English English French French Spanish Spanish German German
Geekflare est soutenu par notre public. Nous pouvons gagner des commissions d'affiliation en achetant des liens sur ce site.
Partager sur:

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

Ensembles Python
Scanner de sécurité des applications Web Invicti – la seule solution qui offre une vérification automatique des vulnérabilités avec Proof-Based Scanning™.

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!

Basics of Python Sets

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 Chaînes Python, les tuples et 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> in <module>()
----> 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 distinct et hachable éléments.

How to Create a Python Set

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 travaillé avec listes Python avant, tu sais que [] initialise une liste vide. Même si un ensemble Python est enfermé dans une paire d'accolades {}, Vous ne peut 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() la 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 coulée dans le décor est souvent utilisée pour supprimer les doublons des listes Python.

How to Add Elements to a Python Set

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.

Remove Elements from a Python Set

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'.

Notes: 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), les .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 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'}

Access Elements of a Python Set

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.

Notes: élément in set Retours 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 retour de l'opérateur True et False, Respectivement.

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

Find the Length of a Python Set

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

How to Clear a Python Set

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 Cru opérations sur les ensembles Python :

  • Création: En utilisant set() fonction, conversion de type et initialisation
  • Lisez: 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
  • Supprimer: Effacer un ensemble en supprimant tous ses éléments

Common Set Operations, Explained with Python Code

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 théorie des ensembles, le union 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 | 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. Intersection d'ensembles

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 & 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

É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.

python-ensemble-différence

- setA.difference(setB) donne l'ensemble des éléments qui ne sont présents que dans setA et pas dans setB.

- setB.difference(setA) donne l'ensemble des éléments qui ne sont présents que dans setB et pas 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

Tandis que définir l'intersection nous donne des éléments présents dans tous les deux ensembles, le 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 ^ 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

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) Retours True if 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) Retours True if setA est un sur-ensemble de setB; sinon ça revient False.

languages_extended.issuperset(languages)
# Output
True

As languages_extended est un sur-ensemble de langues, languages_extended.issuperset(languages) Retours True, comme 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 votre Projets Python.

Vous pouvez consulter d'autres informations détaillées Guides Python. Bon apprentissage!

Merci à nos commanditaires
Plus de bonnes lectures sur le développement
Alimentez votre entreprise
Certains des outils et services pour aider votre entreprise à se développer.
  • Invicti utilise Proof-Based Scanning™ pour vérifier automatiquement les vulnérabilités identifiées et générer des résultats exploitables en quelques heures seulement.
    Essayez Invicti
  • Web scraping, proxy résidentiel, proxy manager, web unlocker, moteur de recherche et tout ce dont vous avez besoin pour collecter des données Web.
    Essayez Brightdata
  • Semrush est une solution de marketing numérique tout-en-un avec plus de 50 outils de référencement, de médias sociaux et de marketing de contenu.
    Essayez Semrush
  • Intruder est un scanner de vulnérabilités en ligne qui détecte les failles de cybersécurité de votre infrastructure, afin d'éviter des violations de données coûteuses.
    Essayez Intruder