Informatique

Chapitre 6 : Listes

Informatique (Chap. 6) Listes 1 / 74

Contenu du chapitre
Chapitre 6. Listes
1 Une liste est une séquence d’éléments

2 Listes et opérateurs

3 Méthodes sur les listes

4 Arguments de la ligne de commande

5 Opérations fréquentes sur les listes

6 Listes et chaînes

7 Objets et valeurs

8 Matrices

9 Erreurs fréquentes et debug

10 Glossaire

Informatique (Chap. 6) Listes 2 / 74

 Une liste est une séquence d’éléments

Une liste est une séquence

d’éléments

Informatique (Chap. 6) Listes 3 / 74

 Une liste est une séquence d’éléments

Une liste est une séquence d’élements

Comme une chaîne de caractères, une liste est une séquence de

valeurs, mais :
dans une chaîne les valeurs sont des caractères, dans une liste
elles peuvent être de n’importe quel type (et pas forcément le
même pour tous les éléments).
une chaîne est une séquence immuable, une liste est une
séquence que l’on peut modifier.
une liste est définie en spécifiant ses éléments, séparés par des
virgules, entre crochets (par ex. : [1, 2, 3])

Informatique (Chap. 6) Listes 4 / 74

 Une liste est une séquence d’éléments

Création de listes

Remarques :
une liste peut être vide
une liste peut contenir des valeurs de types différents
une liste peut contenir des listes, des tuples, ou n’importe quelle
autre type de valeur
la fonction len peut être appliquée sur une liste
>>> empty = []
>>> type(empty)
<class ’list’>
>>> data = [’text’, 2.0, 1, [2, 3]]
>>> print (data)
[’text’, 2.0, 1, [2, 3]]
>>> len(data)
4

Informatique (Chap. 6) Listes 5 / 74

 Une liste est une séquence d’éléments

Accéder et modifier les éléments d’une liste.

On peut accéder aux éléments d’une liste grâce à l’opérateur [.]. Les
indices fonctionnent de la même manière que pour les chaînes de
caractères.
>>> data = [’text’, 2.0, 1, [2, 3]]
>>> print ( data[0] )
text
>>> print ( data[-1] )
[2, 3]

Informatique (Chap. 6) Listes 6 / 74

 Une liste est une séquence d’éléments

Accéder et modifier les éléments d’une liste.

On peut représenter les listes par un diagramme d’état qui illustre les
relations entre les indices et les éléments.
>>> empty = []
>>> numbers = [1, 3, 6]

empty

numbers 0 1
1 3
2 6

Informatique (Chap. 6) Listes 7 / 74

 Une liste est une séquence d’éléments

Accéder et modifier les éléments d’une liste.

>>> data = [’text’, 2.0, 1, [2, 3]]

data
0 ’text’
1 2.0
2 1
3
0 2
1 3

Informatique (Chap. 6) Listes 8 / 74

 Une liste est une séquence d’éléments

Accéder et modifier les éléments d’une liste.

Contrairement aux chaînes qui sont immuables, on peut modifier les
éléments d’une liste.
>>> mot = ’bonjour’
>>> numbers = [1, 3, 6]
>>> mot[0] = ’B’

Traceback (most recent call last):

File "<pyshell#36>", line 1, in <module>
mot[0] = ’B’
TypeError: ’str’ object does not support item assignment
>>> numbers[0] = 12
>>> print (numbers)
[12, 3, 6]

numbers 0 1
12
1 3
2 6

Informatique (Chap. 6) Listes 9 / 74

 Une liste est une séquence d’éléments

Boucles for

Une liste est une séquence : peut être utilisée dans une boucle for.
data = [’text’, 2.0, 1, [2, 3]]

for item in data:

print (item, type(item))

text <class ’str’>

2.0 <class ’float’>
1 <class ’int’>
[2, 3] <class ’list’>

Remarque : nous l’avions déjà utilisé avec la fonction range qui

renvoie une séquence d’entiers.

Informatique (Chap. 6) Listes 10 / 74

 Une liste est une séquence d’éléments

Boucles for

Si on a besoin d’accéder aux indices de la liste, une manière de faire

est d’utiliser range et len :
for i in range(len(numbers)):
numbers[i] = numbers[i] * 2

