Afin de pouvoir personnaliser votre classeur sans détruire le classeur sur lequel travaille votre voisin, vous allez tout d'abord aller dans le menu File puis Make a copy.... Renommez le classeur en ajoutant votre nom à la fin du nom de fichier par exemple.

Les listes

Nous avons déjà rencontré sans le savoir des listes, à travers la commande range() :

In [ ]:
list(range(10))

Nous allons dans ce chapitre détailler ce qu'est une liste, comment les manipuler et expliquer pourquoi elles sont si importantes en Informatique.

Manipulation de listes

Présentation du type list

Une liste en Python est un objet délimité par deux crochets et qui renferme un nombre fini d'éléments de n'importe quel type, ces éléments étant séparés par des virgules.

Voici quelques caractéristiques sur les listes

  • les éléments d'une liste sont ordonnés : si on échange de place deux éléments différents d'une liste, la liste est modifiée.
  • les éléments d'une liste sont numérotés depuis 0
  • un même objet peut appparaître plusieurs fois dans une liste.
  • une liste peut contenir des éléments de type différents (nombres, chaines...)
In [ ]:
Premier_Exemple=[21,"Bonjour",1+2,5!=6,[1,2,3,1],21,1.3/4.565] # deux fois la même occurrence
print(Premier_Exemple)
print(type(Premier_Exemple))

Index d'une liste, longueur d'une liste

Les éléments d'une liste appelés occurrences sont rangés selon leur index, c'est-à-dire la place de l'occurrence dans la liste. Les éléments d'une liste s'appellent via leur index. La syntaxe $L[k]$ donne accès au $k^{\grave{e}me}$ élément de la liste $L$.

Le premier élément d'une liste a pour index $0$. Ainsi, $L[0]$ est toujours égal au premier terme de la liste $L$.

La syntaxe $len(L)$ permet de calculer la longueur d'une liste $L$, c'est-à-dire le nombre de ses éléments.

Pour avoir accès au dernier élément d'une liste $L$, on peut utiliser la syntaxe $L[len(L)-1]$.

Index particuliers : $L[-1]$ renvoie toujours au dernier terme de la liste $L$, alors que $L[-len(L)]$ renvoie au premier terme de la liste. Il est parfois utile d'utiliser ce caractère cyclique pour décrire une liste dans le sens inverse.

La syntaxe $L[k]$, lorsque l'entier $k$ sort de l'intervalle discret $[-len(L),len(L)-1]\cap \mathbb{Z}$ renvoie un message d'erreur.

La liste vide est $[~ ]$ : c'est la seule liste ne contenant aucun élément. Elle sert essentiellement à initialisée une liste à la liste vide pour ensuite la remplir.

Voici des exemples d'illustration.

In [ ]:
Liste=["un mot", 1,0,1,2,1,2,(7==9),[6,5]]
print("affichage de la liste : ",Liste)
print("affichage de la longueur de la liste",len(Liste)) # les mêmes occurrences sont comptées avec les redondances
p=len(Liste)
print("affichage du premier terme de la liste : ",Liste[0], " ou bien : ", Liste[-p])
print("affichage du dernier terme de la liste ",Liste[-1], " ou bien : ", Liste[p-1])
print("affichage du troisième terme de la liste : ",Liste[2]) #car on commence à 0
print("affichage de tous les termes de la liste dans l'ordre :")
for k in range(p) :
    print(Liste[k])

Modification d'une liste

Pour modifier une liste, il suffit d'effectuer une affectation à l'un de ses éléments via son index :

In [ ]:
L=[[1,2,3],"bonjour",3]
print("Liste initiale ",L)
L[0]=[6,8]
print("Premier index modifié :",L)
L[-1]=["au revoir",3!=0]
print("Dernier index modifié :", L)
L[0][-1]="8 remplacé par 9"
print("On modifie le premier index :",L)

Tranches de listes

Etant donnée une liste $L$, la syntaxe $L[Indice$$Debut:Indice$$Fin:Pas]$ renvoie la sous-liste composée des termes $L[k]$, lorsque l'indice $k$ est un entier de la forme $k=Indice$$Debut+q\cdot Pas$, avec $q\in \mathbb{N}$ de façon que $k$ reste entre $Indice$$Debut$ et $Indice$$Fin$ exclus : les index varient donc selon une incrémentation égale à $Pas$, tout en restant supérieur ou égal à $Indice$$Debut$ et strictement inférieur à $Indice$_$Fin$ tout au long de sa progression arithmétique.

