Ch 5. Séquences. 1 Présentation des trois types de séquence

PTSI2 – 2016/2017 – Info
Lycée La Martinière-Monplaisir – Lyon
Ch 5. Séquences.
1
Présentation des trois types de séquence
Les séquences sont composées d’un nombre fini d’éléments auxquels on peut accéder par un indice,
à l’aide des crochets : s[k] donnera le kième élément de la séquence s (attention, la numérotation
commence à 0).
Nous allons voir les trois types suivants de séquences :
H les listes
H les tuples
H les chaînes de caractères
Les objets créés par l’instruction range peuvent aussi êtres considérés comme des séquences.
Tous ces objets sont dits itérables car l’on peut parcourir leurs éléments à l’aide d’une boucle for.
La syntaxe est : for e in seq :
1.a
les listes
— Une liste python est une succession d’objets séparés par une virgule, délimitée par des crochets
[ et ].
— Elle peut contenir des objets de type quelconque.
— Une liste est dite mutable c’est-à-dire que l’on peut en modifier (voire en supprimer) un ou
plusieurs éléments.
La liste vide est désignée par [].
Python shell
>>> a = [1, 2.14, ’bonjour’]
>>> type(a)
<class ’list’>
>>> a[0]
1
>>> a[2]
’bonjour’
>>> a[1] = 3.14
>>> a
[1, 3.14, ’bonjour’]
1
1.b
Les tuples
Un tuple ressemble à une liste :
— C’est une succession d’objets séparés par une virgule, délimitée par des parenthèses ( et ).
— Un tuple peut lui aussi contenir des objets de type quelconque.
— Mais c’est une séquence non mutable.
Un tuple permet donc de "packer" un ensemble de données qu’on ne souhaite pas modifier individuellement.
Le tuple vide est désigné par ().
Python shell
>>> t = (1, 4, ’abc’, -3)
>>> type(t)
<class ’tuple’>
>>> t[1]
4
>>> t[0] = 5
Traceback (most recent call last):
File "<pyshell#87>", line 1, in <module>
t[0] = 5
TypeError: ’tuple’ object does not support item assignment
1.c
Les chaînes de caractères
— Les chaînes de caractères sont délimitées par des quotes (’bonjour’), des guillemets ("bonjour")
ou des guillemets triples ("""bonjour""").
— Les chaînes sont des séquences non mutables.
Python shell
>>> c = "hello world"
>>> type(c)
<type ’str’>
>>> c[5]
’ ’
>>> c[0] = ’y’
Traceback (most recent call last):
File "<pyshell#38>", line 1, in <module>
c[0] = ’y’
TypeError: ’str’ object does not support item assignment
2
2
Propriétés communes aux séquences
Voici un aperçu des principales instructions communes aux séquences ; s et t désignent deux séquences
du même type.
Instruction
Effet
s[k]
s[-1]
s[-k]
len(s)
s + t
s * n
s[i:j]
s[i:j:k]
min(s)
max(s)
sum(s)
x in s
x not in s
Bien noter que, si n est la longueur de la séquence s, l’indice du dernier élément est n-1 (et pas n) :
ceci est dû à l’indiçage qui commence à 0.
Illustrons avec des listes, des tuples, des chaînes de caractère :
Python shell
>>> a = [13, 4, ’f’, ’bonjour’, -5] # une liste
>>> t = (10, 2.5, -7) # un tuple
>>> c = "b a ba." # une chaîne de caractères
>>> a[-1]
-5
>>> a[-3]
’f’
>>> len(t)
3
>>> len(c)
7
>>> min(t)
-7
3
>>> sum(t)
5.5
>>> y = [3, 12, -6] # une autre liste
>>> z = a + y
>>> z
[13, 4, ’f’, ’bonjour’, -5, 3, 12,-6]
>>> y * 2
[3, 12, -6, 3, 12, -6]
>>> c * 5
’b a ba.b a ba.b a ba.b a ba.b a ba.’
>>> z[2:5]
[’f’, ’bonjour’, -5]
>>> z[1:-2]
>>> z[1:6:2]
>>> d = ’anticonstitutionnellement’
>>> d[::3]
’ainitnlmt’
>>> d[:4]
>>> d[4:]
Exercice : Utilisation du slicing.
Soit une séquence s.
1◦ ) Déterminer une séquence ne contenant que les éléments d’indices pairs de s, une séquence ne
contenant que les éléments d’indices impairs.
2◦ ) Créer la séquence obtenue en renversant la séquence s.
4
3
Particularités des listes
3.a
Ajout et suppression d’éléments dans une liste a
De manière générale, il faut bien réfléchir à ce qu’on veut : soit créer une nouvelle liste b obtenue à
partir de a, soit modifier la liste a. C’est d’ailleurs une question à se poser dans beaucoup d’exercices
sur les listes (bien lire l’énoncé !).
Ajout d’un élément en fin de liste
On peut utiliser la concaténation, que l’on veuille créer une nouvelle liste ou modifier a :
Python shell
>>> a = [1,2,3]
>>> b = a + [4] # création d’une nouvelle liste ; ne pas oublier les crochets.
>>> b
[1,2,3,4]
>>> a = a + [4] # modification de la liste a
Dans le cas où on veut modifier la liste, le mieux est cependant d’utiliser la méthode append (c’est une
fonction associée à un objet ; l’objet en question se met devant, suivi d’un point) :
Python shell
>>> a = [1,2,3]
>>> a.append(4)
>>> a
[1,2,3,4]
À la différence de la concaténation a = a + [4], l’instruction a.append(4) "agit sur place" : il ne
s’agit pas d’une réaffectation (la liste reste à la même adresse mémoire, voir explications plus loin).
Ajout d’un élément à un endroit précis de la liste
On peut mettre à profit le "slicing" dans le cas où l’on veut modifier la liste a :
Python shell
>>> a = [4, 6, 7]
>>> a[1:1] = [5]
>>> a
[4, 5, 6, 7]
5
Supprimer un ou des éléments avec del
Là encore, il s’agit d’une modification de la liste :
Python shell
>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> del(a[1])
>>> a
[1, 3, 4, 5, 6, 7]
>>> del(a[0:2])
>>> a
[4, 5, 6, 7]
3.b
Listes définies en compréhension
Cela correspond à l’utilisation de la syntaxe : [expr for indice in iterable]
Quelques exemples :
Python shell
>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [x**2 for x in range(10) if x % 2 == 0]
[0, 4, 16, 36, 64]
>>> [(i, j) for i in range(4) for j in range(i)]
[(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2)]
Remarque : pour le dernier exemple, la syntaxe remplace la construction suivante en respectant bien
l’ordre.
for i in range(4):
for j in range(i):
...
Exercice 1 : Calculer
X
(100i + j).
1≤i≤5
1≤j≤4
# Première méthode: avec des boucles
6
# Deuxième méthode: en compréhension
Exercice 2 : Construire la liste a = [1, 2, 2, 3, 3, 3, ..., 10, ..., 10]
# Première méthode: avec des boucles, à partir d’une liste vide
# Deuxième méthode: en compréhension
Remarque : Il est intéressant de connaître les techniques en compréhension pour pouvoir effectuer
rapidement certaines opérations mais il est aussi important de connaître la technique de construction
d’une liste pas à pas à partir d’une liste vide. Cette dernière méthode est parfois la seule possible quand
la construction est un peu complexe.
3.c
Listes de listes
On pourra être amené à manipuler le type d’objet suivant (qui correspond mathématiquement à une
matrice) :

