chap1-part3-listes

Chapire 1 - Partie 3

Cette partie est consacrée aux listes list

1. Les variables séquentielles (suite)¶

1.1. Les chaînes de caractères (fichier précédent)

1.2. Les listes¶

Contenu

• 1. Les variables séquentielles (suite)
  • 1.1. Les chaînes de caractères (fichier précédent)
  • 1.2. Les listes
    • 1.2.1. Création d'une liste
    • 1.2.2. Opérations sur les listes
      • 1.2.2.1. Indices et comptage d'éléments
      • 1.2.2.2. Concaténation et réplication
      • 1.2.2.3. Ajout et insertion d'un élément
      • 1.2.2.4. Suppression d'éléments de la liste
      • 1.2.2.5. Inversion et tri d'une liste
    • 1.2.3. Jointure avec des chaînes de caractères

Une liste (list) en python est un contenant de type séquence ordonnée et mutable qui permet de stocker une collection d’éléments (objets) hétérogènes (c’est-à-dire de types différents), accessibles par leurs indices.

Chaque élément d’une liste est indexé à partir de 0, et la structure peut être modifiée dynamiquement : on peut ajouter, supprimer ou remplacer des éléments après sa création. La liste est dite mutable

• Caractéristiques principales de la liste :
  • Ordonnée : les éléments conservent leur position d’insertion.
  • Mutable : on peut modifier le contenu sans recréer la liste.
  • Hétérogène : une même liste peut contenir plusieurs types de données.
  • Itérable : on peut parcourir ses éléments dans une boucle.

1.2.1. Création d'une liste¶

Pour créer une liste, on utiliser une paire de crochets [] et on insère à l'intérieur des variables de différents types y compris d'autres listes. Les variables sont séparées par des virgules.

Voici quelques exemples de création de liste.

In [1]:

a = []                         # liste vide
b = [1, 2, 3, 4]               # liste de 5 nombres entiers
c = [1.21, 12.15, 3.14]        # liste de 4 nombres réels
d = ['a', 'b', 'c']            # liste de 3 caractères
e = ['abc', 1, 5.2 ]           # liste de 3 éléments : str, int, float

print(f'{a = } \n{b = }\n{c = }\n{d = }\n{e = }')

a = [] 
b = [1, 2, 3, 4]
c = [1.21, 12.15, 3.14]
d = ['a', 'b', 'c']
e = ['abc', 1, 5.2]

Tout comme pour la chaîne de caractères, on peut accéder aux éléments de la liste est faisant appel à l'opérateur [] et en spécifiant l'indice de l'élément désiré.

La paire de crochets [] sert donc à la fois pour créer la liste et pour accéder à ses éléments

In [2]:

print(f'{c[1] = }')  # affiche le 2éme élément de la liste c (les indices commencent per 0)
print(f'{e[0] = }')  # affiche le 1er  élément de la liste e 

c[1] = 12.15
e[0] = 'abc'

Remarquer que e[0] renvoi la chaîne de caractères abc, on peut donc accéder aux éléments de la chaîne en utilisant une autre paire de crochets comme suit:

In [3]:

print(f'{e[0][1] = }')

e[0][1] = 'b'

In [4]:

# On peut construire une liste complexe comportant même une autre liste:
L = ['a', ['bc', 'def'], 12.5]

print(f'{L = }')       # affiche toute la liste 

print(f'{L[0] = }')    # affichage des éléments de la liste
print(f'{L[1] = }')
print(f'{L[2] = }')

print(f'{L[1][0] = }')    # affichage des éléments de la sous-liste
print(f'{L[1][1] = }')

print(f'{L[1][1][0] = }')    # affichage d'un élément de la chaîne 'def' de la sous-liste

L = ['a', ['bc', 'def'], 12.5]
L[0] = 'a'
L[1] = ['bc', 'def']
L[2] = 12.5
L[1][0] = 'bc'
L[1][1] = 'def'
L[1][1][0] = 'd'

