TP-Cours ITC 01

Un type composé de Python : les listes (partie II)

II. Accès et modification

II.1 Les listes : un type d'objets mutables

On accède à un/aux élément(s) d’une liste par son/leurs indice(s). Ainsi, l[i] désigne le i-ème élément (le premier élément a l’indice 0) d’une liste l et l[i:j] désigne la liste formée formée des éléments de l qui sont situés entre l’indice i (inclus) et l’indice j (exclu). On parle alors de coupe ou de slice en anglais et la technique utilisée porte le nom de slicing !

Par ailleurs, l[i:j:k] désigne une coupe dans la liste l entre l’indice i (inclus) et l’indice j (exclu) par pas de k $\in N^{*}$ . Dans les exemple suivants, on notera les variantes l[i:], l[:j], l[i::k] ou l[:j:k] ainsi que l[::] ou l[:] qui renvoient une copie de la liste complète et l[::-1] qui retourne une copie de la liste décrite à l’envers.

Rappelons que quand on crée une variable, donc lorsqu’on lie un identificateur à un objet par l’instruction nom=obj , on associe en fait à cet identificateur l’adresse en mémoire où se trouve physiquement l’objet. On exprime cette situation en disant qu’on crée une référence, ou encore un pointeur, vers l’objet.

Il y a une différence importante entre les listes d’une part, et les chaînes et tuples de l’autre : les listes sont dites mutables, mais les chaînes et les tuples ne le sont pas.

Dire qu’un objet est mutable, c’est dire qu’on peut en modifier (voire supprimer/ajouter) un (ou plusieurs) élément(s), sans pour autant créer une nouvelle référence vers l’objet ainsi modifié (l’adresse du début de l’objet reste inchangée).

On peut donc modifier un élément ou plusieurs éléments d’une liste en s’inspirant des différentes manières d’y accéder que nous venons d’expérimenter ci-dessus. Exécutez le code suivant en essayant de bien comprendre les résultats obtenus.

Parcours d’une liste (version 2)

Notons que len(maliste) désigne la longueur de la liste maliste . Il est possible de parcourir les éléments d’une liste en utilisant une boucle for et l’indexation selon la syntaxe suivante :

for i in range(len(maliste)):

instructions utilisant maliste[i]

for i in range(len(maliste)): instructions utilisant maliste[i]

for i in range(len(maliste)):
    instructions utilisant maliste[i]

Ici, la variable i va prendre les valeurs 0 puis 1 puis … puis len(maliste)-1 donc maliste[i] prendra toutes les valeurs de maliste (dans l’ordre). Les exemples suivants illustrent l’utilisation d’une boucle for et de l’indexation pour parcourir une liste :

Exercice 1

On considère les listes

t2 = [31,28,31,30,31,30,31,31,30,31,30,31]

t1 = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre']

t2 = [31,28,31,30,31,30,31,31,30,31,30,31] t1 = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre']

t2 = [31,28,31,30,31,30,31,31,30,31,30,31]
t1 = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre']

Écrire un programme qui crée une nouvelle liste t3 contenant tous les couples (‘mois’, nb de jours du mois) c’est-à-dire

t3 = [('janvier',31), ('février',28), ...]

t3 = [('janvier',31), ('février',28), ...]

Exercice 2

Écrire une fonction qui prend comme paramètre une liste d’entiers l et renvoie deux listes : l’une contenant, dans l’ordre, les entiers pairs de l et l’autre les entiers impairs de l . Par exemple, si l=[11,2,3,15,6,12,13,45,14], votre fonction devra renvoyer les liste [2,6,12,14] et [11,3,15,13,45].

Exercice 3

A l’aide du code suivant :

file = open("mots.txt",'r',encoding="utf-8")

listeMots = file.read().split()

file.close()

file = open("mots.txt",'r',encoding="utf-8") listeMots = file.read().split() file.close()

file = open("mots.txt",'r',encoding="utf-8")
listeMots = file.read().split()
file.close()

ouvrir le fichier mots.txt contenant des mots Français.

Attention ! Utilisez Ctrl+Shift+E (Command +Shift+E sur Mac) pour exécuter ce code dans Pyzo afin que celui-ci considère votre répertoire courant comme le répertoire dans lequel chercher le fichier mots.txt ! Un simple Ctrl+E (Command+E) ne fonctionnera pas.

Écrire une fonction qui prend comme paramètre une liste de mots (des chaînes de caractères) et renvoie deux listes; la première liste contiendra les mots de six lettres au plus et la seconde les mots d’au moins 7 lettres. On pourra tester cette fonction sur

listeMots

listeMots

Exercice 4

Soit $n$ un entier strictement supérieur à 1 et $M \in M_{n} (R)$ . On note $M = (m_{i j})_{\begin{matrix} 1 \leq i \leq n \\ 1 \leq j \leq n \end{matrix}}$ et si pour tout $(i, j) \in {1, 2, \dots, n}^{2}$