1
0

m=
4
2
7 −8
−3 2

1

3

1
9
Pour pouvoir représenter cet objet, on pourra utiliser une liste de listes.
Python shell
>>> m = [[1, 0, -3, 2], [4, 2, 1, 3],[7 ,-8, 1, 9]]
>>> m[0]
>>>
# A compléter
-8
7
Exercice :

0

0

1◦ ) Construire la matrice nulle m1 = 
0

0

0 0

0 0

.
0 0

0 0
2◦ ) Soit n un entier ≥ 2. Construire la matrice identité :

 1 0
 0 1

m2 = 



0 0

0 
0 





1
Remarque : On peut aussi faire la construction en une ligne :
m2 = [[1 if j == i else 0 for j in range(n)] for i in range(n)]
8
3.d
Modification d’une liste et conséquences
Si on modifie par exemple a[0], c’est uniquement l’adresse de a[0] qui change, pas celle de a.
Explicitons par un exemple :
Python shell
>>> a = [3, 2, ’hi’]
>>> id(a)
47107080
>>> id(a[0]), id(a[1]), id(a[2])
(507098784, 507098816, 47098936)
>>> a[2] = 5
>>> id(a)
47107080
>>> id(a[0]), id(a[1]), id(a[2])
(507098784, 507098816, 507838156)
9
Conséquence 1 : le problème lors d’une copie de liste et sa solution
Reprenons l’exemple précédent et essayons de faire une copie b de la liste a au départ :
Python shell
>>> a = [3, 2, ’hi’]
>>> b = a
>>> a[2] = 5
>>> b[0] = 1
>>> a
[1, 2, 5]
>>> b
[1, 2, 5]
Pour mieux comprendre, on peut se représenter ce qui se passe en mémoire :
Une solution à retenir pour réaliser une vraie copie b de la liste a qui ne subira pas toutes les modifications des éléments de a : utiliser le slicing avec tous les éléments de a, du début à la fin :
Python shell
>>> a = [3, 2, ’hi’]
>>> b = a[:]
On peut alors constater qu’une modification de a ne se répercute pas sur b, et réciproquement :
Python shell
>>> a[2] = 5
>>> b[0] = 1
>>> a
[3, 2, 5]
>>> b
[1, 2, ’hi’]
10
Conséquence 2 : création d’une matrice à coefficients égaux, la bonne méthode