Remarque 1
Si on tente d'accéder à un élément d'une liste en utilisant des indices hors limites, la commande provoquera une erreur list index out of range. Un indice ne doit pas dépasser la longueur de la liste.

Comme pour les str, on utilise la fonction len() pour déterminer cette longueur. La fonction len est générique, elle s'applique à n'importe quel objet Python de type séquentiel.

In [5]:

print(f'La list L contient : {len(L)} éléments' )
i = 1
print(f"L'élément {i} de la liste L est une liste qui contient : {len(L[i])} éléments" )

La list L contient : 3 éléments
L'élément 1 de la liste L est une liste qui contient : 2 éléments

Remarque 2
On peut convertir une chaîne de caractères en une liste de caractères, part transtypage, en faisant appel à la fonction list qui porte le nom de la classe list.

In [6]:

D = list('abcde')
print(f'{D = }')

D = ['a', 'b', 'c', 'd', 'e']

On peut créer une liste sous forme de matrice et l'afficher en tableau

In [7]:

A = [[1.1, 1.2],
     [2.1, 2.2]]
print(f'A = [ {A[0][0]}    {A[0][1]}\n      {A[1][0]}    {A[1][1]} ]')

A = [ 1.1    1.2
      2.1    2.2 ]

1.2.2. Opérations sur les listes¶

1.2.2.1. Indices et comptage d'éléments¶

Pour connaître l'indice d'un élément dans une liste utilise la fonction index. Cette fonction retournera la position de la 1ere occurrence de l'élément.

Par exemple, si on recherche l'indice de l'élément qui possède la valeur val dans une liste listA, entre deux positions i et j, on écrit:

indice = listA.index(val,i,j)

• Si on omet la plage de recherche i,j, la recherche se fait par défaut sur toute la liste.
• Si on donne uniquement le début i la recherche se fait à partir de i jusqu'à la fin de la liste.
• Si la fonction ne trouve pas val dans listA, elle retournera une erreur: ValueError: val is not in list qui signifie que la valeur n'est pas dans la liste.

En cas de doute, et afin d'éviter un renvoie de ce genre d'erreur, on peut tester si un valeur val est un élément de la liste en utilisant l'opérateur in.

In [8]:

listA = [1 ,'a', 'bc', 2.5, 'b', 7, 'a', 9]
listA.index('a') 
print(" position de 'a' =", listA.index('a'))      # recherche 'a' sur toute la liste 
print(' position de  7  =', listA.index(7,3))      # recherche 7 à partir de l'indice 3 jusqu'à la fin
print(" 'a' est un élément de la liste : ", 'a' in listA)
print(" 'c' est un élément de la liste : ", 'c' in listA)

 position de 'a' = 1
 position de  7  = 5
 'a' est un élément de la liste :  True
 'c' est un élément de la liste :  False

Remarque
Il est important de noter que index retourne toujours l'indice de la 1ere occurrence de la valeur recherchée.

Pour trouver la 2nd occurrence, il faut d'abord trouver l'indice de la 1ere, puis réutiliser index en précisant une plage de recherche à partir de l'indice suivant.

Si on veut savoir le nombre d'occurrence n d'un élément elem dans une liste, on écrit n = liste.count(elem)

In [9]:

listA = [1 ,'a', 'abc', 2.5, 'b', 'a', 7, 'a', 9]

i1 = listA.index('a')         # recherche de la 1er position (i1)
i2 = listA.index('a',i1+1)    # recherche de la 2ème position (i2) à partir de i1+1 

print(f"Les 2 premières positions de 'a' dans listA sont : {i1} et {i2}")

n = listA.count('a')
print(f"Le nombre d'occurrence de 'a' dans listA est : {n}")

Les 2 premières positions de 'a' dans listA sont : 1 et 5
Le nombre d'occurrence de 'a' dans listA est : 3

1.2.2.2. Concaténation et réplication¶

