Recherche de site Web

Python Set Comprehensions: Comment et quand les utiliser


Les compréhensions d'ensembles Python fournissent un moyen concis de créer et de manipuler des ensembles dans votre code. Ils génèrent des ensembles avec une syntaxe propre, rendant votre code plus lisible et pythonique. Avec la compréhension des ensembles, vous pouvez créer, transformer et filtrer des ensembles, qui constituent d'excellentes compétences à ajouter à votre boîte à outils de programmation Python.

À la fin de ce tutoriel, vous comprendrez que:

  • Python possède des compréhensions d'ensembles, qui vous permettent de créer des ensembles avec une syntaxe concise.
  • Python a quatre types de compréhensions : liste, set, dictionnaire et générateur. expressions.
  • Une compréhension d'ensemble peut être écrite sous la forme {expression for item in iterable [if condition]}.
  • Les ensembles ne peuvent pas contenir de doublons, car ils garantissent que tous leurs éléments sont uniques.

Pour tirer le meilleur parti de ce tutoriel, vous devez être familier avec les concepts de base Python tels que pour Loops, Iterables, List Comprehensions et Dictionary Comprehensions.

Création et transformation d'ensembles en Python

Dans la programmation Python, vous devrez peut-être créer, remplir et transformer des ensembles. Pour ce faire, vous pouvez utiliser Set Literals, le constructeur set() et pour boucles. Dans les sections suivantes, vous examinerez rapidement comment utiliser ces outils. Vous découvrirez également les compréhensions des ensembles, qui sont un moyen puissant de manipuler les ensembles dans Python.

Création d'ensembles avec des littéraux et set()

Pour créer de nouveaux ensembles, vous pouvez utiliser des littéraux. Un ensemble littéral est une série d'éléments enfermés en accolades bouclées. La syntaxe d'un littéral défini est illustrée ci-dessous:

{element_1, element_2,..., element_N}

Les éléments doivent être des objets hachables. Les objets du littéral peuvent être dupliqués, mais une seule instance sera stockée dans l'ensemble résultant. Les ensembles n'autorisent pas les éléments en double. Voici un exemple rapide d’un ensemble :

>>> colors = {"blue", "red", "green", "orange", "green"}
>>> colors
{'red', 'green', 'orange', 'blue'}

>>> colors.add("purple")
>>> colors
{'red', 'green', 'orange', 'purple', 'blue'}

Dans cet exemple, vous créez un ensemble contenant des noms de couleurs. Les éléments de votre ensemble résultant sont des objets chaîne uniques. Vous pouvez ajouter de nouveaux éléments en utilisant la méthode .add(). N'oubliez pas que les ensembles sont des collections non ordonnées, donc l'ordre des éléments dans l'ensemble résultant ne correspondra pas à l'ordre d'insertion dans la plupart des cas.

Vous pouvez également créer un nouvel ensemble à l'aide du constructeur set() et un itérable d'objets:

>>> numbers = [2, 2, 1, 4, 2, 3]

>>> set(numbers)
{1, 2, 3, 4}

Dans cet exemple, vous créez un nouvel ensemble en utilisant set() avec une liste de valeurs numériques. Notez que l'ensemble résultant ne contient pas d'éléments en double. En pratique, le constructeur set() est un excellent outil pour éliminer les valeurs en double dans les itérables.

Pour créer un ensemble vide, vous utilisez le constructeur set() sans arguments :

>>> set()
set()

Vous ne pouvez pas créer un ensemble vide avec un littéral car une paire d'accolades {} représente un dictionnaire vide, pas un ensemble. Pour créer un ensemble vide, vous devez utiliser le constructeur set().

Utilisation des boucles for pour remplir des ensembles

Parfois, vous devez commencer par un ensemble vide et le remplir avec des éléments dynamiquement. Pour ce faire, vous pouvez utiliser une boucle pour . Par exemple, dites que vous souhaitez créer un ensemble de mots uniques à partir d'un texte. Voici comment faire cela avec une boucle:

