python:bases:ensembles [WEBGE Wikis]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
[[python:bases:accueilmodule|{{ :suivant.png?nolink&30|Modules}}]] 
[[:python:bases:dictionnaires|{{ :retour.png?nolink&30|Dictionnaires}}]] 
[[:python:accueilpython|{{ :iconemaison.jpg?nolink&30|Sommaire Python et microPython}}]]

===== Python - Ensembles (set) =====

[Mise à jour le : 30/6/2021] 

  * **Sources**
    * **Documentation** sur Python.org : <html><html><a href="https://docs.python.org/fr/3.6/reference/index.html" target="_blank">référence du langage</a>, <a href="https://docs.python.org/fr/3/tutorial/datastructures.html#sets" target="_blank">ensembles</a>, <a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">fonctions natives</a></html> (built-in)

  * ** Mots-clés** : ensemble, mutable, immuable, union, intersection, différence, différence symétrique, comparaison, égalité, inclusion, disjoint.

<callout type="warning" icon="true">Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</callout>

|  and        |  continue   |  finally  |    is          |  raise      |
|  as         |  def        |    for    |  lambda        |  return     |
|  assert     |  del        |  from     |  __None__      |  __True__   |
|  __async__  |  elif       |  global   |  __nonlocal__  |  try        |
|  __await__  |  else       |    if     |    not         |  while      |
|  break      |  except     |  import   |  or            |  with       |
|  class      |  __False__  |    in     |  pass          |  yield      |

  * <html><a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">Fonctions natives</a></html>** (built-in)**((Fonctions toujours disponibles.)) utilisées dans les exemples : **frozenset**(), **len**() **print**(), **set**().

----

==== 1. Introduction ====
Proche des dictionnaires, les sets ne stockent qu'une clé. Ils sont très utilisés pour **garder le nombre d'éléments uniques d'une séquence** ou faire le **test d'appartenance sur les éléments d'une séquence**. Un set peut stocker n'importe quel élément hashable (entier,caractère, booléen etc.).

<callout type="warning" icon="true">Les ensembles ne sont pas ordonnés !</callout>

==== 2. Création ====
=== 2.1 Création en extension ===

<callout type="primary" icon="true">On crée un ensemble avec les accolades, comme les dictionnaires, mais sans utiliser le caractère ":" ou avec la fonction **set**().</callout>

// Exemple 1 // : avec des accolades

<code python *.py>
# Un set sur une liste élimine les doublons
ensemble = {'marc', 12, 'pierre', (1, 2, 3), 'pierre'} 
print(ensemble) # Résultat : {'marc', 'pierre', 12, (1, 2, 3)}
</code>

// Exemple 2 // : avec la fonction set()

<code python *.py>
# Un set sur une liste élimine les doublons
ensemble = set(['marc', 12, 'pierre', (1, 2, 3), 'pierre'])
print(ensemble) # Résultat : {'marc', 'pierre', 12, (1, 2, 3)}
</code>

=== 2.1 Création d'un ensemble vide ===
<callout type="warning" icon="true">Un ensemble vide se crée seulement avec la fonction **set**().</callout>

//Exemple//

<code python *.py>
ensemble_vide = set()
# ou
ensemble_vide = set([])
</code>

==== 3. Eléments dans un ensemble ====

<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Les **éléments** d'un ensemble doivent être globalement **immuables**. Le type set étant **mutable**, on ne peut **pas** créer un **ensemble d'ensembles**.</callout>

==== 4. Fonction native Frozenset ====
Source <html><a href = "https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset" target="_blank">set, frozenset</a></html>

<callout type="primary" icon="true">Un frozenset est un ensemble qu'on ne peut pas modifier, et qui donc peut servir de clé dans un dictionnaire, ou être inclus dans un autre ensemble (mutable ou pas).</callout>


==== 5. Opérations ====

=== 5.1 Test d'appartenance ===

<code python *.py>
a = {'marc', 'pierre', 12, (1, 2, 3)}
'pierre' in a # Résultat :True
6 in a # Résultat : False
</code>

<callout type="tip" icon="true">Lors d'un test d'appartenance sur une séquence, convertir la séquence en set accélère le traitement.</callout>

=== 5.2 Cardinal ===
  * **Nombre d'éléments dans un ensemble**
<code python *.py>
a = {'marc', 'pierre', 12, (1, 2, 3)}
len(a) # Résultat : 4
</code>


=== 5.3  Manipulations ===

  * **Suppression des doublons dans une liste**

