Skip to content

Aide mémoire Python3 : Listes, Tuples et Dictionnaires

Posted in GNU/Linux

Python est un langage de programmation objet, multi-paradigme et multiplateformes. Il est sous licence libre. Cette page se veut un aide mémoire sur Python3.


Listes, Tuples et Dictionnaires :

    Toutes chaîne de caractère est une séquence. Une séquence est une suite d’éléments indexés pouvant être accédée de différentes façon. Cela permet des manipulations rapides et intéressantes.

    Quelques exemples ci dessous

    >>nom='Guillaume'
    >> nom[2:4]
     'il'
    >> nom[-4:-1]
     'aum'
    >> nom[-4:]
     'aume'
    

    Par contre une chaine de caractères est immuable. Si on souhaite la modifier, c’est une autre chaine de caractère qui doit être crée. Par exemple on ne peut pas supprimer un caractère :

    >>del liste[2]
    >>del liste[3:4]
    >>del nom[2]
      Traceback (most recent call last):
       File "", line 1, in 
           del nom[2]
     TypeError: 'str' object doesn't support item deletion 
    
  • Listes : Les listes sont des séquences (ensembles de valeurs indexées) mais sont des objets mutables. La liste peut être modifiée. Cela signifie que lors de la modification il n’y a pas de copie, c’est bien la même référence qui est modifiée (donc moins de travail en mémoire et plus rapide)
    >>liste = [1, 2, 3, 4, 5]
    >>liste[3] #pour accéder au 4ème élément de la liste
    >>liste.append(6) #pour ajouter un élément
    >>liste.extend(liste2) #pour ajouter liste2 à la fin de liste
    >>liste.remove(4) #pour supprimer la valeur 4
    >>liste.reverse
    >>liste.sort
    >>del liste[2] >>del liste[3:4]

    Il est possible de transformer une séquence en liste. Pour cela on utilise l’opération suivante

    >> list(nom)
     ['G', 'u', 'i', 'l', 'l', 'a', 'u', 'm', 'e']
    

    Une liste peut être générée avec du code et une boucle mais on peut aussi le faire directement. Voici deux exemples (issus du site officiel Python.)

    Pour construire une liste des 10 premiers carrés :

    >> squares = [x**2 for x in range(10)]
    >> squares
     [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    Ou pour construire la liste des couples (x,y) avec x dans (1,2,3) et y dans (3,1,4) et où x est différent de y. :

    >> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
      [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
     
  • Tuples : les tuples sont semblables aux listes (collection indexée ou ordonnée) mais ne peuvent pas être modifiés une fois qu’ils sont définis (immuables). Ils sont intéressant car l’accès à leurs éléments est très rapide (pour un for in par exemple). Leur déclaration se fait entre parenthèses (contrairement aux listes qui utilisent des crochets).
    >> untuple= ('1', '2', '3', '4', '5')
    
  • Dictionnaires : Contrairement aux listes et aux tuples, un dictionnaire n’est pas un ensemble ordonné. C’est un ensemble de paires constituées d’une clé et d’une valeur. C’est ce qu’on appelle un tableau associatif dans certains langages. L’intérêt du dictionnaire est que son accès est réalisé par une fonction de hash. En clair si on recherche un élément dans le tableau python ne lit pas un à un les éléments. Les tests d’appartenances sont donc beaucoup plus rapide.

    Un dictionnaire est défini entre des “{ }”.

     
    >> livre = {'titre':"Un beau titre", 'auteur':"un bel auteur"} # crée le dictionnaire livre
    >> del livre['auteur'] # supprime l'auteur
    >> livre['isbn']='5453362sdq' #ajoute l'entrée isbn (ou la modifie si elle existe)
    

    Comme pour les listes, les dictionnaires peuvent être générés en englobant du code entre “{}”

    >> squares = {x: x**2 for x in range(10)}
    >> squares
    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
  • La boucle For : Il est intéressant de regarder quelques cas de manipulation avec une boucle for.
    Cas d’une liste :

     In [36]: for c in nom:
         ...:    print(c)
         ...: 
     G
     u
     i
     l
     l
     a
     u
     m
     e
     >>for c in nom:
         ...:    print(c,end='')
         ...: 
     Guillaume
    

    # Ici le “end=”” permet de remplacer le retour chariot par … rien 🙂

    Cas d’un dictionnaire :

     >> for c,v in livre.items():
         ...:    print(c,v)
         ...: 
     auteur un bel auteur
     titre Un beau titre
     >> for v,m in {int(x/7): x for x in range(100) if x % 7 == 0}.items():
     ...     print(str(v) + ' * 7 = ' + str(m))
     ... 
     0 * 7 = 0
     1 * 7 = 7
     2 * 7 = 14
     3 * 7 = 21
     4 * 7 = 28
     5 * 7 = 35
     6 * 7 = 42
     7 * 7 = 49
     8 * 7 = 56
     9 * 7 = 63
     10 * 7 = 70
     11 * 7 = 77
     12 * 7 = 84
     13 * 7 = 91
     14 * 7 = 98
     

    Et puis un “mixte” des deux (pris sur le site officiel) :

     
     >> questions = ['name', 'quest', 'favorite color']
     >> answers = ['lancelot', 'the holy grail', 'blue']
     >> for q, a in zip(questions, answers):
     ...     print('What is your {0}?  It is {1}.'.format(q, a))
     ...
     What is your name?  It is lancelot.
     What is your quest?  It is the holy grail.
     What is your favorite color?  It is blue.
     

    Remarque : format() est une methode de string qui permet de fournir des arguments à la chaine de caractères. Les champs devant prendre en compte les arguments sont mis entre “{ }”