Les sets

Une vidéo de présentation des ensembles…

Les set sont des containers mutables non ordonnés qui possèdent les caractéristiques des ensembles mathématiques. En particulier, ils ne disposent pas d’éléments dupliqués. Ils se définissent à partir des opérateurs { et } ou du constructeur set:

>>> foot = set(['Angers', 'Bordeaux', 'Brest', 'Dijon', 'Lens', 'Lille', 'Lorient', 'Lyon', 'Marseille', 'Metz', 'Monaco', 'Montpellier', 'Nantes', 'Nice', 'Nimes', 'Paris', 'Reims', 'Rennes', 'Saint - Étienne', 'Strasbourg'])
>>> len(foot)
20

L’ordonnancement n’a pas de sens pour un set et n’est pas prédictible:

>>> foot
{'Marseille', 'Lille', 'Metz', 'Rennes', 'Nice', 'Nantes', 'Nimes', 'Strasbourg', 'Bordeaux', 'Dijon', 'Montpellier', 'Brest', 'Lorient', 'Reims', 'Lens', 'Paris', 'Monaco', 'Angers', 'Lyon', 'Saint - Étienne'}

Comme la list, le set est une séquence mutable. Il dispose donc de toutes les méthodes correspondantes à ce type de séquence. On peut donc en particulier le modifier une fois créé, par exemple retirer des éléments avec la méthode remove():

>>> foot.remove('Metz')
>>> len(foot)
19

ou en ajouter avec la méthode add():

>>> foot.add('Metz')
>>> len(foot)
20

Note

La sémantique est importante :

Une list étant un container ordonné, ajouter un élément c’est le placer à la fin, et à cette fin, on utilise le verbe append() ;
Un set étant un container non ordonné, ajouter un élément ne donne pas d’information de position, et à cette fin, on utilise le verbe add().

Le constructeur set prend en argument une séquence (une list pour ce qui concerne l’exemple ci dessus). Cette séquence peut éventuellement contenir des éléments dupliqués. Les doublons sont automatiquement éliminés.

A expérimenter…

Une chaîne de caractères (str) est une séquence et peut être utilisée pour construire un set. Conjecturer le résultat de l’opération suivante:

>>> f = set('football')

Vérifier dans un interpréteur interactif.

Le set est un conteneur non ordonné. La position ou l’ordre d’insertion des éléments n’est pas enregistré. En conséquence, les opérations d’indexation ou de slicing ne sont pas supportées:

>>> f[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

Les set ne peuvent contenir que des objets immutables, dont la structure ne peut pas être modifiée après création. Ces objets sont dits « hashables ». Les exemples ci dessus utilisent des chaînes de caractères. On peut également créer des set de nombres entiers:

>>> s = {0, 1, 2, 3, 4}
>>> s
{0, 1, 2, 3, 4}

Si l’on tente d’insérer un objet mutable dans un set, une exception de type TypeError est générée:

>>> s = {0, 1, 2, [3, 4]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Appartenance

Comme toutes les séquences, les set disposent de l’opérateur in:

>>>  basket = set(['Boulazac', 'Bourg-en-Bresse', 'Chalon/Saône', 'Cholet', 'Reims', 'Dijon', 'Gravelines', 'Levallois', 'Le Mans', 'Le Portel', 'Limoges', 'Monaco', 'Nanterre', 'Orléans', 'Pau', 'Roanne', 'Strasbourg', 'Villeurbane'])

>>>  'Limoges' in basket
True

>>>  'Limoges' in foot
False

Itérer sur un set

Le set étant également une séquence, l’opérateur in est utilisé pour l’itération:

>>> for elt in f:
...     print(elt)
...
a
b
o
f
t
l

Puisque le set ne supporte pas l’indexation, on ne peut itérer que sur les éléments. Inutile donc ici de préciser une bonne pratique, contrairement aux str, list et tuple.

Opérations ensemblistes

Les set disposent d’opérations ensemblistes puissantes et rapides :

intersection
union
différence
inclusion
etc…

>>>  rugby = set(['Agen', 'Bayonne', 'Bordeaux', 'Brive', 'Castres', 'Clermont', 'La Rochelle', 'Lyon', 'Montpellier', 'Pau', 'Racing 92','Paris', 'Toulon', 'Toulouse'])

La méthode intersection() est utilisée pour calculer l’intersection de deux ou plusieurs set. L’opérateur & permet une écriture plus lisible:

>>> foot & rugby # intersection
{'Paris', 'Montpellier', 'Bordeaux', 'Lyon'}

La méthode union() est utilisée pour calculer l’union de deux ou plusieurs set. L’opérateur | permet une écriture plus lisible:

>>> foot | rugby
{'Marseille', 'Monaco', 'Lille', 'Metz', 'Dijon', 'Pau', 'Agen', 'Clermont', 'Montpellier', 'Racing 92', 'Rennes', 'Bayonne', 'Brive', 'Nice', 'Nantes', 'Brest', 'Toulouse', 'Lorient', 'Castres', 'Nimes', 'La Rochelle', 'Reims', 'Lens', 'Paris', 'Toulon', 'Strasbourg', 'Angers', 'Lyon', 'Saint - Étienne', 'Bordeaux'}

La méthode difference() est utilisée pour calculer la différence de deux ou plusieurs set. L’opérateur - permet une écriture plus lisible:

>>> rugby - foot - basket # difference
{'Toulouse', 'Castres', 'Agen', 'Clermont', 'La Rochelle', 'Racing 92', 'Toulon', 'Bayonne', 'Brive'}

La méthode symetric_difference() est utilisée pour calculer la différence symétrique (des éléments appartenant à l’un ou à l’autre mais pas aux deux) de deux set. L’opérateur ^ permet une écriture plus lisible:

>>> rugby ^ foot
{'Marseille', 'Monaco', 'Lille', 'Metz', 'Dijon', 'Pau', 'Agen', 'Clermont', 'Racing 92', 'Rennes', 'Bayonne', 'Brive', 'Nice', 'Nantes', 'Brest', 'Toulouse', 'Lorient', 'Castres', 'Nimes', 'La Rochelle', 'Reims', 'Lens', 'Toulon', 'Strasbourg', 'Angers', 'Saint - Étienne'}

Pour une meilleure compréhension de la manipulation des set, on consultera les méthodes dédiées.

Les “set comprehension”

Comme pour les listes, on peut construire un set de façon concise avec un set comprehension

>>> {x*y for x in {1,2,3} for y in {2,3,4} if x != y}
{2, 3, 4, 6, 8, 12}

Chaque fois que ce sera possible cette syntaxe devra être utilisée.

Ce qu’il faut retenir

Un set se délimite avec [ et ]
Un set se délimite avec ( et )
Un set se délimite avec { et }
Un set peut contenir des objets hétérogènes
Un set peut contenir des objets mutables
Un set est mutable
Un set est une collection ordonnée
Les opérations de slicing sur un set sont possibles
Une fois créée, la taille d’un set est figée
est une méthode permettant d’insérer un élément dans un set
Il est possible d’insérer un élément à la fin d’un set
est une méthode permettant de supprimer un élément d’un set
Le constructeur d’un set prend en paramètre une séquence
Le slicing peut être utilisé pour extraire des éléments d’un set
Le slicing peut être utilisé pour insérer des éléments dans un set
Sur un set, l’opérateur d’appartenance in fonctionne comme pour toute séquence
On peut parcourir un set en itérant sur ses éléments
On peut parcourir un set en itérant sur l’index de ses éléments
Un set peut contenir n’importe quel objet Python
On peut construire des sets imbriqués
Un est une façon concise de construire un set