Comprendre la notation des tranches

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]

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

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]

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]

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]

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.

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

#!/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.

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