Le multiprocessing en Python est un outil puissant qui peut accélérer considérablement l'exécution de programmes Python nécessitant une forte puissance de calcul. Dans ce laboratoire, vous allez découvrir le multiprocessing en Python et apprendre à l'utiliser pour exécuter des processus en parallèle. Nous commencerons par des exemples simples et irons progressivement vers des exemples plus complexes.
La première étape pour découvrir le multiprocessing en Python est de créer un programme simple qui montre comment il fonctionne. Dans ce programme, nous allons créer une fonction qui prend un seul argument et renvoie le carré de ce nombre. Nous utiliserons ensuite le multiprocessing pour exécuter cette fonction sur plusieurs processus.
Veuillez compléter square.py.
import multiprocessing
def square(x):
return x * x
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=4)
results = pool.map(square, range(10))
print(results)Ce code crée un pool de quatre processus et utilise la fonction map() pour appliquer la fonction square() à chacun des nombres compris dans la plage de 0 à 9. Les résultats sont ensuite affichés dans la console.
Maintenant que vous comprenez comment le multiprocessing fonctionne en Python, nous pouvons passer à un exemple plus complexe. Dans cet exemple, nous utiliserons le multiprocessing pour accélérer le traitement d'une longue liste de nombres.
Veuillez compléter complex_square.py.
import multiprocessing
def square(x):
return x * x
if __name__ == '__main__':
with multiprocessing.Pool(processes=4) as pool:
results = pool.map(square, range(1000000))
print(results[:10])Ce code crée un pool de quatre processus et utilise la fonction map() pour appliquer la fonction square() à chacun des nombres compris dans la plage de 0 à 999999. L'instruction with est utilisée pour s'assurer que le pool de processus est correctement fermé une fois le traitement terminé. Les dix premiers résultats sont ensuite affichés dans la console.
Dans certains cas, vous devrez peut-être communiquer entre des processus lors de l'utilisation du multiprocessing en Python. Dans cet exemple, nous utiliserons la fonction multiprocessing.Queue() pour créer une file partagée entre les processus.
Veuillez compléter multiprocessing_queue.py.
import multiprocessing
def producer(queue):
for i in range(10):
queue.put(i)
def consumer(queue):
while True:
item = queue.get()
if item is None:
break
print(item)
if __name__ == '__main__':
queue = multiprocessing.Queue()
process_producer = multiprocessing.Process(target=producer, args=(queue,))
process_consumer = multiprocessing.Process(target=consumer, args=(queue,))
process_producer.start()
process_consumer.start()
process_producer.join()
queue.put(None)
process_consumer.join()Ce code crée une file partagée queue à l'aide de la fonction multiprocessing.Queue(). Nous créons ensuite deux processus qui appellent chacun une fonction producer() et consumer(). La fonction producer() place les nombres de 0 à 9 dans la file, tandis que la fonction consumer() récupère chaque élément de la file et l'affiche dans la console.
En plus de map(), la classe multiprocessing.Pool() fournit une autre méthode pour exécuter des processus en parallèle appelée apply_async(). Cette méthode vous permet de soumettre un appel de fonction à un pool de processus et de continuer immédiatement l'exécution sans attendre le résultat. Au lieu de cela, vous pouvez utiliser une fonction de rappel pour récupérer le résultat de l'appel de fonction lorsque celui-ci est prêt.
Veuillez compléter slow_square.py.
import multiprocessing
import time
def slow_square(x):
time.sleep(1)
return x * x
def callback(result):
print(result)
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=4)
results = [pool.apply_async(slow_square, (x,), callback=callback) for x in range(10)]
for result in results:
result.wait()
print("All tasks completed.")Dans cet exemple, nous définissons une fonction slow_square() qui prend un nombre x, attend une seconde, puis renvoie le carré de x. Nous définissons également une fonction de rappel callback() qui imprime simplement le résultat lorsqu'il est disponible.
Nous créons ensuite un pool de quatre processus et utilisons apply_async() pour soumettre un appel de fonction au pool pour chaque nombre compris dans la plage de 0 à 9. Nous passons la fonction slow_square() et l'argument x à l'aide du paramètre args, et spécifions également la fonction de rappel à appeler lorsque le résultat est prêt.
Nous parcourons ensuite la liste des résultats et appelons result.wait() pour bloquer le fil principal jusqu'à ce que le résultat soit prêt. Enfin, nous imprimons un message pour indiquer que toutes les tâches sont terminées.
Dans ce laboratoire, vous avez appris à utiliser le multiprocessing Python pour exécuter des processus en parallèle. Vous avez commencé par un programme simple qui montrait comment le multiprocessing fonctionne, puis vous êtes passé à des exemples plus complexes qui utilisaient le multiprocessing pour accélérer le traitement, partager la mémoire entre les processus et effectuer des tâches asynchrones à l'aide de apply_async(). À la fin de ce laboratoire, vous devriez avoir une bonne compréhension de la manière d'utiliser le multiprocessing dans vos propres programmes Python pour obtenir une puissance de traitement et une efficacité plus grandes, et pour communiquer entre les processus si nécessaire.