Une boucle for sur une liste vide n’exécute jamais son corps.
for x in []:
print (’This never happens.’)

Informatique (Chap. 6) Listes 11 / 74

 Listes et opérateurs

Listes et opérateurs

Informatique (Chap. 6) Listes 12 / 74

 Listes et opérateurs

Listes et opérateurs

Comme pour les chaînes, l’opérateur + concatène deux listes,

l’opérateur * répète une liste un certain nombre de fois.
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b
>>> print (c)
[1, 2, 3, 4, 5, 6]
>>> [0] * 4
[0, 0, 0, 0]
>>> a * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Informatique (Chap. 6) Listes 13 / 74

 Listes et opérateurs

Opérateur in

Comme pour toutes les séquences, l’opérateur in est applicable sur

une liste.
>>> cheeses = [’Cheddar’, ’Edam’, ’Gouda’]
>>> ’Edam’ in cheeses
True
>>> ’Brie’ in cheeses
False

Informatique (Chap. 6) Listes 14 / 74

 Listes et opérateurs

Tranches de listes

L’opérateur [:] fonctionne aussi sur les listes. Il peut être utilisé dans
le membre gauche d’une assignation.
>>> t = list(range(10))
>>> print (t)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> t[1:3]
[1, 2]
>>> t[:4]
[0, 1, 2, 3]
>>> t[3:]
[3, 4, 5, 6, 7, 8, 9]
>>> t[1:3] = [34,26]
>>> print (t)
[0, 34, 26, 3, 4, 5, 6, 7, 8, 9]

Informatique (Chap. 6) Listes 15 / 74

 Listes et opérateurs

Copie d’une liste

Comme les listes sont mutables, il est parfois utile de faire une copie
avant de les modifier. On peut créer une copie avec une “tranche
complète”.
>>> copy = t[:]
>>> t[4:6] = [0] * 2
>>> print (t, copy)
[0, 34, 26, 3, 0, 0, 6, 7, 8, 9] [0, 34, 26, 3, 4, 5, 6, 7, 8, 9]

Informatique (Chap. 6) Listes 16 / 74

 Listes et opérateurs

Exercice

Problème
Construire la liste suivante :

[1, 3, 0, 0, 9, 11, 13, 15, 1, 3, 0, 0, 9, 11, 13, 15]

Informatique (Chap. 6) Listes 17 / 74

 Listes et opérateurs

Exercice

Problème
Construire la liste suivante :

[1, 3, 0, 0, 9, 11, 13, 15, 1, 3, 0, 0, 9, 11, 13, 15]

>>> liste = list(range(1,16,2))
>>> print (liste)
[1, 3, 5, 7, 9, 11, 13, 15]
>>> liste[2:4] = [0] * 2
>>> print (liste)
[1, 3, 0, 0, 9, 11, 13, 15]
>>> liste = liste * 2
>>> print (liste)
[1, 3, 0, 0, 9, 11, 13, 15, 1, 3, 0, 0, 9, 11, 13, 15]

Informatique (Chap. 6) Listes 18 / 74

 Méthodes sur les listes

Méthodes sur les listes

Informatique (Chap. 6) Listes 19 / 74

 Méthodes sur les listes

Méthodes sur les listes

Les objets “liste” possèdent une série de méthodes utiles.

>>> dir(list)
[...
’append’, ’count’, ’extend’, ’index’, ’insert’, ’pop’, ’remove’,
’reverse’, ’sort’]

Informatique (Chap. 6) Listes 20 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode append ajoute un nouvel élément à la fin de la liste.

>>> help(list.append)
Help on method_descriptor:

append(...)
L.append(object) -- append object to end

>>> t = [’a’, ’b’, ’c’]

>>> t.append(’d’)
>>> print (t)
[’a’, ’b’, ’c’, ’d’]

Informatique (Chap. 6) Listes 21 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode extend prend une liste en argument et ajoute tous ces

éléments en fin de la liste.
>>> help(list.extend)
Help on method_descriptor:

extend(...)
L.extend(iterable) -- extend list by appending elements from the iterable

>>> t1 = [’a’, ’b’, ’c’]