>>> unique_words = set()

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> for word in text.split():
...     unique_words.add(word)
...

>>> unique_words
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

Dans cet exemple, vous créez d'abord un ensemble vide en utilisant set(). Vous appliquez des minuscules au texte à l'aide de la méthode .lower() pour rendre l'extraction de mots insensible à la casse. Ensuite, vous exécutez une boucle sur une liste de mots extraits du texte.

Comme approche rapide, vous avez utilisé la méthode .split() pour diviser le texte en mots individuels en utilisant le caractère espace comme séparateur.

La boucle tente d'ajouter un mot à l'ensemble dans chaque itération. Cependant, si un mot est déjà dans l'ensemble, aucune nouvelle instance ne sera ajoutée. C'est pourquoi l'ensemble résultant n'a qu'une seule instance de mieux , par exemple. La boucle est lisible et claire, mais vous pouvez utiliser une compréhension définie pour rendre votre code encore plus concis.

Introduire les compréhensions des ensembles

Les compréhensions d'ensembles vous permettent de créer des ensembles avec une boucle for sur une seule ligne. Si vous êtes familier avec les compréhensions de listes, vous maîtriserez rapidement les compréhensions d’ensembles. Les deux constructions ont une syntaxe similaire. La principale différence est que les compréhensions d’ensembles utilisent des accolades au lieu de crochets.

Voici la syntaxe d'une compréhension définie:

{expression for member in iterable [if condition]}

Une compréhension de set renvoie un nouvel ensemble. Pour construire cet ensemble, vous calculez les éléments à partir des éléments d'une entrée itérable. La syntaxe comprend un conditionnel facultatif à la fin, que vous pouvez utiliser pour filtrer les collections existantes ou générer des éléments conditionnellement.

La syntaxe de compréhension définie se compose de quatre éléments clés:

  1. Les supports d'enfermement: Braces bouclés ( {} ) sont utilisés pour définir les compréhensions de l'ensemble.
  2. L'expression de compréhension: Une expression qui fournit un élément dans chaque itération.
  3. Le membre actuel : Ceci est le nom de l'élément ou de la valeur actuel dans l'itérable.
  4. le itéable : Il peut s'agir de n'importe quel objet Python ITERAY, y compris une liste, un tuple, un ensemble, un générateur ou des types similaires.

Le code suivant montre comment créer un ensemble de mots uniques à l'aide d'une compréhension :

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> {word for word in text.split()}
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

Dans cet exemple, vous utilisez une compréhension définie pour extraire des mots uniques du texte original. La syntaxe est concise et claire, améliorant la lisibilité de votre code.

En pratique, lorsque vous n’avez pas besoin de transformer les données pour générer les éléments de votre ensemble, vous pouvez remplacer la boucle de la section précédente et la compréhension ci-dessus par le code suivant :

>>> set(text.split())
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

Dans cet exemple, vous passez le texte divisé directement au constructeur set() et obtenez le même résultat qu'avec la boucle ou la compréhension. Vous pouvez le faire car les éléments définis n'ont pas besoin de parcourir une transformation.

Les compréhensions peuvent également inclure plusieurs clauses for. Lorsqu'ils le font, le for le plus à gauche parcourt la collection externe, le for suivant de gauche à droite parcourt le premier niveau d'imbrication, et ainsi de suite.

Pour illustrer, dites que vous avez une liste de listes. Chaque liste imbriquée contient des nombres et vous souhaitez créer un ensemble avec leurs valeurs carrées. Pour ce faire, vous pouvez utiliser une compréhension avec deux pour Clauses comme indiqué ci-dessous:

>>> matrix = [
...     [9, 3, 8, 3],
...     [4, 5, 2, 8],
...     [6, 4, 3, 1],
...     [1, 0, 4, 5],
... ]

>>> {value**2 for row in matrix for value in row}
{64, 1, 0, 4, 36, 9, 16, 81, 25}

Dans cet exemple, la première boucle for parcourt les lignes de votre matrice. La deuxième boucle for parcourt le numéro de chaque ligne. En conséquence, vous obtenez un ensemble de valeurs carrées.

