Tutoriel de compréhension de liste Python

Python est célèbre pour vous permettre d'écrire du code élégant, facile à écrire et presque aussi facile à lire que l'anglais simple. L'une des caractéristiques les plus distinctives de la langue est la compréhension de la liste , que vous pouvez utiliser pour créer des fonctionnalités puissantes dans une seule ligne de code. Cependant, de nombreux développeurs ont du mal à tirer pleinement parti des fonctionnalités plus avancées d'une compréhension de liste en Python. Certains programmeurs les utilisent même trop, ce qui peut conduire à un code moins efficace et plus difficile à lire.

À la fin de ce didacticiel, vous comprendrez toute la puissance des compréhensions de liste Python et comment utiliser confortablement leurs fonctionnalités. Vous comprendrez également les compromis qui accompagnent leur utilisation afin de pouvoir déterminer quand d'autres approches sont préférables.

Dans ce didacticiel, vous apprendrez à :

• Réécrire les boucles et |__+_| appelle comme un compréhension de la liste en Python
Choisirentre les compréhensions, les boucles et |__+_| appels
• Boostez vos compréhensions avec logique conditionnelle
Utiliser des compréhensionspour remplacer |__+_| Profilvotre code pour résoudre les questions de performance

Table des matières

• Comment créer des listes en Python
• Utilisation des boucles for
• Utilisation des objets map()
• Utilisation des compréhensions de liste
• Avantages de l'utilisation des compréhensions de liste

Comment créer des listes en Python

Il existe plusieurs façons de créer des listes en Python. Pour mieux comprendre les compromis de l'utilisation d'une compréhension de liste en Python, voyons d'abord comment créer des listes avec ces approches.

Utiliser |__+_| Boucles

Le type de boucle le plus courant est le |__+_| boucle. Vous pouvez utiliser un |_+_| boucle pour créer une liste d'éléments en trois étapes :

1. Instancier une liste vide.
2. Boucle sur un itérable ou une plage d'éléments.
3. Ajoutez chaque élément à la fin de la liste.

Si vous souhaitez créer une liste contenant les dix premiers carrés parfaits, vous pouvez effectuer ces étapes en trois lignes de code :

Ici, vous instanciez une liste vide, |__+_|. Ensuite, vous utilisez un |__+_| boucle pour itérer sur |__+_|. Enfin, vous multipliez chaque nombre par lui-même et ajoutez le résultat à la fin de la liste.

Utiliser |__+_| Objets

|__+_| fournit une approche alternative basée sur la programmation fonctionnelle. Vous passez une fonction et un itérable, et |__+_| va créer un objet. Cet objet contient la sortie que vous obtiendriez en exécutant chaque élément itérable via la fonction fournie.

A titre d'exemple, considérons une situation dans laquelle vous devez calculer le prix après taxes pour une liste de transactions :

Ici, vous avez un itérable |__+_| et une fonction |_+_|. Vous passez ces deux arguments à |__+_| et stockez l'objet résultant dans |__+_|. Vous pouvez facilement convertir cet objet cartographique en une liste en utilisant |__+_|.

Utilisation des compréhensions de liste

Les compréhensions de liste sont une troisième façon de faire des listes. Avec cette approche élégante, vous pourriez réécrire le |__+_| boucle du premier exemple en une seule ligne de code :

Plutôt que de créer une liste vide et d'ajouter chaque élément à la fin, vous définissez simplement la liste et son contenu en même temps en suivant ce format :

Chaque compréhension de liste en Python comprend trois éléments :

|__+_|est le membre lui-même, un appel à une méthode ou toute autre expression valide qui renvoie une valeur. Dans l'exemple ci-dessus, l'expression |__+_| est le carré de la valeur du membre. |__+_|est l'objet ou la valeur dans la liste ou itérable. Dans l'exemple ci-dessus, la valeur du membre est |__+_|. |__+_|est une liste, un ensemble, une séquence, un générateur ou tout autre objet pouvant renvoyer ses éléments un par un. Dans l'exemple ci-dessus, l'itérable est |_+_|.

Parce que le expression L'exigence est si flexible qu'une compréhension de liste en Python fonctionne bien dans de nombreux endroits où vous utiliseriez |_+_|. Vous pouvez réécrire l'exemple de tarification avec sa propre compréhension de liste :

La seule distinction entre cette implémentation et |__+_| est que la compréhension de liste en Python renvoie une liste, pas un objet de carte.

pouvez-vous voir les tweets supprimés

Avantages de l'utilisation des compréhensions de liste

