Les listes sont des objets Python pouvant contenir plusieurs données ou variables. Elles sont assimilées à des tableaux (array) mais quelques différences existent.
Une liste se présente entre crochet. On peut la définir directement en utilisant les crochets :
maListe = [1,2,3,4]
# Ou de manière à expliciter le type en utilisant le constructeur de type :
maListe = list([1,2,3,4])
La liste peut contenir des données de différents type : chaine de caractère, entier, flottant, ...
Elles sont particulièrement intéressantes en physique pour stocker des données liés à du pointage, des grandeurs dépendantes d'un facteur, ou pour tracer des graphiques.
Particularité des listes : On écrit et on lit les données qui y sont stockées par leur indice. L'indice du premier élément est ... 0 !
Manipulation de base de liste : mémo
# Création d'une liste vide
maListe = []
>>>maliste
[]
# Associer une liste à une variable
a = 12
maListe = [a]
>>>maliste
[12]
# Ajouter un élément à la fin de la liste
maListe.append(5)
>>>maListe
[12, 5]
# Ajout d'un élément à une position donnée : (Rappel position 0 = 1er élément)
maListe.insert(0,"hello")
>>>maListe
['hello',12, 5]
# Lire une valeur contenu dans la liste :
>>>maListe[1]
12
# On peut aussi accèder à la dernière valeur par "-1", celle d'avant par -2, ...
>>>maListe[-1]
5
# On peut lire qu'une partie de la liste
maListe[1:] #de l'indice 1 (cest à dire le 2nd élément) jusqu'à la fin
maListe[:1] # du début jusqu'à l'indice 1 exclu
# Remplacer une valeur contenu dans la liste :
maListe[1] = "On remplace le 12"
>>>maListe
['hello', 'On remplace le 12', 5]
# Taille d'une liste (= nombre d'élements qu'elle contient)
>>>len(maListe)
3
Voilà quelques fonctions "de base" pour les listes. Il en existe bien d'autres que vous pouvez découvrir sur la documentation officielle python : https://docs.python.org/fr/3.7/tutorial/datastructures.html#more-on-lists ou sur Edupython en tapant le nom de votre liste suivi d'un point "maListe." ce qui vous fera apparaitre les fonctions disponibles pour un objet du type "list".
Applications directes
On dispose d'une liste :
liste = [1,2,4]
Lire la dernière valeur de la liste
Ajouter en fin de liste le numéro "7".
Après reflexion, vous deviez mettre le numéro "8". Modifier la valeur
Créer une nouvelle liste : liste2 qui contient "16" et "32"
Concaténer les deux listes dans une nouvelle liste que l'on appelera "nouvelleListe".
Combien d'éléments contient la nouvelleListe ? Afficher la longueur de "nouvelleListe"
liste = [1,2,4]
#Lire la dernière valeur de la liste.
liste[-1]
#Ajouter en fin de liste le numéro "7".
liste.append(7)
#Après reflexion, vous deviez mettre le numéro "8". Modifier la valeur
liste[-1] = 8
#Créer une nouvelle liste : liste2 qui contient "16" et "32"
liste2 = [16,32]
#Concaténer les deux listes dans une nouvelle liste que l'on appelera "nouvelleListe".
nouvelleListe = liste + liste2
#Combien d'éléments contient la nouvelleListe ? Afficher la longueur de "nouvelleListe"
len(nouvelleListe)
Ex1 : L’équation du nénuphar.
Une liste contient le nombre de nénuphars dans un lac chaque jour qui passe...
Définir une variable "nbNenuphar" égal à 1, correspondant au nombre de nénuphar initialement présent.
Créer une liste appelée "listeNenuphar" à partir du nombre de nénuphar initial.
Créer une fonction "fonctionNenuphar" qui prend comme paramètre la liste "listeNenuphar"
Cette fonction va lire la dernière valeur de la liste
Et va retourner une liste correspond à l'ancienne à laquelle on ajoute en fin de liste, le nouveau nombre de nénuphar, correspondant au double du jour précédent.
Appeler plusieurs fois la fonction, et afficher la valeur de la liste.
Vous devez obtenir une liste qui va évoluer de [1] à [1,2] puis [1,2,4] puis [1,2,4,8] ...
Module 1 : Définir une variable
Ligne 6-8 du mémo
Module 1 : Définir une fonction
Ligne 27 du mémo
Module 1 : fonction (return) + ligne 13 du mémo
nbNenuphar = 1
# Création de la liste
listeNenuphar = [nbNenuphar]
# Créer une fonction "fonctionNenuphar"
def fonctionNenuphar(liste):
#Lire le dernier élément, stocke dans la variable "derniere"
derniere = liste[-1]
#On multiplie pas deux cette valeur
derniere = derniere*2
#On l'ajoute en fin de liste
liste.append(derniere)
return liste
#en version condensée de cette fonction :
def fonctionNenuphar2(liste):
liste.append(liste[-1]*2)
return liste
Vous pouvez maintenant appeler votre fonction dans la console et observer le résultat :
>>> fonctionNenuphar2(listeNenuphar)
[1, 2]
Manipulations avancées
Création de liste avec range
Une manière simple de créer une liste est d'utiliser la fonction range.
Cette fonction prend 3 paramètres : le nombre de départ (inclu), celui d'arrivé (exclu), et le pas.
Remarque : Par défault le nombre de départ est 0, et le pas est 1. On peut donc spécifier que la fin si c'est ce qui est souhaité.
On utilise le constructeur "list" pour transformer son contenu en liste !
Attention ! En python 2.7, son fonctionnement était différent car range(...) générait une liste.
On peut sélectionner qu'une partie de liste en utilisant le sélectionneur ":"
uneListe=["a","b","c","d","e","f","g","h"]
# Selection Jusqu'à ...
>>>uneListe[:3] #selectionne du début jusqu'à l'élement d'indice 3 exclu (donc l'élement 0,1,2)
['a', 'b', 'c']
# Selection à partir de ...
>>>uneListe[3:] #selectionne de l'élement d'indice 3 inclu, jusqu'à la fin
['d', 'e', 'f', 'g', 'h']
# Selection à partir de ... jusqu'à ...
>>>uneListe[3:5] # de l'indice 3 inclu jusqu'au 5 exclu... donc 3 et 4
['d', 'e']
# Selectionne tout le contenu
>>>uneListe[:]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
Copie de liste
La copie d'une liste nécessite un paragraphe dédié. Il existe en effet deux approches pour copier une liste. Il faut se rappeler qu'une liste, c'est un conteneur de plusieurs variables. Quand on copie une liste, on peut donc :
Affecter la même contenu de la liste précédente à la nouvelle. C'est la copie "par référence". Ce n'occupe pas d'espace mémoire car on indique simplement au programme "dans la liste il y a cette variable que j'ai déjà en mémoire". Par contre, quand on modifie la variable dans une liste, ça affecte les autres.
Soit on recopie le contenu de la liste dans une nouvelle, qui devient alors indépendante. C'est à dire que l'on peut modifier la copie sans modifier l'original. Cette méthode utilise plus de mémoire, mais conserve l'original.
l1 = [1,2,3,4] # Liste originale
l2 = l1 #Copie par référence
l2[1] = 5 #Modification d'une variable
>>>l1,l2 #Affichage des deux listes
([1, 5, 3, 4], [1, 5, 3, 4]) #On a modifié les deux listes, car elles font références aux mêmes variables
# Il existe plusieurs façons
# 1 : En utilisant le constructeur
l1 = [1,2,3,4]
l2 = list(l1) #Le constructeur permet de créer une liste indépendante
l2[1] = 5
>>>l1,l2
([1, 2, 3, 4], [1, 5, 3, 4]) #On a modifié seulement l2
# 2 : En utilisant la copie du contenu
l1 = [1,2,3,4]
l2 = l1[:]
l2[1] = 5
>>>l1,l2
([1, 2, 3, 4], [1, 5, 3, 4])
# En utilisant le module "copy" (voir Module 3 de la formation)
# Cette méthode permet de copier des listes de listes notamment.
import copy
l1 = [1,2,3,4]
l2 = copy.deepcopy(l1)
l2[1] = 5
>>>l1,l2
([1, 2, 3, 4], [1, 5, 3, 4])
Un élève a réalisé un pointage, mais semble avoir fait une erreur sur une mesure.
Créer une copie indépendante de la liste (on ne sait jamais...) nommée "listeCorrige"
Modifier la 4ème valeur pour qu'elle passe de "320" à "3.20".
Créer une fonction "calcMoyenne" qui prend pour paramètre la liste, et retourne la moyenne. On utilisera sum(liste) qui fait la somme de la liste.
On veut afficher de manière plus propre les mesures pour que ça ressemble à :
La mesure 2 a une valeur d'intensité de 0.048 A
Méthode : On va définir une fonction qui prend en paramètre la liste des valeurs, et le numéro de la mesure que l'on souhaite interroger. On fera attention à l'indice différent de la mesure (la 1ere mesure a pour indice 0).
On peut ajouter une fonction input("Quelle valeur souhaitez vous interroger ?") dans le script à la fin.
Remarque : Cette fonction ne nécessite pas de "return" car c'est une fonction qui sert uniquement à la console, à l'affichage. En réalité Python retourne "None" (réponse vide). Ce genre de fonctions, sans "return" sont appelées des "procédures" en python.
Il faut déjà définir une fonction (voir module : fonction) qui prend deux paramètres : une liste, un indice. Par exemple la fonction peut s'appeler "affichage(liste,indice)", et on l'appelera ainsi "affichage(listePointage,2) pour avoir la valeur de la 2nd mesure (donc indice 1) de la liste.
def affichage( ... , ...):
Ensuite dans la fonction, il peut être utile pour la lecture de créer un variable, qui passera la paramètre "n° de la mesure" en "indice".
Ensuite, il faut utiliser la fonction print, pour afficher l'indice rentré par l'utilisateur, et la valeur issue de la liste.
## Une correction possible..
listePointage = [0.0010,0.0480,1.5810,30.000,151.00]
def affichage(liste=listePointage):
numero = int(input("Quelle mesure ?")) #Demande à l'utilisateur le n° de mesure
indice = numero-1 #Car la mesure 'n' porte l'indice 'n-1' dans une liste
print("La mesure "+str(numero)+" a une valeur d'intensité de "+str(liste[indice])+"A")
