Les listes

Méthodes applicables à une liste.

Les listes sont manipulables comme les autres objets, c’est-à-dire on peut appliquer dessus des méthodes.

Le tableau suivant présente quelques méthodes applicables aux listes.

Exemple

liste = [10,2,6,4,8,3,7,9]		# définition d’une liste
print(liste)			# affiche cette liste
liste.sort()				# trie la liste par ordre croissant
print(liste)			# affiche la liste triée.

Ce qui affiche :

[10, 2, 6, 4, 8, 3, 7, 9]
[2, 3, 4, 6, 7, 8, 9, 10]

Modifier les éléments d'une liste.

Modifier la valeur d'un élément d'indice connu.

L=['ba', 'be', 'bi', 'bo', 'bu']

L[2]='fifi'

print(L)

La liste L est modifiée :

['ba', 'be', 'fifi', 'bo', 'bu']

Effacer un élément d'indice connu.

L=['ba', 'be', 'bi', 'bo', 'bu']

del(L[3])

print(L)

L'élément d'indice 3 est ainsi effacé :

['ba', 'be', 'bi', 'bu']

On peut également utiliser pop :

L=['ba', 'be', 'bi', 'bo', 'bu']

L.pop(3)

print(L)

On obtient :

['ba', 'be', 'bi', 'bu']

Avec pop, on peut en fait également récupérer la valeur de l'élément supprimé en même temps :

L=['ba', 'be', 'bi', 'bo', 'bu']

a=L.pop(3)

print(L)
print(a)

On obtient :

['ba', 'be', 'bi', 'bu']
bo

Récupérer l'indice d'un élément.

Si on l'on veut connaître l'indice d'un élément présent dans la liste L, on peut utiliser index :

L=['ba', 'be', 'bi', 'bo', 'bu']

k=L.index('bo')

print(k)

Ce qui donne :

3

Si l'élément a plusieurs occurrences dans la liste L, L.index() renverra le plus petit indice correspondant.

L=['ba', 'be', 'bi', 'bo', 'bu', 'bo', 'by', 'bo']
k=L.index('bo')
print(k)

Ce qui donne :

3

Si l'élément n'est pas présent dans la liste, python renvoie une erreur :

L=['ba', 'be', 'bi', 'bu', 'by']
k=L.index('bo')
print(k)

donne :

ValueError: 'bo' is not in list

Pour éviter une erreur, on peut utiliser count qui permet de retourner le nombre d'éléments de valeur donnée présents dans la liste.

