Ensembles en Python : un guide complet avec des exemples de code

Dans ce didacticiel, vous apprendrez les bases de Ensembles Python et les différentes méthodes d’ensemble que vous pouvez utiliser pour modifier les ensembles Python.

Les ensembles sont l’une des structures de données intégrées à Python. Lorsque vous devez travailler avec une collection d’éléments non répétitifs, vous utiliserez l’ensemble comme structure de données de référence.

Au cours des sections suivantes, nous passerons en revue les bases des ensembles python et les méthodes d’ensemble que vous pouvez utiliser pour les utiliser. Nous apprendrons ensuite à effectuer des opérations communes sur les ensembles en Python.

Commençons!

Bases des ensembles Python

En Python, un ensemble est une collection non ordonnée d’éléments non répétitifs. Cela signifie que les éléments d’un ensemble doivent tous être distinct.

Vous pouvez ajouter et supprimer des éléments d’un ensemble ; par conséquent, l’ensemble est un collection modifiable. Il peut contenir des éléments de différents types de données. Cependant, les éléments individuels d’un ensemble doivent être hachable.

En Python, un objet est dit hachable si sa valeur de hachage ne change jamais. La plupart des objets immuables tels que les chaînes Python, les tuples et les dictionnaires sont hachables.

Nous allons apprendre à créer des ensembles en détail. Pour l’instant, considérons les deux ensembles suivants :

py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01&gt; in <module&gt;()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}

TypeError: unhashable type: 'list'

Le premier ensemble contient trois nombres, un tuple et une chaîne. L’initialisation de l’ensemble s’exécute sans erreur. Alors que le deuxième ensemble contient une liste au lieu d’un tuple. Une liste est une collection mutable, elle ne peut pas être hachée et l’initialisation lance un TypeError.

📑 En mettant tout cela ensemble, nous pouvons définir un ensemble Python comme un mutable collection de distinct et hachable éléments.

Comment créer un ensemble Python ?

Nous allons commencer par apprendre à créer un ensemble en Python.

#1. Utilisation de l’initialisation explicite

Vous pouvez créer un ensemble en Python en spécifiant les éléments de l’ensemble, séparés par des virgules (,) et entourée d’une paire d’accolades {}.

py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)

# Output
set

Si vous avez déjà travaillé avec des listes Python, vous savez que [] initialise une liste vide. Même si un ensemble Python est enfermé dans une paire d’accolades {}tu ne peux pas utiliser une paire {} pour initialiser un ensemble. Ceci est dû au fait {} it initialise un dictionnaire Python et non un ensemble Python.

py_set2 = {}
type(py_set2)

# Output
dict

Vous pouvez de nouveau appeler le type() fonction pour vérifier que py_set c’est un dictionnaire (dict).

#2. Utilisation de la fonction set()

Si vous souhaitez initialiser un ensemble vide, puis y ajouter des éléments, vous pouvez le faire en utilisant le set() fonction.

py_set3 = set()
type(py_set3)

# Output
set

#3. Caster d’autres itérables dans un ensemble

Une autre façon de créer des ensembles consiste à convertir d’autres itérables, tels que des listes et des tuples, en ensembles, en utilisant set(iterable).

py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set

Dans l’exemple ci-dessus, py_list contient ‘C’ deux fois. Mais dans py_set4, ‘C’ n’apparaît qu’une seule fois, car l’ensemble est une collection d’éléments distincts. Cette technique de diffusion dans l’ensemble est souvent utilisée pour supprimer les doublons des listes Python.

Comment ajouter des éléments à un ensemble Python ?

Commençons par créer un ensemble vide py_set et utilisez-le pour le reste de ce didacticiel.

py_set = set()
len(py_set) # returns the length of a set
# Output
0

#1. Utilisation de la méthode .add()

Pour ajouter des éléments à un ensemble, vous pouvez utiliser la .add() méthode. set.add(element) ajoute un élément à l’ensemble.

Pour plus de clarté, nous allons ajouter des éléments à l’ensemble Python et imprimer l’ensemble à chaque étape.

▶️ Ajoutons la chaîne ‘Python’ comme élément à py_set.

py_set.add('Python')
print(py_set)

# Output
{'Python'}

Ensuite, nous ajouterons un autre élément.

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

Il est important de comprendre que le .add() La méthode ajoute uniquement un élément à l’ensemble s’il n’est pas déjà présent. Si l’ensemble contient déjà l’élément que vous souhaitez ajouter, l’opération d’ajout n’a aucun effet.

Pour vérifier cela, essayons d’ajouter ‘C++’ à py_set.

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

L’ensemble contient ‘C++’, donc l’opération d’ajout n’a aucun effet.

▶️ Ajoutons quelques éléments supplémentaires à l’ensemble.

py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)

# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}

#2. Utilisation de la méthode .update()

Jusqu’à présent, nous avons vu comment ajouter des éléments à l’ensemble existant, un élément à la fois.

Que faire si vous souhaitez ajouter plusieurs éléments à une séquence d’éléments ?

