le tutoriel Python en parle (faites défiler un peu jusqu'à ce que vous arriviez à la partie sur le tranchage).

le diagramme de l'art ASCII est également utile pour se rappeler comment les tranches de travail:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

une façon de se rappeler comment fonctionnent les tranches est de penser que les indices pointent entre les caractères , avec le bord gauche du premier caractère numéroté 0. Puis le bord droit de la dernière caractère d'une chaîne de n caractères a l'index n .

énumé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 , alors le point final sera un peu plus bas que high-1 .

si stride est négatif, l'ordre est un peu modifié puisque nous sommes en train de compter:

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

découpage étendu (avec des virgules et des ellipses) sont principalement utilisés uniquement par des structures de données spéciales (comme Numpy); les séquences de base ne supportent pas ils.

>>> class slicee:
...     def __getitem__(self, item):
...         return `item`
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'

les réponses ci-dessus ne traitent pas de l'affectation slice. Pour comprendre l'attribution de tranche, 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']

un heuristique est, pour une tranche de zéro à n, penser: "Zéro est le début, commencer au début et prendre N articles 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 toute tranche, remplacer le départ par zéro, appliquer l'heuristique précédente pour obtenir la fin de la liste, puis compter le premier nombre de revenir à couper les articles au 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 de l'assignation de tranche est que depuis le tranchage retourne une liste, l'assignation 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 seconde règle de slice assignment, que vous pouvez également voir ci-dessus, est que quelle que soit la partie de la liste est retournée par slice indexing, c'est la même partie que est modifié par attribution 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'assignation de tranche 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 assigné:

>>> 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 difficile à s'habituer est l'assignation à vider les tranches. Utilisation heuristique 1 et 2 Il est facile d'obtenir votre tête autour de indexation 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 que, l'affectation de tranche à la tranche vide a du sens aussi:

>>> 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'] # result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # result is longer still

notez que, puisque nous ne changeons pas le deuxième nombre de la tranche (4), les éléments insérés s'empilent toujours directement contre le "o", même lorsque nous assignons à la tranche vide. Ainsi, la position pour l'assignation de tranche vide est l'extension logique des positions pour les affectations de tranche non vide.

marche arrière un peu, que se passe-t-il quand vous continuez avec notre procession de compter le début de la tranche?

>>> 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 slicking, une fois que vous avez terminé, vous êtes fait; il ne commence pas à couper à l'envers. En Python, vous n'obtenez pas de 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 bizarres à la règle" une fois que tu as fini, tu as fini":

>>> 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, comparé à l'indexation, le tranchage python est étrangement à l'épreuve des erreurs:

>>> p[100:200]
 []
>>> p[int(2e99):int(1e99)]
 []

cela peut être utile parfois, mais cela peut aussi conduire à un comportement un 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, ça pourrait... ou peut-être pas... être ce que vous espériez!

ci - dessous est le texte de ma réponse originale, il a été utile à beaucoup de gens donc je ne voulais pas le supprimer.

>>> r=[0,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 tranchage et l'indexation.

Expliquer Python de tranche du la notation

en bref, les colons ( : ) en notation en indice ( subscriptable[subscriptarg] ) font la notation en tranche-qui a les arguments optionnels, start , stop , step :

sliceable[start:stop:step]

le tranchage Python est un moyen computationnellement rapide d'accéder méthodiquement à certaines parties de vos données. À mon avis, pour être un programmeur Python intermédiaire, c'est un aspect de la langue qu'il est nécessaire d'être familier avec.

Définitions Importantes

pour commencer, définissons quelques termes:

début: le début de l'indice de la tranche, il comprendra l'élément à cet indice, sauf si c'est la même chose que stop , par défaut à 0, c'est à dire le premier indice. S'il est négatif, il signifie de commencer n articles de la fin.

stop: l'index de fin de la tranche, il n' pas inclure l'élément à cet indice, les valeurs par défaut de la longueur de la séquence de tranchées, qui est, jusqu'à et y compris la fin.

étape: le montant par lequel l'indice augmente, par défaut à 1. Si c'est négatif, vous tranchez sur le itérable à l'envers.

comment Travaux D'Indexation

vous pouvez faire n'importe lequel de ces nombres positifs ou négatifs. Le sens des nombres positifs est simple, mais pour les nombres négatifs, tout comme les index en Python, vous comptez à rebours à partir de la fin pour le start et stop , et pour le step , vous décrémentez simplement votre index. Cet exemple est du tutoriel de la documentation , mais j'ai modifié légèrement pour indiquer quel article dans 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 Le Découpage Des Œuvres

pour utiliser la notation slice avec une séquence qui la Supporte, vous devez inclure au moins deux points dans les crochets qui suivent la séquence (qui en fait implémentent la méthode __getitem__ de la séquence, selon le modèle de données Python .)

Tranche de notation fonctionne comme ceci:

sequence[start:stop:step]

et rappeler qu'il y a des valeurs par défaut pour start , stop , et step , donc pour accéder aux valeurs par défaut, il suffit d'écarter l'argument.

notation de tranche pour obtenir les neuf derniers éléments d'une liste (ou toute autre séquence qui la supporte, comme une chaîne de caractères) ressemblerait à ceci:

my_list[-9:]

quand je vois ça, je lis le partie entre parenthèses "9e de la fin, à la fin."(En fait, je l'écourter, mentalement "-9,")

explication:

la notation complète est

my_list[-9:None:None]

et de substituer les valeurs par défaut (en fait, lorsque step est négatif, stop de l 'défaut est -len(my_list) - 1 , donc None pour stop signifie vraiment juste qu'il va à la fin de l'étape le prend à):

my_list[-9:len(my_list):1]

le colon , : , c'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 nettoyer 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 dans un entier négatif, et la liste (ou la plupart des autres tranchants standard) sera tranchée de la fin au début.

ainsi une tranche négative changera les valeurs par défaut pour start et stop !

confirmant ceci 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 . Tout d'abord, nous déterminons si step est négatif:

 step_is_negative = step_sign < 0;

si c'est le cas, la limite inférieure est -1 ce qui signifie que nous coupons jusqu'au début inclusivement, et la limite supérieure est la longueur moins 1, ce qui signifie que nous commençons à la fin. (Notez que l' la sémantique de ce -1 est différent 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;
}

Autrement step est positive, et la limite inférieure sera égal à zéro et la limite supérieure (qui nous aller jusqu'à, mais pas y compris) la longueur des tranches de liste.

else {
    lower = _PyLong_Zero;
    Py_INCREF(lower);
    upper = length;
    Py_INCREF(upper);
}

alors, nous pouvons devoir appliquer les valeurs par défaut pour start et stop - la valeur par défaut pour start est calculée comme 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 limite inférieure:

if (self->stop == Py_None) {
    stop = step_is_negative ? lower : upper;
    Py_INCREF(stop);
}

donnez à vos tranches un nom descriptif!

vous pouvez trouver utile de séparer la formation de la tranche de passer à la list.__getitem__ méthode ( c'est ce que font les crochets ). Même si vous n'êtes pas nouveau à cela, il garde votre code plus lisible de sorte que les autres qui peuvent avoir à lire votre code peuvent plus facilement comprendre ce que vous faites.

cependant, vous ne pouvez pas juste assigner quelques entiers séparés par des colonnes à une variable. Vous devez utiliser l'objet slice:

last_nine_slice = slice(-9, None)

Le deuxième argument, None , est nécessaire, de sorte que le le premier argument est interprété comme le start argument sinon, ce serait le stop argument .

vous pouvez alors passer l'objet slice à votre séquence:

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

il est intéressant que les gammes prennent aussi des tranches:

>>> range(100)[last_nine_slice]
range(91, 100)

Considérations Relatives À La Mémoire:

depuis que des tranches de listes Python créent de nouveaux objets en mémoire, un autre important la fonction à connaître est itertools.islice . Généralement, vous voudrez itérer sur une tranche, pas juste l'avoir créé statiquement dans la mémoire. islice est parfait pour cela. Une mise en garde, il ne supporte pas les arguments négatifs à start , stop , ou step , donc si c'est un problème, vous pouvez avoir besoin de calculer des indices ou inverser le 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 font la copie est une caractéristique des listes elles-mêmes. Si vous découpez des objets avancés comme une base de données Pandas, elle peut retourner une vue sur l'original, et non une copie.

et deux ou trois choses qui n'étaient pas immédiatement évidentes pour moi quand j'ai vu la syntaxe de tranchage:

>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]

façon facile d'inverser les séquences!

et si vous vouliez, pour une raison quelconque, chaque deuxième élément dans la séquence inversée:

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]

trouvé cette grande table à 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)

En Python 2.7

tranchant 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 de l'indice 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

quand vous dites [A:b: c], vous dites selon le signe de c (vers l'avant ou vers l'arrière), commencez par a et finissez par b (à l'exclusion de l'élément à l'index 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 gamme continue dans les deux directions à l'infini:

...,-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 le chevauchement avec la gamme ci-dessus que vous traversez en utilisant des règles pour a,b,c ci-dessus, vous obtiendrez soit une liste avec des éléments (touché pendant traversal) ou vous obtiendrez une liste vide.

une dernière chose: si a et b sont égaux, alors vous obtenez aussi 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]

après l'avoir utilisé un peu, je me rends compte que la description la plus simple est qu'elle est exactement la même que les arguments dans une boucle for...

(from:to:step)

l'un d'eux est facultatif

(:to:step)
(from::step)
(from:to)

alors l'indexation négative a juste besoin que vous ajoutiez la longueur de la chaîne aux indices négatifs pour la comprendre.

ça me va quand même...

je trouve qu'il est plus facile de se rappeler comment cela fonctionne, alors je peux comprendre n'importe quelle combinaison de démarrage/arrêt/étape spécifique.

il est instructif de comprendre range() premier:

def range(start=0, stop, step=1):  # illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

commence de start , incrément de step , ne pas atteindre stop . Très simple.

la chose à se rappeler au sujet de l'étape négative est que stop est toujours la fin exclue, si elle est supérieure ou inférieure. Si vous voulez la même tranche dans l'ordre opposé, il est beaucoup plus propre de faire l'inversion séparément: par exemple 'abcde'[1:-2][::-1] tranches d'un char de gauche, deux de droite, puis inverse. (Voir aussi reversed() .)

Séquence de découpage est le même, sauf qu'il normalise en premier lieu des index négatifs, et ne peut jamais aller à l'extérieur de la séquence:

TODO : le code ci-dessous avait un bug avec "Ne jamais sortir de la séquence" quand abs(step)>1; I penser j'ai patché pour être correct, mais il est difficile à comprendre.

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

ne vous inquiétez pas pour les détails de is None - rappelez-vous juste que l'omission de start et/ou stop fait toujours la bonne chose pour vous donner la séquence entière.

la normalisation des indices négatifs permet d'abord de compter le début et/ou l'arrêt à partir de la fin indépendamment: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc' malgré range(1,-2) == [] . Le la normalisation est parfois considérée comme " modulo la longueur "mais notez qu'elle ajoute la longueur une seule fois: par exemple 'abcde'[-53:42] est juste la chaîne entière.

j'utilise la méthode" an index points between elements "pour y réfléchir moi-même, mais une façon de la décrire qui aide parfois les autres à l'obtenir est celle-ci:

mylist[X:Y]

X est l'index du premier élément que vous souhaitez.

Y est l'index du premier élément que vous ne voulez.

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

Python découpage de notation:

a[start:end:step]

• pour start et end , les valeurs négatives sont interprétées comme étant relatives à la fin de la séquence.
• les indices positifs pour end indiquent la position après le dernier élément à être inclus.
• les valeurs vierges sont par défaut comme suit: [+0:-0:1] .
• avec un pas négatif inverse l'interprétation de start et end

la notation s'étend aux matrices (numpy) et aux tableaux multidimensionnels. Par exemple, pour trancher des colonnes entières vous pouvez utiliser:

m[::,0:2:] ## slice the first two columns

contiennent des références, et non des copies, des éléments du tableau. Si vous voulez faire une copie d'un tableau, vous pouvez utiliser deepcopy() .

vous pouvez également utiliser l'assignation 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]

C'est juste pour quelques informations supplémentaires... Voir 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]

voir la réponse d'abc ci-dessus

C'est comme ça que j'enseigne les tranches aux débutants:

comprendre la différence entre l'indexation et le tranchage:

Wiki Python a cette image étonnante qui distingue clairement l'indexation et le tranchage.

il s'agit d'une liste de 6 é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 a une alphabet.

L'indexation est comme s'occuper du contenu de la boîte. Vous pouvez vérifier le contenu de la 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 2 balles dans 1 boîte ou remplacer 2 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

trancher, c'est comme s'occuper des boîtes. Vous pouvez ramasser la première boîte et la placer sur une autre table. Pour ramasser la boîte tout ce que vous avez besoin de savoir est la position de début et de fin de la zone.

vous pouvez même ramasser les 3 premières boîtes ou les 2 dernières boîtes ou toutes les boîtes entre 1 et 4. Ainsi, vous pouvez choisir n'importe quel ensemble de boîtes si vous connaissez le début et la fin. Ces positions sont appelées positions start & stop.

La chose intéressante est que Vous pouvez remplacer plusieurs boîtes à la fois. Aussi, vous pouvez placer plusieurs boîtes où vous voulez.

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écoupage À Pas:

Jusqu'à présent vous avez choisi des boîtes en continu. Mais parfois vous devez ramasser discrètement. Par exemple, vous pouvez ramasser chaque deuxième boîte. Vous pouvez même ramasser une boîte sur trois à partir de la fin. Cette valeur s'appelle la taille de pas. Cela représente l'écart entre vos Pick-Up successifs. La taille de l'étape doit être positive si vous choisissez des boîtes 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 Découvre La Disparition Paramètres:

lors du tranchage 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 calcule des indices à une tranche pour un paramètre donné. Voici le code équivalent logique en Python.

cette fonction prend un objet Python et les paramètres optionnels pour trancher et retourne start, stop, step & longueur de la tranche pour la tranche demandée.

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. Puisque Python a une fonction intégrée appelée slice, vous pouvez passer quelques paramètres et vérifier comment 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]

Note: http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html

en règle générale, l'écriture de code avec un grand nombre de valeurs d'index hardcoded conduit à une lisibilité d'entretien et de désordre. Par exemple, si vous revenez au code un an plus tard, vous la regarde et me demande ce que vous pensiez quand vous avez écrit. La solution montrée c'est simplement une façon d'indiquer plus clairement ce que votre code fait réellement. En général, la slice () intégrée crée un objet slice qui peut être utilisé n'importe où 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 tranche instance s, vous pouvez obtenir plus d'informations à ce sujet, en regardant son S. start, S. stop, et S. les attributs step, respectivement. Par exemple:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>

1. Mention

pour simplifier, rappelez-vous tranche n'a qu'un seul formulaire

s[start:end:step]

et voici comment cela fonctionne:

• s : un objet qui peut être tranché
• start : premier indice pour démarrer l'itération
• end : dernier indice, notez que l'indice end ne sera pas inclus dans la tranche obtenue
• step : choisissez l'élément de tous les step index

autre chose d'importation: tous start , end , step peut être omis! et s'ils sont omis, leur valeur par défaut sera utilisée: 0 , len(s) , 1 en conséquence.

Afin de variations possibles sont:

# mostly used variations
s[start:end]
s[start:]
s[:end]

# step related variations
s[:end:step]
s[start::step]
s[::step]

# make a copy
s[:]

NOTE: Si start>=end (en considérant seulement quand step>0 ), python retournera une tranche vide [] .

2. Pièges

la partie ci-dessus explique les caractéristiques de base sur la façon dont fonctionne slice, il fonctionnera à la plupart des occasions. Cependant il peut y avoir des pièges que vous devez surveiller, et cette partie explique.

indices négatifs

la toute première chose qui trouble les apprenants en python est que l'indice peut être négatif! Ne paniquez pas: l'indice négatif signifie Compter à l'envers.

par exemple:

s[-5:]    # start at the 5th index from the end of array, 
          # thus returns the last 5 elements
s[:-5]    # start at index 0, end until the 5th index from end of array, 
          # thus returns s[0:len(s)-5]

Négatif étape

rend les choses plus confuses est que step peut être négatif aussi!

Négatif étape signifie itérer le tableau à l'envers: à partir de la fin, avec la fin de l'index inclus, et de commencer à indice exclu du résultat.

NOTE : lorsque step est négatif, la valeur par défaut pour start à len(s) (tandis que end n'est pas égal à 0 , parce que s[::-1] contient s[0] ). Par exemple:

s[::-1]            # reversed slice
s[len(s)::-1]      # same as above, reversed slice
s[0:len(s):-1]     # empty list

erreur hors de portée?

soyez surpris: slice n'augmente pas IndexError lorsque l'indice est hors de portée!

si l'index est hors de portée, python essaiera de régler l'index à 0 ou len(s) selon la situation. Par exemple:

s[:len(s)+5]      # same as s[:len(s)]
s[-len(s)-5::]    # same as s[0:]
s[len(s)+5::-1]   # same as s[len(s)::-1], same as s[::-1]

3. Exemples

finissons cette réponse par des exemples, explique tout ce dont nous avons parlé:

# create our array for demonstration
In [1]: s = [i for i in range(10)]

In [2]: s
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: s[2:]   # from index 2 to last index
Out[3]: [2, 3, 4, 5, 6, 7, 8, 9]

In [4]: s[:8]   # from index 0 up to index 8
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7]

In [5]: s[4:7]  # from index 4(included) up to index 7(excluded)
Out[5]: [4, 5, 6]

In [6]: s[:-2]  # up to second last index(negative index)
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7]

In [7]: s[-2:]  # from second last index(negative index)
Out[7]: [8, 9]

In [8]: s[::-1] # from last to first in reverse order(negative step)
Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [9]: s[::-2] # all odd numbers in reversed order
Out[9]: [9, 7, 5, 3, 1]

In [11]: s[-2::-2] # all even numbers in reversed order
Out[11]: [8, 6, 4, 2, 0]

In [12]: s[3:15]   # end is out of range, python will set it to len(s)
Out[12]: [3, 4, 5, 6, 7, 8, 9]

In [14]: s[5:1]    # start > end, return empty list
Out[14]: []

In [15]: s[11]     # access index 11(greater than len(s)) will raise IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

les réponses ci-dessus ne discutent pas du découpage de tableaux multidimensionnels qui est possible en utilisant le célèbre paquet de numpy:

le tranchage s'applique également aux matrices multidimensionnelles.

# 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]])

La ":2" avant la virgule fonctionne sur la première dimension et le "0:3:2" après la virgule fonctionne sur la deuxième dimension.

pour obtenir un certain morceau d'une itérable (comme une liste), voici un exemple:

variable[number1:number2]

dans cet exemple, un nombre positif pour le numéro 1 est le nombre de composants que vous retirez de l'avant. Un nombre négatif est l'exact opposé, combien vous gardez de la fin. Un nombre positif pour le numéro 2 indique combien de composants vous avez l'intention de garder dès le début, et un négatif est combien vous avez l'intention de décoller de la fin. C'est un peu contre-intuitif, mais vous avez raison de penser que le découpage de listes est extrêmement utile.

Mon cerveau semble heureux d'accepter que lst[start:end] contient start -ème élément. Je pourrais même dire que c'est un "naturel hypothèse'.

mais parfois un doute s'insinue et mon cerveau demande à être rassuré sur le fait qu'il ne contient pas l'élément end - th.

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 c'est dans lst[end:] .

notez que ce théorème est vrai pour tout n du tout. Par exemple, vous pouvez vérifier que

lst = range(10)
lst[:-42] + lst[-42:] == lst

renvoie True .

#!/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 à partir 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, remarquez que la réponse est décalée de 1 vers la droite.

en Python, la forme la plus basique pour le tranchage est la suivante:

l[start:end]

où l est une certaine 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 tranchage à partir du début, vous pouvez omettre l'indice zéro, et lors du tranchage à la fin, vous pouvez omettre l'indice final car il est redondant, donc 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 pour effectuer des offsets relatifs à 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 3 elements
Out[8]: [7, 8, 9]

il est possible de fournir des indices qui sont hors limites lors du tranchage tel que:

In [9]: l[:20] # 20 is out of index bounds, 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, 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. De plus, lorsqu'on utilise la notation des tranches dans les assignations, il n'est pas nécessaire que la longueur de l'assignation des tranches soit la même. Les valeurs avant et après la la tranche attribuée sera conservée et la collection diminuera ou augmentera pour contenir les nouvelles valeurs:

In [16]: l[2:6] = list('abc') # assigning less 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 de cession, 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', '.', '.', '.']

en plus du tranchage 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é pour prendre chaque nth article 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]

