Boucle For en Python
Une instruction de boucle for en Python itère séquentiellement sur les membres de tout objet, liste, chaîne, etc. Par rapport à d'autres langages de programmation, sa syntaxe est beaucoup plus claire et ne nécessite pas de définir manuellement les étapes d'itération et de démarrer l'itération. Bien qu'il existe des moyens de rendre son comportement identique à celui des autres langages de programmation (cela ne sera pas couvert dans cet article). Vous pouvez également exercer un certain contrôle sur les boucles for en utilisant des instructions telles que continue, break, pass, etc. Vous trouverez ci-dessous un exemple simple de boucle for en Python :
pourXdans gamme(dix):
imprimer(X)
La boucle for ci-dessus imprimera dix nombres commençant à 0 et se terminant à 9.
Compréhensions de liste
La compréhension de liste n'est rien d'autre qu'un moyen abrégé / concis d'écrire des boucles for multilignes dans une instruction d'une seule ligne. L'exemple de compréhension de liste ci-dessous créera une nouvelle liste sous la forme [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] en y incluant toutes les valeurs de x.
Nombres= [XpourXdans gamme(dix)]
imprimer (Nombres)
Notez que la compréhension de liste crée toujours une nouvelle liste et ne modifie pas les itérables d'origine utilisés dans l'expression. Une expression de compréhension de liste typique doit avoir une clause for et peut être suivie d'instructions conditionnelles if et else. Sans utiliser une compréhension de liste, l'exemple ci-dessus s'écrira de la manière suivante :
Nombres= []
pourXdans gamme(dix):
Nombres.ajouter(X)
imprimer (Nombres)
Performances et lisibilité
Les compréhensions de liste sont plus rapides que pour les boucles. Cependant, à moins d'itérer sur des centaines de milliers d'éléments, vous ne remarquerez pas d'améliorations majeures des performances. Alors que la compréhension de liste fournit un moyen concis d'écrire des boucles for, des expressions complexes peuvent entraîner une mauvaise lisibilité du code et une verbosité accrue. Il est important de garder le code lisible, à moins que l'obtention de performances maximales ne soit une nécessité absolue pour votre programme.
Exemple : Utilisation de la syntaxe de compréhension de liste avec des dictionnaires et des ensembles
Un dictionnaire python est une collection d'éléments définis dans des paires clé-valeur tandis qu'un ensemble est une collection de valeurs uniques où les doublons ne sont pas autorisés. Les compréhensions de liste peuvent également être utilisées avec les dictionnaires et les ensembles Python. La syntaxe diffère légèrement, au lieu d'envelopper l'expression entre des accolades, vous devrez maintenant utiliser des accolades. Vous obtiendrez également un nouveau dictionnaire / objet set au lieu d'une nouvelle liste.
Les données= {'ville':'New York', 'Nom':'john doe'}
données_formatées= {k : v.Titre() pourà,vdansLes données.éléments()}
imprimer (données_formatées)
L'exemple ci-dessus convertira les valeurs de chaîne en casse de titre et créera un nouveau dictionnaire appelé formatted_data, dont la sortie sera : {'city': 'New York', 'name': 'John Doe'}. Vous pouvez également modifier le dictionnaire / définir sur place en spécifiant la variable de dictionnaire existante sur le côté gauche.
Les données= {'ville':'New York', 'Nom':'john doe'}Les données= {k : v.Titre() pourà,vdansLes données.éléments()}
imprimer (Les données)
Sans utiliser les compréhensions de dictionnaire, le code ressemblerait à ceci :
Les données= {'ville':'New York', 'Nom':'john doe'}données_formatées= {}
pourà,vdansLes données.éléments():
données_formatées[à] =v.Titre()
imprimer (données_formatées)
Comme il n'y a pas de paires clé-valeur dans les ensembles, une compréhension d'ensemble peut être définie de la même manière qu'une compréhension de liste. La seule différence est l'utilisation d'accolades.
Exemple : plusieurs boucles For dans une compréhension de liste
L'exemple de compréhension de liste mentionné ci-dessus est basique et utilise une seule instruction for. Vous trouverez ci-dessous un exemple qui utilise plusieurs boucles for et une instruction conditionnelle if.
adjectifs= ['Disque', 'Eoan', 'Focal', 'Astucieux']animaux= ['Dingo', 'Hermine', 'La fosse', 'Castor']
noms de code= [x +''+ etpourXdansadjectifspouretdansanimauxsiet.commence avec(X[0])]
imprimer (noms de code)
Le code affichera ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] en sortie. Les deux boucles for parcourent les adjectifs et les listes d'animaux et leurs membres sont réunis à l'aide d'un espace, uniquement si la première lettre des deux mots est la même. Sans utiliser les compréhensions de liste, le code ressemblerait à ceci :
adjectifs= ['Disque', 'Eoan', 'Focal', 'Astucieux']animaux= ['Dingo', 'Hermine', 'La fosse', 'Castor']
noms de code= []
pourXdansadjectifs:
pouretdansanimaux:
siet.commence avec(X[0]):
noms de code.ajouter(x +''+ et)
imprimer (noms de code)
Exemple : Compréhension de liste avec clause if-else
L'exemple ci-dessous montrera l'utilisation des instructions if et else dans les compréhensions de liste.
liste_numéros= [1, 2, 3, 4]une autre_liste= [5, 6, 7, 8]
résultat= [Vrai si (x + y)%2 == 0 autre Faux pourXdansliste_numérospouretdansune autre_liste]
imprimer (résultat)
En parcourant deux listes, la compréhension de liste ci-dessus vérifie si la somme de la paire d'éléments est paire ou non. L'exécution du code ci-dessus vous montrera [True, False, True, False, False, True, False, True, True, False, True, False, False, True, False, True] comme sortie. Sans utiliser la compréhension de liste, le code ressemblerait à ceci :
liste_numéros= [1, 2, 3, 4]une autre_liste= [5, 6, 7, 8]
résultat= []
pourXdansliste_numéros :
pouretdansune autre_liste :
si (x + y)%2 == 0:
résultat.ajouter(Vrai)
autre:
résultat.ajouter(Faux)
imprimer (résultat)
Conclusion
Les compréhensions de liste offrent un bon moyen d'écrire des instructions de boucle propres et concises. Cependant, ils peuvent rapidement devenir complexes et difficiles à comprendre si plusieurs boucles et instructions conditionnelles sont utilisées. En fin de compte, il s'agit du niveau de confort d'un programmeur, mais en général, c'est une bonne idée d'écrire du code explicite, lisible et facile à déboguer au lieu d'utiliser excessivement des raccourcis.