PEP 380
Je trouve assez sexy ce qu’il est possible de faire avec le PEP 380.
class BinaryTree(object):
"""
Illustrates PEP 380
(http://python.org/dev/peps/pep-0380)
"""
def __init__(self, left=None, us=None, right=None):
self.left = left
self.us = us
self.right = right
def __iter__(self):
if self.left:
yield from self.left
if self.us:
yield self.us
if self.right:
yield from self.right
left = BinaryTree(us=2)
right = BinaryTree(us=3, right=BinaryTree(us=12))
tree = BinaryTree(left, 5, right)
for i in tree:
print(i)
Avec cette syntaxe il est aussi possible d’utiliser les générateurs avec un comportement de threads (plus léger), comme des coroutines. Prenons l’exemple dans ce PEP:
y = yield from g(x)
où g est un générateur. Le thread peut être lancé dans différentes fonctions
qui produisent ou consomment des éléments (si nous parlons du problème du
producteur/consommateur). Voici un exemple intéressant avec le problème
des philosophes. Ces deux problèmes sont souvent utilisés en cours de
programmation lorsque l’on aborde les threads. Bien que des coroutines sont
suffisantes.
Et pour comparaison voilà l’exemple que j’avais posté il y a quelques temps
avec le langage Go. On utilise ici des goroutines et des channels. J’aime
aussi cette solution, mais il faut bien dire qu’un des objectifs majeur de Go
est d’offrir des solutions modernes pour les problèmes de programmation
asynchrone. Python également, notamment via la syntaxe yield, fournit des
fonctionnalités avancées pour répondre à ces problèmes. Doù limportance de se
tenir à jour et de se remettre en question sur ces compétences.
Le PEP 3156 introduit d’ailleurs le module asyncio (implémentation de
référence) à partir de Python 3.3 et offre un ordonnanceur de plus haut niveau
basé sur yield from (PEP 380). Nous pourrons en parler plus en détail dans un
prochain billet.