DESCRIPTION.

Créer un objet séquence, ou collection, qui contient un ensemble muable de valeurs pouvant être de toutes natures d'objets valides. 

SYNTAXE.

ESB_Ensemble = { valeura , ... , valeurn }

ESB_Ensemble ⇨ Nom de la variable [ OBLIGATOIRE ]

= ⇨ affectation de l'ensemble à la variable [ OBLIGATOIRE ]

{ } ⇨ création d'une instance de set ( ) [ OBLIGATOIRE ]

valeura , ... , valeurn ⇨ éléments de l'ensemble [ optionnel ]

ESB_Ensemble = set ( iterable )

ESB_Ensemble ⇨ Nom de la variable [ OBLIGATOIRE ]

= ⇨ affectation de l'ensemble à la variable [ OBLIGATOIRE ]

set ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

iterable ⇨ objet itérable contenant les valeurs [ optionnel ]

REMARQUES.

valeur peut être n'importe quel objet valide de Python pouvant être comparé, mais non muable. 

iterable doit être un objet collection, ou séquence, nom muable tel que : tuple ( ), bytes ( ) , str ( ) ou set ( ).

Python gère de nombreux types d'objets_variables. Certains sont des collections de valeurs regroupées au sein d'un même objet_variable. Les ensembles, set ( ),  sont des objets_variables composites, comme les listes, où l'on peut enregistrer des valeurs dans un ordre quelconque.

Python propose 2 types d'ensembles, set ( ) et frozenset ( ). On peut les considérer comme des dict ( ) où les valeurs ne sont pas associées à une clé. Le type set ( ) est muable, comme les objets de type list ( ), le nombre de ses éléments peut changer. Le type frozenset ( ) est immuable, les objets de type tuple ( ), le nombre de ses éléments ne peut pas changer. L'avantage des objets ensembles est leur rapidité dans les comparaisons d'ensembles par rapport aux objet list ( ), tuple ( ), dict ( ), ... En contrepartie, la gestion de leurs éléments, recherche et tri par exemple, est plus ardue, du fait qu'ils ne peut pas être indexés.

Comme il est muable, il n'a pas de valeur de hachage, un set ( ) ne peut servir de clef dans un dict ( ) ou comme élément d'un autre ensemble. 

L'ordre d'entrée, et la position, des éléments dans un set ( ) n'est pas mémorisé. Il n'est donc pas possible d'appeler ou d'identifier l'un des éléments d'un set ( ) par un index, ni de retourner un sous-ensemble d'un set ( ) par une méthodes de tranchages (slicing) comme pour les list ( ) et les tuple ( ).

Les instances de set ( ) sont des objets itérables et mutables.

valeur peut être une référence à n'importe quel objet valide dans Python.

Dans la forme ESB_Ensemble = set ( iterable ), iterable peut prendre de nombreuses formes, faisant parfois intervenir des méthodes builtin pour sa constitution. 

Bien qu'étant un raccourcit, la forme de création ESB_Ensemble = { valeura , ... , valeurn } est à privilégier.

Les variables globales de type set ( ) sont identifiées dans le site par : ESB_. 

Voir les conventions sur les variables utilisées dans ce site ...

CRÉER UN ENSEMBLE MUTABLE.

Pour créer un nouveau set ( ), Il suffit de le déclarer par une paire d'accolades et de lui ajouter des valeurs séparées par des virgules.

ESB_Premiers = { 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 }

print ( ESB_Premiers ) retourne {2, 3, 5, 7, 11, 13, 17, 19, 23}

print ( type ( ESB_Premiers ) ) retourne <class 'set'>

ou utiliser le constructeur de classe.

ESB_Couleurs = set ( { "noir" , "rouge" , "vert" , "jaune" , "bleu" , "fushia" , "cyan" , "blanc" } )

print ( ESB_Couleurs ) retourne {'bleu', 'rouge', 'jaune', 'fushia', 'cyan', 'vert', 'noir', 'blanc'}

