====== Listes ======

===liste = [] (création d'une liste vide)===
Crée une liste ne contenant aucun élément. On pourra ensuite y ajouter des éléments au fur et à mesure du programme.

<code python>
ma_liste = []
print(ma_liste)  #affiche []
</code>

===liste = [valeur1, valeur2, ...] (création d'une liste avec valeurs initiales)===
Crée une liste en indiquant directement les valeurs qu'elle doit contenir, séparées par des virgules.

<code python>
ma_liste = ["pomme", "poire", "banane"]
print(ma_liste)  #affiche ['pomme', 'poire', 'banane']
</code>

===liste = [valeur] * n (création d'une liste par répétition d'une valeur)===
Crée une liste contenant n fois la même valeur.

<code python>
ma_liste = [0] * 5
print(ma_liste)  #affiche [0, 0, 0, 0, 0]
</code>

===liste1 + liste2 (concaténation de deux listes)===
L'opérateur + permet d'assembler deux listes pour n'en former qu'une seule.

<code python>
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
liste3 = liste1 + liste2  #concatène liste1 et liste2
print(liste3)  #affiche [1, 2, 3, 4, 5, 6]
</code>

===list.append(valeur)===
Ajoute un élément à la fin de la liste.

<code python>
ma_liste = ["pomme", "poire"]
ma_liste.append("banane")  #ajoute "banane" à la fin de la liste
print(ma_liste)  #affiche ['pomme', 'poire', 'banane']
</code>

===list.pop() (retire et renvoie le dernier élément de la liste)===
Supprime le dernier élément de la liste et renvoie sa valeur.

<code python>
ma_liste = ["pomme", "poire", "banane"]
element = ma_liste.pop()  #retire "banane" et le renvoie dans la variable element
print(element)   #affiche banane
print(ma_liste)  #affiche ['pomme', 'poire']
</code>

===list.pop(indice) (retire et renvoie l'élément à l'indice donné, ex : list.pop(0))===
Supprime l'élément situé à l'indice indiqué et renvoie sa valeur.

<code python>
ma_liste = ["pomme", "poire", "banane"]
element = ma_liste.pop(0)  #retire l'élément d'indice 0 et le renvoie dans la variable element
print(element)   #affiche pomme
print(ma_liste)  #affiche ['poire', 'banane']
</code>

===list[i] renvoie une valeur d'une liste===
Permet de lire la valeur d'une liste à l'indice i, sans la supprimer de la liste.

<code python>
ma_liste = ["pomme", "poire", "banane"]
print(ma_liste[1])  #affiche poire (valeur d'indice 1)
</code>

===list[i] = valeur (écriture d'une valeur dans une liste par indice)===
Permet de remplacer la valeur présente à l'indice i par une nouvelle valeur.

<code python>
ma_liste = ["pomme", "poire", "banane"]
ma_liste[1] = "fraise"  #remplace la valeur d'indice 1 par "fraise"
print(ma_liste)  #affiche ['pomme', 'fraise', 'banane']
</code>

===liste == [] (tester si une liste est vide par comparaison)===
Permet de vérifier si une liste ne contient aucun élément, en la comparant à une liste vide.

<code python>
ma_liste = []
if ma_liste == []:  #vérifie que la liste est vide
    print("la liste est vide")
</code>

===len(list)===
Renvoie le nombre d'éléments contenus dans la liste.

<code python>
ma_liste = ["pomme", "poire", "banane"]
print(len(ma_liste))  #affiche 3
</code>

===valeur in list (renvoie True si Valeur est présent dans la liste)===
Permet de vérifier si une valeur est présente dans une liste.

<code python>
ma_liste = ["pomme", "poire", "banane"]
print("poire" in ma_liste)   #affiche True
print("fraise" in ma_liste)  #affiche False
</code>

===Liste de liste===
Une liste peut elle-même contenir d'autres listes. On parle alors de liste de liste, ce qui permet par exemple de représenter une matrice (un tableau à deux dimensions).

<code python>
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrice)  #affiche [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
</code>

===liste[i][j] (lecture/écriture d'un élément dans une liste de listes - matrice)===
Permet d'accéder à un élément précis d'une liste de listes : i correspond à l'indice de la sous-liste (la ligne), j correspond à l'indice de l'élément dans cette sous-liste (la colonne).

<code python>
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrice[1][2])  #affiche 6 (ligne d'indice 1, colonne d'indice 2)
matrice[0][0] = 100    #remplace la valeur ligne 0, colonne 0
print(matrice)
</code>

===list.clear()===
Supprime tous les éléments de la liste, qui devient alors une liste vide.

<code python>
ma_liste = ["pomme", "poire", "banane"]
ma_liste.clear()
print(ma_liste)  #affiche []
</code>

===del(list[indice])===
Supprime l'élément de la liste ayant l'indice indiqué.

<code python>
ma_liste = ["pomme", "poire", "banane"]
del(ma_liste[1])  #supprime l'élément d'indice 1 (poire)
print(ma_liste)  #affiche ['pomme', 'banane']
</code>

===sorted(list)===
Renvoie une nouvelle liste triée par ordre croissant (ou alphabétique pour des chaines de caractères), sans modifier la liste d'origine.

<code python>
ma_liste = [3, 1, 2]
liste_triee = sorted(ma_liste)
print(liste_triee)  #affiche [1, 2, 3]
print(ma_liste)      #affiche [3, 1, 2] (la liste d'origine n'est pas modifiée)
</code>

===s.extend(list)===
Ajoute tous les éléments d'une liste à la fin d'une autre liste, contrairement à append() qui ajouterait la liste entière comme un seul élément.

<code python>
s = ["pomme", "poire"]
s.extend(["banane", "fraise"])  #ajoute chaque élément de la deuxième liste à la fin de s
print(s)  #affiche ['pomme', 'poire', 'banane', 'fraise']
</code>

===[expression for variable in range(...)] (compréhension de liste)===
La compréhension de liste permet de créer une liste en une seule ligne, en appliquant une expression à chaque valeur d'un intervalle (ou d'une autre liste).

<code python>
carres = [nombre**2 for nombre in range(5)]  #crée une liste des carrés de 0 à 4
print(carres)  #affiche [0, 1, 4, 9, 16]
</code>