passer la liste des chaînes à map_async()

Question

Je rencontre un drôle de problème avec map_async que je n'arrive pas à comprendre. J'utilise la bibliothèque multiprocessing de python avec des pools de processus. Je suis en train de passer une liste de chaînes à comparer contre et une liste de chaînes à comparer à une fonction à l'aide map_async()

en ce moment j'ai:

from multiprocessing import Pool, cpu_count 
import functools 

dictionary = /a/file/on/my/disk 
passin = /another/file/on/my/disk 

num_proc = cpu_count() 

dictionary = readFiletoList(fdict) 
dictionary = sortByLength(dictionary) 

words = readFiletoList(passin, 'WINDOWS-1252') 
words = sortByLength(words) 

result = pool.map_async(functools.partial(mpmine, dictionary=dictionary), [words], 1000) 

def readFiletoList(fname, fencode='utf-8'): 
    linelist = list() 
    with open(fname, encoding=fencode) as f: 
    for line in f: 
     linelist.append(line.strip()) 
    return linelist 


def sortByLength(words): 
    '''Takes an ordered iterable and sorts it based on word length''' 
    return sorted(words, key=len) 

def mpmine(word, dictionary): 
    '''Takes a tuple of length 2 with it's arguments. 

    At least dictionary needs to be sorted by word length. If not, whacky results ensue. 
    ''' 
    results = dict() 
    for pw in word: 
    pwlen = len(pw) 
    pwres = list() 
    for word in dictionary: 
     if len(word) > pwlen: 
     break 
     if word in pw: 
     pwres.append(word) 
    if len(pwres) > 0: 
     results[pw] = pwres 
    return results 



if __name__ == '__main__': 
    main() 

deux dictionnaire et les mots sont des listes de chaînes. Cela entraîne l'utilisation d'un seul processus au lieu du montant que j'ai défini. Si je supprime les crochets de la variable 'mots', il semble que les caractères de chaque chaîne se répètent et provoquent un désordre. Ce que je voudrais avoir, c'est prendre comme des milliers de chaînes de mots et les passer dans le processus de travail, puis obtenir les résultats, parce que c'est une tâche ridiculement parallélisable.

EDIT: Ajout de plus de code pour rendre ce qui se passe plus clair.

Answer 1

Ok, en fait, j'ai pensé moi-même. Je vais seulement poster la réponse ici pour quelqu'un d'autre qui pourrait venir et avoir le même problème. La raison pour laquelle j'éprouvais des problèmes était que map_async prenait un élément de la liste (dans ce cas, une chaîne de caractères) et l'introduisait dans la fonction, qui attendait une liste de chaînes. alors il traitait chaque chaîne comme une liste de caractères. le code corrigé pour mpmine est:

def mpmine(word, dictionary): 
    '''Takes a tuple of length 2 with it's arguments. 

    At least dictionary needs to be sorted by word length. If not, whacky results ensue. 
    ''' 
    results = dict() 
    pw = word 
    pwlen = len(pw) 
    pwres = list() 
    for word in dictionary: 
    if len(word) > pwlen: 
     break 
    if word in pw: 
     pwres.append(word) 
    if len(pwres) > 0: 
    results[pw] = pwres 
    return results 

J'espère que cela aide quelqu'un d'autre confronté à un problème similaire.