J'ai besoin d'une bonne explication (les références sont un plus) sur la notation de tranche de Python.
Pour moi, cette notation nécessite un peu de ramassage.
Il a l'air extrêmement puissant, mais je n'y ai pas vraiment pensé.
27 réponses
Vous pouvez également utiliser l'affectation de tranche pour supprimer un ou plusieurs éléments d'une liste:
r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
Les réponses précédentes ne traitent pas du découpage multidimensionnel de tableaux qui est possible en utilisant le célèbre package NumPy :
Le découpage peut également être appliqué à des tableaux multidimensionnels.
# Here, a is a NumPy array
>>> a
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> a[:2, 0:3:2]
array([[1, 3],
[5, 7]])
Le ":2
" avant la virgule opère sur la première dimension et le "0:3:2
" après la virgule opère sur la deuxième dimension.
Le tutoriel Python en parle (faites défiler un peu jusqu'à ce que vous arriviez à la partie sur le tranchage).
Le diagramme d'art ASCII est également utile pour se souvenir du fonctionnement des tranches:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Une façon de se souvenir du fonctionnement des tranches consiste à considérer les index comme pointant entre caractères, avec le bord gauche du premier caractère numéroté 0. Puis le bord droit du dernier caractère d'une chaîne de n caractères ont l'index n .
Si vous pensez que les indices négatifs dans le découpage prêtent à confusion, voici une façon très simple de penser à cela: remplacez simplement l'indice négatif par len - index
. Par exemple, remplacez -3 par len(list) - 3
.
La meilleure façon d'illustrer ce que le découpage fait en interne est simplement de le montrer dans du code qui implémente cette opération:
def slice(list, start = None, end = None, step = 1):
# Take care of missing start/end parameters
start = 0 if start is None else start
end = len(list) if end is None else end
# Take care of negative start/end parameters
start = len(list) + start if start < 0 else start
end = len(list) + end if end < 0 else end
# Now just execute a for-loop with start, end and step
return [list[i] for i in range(start, end, step)]
La technique de découpage de base consiste à définir le point de départ, le point d'arrêt et la taille du pas - également connu sous le nom de foulée.
Tout d'abord, nous allons créer une liste de valeurs à utiliser dans notre découpage.
Créez deux listes à découper. Le premier est une liste numérique de 1 à 9 (liste A). Le second est également une liste numérique, de 0 à 9 (liste B):
A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))
print("This is List A:", A)
print("This is List B:", B)
Indexez le numéro 3 de A et le numéro 6 de B.
print(A[2])
print(B[6])
Tranchage de base
La syntaxe d'indexation étendue utilisée pour le découpage est aList [start: stop: step]. L'argument start et l'argument step sont tous les deux par défaut sur none - le seul argument requis est stop. Avez-vous remarqué que cela est similaire à la façon dont la plage a été utilisée pour définir les listes A et B? En effet, l'objet tranche représente l'ensemble des indices spécifiés par plage (démarrage, arrêt, étape). Documentation Python 3.4.
Comme vous pouvez le voir, définir uniquement stop renvoie un élément. Comme le début par défaut est none, cela se traduit par la récupération d'un seul élément.
Il est important de noter que le premier élément est l'index 0, pas l'index 1. C'est pourquoi nous utilisons 2 listes pour cet exercice. Les éléments de la liste A sont numérotés en fonction de la position ordinale (le premier élément est 1, le deuxième élément est 2, etc.) tandis que les éléments de la liste B sont les nombres qui seraient utilisés pour les indexer ([0] pour le premier élément 0, etc.).
Avec la syntaxe d'indexation étendue, nous récupérons une plage de valeurs. Par exemple, toutes les valeurs sont récupérées avec deux points.
A[:]
Pour récupérer un sous-ensemble d'éléments, les positions de départ et d'arrêt doivent être définies.
Étant donné le modèle aList [start: stop], récupérez les deux premiers éléments de la liste A.
Ce qui suit est l'exemple d'un index d'une chaîne:
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
str="Name string"
Exemple de découpage: [début: fin: étape]
str[start:end] # Items start through end-1
str[start:] # Items start through the rest of the array
str[:end] # Items from the beginning through end-1
str[:] # A copy of the whole array
Voici l'exemple d'utilisation:
print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm ti
En règle générale, l'écriture de code avec de nombreuses valeurs d'index codées en dur conduit à un problème de lisibilité et de maintenance. Par exemple, si vous revenez au code un an plus tard, vous le regarderez et vous vous demanderez ce que vous pensiez quand vous l'avez écrit. La solution présentée est simplement un moyen d'indiquer plus clairement ce que fait réellement votre code. En général, la tranche intégrée () crée un objet tranche qui peut être utilisé partout où une tranche est autorisée. Par exemple:
>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]
Si vous avez une instance de tranche s, vous pouvez obtenir plus d'informations à son sujet en consultant respectivement ses attributs s.start, s.stop et s.step. Par exemple:
>>> a = slice(10, 50, 2) >>> a.start 10 >>> a.stop 50 >>> a.step 2 >>>
Ceci est juste pour quelques informations supplémentaires ... Considérez la liste ci-dessous
>>> l=[12,23,345,456,67,7,945,467]
Quelques autres astuces pour inverser la liste:
>>> l[len(l):-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[len(l)::-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[-1:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
C'est assez simple vraiment:
a[start:stop] # items start through stop-1
a[start:] # items start through the rest of the array
a[:stop] # items from the beginning through stop-1
a[:] # a copy of the whole array
Il existe également la valeur step
, qui peut être utilisée avec l'une des options ci-dessus:
a[start:stop:step] # start through not past stop, by step
Le point clé à retenir est que la valeur :stop
représente la première valeur qui n'est pas dans la tranche sélectionnée. Ainsi, la différence entre stop
et start
est le nombre d'éléments sélectionnés (si step
est 1, la valeur par défaut).
L'autre caractéristique est que start
ou stop
peut être un nombre négatif , ce qui signifie qu'il compte à partir de la fin du tableau au lieu du début. Alors:
a[-1] # last item in the array
a[-2:] # last two items in the array
a[:-2] # everything except the last two items
De même, step
peut être un nombre négatif:
a[::-1] # all items in the array, reversed
a[1::-1] # the first two items, reversed
a[:-3:-1] # the last two items, reversed
a[-3::-1] # everything except the last two items, reversed
Python est gentil avec le programmeur s'il y a moins d'éléments que vous n'en demandez. Par exemple, si vous demandez a[:-2]
et a
ne contient qu'un seul élément, vous obtenez une liste vide au lieu d'une erreur. Parfois, vous préférez l'erreur, vous devez donc être conscient que cela peut se produire.
Relation avec l'objet slice()
L'opérateur de découpage []
est actuellement utilisé dans le code ci-dessus avec un objet slice()
utilisant la notation :
(qui n'est valide que dans []
), à savoir:
a[start:stop:step]
Est équivalent à:
a[slice(start, stop, step)]
Les objets Slice se comportent également légèrement différemment selon le nombre d'arguments, de la même manière que range()
, c'est-à-dire que slice(stop)
et slice(start, stop[, step])
sont pris en charge. Pour ignorer la spécification d'un argument donné, on peut utiliser None
, de sorte que par ex. a[start:]
est équivalent à a[slice(start, None)]
ou a[::-1]
est équivalent à a[slice(None, None, -1)]
.
Alors que la notation basée sur :
est très utile pour le découpage simple, l'utilisation explicite des objets slice()
simplifie la génération programmatique du découpage.
Personnellement, j'y pense comme une boucle for
:
a[start:end:step]
# for(i = start; i < end; i += step)
Notez également que les valeurs négatives pour start
et end
sont relatives à la fin de la liste.
Et quelques choses qui n'étaient pas immédiatement évidentes pour moi lorsque j'ai vu la syntaxe de découpage pour la première fois:
>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]
Un moyen facile d'inverser des séquences!
Et si vous vouliez, pour une raison quelconque, un élément sur deux dans l'ordre inverse:
>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]
J'ai trouvé cette excellente table sur http://wiki.python.org/moin/MovingToPythonFromOtherLanguages
Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.
Index from rear: -6 -5 -4 -3 -2 -1 a=[0,1,2,3,4,5] a[1:]==[1,2,3,4,5]
Index from front: 0 1 2 3 4 5 len(a)==6 a[:5]==[0,1,2,3,4]
+---+---+---+---+---+---+ a[0]==0 a[:-2]==[0,1,2,3]
| a | b | c | d | e | f | a[5]==5 a[1:2]==[1]
+---+---+---+---+---+---+ a[-1]==5 a[1:-1]==[1,2,3,4]
Slice from front: : 1 2 3 4 5 : a[-2]==4
Slice from rear: : -5 -4 -3 -2 -1 :
b=a[:]
b==[0,1,2,3,4,5] (shallow copy of a)
Index:
------------>
0 1 2 3 4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
0 -4 -3 -2 -1
<------------
Slice:
<---------------|
|--------------->
: 1 2 3 4 :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
: -4 -3 -2 -1 :
|--------------->
<---------------|
J'espère que cela vous aidera à modéliser la liste en Python.
Référence: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages
Après l'avoir un peu utilisé, je me rends compte que la description la plus simple est qu'elle est exactement la même que les arguments d'une boucle for
...
(from:to:step)
Chacun d'eux est facultatif:
(:to:step)
(from::step)
(from:to)
Ensuite, l'indexation négative a juste besoin de vous pour ajouter la longueur de la chaîne aux indices négatifs pour la comprendre.
Cela fonctionne pour moi de toute façon ...
Les réponses ci-dessus ne traitent pas de l'affectation des tranches. Pour comprendre l'attribution des tranches, il est utile d'ajouter un autre concept à l'art ASCII:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
Slice position: 0 1 2 3 4 5 6
Index position: 0 1 2 3 4 5
>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
'P'
>>> p[5]
'n'
# Slicing gives lists
>>> p[0:1]
['P']
>>> p[0:2]
['P','y']
Une heuristique est, pour une tranche de zéro à n, de penser: "zéro est le début, commencez au début et prenez n éléments dans une liste".
>>> p[5] # the last of six items, indexed from zero
'n'
>>> p[0:5] # does NOT include the last item!
['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
['P','y','t','h','o','n']
Une autre heuristique est, "pour n'importe quelle tranche, remplacez le début par zéro, appliquez l'heuristique précédente pour obtenir la fin de la liste, puis comptez le premier nombre pour remonter les éléments du début"
>>> p[0:4] # Start at the beginning and count out 4 items
['P','y','t','h']
>>> p[1:4] # Take one item off the front
['y','t','h']
>>> p[2:4] # Take two items off the front
['t','h']
# etc.
La première règle d'attribution de tranche est que, puisque le découpage renvoie une liste, l'affectation de tranche nécessite une liste (ou autre itérable):
>>> p[2:3]
['t']
>>> p[2:3] = ['T']
>>> p
['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
La deuxième règle d'affectation de tranche, que vous pouvez également voir ci-dessus, est que quelle que soit la partie de la liste renvoyée par l'indexation de tranche, c'est la même partie qui est modifiée par l'affectation de tranche:
>>> p[2:4]
['T','h']
>>> p[2:4] = ['t','r']
>>> p
['P','y','t','r','o','n']
La troisième règle d'affectation des tranches est que la liste assignée (itérable) n'a pas à avoir la même longueur; la tranche indexée est simplement découpée et remplacée en masse par ce qui est attribué:
>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
['P','y','s','p','a','m','o','n']
La partie la plus délicate à laquelle s'habituer est l'affectation à des tranches vides. En utilisant l'heuristique 1 et 2, il est facile de se familiariser avec l'indexation d'une tranche vide:
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
Et puis, une fois que vous avez vu cela, l'affectation de tranche à la tranche vide est également logique:
>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
['P','y','t','h','x','y','o','n'] # The result is longer still
Notez que, comme nous ne modifions pas le deuxième numéro de la tranche (4), les éléments insérés s'empilent toujours juste contre le «o», même lorsque nous les affectons à la tranche vide. Ainsi, la position pour l'affectation de tranche vide est l'extension logique des positions pour les affectations de tranche non vide.
Sauvegarde un peu, que se passe-t-il lorsque vous continuez avec notre procession de comptage de la tranche commençant?
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
Avec le tranchage, une fois que vous avez terminé, vous avez terminé; il ne commence pas à trancher en arrière. En Python, vous n'obtenez pas de pas négatifs à moins que vous ne les demandiez explicitement en utilisant un nombre négatif.
>>> p[5:3:-1]
['n','o']
Il y a des conséquences étranges à la règle "une fois que vous avez terminé, vous avez terminé":
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
>>> p[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
En fait, par rapport à l'indexation, le découpage Python est étrangement à l'abri des erreurs:
>>> p[100:200]
[]
>>> p[int(2e99):int(1e99)]
[]
Cela peut parfois être utile, mais cela peut également conduire à un comportement quelque peu étrange:
>>> p
['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']
Selon votre application, cela pourrait ... ou non ... être ce que vous espériez!
Voici le texte de ma réponse originale. Il a été utile à beaucoup de gens, donc je ne voulais pas le supprimer.
>>> r=[1,2,3,4]
>>> r[1:1]
[]
>>> r[1:1]=[9,8]
>>> r
[1, 9, 8, 2, 3, 4]
>>> r[1:1]=['blah']
>>> r
[1, 'blah', 9, 8, 2, 3, 4]
Cela peut également clarifier la différence entre le découpage et l'indexation.
En Python 2.7
Découpage en Python
[a:b:c]
len = length of string, tuple or list
c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.
a -- When c is positive or blank, default is 0. When c is negative, default is -1.
b -- When c is positive or blank, default is len. When c is negative, default is -(len+1).
Comprendre l'attribution d'index est très important.
In forward direction, starts at 0 and ends at len-1
In backward direction, starts at -1 and ends at -len
Lorsque vous dites [a: b: c], vous dites en fonction du signe de c (en avant ou en arrière), commencez en a et terminez en b (à l'exclusion de l'élément à l'indice bth). Utilisez la règle d'indexation ci-dessus et n'oubliez pas que vous ne trouverez que des éléments dans cette plage:
-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1
Mais cette plage continue indéfiniment dans les deux sens:
...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....
Par exemple:
0 1 2 3 4 5 6 7 8 9 10 11
a s t r i n g
-9 -8 -7 -6 -5 -4 -3 -2 -1
Si votre choix de a, b et c permet de chevaucher la plage ci-dessus pendant que vous parcourez en utilisant les règles pour a, b, c ci-dessus, vous obtiendrez soit une liste d'éléments (touchés pendant la traversée), soit une liste vide.
Une dernière chose: si a et b sont égaux, alors vous obtenez également une liste vide:
>>> l1
[2, 3, 4]
>>> l1[:]
[2, 3, 4]
>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]
>>> l1[:-4:-1] # a default is -1
[4, 3, 2]
>>> l1[:-3:-1] # a default is -1
[4, 3]
>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]
>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]
>>> l1[-100:-200:-1] # Interesting
[]
>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]
>>> l1[-1:-1:1]
[]
>>> l1[-1:5:1] # Interesting
[4]
>>> l1[1:-7:1]
[]
>>> l1[1:-7:-1] # Interesting
[3, 2]
>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]
La plupart des réponses précédentes clarifient les questions sur la notation des tranches.
La syntaxe d'indexation étendue utilisée pour le découpage est aList[start:stop:step]
, et les exemples de base sont:
Autres exemples de découpage: 15 tranches étendues
Mon cerveau semble heureux d'accepter que lst[start:end]
contienne le start
- e élément. Je pourrais même dire que c'est une «hypothèse naturelle».
Mais parfois, un doute se glisse et mon cerveau demande à être rassuré qu'il ne contient pas le end
- e élément.
Dans ces moments, je m'appuie sur ce théorème simple:
for any n, lst = lst[:n] + lst[n:]
Cette jolie propriété me dit que lst[start:end]
ne contient pas le end
- ème élément car il est dans lst[end:]
.
Notez que ce théorème est vrai pour tout n
. Par exemple, vous pouvez vérifier que
lst = range(10)
lst[:-42] + lst[-42:] == lst
Renvoie True
.
À mon avis, vous comprendrez et mémoriserez mieux la notation de découpage de chaîne Python si vous la regardez de la manière suivante (lire la suite).
Travaillons avec la chaîne suivante ...
azString = "abcdefghijklmnopqrstuvwxyz"
Pour ceux qui ne le savent pas, vous pouvez créer n'importe quelle sous-chaîne à partir de azString
en utilisant la notation azString[x:y]
Venant d'autres langages de programmation, c'est là que le bon sens est compromis. Que sont x et y?
J'ai dû m'asseoir et exécuter plusieurs scénarios dans ma quête d'une technique de mémorisation qui m'aidera à me rappeler ce que sont x et y et m'aidera à trancher correctement les cordes lors de la première tentative.
Ma conclusion est que x et y doivent être considérés comme les indices limites qui entourent les chaînes que nous voulons extraire. Nous devrions donc voir l'expression comme azString[index1, index2]
ou encore plus clairement comme azString[index_of_first_character, index_after_the_last_character]
.
Voici un exemple de visualisation de cela ...
Letters a b c d e f g h i j ...
^ ^ ^ ^ ^ ^ ^ ^ ^ ^
Indexes 0 1 2 3 4 5 6 7 8 9 ...
| |
cdefgh index1 index2
Il vous suffit donc de définir index1 et index2 sur les valeurs qui entoureront la sous-chaîne souhaitée. Par exemple, pour obtenir la sous-chaîne "cdefgh", vous pouvez utiliser azString[2:8]
, car l'index sur le côté gauche de "c" est 2 et celui sur la bonne taille de "h" est 8.
N'oubliez pas que nous fixons les limites. Et ces limites sont les positions où vous pouvez placer des crochets qui seront enroulés autour de la sous-chaîne comme ceci ...
A b [ c d e f g h ] i j
Cette astuce fonctionne tout le temps et est facile à mémoriser.
Je ne pense pas que le tutoriel Python (cité dans divers autres réponses) est bonne car cette suggestion fonctionne pour une foulée positive, mais pas pour une foulée négative.
Voici le schéma:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
D'après le diagramme, je m'attends à ce que a[-4,-6,-1]
soit yP
mais c'est ty
.
>>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'
Ce qui fonctionne toujours, c'est de penser en caractères ou en emplacements et d'utiliser l'indexation comme un intervalle semi-ouvert - ouvert à droite si foulée positive, ouvert à gauche si foulée négative.
De cette façon, je peux penser à a[-4:-6:-1]
comme a(-6,-4]
dans la terminologie d'intervalle.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
+---+---+---+---+---+---+---+---+---+---+---+---+
| P | y | t | h | o | n | P | y | t | h | o | n |
+---+---+---+---+---+---+---+---+---+---+---+---+
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5
Enumérant les possibilités permises par la grammaire:
>>> seq[:] # [seq[0], seq[1], ..., seq[-1] ]
>>> seq[low:] # [seq[low], seq[low+1], ..., seq[-1] ]
>>> seq[:high] # [seq[0], seq[1], ..., seq[high-1]]
>>> seq[low:high] # [seq[low], seq[low+1], ..., seq[high-1]]
>>> seq[::stride] # [seq[0], seq[stride], ..., seq[-1] ]
>>> seq[low::stride] # [seq[low], seq[low+stride], ..., seq[-1] ]
>>> seq[:high:stride] # [seq[0], seq[stride], ..., seq[high-1]]
>>> seq[low:high:stride] # [seq[low], seq[low+stride], ..., seq[high-1]]
Bien sûr, si (high-low)%stride != 0
, le point final sera un peu inférieur à high-1
.
Si stride
est négatif, l'ordre est légèrement modifié depuis le décompte:
>>> seq[::-stride] # [seq[-1], seq[-1-stride], ..., seq[0] ]
>>> seq[high::-stride] # [seq[high], seq[high-stride], ..., seq[0] ]
>>> seq[:low:-stride] # [seq[-1], seq[-1-stride], ..., seq[low+1]]
>>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]
Le découpage étendu (avec des virgules et des ellipses) n'est principalement utilisé que par des structures de données spéciales (comme NumPy); les séquences de base ne les prennent pas en charge.
>>> class slicee:
... def __getitem__(self, item):
... return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
J'utilise la méthode «un index entre les éléments» pour y penser moi-même, mais une façon de le décrire qui aide parfois les autres à l'obtenir est la suivante:
mylist[X:Y]
X est l'indice du premier élément souhaité.
Y est l'index du premier élément que vous ne voulez pas .
#!/usr/bin/env python
def slicegraphical(s, lista):
if len(s) > 9:
print """Enter a string of maximum 9 characters,
so the printig would looki nice"""
return 0;
# print " ",
print ' '+'+---' * len(s) +'+'
print ' ',
for letter in s:
print '| {}'.format(letter),
print '|'
print " ",; print '+---' * len(s) +'+'
print " ",
for letter in range(len(s) +1):
print '{} '.format(letter),
print ""
for letter in range(-1*(len(s)), 0):
print ' {}'.format(letter),
print ''
print ''
for triada in lista:
if len(triada) == 3:
if triada[0]==None and triada[1] == None and triada[2] == None:
# 000
print s+'[ : : ]' +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] == None and triada[2] != None:
# 001
print s+'[ : :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] != None and triada[2] == None:
# 010
print s+'[ :{0:2d} : ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] != None and triada[2] != None:
# 011
print s+'[ :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] == None and triada[2] == None:
# 100
print s+'[{0:2d} : : ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] == None and triada[2] != None:
# 101
print s+'[{0:2d} : :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] != None and triada[2] == None:
# 110
print s+'[{0:2d} :{1:2d} : ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] != None and triada[2] != None:
# 111
print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif len(triada) == 2:
if triada[0] == None and triada[1] == None:
# 00
print s+'[ : ] ' + ' = ', s[triada[0]:triada[1]]
elif triada[0] == None and triada[1] != None:
# 01
print s+'[ :{0:2d} ] '.format(triada[1]) + ' = ', s[triada[0]:triada[1]]
elif triada[0] != None and triada[1] == None:
# 10
print s+'[{0:2d} : ] '.format(triada[0]) + ' = ', s[triada[0]:triada[1]]
elif triada[0] != None and triada[1] != None:
# 11
print s+'[{0:2d} :{1:2d} ] '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]]
elif len(triada) == 1:
print s+'[{0:2d} ] '.format(triada[0]) + ' = ', s[triada[0]]
if __name__ == '__main__':
# Change "s" to what ever string you like, make it 9 characters for
# better representation.
s = 'COMPUTERS'
# add to this list different lists to experement with indexes
# to represent ex. s[::], use s[None, None,None], otherwise you get an error
# for s[2:] use s[2:None]
lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]]
slicegraphical(s, lista)
Vous pouvez exécuter ce script et l'expérimenter, voici quelques exemples que j'ai obtenus du script.
+---+---+---+---+---+---+---+---+---+
| C | O | M | P | U | T | E | R | S |
+---+---+---+---+---+---+---+---+---+
0 1 2 3 4 5 6 7 8 9
-9 -8 -7 -6 -5 -4 -3 -2 -1
COMPUTERS[ 4 : 7 ] = UTE
COMPUTERS[ 2 : 5 : 2 ] = MU
COMPUTERS[-5 : 1 :-1 ] = UPM
COMPUTERS[ 4 ] = U
COMPUTERS[-4 :-6 :-1 ] = TU
COMPUTERS[ 2 :-3 : 1 ] = MPUT
COMPUTERS[ 2 :-3 :-1 ] =
COMPUTERS[ : :-1 ] = SRETUPMOC
COMPUTERS[-5 : ] = UTERS
COMPUTERS[-5 : 0 :-1 ] = UPMO
COMPUTERS[-5 : :-1 ] = UPMOC
COMPUTERS[-1 : 1 :-2 ] = SEUM
[Finished in 0.9s]
Lorsque vous utilisez une étape négative, notez que la réponse est décalée vers la droite de 1.
Expliquer la notation de tranche de Python
En bref, les deux-points (:
) en notation indice (subscriptable[subscriptarg]
) font une notation par tranche - qui a les arguments facultatifs, start
, stop
, step
:
sliceable[start:stop:step]
Le découpage Python est un moyen rapide sur le plan informatique d'accéder méthodiquement à des parties de vos données. À mon avis, pour être même un programmeur Python intermédiaire, c'est un aspect du langage qu'il est nécessaire de connaître.
Définitions importantes
Pour commencer, définissons quelques termes:
start: l'index de début de la tranche, il inclura l'élément à cet index à moins qu'il ne soit le même que stop , par défaut à 0, c'est-à-dire le premier index. S'il est négatif, cela signifie commencer les
n
éléments depuis la fin.stop: l'index de fin de la tranche, il ne comprend pas l'élément à cet index, par défaut la longueur de la séquence découpée, c'est-à-dire jusqu'à et y compris le fin.
étape: le montant de l'augmentation de l'indice, par défaut à 1. S'il est négatif, vous coupez l'itérable à l'envers.
Fonctionnement de l'indexation
Vous pouvez faire n'importe lequel de ces nombres positifs ou négatifs. La signification des nombres positifs est simple, mais pour les nombres négatifs, tout comme les index en Python, vous comptez en arrière à partir de la fin pour le début et arrêt , et pour le < em> step , vous décrémentez simplement votre index. Cet exemple est du didacticiel de la documentation, mais je l'ai légèrement modifié pour indiquer à quel élément d'une séquence chaque index fait référence:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
Comment fonctionne le tranchage
Pour utiliser la notation de tranche avec une séquence qui la prend en charge, vous devez inclure au moins un deux-points dans les crochets qui suivent la séquence (qui en fait implémente la méthode __getitem__
de la séquence, selon le modèle de données Python.)
La notation de tranche fonctionne comme ceci:
sequence[start:stop:step]
Et rappelez-vous qu'il existe des valeurs par défaut pour start , stop et step , donc pour accéder aux valeurs par défaut, laissez simplement de côté l'argument.
La notation de tranche pour obtenir les neuf derniers éléments d'une liste (ou toute autre séquence qui la prend en charge, comme une chaîne) ressemblerait à ceci:
my_list[-9:]
Quand je vois cela, j'ai lu la partie entre parenthèses comme "9ème de la fin à la fin". (En fait, je l'abrège mentalement en "-9, on")
Explication:
La notation complète est
my_list[-9:None:None]
Et pour remplacer les valeurs par défaut (en fait, lorsque step
est négatif, la valeur par défaut de stop
est -len(my_list) - 1
, donc None
pour arrêter signifie simplement qu'il va à la fin de l'étape à):
my_list[-9:len(my_list):1]
Le deux-points , :
, est ce qui indique à Python que vous lui donnez une tranche et non un index régulier. C'est pourquoi la façon idiomatique de faire une copie superficielle des listes en Python 2 est
list_copy = sequence[:]
Et les effacer c'est avec:
del my_list[:]
(Python 3 obtient une méthode list.copy
et list.clear
.)
Lorsque step
est négatif, les valeurs par défaut pour start
et stop
changent
Par défaut, lorsque l'argument step
est vide (ou None
), il est affecté à +1
.
Mais vous pouvez passer un entier négatif et la liste (ou la plupart des autres tranches standard) sera découpée de la fin au début.
Ainsi, une tranche négative changera les valeurs par défaut pour start
et stop
!
Confirmer cela dans la source
J'aime encourager les utilisateurs à lire la source ainsi que la documentation. Le code source pour les objets slice et cette logique se trouve ici. On détermine d'abord si step
est négatif:
step_is_negative = step_sign < 0;
Si tel est le cas, la limite inférieure est -1
, ce qui signifie que nous tranchons jusqu'au début et y compris, et la limite supérieure est la longueur moins 1, ce qui signifie que nous commençons à la fin. (Notez que la sémantique de ce -1
est différente d'un -1
que les utilisateurs peuvent passer des index en Python indiquant le dernier élément.)
if (step_is_negative) { lower = PyLong_FromLong(-1L); if (lower == NULL) goto error; upper = PyNumber_Add(length, lower); if (upper == NULL) goto error; }
Sinon, step
est positif, et la limite inférieure sera nulle et la limite supérieure (jusqu'à laquelle nous montons mais n'inclut pas) la longueur de la liste découpée.
else { lower = _PyLong_Zero; Py_INCREF(lower); upper = length; Py_INCREF(upper); }
Ensuite, nous devrons peut-être appliquer les valeurs par défaut pour start
et stop
- la valeur par défaut alors pour start
est calculée comme la limite supérieure lorsque step
est négatif:
if (self->start == Py_None) { start = step_is_negative ? upper : lower; Py_INCREF(start); }
Et stop
, la borne inférieure:
if (self->stop == Py_None) { stop = step_is_negative ? lower : upper; Py_INCREF(stop); }
Donnez à vos tranches un nom descriptif!
Il peut être utile de séparer la formation de la tranche de sa transmission à la méthode list.__getitem__
(c'est ce que font les crochets). Même si vous n'êtes pas nouveau, cela permet à votre code d'être plus lisible afin que les autres personnes susceptibles de lire votre code puissent plus facilement comprendre ce que vous faites.
Cependant, vous ne pouvez pas simplement affecter des entiers séparés par des deux-points à une variable. Vous devez utiliser l'objet tranche:
last_nine_slice = slice(-9, None)
Le deuxième argument, None
, est requis, afin que le premier argument soit interprété comme l'argument start
sinon ce serait l'argument stop
.
Vous pouvez ensuite passer l'objet tranche à votre séquence:
>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]
Il est intéressant de noter que les plages prennent également des tranches:
>>> range(100)[last_nine_slice]
range(91, 100)
Considérations sur la mémoire:
Étant donné que des tranches de listes Python créent de nouveaux objets en mémoire, une autre fonction importante à connaître est itertools.islice
. En règle générale, vous souhaiterez parcourir une tranche, pas seulement la créer statiquement en mémoire. islice
est parfait pour cela. Une mise en garde, il ne prend pas en charge les arguments négatifs à start
, stop
ou step
, donc si c'est un problème, vous devrez peut-être calculer des indices ou inverser l'itérable à l'avance.
length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)
Et maintenant:
>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]
Le fait que les tranches de liste effectuent une copie est une caractéristique des listes elles-mêmes. Si vous découpez des objets avancés comme un Pandas DataFrame, il peut retourner une vue sur l'original, et non une copie.
Voici comment j'enseigne les tranches aux débutants:
Comprendre la différence entre l'indexation et le découpage:
Wiki Python a cette image étonnante qui distingue clairement l'indexation et le découpage.
Il s'agit d'une liste contenant six éléments. Pour mieux comprendre le découpage, considérez cette liste comme un ensemble de six boîtes placées ensemble. Chaque boîte contient un alphabet.
L'indexation est comme traiter le contenu de la boîte. Vous pouvez vérifier le contenu de n'importe quelle boîte. Mais vous ne pouvez pas vérifier le contenu de plusieurs boîtes à la fois. Vous pouvez même remplacer le contenu de la boîte. Mais vous ne pouvez pas placer deux balles dans une boîte ou remplacer deux balles à la fois.
In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']
In [124]: alpha[0]
Out[124]: 'a'
In [127]: alpha[0] = 'A'
In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']
In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]
TypeError: list indices must be integers, not tuple
Le découpage, c'est comme gérer les boîtes elles-mêmes. Vous pouvez ramasser la première boîte et la placer sur une autre table. Pour récupérer la boîte, il vous suffit de connaître la position de début et de fin de la boîte.
Vous pouvez même ramasser les trois premières cases ou les deux dernières cases ou toutes les cases entre 1 et 4. Ainsi, vous pouvez choisir n'importe quel ensemble de cases si vous connaissez le début et la fin. Ces positions sont appelées positions de départ et d'arrêt.
La chose intéressante est que vous pouvez remplacer plusieurs boîtes à la fois. Vous pouvez également placer plusieurs boîtes où vous le souhaitez.
In [130]: alpha[0:1]
Out[130]: ['A']
In [131]: alpha[0:1] = 'a'
In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']
In [133]: alpha[0:2] = ['A', 'B']
In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']
In [135]: alpha[2:2] = ['x', 'xx']
In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']
Découpe avec étape:
Jusqu'à présent, vous avez sélectionné des boîtes en continu. Mais parfois, vous devez décrocher discrètement. Par exemple, vous pouvez récupérer une boîte sur deux. Vous pouvez même ramasser une boîte sur trois à la fin. Cette valeur est appelée taille de pas. Cela représente l'écart entre vos micros successifs. La taille du pas doit être positive si vous choisissez des cases du début à la fin et vice versa.
In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [142]: alpha[1:5:2]
Out[142]: ['b', 'd']
In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']
In [144]: alpha[1:5:-2]
Out[144]: []
In [145]: alpha[-1:-5:2]
Out[145]: []
Comment Python résout les paramètres manquants:
Lors du découpage, si vous omettez un paramètre, Python essaie de le comprendre automatiquement.
Si vous vérifiez le code source de CPython, vous trouverez une fonction appelée PySlice_GetIndicesEx () qui représente des indices sur une tranche pour tout paramètre donné. Voici le code équivalent logique en Python.
Cette fonction prend un objet Python et des paramètres facultatifs pour le découpage et renvoie le début, l'arrêt, l'étape et la longueur de découpage pour le découpage demandé.
def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):
length = len(obj)
if step is None:
step = 1
if step == 0:
raise Exception("Step cannot be zero.")
if start is None:
start = 0 if step > 0 else length - 1
else:
if start < 0:
start += length
if start < 0:
start = 0 if step > 0 else -1
if start >= length:
start = length if step > 0 else length - 1
if stop is None:
stop = length if step > 0 else -1
else:
if stop < 0:
stop += length
if stop < 0:
stop = 0 if step > 0 else -1
if stop >= length:
stop = length if step > 0 else length - 1
if (step < 0 and stop >= start) or (step > 0 and start >= stop):
slice_length = 0
elif step < 0:
slice_length = (stop - start + 1)/(step) + 1
else:
slice_length = (stop - start - 1)/(step) + 1
return (start, stop, step, slice_length)
C'est l'intelligence qui est présente derrière les tranches. Étant donné que Python a une fonction intégrée appelée tranche, vous pouvez passer certains paramètres et vérifier à quel point il calcule intelligemment les paramètres manquants.
In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [22]: s = slice(None, None, None)
In [23]: s
Out[23]: slice(None, None, None)
In [24]: s.indices(len(alpha))
Out[24]: (0, 6, 1)
In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]
In [26]: s = slice(None, None, -1)
In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]
In [28]: s = slice(None, 3, -1)
In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]
Remarque: ce message a été initialement écrit dans mon blog, L'intelligence derrière les tranches Python .
Je veux ajouter un exemple Hello, World! qui explique les bases des tranches pour les tout débutants. Cela m'a beaucoup aidé.
Ayons une liste avec six valeurs ['P', 'Y', 'T', 'H', 'O', 'N']
:
+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
0 1 2 3 4 5
Maintenant, les tranches les plus simples de cette liste sont ses sous-listes. La notation est [<index>:<index>]
et la clé est de la lire comme ceci:
[ start cutting before this index : end cutting before this index ]
Maintenant, si vous créez une tranche [2:5]
de la liste ci-dessus, cela se produira:
| |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
0 1 | 2 3 4 | 5
Vous avez coupé avant l'élément avec l'index 2
et une autre coupe avant l'élément avec l'index 5
. Le résultat sera donc une tranche entre ces deux coupes, une liste ['T', 'H', 'O']
.
En Python, la forme la plus élémentaire de découpage est la suivante:
l[start:end]
Où l
est une collection, start
est un index inclusif et end
est un index exclusif.
In [1]: l = list(range(10))
In [2]: l[:5] # First five elements
Out[2]: [0, 1, 2, 3, 4]
In [3]: l[-5:] # Last five elements
Out[3]: [5, 6, 7, 8, 9]
Lors du découpage depuis le début, vous pouvez omettre l'index zéro et lors du découpage jusqu'à la fin, vous pouvez omettre l'index final car il est redondant, alors ne soyez pas verbeux:
In [5]: l[:3] == l[0:3]
Out[5]: True
In [6]: l[7:] == l[7:len(l)]
Out[6]: True
Les entiers négatifs sont utiles lors des décalages par rapport à la fin d'une collection:
In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]
In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]
Il est possible de fournir des indices hors limites lors du découpage tels que:
In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Gardez à l'esprit que le résultat du découpage d'une collection est une toute nouvelle collection. En outre, lorsque vous utilisez la notation de tranche dans les affectations, la longueur des affectations de tranche n'a pas besoin d'être la même. Les valeurs avant et après la tranche affectée seront conservées et la collection se réduira ou s'agrandira pour contenir les nouvelles valeurs:
In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]
In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]
In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]
In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]
Si vous omettez l'index de début et de fin, vous ferez une copie de la collection:
In [14]: l_copy = l[:]
In [15]: l == l_copy and l is not l_copy
Out[15]: True
Si les index de début et de fin sont omis lors de l'exécution d'une opération d'affectation, tout le contenu de la collection sera remplacé par une copie de ce qui est référencé:
In [20]: l[:] = list('hello...')
In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']
Outre le découpage de base, il est également possible d'appliquer la notation suivante:
l[start:end:step]
Où l
est une collection, start
est un index inclusif, end
est un index exclusif et step
est une foulée qui peut être utilisée pour prendre chaque nième élément dans l
.
In [22]: l = list(range(10))
In [23]: l[::2] # Take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]
In [24]: l[1::2] # Take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]
L'utilisation de step
fournit une astuce utile pour inverser une collection en Python:
In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Il est également possible d'utiliser des entiers négatifs pour step
comme exemple suivant:
In[28]: l[::-2]
Out[28]: [9, 7, 5, 3, 1]
Cependant, l'utilisation d'une valeur négative pour step
peut devenir très déroutante. De plus, pour être Pythonic, vous devez éviter d'utiliser start
, end
et step
en une seule tranche. Dans le cas où cela est nécessaire, envisagez de le faire en deux affectations (une pour découper et l'autre pour avancer).
In [29]: l = l[::2] # This step is for striding
In [30]: l
Out[30]: [0, 2, 4, 6, 8]
In [31]: l = l[1:-1] # This step is for slicing
In [32]: l
Out[32]: [2, 4, 6]