Participer au site avec un Tip
Rechercher
 

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 :

Module « builtins »

Classe « set »

Informations générales

Héritage

builtins.object
    builtins.set

Définition

class set(builtins.object):

Description

La classe set représente un ensemble de valeur non ordonnées et sans doublons de valeurs. Diverses opérations sont possibles sur vos sets : ajout de données, suppression de données, recherche de données... Les sets proposent également des opérations mathématiques telles que les unions, les intersections, les différences et différences symétriques d'ensembles.

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
>>> 
Exemple de définition d'un set vierge.
la syntaxe 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}
>>> 
Exemple de définitions de sets avec des données de différents types.

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}
>>> 
Exemple de définitions d'un set avec des données hétérogènes.

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
>>> 
Utilisation de l'opérateur in

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}
>>>
Exemple d'ajout de valeurs dans un set.

Pour supprimer une données d'un set, vous pouvez utiliser la méthode remove.

si la donnée à supprimer n'est pas présente dans la collection, une exception de type 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é")
Fichier sample.py : exemple de parcours d'un set avec une boucle for

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#'}
>>> 
cet opérateur nécessite que les deux opérandes (les deux parties) de l'opérateur | 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'}
>>> 
cet opérateur nécessite que les deux opérandes (les deux parties) de l'opérateur & 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}
>>> 
cet opérateur nécessite que les deux opérandes (les deux parties) de l'opérateur - 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}
>>> 
cet opérateur nécessite que les deux opérandes (les deux parties) de l'opérateur ^ 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.

Description [extrait de set.__doc__]

set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.

Exemple(s) de code

 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).")
Exemple d'utilisation de la class set.

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).
$> 

Constructeur(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__]

Liste des opérateurs

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__]

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
__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__]

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __hash__, __init_subclass__, __reduce_ex__, __setattr__, __str__, __subclasshook__

Voir aussi

Classe list
Classe dict
Classe tuple

Fonction len
Fonction max
Fonction min
Fonction sum