Les trois arguments $Indice$$Debut$, $Indice$$Fin$ ou $Pas$ sont optionnels. Par défaut, $Indice$$Debut$ vaut $0$ ou $-len(L)$, $Indice$$Fin$ vaut $len(L)$ ou $-1$ et $Pas$ vaut 1. Il est à noter que $Pas$ peut être strictement négatif.

In [ ]:
L=list(range(30)) # list() trasnforme un objet en liste
print("affichage de toute la liste : ",L)
print("une liste du troisième au dixième terme :",L[2:10])
print("affichage de certains termes : ", L[3:28:6])
print("affichage sans le premier terme :", L[1:])
print("affichage sans le dernier terme :", L[:-1])
print("affichage des trois derniers termes :",L[-3:])
print("affichage des cinq premiers termes :",L[:5])
print("affichage de certains termes à l'envers :",L[-3:-18:-5])
print("la liste vide :",L[-3:6:4])
print("une liste de pas -4 :",L[-3:6:-4])
print("la liste dans le sens inverse :",L[::-1])

Premières opérations sur les listes

Etant donnée des listes, à partir de certaines opérations élémentaires, on peut en former d'autres. Le paragraphe précédent montre d'ailleurs un moyen assez performant pour extraire des éléments d'une liste, pour donc en former d'autres. Nous allons présenter ici des manipulations d'ordre algébrique.

L'addition ou la concaténation

L'addition ou la concaténation entre listes permet de coller deux listes l'une avec l'autre.

Si $L$ et $M$ sont deux listes, on peut former la concaténation entre ces deux listes selon la syntaxe : $L+M$

In [ ]:
L=[2,3,"un mot"]
M=[4,3,2,(4<6),"un autre mot",3]
print(L+M)
print(M+L)

La mutliplication externe d'une liste pas un entier

La multiplication d'une liste par une valeur entière permet la répétition de la liste un nombre de fois égale à l'entier choisi. La multiplication par une valeur non entière conduit à un message d'erreur et conduit à la liste vide lorsque l'entier est négatif ou nul.

In [ ]:
L=[2,19,"un mot",-3.5,"Informatique","   "]
print(4*L)
print(-1*L)
#print(3.56*L)
print(0*L)

Remarque : on ne peut multiplier les listes entre elles :

In [ ]:
L=[1,2,1,3]
M=[6,3,2]
print(L*M)
print(L**2)

La longueur d'une liste

On rappelle que la syntaxe $len(L)$ donne la longueur de $L$ :

In [ ]:
print(len([]))
L=[3,4,3,2,3,2,"bonjour"!="au revoir","True"!=True,2>3.9]
print(len(L))

La somme des termes d'une liste

On suppose ici qu'une liste ne contient que des valeurs numériques, par exemple la liste L ci-dessous :

In [ ]:
L=list(range(30))

Ecrire une fonction somme prenant en argument une liste et retournant la somme de tous les termes de la liste

In [ ]:
# Ecrire votre fonction ici

Tester votre fonction sur la liste des entiers de 1 à 29 fabriquée ci-dessus

In [ ]:
# Taper votre commande ici

Le calcul d'une somme de termes d'une liste $L$ se fait par $sum(L)$, à condition d'avoir uniquement des occurrences numériques. Vérifier le bon fonctionnement de votre fonction en calculant ce résultat à l'aide de la fonciton intégrée à Python

In [ ]:
# Taper votre commande ici

Les méthodes sur les listes

Il existe encore d'autres moyens de manipulation de listes.

Il existe en fait des fonctions déjà prédéfinies dans le logiciel Python pour modifier des listes. Ces moyens prédéfinis s'appellent des méthodes et leur syntaxe générale est, étant donnée une liste $L$ :

$L.Methode()$, où $Methode()$ fait référence à l'une des méthodes détaillée ci-dessous.

Il est à noter qu'une fois la ligne $L.Methode()$ executée, la liste $L$ est, en général, transformée en sa liste modifiée.

