Vous êtes sur la page 1sur 18

Listes et chaînes de caractères

1. Définitions et exemples
Une liste permet de manipuler une séquence d’objets.

1.1. Exemples de listes


Une liste est représentée entre crochets, et ses éléments sont séparés par des
virgules:

[1, 10, 2, 3, 2, 2]

Une liste peut contenir des objets de n’importe-quel type. Par exemple, des chaînes
de caractères:

['a', 'b', 'toto']

On peut aussi mélanger des objets de types différents dans la même liste:

[1, 'a', 2, 3, 3.14159, True, False, 1]

On peut même avoir une liste qui contient une liste:

[1, [2, 3], 'toto']

Une liste peut être vide:

[]

Les éléments d’une liste peuvent contenir des expressions complexes, faisant appel à
des variables ou des fonctions:

a = 2
[(2 + 3) * a, a * 2]

1.2. Indices, longueur et intervalles


On accède aux éléments individuels d’une liste en indiquant leur indice entre crochets.
La numérotation des éléments commence à zéro. Par exemple:
>>> a = [1, 7, 5]
>>> a[0]
1
>>> a[2]
5

On peut utiliser des indices négatifs pour compter à partir de la fin de la liste:

>>> a = [1, 7, 5]
>>> a[-1]
5
>>> a[-3]
1

La fonction len donne la longueur d’une liste:

>>> liste = [3, 7, 6]


>>> len(liste)
3

On peut extraire un sous-ensemble des éléments d’une liste en spécifiant un intervalle


d’indices de la façon suivate: liste[min:max]. Les indices conservés sont ceux qui
sont supérieurs ou égaux à min, et inférieurs strictement à max:

>>> liste = [1, 4, 1, 5, 9]


>>> liste[1:3]
[4, 1]
>>> liste[2:2]
[]

min ou max peut être omis. Dans ce cas, tout se passe comme si min était 0,
et max était len(liste):

>>> liste[2:]
[1, 5, 9]
>>> liste[:2]
[1, 4]
>>> liste[:]
[1, 4, 1, 5, 9]

Les indices négatifs peuvent être utilisés dans les intervalles aussi:

>>> liste[:-1]
[1, 4, 1, 5]
1.3. Opérateurs sur les listes
De la même manière que les chaînes, les listes peuvent être concaténées avec
l’opérateur +, et multipliées par un entier:

>>> [1, 2] + [2]


[1, 2, 2]
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

On peut comparer deux listes avec l’opérateur ==:

>>> [1, 2] == [2, 3]


False
>>> [1, 2] == [1, 2]
True

1.4. Modification d’une liste


On peut affecter une valeur à un élément d’une liste:

>>> a = [1, 7, 5]
>>> a[1] = 0
>>> a
[1, 0, 5]

On peut aussi affecter une liste à un intervalle:

>>> a = [1, 7, 5]
>>> a[0:2] = [2, 3]
>>> a
[2, 3, 5]

Lors d’une affectation à un intervalle, il n’est pas nécessaire que les listes soient de
longueur identique:

>>> a = [1, 7, 5]
>>> a[0:2] = [2, 3, 4]
>>> a
[2, 3, 4, 5]
>>> a[0:2] = []
>>> a
[4, 5]

La méthode append permet d’ajouter un élément à la fin de la liste:

>>> a = [1, 4, 5]
>>> a.append(0)
>>> a
[1, 4, 5, 0]

1.5. Sémantique de pointeur


L’affectation d’une liste à une variable ne crée pas une copie de la liste. Voici un
exemple de programme qui illustre ce phénomène:

>>> a = [1, 7, 5]
>>> b = a
>>> a[1] = 0
>>> b
[1, 0, 5]

On voit que la modification de la liste a affecte aussi la liste b. Cela peut se représenter
de la façon suivante dans un tableau d’exécution:

a b L1
L1 [1, 7, 5]
L1
[1, 0, 5]

Pour faire une nouvelle copie de la liste, il est nécessaire d’utiliser une expression
comme ci-dessous:

>>> a = [1, 7, 5]
>>> b = a[:] # b = a + [], ou b = list(a) fonctionnent aussi
>>> a[1] = 0
>>> b
[1, 7, 5]

