builtins.object builtins.list
class list(builtins.object):
list permet de représenter un ensemble séquentiel d'éléments.[], 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] >>>
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é") |
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] >>>
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é.
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'] >>>
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)
|
Built-in mutable sequence. If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.
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) |
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 $>
| 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__] |
| 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__] |
| Signature de la méthode | Description |
|---|---|
| __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__] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 :