>>> t2 = [’d’, ’e’]
>>> t1.extend(t2)
>>> print (t1)
[’a’, ’b’, ’c’, ’d’, ’e’]

Informatique (Chap. 6) Listes 22 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode count compte toutes les occurrences d’une valeur passée

en argument.
>>> help(list.count)
Help on method_descriptor:

count(...)
L.count(value) -> integer -- return number of occurrences of value

>>> t = [’a’, ’b’, ’c’, ’a’]

>>> t.count(’a’)
2

Informatique (Chap. 6) Listes 23 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode index retourne l’indice de la première occurrence d’une
valeur donnée (des arguments optionnels permettent de limiter la
recherche à un intervalle d’indices).
>>> help(list.index)
Help on method_descriptor:

index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

>>> t = [’a’, ’b’, ’c’, ’a’]

>>> t.index(’a’)
0
>>> t.index(’z’)

Traceback (most recent call last):

File "<pyshell#78>", line 1, in <module>
t.index(’z’)
ValueError: list.index(x): x not in list
>>> t.index(’a’,1)
3

Informatique (Chap. 6) Listes 24 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode sort trie les éléments d’une liste. Tous ses arguments
sont optionnels : reverse permet de trier par ordre décroissant, les
deux autres arguments seront détaillés plus tard.
>>> help(list.sort)
Help on method_descriptor:

sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

>>> t = [’d’, ’c’, ’e’, ’b’, ’a’]

>>> t.sort()
>>> print (t)
[’a’, ’b’, ’c’, ’d’, ’e’]
>>> t.sort(reverse=True)
>>> print (t)
[’e’, ’d’, ’c’, ’b’, ’a’]

Informatique (Chap. 6) Listes 25 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode insert permet d’insérer un élément à un endroit donné

de la liste.
>>> help(list.insert)
Help on method_descriptor:

insert(...)
L.insert(index, object) -- insert object before index

>>> t = [’a’, ’b’, ’c’]

>>> t.insert(0,’z’)
>>> print (t)
[’z’, ’a’, ’b’, ’c’]
>>> t.insert(2,’x’)
>>> print (t)
[’z’, ’a’, ’x’, ’b’, ’c’]

Informatique (Chap. 6) Listes 26 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode remove supprime la première occurence d’une valeur

donnée.
>>> help(list.remove)
Help on method_descriptor:

remove(...)
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

>>> t = [’a’, ’b’, ’c’]

>>> t.remove(’z’)

Traceback (most recent call last):

File "<pyshell#100>", line 1, in <module>
t.remove(’z’)
ValueError: list.remove(x): x not in list
>>> t.remove(’b’)
>>> print (t)
[’a’, ’c’]

Informatique (Chap. 6) Listes 27 / 74

 Méthodes sur les listes

Méthodes sur les listes

La méthode pop supprime le dernier élément de la liste et retourne
l’élément supprimé. Si l’argument optionnel est défini, supprime et
retourne l’élément situé à l’indice donné.
>>> help(list.pop)
Help on method_descriptor:

pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

>>> t = [’a’, ’b’, ’c’, ’d’]

>>> deleted = t.pop()
>>> print (deleted)
d
>>> print (t)
[’a’, ’b’, ’c’]
>>> t.pop(1)
’b’
>>> print (t)
[’a’, ’c’]

Informatique (Chap. 6) Listes 28 / 74

 Méthodes sur les listes

Supprimer les éléments d’une liste

Outre les méthodes remove et pop, l’opérateur del peut également
être utilisé pour supprimer un élément à partir d’un indice (ou d’une
tranche d’indices).
>>> t = [’a’, ’b’, ’c’, ’d’]
>>> x = t.pop(1)
>>> print (x)
b
>>> print (t)
[’a’, ’c’, ’d’]
>>> x = t.remove(’c’)
>>> print (x)
None
>>> print (t)
[’a’, ’d’]
>>> del t[1]
>>> print (t)
[’a’]
>>> t = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]
>>> del t[1:5]
>>> print (t)
[’a’, ’f’]

Informatique (Chap. 6) Listes 29 / 74

 Méthodes sur les listes