Ce qui donne:

a b L1 L2
L1 [1, 7, 5]
L2 [1, 7, 5]
[1, 0, 5]
1.6. Boucle for
On est souvent amené à faire des boucles pour énumérer les éléments d’une liste. Par
exemple, si on veut afficher sur une ligne différente chaque élément de la liste a:

i = 0
while i < len(a):
x = a[i]
print(x)
i = i + 1

La boucle for permet d’écrire la même chose de façon plus simple:

for x in a:
print(x)

Le corps de la boucle s’exécutera une fois pour chaque valeur de x dans la liste a.

La fonction range permet de produire un intervalle. La valeur retournée par la


fonction range n’est pas une liste, mais un objet spécial que l’on peut transformer en
liste:

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(2, 5))
[2, 3, 4]

La fonction range est très pratique pour les boucles. Plutôt que d’écrire la boucle
suivante:

i = 0
while i < 5:
print(i)
i = i + 1

On peut simplement écrire:

for i in range(5):
print(i)

1.7. Autres fonctions et opérations pratiques


(À faire en exercice d’écriture: programmer ces fonctions sans les utiliser. Pour sort,
c’est trop compliqué: on fait l’exercice de lecture)

On peut trier une liste sur place avec la méthode sort:


>>> a = [1, 5, 3, 2]
>>> a.sort()
>>> print(a)
[1, 2, 3, 5]

Si on souhaite conserver la liste a intacte, et créer une nouvelle liste, on peut utiliser
la fonction sorted:

>>> a = [1, 5, 3, 2]
>>> b = sorted(a)
>>> print(b)
[1, 2, 3, 5]
>>> print(a)
[1, 5, 3, 2]

L’appartenance à une liste peut se tester avec l’opérateur in:

>>> 1 in [3, 4, 5]
False
>>> 4 in [3, 4, 5]
True

Le minimum et le maximum peuvent se trouver avec les fonctions min et max:

>>> min([3, 1, 4, 1, 5, 9, 2])


1
>>> max([3, 1, 4, 1, 5, 9, 2])
9

del permet de supprimer un élément d’une liste:

>>> a = [0, 1, 2, 3, 4]
>>> del a[2]
>>> a
[0, 1, 3, 4]

Notez qu’on peut faire la même opération en affectant une liste vide:

>>> a = [0, 1, 2, 3, 4]
>>> a[2:3] = []
>>> a
[0, 1, 3, 4]

1.8. Chaînes de caractères


Les chaînes de caractères peuvent se manipuler de manière quasi identique aux listes,
à la différence près qu’il est impossible de modifier une chaîne de caractères sur place.
Par exemple:
>>> c = "bonjour"
>>> c[0]
b
>>> c[0:3]
bon
>>> len(c)
7

Si on cherche à modifier la chaîne, il se produit des erreurs:

>>> c[0] = "B"


Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> c.append("!")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'append'

Mais on peut obtenir un effet similaire en construisant une nouvelle chaîne:

>>> c = "B" + c[1:]


>>> c
Bonjour

L’opérateur d’appartenance in permet aussi de tester les sous-chaînes:

>>> "x" in c
False
>>> "Bon" in c
True

Attention: in ne fonctionne pas de cette façon pour les listes:

>>> [1, 2] in [1, 2, 3]


False
>>> [1, 2] in [[1, 2], 3]
True
1.9. Exercices de lecture

1.9.1. Que va-t-il afficher ?

1. liste = []
2. i = 1
3. while i <= 5:
4. i = i + 1
5. liste.append(i * i)
6. print(liste)

1.9.2. Que va-t-il afficher ?

1. liste = [1, 5, 7, 2]
2. x = 0
3. for i in liste:
4. x = x + i
5. print(x)

1.9.3. Que va-t-il afficher ?

1. a = [3, 1, 4, 1, 5]
2. b = []
3. for i in range(len(a) - 1):
4. b.append(a[i] + a[i + 1])
5. print(b)

1.9.4. Que va-t-il afficher ?

