4.1 Obtention d'un sous-ensemble selon une règle
Un sous-ensemble est un ensemble dont tous les éléments appartiennent à un autre ensemble plus grand. En Python, il y a plusieurs méthodes et opérateurs intégrés pour travailler avec les sous-ensembles. Ci-dessous, je vais te montrer comment obtenir des sous-ensembles, comment vérifier si un ensemble est un sous-ensemble d'un autre, et comment utiliser ces connaissances dans différents scénarios.
Utilisation de la boucle for
Tu peux créer un ensemble vide et y ajouter des éléments qui satisfont une condition à l'aide de la boucle for.
my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set()
for x in my_set:
if x % 2 == 0:
even_set.add(x)
print(even_set) # Résultat: {2, 4, 6, 8, 10}
C'est le moyen le plus simple et le plus évident de créer un sous-ensemble. Mais il y a plusieurs autres façons, plus compactes.
Utilisation de la fonction filter()
La fonction filter() applique une fonction à chaque élément et retourne seulement ceux pour lesquels la fonction a retourné True. Le résultat doit être converti de nouveau en ensemble.
my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set(filter(lambda x: x % 2 == 0, my_set))
print(even_set) # Résultat: {2, 4, 6, 8, 10}
À l'intérieur de la fonction filter(), on utilise une expression lambda – c'est un moyen court pour définir une fonction ou une règle pour filtrer. Je te parlerai des lambdas dans quelques conférences.
4.2 Utilisation des générateurs d'ensembles
Tu te souviens des List Comprehensions? Quand on définissait dans des crochets une manière rapide de générer une liste et ses éléments? Cet outil syntaxique avait ce format:
[expression for variable in séquence]
Où:
-
variable— identificateur de la variable, -
séquence— séquence de valeurs que la variable prend (cela peut être une liste, une chaîne ou un objet obtenu avec la fonctionrange), -
expression— une expression, généralement dépendante de la variable utilisée dans le générateur, qui remplira les éléments de la liste.
Pour les ensembles, il y a une fonction similaire, sauf qu'il faut utiliser des accolades:
{expression for variable in séquence}
Les générateurs d'ensembles permettent de créer facilement et de manière concise de nouveaux ensembles basés sur des ensembles existants, en appliquant des conditions de filtrage.
Voici comment sélectionner uniquement les éléments pairs d'un ensemble:
my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = {x for x in my_set if x % 2 == 0}
print(even_set) # Résultat: {2, 4, 6, 8, 10}
Et voici comment sélectionner uniquement les chaînes:
my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, "apple", "banana"}
even_set = {x for x in my_set if type(x) == str}
print(even_set) # Résultat: {"apple", "banana"}
4.3 Vérification de la présence d'un élément
Une des principales opérations que tu peux faire avec les ensembles est la vérification de la présence d'un élément dans un ensemble. En Python, il existe plusieurs façons de faire cela. Voyons les différentes méthodes pour vérifier si un élément est présent dans un ensemble.
Utilisation de l'opérateur in
La manière la plus courante et pratique de vérifier la présence d'un élément dans un ensemble est d'utiliser l'opérateur in. Cette méthode retourne True si l'élément est présent dans l'ensemble, et False sinon.
my_set = {1, 2, 3, 4, 5}
print(3 in my_set) # Résultat: True
print(6 in my_set) # Résultat: False
Utilisation de l'opérateur not in
L'opérateur not in est l'opposé de l'opérateur in et est utilisé pour vérifier qu'un élément est absent d'un ensemble. Il retourne True si l'élément n'est pas présent, et False sinon.
my_set = {1, 2, 3, 4, 5}
print(6 not in my_set) # Résultat: True
print(3 not in my_set) # Résultat: False
Utilisation de boucles
Même si l'utilisation de boucles pour vérifier la présence d'un élément dans un ensemble n'est pas le moyen le plus efficace, cela peut être utile dans des situations où tu travailles avec des structures de données plus complexes ou effectues des opérations supplémentaires.
my_set = {1, 2, 3, 4, 5}
element = 3
found = False
for item in my_set:
if item == element:
found = True
break
print(found) # Résultat: True
4.4 Vérification de l'inclusion d'ensembles
Python fournit l'opérateur <= et la méthode issubset() pour vérifier si un ensemble est un sous-ensemble d'un autre.
Utilisation de l'opérateur <=
L'opérateur <= permet de vérifier facilement si un ensemble est un sous-ensemble d'un autre.
set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
print(set_a <= set_b) # Résultat: True
print(set_b <= set_a) # Résultat: False
Utilisation de la méthode issubset()
La méthode issubset() remplit la même fonction que l'opérateur <=, et retourne True si tous les éléments d'un ensemble sont contenus dans l'autre.
set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
print(set_a.issubset(set_b)) # Résultat: True
print(set_b.issubset(set_a)) # Résultat: False
Vérification de la sur-ensembles
De la même manière que pour les sous-ensembles, tu peux vérifier si un ensemble est un sur-ensemble d'un autre, en utilisant l'opérateur >= et la méthode issuperset().
Utilisation de l'opérateur >=
set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
print(set_a >= set_b) # Résultat: True
print(set_b >= set_a) # Résultat: False
Utilisation de la méthode issuperset()
set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
print(set_a.issuperset(set_b)) # Résultat: True
print(set_b.issuperset(set_a)) # Résultat: False
GO TO FULL VERSION