Python 3.5 : apprendre le fonctionnement d'un code asynchrone, un tutoriel de Julien Garderon

Membre régulier

Le 18/04/2018 à 17:34

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)...

0

0

Nothus

Membre émérite

Le 19/04/2018 à 9:52

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.

0

Malick

Community Manager

Le 19/04/2018 à 11:32

Bonjour,

Envoyé par iliak

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

0

valkar

Candidat au Club

Le 13/10/2020 à 18:43

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.

0

Nothus

Membre émérite

Le 14/10/2020 à 20:23

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.

0

YCL-1

Membre confirmé

Le 30/12/2020 à 11:14

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 * :

[SPOILER]

Code :

Sélectionner tout

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

[/SPOILER]

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

[SPOILER]

Code :

Sélectionner tout

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

[/SPOILER]

Je poursuis la lecture,

Merci.

0

Carl_Smith

Nouveau Candidat au Club

Le 08/04/2022 à 17:11

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.

0

Identifiez-vous

Créer un compte

Python 3.5 : apprendre le fonctionnement d'un code asynchrone

Un tutoriel de Julien Garderon

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

Python 3.5 : apprendre le fonctionnement d'un code asynchrone Un tutoriel de Julien Garderon

Python 3.5 : apprendre le fonctionnement d'un code asynchrone

Un tutoriel de Julien Garderon