Categories
Programming

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. D’où l’importance 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.