Les compréhensions de liste sont souvent décrites comme étant plus pythoniques que les boucles ou |_+_|. Mais plutôt que d'accepter aveuglément cette évaluation, cela vaut la peine de comprendre les avantages de l'utilisation d'une compréhension de liste en Python par rapport aux alternatives. Plus tard, vous découvrirez quelques scénarios où les alternatives sont un meilleur choix.

L'un des principaux avantages de l'utilisation d'une compréhension de liste en Python est qu'il s'agit d'un outil unique que vous pouvez utiliser dans de nombreuses situations différentes. En plus de la création de liste standard, les compréhensions de liste peuvent également être utilisées pour le mappage et le filtrage. Vous n'êtes pas obligé d'utiliser une approche différente pour chaque scénario.

C'est la principale raison pour laquelle les compréhensions de liste sont considérées Pythonique , car Python comprend des outils simples et puissants que vous pouvez utiliser dans une grande variété de situations. Comme avantage secondaire supplémentaire, chaque fois que vous utilisez une compréhension de liste en Python, vous n'aurez pas besoin de vous souvenir du bon ordre des arguments comme vous le feriez lorsque vous appelez |_+_|.

Les compréhensions de liste sont également plus déclaratif que les boucles, ce qui signifie qu'elles sont plus faciles à lire et à comprendre. Les boucles nécessitent que vous vous concentriez sur la façon dont la liste est créée. Vous devez créer manuellement une liste vide, parcourir les éléments et ajouter chacun d'eux à la fin de la liste. Avec une compréhension de liste en Python, vous pouvez plutôt vous concentrer sur Quel vous voulez aller dans la liste et faire confiance à Python pour s'en occuper comment la construction de la liste a lieu.

Comment booster vos compréhensions

Afin de comprendre toute la valeur que les compréhensions de liste peuvent fournir, il est utile de comprendre leur gamme de fonctionnalités possibles. Vous voudrez également comprendre les changements apportés à la compréhension de la liste dans Python 3.8.

Utilisation de la logique conditionnelle

Plus tôt, vous avez vu cette formule pour savoir comment créer des compréhensions de liste :

Bien que cette formule soit exacte, elle est également un peu incomplète. Une description plus complète de la formule de compréhension ajoute la prise en charge des options conditionnels . La manière la plus courante d'ajouter une logique conditionnelle à une compréhension de liste consiste à ajouter une condition à la fin de l'expression :

Ici, votre instruction conditionnelle vient juste avant la parenthèse fermante.

Les conditions sont importantes car elles permettent aux compréhensions de liste de filtrer les valeurs indésirables, ce qui nécessiterait normalement un appel à |__+_| :

Dans ce bloc de code, l'instruction conditionnelle filtre tous les caractères dans |__+_| ce n'est pas une voyelle.

Le conditionnel peut tester n'importe quelle expression valide. Si vous avez besoin d'un filtre plus complexe, vous pouvez même déplacer la logique conditionnelle vers une fonction distincte :

Ici, vous créez un filtre complexe |__+_| et transmettez cette fonction comme instruction conditionnelle pour votre compréhension de liste. Notez que la valeur de membre |__+_| est également passé en argument à votre fonction.

Vous pouvez placer le conditionnel à la fin de l'instruction pour un filtrage simple, mais que se passe-t-il si vous voulez monnaie une valeur de membre au lieu de la filtrer ? Dans ce cas, il est utile de placer le conditionnel près du début de l'expression :

Avec cette formule, vous pouvez utiliser la logique conditionnelle pour sélectionner parmi plusieurs options de sortie possibles. Par exemple, si vous avez une liste de prix, vous pouvez remplacer les prix négatifs par |__+_| et laissez les valeurs positives inchangées :

Ici, votre expression |__+_| contient une instruction conditionnelle, |__+_|. Cela indique à Python de sortir la valeur de |__+_| si le nombre est positif, mais pour changer |__+_| à |__+_| si le nombre est négatif. Si cela semble écrasant, il peut être utile de considérer la logique conditionnelle comme sa propre fonction :

Maintenant, votre instruction conditionnelle est contenue dans |__+_|, et vous pouvez l'utiliser dans le cadre de votre expression de compréhension de liste.

Utilisation des compréhensions d'ensemble et de dictionnaire

Bien que la compréhension de liste en Python soit un outil courant, vous pouvez également créer des compréhensions d'ensemble et de dictionnaire. UN ensemble de compréhension est presque exactement la même chose qu'une compréhension de liste en Python. La différence est que les compréhensions d'ensemble garantissent que la sortie ne contient pas de doublons. Vous pouvez créer une compréhension d'ensemble en utilisant des accolades au lieu de crochets :

