Même si vous ne faites que commencer votre voyage Python, vous avez très probablement rencontré des ensembles Python. Mais savez-vous comment les utiliser efficacement ? Cet article vise à couvrir toutes les principales opérations d'ensemble Python pour vous donner une meilleure idée du moment et de la manière d'utiliser cette structure de données importante.
Que sont les ensembles Python ?
Tout d'abord, commençons par les bases. Un ensemble est un type intégré à Python qui possède un certain nombre de caractéristiques importantes :
- Les ensembles ne sont pas ordonnés. En d'autres termes, les éléments sont insérés dans un ordre aléatoire, vous ne pouvez donc pas accéder aux éléments à l'aide d'index.
- Les ensembles ne comprennent que des éléments uniques. Aucun doublon n'est autorisé dans les ensembles.
- Un ensemble est modifiable. Un ensemble peut être modifié, et il est possible d'y ajouter et d'en supprimer des éléments.
- Les éléments d'un ensemble doivent être d'un type immuable. Par exemple, les chaînes, les entiers, les flottants et les tuples sont des types acceptables pour un ensemble.
- Un ensemble peut inclure des éléments de différents types. Par exemple, vous pouvez inclure un mélange de nombres, de chaînes et de tuples dans un seul ensemble.
Il est maintenant temps de voir comment définir et modifier les ensembles Python.
Créer et modifier un ensemble en Python
Créer des ensembles
Il existe deux façons de créer un ensemble :vous pouvez utiliser le set() function intégré ou, alternativement, définir un ensemble avec des accolades . Voici quelques exemples :
# Creating sets using built-in function set_one = set((0, "one", (2, 3, 4))) set_one
{(2, 3, 4), 0, 'one'}
# Creating sets using built-in function
set_two = set("Game of Thrones")
set_two
{' ', 'G', 'T', 'a', 'e', 'f', 'h', 'm', 'n', 'o', 'r', 's'}
# Creating sets using curly braces
set_three = {0, "one", (2, 3, 4)}
set_three
{(2, 3, 4), 0, 'one'}
# Creating sets using curly braces
set_four = {"Game of Thrones"}
set_four
{'Game of Thrones'}
L'argument du set() function doit être un itérable qui génère une liste d'objets (par exemple, tuples, listes, chaînes); ceux-ci seront insérés dans l'ensemble. En revanche, si vous utilisez des accolades, les objets eux-mêmes sont placés manuellement. Vous avez donc probablement repéré la différence dans l'application de ces deux approches :
- On passe dans un tuple au
set()fonction pour créerset_one, mais nous plaçons les objets directement dans les accolades pour obtenirset_threeavec les mêmes éléments. - Le
set()la fonction traite la chaîne que nous transmettons pour créerset_twocomme un itérable, et donc l'ensemble résultant est une collection de lettres de cette chaîne, tandis que les accolades traitent une chaîne comme un élément distinct de l'ensemble et nous obtenons doncset_fouravec cette chaîne comme seul membre.
Notez également que les ensembles résultants ne sont pas ordonnés et que les valeurs en double ne sont représentées qu'une seule fois dans l'ensemble (comme avec la lettre 'e' dans le deuxième exemple).
Vérification de la taille et de l'appartenance de l'ensemble
Vous pouvez utiliser le len() fonction pour vérifier le nombre d'éléments dans un ensemble, et vous pouvez également vérifier si un élément particulier existe ou n'existe pas dans un ensemble en utilisant le in ou not in opérateurs, respectivement.
# Checking the number of elements in a set len(set_one)
3
# Checking if an element is in a set 0 in set_one
True
# Checking if an element is not in a set 0 not in set_one
False
Ajouter des éléments à un ensemble
Vous pouvez utiliser le add() méthode pour insérer un seul élément dans un ensemble. Si vous souhaitez insérer plusieurs objets dans un ensemble à la fois, utilisez le update() méthode. Voici quelques exemples :
# Adding a single element using add() method
my_set = {'a', 'b', 'c'}
my_set.add('d')
my_set
{'a', 'b', 'c', 'd'}
# Adding multiple elements using update() method
my_set.update('e', 'f', 'g', 'b')
my_set
{'a', 'b', 'c', 'd', 'e', 'f', 'g'}
# Adding multiple elements of different types (i.e., adding a tuple and another set)
my_set.update(('a', 'h'), {'c', 'i', 'j'})
my_set
{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Supprimer des éléments d'un ensemble
Il existe plusieurs façons de supprimer des éléments d'un ensemble :
- Utilisez le
remove()si vous souhaitez supprimer un seul élément d'un ensemble, ou obtenir un message d'erreur si l'élément respectif n'est pas dans l'ensemble. - Utilisez le
discard()si vous voulez supprimer un seul élément d'un ensemble mais n'avez pas besoin d'un message d'erreur si l'élément donné n'est pas dans l'ensemble. - Utilisez le
pop()méthode pour supprimer et renvoyer un élément aléatoire d'un ensemble. - Utilisez le
clear()méthode pour supprimer tous les éléments d'un ensemble.
Nous verrons plus tard comment supprimer plusieurs éléments d'un ensemble sans utiliser de boucle.
# Using remove() to remove an item that doesn't exist in a set
my_set.remove('o')
my_set
--------------------------------------------------------------------------- KeyError Traceback (most recent call last)in () 1 # Using remove() to remove an item that doesn't exist in a set ----> 2 my_set.remove('o') 3 my_set KeyError: 'o'
# Using discard() to remove an item that doesn't exist in a set
my_set.discard('o')
my_set
{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
# Using pop() to remove and return a random element print(my_set.pop()) print(my_set)
j
{'d', 'b', 'e', 'c', 'a', 'i', 'h', 'g', 'f'}
# Using clear() to remove all elements from a set my_set.clear() my_set
set()
Ce sont les méthodes de base que vous pouvez utiliser pour modifier un ensemble. Passons maintenant à quelques opérations et méthodes d'ensemble Python plus avancées.
Opérations et méthodes d'ensemble Python
Nous pouvons utiliser des ensembles Python pour effectuer des opérations d'ensemble mathématiques comme union , intersection , différence , et différence symétrique . Ces opérations peuvent être effectuées à l'aide d'opérateurs ou de méthodes.
Cependant, il existe une différence importante entre ces deux approches :les opérateurs ne peuvent travailler qu'avec des ensembles, tandis que les méthodes acceptent n'importe quel itérable (par exemple, des listes, des tuples) comme argument, le convertissent en un ensemble, puis effectuent l'opération.
Ne vous inquiétez pas si ce n'est pas encore clair pour vous, nous allons voir quelques exemples ci-dessous.
Définir l'union
S'il y a deux ensembles, first_set et second_set , l'union de ces deux ensembles est l'ensemble de tous les éléments des deux ensembles . Vous pouvez obtenir une union de deux ensembles en utilisant le union() méthode ou le | opérateur. Cependant, si vous voulez obtenir une union d'un ensemble et d'une liste, le | l'opérateur ne fonctionnera pas et vous devrez utiliser le union() méthode.
# Initializing sets
first_set = {1, 3, 5, 7, 9}
second_set = {2, 4, 6, 8, 10}
# Set union using | operator first_set | second_set
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
# Set union using union() method first_set.union(second_set)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
# Getting a union of a set and a list first_set.union([2, 4, 6, 8, 10])
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Définir l'intersection
L'intersection de deux ensembles, first_set et second_set , est l'ensemble de tous les éléments communs aux deux ensembles . Cette opération peut être effectuée à l'aide de l'opérateur &ou du intersection() méthode.
# Initializing sets
first_set = {1, 2, 3, 4, 5}
second_set = {4, 5, 6, 7, 8}
third_set = {4, 5, 9, 10}
# Performing intersection using & operator first_set & second_set & third_set
{4, 5}
# Performing inteesection using intersection() method first_set.intersection(second_set, third_set)
{4, 5}
Comme vous pouvez le voir, à la fois le intersection() La méthode et l'opérateur &vous permettent de créer une intersection pour plus de deux ensembles. Notez que cela s'applique non seulement aux intersections définies, mais également à d'autres opérations.
Définir la différence
La différence de first_set et second_set est l'ensemble de tous les éléments qui ne sont que dans first_set et pas dans second_set . Vous pouvez créer la différence de deux ensembles en utilisant soit l'opérateur – soit le difference() méthode.
# Initializing sets
first_set = {1, 2, 3, 4, 5}
second_set = {4, 5, 6, 7, 8}
# Performing difference using - operator print(first_set - second_set) print(second_set - first_set)
{1, 2, 3}
{8, 6, 7}
# Performing difference using difference() method print(first_set.difference(second_set)) print(second_set.difference(first_set))
{1, 2, 3}
{8, 6, 7}
Comme vous pouvez le voir dans les exemples, l'ordre des ensembles est important lors de l'exécution de l'opération de différence d'ensemble.
Définir la différence symétrique
L'opération de différence symétrique permet d'obtenir les éléments qui sont soit en first_set ou en second_set mais pas dans les deux . Encore une fois, vous avez deux options pour effectuer cette opération :le symmetric_difference() méthode ou le ^ opérateur.
# Initializing sets
first_set = {1, 2, 3, 4, 5}
second_set = {4, 5, 6, 7, 8}
# Performing symmetric difference using ^ operator first_set^second_set
{1, 2, 3, 6, 7, 8}
# Performing symmetric difference using symmetric_difference() method first_set.symmetric_difference(second_set)
{1, 2, 3, 6, 7, 8}
Opérations de mise à jour
Chacune des opérations dont nous avons discuté ci-dessus (union, intersection, différence et différence symétrique) peut également être utilisée pour mettre à jour un ensemble . Il suffit d'utiliser une forme d'affectation augmentée pour les opérateurs (|=, &=, -=, ^=), ou les méthodes correspondantes update() , intersection_update() , difference_update() , et symmetric_difference_update() ). Voici quelques exemples :
# Initializing sets
first_set = {1, 2, 3, 4, 5}
second_set = {4, 5, 6, 7, 8}
# Modifying a set by union using update() method first_set.update(second_set) first_set
{1, 2, 3, 4, 5, 6, 7, 8}
# Modifying a set by intersection using an operator first_set &= second_set first_set
{4, 5, 6, 7, 8}
# Modifying a set by difference using difference_update() method first_set.difference_update((6, 7, 8)) first_set
{4, 5}
# Modifying a set by symmetric difference using an operator first_set ^= second_set first_set
{6, 7, 8}
Remarquez comment nous avons pu supprimer plusieurs éléments de first_set en spécifiant les éléments que nous voulions supprimer dans un tuple que nous avons passé en argument au difference_update() méthode.
Autres méthodes de définition
Passons brièvement en revue certaines méthodes qui vous aideront à déterminer comment les ensembles sont liés les uns aux autres :
isdisjoint()renvoie vrai si deux ensembles ont des éléments en commun.issubset()ou le<=renvoie vrai si le premier ensemble est un sous-ensemble du second.issuperset()ou le>=renvoie vrai si le premier ensemble contient tous les éléments du second.
Python gelé
Si vous avez déjà essayé d'utiliser des éléments d'ensemble comme clés de dictionnaire, vous savez que cela ne fonctionne pas car les ensembles sont modifiables et donc non hachables . Heureusement, Python a un autre type intégré nommé frozenset qui a toutes les propriétés d'un ensemble mais qui est immuable. Les Frozensets sont hachables et sont acceptés comme clés d'un dictionnaire. Consultez les bases de Python. Cours de la partie 2 pour plus d'informations sur la création de dictionnaires.
Vous pouvez créer un frozenset en utilisant le frozenset() fonction. Étant immuable, un frozenset n'a pas de méthodes pour ajouter ou supprimer des éléments. Cependant, les opérations de mise à jour fonctionnent avec les frozensets. En effet, ces opérations ne modifient pas l'ensemble d'origine mais affectent plutôt l'ensemble à un nouvel objet.
Récapitulez
Vous savez maintenant comment définir un objet ensemble en Python, comment modifier un ensemble et quels types d'opérations peuvent être effectuées avec des ensembles. Vous connaissez également les principales caractéristiques des ensembles Python et devriez avoir une meilleure idée du moment où un ensemble est un choix approprié.
Tout ce dont vous avez besoin maintenant, c'est d'un peu de pratique ! Consultez les bases de Python. Cours de la partie 3 pour un certain nombre d'exercices interactifs qui couvrent les ensembles, les tuples et les objets date/heure.
Si vous avez également besoin d'un rappel sur les listes, les dictionnaires et les fichiers texte, Python Basics. La partie 2 vous fournira des explications faciles à comprendre et de nombreux exercices pratiques.