Vous pouvez le faire en utilisant le .update() méthode avec la syntaxe : set.update(collection) pour ajouter des éléments dans collection à un ensemble. La collection peut être une liste, un tuple, un dictionnaire, etc.

py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)

# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}

Cette méthode est utile lorsque vous souhaitez ajouter une collection d’éléments à un ensemble sans créer un autre objet en mémoire.

Dans la section suivante, apprenons à supprimer des éléments d’un ensemble.

Comment supprimer des éléments d’un ensemble Python ?

Considérons l’ensemble suivant (py_set avant l’opération de mise à jour).

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

#1. Utilisation de la méthode .pop()

set.pop() supprime un élément au hasard de l’ensemble et le renvoie. Appelons la méthode pop sur py_set et tu verras ce que ça donne.

py_set.pop()

# Output
'Rust'

Cette fois, l’appel à .pop() méthode a renvoyé la chaîne ‘Rust’.

Noter: Parce que le .pop() renvoie un élément au hasard, lorsque vous exécutez le code de votre côté, vous pouvez tout aussi bien obtenir un autre élément.

Lorsque nous examinons l’ensemble, ‘Rust’ n’est plus présent dans l’ensemble.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++', 'C'}

#2. Utilisation des méthodes .remove () et de rejet ()

En pratique, vous souhaiterez peut-être supprimer des éléments spécifiques de l’ensemble. Pour ce faire, vous pouvez utiliser le .remove() et .discard() méthodes.

set.remove(element) supprime des éléments de l’ensemble.

py_set.remove('C')
print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

Si nous essayons de supprimer un élément non présent dans l’ensemble, nous rencontrons une KeyError.

py_set.remove('Scala')

# Output
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')

KeyError: 'Scala'

Jetons un coup d’oeil à py_set à nouveau. Nous avons maintenant trois éléments.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

Avec la syntaxe set.discard(element)la .discard() La méthode supprime également des éléments de l’ensemble.

py_set.discard('C++')
print(py_set)

# Output
{'JavaScript', 'Python'}

Cependant, il diffère de la .remove() méthode en ce qu’elle fait ne pas élever une KeyError lorsque nous essayons de supprimer un élément qui n’est pas présent.

Si nous essayons de supprimer ‘Scala’ (qui n’existe pas) de la liste en utilisant le .discard() méthode, nous ne voyons aucune erreur.

py_set.discard('Scala') #no error!
print(py_set)

# Output
{'JavaScript', 'Python'}

Comment accéder aux éléments d’un ensemble Python ?

Jusqu’à présent, nous avons appris à ajouter et à supprimer des éléments des ensembles Python. Cependant, nous n’avons pas encore vu comment accéder aux éléments individuels d’un ensemble.

Comme un ensemble est une collection non ordonnée, il n’est pas indexable. Par conséquent, si vous essayez d’accéder aux éléments d’un ensemble à l’aide de l’index, vous rencontrerez une erreur, comme indiqué.

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

print(py_set[0])

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])

TypeError: 'set' object is not subscriptable

Alors, comment accéder aux éléments d’un ensemble ?

Il existe deux manières courantes de procéder :

• Parcourez l’ensemble et accédez à chaque élément
• Vérifier si un élément particulier fait partie de l’ensemble

▶️ Parcourez le décor et accédez aux éléments à l’aide d’un for boucle.

for elt in py_set:
  print(elt)

# Output
C++
JavaScript
Python
Rust
C

En pratique, vous voudrez peut-être vérifier si un élément donné est présent dans l’ensemble à l’aide de la in opérateur.

Noter: élément in Positionner Retour True si l’élément est présent dans l’ensemble ; sinon ça revient False.

Dans cet exemple, py_set contient ‘C++’ et ne contient pas ‘Julia’ et le in l’opérateur renvoie True et Falserespectivement.

'C++' in py_set
# True
'Julia' in py_set
# False

Comment trouver la longueur d’un ensemble Python ?

Comme vu précédemment, vous pouvez utiliser le len() fonction pour obtenir le nombre d’éléments présents dans un ensemble.

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)

# Output: 5

Comment effacer un ensemble Python ?

Pour effacer un ensemble en supprimant tous les éléments, vous pouvez utiliser la .clear() méthode.

Appelons le .clear() méthode sur py_set.

py_set.clear()

Si vous essayez de l’imprimer, vous obtiendrez set() – indiquant que l’ensemble est vide. Vous pouvez également appeler le len() fonction pour vérifier que la longueur de l’ensemble est nulle.

print(py_set)
# set()
print(len(py_set))
# 0

Jusqu’à présent, nous avons appris à effectuer des CRUD opérations sur les ensembles Python :

• Créer: Utilisant set() fonction, conversion de type et initialisation
• Lis: Accéder aux éléments du décor à l’aide de boucles et in opérateur pour les tests d’adhésion
• Mise à jour: ajouter, supprimer des éléments d’ensembles et mettre à jour des ensembles
• Effacer: Effacer un ensemble en supprimant tous ses éléments

Opérations sur les ensembles communs, expliquées avec le code Python

Les ensembles Python nous permettent également d’effectuer les opérations d’ensemble de base. Nous les découvrirons dans cette section.