Il est important de noter que dans cet exemple, au lieu d'avoir 16 éléments, vous vous retrouvez avec seulement neuf. En effet, les éléments définis sont uniques. Lorsqu'un élément est dupliqué, la nouvelle instance n'est pas ajoutée à l'ensemble final.

Tirer parti des compréhensions d’ensembles en Python

Avec les compréhensions d'ensembles, vous pouvez créer de nouveaux ensembles, transformer ceux existants et même filtrer des éléments à l'aide de conditions. Dans les sections suivantes, vous apprendrez à utiliser la compréhension des ensembles pour aborder ces cas d'utilisation.

Pour commencer, vous apprendrez à utiliser les compréhensions pour créer de nouveaux ensembles à partir d’itérables existants.

Création d'ensembles à partir d'itérables

Parfois, vous avez une itérable de données et souhaitez créer un ensemble à l'aide des éléments de données pour générer les éléments via une certaine transformation de données.

Par exemple, disons que vous disposez d’une liste d’outils et de bibliothèques. Vous devez continuellement vérifier si un outil donné figure sur la liste. Pour ce faire, vous utilisez des tests d’adhésion. Vous devez également rendre votre code insensible à la casse, vous décidez donc de transformer tous les mots en lettres minuscules.

Les ensembles sont plus efficaces que les listes dans les tests d'appartenance. Par conséquent, vous décidez également de convertir votre liste d’outils en un ensemble de mots minuscules :

>>> tools = ["Python", "Django", "Flask", "pandas", "NumPy"]

>>> tools_set = {tool.lower() for tool in tools}
>>> tools_set
{'django', 'numpy', 'flask', 'pandas', 'python'}

>>> "python".lower() in tools_set
True
>>> "Pandas".lower() in tools_set
True
>>> "Numpy".lower() in tools_set
True

Dans la ligne en surbrillance, vous utilisez une compréhension définie tout en normalisant toutes les valeurs en minuscules pour garantir des comparaisons cohérentes. Ensuite, vous utilisez l'opérateur in pour exécuter des tests d'adhésion et déterminer si un outil donné figure dans votre liste d'origine.

Encore une fois, si vous n'avez pas besoin d'appliquer une transformation de données aux éléments de l'itérable d'entrée, vous n'avez pas besoin d'utiliser une compréhension d'ensemble. Vous pouvez utiliser set(iterable) à la place. Dans l'exemple ci-dessus, la transformation consiste à mettre les noms d'outils en minuscules.

Transformer les ensembles existants

Vous pouvez également utiliser les compréhensions des ensembles pour transformer rapidement les ensembles existants. Disons que vous avez un ensemble d'adresses e-mail entrées par l'utilisateur. Vous avez remarqué que certaines adresses incluent des espaces de tête et de fin, ainsi que des lettres majuscules, et vous souhaitez résoudre ce problème. Plus important encore, vous avez remarqué qu'il y a une adresse e-mail en double.

Vous décidez de nettoyer cela avec une compréhension:

>>> emails = {
...     " alice@example.org ",
...     "BOB@example.com",
...     "charlie@EXAMPLE.com",
...     "David@example.net",
...     " bob@example.com",
...     "JohnDoe@example.com",
... }

>>> {email.strip().lower() for email in emails}
{
    'alice@example.org',
    'bob@example.com',
    'johndoe@example.com',
    'charlie@example.com',
    'david@example.net'
}

Dans la ligne en surbrillance, vous avez une compréhension définie qui supprime les espaces de tête et de fin de chaque adresse à l'aide de la méthode .strip() . Ensuite, il s'applique en minuscules à toutes les adresses à l'aide de .lower() . À la suite du nettoyage, l'adresse en double est éliminée car les ensembles ne peuvent contenir que des éléments uniques.

Filtrage des éléments des ensembles

