Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Module « builtins »

Classe « list »

Informations générales

Héritage

builtins.object
    builtins.list

Définition

class list(builtins.object):

Description

Le type list permet de représenter un ensemble séquentiel d'éléments. Le langage Python ne fait pas la distinction entre la notion de tableau ou de liste : néanmoins, on parlera plutôt de liste. Pour définir une liste, on utilise la syntaxe [], comme le montre l'exemple suivant.

>>> data = [10, 20, 30, 40, 50]
>>> data
[10, 20, 30, 40, 50]
>>> type(data)
<class 'list'>
>>> 

Une liste Python n'est pas limitée à un type de données unique : vous pouvez donc avoir des données quelconque dans une liste. Voici un exemple de définition d'une liste contenant des données diverses et variées.

>>> data = [10, 2.3, True, "Une chaîne", False, ["une", "sous", "liste"]]
>>> data
[10, 2.3, True, 'Une chaîne', False, ['une', 'sous', 'liste']]
>>> 

L'opérateur [] permet d'accéder à un élément de la liste par sa position. Il est important de mémoriser que les indices (les positions) dans une liste commencent à 0. Ainsi, si une liste contient cinq éléments alors les indices seront compris entre 0 et 4. Voici un exemple de récupération des valeurs d'une liste.

>>> data = [10, 20, 30, 40, 50]
>>> data[0]     # On récupère le premier élément
10
>>> data[1]     # Le second
20
>>> data[2]
30
>>> data[3]
40
>>> data[4]     # Le dernier élément de la liste
50
>>> data[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> 

Il est aussi possible d'utiliser l'opérateur [] pour modifier le contenu d'une liste. Voici un petit exemple.

>>> data = [10, 20, 30, 40, 50]
>>> data[2] = 3000
>>> data
[10, 20, 3000, 40, 50]
>>> 

Contrairement à certains autres langages de programmation, Python autorise l'utilisation d'index négatifs : Dans ce cas, on accède aux valeurs de la collection par la fin : -1 correspond à l'indice du dernier éléments de la liste, -2 correspond à l'indice de l'avant-dernier élément... Voici un exemple d'utilisation d'index négatif.

>>> data = [10, 20, 30, 40, 50]
>>> data[-1]    # Dernier élément
50
>>> data[-2]
40
>>> data[-3]
30
>>> data[-4]
20
>>> data[-5]
10
>>> data[-6]    # Premier élément
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> 

Pour ajouter une nouvelle valeur en fin de liste, on utilise la méthode append. Vous pouvez aussi utiliser la méthode insert pour insérer une valeur à une position donnée (basée à partir de 0, bien entendu). Voici deux exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> data.append(60)
>>> data
[10, 20, 30, 40, 50, 60]
>>> data.insert(2, 25)
>>> data
[10, 20, 25, 30, 40, 50, 60]
>>>

Pour supprimer une valeur à une position donnée de votre liste, vous pouvez utiliser l'opérateur del. Il est aussi possible d'utiliser la méthode pop pour arriver au même résultat. La différence entre les deux possibilités est que la méthode pop vous renvoie la valeur supprimée, comme le montre l'exemple suivant.

>>> data = [10, 20, 30, 40, 50]
>>> del data[2]         # Utilisation de l'opérateur del
>>> data
[10, 20, 40, 50]
>>> data.pop(2)         # Utilisation de la méthode pop
40
>>> data
[10, 20, 50]
>>> data.pop()          # Utilisation de la méthode pop
50
>>> data
[10, 20]
>>> 
si vous ne spécifiez aucun paramètre à la méthode pop, celle-ci vous supprimera la dernière valeur de la liste.

Si vous souhaitez supprimer toutes les valeurs présentes dans une liste, vous pouvez aussi invoquer la méthode clear.

>>> data = [10, 20, 30, 40, 50]
>>> data.clear()
>>> data
[]
>>>

Il est bien entendu possible de parcourir tous les éléments d'une liste. Pour ce faire, vous pouvez utiliser une boucle while ou une boucle for. Mais veuillez privilégier, tant que possible, la boucle for

 1 
 2 
 3 
 4 
 5 
 6 
 7 
data = [10, 20, 30, 40, 50]

# On traite chaque élément de la liste, un par un
for value in data:
    print(value)
    
print("Parcours terminé")
Fichier sample.py : exemple de parcours d'une liste avec une boucle while

Et voici les résultats produits par cet exemple.

$> python sample.py
10
20
30
40
50
Boucle while terminée
$> 

Pour extraire une sous-liste, à l'instar des chaînes de caractères, vous pouvez utiliser la notion de slicing. Il faut passer l'indice de début (basé à partir de 0) et l'indice de fin (position exclusive) de cette dernière. Les deux indices doivent être séparés par un caractère :. Voici quelques exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> data[1:3]
[20, 30]
>>> data[1:4]
[20, 30, 40]
>>> data[1:5]
[20, 30, 40, 50]
>>> data[:4]
[10, 20, 30, 40]
>>> data[2:]
[30, 40, 50]
>>> data[:]
[10, 20, 30, 40, 50]
>>> 
comme vous le constatez, si vous ne mentionnez pas l'indice de début, la valeur 0 sera considérée. De même, si vous ne spécifiez pas l'indice de fin, la valeur len(la_liste) sera considérée. Dans les deux cas, le caractère : doit impérativement être présent, sans quoi un seul élément de la liste sera considéré.
l'indice de fin est exclusif, ce qui implique que la valeur à la position de fin ne fera pas partie de la sous-liste. Le nombre d'éléments à extraire vaut donc indice_de_fin - indice_de_debut : data[1, 4] permettra donc d'extraire 3 valeurs (4 - 1 = 3).

Il est aussi possible d'extraire les éléments d'une sous-liste tout les « n » éléments. Imaginons que vous ayez une liste qui contiennent des coordonnées x, y qui suivent les une après les autres. Si vous souhaitez extraire que les abscisses (les x), vous pouvez le faire en spécifiant la slice suivante : coords[::2] (avec le pas en troisième paramètre de la slice). Pour obtenir toutes les ordonnées (les y), veuillez utiliser la slice suivante : coords[1::2], pour débuter l'extraction à partir de la seconde valeur par pas de 2. Voici un exemple d'utilisation.

>>> #         x, y, x,  y, x,  y,  x, y
>>> coords = [0, 0, 10, 5, 13, 12, 5, 7]
>>> 
>>> all_x = coords[::2]
>>> all_x
[0, 10, 13, 5]
>>> 
>>> all_y = coords[1::2]
>>> all_y
[0, 5, 12, 7]
>>> 

Vous pouvez aussi utiliser le concept de « liste en compréhension » (list comprehension, en anglais). Il permet de produire une nouvelle liste par filtrage et adaptation du contenu d'une autre liste. Voici un exemple qui sélectionne dans une liste de chaînes de caractères toutes celles qui commencent par la lettre P et les transforme en majuscules.

>>> langages = ["c", "Java", "Python", "c++", "Perl", "Visual Basic"]
>>> selection = [lang.upper() for lang in langages if lang[0] == 'P']
>>> selection
['PYTHON', 'PERL']
>>> 
pour de plus amples informations sur ce sujet, je vous renvoie vers notre tutoriel Python.

De nombreux autres opérateurs sont aussi proposés par la classe list. Voici quelques exemples d'utilisation.

>>> l1 = [10, 20, 30, 40, 50]
>>> l2 = [60, 70, 80, 90, 100]
>>> 
>>> # Concaténation de listes
>>> full = l1 + l2
>>> full
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> 
>>> # Répétition d'une liste
>>> l1 * 3
[10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50]
>>> 
>>> # Comparaison de listes
>>> l1 == l2
False
>>> 
>>> # Recherche d'une valeur dans une liste
>>> 30 in l1
True
>>> 70 in l1
False
>>>
>>> # Insertion de valeurs dans une liste
>>> l1 += l2
>>> l1
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> 
Exemple d'utilisation d'opérateurs disponibles pour vos listes.

Il est possible de typer vos tuples en utilisant la syntaxe suivante.

 1 
 2 
 3 
# Attention : Python 3.9 ou supérieur requis !!!
data: list[float] = [10, 20.2, 13.4]
print(data)
Typage d'une variable en tant que liste de valeurs flottantes.

Description [extrait de list.__doc__]

Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list.
The argument must be an iterable if specified.

Exemple(s) de code

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
#!/usr/bin/python3

from random import randint

# On génère une liste avec des valeurs entières aléatoires
data = []
for i in range(10):
    data.append(randint(-10, 10))
print(data)

# On calcule la somme de toutes valeurs de la liste
total = 0
for value in data:
    total += value
# On aurrait pu aussi écrire : total = sum(data)

# On calcule la valeur moyenne de la liste
mean = total / len(data)

# On affiche les résultats
print("Data =", data)
print("Total = ", total)
print("Valeur moyenne = ", mean)
Exemple de manipulation d'une liste d'entiers.

Et voici les résultats produits par cet exemple.

$> python3 sample.py
[-9, -7, 10, -1, 2, 1, -6, 10, 10, 4]
Data = [-9, -7, 10, -1, 2, 1, -6, 10, 10, 4]
Total =  14
Valeur moyenne =  1.4
$> 

Constructeur(s)

Signature du constructeur Description
__new__(*args, **kwargs) Create and return a new object. See help(type) for accurate signature. [extrait de __new__.__doc__]
__init__(self, /, *args, **kwargs) Initialize self. See help(type(self)) for accurate signature. [extrait de __init__.__doc__]

Liste des opérateurs

Signature de l'opérateur Description
__add__(self, value) Return self+value. [extrait de __add__.__doc__]
__contains__(self, key) Return key in self. [extrait de __contains__.__doc__]
__delitem__(self, key) Delete self[key]. [extrait de __delitem__.__doc__]
__eq__(self, value) Return self==value. [extrait de __eq__.__doc__]
__ge__(self, value) Return self>=value. [extrait de __ge__.__doc__]
__getitem__ x.__getitem__(y) <==> x[y] [extrait de __getitem__.__doc__]
__gt__(self, value) Return self>value. [extrait de __gt__.__doc__]
__iadd__(self, value) Implement self+=value. [extrait de __iadd__.__doc__]
__imul__(self, value) Implement self*=value. [extrait de __imul__.__doc__]
__le__(self, value) Return self<=value. [extrait de __le__.__doc__]
__lt__(self, value) Return self<value. [extrait de __lt__.__doc__]
__mul__(self, value) Return self*value. [extrait de __mul__.__doc__]
__ne__(self, value) Return self!=value. [extrait de __ne__.__doc__]
__rmul__(self, value) Return value*self. [extrait de __rmul__.__doc__]
__setitem__(self, key, value) Set self[key] to value. [extrait de __setitem__.__doc__]

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
__class_getitem__ See PEP 585 [extrait de __class_getitem__.__doc__]
__getattribute__(self, name) Return getattr(self, name). [extrait de __getattribute__.__doc__]
__iter__(self) Implement iter(self). [extrait de __iter__.__doc__]
__len__(self) Return len(self). [extrait de __len__.__doc__]
__repr__(self) Return repr(self). [extrait de __repr__.__doc__]
__reversed__(self) Return a reverse iterator over the list. [extrait de __reversed__.__doc__]
__sizeof__(self) Return the size of the list in memory, in bytes. [extrait de __sizeof__.__doc__]
append(self, value) -> None Ajoute une nouvelle valeur à la fin de la liste courante. Append object to the end of the list. [extrait de append.__doc__]
clear(self) -> None Supprime toutes les valeurs stockées dans la liste. Remove all items from list. [extrait de clear.__doc__]
copy(self) -> list Renvoie une copie « peu profonde » (shallow copy, en anglais) de la liste courante. Return a shallow copy of the list. [extrait de copy.__doc__]
count(self, value) -> int Compte le nombre d'occurrences de la valeur spécifiée en paramètre. Return number of occurrences of value. [extrait de count.__doc__]
extend(self, iterable) -> None Ajoute les valeurs d'un itérable (list, tuple, ...) à la fin de la liste courante. Extend list by appending elements from the iterable. [extrait de extend.__doc__]
index(self, value, start=0, stop=2**63-1) -> int Renvoie la position de la première occurrence d'une valeur dans la liste courante. Return first index of value. [extrait de index.__doc__]
insert(self, position, value) -> None Insère une nouvelle valeur dans la liste courante, à la position spécifiée en paramètre. Insert object before index. [extrait de insert.__doc__]
pop(self, index = -1) -> object Retire de la liste et renvoie la valeur à la position spécifiée. Remove and return item at index (default last). [extrait de pop.__doc__]
remove(self, value) -> None Retire la première occurrence d'une valeur de la liste courante. Remove first occurrence of value. [extrait de remove.__doc__]
reverse(self) -> None Renverse, sur place, le contenu de la liste. Reverse *IN PLACE*. [extrait de reverse.__doc__]
sort(self, *, key=None, reverse=False) -> None Cette méthode trie, sur place, la collection courante. Sort the list in ascending order and return None. [extrait de sort.__doc__]

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __hash__, __init_subclass__, __reduce__, __reduce_ex__, __setattr__, __str__, __subclasshook__

Voir aussi

Classe dict
Classe set
Classe tuple

Fonction len
Fonction max
Fonction min
Fonction sum