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)
На моей машине многопроцессорная операция занимает всего ~ 60% времени однопоточной.