Discussion :

[Nothus]

Chers membres du club,

J'ai le plaisir de vous présenter ce tutoriel  :

Python 3.5 : enfin comprendre le fonctionnement d'un code asynchrone

Ce tutoriel, livré pour Python 3.5, va parcourir en apprentissage le mécanisme sous-jacent de l’asynchronisme tel que cette méthode de programmation s’est elle-même construite. Ne vous étonnez donc pas de ne pas retrouver immédiatement des termes que vous auriez vus par ailleurs (asyncio, away, etc).

Avant de le démarrer, vérifiez que vous disposez des connaissances de base du développement*: cet article tentera d’être le plus accessible possible.

Bonne lecture

Retrouvez les meilleurs cours et tutoriels pour apprendre Python.

[iliak]

Salut,

N'y aurait-il pas des typos sur le mot clef await ? A plusieurs reprises, le mot away est utilisé à la place (dans le préambule, II/A, IV/B)...

[Nothus]

Bonjour Iliak,

Merci de ta remarque... (malheureusement) tout à fait justifiée. Une grande honte, lors de la dernière relecture en rédaction, j'ai accepté les propositions du correcteur auto un peu vite ! Le code, provenant d'ailleurs, n'a pas été modifié d'où le persistance des autres occurrences du terme.

L'article va être modifié au plus vite.

N'hésitez pas à nous signaler d'autres coquilles s'il devait y en avoir.

Bien à toi,

Julien.

[Malick]

Bonjour,

N'y aurait-il pas des typos sur le mot clef await ? A plusieurs reprises, le mot away est utilisé à la place (dans le préambule, II/A, IV/B)...

C'est corrigé. Merci

[valkar]

Bonjour Nothus,

Je mets une mauvaise note à ton tutoriel car je ne suis pas arrivé à aller jusqu'au bout ! Les parties I, II (E exclue) et IV sont bien expliquées et elles sont synthétiques.

En revanche, j'ai réussi à comprendre le II.E qu'en fournissant de grands efforts en recherchant des informations supplémentaires sur le web anglo'... Si j'étais toi, j'utiliserais plus de termes génériques employés par la profession. Par exemple, il faudrait définir clairement les fonctions de type générateur, coroutine et bogue. Dans ton dernier exemple de II.E, tu utilises un bogue puisqu'il peut recevoir et envoyer des données ("je démarre"/"je continue"): il faudrait le spécifier/formaliser, je pense que ça rajouterait de la clarté à ton tutoriel.

En revanche, j'ai pas compris le fonctionnement de ton premier programme de la partie III : quel est le principe de fonctionnement d'un gestionnaire de tâches ? Comment on le définit ? Par conséquent, je ne suis pas allé plus loin dans cette partie.

Il y a 3 possibilités à mon incompréhension : soit je suis trop con, soit je manque de base et dans ce cas là, dans ton tutoriel, il devrait être inclu des liens vers d'autres tutoriels ou au moins définir les prérequis pour l'entamer soit les parties de ton tutoriel sont pas assez expliquées (notamment la partie III).

La conséquence, c'est que je vais m'appuyer sur d'autres ressources (notamment du web anglo) pour essayer de comprendre les rouages de la programmation asynchrone.

[Nothus]

Bonsoir Valkar,

Désolé que tu n'aies pas trouvé ton bonheur avec ce tutoriel. Ça arrive, et comme tu l'indiques, d'autres ressources existent. Il est bon quoiqu'il arrive, d'être le plus large possible dans sa recherche.

Pour la partie III, merci de ton retour. Comme je l'explique dans l'article, c'est un moment délicat à appréhender pour passer d'un fonctionnement purement séquentielle "prédictible" à un enchaînement qui l'est moins (avec la notion de tâches à ordonner). A ce jour tu es le seul à avoir remonter un problème d'approche sur ce point (pas les autres donc ?), mais compte tenu de la version datée de Python utilisée et d'un manque de temps à y consacrer, je ne modifierais pas le tutoriel.

Par contre rien ne t'empêche de faire une publication avec une version moderne sur ce que tu as trouvé et comment il serait le mieux pour expliquer ces concepts. J'ai appris le développement seul : c'est appréciable d'avoir des approches différentes. Écris la tienne, c'est bon pour toute la communauté.