Exercice
Problème
Ecrire un script qui demande à l’utilisateur le nom d’un fichier de texte
(.txt), puis affiche les mots contenus dans le fichier par ordre
alphabétique (grâce à une liste). Un même mot ne peut pas être
affiché deux fois. Tous les caractères qui ne sont pas des lettres ou
des chiffres seront supprimés dans la création de la liste de mots.

Hints :
la méthode isalnum invoquée sur une chaîne retourne vrai ssi
tous les caractères de la chaîne sont des lettres ou des chiffres.
la méthode split invoquée sur une chaîne retourne une liste des
“mots” de la chaîne (c-à-d les sous-chaînes séparées par des
caractères blancs1 ). On peut spécifier d’autres séparateurs que
des blancs avec le paramètre optionnel sep.
1
Espaces, retours à la ligne, tabulations, etc.
Informatique (Chap. 6) Listes 30 / 74
 Méthodes sur les listes

Exercice

>>> help(str.split)
Help on method_descriptor:

split(...)
S.split([sep [,maxsplit]]) -> list of strings

Return a list of the words in the string S, using sep as the

delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.

>>> ’Un deux trois’.split()

[’Un’, ’deux’, ’trois’]
>>> ’000-123456-47’.split(’-’)
[’000’, ’123456’, ’47’]

Informatique (Chap. 6) Listes 31 / 74

 Méthodes sur les listes

Exercice

On définit une fonction keepAlnum qui retourne la chaîne passée en

argument, en lui ayant retiré tous les caractères qui ne sont pas des
lettres ou des chiffres.
def keepAlnum(s):
res = ’’
for letter in s:
if letter.isalnum():
res = res + letter
return res

>>> keepAlnum(’he23.?56th’)
’he2356th’

Informatique (Chap. 6) Listes 32 / 74

 Méthodes sur les listes

Exercice

Solution :
filename = input(’Nom du fichier: ’)
file = open(filename)

wordsList = []
for line in file:
for word in line.split():
cleanWord = keepAlnum(word)
if not cleanWord in wordsList:
wordsList.append(cleanWord)

wordsList.sort()
print (wordsList)

Informatique (Chap. 6) Listes 33 / 74

 Arguments de la ligne de commande

Arguments de la ligne de
commande

Informatique (Chap. 6) Listes 34 / 74

 Arguments de la ligne de commande

Arguments de la ligne de commande

La fonction input permet d’obtenir des entrées de l’utilisateur.

Un autre moyen (rapide et donc souvent apprécié à l’utilisation)

d’obtenir des entrées de l’utilisateur, est de récupérer les “arguments
de la ligne de commande”.

Exemples :
la commande cd myDir vous permet de changer de répertoire
dans une console. Le nom du répertoire (myDir) est un argument
de la commande cd.
la commande python myscript.py vous permet d’interpréter le
script myscript.py. Le nom du script est un argument de la
commande python qui lance l’interpréteur.

Informatique (Chap. 6) Listes 35 / 74

 Arguments de la ligne de commande

Arguments de la ligne de commande

Tous les argments passés après la commande python (et séparés par
des espaces2 ) sont disponibles via l’attribut argv du module sys. La
valeur argv est une liste qui contient ces arguments.

Fichier args.py :
import sys
print (sys.argv)

La commande “python args.py” produit :

[’args.py’]

La commande “python args.py un deux trois "x + y"” produit :

[’args.py’, ’un’, ’deux’, ’trois’, ’x + y’]

2
Pour passer un argument qui contient des espaces, on peut le mettre entre
apostrophes.
Informatique (Chap. 6) Listes 36 / 74
 Arguments de la ligne de commande

Arguments de la ligne de commande

Amélioration du script qui trie les mots d’un fichier :

...
import sys

filename = ’’
if len(sys.argv) < 2:
filename = input(’Nom du fichier: ’)
else:
filename = sys.argv[1]

file = open(filename)

...

Informatique (Chap. 6) Listes 37 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les

listes

Informatique (Chap. 6) Listes 38 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Pour additionner tous les éléments d’une séquence, on peut utiliser

une boucle :
def add_all(t):
total = 0
for x in t:
total += x
return total

>>> t = range(1,11)
>>> add_all(t)
55

Remarques :
total += x est équivalent à total = total + x
une variable comme total qui accumule progressivement la
somme des éléments est appelée un accumulateur

