Je n'aurai plus de difficultés. .. Multi-processus utilisant la bibliothèque standard de Python.

Aperçu

Multi-processus, faisons-le facilement. Mais j'étais un peu coincé et je ne pouvais pas gagner de temps après tout. .. ?? ??

C'est impossible. .. .. .. .. Normalement pour la peine. .. .. ..

Je veux qu'une telle personne la lise.

Utilisez ProcessPoolExecutor et functools.partial, qui sont des équipements standard de Python, pour effectuer confortablement des calculs parallèles dans plusieurs processus. Ce que vous pouvez utiliser est une perte si vous ne l'utilisez pas, non? ??

Explication de la situation

`test.py`



def my_function(arg1):
    for i in range(100):
        'C'est un processus très lourd.'
        result_list.append(some_operation(i))

if __name__ == "__main__":
    my_function()

Vous écrivez de cette façon sans penser à rien, non? Dans un tel cas, il y a 100 processus, mais je souhaite effectuer facilement des processus parallèles dans plusieurs processus. .. ..

Moyen facile

Réécrivez un peu la fonction.
Importez ProcessPoolExecutor.
Importez functools.partial et mappez la fonction.

1. Réécrivez un peu la fonction.

Écrivez la précédente `` ma_fonction``` comme ceci.

`test.py`


def my_function(index, arg1):
    return some_operation(index)

En d'autres termes, au lieu d'écrire une boucle, c'est comme passer un index et le traiter un par un.

2. Importez ProcessPoolExecutor.

Tout d'abord, écrivez comme suit.

`test.py`


import os
from concurrent.futures import ProcessPoolExecutor

max_workers = os.cpu_count() or 4
print('=====MAX WORKER========')
print(max_workers)

with ProcessPoolExecutor(max_workers=max_workers) as executor:

max_workersStocke le nombre de processus disponibles. S'il ne peut pas être stocké, dans cet exemple4Est saisi.

3. Importez functools.partial et mappez la fonction.

Ensuite, écrivez comme ça.

`test.py`


import functools

with ProcessPoolExecutor(max_workers=max_workers) as executor:
    result_list = list(executor.map(functools.partial(my_function, arg1), range(100)))
    executor.shutdown(wait=True)

Seulement ça. Pour expliquer un peu, les opérations que j'avais l'habitude d'écrire dans une boucle et d'ajouter à result_list my_funtion```En passant l'index à, l'opération au niveau de chaque index est exécutée dans plusieurs processus.

`functools.partial est une fonction (mon_Changer certains des arguments de la fonction) et renvoyer chaque fonction avec différents arguments en tant qu'itérateur de fonction. En ce moment, mon_function(index, arg1)Comme dans, il n'y a qu'un seul argument qui peut être modifié, et c'est le premier argument de la fonction.Mise en garde!!`



 De plus, selon executable.map, index, qui est la première variable passée à cette `` ma_fonction '', est exécuté en parallèle dans chacune des plages de l'itérateur (100), et chaque résultat d'exécution est stocké dans la liste.
 C'est exactement la même chose que lors de l'ajout de `` result_list '' dans chaque boucle.


## Résumé
 Multi-processus que vous souhaitez faire pour gagner même un peu de temps. C'est douloureux de finir par avoir du mal à écrire des multi-processus et de prendre beaucoup de temps. .. ..
 Cette fois, j'ai introduit un multi-processus que vous pouvez écrire en utilisant uniquement la bibliothèque Python standard assez facilement! !!

 fin.