1. s = ''
2. for i in range(8):
3. if i % 2 == 0:
4. s = s + str(i)
5. else:
6. s = s + '-'
7. print(s)
1.9.5. Que va-t-il afficher ?

1. x = 'ohlala'
2. print(x[3:4] + x[4:] + x[:2])

1.9.6. Que va-t-il afficher ?

1. def f(liste):
2. resultat = []
3. i = len(liste)
4. while i > 0:
5. i = i - 1
6. resultat.append(liste[i])
7. return resultat
8.
9. print(f([1, 2, 'a', 'b']))

1.9.7. Que va-t-il afficher ?

1. liste_a = [1, 2, 3, 4]
2. liste_b = [2, 3, 4, 5]
3. print(liste_a + liste_b)

1.9.8. Que va-t-il afficher ?

1. liste_a = [1, 2, 3, 4]
2. liste_b = liste_a
3. liste_c = liste_a[:]
4.
5. liste_b.append(5)
6. liste_c.append(6)
7.
8. print(liste_a)
9. print(liste_b)
10. print(liste_c)

1.9.9. Que va-t-il afficher ?

1. liste = ['a', 1, 'b', 2]


2. liste[1:2] = liste[2:3]
3. print(liste)

1.9.10. Que va-t-il afficher ?

1. liste = ['a', 1, 'b', 2]


2. liste[1:2] = liste[3:3]
3. print(liste)
1.9.11. Que va-t-il afficher ?

1. def f(liste, i, j):


2. x = liste[i]
3. liste[i] = liste[j]
4. liste[j] = x
5.
6. liste = ['a', 'b', 'c']
7. f(liste, 1, 2)
8. print(liste)

1.9.12. Que va-t-il afficher ?

1. def f(liste, i, j):


2. x = liste[i]
3. liste[i] = liste[j]
4. liste[j] = x
5.
6. liste = [7, 1, 2, 5, 2]
7. x = 1
8. while x > 0:
9. x = 0
10. i = 1
11. while i < len(liste):
12. if liste[i] < liste[i - 1]:
13. f(liste, i, i - 1)
14. x = x + 1
15. i = i + 1
16.
17. print(liste)

1.9.13. Que va-t-il afficher ?

1. def f(liste):
2. liste[0] = 2
3.
4. x = [1, 2]
5. f(x)
6. print(x)

1.9.14. Que va-t-il afficher ?

1. def f(liste):
2. liste = liste + [1]
3.
4. x = [3, 4]
5. f(x)
6. print(x)
1.9.15. Que va-t-il afficher ?

1. def f(liste):
2. liste.append(1)
3.
4. x = [3, 4]
5. f(x)
6. print(x)

1.9.16. Que va-t-il afficher ?

1. def f(liste):
2. return liste + [1]
3.
4. x = [2, 3]
5. print(f(x))

1.9.17. Que va-t-il afficher ?

1. def f(liste):
2. liste = liste + [1]
3.
4. x = [2, 3]
5. print(f(x))

1.9.18. Que va-t-il afficher ?

1. def f(liste):
2. if len(liste) < 2:
3. return liste + [1]
4. else:
5. return liste + [liste[len(liste) - 2] + liste[len(liste) - 1]]
6.
7. x = []
8. i = 0
9. while i < 6:
10. x = f(x)
11. i = i + 1
12. print(x)

1.9.19. Que va-t-il afficher ?

1. liste = [1, 3, 4, 5, 8, 2]
2. i = 1
3. while i < len(liste) - 1:
4. liste[i] = liste[i] + liste[i - 1] + liste[i + 1]
5. i = i + 1
6. print(liste)
1.9.20. Que va-t-il afficher ?

1. a = [3, 1, 4, 1, 5]
2. b = []
3. for i in range(len(a)):
4. if i < 2:
5. b.append(a[i + 1])
6. else:
7. b.append(a[i - 1])
8. print(b)

1.9.21. Que va-t-il afficher ?

1. for i in range(8):
2. if i % 3 == 0:
3. print('!')
4. else:
5. print(i)

1.9.22. Que va-t-il afficher ?

1. x = 'bonjour'
2. print('=' + x[:3] + '-' + x[3:] + '=')