Parfois, vous devez filtrer un ensemble existant et en créer un nouveau avec des éléments qui répondent à une exigence ou une condition donnée. Par exemple, supposons que vous souhaitiez filtrer vos adresses e-mail pour extraire uniquement les e-mails .com. Pour ce faire, vous pouvez utiliser la compréhension suivante :

>>> emails_set = {
...     "alice@example.org",
...     "bob@example.com",
...     "johndoe@example.com",
...     "charlie@example.com",
...     "david@example.net",
... }

>>> {email for email in emails_set if email.endswith(".com")}
{'bob@example.com', 'charlie@example.com', 'johndoe@example.com'}

Dans cet exemple, vous utilisez une condition pour créer un ensemble qui inclut uniquement les adresses e-mail du domaine .com.

Décider quand utiliser les compréhensions d’ensembles

Lorsque vous décidez d'utiliser une compréhension définie au lieu d'une boucle régulière ou d'une combinaison d'appels de fonction, vous devez considérer les facteurs suivants:

  • Concision : les compréhensions d'ensembles réduisent la quantité de code par rapport aux boucles for équivalentes.
  • Lisibilité : les compréhensions définies peuvent rendre votre code plus explicite et plus lisible.

En pratique, vous pouvez utiliser Set Comprehensions lorsque vous devez effectuer les opérations suivantes:

  • Créer des ensembles à partir des iterables existants en appliquant des transformations de données
  • Transformer les éléments d'un ensemble existant
  • Filtrez les éléments d'un ensemble existant

Jusqu’à présent, vous avez appris à effectuer toutes ces opérations en utilisant des compréhensions d’ensembles. Néanmoins, vous pouvez trouver d'autres bons cas d'utilisation pour la compréhension d'ensembles au cours de votre expérience de codage Python.

De plus, il existe des situations dans lesquelles l’utilisation de compréhensions d’ensembles peut ne pas être nécessaire. Par exemple, si vous devez supprimer les éléments en double d'un itérable, vous pouvez simplement utiliser la syntaxe suivante :

>>> set([2, 2, 1, 4, 2, 3])
{1, 2, 3, 4}

Si vous n'avez pas besoin de transformer les données d'entrée pour générer les éléments de l'ensemble, vous pouvez simplement utiliser le constructeur set(). C'est un excellent moyen de supprimer les éléments en double d'un itérable. Cependant, il est important de noter que les objets de l’itérable d’entrée doivent être hachables et que l’ordre original des éléments ne sera pas conservé.

Explorer les mauvaises pratiques communes

Il y a quelques mauvaises pratiques que vous voudrez éviter lorsque vous travaillez avec Set Comprehensions dans votre code Python. Certains des plus courants comprennent:

  • Utiliser des expressions complexes dans les compréhensions
  • Écriture compréhension imbriquée avec plusieurs pour clauses ou conditionnels
  • Essayer de accéder aux variables de compréhension de l'extérieur
  • Courir transformations coûteuses lors de la construction des éléments définis

Parfois, vous pouvez avoir une compréhension définie où l’expression de compréhension est trop compliquée.

Par exemple, disons que vous avez créé un ensemble à partir d’une liste de nombres. Si le nombre est pair, alors vous voulez son carré. Sinon, vous voulez son cube. Pour ce faire, vous pouvez utiliser la compréhension suivante :

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> {number**2 if number % 2 == 0 else number**3 for number in numbers}
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

Dans cette compréhension, vous utilisez une expression relativement complexe pour générer les éléments définis. Il peut être difficile de lire cette compréhension et de déchiffrer ce qu'elle fait. Lorsqu'une expression compliquée rend votre code difficile à lire, vous pouvez bénéficier de l'utilisation d'une boucle régulière pour à la place:

>>> result_set = set()

>>> for number in numbers:
...     if number % 2 == 0:
...         value = number**2
...     else:
...         value = number**3
...     result_set.add(value)
...

>>> result_set
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

Cette boucle produit le même résultat que la compréhension mais peut être plus explicite, ce qui rend votre code plus lisible.

