PYTHON 6 : TYPES ITERABLES

Une variable dont le type est itérable, cela signifie qu'il est possible d'atteindre tous les éléments qui la compose (indépendamment des caractères de syntaxe propre au type considéré). Pour cela, il faut retenir que la position d'un caractère dans sa chaîne est rattaché à ce qu'on va appeler un indice ou un index.

Seul le type dictionnaire se comporte différemment, une clé remplaçant l'index. Il est présenté à part entière à la fin de cette page.

Exemple :
Index (sens de lecture) 0 1 2 3 4 5
Index (sens inverse) -6 -5 -4 -3 -2 -1
Chaîne de caractères 'c' 'h' 'e' 'v' 'a' 'l'
Liste ['c', 'h', 'e', 'v', 'a', 'l']
Tuple ('c', 'h', 'e', 'v', 'a', 'l')
1. Chaînes de caractères - Type string
Voici les principales commandes sur une chaîne de caractères :
  • Déterminer la longueur d'une variable itérable : len(variable).
    Exemple :
                                    
    >>> char = 'cheval'
    >>> len(char)
    6
                                
                                
  • Atteindre un élément dont on connaît l'index : variable[index].
    Exemple :
                                    
    >>> char = 'cheval'
    >>> char[4] 
    'a' 
    >>> char[-3] 
    'v'
                                    
                                
  • Atteindre une partie de la variable itérable en fonction des index.
    Exemple :
                                    
    >>> char = 'cheval'
    >>> char[2:4] # portion entre deux index
    'ev' 
    >>> char[3:] # fin de la chaîne à partir d'un index
    'val'
    >>> char[:3] # début de la chaîne jusqu'à un index
    'che'
    >>> char[-3:-1] # portion entre deux index (sens inverse)
    'va'
                                    
                                
  • Parcourir une variable itérable : for element in variable :
    Exemple :
                                                
    >>> for lettre in char :
    ...     print(lettre)
    ...
    c
    h
    e
    v
    a
    l 
                                    
                                
                                                
    >>> for index in range(len(char)) :
    ...     print(char[index])
    ... 
    c 
    h 
    e 
    v 
    a 
    l 
                                            
                                        
  • Mettre bout à bout deux variables itérables de même nature (ou concaténer) : variable1 + variable2
    Exemple :
                                    
    >>> char = 'cheval'
    >>> char2 = ' blanc'
    >>> char + char2
    'cheval blanc'
                                    
                                
  • Concaténer x fois la même variable : variable1 * x
    Exemple :
                                    
    >>> char = 'cheval '
    >>> char * 3
    'cheval cheval cheval '
                                    
                                
  • Vérifier la présence d'un élément dans une variable itérable : element in variable renvoie True pour vrai.
    Exemple :
                                    
    >>> char = 'cheval '
    >>> 'h' in char
    True
                                        
                                    
Les variables de type chaîne de caractères (string) sont des suites de caractères. Un caractère peut représenter une lettre minuscule, une lettre majuscule, un chiffre ou un signe de ponctuation, mais aussi un espace, une tabulation, un retour à la ligne. On retrouve l'ensemble de ces caractères dans la table ASCII.

Un chaîne de caractère doit toujours être écrite entre des guillemets " " ou des apostrophes ' '. On remarque que l'un conditionne l'autre, en fonction de leur usage dans la chaîne de caractères à afficher.

Pour transformer un mot (ou un chiffre) en une chaîne de caractère, deux solutions :
  • L'encadrer avec des guillemets ou apostrophes.
  • Appeler la fonction str(...), si la variable n'est pas de type string.
Exemple :
                              
>>> char1 = 'bonjour'
>>> char2 = "s'adapter"
>>> phrase = 'elle me dit "bonjour"'