Informatique (Chap. 6) Listes 39 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Additionner les éléments d’une liste est une opération fréquente.

Python offre une fonction qui permet également de le faire.
>>> t = [1, 2, 3]
>>> sum(t)
6

Une opération qui combine une séquence d’éléments en une seule

valeur est appelée une réduction : séquence → valeur.

Informatique (Chap. 6) Listes 40 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Une autre opération fréquente : traverser une séquence en en

construisant une nouvelle. Par exemple, la fonction suivante prend
une liste de chaînes en argument et retourne une liste qui ‘capitalise”
les mots de la liste de départ3 .
def capitalize_all(t):
res = []
for s in t:
res.append(s.capitalize())
return res

>>> liste = [’hello’, ’bonjour’, ’dag’]

>>> capitalize_all(liste)
[’Hello’, ’Bonjour’, ’Dag’]

3
On utilise la méthode capitalize sur chaque chaîne : elle met la première
lettre en majuscule.
Informatique (Chap. 6) Listes 41 / 74
 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

def capitalize_all(t):
res = []
for s in t:
res.append(s.capitalize())
return res

res est initialisé avec une liste vide; à chaque itération de la

boucle, on ajoute le nouvel élément : res est une sorte
d’accumulateur.
Une opération qui applique une fonction (ici, capitalize) sur
chaque élément d’une séquence est appelée un mapping.

Informatique (Chap. 6) Listes 42 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Une autre opération fréquente : sélectionner certains éléments d’une

séquence et retourner une sous-séquence. Par exemple, la fonction
suivante ne retourne que les chaînes d’une liste qui sont en
majuscules.
def only_upper(t):
res = []
for s in t:
if s.isupper():
res.append(s)
return res

>>> liste = [’Hello’, ’bonjour’, ’DAG’]

>>> only_upper(liste)
[’DAG’]

une opération qui sélectionne certains éléments et en rejette

d’autres est appelée un filtre.

Informatique (Chap. 6) Listes 43 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Problème
Ecrire une fonction qui prend une liste de nombre entiers en
paramètres et qui retourne la somme cumulative, c-à-d une nouvelle
liste telle que l’élément d’indice i soit la somme des i + 1 premiers
éléments.
Par exemple, la somme cumulative de [1, 2, 3] est [1, 3, 6].

Informatique (Chap. 6) Listes 44 / 74

 Opérations fréquentes sur les listes

Opérations fréquentes sur les listes

Solution :
def cum_sum(t):
res = []
sum = 0
for x in t:
sum += x
res.append(sum)
return res

>>> cum_sum([1,2,3])
[1, 3, 6]
>>> cum_sum(range(10))
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]

Informatique (Chap. 6) Listes 45 / 74

 Listes et chaînes

Listes et chaînes

Informatique (Chap. 6) Listes 46 / 74

 Listes et chaînes

Listes et chaînes

Un str est une séquence de caractères et une liste est une séquence
de valeurs, mais une liste de caractères n’est pas la même chose
qu’une chaîne.

Pour convertir une chaîne en liste, on peut utiliser list.

>>> s = ’hello’
>>> t = list(s)
>>> print (t)
[’h’, ’e’, ’l’, ’l’, ’o’]

Comme list est le nom d’une fonction, on ne peut pas l’utiliser

comme nom de variable (mais liste peut l’être).
En général, on évite d’utiliser la lettre l car elle ressemble trop au
nombre 1, c’est pourquoi t est souvent utilisé dans les exemples.

Informatique (Chap. 6) Listes 47 / 74

 Listes et chaînes

Listes et chaînes
La fonction list sépare une chaîne en caractères individuellement.
Nous avons vu la méthode split qui permet de séparer une chaîne
en mots ou en sous-chaînes.

La méthode join fait le contraire de split. C’est une méthode sur les
chaînes : on l’invoque sur le délimiteur et on passe la liste en
paramètre.
>>> s = ’to be or not to be’
>>> t = s.split()
>>> print (t)
[’to’, ’be’, ’or’, ’not’, ’to’, ’be’]
>>> s = ’spam*spam*spam’
>>> delimiter = ’*’
>>> s.split(delimiter)
[’spam’, ’spam’, ’spam’]
>>> delimiter = ’ ’
>>> delimiter.join(t)
’to be or not to be’
>>> ’’.join(t)
’tobeornottobe’
Informatique (Chap. 6) Listes 48 / 74
 Objets et valeurs

