Listes et Tuples en Python
Lists ettuples sont sans doute lesdata types les plus polyvalents et les plus utiles de Python. Vous les trouverez dans pratiquement tous les programmes Python non triviaux.
Here’s what you’ll learn in this tutorial: Vous couvrirez les caractéristiques importantes des listes et des tuples. Vous apprendrez à les définir et à les manipuler. Lorsque vous avez terminé, vous devriez avoir une bonne idée de quand et comment utiliser ces types d'objets dans un programme Python.
__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Listes et tuples Python». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:
Listes Python
En bref, une liste est une collection d'objets arbitraires, quelque peu semblable à un tableau dans de nombreux autres langages de programmation mais plus flexible. Les listes sont définies en Python en plaçant une séquence d'objets séparés par des virgules entre crochets ([]), comme indiqué ci-dessous:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print(a)
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']Les caractéristiques importantes des listes Python sont les suivantes:
-
Les listes sont ordonnées.
-
Les listes peuvent contenir tout objet arbitraire.
-
Les éléments de la liste sont accessibles par index.
-
Les listes peuvent être imbriquées à une profondeur arbitraire.
-
Les listes sont modifiables.
-
Les listes sont dynamiques.
Chacune de ces caractéristiques est examinée plus en détail ci-dessous.
Les listes sont ordonnées
Une liste n'est pas simplement une collection d'objets. Il s'agit d'une collection ordonnée d'objets. L'ordre dans lequel vous spécifiez les éléments lorsque vous définissez une liste est une caractéristique innée de cette liste et est conservé pendant toute la durée de vie de cette liste. (Vous verrez un type de données Python qui n'est pas commandé dans le prochain didacticiel sur les dictionnaires.)
Les listes qui ont les mêmes éléments dans un ordre différent ne sont pas les mêmes:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
FalseLes listes peuvent contenir des objets arbitraires
Une liste peut contenir n'importe quel assortiment d'objets. Les éléments d'une liste peuvent tous être du même type:
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]Ou les éléments peuvent être de différents types:
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]Les listes peuvent même contenir des objets complexes, comme des fonctions, des classes et des modules, que vous découvrirez dans les prochains didacticiels:
>>>
>>> int
>>> len
>>> def foo():
... pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
] Une liste peut contenir n'importe quel nombre d'objets, de zéro à autant que la mémoire de votre ordinateur le permet:
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
... 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
... 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
... 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100](Une liste avec un seul objet est parfois appelée liste singleton.)
Les objets de liste ne doivent pas être uniques. Un objet donné peut apparaître plusieurs fois dans une liste:
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']Les éléments de liste sont accessibles par index
Les éléments individuels d'une liste sont accessibles à l'aide d'un index entre crochets. Ceci est exactement analogue à l'accès à des caractères individuels dans une chaîne. L'indexation de liste est basée sur zéro comme pour les chaînes.
Considérez la liste suivante:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']Les indices des éléments ena sont indiqués ci-dessous:
Voici le code Python pour accéder à certains éléments dea:
>>>
>>> a[0]
'foo'
>>> a[2]
'baz'
>>> a[5]
'corge'Presque tout sur l'indexation des chaînes fonctionne de la même manière pour les listes. Par exemple, un index de liste négatif compte à partir de la fin de la liste:
>>>
>>> a[-1]
'corge'
>>> a[-2]
'quux'
>>> a[-5]
'bar'Le découpage fonctionne également. Sia est une liste, l'expressiona[m:n] renvoie la partie dea de l'indexm à, mais non compris, l'indexn:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:5]
['baz', 'qux', 'quux']Les autres caractéristiques du découpage de chaîne fonctionnent également de manière analogue pour le découpage de liste:
-
Les indices positifs et négatifs peuvent être spécifiés:
>>>
>>> a[-5:-2]
['bar', 'baz', 'qux']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[-5:-2] == a[1:4]
True-
L'omission du premier index démarre la tranche au début de la liste, et l'omission du deuxième index prolonge la tranche jusqu'à la fin de la liste:
>>>
>>> print(a[:4], a[0:4])
['foo', 'bar', 'baz', 'qux'] ['foo', 'bar', 'baz', 'qux']
>>> print(a[2:], a[2:len(a)])
['baz', 'qux', 'quux', 'corge'] ['baz', 'qux', 'quux', 'corge']
>>> a[:4] + a[4:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:4] + a[4:] == a
True-
Vous pouvez spécifier une foulée, positive ou négative:
>>>
>>> a[0:6:2]
['foo', 'baz', 'quux']
>>> a[1:6:2]
['bar', 'qux', 'corge']
>>> a[6:0:-2]
['corge', 'qux', 'bar']-
La syntaxe pour inverser une liste fonctionne de la même manière que pour les chaînes:
>>>
>>> a[::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']-
La syntaxe
[:]fonctionne pour les listes. Cependant, il existe une différence importante entre le fonctionnement de cette opération avec une liste et son fonctionnement avec une chaîne.Si
sest une chaîne,s[:]renvoie une référence au même objet:>>>
>>> s = 'foobar'
>>> s[:]
'foobar'
>>> s[:] is s
True+ Inversement, sia est une liste,a[:] renvoie un nouvel objet qui est une copie dea:
+>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:] is a
FalsePlusieurs opérateurs Python et fonctions intégrées peuvent également être utilisés avec des listes de manière analogue aux chaînes:
-
Les opérateurs
inetnot in:>>>
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> 'qux' in a
True
>>> 'thud' not in a
True-
Les opérateurs de concaténation (
+) et de réplication (*):>>>
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a + ['grault', 'garply']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'foo', 'bar', 'baz',
'qux', 'quux', 'corge']-
Les fonctions
len(),min()etmax():>>>
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> len(a)
6
>>> min(a)
'bar'
>>> max(a)
'qux'Ce n'est pas un hasard si les chaînes et les listes se comportent de manière similaire. Ce sont deux cas particuliers d'un type d'objet plus général appelé un itérable, que vous rencontrerez plus en détail dans le prochain tutoriel sur l'itération définie.
Par ailleurs, dans chaque exemple ci-dessus, la liste est toujours affectée à une variable avant qu'une opération ne soit effectuée sur celle-ci. Mais vous pouvez également opérer sur une liste littérale:
>>>
>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][2]
'baz'
>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']
>>> 'quux' in ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
True
>>> ['foo', 'bar', 'baz'] + ['qux', 'quux', 'corge']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> len(['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1])
6D'ailleurs, vous pouvez faire de même avec un littéral de chaîne:
>>>
>>> 'If Comrade Napoleon says it, it must be right.'[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'Les listes peuvent être imbriquées
Vous avez vu qu'un élément d'une liste peut être n'importe quelle sorte d'objet. Cela comprend une autre liste. Une liste peut contenir des sous-listes, qui à leur tour peuvent contenir des sous-listes elles-mêmes, et ainsi de suite à une profondeur arbitraire.
Considérez cet exemple (certes artificiel):
>>>
>>> x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']La structure d'objet quex référence est schématisée ci-dessous:
x[0],x[2] etx[4] sont des chaînes, chacune d'un caractère:
>>>
>>> print(x[0], x[2], x[4])
a g jMaisx[1] etx[3] sont des sous-listes:
>>>
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[3]
['hh', 'ii']Pour accéder aux éléments d'une sous-liste, ajoutez simplement un index supplémentaire:
>>>
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[1][0]
'bb'
>>> x[1][1]
['ccc', 'ddd']
>>> x[1][2]
'ee'
>>> x[1][3]
'ff'
>>> x[3]
['hh', 'ii']
>>> print(x[3][0], x[3][1])
hh iix[1][1] est encore une autre sous-liste, donc l'ajout d'un index supplémentaire accède à ses éléments:
>>>
>>> x[1][1]
['ccc', 'ddd']
>>> print(x[1][1][0], x[1][1][1])
ccc dddIl n'y a pas de limite, à part l'étendue de la mémoire de votre ordinateur, à la profondeur ou à la complexité avec laquelle les listes peuvent être imbriquées de cette manière.
Toute la syntaxe habituelle concernant les indices et le découpage s'applique également aux sous-listes:
>>>
>>> x[1][1][-1]
'ddd'
>>> x[1][1:3]
[[ccc', 'ddd'], 'ee']
>>> x[3][::-1]
['ii', 'hh']Cependant, sachez que les opérateurs et les fonctions s'appliquent uniquement à la liste au niveau que vous spécifiez et ne sont pas récursifs. Considérez ce qui se passe lorsque vous interrogez la longueur dex en utilisantlen():
>>>
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> len(x)
5
>>> x[0]
'a'
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[2]
'g'
>>> x[3]
['hh', 'ii']
>>> x[4]
'j'x n'a que cinq éléments: trois chaînes et deux sous-listes. Les éléments individuels des sous-listes ne comptent pas dans la longueur dex.
Vous rencontrez une situation similaire lors de l'utilisation de l'opérateurin:
>>>
>>> 'ddd' in x
False
>>> 'ddd' in x[1]
False
>>> 'ddd' in x[1][1]
True'ddd' n'est pas l'un des éléments dex oux[1]. Ce n'est que directement un élément de la sous-listex[1][1]. Un élément individuel dans une sous-liste ne compte pas comme un élément de la ou des listes parentes.
Les listes sont modifiables
La plupart des types de données que vous avez rencontrés jusqu'à présent sont des types atomiques. Les objets entiers ou flottants, par exemple, sont des unités primitives qui ne peuvent plus être décomposées. Ces types sont immuables, ce qui signifie qu'ils ne peuvent pas être modifiés une fois qu'ils ont été attribués. Cela n'a pas beaucoup de sens de penser à changer la valeur d'un entier. Si vous voulez un entier différent, il vous suffit d'en attribuer un autre.
En revanche, le type de chaîne est un type composite. Les chaînes sont réductibles en parties plus petites - les caractères des composants. Il pourrait être judicieux de penser à changer les caractères d'une chaîne. Mais tu ne peux pas. En Python, les chaînes sont également immuables.
La liste est le premier type de données modifiable que vous avez rencontré. Une fois la liste créée, les éléments peuvent être ajoutés, supprimés, décalés et déplacés à volonté. Python offre un large éventail de façons de modifier des listes.
Modification d'une valeur de liste unique
Une seule valeur dans une liste peut être remplacée par l'indexation et l'affectation simple:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2] = 10
>>> a[-1] = 20
>>> a
['foo', 'bar', 10, 'qux', 'quux', 20]Vous vous souviendrez peut-être du tutorielStrings and Character Data in Python que vous ne pouvez pas faire cela avec une chaîne:
>>>
>>> s = 'foobarbaz'
>>> s[2] = 'x'
Traceback (most recent call last):
File "", line 1, in
TypeError: 'str' object does not support item assignment Un élément de liste peut être supprimé avec la commandedel:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[3]
>>> a
['foo', 'bar', 'baz', 'quux', 'corge']Modification de plusieurs valeurs de liste
Que faire si vous souhaitez modifier plusieurs éléments contigus dans une liste à la fois? Python permet cela avec une affectation de tranche, qui a la syntaxe suivante:
a[m:n] = Encore une fois, pensez à un itérable comme une liste. Cette affectation remplace la tranche spécifiée dea par<iterable>:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
>>> a
['foo', 1.1, 2.2, 3.3, 4.4, 5.5, 'quux', 'corge']
>>> a[1:6]
[1.1, 2.2, 3.3, 4.4, 5.5]
>>> a[1:6] = ['Bark!']
>>> a
['foo', 'Bark!', 'quux', 'corge']Le nombre d'éléments insérés n'a pas besoin d'être égal au nombre remplacé. Python ne fait qu'augmenter ou réduire la liste selon les besoins.
Vous pouvez insérer plusieurs éléments à la place d'un seul élément - utilisez simplement une tranche qui ne désigne qu'un seul élément:
>>>
>>> a = [1, 2, 3]
>>> a[1:2] = [2.1, 2.2, 2.3]
>>> a
[1, 2.1, 2.2, 2.3, 3]Notez que ce n'est pas la même chose que de remplacer l'élément unique par une liste:
>>>
>>> a = [1, 2, 3]
>>> a[1] = [2.1, 2.2, 2.3]
>>> a
[1, [2.1, 2.2, 2.3], 3]Vous pouvez également insérer des éléments dans une liste sans rien supprimer. Spécifiez simplement une tranche de la forme[n:n] (une tranche de longueur nulle) à l'index souhaité:
>>>
>>> a = [1, 2, 7, 8]
>>> a[2:2] = [3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]Vous pouvez supprimer plusieurs éléments du milieu d'une liste en affectant la tranche appropriée à une liste vide. Vous pouvez également utiliser l'instructiondel avec la même tranche:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:5] = []
>>> a
['foo', 'corge']
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[1:5]
>>> a
['foo', 'corge']Ajout ou ajout d'éléments à une liste
Des éléments supplémentaires peuvent être ajoutés au début ou à la fin d'une liste à l'aide de l'opérateur d'affectation augmentée+` concatenation operator or the `=+:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a += ['grault', 'garply']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a = [10, 20] + a
>>> a
[10, 20, 'foo', 'bar', 'baz', 'qux', 'quux', 'corge']Notez qu'une liste doit être concaténée avec une autre liste, donc si vous voulez ajouter un seul élément, vous devez le spécifier comme une liste singleton:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a += 20
Traceback (most recent call last):
File "", line 1, in
a += 20
TypeError: 'int' object is not iterable
>>> a += [20]
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 20] Note: Techniquement, il n’est pas tout à fait correct de dire qu’une liste doit être concaténée avec une autre liste. Plus précisément, une liste doit être concaténée avec un objet itérable. Bien sûr, les listes sont itérables, donc cela fonctionne pour concaténer une liste avec une autre liste.
Les cordes sont également itérables. Mais regardez ce qui se passe lorsque vous concaténez une chaîne sur une liste:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += 'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'c', 'o', 'r', 'g', 'e']Ce résultat n'est peut-être pas tout à fait ce que vous attendiez. Lorsqu'une chaîne est itérée, le résultat est une liste de ses caractères composants. Dans l'exemple ci-dessus, ce qui est concaténé sur la listea est une liste des caractères de la chaîne'corge'.
Si vous voulez vraiment n'ajouter que la seule chaîne'corge' à la fin de la liste, vous devez la spécifier en tant que liste de singleton:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += ['corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']Si cela vous semble mystérieux, ne vous inquiétez pas trop. Vous découvrirez les tenants et aboutissants des itérables dans le didacticiel sur l'itération définie.
Méthodes qui modifient une liste
Enfin, Python fournit plusieurs méthodes intégrées qui peuvent être utilisées pour modifier des listes. Les informations sur ces méthodes sont détaillées ci-dessous.
Note: Les méthodes de chaîne que vous avez vues dans le didacticiel précédent n'ont pas modifié la chaîne cible directement. C'est parce que les chaînes sont immuables. Au lieu de cela, les méthodes de chaîne retournent un nouvel objet chaîne qui est modifié comme indiqué par la méthode. Ils laissent la chaîne cible d'origine inchangée:
>>>
>>> s = 'foobar'
>>> t = s.upper()
>>> print(s, t)
foobar FOOBARLes méthodes de liste sont différentes. Les listes étant modifiables, les méthodes de liste présentées ici modifient la liste cible en place.
a.append(
Ajoute un objet à une liste.
a.append(<obj>) ajoute l'objet<obj> à la fin de la listea:
>>>
>>> a = ['a', 'b']
>>> a.append(123)
>>> a
['a', 'b', 123]N'oubliez pas que les méthodes de liste modifient la liste cible en place. Ils ne renvoient pas de nouvelle liste:
>>>
>>> a = ['a', 'b']
>>> x = a.append(123)
>>> print(x)
None
>>> a
['a', 'b', 123]N'oubliez pas que lorsque l'opérateur+ est utilisé pour concaténer en une liste, si l'opérande cible est un itérable, ses éléments sont séparés et ajoutés à la liste individuellement:
>>>
>>> a = ['a', 'b']
>>> a + [1, 2, 3]
['a', 'b', 1, 2, 3]La méthode.append() ne fonctionne pas de cette façon! Si un itérable est ajouté à une liste avec.append(), il est ajouté en tant qu'objet unique:
>>>
>>> a = ['a', 'b']
>>> a.append([1, 2, 3])
>>> a
['a', 'b', [1, 2, 3]]Ainsi, avec.append(), vous pouvez ajouter une chaîne comme une seule entité:
>>>
>>> a = ['a', 'b']
>>> a.append('foo')
>>> a
['a', 'b', 'foo']a.extend(
Étend une liste avec les objets d'un itérable.
Oui, c'est probablement ce que vous pensez. .extend() ajoute également à la fin d'une liste, mais on s'attend à ce que l'argument soit un itérable. Les éléments en<iterable> sont ajoutés individuellement:
>>>
>>> a = ['a', 'b']
>>> a.extend([1, 2, 3])
>>> a
['a', 'b', 1, 2, 3]En d'autres termes,.extend() se comporte comme l'opérateur+` operator. More precisely, since it modifies the list in place, it behaves like the `=+:
>>>
>>> a = ['a', 'b']
>>> a += [1, 2, 3]
>>> a
['a', 'b', 1, 2, 3]a.insert(
Insère un objet dans une liste.
a.insert(<index>, <obj>) insère l'objet<obj> dans la listea au<index> spécifié. Après l'appel de méthode,a[<index>] est<obj>, et les éléments restants de la liste sont poussés vers la droite:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.insert(3, 3.14159)
>>> a[3]
3.14159
>>> a
['foo', 'bar', 'baz', 3.14159, 'qux', 'quux', 'corge']a.remove(
Supprime un objet d'une liste.
a.remove(<obj>) supprime l'objet<obj> de la listea. Si<obj> n'est pas dansa, une exception est déclenchée:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.remove('baz')
>>> a
['foo', 'bar', 'qux', 'quux', 'corge']
>>> a.remove('Bark!')
Traceback (most recent call last):
File "", line 1, in
a.remove('Bark!')
ValueError: list.remove(x): x not in list a.pop(index=-1)
Supprime un élément d'une liste.
Cette méthode diffère de.remove() de deux manières:
-
Vous spécifiez l'index de l'élément à supprimer, plutôt que l'objet lui-même.
-
La méthode renvoie une valeur: l'élément qui a été supprimé.
a.pop() supprime simplement le dernier élément de la liste:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.pop()
'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux']
>>> a.pop()
'quux'
>>> a
['foo', 'bar', 'baz', 'qux']Si le paramètre facultatif<index> est spécifié, l'élément de cet index est supprimé et renvoyé. <index> peut être négatif, comme avec l'indexation de chaînes et de listes:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.pop(1)
'bar'
>>> a
['foo', 'baz', 'qux', 'quux', 'corge']
>>> a.pop(-3)
'qux'
>>> a
['foo', 'baz', 'quux', 'corge']<index> est par défaut-1, donca.pop(-1) équivaut àa.pop().
Les listes sont dynamiques
Ce didacticiel a commencé par une liste de six caractéristiques définissant les listes Python. Le dernier est que les listes sont dynamiques. Vous en avez vu de nombreux exemples dans les sections ci-dessus. Lorsque des éléments sont ajoutés à une liste, elle s'agrandit au besoin:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:2] = [1, 2, 3]
>>> a += [3.14159]
>>> a
['foo', 'bar', 1, 2, 3, 'baz', 'qux', 'quux', 'corge', 3.14159]De même, une liste se réduit pour permettre la suppression d'éléments:
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:3] = []
>>> del a[0]
>>> a
['bar', 'qux', 'quux', 'corge']Tuples en python
Python fournit un autre type qui est une collection ordonnée d'objets, appelée tuple.
La prononciation varie en fonction de qui vous demandez. Certains le prononcent comme s'il était orthographié «trop-ple» (rimes avec «Mott the Hoople»), et d'autres comme s'il était orthographié «tup-ple» (rimes avec «souple»). Mon inclination est celle-ci, car elle dérive vraisemblablement de la même origine que «quintuple», «sextuple», «octuple», etc., et tout le monde que je connais prononce ces derniers comme s'ils rimaient avec «souple».
Définition et utilisation de tuples
Les tuples sont identiques aux listes à tous égards, à l'exception des propriétés suivantes:
-
Les tuples sont définis en plaçant les éléments entre parenthèses (
()) au lieu de crochets ([]). -
Les tuples sont immuables.
Voici un court exemple montrant une définition, une indexation et un découpage de tuple:
>>>
>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t
('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[0]
'foo'
>>> t[-1]
'corge'
>>> t[1::2]
('bar', 'qux', 'corge')Jamais peur! Notre mécanisme d'inversion de chaîne et de liste préféré fonctionne également pour les tuples:
>>>
>>> t[::-1]
('corge', 'quux', 'qux', 'baz', 'bar', 'foo')Note: Même si les tuples sont définis à l'aide de parenthèses, vous indexez et découpez toujours les tuples en utilisant des crochets, tout comme pour les chaînes et les listes.
Tout ce que vous avez appris sur les listes - elles sont ordonnées, elles peuvent contenir des objets arbitraires, elles peuvent être indexées et découpées, elles peuvent être imbriquées - est également valable pour les tuples. Mais ils ne peuvent pas être modifiés:
>>>
>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[2] = 'Bark!'
Traceback (most recent call last):
File "", line 1, in
t[2] = 'Bark!'
TypeError: 'tuple' object does not support item assignment Pourquoi utiliser un tuple au lieu d'une liste?
-
L'exécution du programme est plus rapide lors de la manipulation d'un tuple que pour la liste équivalente. (Cela ne sera probablement pas visible lorsque la liste ou le tuple est petit.)
-
Parfois, vous ne voulez pas que les données soient modifiées. Si les valeurs de la collection sont censées rester constantes pendant toute la durée de vie du programme, l'utilisation d'un tuple au lieu d'une liste protège contre les modifications accidentelles.
-
Il existe un autre type de données Python que vous rencontrerez sous peu, appelé dictionnaire, qui requiert comme l'un de ses composants une valeur de type immuable. Un tuple peut être utilisé à cette fin, alors qu'une liste ne peut pas l'être.
Dans une session Python REPL, vous pouvez afficher les valeurs de plusieurs objets simultanément en les saisissant directement à l'invite>>>, séparées par des virgules:
>>>
>>> a = 'foo'
>>> b = 42
>>> a, 3.14159, b
('foo', 3.14159, 42)Python affiche la réponse entre parenthèses car il interprète implicitement l'entrée comme un tuple.
Il y a une particularité concernant la définition de tuple que vous devez connaître. Il n'y a aucune ambiguïté lors de la définition d'un tuple vide, ni d'un élément comportant deux éléments ou plus. Python sait que vous définissez un tuple:
>>>
>>> t = ()
>>> type(t)
>>>
>>> t = (1, 2)
>>> type(t)
>>> t = (1, 2, 3, 4, 5)
>>> type(t)
Mais que se passe-t-il lorsque vous essayez de définir un tuple avec un élément:
>>>
>>> t = (2)
>>> type(t)
Doh! Puisque les parenthèses sont également utilisées pour définir la priorité des opérateurs dans les expressions, Python évalue l'expression(2) comme simplement l'entier2 et crée un objetint. Pour dire à Python que vous voulez vraiment définir un tuple singleton, incluez une virgule de fin (,) juste avant la parenthèse fermante:
>>>
>>> t = (2,)
>>> type(t)
>>> t[0]
2
>>> t[-1]
2 Vous n'aurez probablement pas besoin de définir un tuple singleton souvent, mais il doit y avoir un moyen.
Lorsque vous affichez un tuple singleton, Python inclut la virgule, pour vous rappeler qu'il s'agit d'un tuple:
>>>
>>> print(t)
(2,)Affectation, emballage et déballage des tuples
Comme vous l'avez déjà vu ci-dessus, un tuple littéral contenant plusieurs éléments peut être affecté à un seul objet:
>>>
>>> t = ('foo', 'bar', 'baz', 'qux')Lorsque cela se produit, c'est comme si les éléments du tuple avaient été «emballés» dans l'objet:
>>>
>>> t
('foo', 'bar', 'baz', 'qux')
>>> t[0]
'foo'
>>> t[-1]
'qux'Si cet objet «compressé» est ensuite affecté à un nouveau tuple, les éléments individuels sont «décompressés» dans les objets du tuple:
>>>
>>> (s1, s2, s3, s4) = t
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'Lors du déballage, le nombre de variables à gauche doit correspondre au nombre de valeurs dans le tuple:
>>>
>>> (s1, s2, s3) = t
Traceback (most recent call last):
File "", line 1, in
(s1, s2, s3) = t
ValueError: too many values to unpack (expected 3)
>>> (s1, s2, s3, s4, s5) = t
Traceback (most recent call last):
File "", line 1, in
(s1, s2, s3, s4, s5) = t
ValueError: not enough values to unpack (expected 5, got 4) L'emballage et le déballage peuvent être combinés en une seule instruction pour effectuer une affectation composée:
>>>
>>> (s1, s2, s3, s4) = ('foo', 'bar', 'baz', 'qux')
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'Encore une fois, le nombre d'éléments dans le tuple à gauche de l'affectation doit être égal à celui de droite:
>>>
>>> (s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
Traceback (most recent call last):
File "", line 1, in
(s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
ValueError: not enough values to unpack (expected 5, got 4) Dans des affectations comme celle-ci et quelques autres situations, Python permet de laisser de côté les parenthèses généralement utilisées pour désigner un tuple:
>>>
>>> t = 1, 2, 3
>>> t
(1, 2, 3)
>>> x1, x2, x3 = t
>>> x1, x2, x3
(1, 2, 3)
>>> x1, x2, x3 = 4, 5, 6
>>> x1, x2, x3
(4, 5, 6)
>>> t = 2,
>>> t
(2,)Cela fonctionne de la même manière, que les parenthèses soient incluses ou non. Donc, si vous avez le moindre doute quant à leur besoin, allez-y et incluez-les.
L'affectation de tuple permet un curieux morceau de Python idiomatique. Souvent, lors de la programmation, vous avez deux variables dont vous devez échanger les valeurs. Dans la plupart des langages de programmation, il est nécessaire de stocker l'une des valeurs dans une variable temporaire pendant que l'échange se produit comme ceci:
>>>
>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')
>>># We need to define a temp variable to accomplish the swap.
>>> temp = a
>>> a = b
>>> b = temp
>>> a, b
('bar', 'foo')En Python, l'échange peut être effectué avec une seule affectation de tuple:
>>>
>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')
>>># Magic time!
>>> a, b = b, a
>>> a, b
('bar', 'foo')Comme le sait quiconque a déjà dû échanger des valeurs à l'aide d'une variable temporaire, le fait de pouvoir le faire de cette façon en Python est le summum de la réussite technologique moderne. Ce ne sera jamais mieux que ça.
Conclusion
Ce didacticiel a couvert les propriétés de base de Pythonlists ettuples, et comment les manipuler. Vous les utiliserez largement dans votre programmation Python.
L'une des principales caractéristiques d'une liste est qu'elle est ordonnée. L'ordre des éléments dans une liste est une propriété intrinsèque de cette liste et ne change pas, sauf si la liste elle-même est modifiée. (Il en va de même pour les tuples, sauf qu'ils ne peuvent bien sûr pas être modifiés.)
Le prochain didacticiel vous présentera lesdictionary: Python, un type de données composite non ordonné. Continuer à lire!
__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Listes et tuples Python». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps: