Les ensembles Python ou set – données non ordonnés

Les ensembles Python ou set sont une structure de données mutable, itérable et qui ne contient aucun élément en double. Il s’agit d’une collection d’éléments non ordonnés, c’est une collection qui stocke des éléments de différents types de données Python. Bien qu’un ensemble lui-même soit mutable, ses éléments doivent être immuables.

Par ailleurs, un ensemble en Python n’indexe pas les éléments dans un ordre particulier.

Les ensembles Python sont généralement utilisés pour exécuter certaines fonctions mathématiques telles que l’union, l’intersection, etc.

En outre, dans les ensembles Python, les éléments n’ont pas d’ordre spécifique.

Créer un ensemble Python

Vous pouvez créer un ensemble en mettant tous les éléments entre accolades {} ou en utilisant la fonction set(). Un ensemble peut contenir des éléments de différents types de données tels que float, tuple, string ou integer. Il ne peut cependant pas contenir un élément mutable tel qu’un dictionnaire, une liste ou un ensemble. Une virgule est utilisée pour séparer les éléments les uns des autres.

# un set contenant différents types de données
>>> mon_set = {5.0, "Python", (5, 4, 2), 6}
>>> mon_set
{'Python', (5, 4, 2), 5.0, 6}

Créer un ensemble Python en utilisant la fonction set(). Notez les doubles parenthèses dans cet exemple.

>>> mon_set = set(("pomme", "banane", "fraise"))
>>> mon_set
{'pomme', 'banane', 'fraise'}

Créer un ensemble à partir d’une liste Python.

>>> set([5, 4, 3, 2 ])
{2, 3, 4, 5}

Et surtout, pas de doublons. Python les supprimera automatiquement.

>>> {1, 3, 9, 1, 4, 3}
{1, 3, 4, 9}

Pour créer un ensemble vide, on utilise la fonction set() sans arguments. Vous ne pouvez pas utiliser d’accolades vides, car il s’agit de la syntaxe pour créer un dictionnaire vide.

>>> mon_set = set()
>>> type(mon_set)
<class 'set'>
>>> mon_set
set()

Modifier les éléments d’un ensemble Python

Étant donné que les ensembles ne sont pas ordonnés, vous ne pouvez pas accéder ou modifier un ou plusieurs éléments via l’indexation ou le découpage comme vous l’avez fait précédemment avec des chaînes de caractères et des listes.

Toutefois, vous pouvez modifier les éléments d’un ensemble avec les méthodes.

add() : ajoute un seul élément à un ensemble.
update() : ajoute plusieurs éléments.

>>> mon_set = { "a" , "b" , "c" }
>>> mon_set.add("d")
>>> mon_set
{'b', 'c', 'd', 'a'}
>>> mon_set.update("e","f")
>>> mon_set
{'d', 'c', 'f', 'b', 'a', 'e'}

Suppression d’éléments d’un ensemble

Les méthodes remove() et discard() sont utilisées pour supprimer un élément spécifique d’un ensemble.
La seule différence entre les deux méthodes est leur réponse à un argument inexistant.
remove() déclenche une erreur, par contre avec discard(), l’ensemble reste simplement inchangé.

>>> mon_set.remove('a')
>>> mon_set
{'d', 'c', 'f', 'b', 'e'}
>>> mon_set.discard('b')
>>> mon_set
{'d', 'c', 'f', 'e'}

pop() est également utilisée pour supprimer et renvoyer l’élément supprimé. Puisque l’ensemble n’est pas ordonné, vous ne pouvez pas contrôler quel élément sera supprimé. La sélection est arbitraire.

>>> mon_set.pop()
'd'
>>> mon_set
{'c', 'f', 'e'}

clear() pour supprimer tous les éléments d’un ensemble.

>>> mon_set.clear()
>>> mon_set
set()

Les opérations sur les ensembles Python

union() : le résultat est une combinaison de tous les éléments, renvoyés dans un ordre croissant. En outre, vous pouvez utiliser l’opérateur |.

>>> A = {3, 5, 7}
>>> B = { "a" , "b" , "c" }
>>> A|B
{3, 'b', 5, 'a', 7, 'c'}
>>> A.union(B)    # B.union(A)
{3, 'b', 5, 'a', 7, 'c'}

intersection() : les éléments communs entre deux ensembles. Elle est également possible avec l’opérateur &.

>>> A = {3, 5, 7}
>>> B = { "a" , "b" , "c" , 3, 5}
>>> A & B
{3, 5}
>>> A.intersection(B)
{3, 5}

difference() : la différence entre deux ensembles fait référence à un ensemble d’éléments qui se trouvent dans un ensemble mais pas dans l’autre.

# dans A, mais pas dans B
>>> A.difference(B)
{7}
>>> A - B
{7}

# dans B, mais pas dans A
>>> B - A
{'b', 'c', 'a'}
>>> B.difference(A)
{'b', 'c', 'a'}

symmetric_difference() : les éléments non-communs entre les deux ensembles. Elle est également possible avec l’opérateur ^.

>>> A = {3, 5, 7}
>>> B = { "a" , "b" , "c" , 3, 5}
>>> A ^ B
{7, 'c', 'a', 'b'}
>>> A.symmetric_difference(B)
{7, 'c', 'a', 'b'}
>>> B ^ A
{7, 'b', 'c', 'a'}
>>> B.symmetric_difference(A)
{7, 'b', 'c', 'a'}

copy() : renvoie une copie de l’ensemble.

>>> C = A.copy()
>>> C
{3, 5, 7}

in et not in pour tester l’appartenance.

>>> 3 in A
True
>>> 5 not in A
False

Les fonctions intégrées avec avec les ensembles Python

len() : elle renvoie le nombre d’éléments d’un ensemble.

>>> len(A)
3

max() : renvoie le plus grand élément d’un ensemble.

>>> max(A)
7

min() : cette méthode renvoie le plus petit élément d’un ensemble.

>>> min(A)
3

sorted() : renvoie une liste triée d’éléments d’un ensemble.

>>> A = {3, 5, 7, 2, 0}
>>> sorted(A)
[0, 2, 3, 5, 7]

enumerate() : renvoie un objet enumerate, qui contient la valeur et l’index de tous les éléments de l’ensemble.

>>> enumerate(A)
<enumerate object at 0x7f2875c5b940>

>>> for i in enumerate(A):
	print(i)
	
(0, 3)
(1, 5)
(2, 7)

frozenset() : frozen, qui veut dire gelé.
Donc, nous aurons un ensemble python gelé. Par conséquent, les éléments ne peuvent pas être modifiés, ils sont devenus immuables. En fait, un frozenset est essentiellement la version inchangeable ou immuable de l’objet set.

>>> malist = ['a', 'b', 'c']
>>> x = frozenset(malist)
>>> x[1] = "d"
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    x[1] = "d"
TypeError: 'frozenset' object does not support item assignment

En fin, pour afficher les attributs et les méthodes de l’objet set, utilisez la fonction dir().

>>> dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']