si mon twitter est privé et que je réponds

Votre compréhension d'ensemble génère toutes les voyelles uniques trouvées dans |_+_|. Contrairement aux listes, les ensembles ne garantissent pas que les éléments seront enregistrés dans un ordre particulier. C'est pourquoi le premier membre de l'ensemble est |_+_|, même si la première voyelle de |_+_| est |__+_|.

Compréhensions du dictionnaire sont similaires, avec l'exigence supplémentaire de définir une clé :

Pour créer le |__+_| dictionnaire, vous utilisez des accolades (|_+_|) ainsi qu'une paire clé-valeur (|_+_|) dans votre expression.

Utilisation de l'opérateur Walrus

Python 3.8 introduira le expression d'affectation , également connu sous le nom de opérateur de morse . Pour comprendre comment vous pouvez l'utiliser, considérez l'exemple suivant.

Supposons que vous deviez faire dix requêtes à une API qui renverra des données de température. Vous souhaitez uniquement renvoyer les résultats supérieurs à 100 degrés Fahrenheit. Supposons que chaque requête renverra des données différentes. Dans ce cas, il n'y a aucun moyen d'utiliser une compréhension de liste en Python pour résoudre le problème. La formule |__+_| ne fournit aucun moyen pour la condition d'affecter des données à une variable à laquelle l'expression peut accéder.

La opérateur de morse résout ce problème. Il vous permet d'exécuter une expression tout en affectant simultanément la valeur de sortie à une variable. L'exemple suivant montre comment cela est possible, en utilisant |__+_| pour générer de fausses données météo :

Vous n'aurez pas souvent besoin d'utiliser l'expression d'affectation à l'intérieur d'une compréhension de liste en Python, mais c'est un outil utile à avoir à votre disposition si nécessaire.

Quand ne pas utiliser une compréhension de liste en Python

Les compréhensions de liste sont utiles et peuvent vous aider à écrire un code élégant, facile à lire et à déboguer, mais elles ne sont pas le bon choix pour toutes les circonstances. Ils peuvent ralentir l'exécution de votre code ou utiliser plus de mémoire. Si votre code est moins performant ou plus difficile à comprendre, il est probablement préférable de choisir une alternative.

Attention aux compréhensions imbriquées

Les compréhensions peuvent être imbriqué pour créer des combinaisons de listes, de dictionnaires et d'ensembles au sein d'une collection. Par exemple, disons qu'un laboratoire climatique suit la température élevée dans cinq villes différentes pour la première semaine de juin. La structure de données idéale pour stocker ces données pourrait être une compréhension de liste Python imbriquée dans une compréhension de dictionnaire :

Vous créez la collection externe |__+_| avec une compréhension du dictionnaire. L'expression est une paire clé-valeur, qui contient encore une autre compréhension. Ce code générera rapidement une liste de données pour chaque ville de |__+_|.

Les listes imbriquées sont un moyen courant de créer matrices , qui sont souvent utilisés à des fins mathématiques. Jetez un œil au bloc de code ci-dessous :

La compréhension de liste externe |__+_| crée six lignes, tandis que la compréhension de liste interne |_+_| remplit chacune de ces lignes avec des valeurs.

Jusqu'à présent, le but de chaque compréhension imbriquée est assez intuitif. Cependant, il existe d'autres situations, telles que aplanissement des listes imbriquées, où la logique rend sans doute votre code plus déroutant. Prenons cet exemple, qui utilise une compréhension de liste imbriquée pour aplatir une matrice :

Le code pour aplatir la matrice est concis, mais il n'est peut-être pas si intuitif pour comprendre comment cela fonctionne. D'un autre côté, si vous utilisiez |__+_| boucles pour aplatir la même matrice, alors votre code sera beaucoup plus simple :

Vous pouvez maintenant voir que le code traverse une ligne de la matrice à la fois, en extrayant tous les éléments de cette ligne avant de passer à la suivante.

Bien que la compréhension de la liste imbriquée sur une seule ligne puisse sembler plus Pythonique, le plus important est d'écrire du code que votre équipe peut facilement comprendre et modifier. Lorsque vous choisissez votre approche, vous devrez porter un jugement selon que vous pensez que la compréhension aide ou nuit à la lisibilité.

Choisissez des générateurs pour de grands ensembles de données

Une compréhension de liste en Python fonctionne en chargeant toute la liste de sortie en mémoire. Pour les petites ou même les listes de taille moyenne, cela convient généralement. Si vous voulez additionner les carrés des premiers mille entiers, alors une compréhension de liste résoudra admirablement ce problème :