L=['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
compteur=L.count('bo')
print("Nombre de 'bo' présents dans la liste L : ",compteur)

donne :

Nombre de 'bo' présents dans la liste L :  2

et pour éviter une erreur en cas d'absence de la valeur :

L=['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']

if L.count('bo')>0 :
	print("Premier indice de 'bo' dans la liste L : ", L.index('bo') )
else :
	print("Aucun 'bo' dans cette liste.")

Effacer un élément d'indice inconnu.

Avec remove, on peut supprimer la première occurrence d'une valeur donnée dans la liste. Attention, python retourne une erreur si la valeur n'était pas présente.

L=['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']

if L.count('bo')>0 :
	L.remove('bo')
	print("Liste L après remove : ", L )
else :
	print("La liste ne contenait aucun 'bo'.")

donne :

Liste L après remove :  ['ba', 'be', 'bi', 'bu', 'by', 'bo']

Ajouter un élément à une liste

append()

On ajoute un élément à une liste L avec L.append(valeur à ajouter). La nouvelle valeur est insérée en fin de liste (et devient donc le dernier élément de la liste après modification) :

L=['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
L.append('foo')
print(L)
L.append(7)
print(L)

L'affichage obtenu :

['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'foo']
['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'foo', 7]

insert()

On peut insérer un élément à une position précise dans une liste avec insert(position, valeur à insérer) :

L=['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
L.insert(0,'foo')
print(L)
L.insert(2,'fii')
print(L)
L.insert(len(L), 'un ajout à la fin')
print(L)

L'affichage obtenu :

['foo', 'ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
['foo', 'ba', 'fii', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
['foo', 'ba', 'fii', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'un ajout à la fin']

extend()

On peut ajouter les éléments d'une liste M à une liste L :

L=['ba', 'bo', 'be', 'bi', 'bu', 'by']
M=[ 4.8, 9.3, 7.2]
L.extend(M)
print(L)

L'affichage obtenu :

['ba', 'bo', 'be', 'bi', 'bu', 'by', 4.8, 9.3, 7.2]

Concaténation de listes.

Il est possible de concaténer deux listes pour en former une troisième.

L=['ba', 'bo', 'be', 'bi', 'bu', 'by']
M=[ 4.8, 9.3, 7.2]

N=L+M

P=M+L

print("Liste N : ", N)
print("Liste P : ", P)

L'affichage obtenu :

Liste N :  ['ba', 'bo', 'be', 'bi', 'bu', 'by', 4.8, 9.3, 7.2]
Liste P :  [4.8, 9.3, 7.2, 'ba', 'bo', 'be', 'bi', 'bu', 'by']

Copier une liste.

Il est important de comprendre la différence entre une instruction L= M dans laquelle M est une liste et cette même instruction lorsque M est par exemple de type int, float, str.

Ces différences et les "pièges" à éviter sont à découvrir ici.

Fonctions sur les listes

On dispose aussi de fonctions qui attendent une liste comme paramètre ou retournent des listes. Ces fonctions ne modifient pas la liste.

Exemple

s = "un-deux-trois"
mots = s.split ("-") 	# mots est égal à [’un’, ’deux’, ’trois’]
print(mots)
mots.reverse () 		# retourne la liste, mots devient égal à[’trois’, ’deux’, ’un’]
print(mots)		# affiche [’trois’, ’deux’, ’un’]
s2 = ";".join (mots) 	# concaténation des éléments de mots séparés par ";"
print (s2) 			# affiche trois ; deux ; un

Ce qui affiche :

['un', 'deux', 'trois']
['trois', 'deux', 'un']
trois;deux;un

Liste et fonction range

y = [2*i for i in range(0,5)]
print(y)

Ce qui affiche :

[0, 2, 4, 6, 8].

Un autre exemple

y = [i for i in range(0,7) if i % 3 ==0]
print(y)

Ce qui affiche :

[0, 3, 6].

Les listes bidimensionnelles

On veut représenter une table à double entrée, par exemple la table :

Une possibilité est d’utiliser une liste de neuf cases liste = [0, 5, 10, 1, 6, 11, 4, 9, 14]. Mais cette façon de faire n’est pas pratique. Il est donc conseillé de représenter cette table par une liste de trois éléments dont chaque élément est la représentation d’une colonne, c’est-à-dire chaque élément est lui-même une liste de trois nombres. Une telle liste s’alloue comme une liste ordinaire.

t = [[0 for j in range(0,3)]for i in range(0,3)] #tous les coefficients de la matrices sont égaux à 0
for j in range(3):
    for i in range(3):
        t[i][j] = i**2+5*j
for i in range(3):
    print(t[i][0], "  ", t[i][1], "  ", t[i][2])

Ce qui affiche :

0    5    10
1    6    11
4    9    14

Si t est une variable qui représente cette table, la valeur de la case de la colonne i et de la ligne j est simplement désignée par l’expression t [i][j]. Affecter une case de la liste t se fait simplement par l’instruction :

t[i][j] = valeur

Les dictionnaires

Les dictionnaires sont des tableaux plus souples que les listes. Une liste référence les éléments en leur donnant une position : la liste associe à chaque élément une position entière comprise entre 0 et n – 1 si n est la longueur de la liste. Un dictionnaire permet d’associer à un élément autre chose qu’une position entière : ce peut être un entier, un réel, une chaîne de caractères, un tuple.

D’une manière générale, un dictionnaire associe à une valeur ce qu’on appelle une clé. Cette clé permettra de retrouver la valeur associée.

Les dictionnaires sont des listes de couples. Chaque couple contient une clé et une valeur. Chaque valeur est indicée par sa clé. La valeur peut-être de tout type, la clé ne doit être ni une liste, ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un type différent des autres clés ou valeurs.

Exemple

tel = { "Lea":"06 53 21 45 78", "Tom":"06 45 12 23 89" }
y = { } # crée un dictionnaire vide
z = dict() # crée aussi un dictionnaire vide
print (te["Lea"])

Ce qui affiche :

06 53 21 45 78

Les indices ne sont plus entiers mais des chaînes de caractères pour cet exemple.

La plupart des fonctions disponibles pour les listes sont interdites pour les dictionnaires comme la concaténation ou l’opération de multiplication (*). Il n’existe plus non plus d’indices entiers pour repérer les éléments, le seul repère est leur clé.

Exemple

d = { "un":1, "zéro":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
"six":6, "sept":7, "huit":8, "neuf":9, "dix":10 }
key = d.keys()
for k in key :
    print(d[k]," : ",k)

Ce qui affiche :

9  :  neuf
8  :  huit
4  :  quatre
0  :  zéro
3  :  trois
6  :  six
1  :  un
10  :  dix
2  :  deux
7  :  sept
5  :  cinq