builtins.object builtins.set
class set(builtins.object):
set
représente un ensemble de valeur non ordonnées et sans doublons de valeurs.
Pour définir un set vide, il faut passer par le constructeur de la classe set
.
>>> empty_set = set() >>> type(empty_set) <class 'set'> >>> empty_set set() >>> len(empty_set) 0 >>>
data = {}
définie un dictionnaire et non un set. Il est donc obligatoire de passer par le constructeur de la classe.
Vous pouvez aussi définir un set avec des valeurs initiales : dans ce cas, elles doivent être placées entre une paire d'accolades. Voici deux exemples de définition de sets, avec des types de données différents : notez la disparition des données en double.
>>> data = {"c", "c++", "java", "python", "perl", "python", "java"} >>> type(data) <class 'set'> >>> data {'python', 'c++', 'java', 'perl', 'c'} >>> len(data) 5 >>> data = {10, 20, 30, 40, 50, 60, 10, 20, 30, 40, 50, 60} >>> data {50, 20, 40, 10, 60, 30} >>>
Ce qui est remarquable, lors des affichages des sets, c'est que les données ne se retrouvent pas dans l'ordre initial.
Cela est dû au fait, que le type set
organisme à sa manière les données afin de pouvoir très rapidement savoir si une donnée est déjà
présente ou non dans le set. Vous ne pouvez donc pas simplement influer sur l'ordonnancement des données d'un set.
Un set peut contenir des données de différentes natures. Voici un exemple contenant des entiers, des flottants, des chaînes de caractères...
>>> data = {10, 3.14, "essai", 10, 20, True, 3.14} >>> data {True, 3.14, 20, 'essai', 10} >>>
Vous pouvez savoir si une donnée est présente dans un set, ou non, en utilisant l'opérateur in
.
>>> data = {10, 20, 30, 10, 20, 30, 40} >>> 20 in data True >>> 50 in data False >>>
A contrario, vous pouvez vérifier si une information n'est pas présente dans la collection avec l'opérateur not in
.
Voici des exemples d'utilisation.
>>> data = {10, 20, 30, 10, 20, 30, 40} >>> 20 not in data False >>> 25 not in data True >>>
Pour ajouter une valeur dans un set, après sa construction, vous devez utiliser la méthode add
.
Voici un exemple d'utilisation
>>> data = {10, 20, 30, 10, 20, 30, 10, 20, 30, 40} >>> data {40, 10, 20, 30} >>> data.add(50) >>> data {40, 10, 50, 20, 30} >>> data.add(60) >>> data {40, 10, 50, 20, 60, 30} >>> data.add(50) # Donnée déjà existante >>> data {40, 10, 50, 20, 60, 30} >>>
Pour supprimer une données d'un set, vous pouvez utiliser la méthode remove
.
KeyError
sera déclenchée.
>>> s = {10, 20, 30, 10, 20, 30, 10, 20, 30, 40} >>> s {40, 10, 20, 30} >>> s.remove(20) >>> s {40, 10, 30} >>> s.remove(50) Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 50 >>>
Si vous souhaitez supprimer toutes les valeurs présentes dans un set, vous pouvez aussi invoquer la méthode
clear
.
>>> data = {10, 20, 30, 40, 50} >>> data.clear() >>> data set() >>>
Vous pouvez utiliser une boucle for
pour parcourir toutes les données d'un set.
1 2 3 4 5 6 7 |
data = {10, 20, 30, 10, 20, 30, 10, 20, 30, 40, 50} # On traite chaque élément du set, un par un for value in data: print(value) print("Parcours du set terminé") |
Et voici le résultat produit par l'exemple ci-dessus.
50 20 40 10 30 Parcours du set terminé
A l'instar des listes en compréhention, il est possible de définir le contenu d'un set par un algorithme : voici quelques exemples d'utilisation. On parle d'ensemble (de set) en compréhention.
>>> s = {x ** 2 for x in range(10)} >>> s {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} >>> 128 in s False >>> >>> languages = ["Python", "Java", "Python", "C", "C++", "Java", "Perl", "Ada"] >>> final = {lang.upper() for lang in languages if lang[0] == "P"} >>> for lang in final: ... print(lang) ... PERL PYTHON >>>
Le concept de set en Python est très proche de la notion d'ensemble dans la théorie des ensembles. D'ailleurs la traduction du mot anglais set en
français est bien ensemble. Du coup, la classe set
reprend quelques opérations définies dans la théorie des ensembles.
L'union de deux ensembles consiste à fusionner les données de deux ensembles tout en garantissant de ne pas avoir de valeurs en doublons.
Le langage Python propose l'opérateur |
pour réaliser l'union de deux ensembles. Voici un exemple d'utilisation.
>>> s1 = {"java", "python", "java", "ada"} >>> s1 {'java', 'python', 'ada'} >>> s2 = {"c", "c++", "c#", "python"} >>> s2 {'c#', 'c++', 'python', 'c'} >>> all = s1 | s2 >>> all {'java', 'c', 'python', 'c++', 'ada', 'c#'} >>>
|
soient des sets.
Vous pouvez néanmoins réaliser l'union d'un set et d'une autre collection de nature quelconque : pour ce faire, il faudra privilégier la méthode
union
de la classe set
. Cela implique que la collection sur laquelle sera invoquée la méthode
est forcément un set.
L'intersection de deux ensembles consiste à ne conserver que les données présentes dans les deux ensembles.
Le langage Python propose l'opérateur &
pour réaliser l'intersection de deux ensembles. Voici un exemple d'utilisation.
>>> s1 = {"java", "python", "java", "ada"} >>> s1 {'ada', 'java', 'python'} >>> s2 = {"c", "c++", "c#", "python"} >>> s2 {'c++', 'c#', 'c', 'python'} >>> inter = s1 & s2 >>> inter {'python'} >>>
&
soient des sets.
Vous pouvez néanmoins réaliser l'intersection d'un set et d'une autre collection de nature quelconque : pour ce faire, il faudra privilégier la méthode
intersection
de la classe set
. Cela implique que la collection sur laquelle sera invoquée
la méthode est forcément un set.
La différence de deux ensembles consiste à ne conserver que les données du premier ensemble qui ne sont pas présentes dans le second.
Le langage Python propose l'opérateur -
pour réaliser l'intersection de deux ensembles. Voici un exemple d'utilisation.
>>> s1 = {10, 20, 30, 40} >>> s2 = {20, 40, 60} >>> diff = s1 - s2 >>> diff {10, 30} >>>
-
soient des sets.
Vous pouvez néanmoins calculer la différence d'un set et d'une autre collection de nature quelconque : pour ce faire, il faudra privilégier la méthode
difference
de la classe set
.
Cela implique que la collection sur laquelle sera invoquée la méthode est forcément un set.
Pour faire simple, la différence symétrique de deux ensembles est l'opposé de l'intersection de ces mêmes ensembles.
Dit autrement, cela permet de récupérer les valeurs distinctes n'appartenant qu'à un seul des deux ensembles.
En Python, vous pouvez obtenir cette opération via l'opérateur ^
.
>>> s1 = {10, 20, 30, 40} >>> s2 = {20, 30, 40, 50} >>> sym_diff = s1 ^ s2 >>> sym_diff {10, 50} >>>
^
soient des sets.
Vous pouvez néanmoins calculer la différence symétrique d'un set et d'une autre collection de nature quelconque : pour ce faire, il faudra privilégier la
méthode symmetric_difference
de la classe set
.
Cela implique que la collection sur laquelle sera invoquée la méthode est forcément un set.
set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from random import randint # On prépare une collection de 20 entiers compris en 0 et 19. data = [] for i in range(20): data.append(randint(0, 20)) # On extrait les différentes valeurs présentes dans la collection. values = set(data) print("data collections contains", len(values), "disctinct values") # On affiche le nombre d'occurrences pour chaque valeur. for value in values: print(value, "appears", data.count(value), "time(s).") |
Et voici les résultats produits par cet exemple.
$> python3 sample.py data collections contains 9 disctinct values 0 appears 5 time(s). 2 appears 1 time(s). 4 appears 3 time(s). 10 appears 1 time(s). 13 appears 2 time(s). 14 appears 2 time(s). 15 appears 3 time(s). 17 appears 2 time(s). 20 appears 1 time(s). $>
Signature du constructeur | Description |
---|---|
__new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. [extrait de __new__.__doc__] |
__init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. [extrait de __init__.__doc__] |
Signature de l'opérateur | Description |
---|---|
__and__(self, value) | Return self&value. [extrait de __and__.__doc__] |
__contains__ | x.__contains__(y) <==> y in x. [extrait de __contains__.__doc__] |
__eq__(self, value) | Return self==value. [extrait de __eq__.__doc__] |
__ge__(self, value) | Return self>=value. [extrait de __ge__.__doc__] |
__gt__(self, value) | Return self>value. [extrait de __gt__.__doc__] |
__iand__(self, value) | Return self&=value. [extrait de __iand__.__doc__] |
__ior__(self, value) | Return self|=value. [extrait de __ior__.__doc__] |
__isub__(self, value) | Return self-=value. [extrait de __isub__.__doc__] |
__ixor__(self, value) | Return self^=value. [extrait de __ixor__.__doc__] |
__le__(self, value) | Return self<=value. [extrait de __le__.__doc__] |
__lt__(self, value) | Return self<value. [extrait de __lt__.__doc__] |
__ne__(self, value) | Return self!=value. [extrait de __ne__.__doc__] |
__or__(self, value) | Return self|value. [extrait de __or__.__doc__] |
__rand__(self, value) | Return value&self. [extrait de __rand__.__doc__] |
__ror__(self, value) | Return value|self. [extrait de __ror__.__doc__] |
__rsub__(self, value) | Return value-self. [extrait de __rsub__.__doc__] |
__rxor__(self, value) | Return value^self. [extrait de __rxor__.__doc__] |
__sub__(self, value) | Return self-value. [extrait de __sub__.__doc__] |
__xor__(self, value) | Return self^value. [extrait de __xor__.__doc__] |
Signature de la méthode | Description |
---|---|
__class_getitem__ | See PEP 585 [extrait de __class_getitem__.__doc__] |
__getattribute__(self, name) | Return getattr(self, name). [extrait de __getattribute__.__doc__] |
__iter__(self) | Implement iter(self). [extrait de __iter__.__doc__] |
__len__(self) | Return len(self). [extrait de __len__.__doc__] |
__reduce__ | Return state information for pickling. [extrait de __reduce__.__doc__] |
__repr__(self) | Return repr(self). [extrait de __repr__.__doc__] |
__sizeof__ | S.__sizeof__() -> size of S in memory, in bytes [extrait de __sizeof__.__doc__] |
add | Add an element to a set. [extrait de add.__doc__] |
clear | Remove all elements from this set. [extrait de clear.__doc__] |
copy | Return a shallow copy of a set. [extrait de copy.__doc__] |
difference | Return the difference of two or more sets as a new set. [extrait de difference.__doc__] |
difference_update | Remove all elements of another set from this set. [extrait de difference_update.__doc__] |
discard | Remove an element from a set if it is a member. [extrait de discard.__doc__] |
intersection | Return the intersection of two sets as a new set. [extrait de intersection.__doc__] |
intersection_update | Update a set with the intersection of itself and another. [extrait de intersection_update.__doc__] |
isdisjoint | Return True if two sets have a null intersection. [extrait de isdisjoint.__doc__] |
issubset | Report whether another set contains this set. [extrait de issubset.__doc__] |
issuperset | Report whether this set contains another set. [extrait de issuperset.__doc__] |
pop | Remove and return an arbitrary set element. [extrait de pop.__doc__] |
remove | Remove an element from a set; it must be a member. [extrait de remove.__doc__] |
symmetric_difference | Return the symmetric difference of two sets as a new set. [extrait de symmetric_difference.__doc__] |
symmetric_difference_update | Update a set with the symmetric difference of itself and another. [extrait de symmetric_difference_update.__doc__] |
union | Return the union of sets as a new set. [extrait de union.__doc__] |
update | Update a set with the union of itself and others. [extrait de update.__doc__] |
Améliorations / Corrections
Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.
Emplacement :
Description des améliorations :