Les opérateurs + et * s'appliquent sur les liste de la même manière qu'ils s'appliquent sur les chaînes de caractères.

Une concaténation de deux liste se fait avec l'opérateur + qui produira une nouvelle liste contenant, dans l'ordre, les éléments des deux listes originales.

Répétition d'une liste se fait en la multipliant par un entier. Cela produira une nouvelle liste formée de multiples copies de la liste originale.

In [10]:

listA = ['a','b']
listB = [[1, 2],[3,4]]
print(listA + listB)
print(listB * 3)
print( (listA + listB) * 2)

['a', 'b', [1, 2], [3, 4]]
[[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]]
['a', 'b', [1, 2], [3, 4], 'a', 'b', [1, 2], [3, 4]]

1.2.2.3. Ajout et insertion d'un élément¶

On ajoute un nouvel élément à la fin d'une liste à l'aide de la fonction (ou méthode) append.
On écrit : liste.append(element)

Si on veut insérer un élément à l'intérieur d'une liste à une position donnée, on utilise la fonction insert.
On écrit liste.insert(position,element)

Il est aussi possible d'étendre la liste pour contenir une autre liste avec la fonction extend
On écrit : liste.extend(autre_liste)

In [11]:

listA = list('abcd')
print(f'{listA = }')

listA.append('e')
print(f"Après ajout de 'e' en fin de liste : {listA = }")

listA.insert(2, 'f')
print(f"Après ajout de 'f' en position 2   : {listA = }")

listA.insert(-1, 'g')    # l'indice -1 fait décaler l'élément en fin de list
print(f"Après ajout de 'f' en position 2   : {listA = }")

listA.extend([1,2,3])
print(f"Après extension avec [1, 2, 3]     : {listA = }")

listA = ['a', 'b', 'c', 'd']
Après ajout de 'e' en fin de liste : listA = ['a', 'b', 'c', 'd', 'e']
Après ajout de 'f' en position 2   : listA = ['a', 'b', 'f', 'c', 'd', 'e']
Après ajout de 'f' en position 2   : listA = ['a', 'b', 'f', 'c', 'd', 'g', 'e']
Après extension avec [1, 2, 3]     : listA = ['a', 'b', 'f', 'c', 'd', 'g', 'e', 1, 2, 3]

1.2.2.4. Suppression d'éléments de la liste¶

• On supprime un élément d'une liste en utilisant la fonction remove
  On écrit : liste.remove(element)

• Si l'élément est présent en plusieurs copies, seul la 1ere occurrence est supprimée les autres copies restent.

• Si la valeur spécifiée n'existe pas dans la liste, la fonction renvoie une erreur de type ValueError.

• On peut aussi supprimer un élément d'un liste avec la fonction pop en spécifiant son indice dans la liste. Cette fonction renvoi la valeur de l'élément supprimé
  On écrit : liste.pop([indice]) ou bien liste.pop() pour supprimer le dernier élément.

• On peut également supprimer un élément de la liste en faisant appel à la fonction del qui, de façon générale, permet de détruire des objets python et libérer l'espace occupé.

• Finalement, on peut supprimer d'un coup tous les élément de la liste avec clear (nettoyer)

Ces fonctions sont documentées dans le tutoriel officiel de python "https://docs.python.org/fr/3/tutorial/datastructures.html#more-on-lists"

In [12]:

listA = [1, 2, 3, 4, 5, 6, 4, 3, 2, 1,7]
print(f'Liste originale          : {listA = }')

listA.remove(4)
print(f"Après suppression de '4' : {listA = }")

del(listA[0:3])    # effacement de tous les éléments du début à la position 3 (non inclus)
print(f"Après del de 0 à 2       : {listA = }")

v = listA.pop(1)  # On supprime à l'indice 1
print(f"Après pop de {v}           : {listA = }")

v = listA.pop()  # On supprime en fin de liste
print(f"Après pop de {v}           : {listA = }")