print ( type ( ESB_Couleurs ) ) retourne <class 'set'> 

Il faudra d'ailleurs procéder de cette façon si l'on souhaite obtenir un set ( ) vide. La présence d’accolades vides créant un objet dict ( ).

ktemporaire = { }

print ( type ( ktemporaire ) ) retourne<class 'dict'>

ktemporaire = set ( { } ) 

print ( type ( ktemporaire ) ) retourne <class 'set'>

On peut aussi utiliser les méthodes de remplissage traditionnelles pour leur création, mais toujours avec le constructeur de classe set ( ).

ESB_Suite = set ( range ( 5 , 21 , 2 ) )

print ( ESB_Suite ) retourne {5, 7, 9, 11, 13, 15, 17, 19}

ESB_Carrees = set ( kmonbre * kmonbre for kmonbre in range ( 11 ) )

print ( ESB_Carrees ) retourne {0, 1, 64, 4, 36, 100, 9, 16, 49, 81, 25}

ESB_Pairs = set ( kvaleur for kvaleur in range ( 31 ) if kvaleur % 2 == 0 )

print ( ESB_Pairs ) retourne {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}

Il est aisé de convertir une collection de type list ( ), tuple ( ) ou dict ( ) en set ( ).

LST_Premiers = [ 1 , 2 , 3 , 5 , 7 , 9 ]

ESB_Premiers = set ( LST_Premiers )

print ( LST_Premiers ) retourne [1, 2, 3, 5, 7, 9]

print ( ESB_Premiers ) retourne {1, 2, 3, 5, 7, 9}

print ( type ( LST_Premiers ) ) retourne <class 'list'>

print ( type ( ESB_Premiers ) ) retourne <class 'set'>

Dans un set ( ) tous les éléments doivent avoir des valeurs différentes.

LST_Points = [ 1 , 1 , 0 , 2 , 0 , 1 , 2 ]

ESB_Points = set ( LST_Points )

print ( LST_Points ) retourne [1, 1, 0, 2, 0, 1, 2]

print ( ESB_Points ) retourne {0, 1, 2}. 

ESB_Lettres = set ( "Cela est très pratique pour trouver quelles lettres composent une phrase" )

print ( ESB_Lettres ) retourne {'t', 'o', 'u', 'r', 'p', 'n', 'q', 'i', 'v', 'l', 'h', 's', 'm', 'a', 'c', ' ', 'e', 'C', 'è'}

Pour connaitre le nombre d'éléments dans un set ( ), on utilise la méthode len ( ).

ESB_Couleurs = set ( { "noir" , "rouge" , "vert" , "jaune" , "bleu" , "fushia" , "cyan" , "blanc" } )

print ( len ( ESB_Couleurs ) ) retourne 8

Pour savoir si une valeur est présente dans un set ( ), on utilise l'opérateur in. Si la valeur est un élément de l'ensemble, l'expression retourne True, sinon c'est False.

ESB_Couleurs = set ( { "noir" , "rouge" , "vert" , "jaune" , "bleu" , "fushia" , "cyan" , "blanc" } )

print ( "vert" in ESB_Couleurs ) retourne True

print ( "orange" in ESB_Couleurs ) retourne False

Pour savoir si une valeur est absente d'un set ( ), on utilise l'opérateur not in. Si la valeur est un élément de l'ensemble, l'expression retourne False, sinon c'est True.

ESB_Couleurs = set ( { "noir" , "rouge" , "vert" , "jaune" , "bleu" , "fushia" , "cyan" , "blanc" } )

print ( "vert" not in ESB_Couleurs ) retourne False

print ( "orange" not in ESB_Couleurs ) retourne True

MODIFIER UN ENSEMBLE MUTABLE.

Pour ajouter un élément à un set ( ), on utilise la méthode .add ( ).

ESB_Premiers = { 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 }

print ( ESB_Premiers ) retourne {2, 3, 5, 7, 11, 13, 17, 19, 23}

ESB_Premiers.add ( 29 )

print ( ESB_Premiers ) retourne {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}