Les compréhensions imbriquées avec plusieurs clauses for ou conditions peuvent rendre votre code moins lisible. Donc, vous devriez généralement les éviter et utiliser des constructions plus lisibles comme une boucle régulière.

Essayer d'utiliser les variables que vous définissez dans une compréhension en dehors de la compréhension elle-même n'est pas possible:

>>> {number**3 for number in range(1, 11)}
{64, 1, 512, 8, 1000, 343, 216, 729, 27, 125}

>>> number
Traceback (most recent call last):
    ...
NameError: name 'number' is not defined

La variable number n'est visible qu'en compréhension. Si vous essayez de l'utiliser en dehors de la compréhension, vous obtenez une exception NameError.

Parfois, lorsque vous travaillez avec SET Comprehensions, vous devrez peut-être exécuter des transformations de données coûteuses pour générer des éléments SET. Dans ces situations, vous devez savoir que la construction de l'ensemble final peut prendre un temps considérable. Une solution de contournement possible consiste à utiliser un générateur qui produit les éléments à la demande.

Conclusion

Vous avez découvert en détail les compréhensions des ensembles de Python. Il s'agit d'un outil puissant pour créer, transformer et filtrer des ensembles à l'aide d'une syntaxe concise et claire. Vous avez également découvert certaines mauvaises pratiques que vous devriez éviter lorsque vous travaillez avec des compréhensions définies.

Les compréhensions des ensembles sont un excellent outil pour les développeurs Python. Ils fournissent une façon pythonique et rationalisée de manipuler des ensembles dans Python.

Dans ce tutoriel, vous avez:

  • créé nouveaux ensembles avec une syntaxe concise
  • Transformé des ensembles existants avec des compréhensions
  • Filtor Éléments indésirables des ensembles existants
  • décidé Quand utiliser Set Comprehensions dans votre code

Avec ces compétences, vous pouvez écrire du code plus lisible et pythonique pour traiter des ensembles. Alors que vous continuez à utiliser Set Comprehensions, vous les trouverez comme un outil inestimable.

Questions fréquemment posées

Maintenant que vous avez une certaine expérience avec les compréhensions des ensembles dans Python, vous pouvez utiliser les questions et réponses ci-dessous pour vérifier votre compréhension et récapituler ce que vous avez appris.

Ces FAQ sont liées aux concepts les plus importants que vous avez couverts dans ce tutoriel. Cliquez sur Afficher/masquer Basculer à côté de chaque question pour révéler la réponse:

La compréhension d'ensembles est une manière concise de créer des ensembles en Python en utilisant une syntaxe similaire à la compréhension de liste. La principale différence est qu'une compréhension d'ensemble utilise des accolades {}, tandis qu'une compréhension de liste utilise des crochets []. Le résultat est un ensemble, qui est une collection désordonnée d’éléments uniques.

Vous pouvez créer un ensemble à partir d'un iTable en utilisant la syntaxe de compréhension de set: {Expression pour le membre dans iTable} . Cela évaluera l'expression de chaque membre de l'ITERAY et ajoutera le résultat à l'ensemble, garantissant que tous les éléments sont uniques.

Vous devriez envisager d'utiliser les compréhensions de SET sur des boucles régulières lorsque vous souhaitez créer des ensembles de manière concise et améliorer la lisibilité du code. Ils sont particulièrement utiles lors de la transformation ou du filtrage des données à partir d'une itérable pour générer des éléments de jeu uniques.

Les mauvaises pratiques courantes incluent l'utilisation d'expressions trop complexes dans les compréhensions, la rédaction de compréhensions imbriquées avec plusieurs clauses pour ou les conditions, tentant d'accéder aux variables de compréhension en dehors de la compréhension et effectuant des transformations coûteuses qui pourraient dégrader les performances.

Oui, vous pouvez utiliser Set Comprehensions pour filtrer les éléments en ajoutant un conditionnel à la fin de la compréhension: {Expression pour le membre dans la condition iTable If} . Cela ne comprendra que les éléments pour lesquels la condition évalue à true .