utiliser 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 nombres 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 pourrait devenir très confuse. De plus, pour être pythonique, vous devez éviter d'utiliser start , end , et step en une seule tranche. Si cela est nécessaire, envisagez de le faire en deux assignations (l'une pour trancher, et l'autre pour enjamber).

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]

l'exemple ci-dessous est l'index d'une chaîne de caractères

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

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

ci-dessous est l'exemple d'usage

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

la plupart des réponses ci-dessus clarifie à propos de Slice notation. La syntaxe d'indexation étendue utilisée pour le tranchage est aList[start:stop:step] les exemples de base sont

:

autres exemples de tranchage: 15 tranches étendues

je veux ajouter un exemple Hello world qui explique les bases des tranches pour les débutants. Il m'a beaucoup aidé.

nous allons avoir une liste avec les six valeurs ['P', 'Y', 'T', 'H', 'O', 'N'] :

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5 

les tranches les plus simples de cette liste sont désormais ses sous-listes. La notation est [<index>:<index>] et la clé est de le lire comme ceci:

[ start cutting before this index : end cutting before this index ]

maintenant si vous faites une tranche [2:5] de la liste ci-dessus, cela arrivera:

        |           |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
  0   1 | 2   3   4 | 5 

Vous avez fait une coupe avant l'élément à l'index 2 et une autre " couper avant l'élément à l'index 5 . Donc, le résultat sera une tranche entre ces deux coupes, une liste ['T', 'H', 'O'] .

