Discussion :

[catzy]

Bonjoouur !

Ça fait depuis ce midi que j'essaie de comprendre comment marche l'asynchrone en python, et je comprends RIEN.
Donc tout simplement, est-ce que qqn peut juste me montrer un code pour exécuter les fonctions a() et b() en même temps ici, svp ? (Jsp si faut les définir async ou pas) C tout ce que je veux faire :3

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
import time
 
def a():
    time.sleep(3)
    print("a() terminé")
 
def b():
    time.sleep(5)
    print("b() terminé")

Donc ça devrais faire :
(Après 3 secondes)
a() terminé
(Après 2 secondes)
b() terminé

Merci d'avance ! ^^'

[Croobyraal]

Bonjour,

Je connais deux modules dans la bibliothèque standart permettant de gérer l’exécution asynchrone: multiprocessing et threading.
La différence fondamentale entre les deux est que le module threading ne gère que le monocœur tendis que multiprocessing permet de paralléliser l'exécution sur plusieurs cœurs.

Un thread est un ensemble d'instruction qui s’exécutera comme une tache autonome sur un coeur donné. En python la classe permettant d'y accéder est Thread.

On peut créer on thread de la manière suivante :
thread = Thread(nom_de_la_fonction, args=(argument1, arguments2..))

On execute avec start()
on attend la fin de l’exécution avec join()

Une seconde solution est d’hériter de la classe Thread et de surcharger la méthode run() qui sera appelée par start()

L' équivalent multiprocessing du Thread et le Process il peut être appelé de la même manière.

Les modules sont très complets et la documentation est de bonne qualité si tu souhaites approfondir.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
from threading import Thread
from multiprocessing import Pool
 
 
import time
 
 
def a(time_to_sleep,message):
    """
 
    :param time_to_sleep: (Double) the time in sec
    :param message: (String) the message to return
    """
    t1 = time.time()
    time.sleep(time_to_sleep)
    print(message, time.time()-t1)
 
 
 
 
class MonThread(Thread):
    def __init__(self, time_to_sleep, message):
        super(MonThread, self).__init__()
        self.time_to_sleep = time_to_sleep
        self.message = message
 
    def run(self):
 
        t1 = time.time()
 
        time.sleep(self.time_to_sleep)
        print(self.message, time.time() - t1)
 
 
if __name__ == '__main__':
    thread1=Thread(target=a,args=(3, "thread1 termine"))
    thread2=Thread(target=a,args=( 6, "thread2 termine"))
 
    thread1.start()
    thread2.start()
    print("le thread principal continue")
 
    thread1.join()
    print('j attend la fin du thread 1')
    thread2.join()
    print('j attend a fin du thread 2')
 
    print("par classe")
 
    thread1= MonThread(2, "thead3")
    thread2 = MonThread(4, "thread4")
    thread2.start()
    thread1.start()
    thread2.join()
    thread1.join()
    print("fin")
    print("multiprocess")
 
 
   # La fonction Pool est une méthode simple pour faire plusieurs fois la même fonction avec des arguments différents
    with Pool(2)as p:
        p.starmap(a, [(1, "01"), (2, '02')])

[wiztricks]

Salut,

Ça fait depuis ce midi que j'essaie de comprendre comment marche l'asynchrone en python, et je comprends RIEN.
Donc tout simplement, est-ce que qqn peut juste me montrer un code pour exécuter les fonctions a() et b() en même temps ici, svp ?

Pour exécuter deux fonctions basiques "en même temps", vous n'avez pas d'autre solution que d'utiliser un multitâche pré-emptif via les bibliothèques threading ou multiprocessing ou concurrent.futures.

async/await permettent de réaliser un multitâche coopératif.... Et le "coopératif" signifie qu'on a un seul thread que chaque tache occupe le moins longtemps possible pour permettre aux autres taches d'avancer.
Ce genre de multitâche là est aussi celui que vous retrouvez dans les bibliothèques graphiques comme tkinter, Qt, ...où vous apprenez assez vite que time.sleep dans un callback fout la grouille.
Et si on veut faire un code qui y ressemble, il va falloir ajouter pas mal de changements:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import asyncio
import time
 
async def block(seconds):
    start = time.time()
    await asyncio.sleep(seconds)
    elapsed = time.time() - start
    print('blocked since', elapsed)
 
async def main():
    t1 = asyncio.create_task(block(1))
    t2 = asyncio.create_task(block(2))
    start = time.time()
    z = await asyncio.gather(t1, t2)
    print('elapsed: ', time.time() - start)
    return z
 
asyncio.run(main())

- W

[catzy]

Merci pour vos réponses ! Je met en [résolu]