Et si vous vouliez additionner les carrés du premier milliard entiers ? Si vous avez essayé ensuite sur votre machine, vous remarquerez peut-être que votre ordinateur ne répond plus. C'est parce que Python essaie de créer une liste avec un milliard d'entiers, ce qui consomme plus de mémoire que votre ordinateur ne le souhaiterait. Votre ordinateur n'a peut-être pas les ressources nécessaires pour générer une énorme liste et la stocker en mémoire. Si vous essayez de le faire quand même, votre machine pourrait ralentir ou même tomber en panne.

Lorsque la taille d'une liste devient problématique, il est souvent utile d'utiliser un générateur au lieu d'une compréhension de liste en Python. UN Générateur ne crée pas une seule grande structure de données en mémoire, mais renvoie plutôt un itérable. Votre code peut demander la valeur suivante de l'itérable autant de fois que nécessaire ou jusqu'à ce que vous ayez atteint la fin de votre séquence, tout en ne stockant qu'une seule valeur à la fois.

Si vous deviez additionner le premier milliard de carrés avec un générateur, votre programme fonctionnera probablement pendant un certain temps, mais cela ne devrait pas provoquer le blocage de votre ordinateur. L'exemple ci-dessous utilise un générateur :

Vous pouvez dire qu'il s'agit d'un générateur car l'expression n'est pas entourée de crochets ou d'accolades. En option, les générateurs peuvent être entourés de parenthèses.

L'exemple ci-dessus nécessite encore beaucoup de travail, mais il effectue les opérations paresseusement . En raison de l'évaluation paresseuse, les valeurs ne sont calculées que lorsqu'elles sont explicitement demandées. Une fois que le générateur a produit une valeur (par exemple, |_+_|), il peut ajouter cette valeur à la somme courante, puis ignorer cette valeur et générer la valeur suivante (|_+_|). Lorsque la fonction somme demande la valeur suivante, le cycle recommence. Ce processus réduit l'empreinte mémoire.

|__+_| fonctionne également paresseusement, ce qui signifie que la mémoire ne sera pas un problème si vous choisissez de l'utiliser dans ce cas :

C'est à vous de décider si vous préférez l'expression du générateur ou |__+_|.

Profil pour optimiser les performances

Alors, quelle approche est la plus rapide ? Devez-vous utiliser les compréhensions de liste ou l'une de leurs alternatives ? Plutôt que de s'en tenir à une seule règle valable dans tous les cas, il est plus utile de se demander si la performance questions dans votre situation particulière. Si ce n'est pas le cas, il est généralement préférable de choisir l'approche qui mène au code le plus propre !

Si vous êtes dans un scénario où les performances sont importantes, il est généralement préférable de profil différentes approches et écouter les données. |__+_| est une bibliothèque utile pour chronométrer le temps nécessaire à l'exécution de morceaux de code. Vous pouvez utiliser |_+_| pour comparer le temps d'exécution de |__+_|, |__+_| boucles et listes de compréhension :

Ici, vous définissez trois méthodes qui utilisent chacune une approche différente pour créer une liste. Ensuite, vous dites |_+_| pour exécuter chacune de ces fonctions 100 fois chacune. |__+_| renvoie le temps total qu'il a fallu pour exécuter ces 100 exécutions.

Comme le montre le code, la plus grande différence se situe entre l'approche basée sur la boucle et |_+_|, la boucle prenant 50 % plus de temps à s'exécuter. Que cela soit important ou non dépend des besoins de votre application.

Conclusion

Dans ce didacticiel, vous avez appris à utiliser un compréhension de la liste en Python pour accomplir des tâches complexes sans rendre votre code trop compliqué.

Maintenant vous pouvez:

• Simplifiez les boucles et |__+_| appels avec déclaratif liste des compréhensions
• Boostez vos compréhensions avec logique conditionnelle
• Créer Positionner et dictionnaire compréhensions
• Déterminez quand la clarté ou les performances du code dictent une approche alternative

Chaque fois que vous devez choisir une méthode de création de liste, essayez plusieurs implémentations et réfléchissez à ce qui est le plus facile à lire et à comprendre dans votre scénario spécifique. Si les performances sont importantes, vous pouvez utiliser des outils de profilage pour obtenir des données exploitables au lieu de vous fier à des intuitions ou à des suppositions sur ce qui fonctionne le mieux.

N'oubliez pas que même si les compréhensions de liste Python attirent beaucoup d'attention, votre intuition et votre capacité à utiliser les données quand cela compte vous aideront à écrire du code propre qui sert la tâche à accomplir. Ceci, en fin de compte, est la clé pour rendre votre code Pythonic !