hehehehe, il est un peu étrange de me voir essayer de fournir une meilleure et plus simple explication après 2600+ votes sur ce qui a été marqué comme la bonne réponse de Grew Hewgill.

C'est parti ...

à mon avis, vous comprendrez et mémoriserez mieux la notation de tranchage Python string si vous la regardez de la manière suivante (lisez la suite).

travaillons avec la chaîne suivante ...

azString = "abcdefghijklmnopqrstuvwxyz"

pour ceux qui ne savent pas, vous pouvez créer n'importe quel substrat 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 souvenir de ce que sont x et y et m'aidera à trancher les cordes correctement à la première tentative.

My la conclusion est que x et y devraient être considérés comme les indices de limite qui entourent les chaînes que nous voulons ajouter. 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 ...

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

donc tout ce que vous avez à faire si vous mettez index1 et index2 aux valeurs qui entoureront le substrat désiré. Par exemple, pour obtenir la sous-chaîne "cdefgh", vous pouvez utiliser azString[2:8] parce que l'index à gauche de" c "est 2 et celui à droite de" h " est 8.

rappelez-vous, nous établissons les limites.

Que l'astuce fonctionne tout le temps et est facile à mémoriser.

heureusement nous, cela aidera.

tranche : - le serpent apparaît près de votre pied. Il se déplace de l'invisible au visible. Notre vision révèle (comme une tranche), seule une partie du monde. de même, une tranche de Python extrait des éléments, basés sur un start et un stop. Nous prenons des tranches sur de nombreux types en Python. Nous spécifions un premier index optionnel, un dernier index optionnel et une étape optionnelle.