1.9.23. Que va-t-il afficher ?

1. liste = [[]]
2. print(len(liste))
3. liste = liste + [1]
4. print(liste)

1.9.24. Que va-t-il afficher ?

1. ligne = '#'
2. i = 0
3. while i < 8:
4. print(ligne)
5. suivante = '#'
6. j = 1
7. while j < len(ligne):
8. if ligne[j] == ligne[j - 1]:
9. suivante = suivante + ' '
10. else:
11. suivante = suivante + '#'
12. j = j + 1
13. suivante = suivante + '#'
14. ligne = suivante
15. i = i + 1
1.9.25. Que va-t-il afficher ?

16. liste = [[1]]


17. i = 0
18. while i < 8:
19. x = liste[i]
20. y = [1]
21. j = 1
22. while j < len(x):
23. y.append(x[j - 1] + x[j])
24. j = j + 1
25. y.append(1)
26. liste.append(y)
27. i = i + 1
28. print(liste)

1.10 Exercices simples


1.10.1. Manipulations élémentaires

1. Créer une variable liste égale à [1, 2, 7, 3, 'a']


2. Remplacer le troisième élément (7) par 8 et afficher la liste
3. Ajouter l’élément 'toto' à la fin de la liste, et l’afficher

1.10.2. Listes et input

1. Écrire un programme qui demande cinq nombres à l’utilisateur, puis les affiche
dans l’ordre croissant:

1. Entrez un nombre: 1
2. Entrez un nombre: 45
3. Entrez un nombre: 65
4. Entrez un nombre: 3
5. Entrez un nombre: 1
6. [1, 1, 3, 45, 65]

1.10.3.

Écrire un programme qui demande une valeur de n, puis qui demande n nombres
à l’utilisateur. Le programme affiche ensuite la liste des nombres pairs qui ont été
entrés. Par exemple:

1. Nombre de valeurs? 5
2. Entrez une valeur: 4
3. Entrez une valeur: 3
4. Entrez une valeur: 8
5. Entrez une valeur: 76
6. Entrez une valeur: 5
7. Les nombres pairs que vous avez entrés sont: [4, 8, 76]
1.10.4.

Écrire un programme qui demande une valeur de n, puis qui demande n nombres,
puis n chaînes de caractères. Le programme affiche ensuite une liste composée
des nombres et des chaînes, alternées. Par exemple, si n = 3, les nombres sont 3,
7, 6 et les chaînes R U V, le résultat est [3,’R’,7,’U’,6,’V’]:

1. n? 3
2. Entrez une valeur: 3
3. Entrez une valeur: 7
4. Entrez une valeur: 6
5. Entrez une chaîne: R
6. Entrez une chaîne: U
7. Entrez une chaîne: V
8. [3,'R',7,'U',6,'V']

1.11. Boucles et listes


1.11.1.

Écrire une fonction intervalle(min, max) qui retourne la liste des entiers
consécutifs entre min et max inclus (sans utiliser la fonction range). Par exemple:

1. >>> intervalle(2, 7)
2. [2, 3, 4, 5, 6, 7]

1.11.2.

Écrire une fonction ajouter_un(liste), qui prend en paramètre une liste de


nombres et qui ajoute 1 à tous ses élements. Par exemple:

1. >>> x = [3, 1, 5]
2. >>> ajouter_un(x)
3. >>> x
4. [4, 2, 6]

1.11.3.

Écrire une fonction plus_un(liste), qui prend en paramètre une liste et qui
retourne une autre liste aux élements de laquelle on a ajouté un. Contrairement à
la question précédente, la liste passée en paramètre doit rester intacte. Par
exemple:

1. >>> x = [3, 1, 5]
2. >>> plus_un(x)
3. [4, 2, 6]
4. >>> print(x)
5. [3, 1, 5]

1.11.4.

Écrire une fonction somme(liste), qui revoie la somme des éléments d’une liste
d’entiers.

S = ∑n+1
i=0 Li

1.11.5.

Écrire une fonction transforme(chaine), qui transforme une chaine à une liste.

Exemple :

1. >>> ma_chaine = "ESSADDOUKI : MOSTAFA : MOHAMAD"