listA.clear()
print(f"Après nettoyage (clear)  : {listA = }")

del(listA)  # la variable listA est supprimée et effacée de la mémoire print(listA) provoquera une erreur

Liste originale          : listA = [1, 2, 3, 4, 5, 6, 4, 3, 2, 1, 7]
Après suppression de '4' : listA = [1, 2, 3, 5, 6, 4, 3, 2, 1, 7]
Après del de 0 à 2       : listA = [5, 6, 4, 3, 2, 1, 7]
Après pop de 6           : listA = [5, 4, 3, 2, 1, 7]
Après pop de 7           : listA = [5, 4, 3, 2, 1]
Après nettoyage (clear)  : listA = []

1.2.2.5. Inversion et tri d'une liste¶

L'inversion d'une liste peut se faire par l'une des deux méthodes suivantes:

1. La méthode reverse permet d'inverser l'ordre des éléments de la liste sur place (elle modifie la liste originale).
2. L'utilisation du découpage slicing [::-1] permet de créer une nouvelle liste avec les éléments dans l'ordre inverse, sans modifier la liste d'origine.

Le découpage de liste s'applique de la même manière que sur les chaînes de caractères. Voir la section 1.2.2.5 de chapitre 1 - Partie 2

Si une liste comporte un même type d'éléments pouvant être être comparables entre eux, alors
elle peut être triée, et on dispose pour cela de deux fonction

1. La fonction sorted renvoie une nouvelle liste triée et laisse la liste originale inchangée.
2. La méthode sort trie la liste sur place, c'est-à-dire qu'elle modifie la liste elle-même.
   Si on precise sort(reverse=True), le trie se fait par ordre inversé.

In [13]:

listA = [1, 8, 2, 6, 5]
#listA = list('abcdedcba')
print(f"ListA originale : {listA = }")

print('Inversion :')
listB = listA[::-1]
print(f"\tInversion sur une autre liste    : {listB = }")

listA.reverse()
print(f"\tInversion sur la liste elle-même : {listA = }")

print('Tri :')
listB = sorted(listA)
listA.sort()
print(f"\tTri sur une autre liste          : {listB = }")
print(f"\tTri sur la liste elle-même       : {listA = }")

print('Tri inversé')
listB = sorted(listA,reverse=True)
listA.sort(reverse=True)

print(f"\tTri inversé sur une autre liste    : {listB = }")
print(f"\tTri inversé sur la liste elle-même : {listA = }")

ListA originale : listA = [1, 8, 2, 6, 5]
Inversion :
	Inversion sur une autre liste    : listB = [5, 6, 2, 8, 1]
	Inversion sur la liste elle-même : listA = [5, 6, 2, 8, 1]
Tri :
	Tri sur une autre liste          : listB = [1, 2, 5, 6, 8]
	Tri sur la liste elle-même       : listA = [1, 2, 5, 6, 8]
Tri inversé
	Tri inversé sur une autre liste    : listB = [8, 6, 5, 2, 1]
	Tri inversé sur la liste elle-même : listA = [8, 6, 5, 2, 1]

1.2.3. Jointure avec des chaînes de caractères¶

Dans le cas particulier où les éléments d'une liste sont des chaînes de caractères, il est possible de réaliser une jointure de ces éléments bout à bout à l'aide d'un séparateur (str) qui peut être vide? ire la joindre. On utilise pour cela la fonction join.

Cette fonction est associée aux chaînes de caractères dans le sens où elle doit être appelée dans le contexte d'une chaîne de caractères.

In [14]:

listA = ['un','deux', 'trois', 'quatre', 'cinq']
print('-'.join(listA))     # séparateur : -
print(''.join(listA))      # séparateur vide
print(' '.join(listA))     # séparateur espace
print(' et '.join(listA))  # séparateur mot 'et'

un-deux-trois-quatre-cinq
undeuxtroisquatrecinq
un deux trois quatre cinq
un et deux et trois et quatre et cinq