<code python *.py>
a = {['marc', 'pierre', 12, (1, 2, 3), 12, 'marc']}
print(a)  # Résultat : {(1, 2, 3), 12, 'marc', 'pierre'}
</code>

  * **Vidage**
<code python *.py>
# pour nettoyer
a = {'marc', 'pierre', 12, (1, 2, 3)}
a.clear() # Résultat : set()
</code>

  * **Ajout d'un élément**
<code python *.py>
# ajouter un élément
a = {'marc', 'pierre', 12, (1, 2, 3)}
a.add(1) # Résultat : {1, (1, 2, 3), 12, 'marc', 'pierre'}
</code>

  * **Mise à jour d'un ensemble avec un autre ensemble**
<code python *.py>
# ajouter tous les éléments d'un autre ensemble
a = {'marc', 'pierre', 12, (1, 2, 3)}
a.update({2, (1, 2, 3), (1, 3, 5)}) # Résultat : {2, (1, 3, 5), 'pierre', (1, 2, 3), 12, 'marc'}
</code>

  * **Suppression d'un élément**
<code python *.py>
# enlever un élément avec discard
a = {2, (1, 3, 5), 'pierre', (1, 2, 3), 12, 'marc'}
a.discard((1, 3, 5)) # Résultat : {2, 'pierre', (1, 2, 3), 12, 'marc'}
</code>

<callout type="primary" icon="true">discard fonctionne même si l'élément n'est pas présent.</callout>

<code python *.py>
# enlever un élément avec remove
a = {2, (1, 3, 5), 'pierre', (1, 2, 3), 12, 'marc'}
a.remove('jean') # Résultat : exception
</code>

<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Contrairement à discard, l'élément doit être présent, sinon il se produit une exception.</callout>

<code python *.py>
# pop() ressemble à la méthode éponyme sur les listes
# sauf qu'il n'y a pas d'ordre dans un ensemble
a = {2, (1, 3, 5), 'pierre', (1, 2, 3), 12, 'marc'}
while a:
    a = a.pop()
    print("element", a)
print("l'ensemble est vide", a)

# Résultat
# element 2
# element (1, 3, 5)
# element pierre
# element (1, 2, 3)
# element 12
# element marc
# l'ensemble est vide set()
</code>

=== 5.4  Opérations sur les ensembles ===
<callout type="primary" icon="true">Les notations des opérateurs sur les ensembles rappellent les opérateurs "**bit-à-bit**" sur les entiers. \\
Ces opérateurs sont également disponibles sous la forme de méthodes.</callout>

  * **Union**

<code python *.py>
A1 = set([0, 2, 4, 6])
A2 = set([0, 6, 3])
A1 | A2 # Résultat : {0, 2, 3, 4, 6}
</code>


  * **Intersection**

<code python *.py>
A1 = set([0, 2, 4, 6])
A2 = set([0, 6, 3])
A1 & A2 # Résultat : {0, 6}
</code>

  * **Différence**

<code python *.py>
A1 = set([0, 2, 4, 6])
A2 = set([0, 6, 3])
A1 - A2 # Résultat : {2, 4}
</code>

  * **Différence symétrique**

<callout type="primary" icon="true">**𝐴Δ𝐵=(𝐴−𝐵) ∪ (𝐵−𝐴)**</callout>

<code python *.py>
A1 = set([0, 2, 4, 6])
A2 = set([0, 6, 3])
A1 ^ A2 # Résultat : {2, 3, 4}
</code>


=== 5.5  Comparaisons ===

  * **Egalité**

<code python *.py>
a = {'marc', 'pierre', 12, (1, 2, 3)}
b = set(['pierre', 12, (1, 2, 3), 'marc'])
a==b # Résultat : True
</code>

  * **Inclusion**

<code python *.py>
a = {0, 1, 2, 3}
b =  {1, 3}
b <= a # Résultat : True
</code>

<code python *.py>
a = {0, 1, 2, 3}
b =  {1, 3}
b < a # Résultat : True
</code>

  * **Ensembles disjoints**

<code python *.py>
a = {0, 1, 2, 3}
b =  {'marc', 'pierre', 12, (1, 2, 3)}
a.isdisjoint(b) # Résultat : True
</code>

{{ :python:bases:realpython.png?nolink|}}
==== Quiz ====
  * **Real Python** : <html><a href="https://realpython.com/quizzes/python-sets/" target="_blank">Python Sets Quiz</a></html>