Les ensembles en Python

Les ensembles en Python

  1. Objectifs

    • Connaître les ensembles en Python, savoir l’utiliser.
  2. Présentation

    • Un ensemble est une collection d’articles non ordonnée. Chaque élément de l’ensemble est unique (pas de doublons) et doit être immuable (ne peut pas être modifié).
    • Un ensemble est une collection non ordonnée d’objets, contrairement aux séquences comme les listes et les tuples dans lesquels chaque élément est indexé. Un ensemble ne peut pas contenir de doublon : on ne peut y trouver des éléments que zéro ou une fois.
    • Un ensemble est une collection non ordonnée d’éléments. Chaque élément est unique (pas de doublons) et doit être immuable (ce qui ne peut pas être changé).Cependant, l’ensemble lui-même est mutable. Nous pouvons ajouter ou supprimer des éléments.
    • Les ensembles en Python ce sont des ensembles non ordonnés de valeurs distinctes. Ces valeurs peuvent être de différents types.
    • Il existe 2 types d’ensembles :
      • set : On peut ajouter ou supprimer des éléments à ce type d’ensemble; par conséquent, ils ne peuvent être utilisés comme clés de dictionnaire.
      • frozenset : On ne peut ajouter ou supprimer des éléments à ce type d’ensemble; par contre, ils peuvent être utilisés comme clés de dictionnaire ou comme membres d’un autre ensemble.




  3. Comment créer des ensembles et leur affecter des valeurs ?

    • Il n’existe pas de syntaxe particulière pour les ensembles comme il en existe par exemple pour les listes et pour les dictionnaires.
    • La seule méthode de création possible consiste à utiliser les fonctions set() et frozenset().
    • Un ensemble est créé en plaçant tous les éléments (éléments) entre accolades {}, séparés par une virgule ou en utilisant la fonction intégrée set().
    • On peut créer un ensemble à l’aide d’une liste, d’un tuple ou d’un dictionnaire.
    • Voyelles = set(["a", "e", "i", "o", "u", "y"])
      print (Voyelles)
      """
      Production
      {'i', 'o', 'e', 'u', 'a', 'y'}
      """
      
    • Si aucun argument n’est fourni, il y a création d’un ensemble vide.
    • Utiliser la fonction intégrée set() pour créer des ensembles.
      • Créer un ensemble à partir d’un ensemble
        • ensemble1 = set({77, 23, 91, 271, 987, 852})
          print("ensemble1 : ",ensemble1)
          """
          Production
          ensemble1 :  {852, 23, 91, 987, 77, 271}
          
      • Créer un ensemble à partir d’une chaîne
        • ensemble1 = set("123456abcdefghij")
          print("ensemble1 : ",ensemble1)
          """
          Production
          ensemble1 :  {'c', 'd', '1', 'b', 'f', 'j',
          'i', '4', '2', 'g', '5', '6', 'h', '3', 'e', 'a'}
          """
          
      • Créer un ensemble à partir d’une liste
        • ensemble1 = set(['formation', 'site', 'apcpedagogie.com', 12, 12.12])
          print("ensemble1 : ",ensemble1)
          """
          Production
          ensemble1 :  {'site', 'apcpedagogie.com',
          'formation', 12, 12.12}
          """
          
      • Créer un ensemble à partir d’un tuple
      • ensemble1 = set(('formation', 'site', 'apcpedagogie.com', 12, 12.12))
        print("ensemble1 : ",ensemble1)
        """
        Production
        ensemble1 :  {'apcpedagogie.com',
        'formation', 'site', 12, 12.12}
        """
        
  4. Méthodes des ensembles Python

    1. frozenset ()
      • La méthode frozenset () renvoie un objet frozenset immuable initialisé avec des éléments de l’itérable donné.
      • # tuple de voyelles
        voyelles = ('a', 'e', 'i', 'o', 'u')
        
        fSet = frozenset(voyelles)
        print('L\'ensemble gelé est:', fSet)
        print('L\'ensemble congelé vide est:', frozenset())
        
        # Les frozensets sont immuables
        fSet.add('v')
        
    2. difference ()
      • La méthode difference () renvoie la différence d’ensemble de deux ensembles.
      • difference() renvoie la différence entre deux ensembles qui est également un ensemble. Il ne modifie pas les ensembles originaux.
      • Si A et B sont deux ensembles. La différence d’ensemble de A et B est un ensemble d’éléments qui n’existe que dans l’ensemble A mais pas dans B . Par exemple:
      • A = {1, 2, 3, 4, 5}
        B = {2, 3, 7, 9}
        print('Le résultat de A - B est:',A - B)
        print('Le résultat de B - A est:',B - A)
        """
        Production:
        Le résultat de A - B est: {1, 4, 5}
        Le résultat de B - A est: {9, 7}
        """
        
      • Cette différence peut être écrit :
      • A = {1, 2, 3, 4, 5}
        B = {2, 3, 7, 9}
        print('Le résultat de A - B est:',A.difference(B))
        print('Le résultat de B - A est:',B.difference(A))
        """
        Production:
        Le résultat de A - B est: {1, 4, 5}
        Le résultat de B - A est: {9, 7}
        """
        
    3. copy()
      • La méthode copy () renvoie une copie superficielle de l’ensemble.
      • Un ensemble peut être copié à l’aide de l’opérateur = en Python.
      • nombres = {1, 2, 3, 4}
        nouveaux_nombres = nombres
        print(nouveaux_nombres)
        """
        Production:
        {1, 2, 3, 4}
        """
        
      • Le problème avec la copie de l’ensemble de cette manière est que si vous modifiez l’ensemble de nombres, l’ensemble nouveaux_nombres est également modifié.
      • nombres = {1, 2, 3, 4}
        print('Ensemble avant l\'ajout nombres',nombres)
        nouveaux_nombres = nombres
        nouveaux_nombres.add(5)
        print('Ensemble après l\'ajout nombres',nombres)
        """
        Production:
        Ensemble avant l'ajout nombres {1, 2, 3, 4}
        Ensemble après l'ajout nombres {1, 2, 3, 4, 5}
        """
        
      • Pour laisser l’ensemble de départ inchangé utiliser la méthode copy ().
      • nombres = {1, 2, 3, 4}
        print('Ensemble avant l\'ajout nombres',nombres)
        nouveaux_nombres = nombres.copy()
        nouveaux_nombres.add(5)
        print('Ensemble après l\'ajout nombres',nombres)
        """
        Production:
        Ensemble avant l'ajout nombres {1, 2, 3, 4}
        Ensemble après l'ajout nombres {1, 2, 3, 4}
        """
        
    4. clear()
      • La méthode clear () supprime tous les éléments d’un ensemble.
      • nombres = {1, 2, 3, 4}
        print('Ensemble avant suppression : ',nombres)
        nombres.clear()
        print('Ensemble après suppression : ',nombres)
        """
        Production:
        Ensemble avant suppression :  {1, 2, 3, 4}
        Ensemble après suppression :  set()
        """
        
    5. discard()
      • La méthode discard () supprime un élément spécifié de l’ensemble (le cas échéant).
      • discard () prend un seul élément x et le supprime de l’ensemble (s’il est présent).
      • nombres = {1, 2, 3, 4}
        nombres.discard(3)
        print('Ensemble après suppression : ',nombres)
        """
        Production:
        Ensemble avant suppression :  {1, 2, 4}
        """
        
    6. intersection()
      • La méthode intersection () retourne un nouvel ensemble avec des éléments communs à tous les ensembles.
      • L’intersection de deux ou plusieurs ensembles est l’ensemble des éléments communs à tous les ensembles.
      • A = {2, 3, 5, 4}
        B = {2, 5, 100}
        C = {2, 3, 8, 9, 10}
        
        print('B inter A : donne l\'ensemble : ',B.intersection(A))
        print('B inter C : donne l\'ensemble : ',B.intersection(C))
        print('A inter C : donne l\'ensemble : ',A.intersection(C))
        print('C inter A et B: donne l\'ensemble : ',C.intersection(A, B))
        """
        Production:
        B inter A : donne l'ensemble :  {2, 5}
        B inter C : donne l'ensemble :  {2}
        A inter C : donne l'ensemble :  {2, 3}
        C inter A et B: donne l'ensemble :  {2}"""
        
    7. remove()
      • La méthode remove () supprime l’élément spécifié de l’ensemble.
      • La méthode remove () prend un seul élément comme argument et le supprime de l’ensemble.
      • remove () supprime l’élément spécifié de l’ensemble et met à jour l’ensemble. Il ne renvoie aucune valeur.
      • Si l’élément passé à remove () n’existe pas, l’exception KeyError est levée.
      • A = {2, 3, 5, 4}
        A.remove(5)
        print(A)
        
        """
        Production:{2, 3, 4}
        """
        
  5. Autres méthodes des ensembles Python

    • Comment convertir une chaîne en un ensemble en Python?
      • Si une chaîne contient un caractère plus d’une fois, ce caractère n’apparaît qu’une seule fois dans l’objet ensemble.
      • Les caractères peuvent ne pas apparaître dans la même séquence que dans la chaîne car la fonction set () a son propre mécanisme de hachage
      • set("hello")
        {'l', 'h', 'o', 'e'}
      • Nous pouvons convertir une chaîne en set en Python en utilisant la méthode set () .
      • # créer une chaîne str 
        string = "apcpedagogie.com"
        print("Initialement") 
        print("Le type de données de la chaîne : " + str(type(string))) 
        print("Contenu de la chaîne : " + string) 
          
        # Convertir une chaîne en ensemble 
        string = set(string) 
        print("\nAprès la conversion") 
        print("Le type de données de la chaîne : " + str(type(string))) 
        print("Contenu de la chaîne : ", string) 
        """
        L'ensemble gelé est: frozenset({'e', 'i', 'o', 'u', 'a'})
        L'ensemble congelé vide est: frozenset()
        Traceback (most recent call last):
          File "C:\Users\bigtec\AppData\Local\Programs\Python\Python38\autregeneral.py", line 9, in 
            fSet.add('v')
        AttributeError: 'frozenset' object has no attribute 'add'
        """
        



Laisser un commentaire