Objets et valeurs

Informatique (Chap. 6) Listes 49 / 74

 Objets et valeurs

Objets et valeurs

Si on exécute les assignations suivantes, on sait que a et b réfèrent à

une chaîne, mais on ne sait pas si ces variables réfèrent la même
chaîne.
>>> a = ’banana’
>>> b = ’banana’

Il y a deux possibilités :

a ’banana’ a
’banana’
b ’banana’ b

Dans un cas, a et b réfèrent deux différents objets qui ont la même

valeur. Dans l’autre, elles réfèrent au même objet.

Informatique (Chap. 6) Listes 50 / 74

 Objets et valeurs

Objets et valeurs

L’opérateur is permet de tester si deux variables réfèrent le même

objet.
>>> a = ’banana’
>>> b = ’banana’
>>> a is b
True

Donc, dans ce cas, Python crée un seul objet “chaîne” et les deux
variables réfère à cet objet.

a
’banana’
b

Informatique (Chap. 6) Listes 51 / 74

 Objets et valeurs

Objets et valeurs

Par contre, dans le cas de deux listes, deux objets sont créés.
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a is b
False

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

on dit que les deux listes sont equivalentes, car elles ont les
mêmes éléments, mais elles ne sont pas identiques, car elle ne
sont pas le même objet.
si deux objets sont identiques, ils sont aussi équivalents, mais le
contraire n’est pas toujours vrai.

Informatique (Chap. 6) Listes 52 / 74

 Objets et valeurs

Objets et valeurs
Jusqu’à présent, on a utilisé les mots “objet” et “valeur” de manière
interchangeable, mais il est plus précis de dire qu’un objet possède
une valeur et un type.

De plus, un objet a accès aux attributs et méthodes qui sont définis en

fonction de son type.

Si on exécute a = [1, 2, 3] :
la variable a réfère à un objet (de type liste),
la valeur de l’objet est une séquence particulière d’éléments,
si un autre objet “liste” a les mêmes éléments, on dira qu’il a la
même valeur,
on peut invoquer sur a toutes les méthodes définies pour les
objets de type “liste”.

Informatique (Chap. 6) Listes 53 / 74

 Objets et valeurs

Objets et valeurs

>>> a = ’banana’
>>> b = ’banana’
>>> c = [1, 2, 3]
>>> d = [1, 2, 3]
>>> a is b
True
>>> c is d
False

Si on modifie par après une des deux listes, l’autre n’est pas modifiée :
elles ont “pour le moment” la même valeur, mais elles peuvent évoluer
de manière indépendante, puisqu’elles sont des objets différents.

Informatique (Chap. 6) Listes 54 / 74

 Objets et valeurs

Alias

Cependant, dans certains cas, on veut que deux variables réfèrent le

même objet.

On appelle cela un alias et on peut le faire en assignant la première

variable à la seconde.
>>> a = [1, 2, 3]
>>> b = a
>>> a is b
True

a
[1, 2, 3]
b

Informatique (Chap. 6) Listes 55 / 74

 Objets et valeurs

Alias

Modifier un objet qui est référé par plusieurs variables est visible
depuis l’ensemble de celles-ci.
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> c = b
>>> print (a, b, c)
[1, 2, 3] [1, 2, 3] [1, 2, 3]
>>> a is b, a is c, b is c
(False, False, True)
>>> a[0] = 4
>>> print (a, b, c)
[4, 2, 3] [1, 2, 3] [1, 2, 3]
>>> b[0] = 5
>>> print (a, b, c)
[4, 2, 3] [5, 2, 3] [5, 2, 3]

Exercice : dessiner le diagramme d’états des variables a, b et c

Informatique (Chap. 6) Listes 56 / 74

 Objets et valeurs

Objets mutables en arguments

Quand on passe une liste en argument d’une fonction, la fonction

reçoit une référence vers la liste : le paramètre de la liste est un alias
et les modifications de la liste sont visibles en dehors de la fonction.
>>> def delete_head(t):
del t[0]