Bonne soirée.

[YCL-1]

Bonjour,

tout d'abord merci pour le temps passé à l'écriture de ce tutoriel, j'en suis qu'au début mais il est bien détaillé pour comprendre les bases des générateurs/itérateurs avant de s'attaquer à l'asynchrone.

Il y a une erreur dans le dernier code du chapitre II-C, il doit manquer des opérateurs * :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def MaFonction(valeur):
    i = 2 
    valeur = int(valeur) 
    i  = valeur
    yield
    i  = (valeur valeur)
    return i 
 
try:
    generateur = MaFonction(3) 
    while True:
        next(generateur)
except StopIteration as retour:
    print(retour.value) # soit (2 x 3) x (3 x 3) ou 54

La correction qui permet d'obtenir 54 en conservant le même calcul :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def MaFonction(valeur):
    i = 2 
    valeur = int(valeur) 
    i *= valeur
    yield
    i *= (valeur * valeur)
    return i 
 
try:
    generateur = MaFonction(3) 
    while True:
        next(generateur)
except StopIteration as retour:
    print(retour.value) # soit (2 x 3) x (3 x 3) ou 54

Je poursuis la lecture,

Merci.

[Carl_Smith]

L'asynchronsime c'est compliqué. Faire un tutoriel la dessus est une tache bien difficile.

Je diviserai le tutoriel en deux parties.

1. Expliquer ce qu'est un itérable - itérateur (générateur)

Il y a des objets qui ont la méthode "__iter__"....donc on les appelle des itérables.

Quand sur ces objets, on appelle la méthode "__iter__"....cela revoie un autre objet qu'on appelle "itérateur" ou "générateur"..qui a la méthode "__next__"

A chaque fois qu'on appelle next, python se souvient "au combientième" next on est rendu et exécute le code correspondant.

Mon avis : Si vous voulez des explications de ce type, il y a plein d'autres sources (même francophones) bien plus claires

2. Utiliser ce qui est expliqué en partie 1 pour faire du code asynchrone

L'auteur prend comme exemple de programme "une décrémentation de 10000 à 0". Ca prend quelques secondes.

Donc l'objectif est de lancer 10 décrémentations "en simultané".

...et pour cela l'auteur propose de faire ainsi :
- routine de décrémentation n°1 (premier passage) = on fait juste un -1 (donc on est rendu à 9999)
- routine de décrémentation n°2 (premier passage) = on fait juste un -1 (donc on est rendu à 9999)
- routine de décrémentation n°3 (premier passage) = on fait juste un -1 (donc on est rendu à 9999)
.....
- routine de décrémentation n°9 (premier passage) = on fait juste un -1 (donc on est rendu à 9999)
- routine de décrémentation n°1 (deuxième passage) = on fait encore juste un -1 (donc on est rendu à 9998)
- routine de décrémentation n°2 (deuxième passage) = on fait encore juste un -1 (donc on est rendu à 9998)
.....jusqu'à être rendu à 0 dans toutes les routine.

Donc avec des générateur, l'auteur a fait quelques chose qu'on savait déja :
Un processeur ne fait qu'une chose à la fois.
Si on veut faire tourner les routines A et B en même temps, et bien on va donner l'illusion du "en même temps" en faisant "un peu de A", "puis un peu de B", "puis de nouveau un peu de A", ......

3. Ma Conclusion

Pour la partie une, à vous devoir, si vous trouvez ce tutoriel bien pour comprendre les itérables, itérateurs et générateurs (pour moi c'est non)
Pour la partie 2, sachez que vous n'apprendrez pas à faire de l'asynchrone en python....vous aurez une démonstration (scolaire) que pour donner une impression de simultanéité, il faut faire une petit bout de A, puis un petit bout de B, puis un petite bout de A encore...

Dans la majorité des cas, le programmeur ne sait pas (sans creuser dans les libs) découper sa tache en plein de petites sous taches.....si il le pouvait il n'aurait même pas recherché "programmation asynchrone"...il aurait lui même géré son découpage.

Bref un peu déçu car j'ai vraiment perdu du temps à essayer de comprendre ce tutoriel.