Aller au contenu

08 Cours Listes Compléments

Méthodes associées aux listes⚓︎

La longueur d’une liste est donnée par fonction len()

Méthodes ne modifiant pas la liste⚓︎

  • L.index(elem) renvoie l’indice de l’élément elem (le premier rencontré)

Méthodes modifiant la liste⚓︎

  • L.append() ajoute un élément à la fin
  • L.pop() retourne le dernier élément et le retire de la liste
  • L.sort() trie la liste
  • L.reverse() inverse l’ordre des éléments de la liste
  • L.insert(i, elem) insère l’élément elem à l’indice i
  • L.remove(elem) supprime l’élément elem

Plus d’infos dans la documentation officielle.

Exemples⚓︎

🐍 Script Python
L = ['egg', 'spam', 'spam', 'spam', 'bacon']

print(f"len() renvoie : {len(L)}")

L.append('spam') # Ne renvoie pas de valeur

print(f"Après append() : {L}")
📋 Texte
len() renvoie : 5
Après append() : ['egg', 'spam', 'spam', 'spam', 'bacon', 'spam']
🐍 Script Python
print(f"pop() renvoie : {L.pop()}")
print(f"Après pop() : {L}")
📋 Texte
pop() renvoie : spam
Après pop() : ['egg', 'spam', 'spam', 'spam', 'bacon']
🐍 Script Python
L.reverse() # Ne renvoie pas de valeur

print(f"Après reverse() : {L}")
📋 Texte
Après reverse() : ['bacon', 'spam', 'spam', 'spam', 'egg']
🐍 Script Python
print(f"index() renvoie : {L.index('egg')}")
📋 Texte
index() renvoie : 4
🐍 Script Python
L.remove('spam') # Ne renvoie pas de valeur

print(f"Après remove : {L}")
📋 Texte
Après remove : ['bacon', 'spam', 'spam', 'egg']

Dans les exemples précédents, remarquez la syntaxe qui permet d’appliquer une méthode à un objet :

🐍 Script Python
objet.methode()

Ici, .methode() est une fonction propre au type de objet. Si .methode() existe pour un autre type, elle n’a pas forcément le même comportement. Nous verrons plus en détail cette mécanique dans la section dédiée à la programmation objet... en Terminale.

Pour obtenir la liste des méthodes associées aux listes, on peut utiliser la fonction interne help() :

🐍 Script Python
help(list) # ou aussi help([])

Opérations sur les listes⚓︎

On peut créer facilement des listes répétitives grâce à l’opération de multiplication.

🐍 Script Python
a = ['a', 1] * 5

print(a)
📋 Texte
['a', 1, 'a', 1, 'a', 1, 'a', 1, 'a', 1]

Mais on ne peut pas ’diviser’ une liste.

🐍 Script Python
a = [1, 2, 3, 4]

print(a / 2)
📋 Texte
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: unsupported operand type(s) for /: 'list' and 'int'

Vous trouverez la documentation complète sur les listes ici.

Slicing (de liste)⚓︎

Le slicing consiste à extraire une sous-séquence à partir d’une séquence.

