Une introduction simple à la compréhension d'ensembles en Python

Étant détestés par les débutants, les codeurs Python expérimentés ne peuvent pas vivre sans cette fonctionnalité Python géniale. Dans cet article, je vous donne tout ce que vous devez savoir sur les compréhensions d'ensembles en utilisant la notation entre parenthèses {} .

Qu'est-ce que la compréhension d'ensemble ?

La compréhension des ensembles est une manière concise de créer des ensembles en Python en utilisant la notation des accolades {expression for element in context} . Par exemple, {x for x in range(10)} crée l'ensemble {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} . Vous pouvez éventuellement ajouter une condition pour restreindre le contexte dans {expression for element in context if condition} . Par exemple, {x for x in range(10) if x>5} crée l'ensemble {6, 7, 8, 9} .

Avez-vous besoin d'un rappel sur les ensembles Python ? Consultez le guide ultime des ensembles Python sur ce blog. Supposons que vous souhaitiez filtrer tous les clients de votre base de données qui gagnent plus de 1 000 000 $. Voici ce que ferait un débutant ne connaissant pas la compréhension des ensembles :

# (name, $-income)
customers = [("John", 240000),
            ("Alice", 120000),
            ("Ann", 1100000),
            ("Zach", 44000)]


# your high-value customers earning &gt;$1M
whales = set()
for customer, income in customers:
   if income&gt;1000000:
       whales.add(customer)


print(whales)
# {'Ann'}

Cet extrait nécessite quatre lignes uniquement pour créer un ensemble de clients de grande valeur (baleines) !

Si vous faites cela dans votre base de code Python publique, préparez-vous à être critiqué pour "ne pas écrire de code Pythonic" . 😉

Au lieu de cela, une bien meilleure façon de faire la même chose est d'utiliser la compréhension d'ensemble :

whales = {x for x,y in customers if y>1000000}
print(whales)
# {'Ann'}

Magnifique, n'est-ce pas ?

La compréhension des ensembles est extrêmement simple lorsque vous connaissez la formule que je vais vous montrer dans un instant. Alors pourquoi les gens ne savent-ils pas comment utiliser la compréhension d'ensemble ? Parce qu'ils n'ont jamais recherché la déclaration la plus importante sur la compréhension des listes (qui est similaire à la compréhension des ensembles) dans la documentation Python. C'est ça:

Voici la formule pour la compréhension d'ensembles. C'est la seule chose que vous devriez retenir de cet article :la compréhension d'ensembles se compose de deux parties.

{ expression + context }

La première partie est l'expression . Dans l'exemple ci-dessus c'était la variable x . Mais vous pouvez également utiliser une expression plus complexe telle que x.upper() . Utilisez n'importe quelle variable dans votre expression que vous avez définie dans le contexte d'une instruction de boucle.

Voir cet exemple :

whales = {x.upper() for x,y in customers if y>1000000}
print(whales)
# {'ANN'}

La deuxième partie est le contexte . Le contexte consiste en un nombre arbitraire de for et if clauses. Le but unique du contexte est de définir (ou de restreindre) la séquence d'éléments sur laquelle on veut appliquer l'expression. C'est pourquoi vous voyez parfois des restrictions complexes comme celle-ci :

small_fishes = {x + str(y) for x,y in customers if y>1000000 if x!='John'}
# (John is not a small fish...)

print(small_fishes)
# {'Zach44000', 'Alice120000'}

C'est à peu près ça!

Pour résumer, souvenez-vous de cette formule de cet article :set comprehension = { expression + context } .

Comment fonctionne la compréhension des ensembles imbriqués en Python ?

Après avoir publié la première version de cet article, de nombreux lecteurs m'ont demandé d'écrire un article de suivi sur la compréhension d'ensembles imbriqués en Python.

Issu d'une formation en informatique, je supposais que la "compréhension d'ensembles imbriqués" faisait référence à la création d'un ensemble d'ensembles . Mais après quelques recherches, j'ai appris que vous ne pouvez pas créer un ensemble d'ensembles car les ensembles ne sont pas hachables. Bien sûr. Comme j'étais stupide !

Au lieu de cela, la plupart des codeurs veulent dire quelque chose de différent lorsqu'ils demandent "comment fonctionne la compréhension d'ensembles imbriqués ?" . Ils veulent savoir comment utiliser une boucle for imbriquée pour créer un ensemble simple d'éléments pouvant être hachés.

Pour être franc, c'est un truc super simple. Vous souvenez-vous de la formule de compréhension d'ensemble { expression + context } ?

Le contexte est une construction complexe arbitraire de for boucles et if restrictions dans le but de spécifier les éléments de données sur lesquels l'expression doit être appliquée.
Dans l'expression, vous pouvez utiliser n'importe quelle variable que vous définissez dans un for boucle dans le contexte.

Examinons un exemple.

Supposons que vous souhaitiez utiliser la compréhension d'ensemble pour rendre ce code plus concis. Par exemple, vous souhaitez rechercher toutes les paires d'utilisateurs possibles dans votre application de réseau social :

# BEFORE
users = ["John", "Alice", "Ann", "Zach"]
pairs = set()
for x in users:
   for y in users:
       if x != y:
           pairs.add((x,y))
print(pairs)
# {('Zach', 'Alice'), ('John', 'Ann'), ('Alice', 'Zach'), ('Ann', 'John'), ('Alice', 'Ann'), ('Alice', 'John'), ('Zach', 'John'), ('Zach', 'Ann'), ('John', 'Zach'), ('Ann', 'Zach'), ('John', 'Alice'), ('Ann', 'Alice')}

Maintenant, ce code est un gâchis! Comment pouvons-nous y remédier ? Utilisez simplement la compréhension des ensembles imbriqués !

# AFTER
pairs = {(x,y) for x in users for y in users if x!=y}
print(pairs)
# {('Ann', 'Zach'), ('Zach', 'John'), ('Alice', 'John'), ('Ann', 'Alice'), ('Ann', 'John'), ('Alice', 'Zach'), ('Alice', 'Ann'), ('John', 'Zach'), ('Zach', 'Ann'), ('John', 'Ann'), ('Zach', 'Alice'), ('John', 'Alice')}

Comme vous pouvez le voir, nous faisons exactement la même chose qu'avec la compréhension d'ensembles non imbriqués. La seule différence est d'écrire les deux for boucles et le if déclaration sur une seule ligne entre parenthèses {} .

Quelle est la différence entre la compréhension de liste et la compréhension d'ensemble en Python ?

Il existe deux différences entre la compréhension de liste et la compréhension d'ensemble.

Braces vs. Brackets :Voulez-vous générer un ensemble ? Utilisez des accolades {} . Voulez-vous générer une liste ? Utilisez des crochets angulaires [] .
Le type de données du résultat :compréhension de la liste génère une liste et définit la compréhension génère un ensemble.

Mais syntaxiquement, la compréhension des listes et la compréhension des ensembles sont identiques.