0

0

Reprenons la première façon de créer la matrice 
0

0

0 0

0 0

, et modifions-la :
0 0

0 0
Python shell
>>> m = [[0, 0, 0]] * 4
>>> m[0][0] = 1
>>> m
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
Expliquons avec un schéma :
Par contre, avec la deuxième méthode :
Python shell
>>> m = [[0 for j in range(3)] for i in range(4)]
>>> m[0][0] = 1
>>> m
[[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
Expliquons avec un schéma :
11
Modification d’une liste dans une fonction
Rappelons-nous que les arguments d’une fonction sont a priori des variables locales :
Python shell
>>> def change(p):
p = p + 1
return(p)
>>> p = 3
>>> change(p)
4
>>> p # p n’est pas modifiée
3
Cependant, lorsque l’argument est une liste et qu’on modifie les éléments "sur place" :
en faisant a[0] = 5 par exemple, ou avec del ou append :
Python shell
>>> def change(a):
a[0] = 5
a.append(3)
return(a)
>>> a = [1, 2]
>>> change(a)
[5, 2, 3]
>>> a # a est modifiée !
[5, 2, 3]
Par contre, dès qu’on utilise la réaffectation dans une fonction, les modifications qui suivent ne seront
pas prises en compte :
Python shell
>>> def change(a):
a[0] = 5 # cette instruction va changer a
a = a + [3] # à partir de là, a n’est plus modifiée globalement
return(a)
>>> a = [1, 2]
>>> change(a)
[5, 2, 3]
>>> a
[5,2]
12
4
Particularités des tuples
Les parenthèses aux extrémités sont facultatives (l’important, ce sont les virgules) mais recommandées
pour la lisibilité. Pour former un tuple à un seul élément, il faut faire suivre cet élément d’une virgule.
>>> t = 100, 32, -2.1 # même effet que t = (100, 32, -2.1)
>>> t # vérifions :
(100, 32, -2.1)
>>> t = (3)
>>> type(t)
<class ’int’>
>>> t =(3,)
>>> type(t)
<class ’tuple’>
Les tuples permettent de faire de l’affectation multiple :
>>> (x, y, z) = (5, 6, 7) # ou x, y, z = 5, 6, 7
>>> y
6
Cette technique d’affectation multiple est en particulier utile lorsque l’on veut récupérer le résultat
d’une fonction renvoyant un tuple. Cela permet en quelque sorte de « dépacker » le tuple.

a = x + y
Par exemple, la fonction resolution donne l’unique couple solution (x, y) au système
b = x − y
a−b
où a et b sont les arguments de la fonction (l’unique solution est a+b
2 , 2 .
Observez comment on récupère le résultat d’un appel à cette fonction :
Python shell
>>> def resolution(a, b):
return( (a + b)/2 , (a - b)/2 )
>>> x, y = resolution(1, 3)
>>> x
2
>>> y
-1
On peut aussi faire t = resolution(1, 3) ; t[0] contiendra 2 et t[1] contiendra −1.
13
Les tuples peuvent aussi se définir en compréhension, comme les listes :
Python shell
>>> tuple( x ** 2 for x in range(1 ,9) )
(1, 4, 9, 16, 25, 36, 49, 64)
5
Particularités des chaînes de caractères
L’utilisation des guillemets par rapport aux simples quotes permet d’insérer des quotes dans une chaîne,
comme dans "bonjour, c’est l’automne".
L’utilisation de guillemets triples permet de faire courir une chaîne sur plusieurs lignes et est utilisée
en particulier pour documenter une fonction (cf. chapitre 4).
On rappelle l’existence de la fonction prédéfinie str rencontrée en TP. Elle permet de transformer par
exemple la valeur d’une variable numérique en chaîne de caractères.
Exercice :
1◦ ) Soient les variables a et b suivantes : a = 8, b = 7.
En utilisant les variables a et b, créer la chaîne de caractères c = ’8 * 7 = 56’. On n’utilisera
pas de manière directe le contenu des variables a et b.
2◦ ) Créer la liste de la table de multiplication de 3 : [2 * 3 = 6, 3 * 3 = 9, 4 * 3 = 12, 5 * 3
= 15, 6 * 3 = 18, 7 * 3 = 21, 8 * 3 = 24, 9 * 3 = 27]
14
Pour passer à la ligne, il y a un caractère spécial : ’\n’. Pour la tabulation, c’est ’\t’.
Python shell
>>> s = ’Bonjour,\ncomment allez-vous ?’
>>> s
’Bonjour,\ncomment allez-vous ?’
>>> print(s)
Bonjour,
comment allez-vous ?
>>> s = ’a \t b \t c’
>>> print(s)
a
b
c
Sur les chaînes de caractères, il faut connaître les méthodes strip et split.
Exemples avec s1 = ’Être ou ne pas être, telle est la question\n’
et s2 = ’
Nom : Turing\tPrénom : Alan\t’.
Python shell
>>> s1.strip()
’Être ou ne pas être, telle est la question’
>>> s2.strip()
’Nom : Turing\tPrénom : Alan’
Retenir : c.strip() renvoie
Python shell
>>> s1.split()
[’Etre’, ’ou’, ’ne’, ’pas’, ’être,’, ’telle’, ’est’, ’la’, ’question’]
>>> s2.split()
[’Nom’, ’:’, ’Turing’, ’Prénom’, ’:’, ’Alan’]
>>> s1.split(’, ’)
[’Etre ou ne pas être,’, ’telle est la question’]
>>> s2.split(’\t’)
[’
Nom : Turing ’, ’ Prénom : Alan ’, ”]
Retenir :
• c.split() renvoieune liste, obtenue en "cassant" la chaîne de caractères c aux endroits où il
y a un espace, ou un saut de ligne, ou une tabulation. Comme strip, elle supprime aussi les
espaces présents, les sauts de lignes , les tabulations en début et fin de ligne
• Si on précise un argument, par exemple c.split(’,’),
15
6
Notions clés
Il faut savoir appréhender les notions suivantes :
H Syntaxe usuelle sur les listes, chaînes de caractères, tuples.
En particulier, savoir accéder à un élément connaissant l’indice, connaître la technique du
slicing.
H Une liste est mutable. Une chaîne de caractère et un tuple ne le sont pas.
H Utilisation de la méthode append sur les listes.
H Construire des listes en compréhension.
H Pour faire une copie b indépendante de la liste a :
b = a[:] (à condition que a ne soit pas une liste de listes).
H Une liste, argument d’une fonction, peut être modifiée par la fonction.
H « Dépacker » un tuple.
H Connaître les caractères spéciaux ’\n’, ’\t’ et les méthodes strip et split sur les chaînes
de caractères.
16