2. >>> transforme(ma_chaine)
3. [ESSADDOUKI , MOSTAFA , MOHAMAD]

1.11.6.

Écrire une fonction transforme_ch(liste), qui transforme une liste à une


chaine.

Exemple :

1. >>> ma_liste = ["ESSADDOUKI"," MOSTAFA" , "MOHAMAD"]


2. >>> transforme(ma_liste)
3. "ESSADDOUKI : MOSTAFA : MOHAMAD"

1.11.7.

Écrire une fonction somme_v(U,V), qui renvoie la somme de deux vecteurs de


même dimension.

1 2 1 2 3
U=(0) V=(−1)  W =U+V  W = (0)+ (−1) = (−1)
1 1 1 1 2

Exemple :

1. >>> U = [1,0,1]
2. >>> V= [2,-1,1]
3. >>> somme_v (U,V)
4. [3,-1,2]
1.11.8.

Écrire une fonction somme_M(M1,M2), qui retourne la somme de deux matrice M1


et M2 de même dimension.

Exemple :

5. >>> M2 = [[20, -5, 11], [10, -1, 5]]


6. >>> M1= [[2, 5, 1], [0, 1, 2]]
7. >>> somme_M(M1, M2)
8. [[22, 0, 12], [10, 0, 7]]

1.11.9.

Écrire une fonction produit_M(M1,M2), qui retourne le produit de deux matrice


M1 et M2 de même dimension.

Exemple :

9. >>> M2 = [[2, 0, 1], [3, 1, 0], [1, 2, 1]]


10. >>> M2 = [[1, 2], [0, 1], [1, 1]]
11. >>> produit_matrice(M1, M2)
12. [[3, 5], [3, 7], [2, 5]]

1.11.10.

Écrire une fonction min_M(M), qui renvoie la plus petite valeur d’une matrice.

1.12. Chaînes de caractères


1.12.1.

Écrire une fonction compte_lettre(mot, lettre) qui compte le nombre


d’occurences de la lettre dans le mot:
1. >>> compte_lettre('toto', 'o')
2. 2

1.12.2.

Écrire une fonction liste_positions(mot, lettre) qui donne la liste des


positions de la lettre dans le mot:

1. >>> liste_positions('toto', 'o')


2. [1, 3]

1.12.3.

Une chaine ch est dit carrée s’il existe une sous chaine s de ch telle que ch = ss.

Exemple : chercher, bonbon.

Écrire une fonction carree(ch) qui retourne si une chaine ch est carrée ou pas.

1. >>> ch = "chercher"
2. >>> carree(ch)
3. Votre chaine est carrée !

1.12.4.

Écrire une fonction inverse(ch) qui retourne l’inverse d’une chaine.

1. >>> ch = "abc"
2. >>> inverse(ch)
3. ‘cba’

1.12.5.

Un mot est dit palindrome lorsqu’il peut être lire indifféremment de gauche à droite
ou de droite à gauche.

Exemple : « radar », « elle », « non »

Ecrire une fonction palindrome(ch) qui renvoie si un mot est palindrome ou pas.

1. >>> ch = "abc"
2. >>> inverse(ch)
3. ‘cba’
1.12.6.

Ecrire une fonction longueur(ch) qui calcule le nombre de caractères d’une


chaîne de caractères.

1. >>> ch = "abc"
2. >>> longueur(ch)
3. 3

1.12.7.

Ecrire une fonction minuscule(caractere) qui retourne True si le caractère est


minuscule, False sinon.
1. >>> ch = "m"
2. >>> mns(ch)
3. True
4. >>> ch = "M"
5. >>> mns(ch)
6. Flase

1.12.8.

Ecrire une fonction majuscule(caractere) qui retourne True si le caractère est


majuscule, False sinon.
1. >>> ch = "M"
2. >>> mns(ch)
3. True
4. >>> ch = "m"
5. >>> mns(ch)
6. Flase

1.12.8.

Ecrire une fonction maxc(ch) qui retourne le caractère ayant le plus grand code
ASCII.
1. >>> ch = "BONJOUR"
2. >>> macx(ch)
3. U