Chap1-part6-set

Chapitre 1 - Partie 5 : Les ensembles (sets)

Les collections non ordonnées (suite)

Contenu

• Les ensembles
  • Réunion
  • Intersection
  • Différence
  • Différence symétrique
  • Autres fonctions utiles
  • Synthèse

Les ensembles¶

Les ensembles font partie de la catégorie des types d'objets de collections non ordonnées.

Tout comme le dictionnaire dict, un ensemble `set' contient une collection de clés uniques mais sans les valeurs associées.

• Chaque élément dans set est unique : il n'y a pas de doublons

• Chaque élément dans set est immuable : l'élément lui-même (la clè) n'est pas modifiable

  • On ne peut pas former des ensembles de listes, car les éléments des listes peuvent être modifiés.
  • On peut faire des ensembles de nombres, de chaînes de caractères ou de tuples.

• dans set, il n’a pas d’ordre (les éléments ne sont pas indexés)

• le set des opérations sur les ensembles, comme en algèbre :

  • union
  • intersection
  • soustraction
  • différence
  • différence symétrique

Création¶

Comme le dictionnaire, un ensemble peut être construit en utilisant une paire d'accolades {} entre lesquelles on insère des éléments clés séparés par des virgules.

s = {clé1, clé2, ...}

Attention ! dans ce cas, si on ne met rien entres les deux accolades, l'ensemble sera considéré comme un dictionnaire vide (de type dict et non pas set).

Afin de s'assurer qu'on crée bien une variable de type set, en utilise la fonction set() qui prend en argument une variable séquence (un itérable) qui peut être vide ou non. On utilise donc le transtypage (casting).

In [20]:

# création d'un set vide
s1 = set()        # aucun argument
s2 = set('')      # argument : str vide
s3 = set({})      # argument : dict vide
s4 = set([])      # argument : list vide
s5 = set(())      # argument : tuple vide

s6 = {}    # Attention ça crée un dict vide et pas un set vide

print(f'{s1 = } : {type(s1)}')
print(f'{s2 = } : {type(s2)}')
print(f'{s3 = } : {type(s3)}')
print(f'{s4 = } : {type(s4)}')
print(f'{s5 = } : {type(s5)}')
print(f'{s6 = } : {type(s6)}')

s1 = set() : <class 'set'>
s2 = set() : <class 'set'>
s3 = set() : <class 'set'>
s4 = set() : <class 'set'>
s5 = set() : <class 'set'>
s6 = {} : <class 'dict'>

In [1]:

# Ensemble non vide avec accolades {}
s1 = {4, 1.5, 'a', 'txt'}   # éléments entre accolades 
                            # il n'y a que des clés !

# Avec le casting (transtypage)

s2 = set('abcd') # argument : str 
                 # chaque character devient un élément de s1

s3 = set([1, 1.23, "a", "mot"])   # argument : list  

s4 = set((1, 3, "a", 'b', 'a'))              # argument : tuple 

print(f"s1 = {s1!s:<25} {type(s1)}")
print(f"s2 = {s2!s:<25} {type(s2)}")
print(f"s3 = {s3!s:<25} {type(s3)}")
print(f"s4 = {s4!s:<25} {type(s4)}")

s1 = {'txt', 1.5, 4, 'a'}      <class 'set'>
s2 = {'d', 'b', 'a', 'c'}      <class 'set'>
s3 = {1, 'mot', 'a', 1.23}     <class 'set'>
s4 = {1, 'b', 3, 'a'}          <class 'set'>

Remarque

1. A noter que dans l'affichage, l'ordre des éléments n'est pas toujours respecté. Dans un ensemble set, tout comme dans un dictionnaire, l'ordre dans lequel les éléments sont énumérés lors est imprévisible, puisqu'il n'y a pas de notion d'ordre.

2. A noter aussi que dans le set s4, le doublon 'a' a été supprimé. C'est un des avantages de set.

Opérations sur les sets¶

Union¶

Comme la fusion de dictionnaires, l'union de deux ou de plusieurs ensembles se fait à l'aide de l'opérateur |. Il produit un ensemble qui regroupe tous les éléments des ensembles unis.

In [20]:

A = {'g', 'ρ' , 'μ', 'λ'}
B = {'n', 'λ', 'σ','μ'}
C = {'λ','T','g','n'}
print(f"{A = } \n{B = } \n{C = }\n")

print(f"A \u222a B     : { A | B     = }")
print(f"A \u222a C     : { A | C     = }")
print(f"B \u222a C     : { B | C     = }")
print(f"A \u222a B \u222a C : { A | B | C = }")

A = {'λ', 'g', 'ρ', 'μ'} 
B = {'n', 'λ', 'σ', 'μ'} 
C = {'λ', 'T', 'n', 'g'}

A ∪ B     :  A | B     = {'λ', 'n', 'σ', 'ρ', 'g', 'μ'}
A ∪ C     :  A | C     = {'λ', 'T', 'n', 'ρ', 'g', 'μ'}
B ∪ C     :  B | C     = {'λ', 'T', 'n', 'σ', 'g', 'μ'}
A ∪ B ∪ C :  A | B | C = {'λ', 'T', 'n', 'σ', 'ρ', 'g', 'μ'}

L'union ($A \cup B$) : A|B donne l'ensemble qui contient tous les éléments des ensembles réunis A et B de départ.

Si un élément appartient à deux ensembles de départ, il ne sera comptabilisé qu'une fois dans l'ensemble produit par l'opérateur de réunion |.

Exemple : 'g' et 'sigma'.

Intersection¶

L'intersection de deux ou de plieurs ensembles se fait à l'aide de l'opérateur &, il produit un ensemble qui contient les éléments communs aux ensembles initiaux.

In [19]:

A = {'g', 'ρ' , 'μ', 'λ'}
B = {'n', 'λ', 'σ','μ'}
C = {'λ','T','g','n'}
print(f"{A = } \n{B = } \n{C = }\n")

print(f"A \ua4f5 B     : {A & B     = }")
print(f"A \ua4f5 C     : {A & C     = }")
print(f"B \ua4f5 C     : {B & C     = }")
print(f"A \ua4f5 B \ua4f5 C : {A & B & C = }")

A = {'λ', 'g', 'ρ', 'μ'} 
B = {'n', 'λ', 'σ', 'μ'} 
C = {'λ', 'T', 'n', 'g'}

A ꓵ B     : A & B     = {'λ', 'μ'}
A ꓵ C     : A & C     = {'λ', 'g'}
B ꓵ C     : B & C     = {'λ', 'n'}
A ꓵ B ꓵ C : A & B & C = {'λ'}

Différence¶

La différence entre deux ensembles se fait à l'aide de l'opérateur moins -.

A - B : permet de retirer de A les éléments appartenant à B et affecte le résultat à un nouvel ensemble.

Attention : Comme pour les ensembles réels, cet opérateur n'est pas commutatif (A-B ≠ B-A ) et n'est pas associatif ( A-(B-C) ≠ (A-B)-C ).

In [14]:

A = {'g', 'ρ' , 'μ', 'λ'}
B = {'n', 'λ', 'σ','μ'}
C = {'T','g'}
print(f"{A = } \n{B = } \n{C = }\n")

print(f"{A - B       = }")
print(f"{A - C       = }")
print(f"{B - C       = }")
print(f"{A - (B - C) = }")
print(f"{(A - B) - C = }")

A = {'λ', 'g', 'ρ', 'μ'} 
B = {'n', 'λ', 'σ', 'μ'} 
C = {'T', 'g'}

A - B       = {'ρ', 'g'}
A - C       = {'λ', 'ρ', 'μ'}
B - C       = {'n', 'λ', 'σ', 'μ'}
A - (B - C) = {'ρ', 'g'}
(A - B) - C = {'ρ'}

Différence symétrique¶

L'opérateur ^ (accent circonflexe) permet de retourner la différence symétrique entre deux ensembles A et B. C'est l'ensemble des éléments qui appartiennent soit à A, soit à B, mais pas aux deux à la fois.

• En utilisant la différence
  $A\land B=(A-B)\cup (B-A)$ : A ^ B = (A - B) | (B - A)

• En utilisant l'union et l'intersection
  $A\land B=(A\cup B)-(A\cap B)$ : A ^ B = (A | B) - (A & B)

In [13]:

A = {'g', 'ρ' , 'μ', 'λ'}
B = {'n', 'λ', 'σ','μ'}
print(f"{A = } \n{B = }\n")

print(f"{A ^ B = }")
print(f"{(A - B) | (B - A) = }")
print(f"{(A | B) - (A & B) = }")

A = {'λ', 'g', 'ρ', 'μ'} 
B = {'n', 'λ', 'σ', 'μ'}

A ^ B = {'n', 'σ', 'ρ', 'g'}
(A - B) | (B - A) = {'ρ', 'σ', 'n', 'g'}
(A | B) - (A & B) = {'n', 'g', 'σ', 'ρ'}

Autres fonctions¶

Lés autres méthodes de set sont les mêmes que celles que nous avons vu dans les sections précédentes (dict, list et tuple).

Voici la liste de 16 méthodes avec une brève description de leurs actions

1. add

   • Ajoute un élément à un ensemble si l'élément n'existe pas A.add(clé)
   • Retourne None

2. update

   • Met à jour l'ensemble en ajoutant des éléments A.update(plusieurs clés)
   • Elle prend plusieurs arguments (clés) séparés par des virgules.
   • Chacun des arguments peut être : str, liste, tuple, set,

3. union

   • Réalise l'opération de l'union : D = A.union(B,C, ...)
   • Retourne un ensemble

4. intersection

   • Réalise l'opération intersection : D = A.intersection(B,C, ...)
   • Retourne un ensemble

5. intersection_update

   • Réalise l'opération d'intersection en mettant à jour l'ensemble : A.intersection_update(B,C, ...)
   • Retourne None

6. difference

   • Réalise l'opération de différence : D = A.difference(B,C, ...)
   • Retourne un ensemble

7. difference_update

   • Réalise l'opération de différence en mettant à jour l'ensemble : A.difference_update(B,C, ...)
   • Retourne None

8. symmetric_difference

   • Réalise l'opération de différence symétrique : D = A.difference(B,C, ...)
   • Retourne un ensemble

9. symmetric_difference_update

   • Réalise l'opération de différence symétrique en mettant à jour l'ensemble : A.symmetric_difference_update(B,C, ...)
   • Retourne None

10. clear

    • Vide le contenu de l'ensemble : A.clear()
    • Retourne None

11. copy

    • Fait une copie de l'ensemble : B = A.copy()
    • Retourne un ensemble

12. discard

    • Efface la clé en argument : A.discard('clé')
    • Retourne None

13. remove

    • Comme discard, efface la clé en argument : A.remove('clé')
    • Retourne Erreur si l'élément n'existe pas

14. pop

    • Supprime le dernier élément de l'ensemble : A.pop()
    • Retourne None

15. isdisjoint

    • Vérifie si deux ensembles n'ont aucun élément en commun. Si c'est le cas, on dit qu'ils sont disjoints. res = A.isdisjoint(B)
    • Renvoie True si l'intersection des deux ensembles est vide.
    • Renvoie False s'ils partagent au moins un élément

16. issubset

    • Vérifie si un ensemble A est un sous-ensemble d'un autre ensemble B res = A.issubset(B)
    • Renvoie True si tous les éléments de A sont présents dans B.
    • L'opérateurs <= est l'équivalent de issubset()
    • l'opérateur < est utilisé pour un sous-ensemble propre (strict), où les deux ensembles ne sont pas identiques

17. issuperset

    • Inverse de issubset, vérifie si un ensemble A est un sur-ensemble d'un autre ensemble B. A.issuperset(B)
    • Renvoie True si tous les éléments de B sont présents dans A.
    • L'opérateur >= est l'équivalent de issuperset()
    • L'opérateur > est utilisé pour un sur-ensemble propre (strict)

Voici quelques exemples :

In [8]:

A = {1,2,3,'a','b'}
B = {"aa","bb","cc","dd"}
print(f'{A = }')
A.update((8,9),{4,5}, "c", ['de',6],B)
A.add("E")
print(f'{A = }')

A = {1, 2, 3, 'b', 'a'}
A = {1, 2, 3, 'b', 4, 5, 6, 8, 9, 'c', 'bb', 'aa', 'de', 'dd', 'a', 'cc', 'E'}

In [ ]:

A ={0,1,2,3}
B ={0,1,2,3}
print(f"{A = }\n{B = }")
print(f'{A.issubset(B) = }')
print(f'{A <= B = }')

A = {0, 1, 2, 3, 4}
B = {0, 1, 2, 3}
A.issubset(B) = False
A <= B = False

In [10]:

A = {'g', 'ρ' , 'μ', 'λ'}
B = {'n', 'λ', 'σ','μ'}

C = A.copy()

print(f"{A = }\n{C = }")
D = C.update(['B','C'],B,[1,2])
D = A.union(B)
print(f"--------\n{A = }\n{D = }\n{C = }\n-------")


C.pop()
print(f"{A = }\n{C = }")

#D = C.discard('g')
D = C.remove('g')
print(f"{A = }\n{C = }\n{D = }")

A = {'ρ', 'μ', 'λ', 'g'}
C = {'ρ', 'μ', 'λ', 'g'}
--------
A = {'ρ', 'μ', 'λ', 'g'}
D = {'λ', 'g', 'ρ', 'n', 'σ', 'μ'}
C = {1, 2, 'λ', 'C', 'g', 'ρ', 'n', 'σ', 'B', 'μ'}
-------
A = {'ρ', 'μ', 'λ', 'g'}
C = {2, 'λ', 'C', 'g', 'ρ', 'n', 'σ', 'B', 'μ'}
A = {'ρ', 'μ', 'λ', 'g'}
C = {2, 'λ', 'C', 'ρ', 'n', 'σ', 'B', 'μ'}
D = None

Exemple d'utilisation de set avec dict¶

In [6]:

# Un dictionnaire pour stocker les propriétés physico-chimiques d'échantillons d'eau
echantillons_eau = {
    "riviere_1": {
        "pH": 7.2,
        "temperature": 15,
        "polluants": {"plastique", "pesticides", "métaux_lourds"}  # set
    },
    "riviere_2": {
        "pH": 8.1,
        "temperature": 22,
        "polluants": {"algues", "pesticides"} # un set
    },
    "source": {
        "pH": 7.0,
        "temperature": 10,
        "polluants": set() # Un ensemble vide pour indiquer l'absence de polluants
    }
}

# On définit un ensemble de polluants particulièrement préoccupants
polluants_preoccupants = {"pesticides", "métaux_lourds", "mercure"}

In [7]:

# Identification des polluants communs aux deux rivières
# On utilise l'opération d'intersection (&) sur les sets
polu1 = echantillons_eau["riviere_1"]["polluants"]
polu2 = echantillons_eau["riviere_2"]["polluants"]
print(f"Polluants communs aux 2 rivières : {polu1 & polu2}")

Polluants communs aux 2 rivières : {'pesticides'}

In [13]:

# Vérification si un échantillon contient des polluants préoccupants 
# On teste avec la méthode `isdisjoint()` pour savoir s'il y a une intersection
danger = polu1.isdisjoint(polluants_preoccupants)
print(f"Absence de polluants préoccupants dans la rivière 1 : {danger}")

# on peut aussi savoir lesquels
print('Polluants préoccupant de la rivière 1 :', polu1 & polluants_preoccupants)

Absence de polluants préoccupants dans la rivière 1 : False
Polluants préoccupant de la rivière 1 : {'pesticides', 'métaux_lourds', 'mercure'}

In [10]:

# Vérification si l'eau de source est potable. On teste si le set est vide
eau_potable_propre = not echantillons_eau["source"]["polluants"]
print("L'eau de source est potable :", not echantillons_eau["source"]["polluants"])

L'eau de source est potable : True

In [11]:

# Mise à  à jour des polluants pour un échantillon
# On peut utiliser les méthodes `update()` ou `add()` des sets
echantillons_eau["riviere_1"]["polluants"].add("mercure")
print(f"Nouveaux polluants dans la rivière 1 : {echantillons_eau['riviere_1']['polluants']}")

Nouveaux polluants dans la rivière 1 : {'pesticides', 'métaux_lourds', 'plastique', 'mercure'}