>>> letters = [’a’, ’b’, ’c’]

>>> delete_head(letters)
>>> print (letters)
[’b’, ’c’]

__main__
letters
0 ’a’
1 ’b’
delete_head 2 ’c’
t

Informatique (Chap. 6) Listes 57 / 74

 Objets et valeurs

Objets mutables en arguments

Il est important de faire la distinction entre ce qui modifie une liste

(comme la méthode append) et ce qui retourne une nouvelle liste
(comme l’opérateur +).
>>> t1 = [1, 2]
>>> t2 = t1.append(3)
>>> print (t1, t2)
[1, 2, 3] None
>>> t3 = t1 + [3]
>>> print (t1, t3)
[1, 2, 3] [1, 2, 3, 3]

Informatique (Chap. 6) Listes 58 / 74

 Objets et valeurs

Objets mutables en arguments

Cette distinction est importante quand on écrit une fonction qui doit
modifier un liste passée en argument. Par exemple, l’opérateur [:]
retourne une nouvelle liste (tranche). La fonction suivante, supposée
supprimer le premier élément de la liste, ne fonctionnera pas :
>>> def delete_head(t):
t = t[1:]

>>> letters = [’a’, ’b’, ’c’]

>>> delete_head(letters)
>>> print (letters)
[’a’, ’b’, ’c’]

l’opérateur crée une nouvelle liste et t réfère maintenant cette

nouvelle liste
le fait d’avoir changé la référence de t (intuition : la flèche sur les
diagrammes d’état), ne signifie pas qu’on a touché à celle de
letters (qui réfère toujours la liste de départ)

Informatique (Chap. 6) Listes 59 / 74

 Objets et valeurs

Objets mutables en arguments

Une solution : retourner la nouvelle liste.

>>> def delete_head(t):
return t[1:]

>>> letters = [’a’, ’b’, ’c’]

>>> letters = delete_head(letters)
>>> print (letters)
[’b’, ’c’]

Exercice : dessiner les diagrammes qui illustrent les deux versions de

la fonction delete_head et leurs appels.

Informatique (Chap. 6) Listes 60 / 74

 Matrices

Matrices

Informatique (Chap. 6) Listes 61 / 74

 Matrices

Matrices
 
7 6 5
M = 1 8 3
2 4 9

En Python, une matrice peut être représentée par une liste de listes,
où chaque sous-liste est une ligne de la matrice

Informatique (Chap. 6) Listes 62 / 74

 Matrices

Matrices

 
7 6 5
M= 1
 8 3
2 4 9

M = [[ligne 0], [ligne 1], [ligne 2], ...]

M = [[7, 6, 5], [1, 8, 3], [2, 4, 9]]

M[i][j] = élément de la matrice en ligne i et colonne j

print(M[1][2]) → 3

Informatique (Chap. 6) Listes 63 / 74

 Matrices

Addition de matrices

     
4 2 7 7 −3 2 11 −1 9
1
 3 2 + 9
 4 −7 = 10
 7 −5
6 9 7 4 11 2  10 20 9 
−1 5 8 4 9 5 3 14 13

A = [ [4, 2, 7], [1, 3, 2], [6, 9, 7], [-1, 5, 8 ] ]

B = [ [7, -3, 2], [9, 4, -7], [4, 11, 2], [4, 9, 5] ]

nb_lignes = len(A)
nb_colonnes = len(A[0])

C = [[0]*nb_colonnes]*nb_lignes

for i in range(nb_lignes):
for j in range(nb_colonnes):
C[i][j] = A[i][j] + B[i][j]

Informatique (Chap. 6) Listes 64 / 74

 Matrices

Transposition d’une matrice

 
  3 2 −2
3 7 9 1 7 6 5 
A= 2 6 3 7 C = Transpose(A) = 
9

3 8 
−2 5 8 4
1 7 4

A = [ [3, 7, 9, 1], [2, 6, 3, 7], [-2, 5, 8, 4] ]

nb_lignes = len(A)
nb_colonnes = len(A[0])

C = [[0]*nb_lignes]*nb_colonnes

for i in range(nb_lignes):
for j in range(nb_colonnes):
C[j][i] = A[i][j]

