1. Pourquoi avons-nous besoin de listes?

Il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Avez-nous donc besoin de créer une variable distincte pour chaque valeur? Devrez-nous passer de longues heures à écrire des déclarations comme celle ci-dessous ?

var1 = int(input())
var2 = int(input())
var3 = int(input())
var4 = int(input())
var5 = int(input())
var6 = int(input())

Jusqu’à présent, vous avez appris à déclarer des variables capables de stocker exactement une valeur donnée à la fois. Ces variables sont parfois appelées scalaires par analogie avec les mathématiques.

Nous allons voir ici comment déclarer des variables à valeurs multiples : les listes. Nous allons pour illustrer cela écrire un programme qui trie une suite de nombres.

2. Déclaration

La déclaration d’une liste se fait de la même manière que pour n’importe quelle variable. On lui donne un nom et on l’affecte d’une collection de valeurs entre crochet et séparées par des virgules :

Soit une variable appelée numbers de type `list`et remplie d’une liste composée de 5 valeurs :

>>> numbers = [10, 5, 7, 2, 1]
>>> type(numbers)
<class 'list'>

  • La variable numbers est une liste composée de 5 valeurs, qui sont toutes des nombres.

  • Nous pouvons également dire que cette déclaration crée une liste de longueur égale à 5 (car il y a 5 éléments à l’intérieur).

  • Les éléments dans une liste peuvent avoir différents types : des entiers, des flottants, des caractères ou des chaines de caractère ou même d’autres listes.

  • Python a adopté une convention stipulant que les éléments d’une liste sont toujours indicés à partir de 0.
    Cela signifie que l’élément stocké au début de la liste aura l’indice 0. Comme il y a 5 éléments dans notre liste, l’indice 4 est attribué au dernier.

  • Pour créer une liste vide, il suffit de ne rien mettre entre les crochets.

3. Liste indexée

Les éléments d’une liste sont identifiés par leur indice :

>>> numbers = [10, 5, 7, 2, 1]
>>> numbers[0]
10
>>> numbers[3]
2

Si on tente d’accéder à un élément au dela du dernier indice, on génère une exeption : list index out of range

