Phenquestions
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 d'autres langages de programmation (ce 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. Voici un exemple simple de boucle for en Python :
pour x dans la plage (10) :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 = [x pour x dans la plage (10)]imprimer (chiffres)
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 = []pour x dans la plage (10) :
Nombres.ajouter (x)
imprimer (chiffres)
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 accolades, vous devrez maintenant utiliser des accolades. Vous obtiendrez également un nouveau dictionnaire / objet set au lieu d'une nouvelle liste.
data = "city": "new york", "name": "john doe"données_formatées = k:v.title() pour k,v dans les données.éléments()
imprimer (formated_data)
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.
data = "city": "new york", "name": "john doe"données = k:v.title() pour k,v dans les données.éléments()
imprimer (données)
Sans utiliser les compréhensions de dictionnaire, le code ressemblerait à ceci :
data = "city": "new york", "name": "john doe"données_formatées =
pour k, v dans les données.éléments():
données_formatées[k] = v.Titre()
imprimer (formated_data)
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 liste de compréhension
L'exemple de compréhension de liste mentionné ci-dessus est basique et utilise une seule instruction « pour ». Vous trouverez ci-dessous un exemple qui utilise plusieurs boucles for et une instruction "if" conditionnelle.
adjectifs = ["Disco", "Eoan", "Focal", "Artful"]animaux = ["Dingo", "Hermine", "Fossa", "Castor"]
noms de code = [x + " " + y pour x dans les adjectifs pour y chez les animaux si y.commence par(x[0])]
imprimer (noms de code)
Le code affichera ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] comme sortie. Les deux boucles for parcourent les listes « adjectifs » et « 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 = ["Disco", "Eoan", "Focal", "Artful"]animaux = ["Dingo", "Hermine", "Fossa", "Castor"]
noms de code = []
pour x dans les adjectifs :
pour y chez les animaux :
si tu.commence par(x[0]):
noms de code.ajouter(x + " " + y)
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]autre_liste = [5, 6, 7, 8]
result = [True if (x + y) % 2 == 0 else False for x in number_list for y in another_list]
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]autre_liste = [5, 6, 7, 8]
résultat = []
pour x dans number_list :
pour y dans une 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 généralement c'est une bonne idée d'écrire du code explicite, lisible et facile à déboguer au lieu d'utiliser excessivement des raccourcis.