#1. Union d’ensembles en Python

En théorie des ensembles, le syndicat de deux ensembles est l’ensemble de tous les éléments d’au moins un des deux ensembles. S’il y a deux ensembles, A et B, alors l’union contient des éléments qui ne sont présents que dans A, que dans B, et les éléments présents à la fois dans A et B.

Pour trouver l’union des ensembles, vous pouvez utiliser la | l’opérateur ou le .union() la méthode avec la syntaxe : setA.union(setB).

setA = {1,3,5,7,9}
setB = {2,4,6,8,9}

print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

setA.union(setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

L’union ensembliste est une opération commutative ; donc AUB est le même que BU A. Vérifions cela en interchangeant les positions de setA et setB dans le .union() appel de méthode.

setB.union(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

#2. L’intersection des ensembles en Python

Une autre opération d’ensemble conjointe est cette intersection de deux ensembles, A et B. L’opération d’intersection d’ensemble renvoie un ensemble qui contient tous les éléments présents à la fois dans A et B.

Pour calculer l’intersection, vous pouvez utiliser le & l’opérateur ou le .intersection() méthode, comme expliqué dans l’extrait de code ci-dessous.

print(setA & setB)

# Output
{9}

setA.intersection(setB)

# Output
{9}

Dans cet exemple, l’élément 9 est présent à la fois dans setA et setB ; donc l’ensemble d’intersection ne contient que cet élément.

Comme l’union d’ensemble, l’intersection d’ensemble est également une opération commutative.

setB.intersection(setA)

# Output
{9}

#3. Définir la différence en Python

Étant donné deux ensembles quelconques, l’union et l’intersection nous aident à trouver les éléments présents dans les deux et au moins un des ensembles, respectivement. D’autre part, définir la différence nous aide à trouver les éléments présents dans un ensemble mais pas dans l’autre.

– setA.difference(setB) donne l’ensemble des éléments qui ne sont présents que dans setA et non dans setB.

– setB.difference(setA) donne l’ensemble des éléments qui ne sont présents que dans setB et non dans setA.

print(setA - setB)

print(setB - setA)

# Output
{1, 3, 5, 7}
{8, 2, 4, 6}

Clairement, A\B n’est pas le même que B\A, donc la différence d’ensemble n’est pas une opération commutative.

setA.difference(setB)
# {1, 3, 5, 7}

setB.difference(setA)
# {2, 4, 6, 8}

#4. Différence d’ensemble symétrique en Python

Alors que définir l’intersection nous donne des éléments présents dans tous les deux ensembles, les différence d’ensemble symétrique renvoie l’ensemble des éléments présents dans exactement un des ensembles.

Prenons l’exemple suivant.

setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}

Pour calculer l’ensemble de différences symétriques, vous pouvez utiliser le ^ l’opérateur ou le .symmetric_difference() méthode.

print(setA ^ setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Les éléments 10 et 12 sont présents dans les deux setA et setB. Ils ne sont donc pas présents dans l’ensemble de différences symétriques.

setA.symmetric_difference(setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Comme l’opération de différence d’ensemble symétrique collecte tous les éléments qui apparaissent exactement dans l’un des deux ensembles, l’ensemble résultant est le même quel que soit l’ordre dans lequel les éléments sont collectés. Par conséquent, une différence d’ensemble symétrique est une opération commutative.

setB.symmetric_difference(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

#5. Sous-ensembles et surensembles en Python

Dans la théorie des ensembles, les sous-ensembles et les sur-ensembles aident à comprendre la relation entre deux ensembles.

Étant donné deux ensembles A et B, l’ensemble B est un sous-ensemble de l’ensemble A si tous les éléments de l’ensemble B sont également présents dans l’ensemble A. Et l’ensemble A est le sur-ensemble de l’ensemble B.

Prenons l’exemple de deux ensembles : languages et languages_extended.

languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}

En Python, vous pouvez utiliser le .issubset() méthode pour vérifier si un ensemble donné est un sous-ensemble d’un autre ensemble.

setA.issubset(setB) Retour True si setA est un sous-ensemble de setB; sinon ça revient False.

Dans cet exemple, languages est un sous-ensemble de languages_extended.

languages.issubset(languages_extended)
# Output
True

De même, vous pouvez utiliser le .issuperset() méthode pour vérifier si un ensemble donné est un sur-ensemble d’un autre ensemble.

setA.issuperset(setB) Retour True si setA est un sur-ensemble de setB; sinon ça revient False.

languages_extended.issuperset(languages)
# Output
True

Comme languages_extended est un sur-ensemble de langues, languages_extended.issuperset(languages) Retour Truecomme vu ci-dessus.

Conclusion

J’espère que ce didacticiel vous a aidé à comprendre le fonctionnement des ensembles Python, les méthodes d’ensemble pour les opérations CRUD et les opérations d’ensemble courantes. Dans une prochaine étape, vous pouvez essayer de les utiliser dans vos projets Python.

Vous pouvez consulter d’autres guides Python détaillés. Bon apprentissage!