Ces méthodes revoient à la programmation orientée objet de Python : les listes sont des objets qui sont manipulés, modifiés selon certains transformations et évoluent au grés de ces modifications.

Voici un petit catalogue des méthodes utiles :

La méthode .append()

La syntaxe $L.append(objet)$ ajoute $objet$ à droite dans $L$ :

In [ ]:
L=list(range(5))
print(L)
L.append("on ajoute une chaîne à droite")
print(L)  # la liste initiale vient d'être modifiée !

La méthode .insert()

La syntaxe $L.insert(Indice,objet)$ insère $objet$ en place $Indice$ dans la liste $L$ et décale le reste des occurrences de $L$ à droite :

In [ ]:
L=["Pomme","Poire","Banane"]
print(L)
L.insert(1,"Fraise") # vient prendre la place de "Poire"
print(L)
L.insert(-1,"Ananas") # vient prendre la place de "Banane"
print(L)
L.insert(-4,"Ananas") # vient prendre la place de "Fraise"
print(L)
L.insert(56,"Pamplemousse")
print(L)
L.insert(-56,"Pamplemousse")
print(L)

La méthode .remove()

La syntaxe $L.remove(objet)$ supprime de la liste la première occurrence égale à $objet$ dans la liste $L$. Si $objet$ n'est pas présent dans $L$, cela produit un message d'erreur.

In [ ]:
L=list(range(34))
print(L)
L.remove(4.)
print(L)
#Liste.remove(5.7)
#print(Liste)
L.remove(23)
print(L)
M=[2,3,2,3,3,2,3]
print(M)
M.remove(2)
print(M)  # seul le premier "2" est supprimé !
M.remove(3)
print(M)  # seul le premier "3" est supprimé !

La méthode .pop()

La syntaxe $L.pop([Indice])$ renvoie $L[Indice]$ et supprime l'élément d'index $Indice$ de la liste $L$. Il n'est pas nécessaire que $Indice$ soit dans les bornes cycliques licites entre $-len(L)$ et $len(L)-1$, mais cela est quand même conseillé pour une meilleure lecture du script.

In [ ]:
L=[2,3,2,2,1,2,"mot",2,3]
print(L)
print(L.pop(6))
print(L)
L.pop(-1)
print(L)
L.pop(3)
print(L)
#L.pop(100)
#print(L)

La méthode .index()

La syntaxe $L.index(objet)$ renvoie l'index de la première occurrence d'$objet$ dans $L$. La liste $L$ n'est pas modifiée par cette méthode. Cela renvoie un message d'erreur lorsque $objet$ ne figure pas dans la liste $L$.

In [ ]:
Liste=[2,1,2,"un mot",3,2,3,2]
print(Liste)
print(Liste.index("un mot"))
print(Liste.index(3))
print(Liste)  # liste non modifiée

La méthode .count()

La syntaxe $L.count(objet)$ renvoie le nombre d'occurrences égales à $objet$ dans la liste $L$. Cele ne modifie pas la liste initiale.

Exercices

Exercice 1 : Simulation de lancer de dé

Fabriquer une liste de 100 nombres aléatoires de 0 à 6 puis donner la fréquence d'apparition du nombre 6.

Indication : On pourra utiliser les commandes suivantes pour tirer un nombre aléatoire entre 0 et 6 :

In [ ]:
from random import * # A mettre au début du programme

randint(1,6)
In [ ]:
# Postez votre solution ici

Exercice 2 : Défi Turing 90 (optionnel)

276 lampes sont numérotées de 1 à 276. Pour passer le temps, 25 enfants appuient sur les interrupteurs à tour de rôle. Le premier enfant presse chaque interrupteur. Le second presse les boutons 2, 4, 6 , etc. (tous les boutons ayant un numéro multiple de 2), le troisième appuie sur les boutons 3, 6, 9, etc. Le quatrième presse tous les boutons ayant un numéro multiple de 4, et ainsi de suite jusqu'au 25ème enfant. Avant le passage du premier enfant, toutes les ampoules sont éteintes.

Combien d'ampoules seront allumées après le passage des 25 enfants ?

In [ ]:
# Taper votre code ici