ESB_Premiers.add ( 31 , 37 , 41 ) retourne TypeError: add() takes exactly one argument (3 given)

Pour ajouter plusieurs éléments on peut utiliser une boucle. Par exemple :

ESB_Premiers = { 2 , 3 , 5 }

for ksuivant in ( 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 ) :

ESB_Premiers.add ( ksuivant )

print ( ESB_Premiers ) retourne {2, 3, 5, 37, 7, 41, 11, 43, 13, 17, 19, 23, 29, 31}

Pour ajouter tous les éléments d'un ou de plusieurs autres ensembles dans un set ( ), on utilise la méthode .update ( ).

ESB_Tous = set ( { } )

ESB_Pairs = { 0 , 2 , 4 , 6 , 8 }

ESB_Premiers = { 2 , 3 , 5 }

ESB_Factoriels = { 1 , 2 , 6 , 24 }

ESB_Tous.update ( ESB_Pairs )

print ( ESB_Tous ) retourne {0, 2, 4, 6, 8}

ESB_Tous.update ( ESB_Premiers )

print ( ESB_Tous ) retourne {0, 2, 3, 4, 5, 6, 8}

print ( ESB_Premiers ) retourne {2, 3, 5}

ESB_Tous.update ( ESB_Factoriels )

print ( ESB_Tous ) retourne {0, 1, 2, 3, 4, 5, 6, 8, 24}

Pour supprimer tous les éléments d'un set ( ), on utilise la méthode .clear ( ).

ESB_Premiers = { 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 }

print ( ESB_Premiers ) retourne {2, 3, 5, 7, 11, 13, 17, 19, 23}

ESB_Premiers.clear ( )

print ( ESB_Premiers ) retourne set()

Pour supprimer une valeur dont la présence est certaine dans un set ( ), on utilise la méthode .remove ( ).

ESB_Jours = { "lundi" , "mardi" , "mercredi" , "jeudi" , "vendredi" , "samedi" , "dimanche" }

print ( ESB_Jours ) retourne {'samedi', 'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi', 'dimanche'}

ESB_Jours.remove ( "samedi" )

print ( ESB_Jours ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi', 'dimanche'}

ESB_Jours.remove ( "dimanche" )

print ( ESB_Jours ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi'}

ESB_Jours.remove ( "monday" )

print ( ESB_Jours ) retourne KeyError: 'monday'

Pour supprimer une valeur si elle est présente dans un set ( ), on utilise la méthode .discard ( ).

ESB_Jours = { "lundi" , "mardi" , "mercredi" , "jeudi" , "vendredi" , "samedi" , "dimanche" }

print ( ESB_Jours ) retourne {'samedi', 'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi', 'dimanche'}

ESB_Jours.discard ( "samedi" )

print ( ESB_Jours ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi', 'dimanche'}

ESB_Jours.discard ( "dimanche" )

print ( ESB_Jours ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi'}

ESB_Jours.discard ( "monday" )

print ( ESB_Jours ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi'}

Pour supprimer aléatoirement un élément d'un set ( ), et retourner sa valeur, on utilise la méthode .pop ( ).

ESB_Jours = { "lundi" , "mardi" , "mercredi" , "jeudi" , "vendredi" , "samedi" , "dimanche" }

print ( ESB_Jours ) retourne {'samedi', 'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi', 'dimanche'}

ESB_Jours.pop ( )

print ( ESB_Jours ) retourne {'jeudi', 'mercredi', 'lundi', 'vendredi', 'mardi', 'dimanche'}

print ( ESB_Jours.pop ( ) ) jeudi

kretrait = ESB_Jours.pop ( ) mercredi

print ( kretrait ) retourne {'jeudi', 'mardi', 'lundi', 'vendredi', 'mercredi'}

print ( ESB_Jours ) retourne {'lundi', 'vendredi', 'mardi', 'dimanche'}

ESB_Jours.clear ( )

ESB_Jours.pop ( ) retourne KeyError: 'pop from an empty set'