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 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é")

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]
>>> 

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']
>>> 

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]
>>> 

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)