Cela fonctionne de manière similaire aux intervalles mathématiques : [début:fin[

La borne de fin ne fait pas partie de l’intervalle sélectionné.

La syntaxe générale est L[i:j:k], où :

  • i = indice de début
  • j = indice de fin, le premier élément qui n’est pas sélectionné
  • k = le « pas » ou intervalle (s’il est omis alors il vaut 1)

La sous-liste sera donc composée de tous les éléments de l’indice i jusqu’à l’indice j-1, par pas de k.

La sous-liste est un nouvel objet.

Dans le sens normal (le pas k est positif), on parcourt par défaut du 1er audernier terme :

  • Si i est omis alors il vaut 0
  • Si j est omis alors il vaut len(L)

Dans le sens inverse (le pas k est négatif), on parcourt par défaut du dernier au 1er terme :

  • Si i est omis alors il vaut -1
  • Si j est omis alors il vaut -len(L)-1

Illustrons ça en créant une liste à partir d’une chaîne de caractères.

La fonction split() découpe une chaîne de caractères en morceaux, par défaut en ’mots’ (en séparant à chaque espace).

🐍 Script Python
L = 'Dans le Python tout est bon'.split()
print(L)

📋 Texte
['Dans', 'le', 'Python', 'tout', 'est', 'bon']
Pour commencer, on extrait de la liste L un nouvel objet liste qui contient tous les éléments de L (ce qui revient à faire une copie de la liste).

🐍 Script Python
print(L[0:len(L):1]) # Cette notation est inutilement lourde car :
print(L[::])         # i = 0, j=len(L) et k=1 donc i, j et k peuvent être omis
print(L[:])          # on peut même ommettre le 2ème ":"
📋 Texte
['Dans', 'le', 'Python', 'tout', 'est', 'bon']
['Dans', 'le', 'Python', 'tout', 'est', 'bon']
['Dans', 'le', 'Python', 'tout', 'est', 'bon']

On extrait une sous-liste qui ne contient que les 3 premiers éléments :

🐍 Script Python
print(L[0:3:1])  # Notation complète
print(L[:3:1])  # Le premier indice vaut i=0, donc on peut l'omettre
print(L[:3])  # Le pas de slicing vaut 1, donc on peut l'omettre, ainsi que le ":"
📋 Texte
['Dans', 'le', 'Python']
['Dans', 'le', 'Python']
['Dans', 'le', 'Python']

J’extrais une sous-liste qui exclut les trois premiers éléments :

🐍 Script Python
print(L[3:len(L):1])  # Cette notation est inutilement lourde car :
print(L[3:])          # j et k peuvent être omis, ainsi que le ":"
📋 Texte
['tout', 'est', 'bon']
['tout', 'est', 'bon']
['tout', 'est', 'bon']

Les indices peuvent être négatifs, ce qui permet de traiter les derniers éléments :

🐍 Script Python
# Je veux exclure le dernier élément :
print(L[0:-1:1])  # Notation complète
print(L[:-1:1])  # Le premier indice vaut i=0, donc on peut l'omettre
print(L[:-1])  # Le pas de slicing vaut 1, donc on peut l'omettre
📋 Texte
['Dans', 'le', 'Python', 'tout', 'est']
['Dans', 'le', 'Python', 'tout', 'est']
['Dans', 'le', 'Python', 'tout', 'est']

On ne garde que les deux derniers éléments

🐍 Script Python
print(L[-2:])
📋 Texte
['est', 'bon']

Note⚓︎

L[1] n’est pas équivalent à L[1:2], ni à L[1:], ni à L[:1].

Illustration :

🐍 Script Python
a = L[1]
print(type(a), a) # Je récupère le deuxième élément de la liste
a = L[1:2]
print(type(a), a) # Je récupère une liste composée du seul élément L[1]
a = L[1:]
print(type(a), a) # Je récupère une liste
a = L[:1]
print(type(a), a) # Je récupère une liste
📋 Texte
<class 'str'> le
<class 'list'> ['le']
<class 'list'> ['le', 'Python', 'tout', 'est', 'bon']
<class 'list'> ['Dans']

Le slicing peut être utilisé pour modifier une séquence mutable grâce à l’opération d’assignation.

🐍 Script Python
L = 'Dans le Python tout est bon'.split()
print(L)
L[2:4] = ['nouvelles', 'valeurs', 'et encore plus...', 1, 2, 3]
print(L)
📋 Texte
['Dans', 'le', 'Python', 'tout', 'est', 'bon']
['Dans', 'le', 'nouvelles', 'valeurs', 'et encore plus...', 1, 2, 3, 'est', 'bon']

Chaînes de caractères⚓︎

Le slicing peut être utilisé sur des chaînes de caractères.

🐍 Script Python
texte = "abcdefghijklmnopqrstuvwxyz"
print(texte)
print(texte[0::3])
📋 Texte
abcdefghijklmnopqrstuvwxyz
adgjmpsvy

Manipulations usuelles sur les listes de nombres⚓︎

Le maximum d'une liste⚓︎

Pour déterminer un maximum, la technique est généralement la suivante :

  • on prend le premier élément, et on considère temporairement que c'est le maximum
  • puis on parcourt la liste. A chaque étape, si l'élément est plus grand que le maximum temporaire que l'on a sauvegardé, on remplace le maximum temporaire par celui-là. Puis on continue.
  • une fois toute la liste parcourue, le maximum temporaire est en fait le maximum de la liste.
🐍 Script Python
from random import randint
L = [randint(1, 100) for i in range(15)]

maxi = L[0]
for nb in L:
    if nb > maxi:
        maxi = nb

print(f"La plus grande valeur de la liste est {maxi}")

Comme habituellement, le parcours de la liste se fait en élément ou en indice, suivant si on besoin des indices ou non.

Remarque : la méthode s'adapte facilement pour déterminer le minimum de la liste.

Calcul d'une somme⚓︎

Lorsqu'on veut calculer une somme à l'aide d'une boucle, la méthode consiste à:

  • initialiser la somme à zéro ;
  • à chaque tour, ajouter à la somme déjà obtenue, l'élément en cours.
🐍 Script Python
from random import randint
L = [randint(1, 100) for i in range(15)]

somme = 0
for nb in L:
    somme += nb

print(f"La somme des valeurs de la liste est {somme}")

Un calcul de somme peut permettre d'autres choses, comme le calcul d'une moyenne (somme / nombre de termes).