$\sum_{k = 1}^{n} m_{i k} = \sum_{k = 1}^{n} m_{k j} = \sum_{k = 1}^{n} m_{k k} = \sum_{k = 1}^{n} m_{k, n - k + 1}$

on dit que $M$ est une matrice magique.

En utilisant l’algorithme suivant, construire une fonction qui a $n$ impair associe une matrice magique d’ordre $n$ dont les coefficients sont les entiers $1, 2, 3, \dots, n^{2}$ :

On place l’entier 1 au milieu de la première ligne. On suppose par récurrence que les $k$ premiers entiers ont été placés et que l’entier $k$ a été placé en $i$ -ème ligne et $j$ -ème colonne. On place alors l’entier $k + 1$ en respectant les règles suivantes :

on pose $I = i - 1$ (sauf si $i = 1$ , auquel cas on pose $I = n$ ) et $J = j + 1$ (sauf si $j = n$ , auquel cas on pose $J = 1$ )
si aucun nombre n’a encore été placé à la $I$ -ème ligne et $J$ -ème colonne, on y place $k + 1$
si cet emplacement est pris, on pose $I = i + 1$ (sauf si $i = n$ , auquel cas on pose $I = 1$ ) et $J = j$ et on y place $k + 1$ en $I$ -ème ligne et $J$ -ème colonne.

II.2 Méthodes (du programme) spécifiques aux listes

maliste

maliste est une variable de type list, la commande

dir(maliste)

dir(maliste) fournit les méthodes s’appliquant aux objets de type list. Le tableau suivant présente deux de ces méthodes :

maliste.append(x) `maliste.append(x)`	Ajoute un élément x à la fin de la liste maliste .
maliste.pop(i) `maliste.pop(i)`	Supprime l’élément d’indice i de la liste maliste et supprime son dernier élément si aucun indice n’est spécifié.

Attention ! Le programme ITC 2021 ne parle que de pop en dernière position, seule pratique autorisée …

Notez bien que ces méthodes modifient la liste

maliste

maliste « en place », ce qui signifie que l’identifiant de la variable maliste n’est pas modifié : la référence vers l’objet modifié est la même qu’avant modification.

Exercice 5

Un polynôme est représenté par la/une liste de ses coefficients. Par exemple, le polynôme $- X + 4 X^{3} + 2 X^{5}$ est représenté par la liste [0,-1,0,4,0,2].

Écrire la fonction
sommePol(P,Q)
sommePol(P,Q)qui renvoie la somme des deux polynômes P et Q
Écrire la fonction
produitPol(P,Q)
produitPol(P,Q) qui renvoie le produit des deux polynômes P et Q

Exercice 6

On souhaite maintenant mélanger la liste en utilisant la méthode de coupe. Il s’agit, comme dans un jeu de carte, de couper la liste en deux à un endroit aléatoire. Les deux parties sont ensuite interverties. Écrire une fonction coupe(liste,index) qui coupe la liste au niveau de l’index :

>>> liste = [0, 1, 2, 3, 4, 5]

>>> coupe(liste, 2)

>>> print(liste)

[2, 3, 4, 5, 0, 1]

>>> liste = [0, 1, 2, 3, 4, 5] >>> coupe(liste, 2) >>> print(liste) [2, 3, 4, 5, 0, 1]

>>> liste = [0, 1, 2, 3, 4, 5]
>>> coupe(liste, 2)
>>> print(liste)
[2, 3, 4, 5, 0, 1]

Écrire ensuite une fonction melange(liste,n) qui mélange la liste en effectuant n coupes aléatoires.

Exercice 7

Le mélange Faro consiste à couper un jeu de cartes en deux et interpénétrer ces deux parties pour reconstituer le jeu. Un mélange parfait (deux moitiés égales, la fusion des deux moitiés se faisant carte par carte) est impressionnant, mais n’est pas un bon mélange.

Le Faro out se pratique comme suit :

On coupe le jeu en deux moitiés égales, puis on reconstitue le jeu avec la 1ère carte de la 1ère moitié, la 1ère carte de la 2ème moitié, la 2ème carte de la 1ère moitié, la 2ème carte de la 2ème moitié, …, la dernière carte de la 1ère moitié, la dernière carte de la 2ème moitié.

La première et la dernière carte restent donc en place.

Le Faro in est semblable, sauf que l’on commence par la 2ème moitié, la première et la dernière carte changent donc de place.

On se propose de programmer le mélange Faro de deux listes :

Créer la liste jeu des 52 nombres de 0 à 51.
Créer une fonction faroOut(jeu) qui mélange la liste jeu en suivant le Faro out.
Créer une fonction faroIn(jeu) qui mélange la liste jeu en suivant le Faro in.