Python, en utilisant des serveurs multi-processus est plus lent que ne l'utilisez pas

ETA: Maintenant que vous avez posté votre code, je peux vous dire qu'il y est un moyen simple de faire ce que vous êtes en train de faire BEAUCOUP plus rapidement (>100 fois plus rapide).

Je vois que ce que vous faites est l'ajout d'une fréquence entre parenthèses pour chaque élément dans une liste de chaînes de caractères. Au lieu de compter tous les éléments à chaque fois (ce qui, comme vous pouvez le confirmer à l'aide de cProfile, est de loin le plus important goulot d'étranglement dans votre code), vous pouvez simplement créer un dictionnaire que les cartes de chaque élément à sa fréquence. De cette façon, vous n'avez qu'à aller dans la liste deux fois - une fois pour créer la fréquence dictionnaire, une fois de l'utiliser pour ajouter de la fréquence.

Ici, je vais vous montrer ma nouvelle méthode, le temps, et de le comparer à l'ancienne méthode, à l'aide d'un cas de test générée. Le cas de test montre même le nouveau résultat à exactement identique à l'ancien. Remarque: Tous vous avez vraiment besoin de faire attention à ci-dessous est la 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()

Lorsque je l'exécute, il devient temps de (15.963812112808228, 0.05961179733276367), c'est environ 250 fois plus rapide, bien que cet avantage dépend de combien de temps les listes et la distribution de fréquence à l'intérieur de chaque liste. Je suis sûr que vous serez d'accord que, avec cet avantage de vitesse, vous n'aurez probablement pas besoin d'utiliser le multitraitement 🙂

(Ma réponse originale à cette question est de gauche ci-dessous pour la postérité)

ETA: Par ailleurs, il est intéressant de noter que cet algorithme est à peu près linéaire en la longueur de la liste, tandis que le code utilisé est quadratique. Cela signifie qu'il effectue avec encore plus de l'avantage le plus grand nombre d'éléments. Par exemple, si vous augmentez la longueur de chaque liste à 1000000, il ne prend que 5 secondes pour s'exécuter. Basée sur l'extrapolation, l'ancien code fallu attendre plus d'une journée 🙂

Il dépend de l'opération que vous effectuez. Par exemple:

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)

Sur ma machine, le multiprocessed opération prend seulement environ 60% du temps de la single thread.

OriginalL'auteur David Robinson

Multitraitement pourrait être utile pour ce que vous faites, mais pas dans la façon dont vous pensez à l'utiliser. Que vous êtes essentiellement faire quelques calculs sur chaque membre de une liste, vous pouvez le faire en utilisant le multiprocessing.Pool.map méthode, pour faire le calcul sur la liste des membres en parallèle.

Voici un exemple qui montre votre code de la performance à l'aide d'un processus unique et à l'aide de multiprocessing.Pool.map:

from multiprocessing import Pool
from random import choice
from string import printable
from time import time
def build_test_list():
# Builds a test list consisting of 5 sublists of 10000 strings each.
# each string is 20 characters long
testlist = [[], [], [], [], []]
for sublist in testlist:
for _ in xrange(10000):
sublist.append(''.join(choice(printable) for _ in xrange(20)))
return testlist
def process_list(l):
# the time-consuming code
result = []
tmp = []
for n in range(len(l)):
if l[n] not in tmp:
result.insert(n, l[n]+' ('+str(l.count(l[n]))+')')
tmp.insert(0, l[n])
return result
def single(l):
# process the test list elements using a single process
results = []
for sublist in l:
results.append(process_list(sublist))
return results
def multi(l):
# process the test list elements in parallel
pool = Pool()
results = pool.map(process_list, l)
return results
print "Building the test list..."
testlist = build_test_list()
print "Processing the test list using a single process..."
starttime = time()
singleresults = single(testlist)
singletime = time() - starttime
print "Processing the test list using multiple processes..."
starttime = time()
multiresults = multi(testlist)
multitime = time() - starttime
# make sure they both return the same thing
assert singleresults == multiresults
print "Single process: {0:.2f}sec".format(singletime)
print "Multiple processes: {0:.2f}sec".format(multitime)

De sortie:

Building the test list...
Processing the test list using a single process...
Processing the test list using multiple processes...
Single process: 34.73sec
Multiple processes: 24.97sec

OriginalL'auteur mdeous