Informatique (Chap. 6) Listes 65 / 74

 Matrices

Multiplication de matrices

 
  4 7 9  
2 9 1 3 145 2 76
12 −1 5 
7 −2 6 4 ×  =  80 75 61
8 6 −2
−2 7 9 11 225 0 54
7 −3 5

A = [ [2, 9, 1, 3], [7, -2, 6, 4], [-2, 7, 9, 11] ]

B = [ [4, 7, 9], [12, -1, 5], [8, 6, -2], [7, -3, 5] ]

nb_lignes_A = len(A)
nb_lignes_B = len(B)
nb_colonnes_B = len(B[0])

C = [[0]*nb_colonnes_B]*nb_lignes_A

for i in range(nb_lignes_A):
for j in range(nb_colonnes_B):
for k in range(nb_lignes_B):
C[i][j] += A[i][k] * B[k][j]

Informatique (Chap. 6) Listes 66 / 74

 Matrices

Matrices : numpy

import numpy

A = numpy.array([ [12, 3, 7], [-1, 8, 4], [1, 9, 2] ])

B = numpy.array([ [8, 3, 4], [12, 1, 9], [3, -2, 5] ])

print(A[1][1])
C = A*2
D = A.transpose()
E = A + B
F = A.dot(B)

Informatique (Chap. 6) Listes 67 / 74

 Erreurs fréquentes et debug

Erreurs fréquentes et debug

Informatique (Chap. 6) Listes 68 / 74

 Erreurs fréquentes et debug

Erreurs fréquentes et debug

La plupart des méthodes sur les listes modifient celles-ci (et

retournent None). C’est l’inverse pour les méthodes sur les chaînes
(qui ne pourraient pas modifier l’argument) : elles retournent une
nouvelle chaîne.

Exemple :
word = word.strip()
t = t.sort() # FAUX: t refere None !

Il faut donc lire avec attention la documentation des fonctions,

méthodes et opérateurs; et écrire votre propre documentation de
manière claire. Le mode interactif est très utile pour tester rapidement
l’utilisation d’une fonction ou d’une méthode.

Informatique (Chap. 6) Listes 69 / 74

 Erreurs fréquentes et debug

Erreurs fréquentes et debug

Voir la documentation des méthodes et opérateurs communs aux

séquences (comme les listes ou les chaînes) :
http://docs.python.org/py3k/library/stdtypes.html
Aller à la section ‘Sequence Types — list, tuple, range”

Informatique (Chap. 6) Listes 70 / 74

 Erreurs fréquentes et debug

Erreurs fréquentes et debug

Faire une copie quand c’est nécessaire : une méthode comme sort
modifie la liste sur laquelle elle est invoquée. Exemple de copie avant
modification :
orig = t[:]
t.sort()

Informatique (Chap. 6) Listes 71 / 74

 Erreurs fréquentes et debug

Erreurs fréquentes et debug

Ces instructions sont correctes pour ajouter un élément :

t.append(x)
t = t + [x]

Ces instructions sont erronées :

t.append([x])
t = t.append(x)
t + [x]
t = t + x

Exercice : essayez ces exemples interactivement pour comprendre ce

qu’ils font (seule la dernière instruction provoque une exception).

Informatique (Chap. 6) Listes 72 / 74

 Glossaire

Glossaire

Informatique (Chap. 6) Listes 73 / 74

 Glossaire

Glossaire

élément : une des valeurs dans une liste (ou une autre séquence).
indice : valeur entière qui indique la position d’un élément dans une liste (ou une
séquence).
liste : séquence de valeurs qui peuvent être modifiées et mises entre crochets droits.
liste imbriquée : liste qui est un élément d’une autre liste.
accumulateur : variable utilisée dans une boucle pour additionner ou accumuler un
résultat.
object : quelque chose qu’une variable peut référer. Un objet possède un type et une
valeur. On peut lui appliquer des méthodes définies en fonction de son type.
référence : l’association entre une variable et sa valeur (c-à-d la valeur de son objet).
alias : assigner une variable depuis une autre, pour qu’elles réfèrent au même objet.
équivalent : ayant la même valeur.
identique : être le même objet (ce qui implique l’équivalence).

Informatique (Chap. 6) Listes 74 / 74