>>> phrase 
'elle me dit "bonjour"'
>>> 'phrase'
'phrase'

                        
2. Liste - Type list
Voici les principales commandes sur une liste :
  • Déterminer la longueur d'une variable itérable : len(variable).
    Exemple :
                                    
    >>> liste = [1, 14, 5, 78]
    >>> len(liste)
    4
                                
                                
  • Atteindre un élément dont on connaît l'index : liste[index].
    Exemple :
                                    
    >>> liste = [1, 14, 5, 78]
    >>> liste[2] 
    2 
    >>> liste2 = ['voiture', 'maison', 'chat', 'chien'] 
    >>> liste2[1] 
    'maison'
                                    
                                
  • Atteindre une partie de la variable itérable en fonction des index.
    Exemple :
                                    
    >>> liste = [1, 14, 5, 78, 6]
    >>> liste[2:4] # portion entre deux index
    [5, 78]
    >>> liste[3:]
    [78, 6]
    >>> liste[:2]
    [1, 14]
    >>> liste[-3:-1]
    [5, 78]
    
                                    
                                
  • Parcourir une variable itérable : for element in liste :
    Exemple :
                                                
    >>> liste = [1, 14, 5, 78, 6]
    >>> for nb in liste :
    ...     print(nb)
    ...
    1
    14
    5
    78
    6
                                
                                
                                                
    >>> for index in range(len(liste)) :
    ...     print(liste[index])
    ... 
    1
    14
    5
    78
    6 
                                            
                                        
  • Mettre bout à bout deux variables itérables de même nature (ou concaténer) : liste1 + liste2
    Exemple :
                                    
    >>> liste1 = [1, 2, 3]
    >>> liste2 = [4, 5, 6]
    >>> liste1 + liste2
    [1, 2, 3, 4, 5, 6]
                                    
                                
  • Concaténer x fois la même variable : liste * x
    Exemple :
                                    
    >>> liste1 = [1, 2, 3]
    >>> liste1 * 3
    [1, 2, 3, 1, 2, 3, 1, 2, 3]
                                    
                                
  • Vérifier la présence d'un élément dans une variable itérable : element in variable renvoie True pour vrai.
    Exemple :
                                    
    >>> liste1 = [1, 2, 3]
    >>> 4 in liste1
    False
                                        
                                    
Les variables de type liste peuvent être composés d'une multitude de données, de même nature ou de nature différente. Elles sont représentés par des crochets [].
Une liste vide se définit d'ailleurs par des crochets, sans rien dedans : liste_vide = [].

Cependant, une liste a une particularité quant à son enregistrement. Lorsqu'une liste est créée, elle est comme toute variable enregistrée à une adresse définie. Lorsque l'on réaffecte cette même liste, dans une autre variable, Python pointe toujours la même adresse, mais ne recopie pas la liste. Donc, si on modifie une liste "réaffectée", on modifie également la liste originale.

Pour réaliser une vraie copie, on utilise : newListe = liste.copy()
Exemple :
                              
# liste et liste2 pointent au même endroit
>>> liste = [1, 2, 3, 4]
>>> liste2 = liste
>>> liste2[0] = 'maison'
>>> liste2
['maison', 2, 3, 4]
>>> liste
['maison', 2, 3, 4]

                  
# liste et liste3 pointent vers deux espaces mémoires différents
>>> liste3 = liste.copy()
>>> liste3[0] = 0
>>> liste
['maison', 2, 3, 4]
>>> liste3
[0, 2, 3, 4]

                        
3. N-uplet - Type tuple
Le type tuple est très proche d'une liste. Il a d'ailleurs le même comportement, et les mêmes fonctions. Cependant, un élément diffère principalement : les tuples ne peuvent être modifier.

Les tuples sont reconnaissables à la présence de parenthèses : (..,..,..) et de virgules séparatrices. On peut aussi les retrouver sans parenthèses (notamment lorsqu'on récupère des variables en sortie d'une fonction).
                            
# Exemple de tuple              
>>> tuple1 = (1, 2, 3)
>>> tuple2 = 'maison', 'cheval'
                        
                                                
4. Dictionnaire - Type dict