Liste des compréhensions dans Python
Pour boucle en python
Une instruction pour Loop dans Python itère séquentiellement sur les membres de n'importe quel objet, liste, chaîne, etc. Par rapport à d'autres langages de programmation, sa syntaxe est beaucoup plus propre et ne nécessite pas de définition manuelle des étapes d'itération et de démarrer l'itération. Bien qu'il existe des moyens de créer son comportement identique à d'autres langages de programmation (ne sera pas couvert dans cet article). Vous pouvez également exercer un certain contrôle pour les boucles en utilisant des instructions comme continuer, casser, passer etc. Vous trouverez ci-dessous un exemple simple de Loop in Python:
pour x dans la gamme (10):Imprimer (x)
La boucle pour ci-dessus imprimera dix numéros à partir de 0 et se terminant à 9.
Liste des compréhensions
La compréhension de la liste n'est rien d'autre qu'une façon raccourci / concise d'écrire plusieurs lignes pour les boucles dans une déclaration en une lignée. L'exemple de compréhension de la liste ci-dessous créera une nouvelle liste comme [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] en incluant toutes les valeurs de «x» dedans.
nombres = [x pour x dans la plage (10)]Imprimer (numéros)
Notez que la compréhension de la liste crée toujours une nouvelle liste et ne modifie pas les itérables originales utilisées dans l'expression. Une expression de compréhension de liste typique doit avoir une clause «pour» et peut être suivie par des déclarations conditionnelles «IF» et «Else». Sans utiliser une compréhension de la liste, l'exemple ci-dessus sera écrit de manière suivante:
nombres = []pour x dans la gamme (10):
Nombres.Ajouter (x)
Imprimer (numéros)
Performance et lisibilité
Les compréhensions de la liste sont plus rapides que pour les boucles. Cependant, à moins que vous ne soyez itéré plus de centaines de milliers d'articles, vous ne remarquerez pas d'améliorations de performances majeures. Bien que la compréhension de la liste offre un moyen concis d'écrire pour les boucles, les expressions complexes peuvent conduire à 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 des compréhensions de la liste avec des dictionnaires et des ensembles
Un dictionnaire Python est une collection d'éléments définis dans les paires de valeurs clés tandis qu'un ensemble est une collection de valeurs uniques où les doublons ne sont pas autorisés. Les compréhensions de la liste peuvent être utilisées avec des dictionnaires et des ensembles Python. La syntaxe diffère légèrement, au lieu de terminer l'expression en accolades carrées, vous devrez maintenant utiliser des accolades bouclées. Vous obtiendrez également un nouvel dictionnaire / objet SET au lieu d'une nouvelle liste.
data = "City": "New York", "Nom": "John Doe"formated_data = k: v.title () pour k, v dans les données.articles()
print (formatted_data)
L'exemple ci-dessus convertira les valeurs de chaîne en cas 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 / set en place en spécifiant la variable de dictionnaire existante sur le côté gauche.
data = "City": "New York", "Nom": "John Doe"data = k: v.title () pour k, v dans les données.articles()
Imprimer (données)
Sans utiliser des compréhensions du dictionnaire, le code ressemblerait à ceci:
data = "City": "New York", "Nom": "John Doe"formated_data =
pour k, v dans les données.articles():
formated_data [k] = v.titre()
print (formatted_data)
Comme il n'y a pas de paires de valeurs clés dans les ensembles, une compréhension des ensembles peut être définie de la même manière qu'une compréhension de la liste. La seule différence est l'utilisation des accolades bouclées.
Exemple: multiple pour les boucles dans une compréhension de la liste
L'exemple de compréhension de la liste mentionné ci-dessus est basique et utilise une seule instruction «pour». Vous trouverez ci-dessous un exemple qui utilise multiple pour les boucles et une instruction «IF» conditionnelle.
adjectifs = ["disco", "eoan", "focal", "art"]animaux = ["dingo", "ermine", "fossa", "castor"]
codenames = [x + "" + y pour x dans les adjectifs pour y chez les animaux si y.startSwith (x [0])]
Imprimer (noms de code)
Le code affichera [«disco dingo», «eoan ermine», «focal fossa»] comme sortie. Les deux pour les boucles passent en revue les listes «adjectifs» et «animaux» et leurs membres sont réunis en utilisant un espace, seulement si la première lettre des deux mots est la même. Sans utiliser les compréhensions de la liste, le code ressemblerait à ceci:
adjectifs = ["disco", "eoan", "focal", "art"]animaux = ["dingo", "ermine", "fossa", "castor"]
codenames = []
pour x dans les adjectifs:
pour y chez les animaux:
Si y.startSwith (x [0]):
noms de code.ajouter (x + "" + y)
Imprimer (noms de code)
Exemple: compréhension de la liste avec la clause IF-Else
L'exemple ci-dessous montrera l'utilisation des déclarations si et else dans les compréhensions de la liste.
numéro_list = [1, 2, 3, 4]un autre_list = [5, 6, 7, 8]
résultat = [true if (x + y)% 2 == 0 else false for x in numéro_list pour y dans un autre_list]
Imprimer (résultat)
Tout en traversant deux listes, la compréhension de la liste ci-dessus vérifie si la somme de la paire d'éléments est même ou non. L'exécution du code ci-dessus vous montrera [vrai, faux, vrai, faux, faux, vrai, faux, vrai, vrai, faux, vrai, faux, faux, vrai, faux, vrai] comme sortie. Sans utiliser la compréhension de la liste, le code ressemblerait à ceci:
numéro_list = [1, 2, 3, 4]un autre_list = [5, 6, 7, 8]
résultat = []
pour x dans numéro_list:
pour y dans un autre_list:
if (x + y)% 2 == 0:
résultat.ajouter (true)
autre:
résultat.Ajouter (false)
Imprimer (résultat)
Conclusion
List Comprehensions offre un bon moyen d'écrire des instructions de boucle propre et concise. Cependant, ils peuvent rapidement devenir complexes et difficiles à comprendre si plusieurs boucles et déclarations 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.