values[1:3]  Index 1 through index 3.
values[2:-1] Index 2 through index one from last.
values[:2]   Start through index 2.
values[2:]   Index 2 through end.
values[::2]  Start through end, skipping ahead 2 places each time.

vous pouvez obtenir de bons exemples au lien ci-dessous:- notation Python slice exemple

si vous pensez que les indices négatifs en tranchant sont déroutants, voici une façon très simple d'y penser: il suffit de remplacer l'indice négatif par len - index . Ainsi, par exemple, remplacer -3 avec len(list) - 3 .

la meilleure façon d'illustrer ce que le tranchage fait en interne est simplement de le montrer dans le 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 for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

la technique de tranchage de base est de définir le point de départ, le point d'arrêt, et la taille de 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éer deux listes pour trancher, la première est une liste numérique de 1 à 9 (liste a). Le second est aussi une liste numérique, de 0 à 9 (liste B)

A = list(range(1,10,1)) # start,stop,step
B = list(range(9))

print("This is List A:",A)
print("This is List B:",B)

indexe le nombre 3 de A et le nombre 6 de B.

print(A[2])
print(B[6])

Découpage De Base

syntaxe d'indexation étendue utilisée pour le tranchage est aList[start:stop:step]. L'argument start et l'argument step sont tous deux par défaut à none - le seul argument requis est stop. Avez-vous remarqué que c'est similaire à la façon dont range a été utilisé pour définir les listes A et B? C'est parce que l'objet tranche représente l'ensemble des indices spécifiés par gamme(début, fin, pas). Python 3.4 documentation

Comme vous pouvez le voir, définir seulement stop renvoie un élément. Puisque le départ est par défaut à 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'indice 0 et non l'indice 1. C'est pourquoi nous utilisons deux 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 second é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'élément 0, etc).

avec une syntaxe d'indexation étendue, nous récupérons une plage de valeurs. Par exemple, toutes les valeurs sont récupérées avec une virgule.

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 motif aList [start:stop], récupérer les deux premiers éléments de la liste a