En Python, en utilisant une tranche (ex :[2:5:2]), you can extract a subsequence of a sequence object, such as a list, string, tuple, etc.
Cet article décrit le contenu suivant.
- Utilisation de la base des tranches
- [commencer à arrêter]
- [démarrer:arrêter:étape]
- Extrait de la fin avec une valeur négative
- Valeurs négatives pour le démarrage et l’arrêt
- Valeurs négatives pour l’étape
- Découper l’objet par tranche()
- Affectation de valeurs par tranches
- Tranches pour une liste de listes
- Les tranches font une copie superficielle
- Tranches pour les chaînes et les tuples
Utilisation de la base des tranches
[commencer à arrêter]
Dans une tranche, la position de départ start et la position finale stop de la sous-séquence sont écrites sous la forme [start:stop].
Le début de la plage <= x
l = [0, 10, 20, 30, 40, 50, 60]
print(l[2:5])
# [20, 30, 40]
Vous pouvez considérer les positions (indices) de la tranche comme pointant entre des éléments.
Une façon de se souvenir du fonctionnement des tranches est de considérer l’index comme pointant entre des caractères, avec le bord gauche du premier caractère numéroté 0.
3. An Informal Introduction to Python – Strings — Python 3.10.4 documentation
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Ce qui précède est un exemple pour les chaînes, mais il en va de même pour les listes, les tuples, etc. Le cas des valeurs négatives est décrit plus loin.
Si start est omis, la sous-séquence est extraite depuis le début, et si stop est omis, la sous-séquence est extraite jusqu’à la fin. Si les deux sont omis, tous les éléments sont extraits.
print(l[:3])
# [0, 10, 20]
print(l[3:])
# [30, 40, 50, 60]
print(l[:])
# [0, 10, 20, 30, 40, 50, 60]
Hors de portée
Aucune erreur n’est générée si vous spécifiez une position qui dépasse le nombre d’éléments.
print(l[2:10])
# [20, 30, 40, 50, 60]
Si aucun élément n’est sélectionné
Aucune erreur n’est renvoyée si vous spécifiez start et stop qui ne sélectionnent aucun élément. Une liste vide est renvoyée.
print(l[5:2])
# []
print(l[2:2])
# []
print(l[10:20])
# []
[démarrer:arrêter:étape]
En plus du début de la position de départ et de l’arrêt de la position de fin, vous pouvez le pas comme [début:arrêt:pas].
Par exemple, si l’étape est définie sur 2, les éléments aux positions impaires ou paires peuvent être sélectionnés.
print(l[::2])
# [0, 20, 40, 60]
print(l[1::2])
# [10, 30, 50]
Autres exemples :
print(l[::3])
# [0, 30, 60]
print(l[2:5:2])
# [20, 40]
Comme dans les exemples précédents, si l’étape est omise, elle est définie sur 1.
Valeurs négatives pour le démarrage et l’arrêt
Si start et stop sont spécifiés avec des valeurs négatives, ils sont représentés comme des positions à partir de la fin.
-1 indique le dernier élément.
Si stop=-1, l’élément à l’arrêt n’est pas inclus, donc la deuxième valeur à partir de la fin est sélectionnée.
print(l[3:-1])
# [30, 40, 50]
Le concept des positions (indices) pour la tranche est rappelé ci-dessous.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Autres exemples :
print(l[-2:])
# [50, 60]
print(l[-5:-2])
# [20, 30, 40]
Valeurs négatives pour l’étape
Si l’étape est indiquée comme une valeur négative, les éléments sont sélectionnés dans l’ordre inverse.
Les éléments sont sélectionnés à partir de la position de départ. Notez qu’à moins que start n’indique une position après l’arrêt, il sera vide.
print(l[5:2:-1])
# [50, 40, 30]
print(l[2:5:-1])
# []
Autres exemples :
print(l[-2:-5:-1])
# [50, 40, 30]
print(l[-2:2:-1])
# [50, 40, 30]
print(l[5:2:-2])
# [50, 30]
En omettant start et stop et en réglant le pas sur -1, vous pouvez obtenir un objet inversé.
print(l[::-1])
# [60, 50, 40, 30, 20, 10, 0]
Vous pouvez également utiliser reverse() et reversed() pour inverser des listes ou des chaînes, des tuples, etc. Voir l’article suivant pour plus de détails.
Découper l’objet par tranche()
Vous pouvez générer un objet slice à l’aide de la fonction intégrée slice(). Si vous souhaitez sélectionner plusieurs fois les éléments à la même position, vous n’avez besoin de générer l’objet tranche qu’une seule fois.
slice(start, stop, step) est équivalent à start:stop:step.
sl = slice(2, 5, 2)
print(sl)
# slice(2, 5, 2)
print(type(sl))
# <class 'slice'>
print(l[sl])
# [20, 40]
Si deux arguments sont spécifiés, l’étape est définie sur Aucun. C’est équivalent à start:stop.
sl = slice(2, 5)
print(sl)
# slice(2, 5, None)
print(l[sl])
# [20, 30, 40]
Si un seul argument est spécifié, start et step sont définis sur None. Cela équivaut à : stop.
sl = slice(2)
print(sl)
# slice(None, 2, None)
print(l[sl])
# [0, 10]
Si tous les arguments sont omis, une erreur TypeError est levée. Si vous voulez générer : avec slice(), spécifiez None.
# sl = slice()
# TypeError: slice expected at least 1 arguments, got 0
sl = slice(None)
print(sl)
# slice(None, None, None)
print(l[sl])
# [0, 10, 20, 30, 40, 50, 60]
Affectation de valeurs par tranches
Vous pouvez attribuer de nouvelles valeurs à la plage sélectionnées par tranches.
Peu importe si le nombre d’éléments dans la plage sélectionné par découpage ne correspond pas au nombre d’éléments (= la longueur de l’objet) à affecter.
print(l)
# [0, 10, 20, 30, 40, 50, 60]
l[2:5] = [200, 300, 400]
print(l)
# [0, 10, 200, 300, 400, 50, 60]
l[2:5] = [-2, -3]
print(l)
# [0, 10, -2, -3, 50, 60]
l[2:4] = [2000, 3000, 4000, 5000]
print(l)
# [0, 10, 2000, 3000, 4000, 5000, 50, 60]
l[2:6] = [20000]
print(l)
# [0, 10, 20000, 50, 60]
Notez que la spécification d’une valeur scalaire sur le côté droit entraînera TypeError.
# l[2:3] = 200
# TypeError: can only assign an iterable
Si le côté droit est vide, les éléments de la plage sélectionnés par la tranche seront supprimés.
l[1:4] = []
print(l)
# [0, 60]
Il est également possible de spécifier une plage hors plage ou vide pour l’affectation. La valeur sur le côté droit est insérée à la position désignée.
l[20:60] = [-1, -2, -3]
print(l)
# [0, 60, -1, -2, -3]
l[2:2] = [-100]
print(l)
# [0, 60, -100, -1, -2, -3]
Si le nombre d’éléments n’est pas égal pour la plage où l’étape est activée, une erreur ValueError est émise.
print(l[:5:2])
# [0, -100, -2]
l[:5:2] = [100, 200, 300]
print(l)
# [100, 60, 200, -1, 300, -3]
# l[:5:2] = [100, 200]
# ValueError: attempt to assign sequence of size 2 to extended slice of size 3
Pour ajouter un élément au milieu ou à la fin de la liste, des méthodes telles que insert() et append() sont fournies. Voir l’article suivant :
Tranches pour une liste de listes
Lors de l’application d’une tranche à une liste de listes (= liste 2D), les listes internes sont sélectionnées.
l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
print(l_2d[1:3])
# [[3, 4, 5], [6, 7, 8]]
Pour appliquer une tranche à des listes internes, utilisez les compréhensions de liste.
print([l[:2] for l in l_2d[1:3]])
# [[3, 4], [6, 7]]
Si vous voulez obtenir une colonne, vous pouvez la transposer.
l_2d_t = [list(x) for x in zip(*l_2d)]
print(l_2d_t)
# [[0, 3, 6, 9], [1, 4, 7, 10], [2, 5, 8, 11]]
print(l_2d_t[1])
# [1, 4, 7, 10]
Notez que si vous pouvez utiliser NumPy, il est plus facile d’utiliser NumPy pour manipuler des tableaux multidimensionnels.
Dans NumPy, vous pouvez spécifiquement une tranche pour chaque dimension comme [1:4, 2:5].
Les tranches font une copie superficielle
Tranche fait une copie superficielle. Pour plus d’informations sur la copie superficielle et profonde, consultez l’article suivant.
Par exemple, dans le cas d’une liste de nombres, affecter le résultat obtenu par découpage à une variable et mettre à jour les éléments de la variable ne modifiera pas l’objet d’origine.
l = [0, 10, 20, 30, 40, 50, 60]
l_slice = l[2:5]
print(l_slice)
# [20, 30, 40]
l_slice[1] = 300
print(l_slice)
# [20, 300, 40]
print(l)
# [0, 10, 20, 30, 40, 50, 60]
Dans le cas d’objets composés contenant des listes, des dictionnaires, etc. en tant qu’éléments, la mise à jour d’un élément modifie l’objet d’origine.
l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
l_2d_slice = l_2d[1:3]
print(l_2d_slice)
# [[3, 4, 5], [6, 7, 8]]
l_2d_slice[0][1] = 400
print(l_2d_slice)
# [[3, 400, 5], [6, 7, 8]]
print(l_2d)
# [[0, 1, 2], [3, 400, 5], [6, 7, 8], [9, 10, 11]]
Dans l’exemple ci-dessus, la liste de la tranche est mise à jour et la liste de l’objet d’origine est également modifiée. Si la liste de l’objet d’origine est mise à jour, la liste de la tranche est également modifiée.
Pour éviter cela, importez le module de copie de la bibliothèque standard et utilisez deepcopy().
import copy
l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
l_2d_slice_deepcopy = copy.deepcopy(l_2d[1:3])
print(l_2d_slice_deepcopy)
# [[3, 4, 5], [6, 7, 8]]
l_2d_slice_deepcopy[0][1] = 400
print(l_2d_slice_deepcopy)
# [[3, 400, 5], [6, 7, 8]]
print(l_2d)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
Tranches pour les chaînes et les tuples
Jusqu’à présent, nous avons montré des exemples de listes (type de liste), mais les tranches peuvent également être utilisées avec d’autres objets de séquence tels que les chaînes str et les tuples tuple.
Cependant, str et tuple sont immuables, de sorte que de nouvelles valeurs ne peuvent pas être attribuées.
s = 'abcdefg'
print(s[2:5])
# cde
print(s[::-1])
# gfedcba
# s[2:5] = 'CDE'
# TypeError: 'str' object does not support item assignment
t = (0, 10, 20, 30, 40, 50, 60)
print(t[2:5])
# (20, 30, 40)
# t[2:5] = (200, 300, 400)
# TypeError: 'tuple' object does not support item assignment
Consultez l’article suivant pour fractionner et remplacer des chaînes.