Comment réécrire cette boucle simple à l'aide d'expressions d'affectation introduites dans Python 3.8 alpha?

Je suggérerais une boucle do-while, mais elle n'est pas prise en charge en Python. Cependant, vous pouvez émuler un moment en agissant comme un do-while. De cette manière, vous pouvez utiliser l'expression d'affectation

a=0
while True:
    print(a)
    if not((a:=a+1)<10):
        break

Le problème avec la question est que toute l'approche du problème semble venir d'un programmeur essayant d'utiliser Python comme d'autres langages.

Un programmeur Python expérimenté n'utiliserait pas une boucle while dans ce cas. Ils feraient soit ceci à la place:

for a in range(10):
    print (a)

... soit encore plus simple:

from itertools import takewhile, count

for a in takewhile(lambda x: x<10, count()):
    print (a)

Comme c'est souvent le cas cas (pas toujours bien sûr), le code laid présenté dans la question est un symptôme de l'utilisation du langage d'une manière moins qu'optimale.

Les boucles simples comme votre exemple ne doivent pas utiliser d'expressions d'attribution . Le PEP a un Recommandations du guide de style section à laquelle vous devez tenir compte:

1. Si des instructions d'affectation ou des expressions d'affectation peuvent être utilisées, préférez les instructions; il s'agit d'une déclaration d'intention claire.
2. Si l'utilisation d'expressions d'affectation entraîne une ambiguïté sur l'ordre d'exécution, restructurez-la pour utiliser des instructions à la place.

Les boucles simples doivent être implémentées en utilisant des itérables et pour , elles sont beaucoup plus clairement destinées à boucler jusqu'à ce que l'itérateur soit terminé. Pour votre exemple, l'itérable de choix serait range():

if any((found := ob).some_test(arg) for ob in iterable):
    # do something with 'found'

qui est beaucoup plus propre, concis et lisible em > que, dites

found = next((ob for ob in iterable if ob.some_test(arg)), None)
if found is not None:
    # do something with 'found'

Ce qui précède nécessite un examen plus approfondi pour déterminer que dans la boucle a commencera à 0 , pas à -1.

L'essentiel est que vous ne devriez pas être tenté de «trouver des moyens d'utiliser les instructions d'assignation». N'utilisez une instruction d'affectation que si elle simplifie le code, pas plus complexe. Il n'y a pas de bon moyen de rendre votre boucle while plus simple qu'une boucle for ici.

Vos tentatives de réécriture d'une boucle simple sont également reprises dans le Les conclusions de Tim Peters em> appendix , qui cite Tim Peters au sujet des expressions de style et d'affectation. Tim Peters est l'auteur du Zen of Python (parmi de nombreuses autres contributions à Python et au génie logiciel dans son ensemble), donc ses mots devraient avoir un poids supplémentaire:

Dans d'autres cas, la combinaison de la logique associée rendait la compréhension plus difficile, comme la réécriture:

if reductor := dispatch_table.get(cls):
    rv = reductor(x)
elif reductor := getattr(x, "__reduce_ex__", None):
    rv = reductor(4)
elif reductor := getattr(x, "__reduce__", None):
    rv = reductor()
else:
    raise Error("un(shallow)copyable object of type %s" % cls)

comme le plus bref:

reductor = dispatch_table.get(cls)
if reductor:
    rv = reductor(x)
else:
    reductor = getattr(x, "__reduce_ex__", None)
    if reductor:
        rv = reductor(4)
    else:
        reductor = getattr(x, "__reduce__", None)
        if reductor:
            rv = reductor()
        else:
            raise Error("un(shallow)copyable object of type %s" % cls)

Le test while y est trop subtil, reposant essentiellement sur une évaluation stricte de gauche à droite dans un contexte de non-court-circuit ou de chaînage de méthodes. Mon cerveau n'est pas câblé de cette façon.

Je m’insiste en gras.

Le modèle assigment-then-test est un bien meilleur cas d’utilisation des expressions d’affectation, en particulier lorsque plusieurs tests doivent être effectués. lieu qui essaie des objets successifs. L'essai de Tim cite un exemple donné par Kirill Balunov, de la bibliothèque standard, qui bénéficie en fait de la nouvelle syntaxe. La fonction copy.copy () a > doit trouver une méthode de hook appropriée pour créer une copie d'un objet personnalisé:

while total != (total := total + term):
    term *= mx2 / (i*(i+1))
    i += 2
return total

L'indentation ici est le résultat d'instructions if imbriquées car Python ne nous donne pas une syntaxe plus agréable pour tester différentes options jusqu'à ce qu'il en trouve une, et en même temps assigne l'option sélectionnée à une variable (vous ne pouvez pas utiliser proprement une boucle ici car tous les tests ne concernent pas les noms d'attributs).

Mais un expression d'affectation vous permet d'utiliser une structure plate if / elif / else :

while True:
    old = total
    total += term
    if old == total:
        return total
    term *= mx2 / (i*(i+1))
    i += 2

Ces 8 lignes sont beaucoup plus propres et plus facile à suivre (dans mon esprit) que le 13.

Un autre bon cas d'utilisation souvent cité est le s'il y a un objet correspondant après le filtrage, faites quelque chose avec cet objet em>, wh ich nécessite actuellement une fonction next () avec une expression de générateur, une valeur de repli par défaut et un test if :

a = -1
while (a := a + 1) < 10:
    # ...

que vous pouvez nettoyer beaucoup avec le any () function

for a in range(10):
    # ...