En Python, set est une collection d’éléments qui ne se chevauchent pas (éléments uniques). Il peut effectuer des opérations d’ensemble telles que l’union, l’intersection, la différence, la différence symétrique, etc.
Cet article décrit le contenu suivant.
Opérations de base:
- Créez un objet défini :
{}, set() - Définir les compréhensions
- Obtenez le nombre d’éléments dans l’ensemble :
len() - Ajoutez un élément à l’ensemble :
add() - Supprimer un élément de l’ensemble :
discard(), remove(), pop(), clear()
Opérations mathématiques :
- Syndicat:
| operator, union() - Intersection:
& operator, intersection() - Différence:
- operator, difference() - Différence symétrique :
^ operator, symmetric_difference() - Testez si A est un sous-ensemble de B :
<= operator, issubset() - Testez si A est un sur-ensemble de B :
>= operator, issuperset() - Teste si A et B sont disjoints :
isdisjoint()
Le type set est un type mutable qui peut ajouter et supprimer des éléments. Python fournit également le type frozenset, qui a des méthodes pour les opérations d’ensemble comme set mais qui est immuable. frozenset ne peut pas être modifié en ajoutant ou en supprimant des éléments.
Créez un objet défini :{}, set()
Créer un objet set avec des accolades {}
les objets set peuvent être créés en plaçant des éléments entre accolades {}.
S’il existe des valeurs en double, elles sont ignorées et seules les valeurs uniques restent en tant qu’éléments.
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
set peut avoir des éléments de types différents mais ne peut pas avoir d’objets modifiables tels que list.
Le type d’ensemble n’est pas ordonné, donc l’ordre dans lequel il a été créé n’est pas conservé.
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
Même si les types sont différents, comme int et float, ils sont considérés comme des doublons si les valeurs sont égales.
s = {100, 100.0}
print(s)
# {100}
Puisqu’un {} vide est considéré comme un dict de dictionnaire, un ensemble vide peut être créé à l’aide de set() décrit ci-après.
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
Créer un objet set avec set()
les objets set peuvent également être créés avec set().
En spécifiant un objet itérable tel qu’une liste ou un tuple comme argument, un objet set est créé dans lequel les éléments en double sont exclus et seules les valeurs uniques restent.
l = [1, 2, 2, 3, 1, 4]
print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>
s_l = set(l)
print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>
Pour un frozenset immuable, utilisez frozenset().
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
Si l’argument est omis, un ensemble vide est généré.
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
Vous pouvez utiliser set() pour supprimer les éléments en double d’une liste ou d’un tuple, mais l’ordre d’origine n’est pas conservé.
Utilisez list() et tuple() pour convertir un ensemble en une liste ou un tuple.
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
Consultez l’article suivant pour supprimer les éléments en double dans l’ordre d’origine ou extraire uniquement les éléments en double.
Définir les compréhensions
Python fournit des compréhensions d’ensemble ainsi que des compréhensions de liste. Utilisez des accolades {} au lieu de crochets [].
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Consultez l’article suivant pour plus d’informations sur les compréhensions de liste.
Obtenez le nombre d’éléments dans l’ensemble :len()
Le nombre d’éléments de l’ensemble peut être obtenu avec la fonction intégrée len().
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
Si vous souhaitez compter le nombre d’occurrences dans une liste avec des éléments en double, consultez l’article suivant.
Ajoutez un élément à l’ensemble :add()
Utilisez la méthode add() pour ajouter un élément à l’ensemble.
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
Supprimer un élément de l’ensemble :discard(), remove(), pop(), clear()
Utilisez les méthodes de suppression (), remove (), pop () et clear () pour supprimer un élément de l’ensemble.
La méthode de suppression () supprime l’élément spécifié par l’argument. Si une valeur qui n’existe pas dans l’ensemble est spécifiée, aucune action n’est entreprise.
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
La méthode remove() supprime également l’élément spécifié par l’argument, mais elle génère une erreur KeyError si une valeur qui n’existe pas dans l’ensemble est spécifiée.
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
La méthode pop() supprime un élément de l’ensemble et renvoie sa valeur. Vous ne pouvez pas choisir les valeurs à supprimer. Il lève une erreur KeyError si l’ensemble est vide.
s = {2, 1, 0}
v = s.pop()
print(s)
print(v)
# {1, 2}
# 0
s = {2, 1, 0}
print(s.pop())
# 0
print(s.pop())
# 1
print(s.pop())
# 2
# print(s.pop())
# KeyError: 'pop from an empty set'
La méthode clear() supprime tous les éléments de l’ensemble et le vide.
s = {0, 1, 2}
s.clear()
print(s)
# set()
Syndicat:| operator, union()
Vous pouvez obtenir l’union avec le | l’opérateur ou la méthode union().
s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}
s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}
s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}
Plusieurs arguments peuvent être spécifiés pour union().
De plus, non seulement set mais aussi des listes et des tuples qui peuvent être convertis en set par set() peuvent être spécifiés comme arguments. Il en va de même pour les méthodes suivantes.
s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}
s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}
Intersection:& operator, intersection()
Vous pouvez obtenir l’intersection avec l’opérateur & ou la méthode intersection().
s_intersection = s1 & s2
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}
Différence:- operator, difference()
Vous pouvez obtenir la différence avec l’opérateur – ou la méthode difference().
s_difference = s1 - s2
print(s_difference)
# {0}
s_difference = s1.difference(s2)
print(s_difference)
# {0}
s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}
Différence symétrique :^ operator, symmetric_difference()
Vous pouvez obtenir la différence symétrique avec l’opérateur ^ ou symmetric_difference().
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
Testez si A est un sous-ensemble de B :<= operator, issubset()
Pour tester si A est un sous-ensemble de B, c’est-à-dire si tous les éléments de A sont contenus dans B, utilisez l’opérateur <= ou la méthode issubset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
L’opérateur <= et la méthode issubset() renvoient True pour les ensembles équivalents.
Pour tester si un ensemble est un sous-ensemble approprié, utilisez l’opérateur <, qui renvoie False pour les ensembles équivalents.
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
Testez si A est un sur-ensemble de B :>= operator, issuperset()
Pour tester si A est un sur-ensemble de B, c’est-à-dire si tous les éléments de B sont contenus dans A, utilisez l’opérateur >= ou issuperset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
L’opérateur >= et la méthode issuperset() renvoient True pour les ensembles équivalents.
Pour tester si un ensemble est un sur-ensemble approprié, utilisez l’opérateur >, qui renvoie False pour les ensembles équivalents.
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
Teste si A et B sont disjoints :isdisjoint()
Pour tester si A et B sont disjoints, c’est-à-dire si A et B n’ont pas d’éléments communs, utilisez la méthode isdisjoint().
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True