Python, используя multiprocess медленнее, чем не используя его

ETA: теперь, когда вы опубликовали свой код, я могу сказать вам, что есть простой способ сделать то, что вы делаете намного быстрее (>в 100 раз быстрее).

Я вижу, что вы добавляете частоту в скобках к каждому элементу в списке строк. Вместо подсчета всех элементов каждый раз (что, как вы можете подтвердить с помощью cProfile, является самым большим узким местом в вашем коде), вы можете просто создать словарь это сопоставляет каждый элемент с его частотой. Что таким образом, вам нужно только пройти через список дважды - один раз, чтобы создать частотный словарь, один раз, чтобы использовать его для добавления частоты.

здесь я покажу свой новый метод, время и сравните его со старым методом, используя сгенерированный тестовый случай. Тестовый случай даже показывает, что новый результат будет ровно идентично старому. Примечание: все, что вам действительно нужно обратить внимание ниже, это new_method.

import random
import time
import collections
import cProfile

LIST_LEN = 14000

def timefunc(f):
    t = time.time()
    f()
    return time.time() - t


def random_string(length=3):
    """Return a random string of given length"""
    return "".join([chr(random.randint(65, 90)) for i in range(length)])


class Profiler:
    def __init__(self):
        self.original = [[random_string() for i in range(LIST_LEN)]
                            for j in range(4)]

    def old_method(self):
        self.ListVar = self.original[:]
        for b in range(len(self.ListVar)):
            self.list1 = []
            self.temp = []
            for n in range(len(self.ListVar[b])):
                if not self.ListVar[b][n] in self.temp:
                    self.list1.insert(n, self.ListVar[b][n] + '(' +    str(self.ListVar[b].count(self.ListVar[b][n])) + ')')
                    self.temp.insert(0, self.ListVar[b][n])

            self.ListVar[b] = list(self.list1)
        return self.ListVar

    def new_method(self):
        self.ListVar = self.original[:]
        for i, inner_lst in enumerate(self.ListVar):
            freq_dict = collections.defaultdict(int)
            # create frequency dictionary
            for e in inner_lst:
                freq_dict[e] += 1
            temp = set()
            ret = []
            for e in inner_lst:
                if e not in temp:
                    ret.append(e + '(' + str(freq_dict[e]) + ')')
                    temp.add(e)
            self.ListVar[i] = ret
        return self.ListVar

    def time_and_confirm(self):
        """
        Time the old and new methods, and confirm they return the same value
        """
        time_a = time.time()
        l1 = self.old_method()
        time_b = time.time()
        l2 = self.new_method()
        time_c = time.time()

        # confirm that the two are the same
        assert l1 == l2, "The old and new methods don't return the same value"

        return time_b - time_a, time_c - time_b

p = Profiler()
print p.time_and_confirm()

когда я запускаю это, он получает время (15.963812112808228, 0.05961179733276367), что означает, что это примерно в 250 раз быстрее, хотя это преимущество зависит как от длины списков, так и от частотного распределения в каждом списке. Я уверен, вы согласитесь, что с этим преимуществом скорости вам, вероятно, не нужно будет использовать многопроцессорную обработку :)

(мой первоначальный ответ оставлен ниже для потомков)

ETA: кстати, стоит отметить, что этот алгоритм примерно линейный по длине списков, в то время как код вы использовали квадратичный. Это означает, что он выполняет с еще большим преимуществом, чем больше количество элементов. Например, если увеличить длину каждого списка до 1000000, то для запуска потребуется всего 5 секунд. Основываясь на экстраполяции, старый код займет день:)

Это зависит от операции, которую вы выполняете. Например:

import time
NUM_RANGE = 100000000

from multiprocessing  import Process

def timefunc(f):
    t = time.time()
    f()
    return time.time() - t

def multi():
    class MultiProcess(Process):
        def __init__(self):
            Process.__init__(self)

        def run(self):
            # Alter string + test processing speed
            for i in xrange(NUM_RANGE):
                a = 20 * 20

    thread1 = MultiProcess()
    thread2 = MultiProcess()
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()

def single():
    for i in xrange(NUM_RANGE):
        a = 20 * 20

    for i in xrange(NUM_RANGE):
        a = 20 * 20

print timefunc(multi) / timefunc(single)

на моей машине, операция multiprocessed занимает только ~60% время однопоточная одна.