>>> numbers = [10, 5, 7, 2, 1]
>>> numbers[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Pour assigner une nouvelle valeur à un élément de la liste, il suffit de lui affecter la nouvelle valeur :

>>> numbers = [10, 5, 7, 2, 1]
>>> numbers[0] = 111
>>> numbers[0]
111
>>> numbers
[111, 5, 7, 2, 1]

Pour copier un élément dans un autre :

>>> numbers = [10, 5, 7, 2, 1]
>>> numbers[1] = numbers[4]
numbers[1]
1
>>> numbers
[111, 1, 7, 2, 1]

La valeur entre crochets qui sélectionne un élément de la liste est appelée un index ou indice.

3.1. Travail à faire : Liste de caractères

  • Créer une liste appelée alphabet qui contient les lettres de l’alphabet. Attention, les éléments de la liste sont des caractères !

  • Faire un programme qui permet d’écrire votre prénom en utilisant les éléments de la liste alphabet.

Exemple :
alphabet = ['a', 'b', ....]
print(alphabet[12],alphabet[0],alphabet[17],alphabet[2], sep='')

4. Longueur d’une liste

La longueur d’une liste peut varier pendant l’exécution. De nouveaux éléments peuvent être ajoutés à la liste, tandis que d’autres peuvent en être supprimés. Cela signifie que la liste est une entité très dynamique.

Pour connaitre la longueur actuelle de la liste, on utilise une fonction nommée len() (son nom provient de longueur en anglais).

La fonction prend le nom de la liste en tant qu’argument et renvoie le nombre d’éléments actuellement stockés dans la liste (autrement dit, la longueur de la liste).

4.1. Travail à faire : Longueur d’une liste

  • Vérifier la longueur de la liste alphabet.

  • Créer une nouvelle liste appelée prenom qui contient les éléments de la liste `alphabet`nécessaires pour écrire votre prénom :

Exemple :
alphabet = ['a', 'b', ....]
prenom =[alphabet[12],alphabet[0],alphabet[17],alphabet[2]]

5. Supprimer des éléments d’une liste

N’importe quel élément de la liste peut être supprimé à tout moment. Ceci se fait avec une instruction nommée del (delete).

Le mot réservé del est une instruction, pas une fonction.

Pour supprimer un élément de la liste, il faut le désigner par son indice. Il disparaîtra de la liste et sa longueur sera réduite de 1.

Exemple :
>>> numbers = [10, 5, 7, 2, 1]
>>> len(numbers)
5
>>> del numbers[1]
>>> numbers
[10, 7, 2, 1]
>>> len(numbers)
4

6. Les indices négatifs sont légaux

Cela peut paraître étrange, mais les indices négatifs sont légaux et peuvent être très utiles.

Un élément d’indice égal à -1 est le dernier de la liste.

6.1. Travail à faire : Accéder aux derniers éléments d’une liste

  • Afficher le dernier et l’avant-dernier élément de la liste alphabet.

  • Supprimer l’avant dernier élément de cette liste.

  • Afficher maintenant le dernier et l’avant-dernier élément de la liste modifiée.

7. Ajouter un élément à une liste

  • Un nouvel élément peut être collé à la fin de la liste existante :

list.append(value)

L’ajout en fin de liste est effectuée par une méthode nommée append().

Elle prend la valeur de son argument et le place à la fin de la liste à laquelle appartient la méthode.

La longueur de la liste augmente alors de 1.

  • La méthode insert () permet d’ajouter un nouvel élément à n’importe quel endroit de la liste, pas seulement à la fin.

list.insert(location, value)

La méthode insert () prend 2 arguments :

  • le premier indique l’emplacement requis de l’élément à insérer; Remarque : tous les éléments existants occupant des emplacements situés à droite du nouvel élément (y compris celui situé à l’emplacement indiqué) sont décalés vers la droite afin de laisser de la place pour le nouvel élément.

  • le second est l’élément à insérer.

7.1. Travail à faire : Ajouter des éléments à une liste

  • Créer une liste appelée numbers qui contient les valeur numériques 111, 7, 2, 1.

  • Ajouter à la fin de la liste la valeur 4.

  • Insérer en tout début de liste la valeur 222.

  • Insérer à l’indice 1 la valeur 333

  • Afficher maintenant la liste modifiée et sa longueur.

8. Remplir une liste avec des valeurs continues

Lorsque les valeurs d’une listes sont continues (comme l’alphabet par exemple ou une suite logique de nombres), on peut commencer par créer une liste vide pour la remplir en utilisant les méthodes append() ou insert() dans une boucle :

Exemple :
myList = [] # creating an empty list

for i in range(5):
    myList.append(i)

print(myList)

8.1. Travail à faire : Créer une liste continue

  • Créer une liste vide appelée myList.

  • Ajouter par la méthode de votre choix les éléments : 10, 9, 8, …​, 0.

  • Afficher la liste remplie et sa longueur.

9. Parcourir une liste

9.1. Parcourir les indices

La première solution consiste à parcourir les indices de la liste au moyen d’une boucle for, dont l’indice va de 0 à la longueur de la liste, pour accéder à chaqu’une de ses valeurs. Dans l’exemple qui suit, on souhaite calculer la somme de tous les éléments d’une liste. On les ajoute donc tous un par un :

Exemple :
myList = [10, 1, 8, 3, 5]
total = 0

for i in range(len(myList)):
    total += myList[i]

print(total)

9.2. Parcourir les valeurs

Mais la boucle for peut faire beaucoup mieux. C’est la deuxième solution pour parcourir une liste : dans cette solution, on masque toutes les actions liées à l’indexation de la liste et fournit tous les éléments de la liste de manière très pratique.

Exemple :
myList = [10, 1, 8, 3, 5]
total = 0

for value in myList:
    total += value

print(total)

10. Echanger des valeurs dans une liste

Imaginons que nous devions réorganiser les éléments d’une liste, c’est-à-dire inverser l’ordre des éléments: les premier et cinquième, ainsi que les deuxième et quatrième éléments doivent être permutés. Le troisième resterait intact.

Question: comment pouvez-vous échanger ces valeurs ?

Si on se contente du code suivant, on perd la valeur à la position afféctée :

Mauvaise manière :
myList = [10, 1, 8, 3, 5]

myList[0] = myList[4]
myList[4] = myList[0]

print(myList)

Les deux valeurs en position 0 et 4 sont maintenant identiques. Ce n’est pas ce que nous voulions. Pour effectuer la permutation, il nous faut une variable intermédiaire :

Bonne manière :
myList = [10, 1, 8, 3, 5]

auxilary  = myList[0]
myList[0] = myList[4]
myList[4] = auxilary

print(myList)

python offre un moyen encore plus pratique d’effectuer cet échange :

Excellente manière :
myList = [10, 1, 8, 3, 5]

myList[0], myList[4] = myList[4], myList[0]

print(myList)

10.1. Travail à faire : Permuter les valeurs d’une liste

  • Créer une liste vide appelée myList.

  • Ajouter par la méthode de votre choix les éléments : 0, 1, 2, …​, 99, 100.

  • Afficher la liste remplie et sa longueur.

  • Permuter les éléments : le premier avec le dernier, le second avec l’avant dernier, …​.

  • Afficher la liste modifiée qui devrait maintenant être 100, 99, …​, 2, 1, 0

Astuce :

Le problème consiste à échanger des éléments de la moitié inférieure de la liste avec des éléments de la moitié supérieure de la liste. On doit donc parcourir seulement la moitié de la liste, soit de l’indice 0 à l’indice len(myList)//2 (division entière de la longueur de la liste)

11. Point clés à retenir

Une liste est un type de données

En Python, une liste est un type de données utilisé pour stocker plusieurs objets. Il s’agit d’une collection ordonnée et modifiable (mutable) d’articles séparés par des virgules entre crochets, par exemple :

myList = [1, None, True, "I am a string", 256, 0]
Accéder aux éléments et mettre à jour

Les listes peuvent être indexées et mises à jour, par exemple :

myList = [1, None, True, 'I am a string', 256, 0]
print(myList[3]) # outputs: I am a string
print(myList[-1]) # outputs: 0

myList[1] = '?'
print(myList) # outputs: [1, '?', True, 'I am a string', 256, 0]

myList.insert(0, "first")
myList.append("last")
print(myList) # outputs: ['first', 1, '?', True, 'I am a string', 256, 0, 'last']
Imbrication de listes

Les listes peuvent être imbriquées, par exemple :

myList = [1, 'a', ["list", 64, [0, 1], False]
Suppression d’éléments

Les éléments de liste et les listes peuvent être supprimés, par exemple :

myList = [1, 2, 3, 4]
del myList[2]
print(myList) # outputs: [1, 2, 4]

del myList # deletes the whole list
Itération d’une boucle

  1. Les listes peuvent être itérées en utilisant la boucle for, par exemple :

myList = ["white", "purple", "blue", "yellow", "green"]

for color in myList:
    print(color)
Longueur d’une liste

La fonction len() peut être utilisée pour vérifier la longueur de la liste, par exemple :

myList = ["white", "purple", "blue", "yellow", "green"]
print(len(myList)) # outputs 5

del myList[2]
print(len(myList)) # outputs 4
Fonctions et méthodes

Un appel de fonction ressemble à ceci :

result = function(arg)

un appel de méthode ressemble à ceci :

result = data.method(arg)
Execices autocorrigés

  • Quelle est la sortie de cet extrait de code :

lst = [1, 2, 3, 4, 5]
lst.insert(1, 6)
del lst[0]
lst.append(1)

print(lst)
  1. [1, 6, 2, 3, 4, 1]
  2. [6, 1, 2, 3, 4, 5]
  3. [6, 2, 3, 4, 5, 1]

  • Quelle est la sortie de cet extrait de code :

lst = [1, 2, 3, 4, 5]
lst2 = []
add = 0

for number in lst:
    add += number
    lst2.append(add)

print(lst2)
  1. [1, 3, 6, 10, 15]
  2. [1, 2, 3, 4, 5]
  3. [10, 20, 30, 40, 50]

  • Quelle est la sortie de cet extrait de code :

lst = []
del lst
print(lst)
  1. NameError: name 'lst' is not defined
  2. []
  3. None

  • Quelle est la sortie de cet extrait de code :

lst = [1, [2, 3], 4]
print(len(lst))
  1. 4
  2. SyntaxError : Invalid syntax ([2, 3]) > line 0
  3. 3

  • Quelle est la sortie de cet extrait de code :

lst = [1, [2, 3], 4]
print(lst[1])
  1. [2]
  2. [2, 3]
  3. [1]

12. Exploitation des listes

Sur votre dépôt github, créez un nouveau repository : listes_python. Vous y sauvegarderez vos travaux :

  • max.py : Recherche du plus grand élément d’une liste

  • min.py : Recherche du plus petit élément d’une liste

  • selection.py : tri par sélection d’une liste

  • insertion.py : tri par insertion d’une liste

12.1. Travail à faire : Recherche du plus grand élément d’une liste

Nous allons ici rechercher dans une liste numérique le plus grand élément qu’elle contient.

  • Créer et afficher une liste aléatoire de 20 nombres compris entre 0 et 20 :

On obtient un nombre aléatoire compris entre deux borne en utilisant la méthode randint() du module random :

from random import *
x = randint(0, 20)
print(x)

  • Ecrire un programme qui recherche dans cette liste l’élément le plus grand.

  • Ecrire une fonction maximum(liste) qui prend une liste en paramètre et retourne sa plus grande valeur.

NE PAS UTILISER LA FONCTION max() DES LISTES !

Le principe consiste à créer une variable maxi et lui affecter 0 (la plus petite valeur de la liste) et comparer chaque élément de la liste avec cette variable.

Si la valeur de la liste comparée est supérieure à la valeur courante de la variable maxi, alors, on affecte à maxi cette valeur de la liste.

12.2. Travail à faire : Recherche du plus petit élément d’une liste

  • Même exercice mais on recherche cette fois le plus petit élément d’une liste de 20 nombres aléatoires.

  • Ecrire une fonction minimum(liste) qui prend une liste en paramètre et retourne sa plus petite valeur.

13. Trier une liste

Plusieurs solutions existent pour trier une liste. Les algoritmes les plus connus sont :

  • Le tri par sélection

  • Le tri par insertion

source : Dépot github Nathan Gaberel, d’après l’applet Java réalisée par David Eck, adaptée en français par Tahia Benhaj-Abdellatif

13.1. Tri par sélection

Le principe du tri par sélection/échange (ou tri par extraction) est d’aller chercher le plus petit élément du vecteur (partie de la liste) pour le mettre en premier, puis de repartir du second élément et d’aller chercher le plus petit élément du vecteur pour le mettre en second, etc…​

Par exemple, considérons la liste suivante : [5, 9, 3, 6, 4, 8]

  • mini = 3 ⇒ échange 3 avec le premier élément de la liste et on recommence sur la liste [9, 5, 6, 4, 8]

  • mini = 4 ⇒ échange 4 avec le premier élément de la liste et on recommence sur la liste [5, 6, 9, 8]

  • mini = 5 ⇒ échange 5 avec le premier élément de la liste et on recommence sur la liste [6, 9, 8]

  • mini = 6 ⇒ échange 6 avec le premier élément de la liste et on recommence sur la liste [9, 8]

  • mini = 8 ⇒ échange 8 avec le premier élément de la liste et on recommence sur la liste [9]

  • Plus d’éléments à comparer, le tableau est trié.

13.2. Travail à faire : Programme de tri par sélection

  • Ecrire un programme qui tri par sélection une liste de 20 nombres aléatoire. On pourra mettre à profit l’utilisation de la fonction minimum(liste)

13.3. Tri par insertion

C’est le tri du joueur de cartes. On fait comme si les éléments à trier étaient donnés un par un, le premier élément constituant, à lui tout seul, une liste triée de longueur 1. On range ensuite le second élément pour constituer une liste triée de longueur 2, puis on range le troisième élément pour avoir une liste triée de longueur 3 et ainsi de suite…​

Le principe du tri par insertion est donc d’insérer à la nième itération le nième élément à la bonne place.

Par exemple, considérons la liste suivante : [5, 1, 7, 2, 6, 4, 3]

  • On considère le premier élément trié : [5] et reste à trier [1, 7, 2, 6, 4, 3]

  • 1 est plus petit que 5, on le range à sa place : [1, 5] et reste à trier [7, 2, 6, 4, 3]

  • 7 est plus petit que …​aucun, on le range à sa place : [1, 5, 7] et reste à trier [2, 6, 4, 3]

  • 2 est plus petit que 7, 6, 5, on le range à sa place : [1, 2, 5, 7] et reste à trier [6, 4, 3]

  • 6 est plus petit que 7, on le range à sa place : [1, 2, 5, 6, 7] et reste à trier [4, 3]

  • 4 est plus petit que 7, 6, 5, on le range à sa place : [1, 2, 4, 5, 6, 7] et reste à trier [3]

  • 3 est plus petit que 7, 6, 5, 4 on le range à sa place : [1, 2, 3, 4, 5, 6, 7]

  • Plus d’éléments à trier, le tableau est trié.

13.4. Travail à faire : Programme de tri par insertion

  • Ecrire un programme qui tri par sélection une liste de 20 nombres aléatoire.

the_end.jpg