Python Academy · Leçon

Les bases de multiprocessing

Utiliser plusieurs cœurs de CPU

Les bases de multiprocessing est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Pourquoi utiliser plusieurs processus

Le GIL empêche les threads d'exécuter du bytecode Python en parallèle. Le module multiprocessing contourne cette limitation en lançant des processus distincts, chacun possédant son propre interpréteur et son propre GIL. Le travail limité par le CPU s'exécute ainsi réellement sur plusieurs cœurs.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Démarrer un Process

Process(target=func) reprend l'API du threading. Appelez start() pour le lancer et join() pour attendre.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

La protection main

Sur certaines plateformes, les processus enfants importent votre script. Sans protection if __name__ == '__main__':, vous pouvez créer des processus de manière récursive. Placez toujours le code de lancement à l'intérieur de cette protection.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Transmettre des arguments

Utilisez args pour les arguments positionnels et kwargs pour les arguments nommés, comme avec les threads. Les arguments sont sérialisés et transmis au processus enfant.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

Un Pool de worker

multiprocessing.Pool gère un groupe de processus. pool.map répartit un itérable entre eux et rassemble les résultats dans l'ordre.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

L'API concurrent.futures propose également ProcessPoolExecutor, avec la même interface submit/map que celle présentée pour les threads.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Espaces mémoire distincts

Chaque processus possède sa propre mémoire. Modifier une variable globale dans un processus enfant ne modifie pas la copie du processus parent. Les données doivent être renvoyées ou partagées explicitement.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Récupérer les résultats

Comme la mémoire n'est pas partagée, renvoyez les résultats via Pool.map, des exécuteurs ou des files d'attente, plutôt que de modifier des variables globales.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async pour les appels uniques

apply_async planifie un appel et renvoie une référence de résultat. Appelez .get() pour récupérer la valeur.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Exigence de sérialisation

Les cibles et les arguments doivent être sérialisables afin de franchir la frontière entre les processus. Les fonctions de niveau supérieur fonctionnent ; les fonctions lambda et les fonctions locales, en général, ne fonctionnent pas.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

Quand choisir les processus

Utilisez les processus pour les tâches limitées par le CPU : calculs mathématiques, traitement d'images et analyse syntaxique. Le coût de leur lancement et de leur sérialisation signifie qu'ils conviennent mieux à un petit nombre de tâches lourdes qu'à de nombreuses tâches minuscules.

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Vérification rapide

Vérifiez votre compréhension du traitement multiprocessus.

Récapitulatif

Vous avez appris les bases du traitement multiprocessus :

Les processus contournent le GIL pour fournir un véritable parallélisme du CPU.
Utilisez la protection if __name__ == '__main__'.
Pool et ProcessPoolExecutor répartissent le travail et rassemblent les résultats.
La mémoire n'est pas partagée ; les arguments doivent être sérialisables.

Ensuite : partager des données en toute sécurité avec des files d'attente et des verrous.

Questions Fréquemment Posées

La leçon « Les bases de multiprocessing » est-elle gratuite ?

Oui — le texte complet de « Les bases de multiprocessing » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les bases de multiprocessing » ?

Utiliser plusieurs cœurs de CPU Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Les bases de multiprocessing » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy