L's destul de simplu:

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

Există, de asemenea, " pas " valoare, care poate fi folosit cu oricare dintre cele de mai sus:

a[start:stop:step] # start through not past stop, by step

Punctul cheie este să-ți amintești că:stop` valoare reprezintă prima valoare care este nu în selectată felie. Deci, diferența între "stop" și "start" este numărul de elemente selectate (dacă " pas " este 1, default).

Altă caracteristică este că "start" sau "stop" poate fi o negativ număr, ceea ce înseamnă că nu contează de la sfârșitul matrice în loc de la început. Deci:

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

În mod similar, " pas " poate fi un număr negativ:

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 este un fel de programator, dacă există mai puține elemente decât ceri. De exemplu, dacă vă întreb pentru o[:-2]șio` conține doar un singur element, veți obține o listă goală în loc de o eroare. Uneori ar prefera eroare, așa că trebuie să fie conștienți de faptul că acest lucru se poate întâmpla.

Raport cu slice() obiect

Felierea operator [] este, de fapt folosit în codul de mai sus cu o felie()obiect folosind:notație (care este valabil numai în cadrul[]`), adică:

a[start:stop:step]

este echivalent cu:

a[slice(start, stop, step)]

Felie de obiecte comporta, de asemenea, ușor diferit, în funcție de numărul de argumente, în mod similar cu raza(), adicăslice(oprire) " și " felie(start, stop[, pas]) sunt acceptate. Pentru a sări peste specificarea unui anumit argument, s-ar putea folosi "Nici unul", așa că, de exemplu, o[start:]este echivalent cuo[felie(start, Nici unul)] " sau " o[::-1]este echivalent cuo[felie(Niciunul, Niciuna, -1)]`.

În timp ce:pe baza de notație este foarte util pentru simplu feliere, utilizarea explicită a slice() obiecte simplifică programatic generație de feliere.

De tutorial Python vorbește despre asta (derulați în jos un pic, până când ajunge la partea de feliere).

Arta ASCII diagrama este util pentru amintindu-mi cât de felii de lucru:

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

O modalitate de a aminti cât de felii de lucru este să ne gândim la indici precum îndreptat între caractere, cu marginea din stânga a primului caracter numerotate de la 0. Apoi marginea din dreapta a ultimul caracter dintr-un șir de n personaje are index n.

Enumerarea posibilităților permise de gramatică:

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

Desigur, dacă (high-low)%pas != 0, atunci punctul final va fi un pic mai mic decâtmare-1`.

Dacă pas este negativ, comanda este schimbat un pic, deoarece am're de numărare în jos:

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

Extins feliere (cu virgule și puncte de suspensie) sunt cele mai utilizate numai de către speciali structuri de date (cum ar fi NumPy); secvențele de bază don't să le sprijine.

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

Răspunsurile de mai sus nu't discuta felie de atribuire. Pentru a înțelege felie de atribuire, l's util pentru a adăuga un alt concept de arta 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']

Unul euristic este, pentru o felie de la zero la n, cred că: "zero este la început, de la început și să ia n elemente într-o listă".

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

O altă euristică este, "pentru orice felie, înlocuiți la început de la zero, se aplică anterior euristice pentru a ajunge la sfârșitul listei, apoi conta primul număr înapoi să taie elementele de pe la începutul"

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

Prima regulă de felie misiune este aceea de feliere revine o listă, o felie de atribuire ** necesită o lista (sau alte iterable):

>>> 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 "", line 1, in 
TypeError: can only assign an iterable

A doua regulă de felie de cesiune, pe care le puteți vedea, de asemenea, de mai sus, este că orice parte din lista este returnat de felie de indexare, care's aceeași porțiune care este schimbat de felie de atribuire:

>>> p[2:4]
 ['T','h']
>>> p[2:4] = ['t','r']
>>> p
 ['P','y','t','r','o','n']

Regula a treia felie de atribuire este desemnat lista (iterable) nu't trebuie să aibă aceeași lungime; indexate felie este pur și simplu tăiate și înlocuite en masse de tot ce este de a fi atribuit:

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

Partea cea mai grea este să te obișnuiești cu misiune este de a goli felii. Folosind euristica 1 și 2 se's ușor pentru a obține capul în jurul valorii de indexare un gol felie:

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

Și apoi, o dată ce'am văzut că, felie misiune la gol felie are sens:

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

Rețineți că, din moment ce nu sunt în schimbare al doilea număr al felie (4), elementele inserate întotdeauna stivă până împotriva 'o', chiar și atunci când ne-am're atribuirea la gol felie. Deci poziția de gol felie de atribuire este extensia logică a pozițiile pentru non-gol felie misiuni.

Back-up un pic, ce se întâmplă când mergi cu procesiunea noastră de numărare până felie început?

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

Cu feliere, odată ce're făcut, ai're face; nu't începe feliere invers. În Python nu't negative pași dacă vă întreb în mod explicit pentru ei, folosind un număr negativ.

>>> p[5:3:-1]
 ['n','o']

Există unele ciudat consecințe la "odată ce ai're făcut, ai're face" regula:

>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []
>>> p[6]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

În fapt, în comparație cu indexare, Python feliere este bizar eroare-dovada:

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

Acest lucru poate veni la îndemână, uneori, dar de asemenea, poate duce la un comportament ciudat:

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

În funcție de aplicația dumneavoastră, care ar putea... sau poate nu... fii ceea ce ai fost în speranța de acolo!

Mai jos este textul meu original răspuns. Acesta a fost util pentru mulți oameni, așa că m-am't doriți să-l ștergeți.

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

Acest lucru poate, de asemenea, să clarifice diferența dintre feliere și indexare.

Explica Python's felie notație

Pe scurt, două puncte (:) în indicele de notație (subscriptable[subscriptarg]) face felie de notație - care are argumente opționale, "start", "stop", "pas":

sliceable[start:stop:step]

Python secționare este un calcul rapid mod de a metodic acces la părți ale datelor. În opinia mea, să fie chiar un intermediar Python programmer, l's un aspect de limba în care este necesar să fie familiarizat cu.

Importante Definiții

Pentru a începe cu, las's definim câțiva termeni:

start: la începutul indicele de felie, acesta va include elementul de la acest indice dacă nu este la fel ca stop, implicit la 0, adică primul indice. Daca's negativ, înseamnă a porni n elementele din urmă. stop: se încheie indicele de felie, se nu nu includ elementul de la acest indice, implicit lungimea secvenței fiind felii, care este, până la și inclusiv end. pas: suma cu care indicele crește, implicit 1. Daca's negative, tu're feliere peste iterable în sens invers.

Cum De Indexare Funcționează

Puteți face oricare dintre aceste pozitiv sau negativ numere. Sensul de numere pozitive este simplu, dar pentru numere negative, doar ca indici în Python, să numeri de la sfârșitul pentru start și stop, și pentru pas, pur și simplu decrementa index. Acest exemplu este din documentația's tutorial, dar am'am modificat-o puțin să indice care item într-o secvență fiecare indice de referință:

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

Cum Feliere Funcționează

Pentru a utiliza felie de notație cu o secvență care acceptă aceasta, trebuie să includă cel puțin un colon în paranteze pătrate care urmează secvența (care de fapt pună în aplicare `getitem metoda de ordine, potrivit Python model de date.) Felie notație funcționează ca aceasta:

sequence[start:stop:step]

Și să nu uităm că nu sunt implicite pentru start, stop, și pas, deci pentru a accesa setările implicite, pur și simplu lăsați afară argument. Felie notație pentru a obține ultimele nouă elemente dintr-o listă (sau orice alte secvențe care acceptă, ca un șir de caractere) ar arata astfel:

my_list[-9:]

Când am văzut asta, am citit o parte din paranteze ca "a 9-a de la capăt, până la capăt." (de Fapt, am abreviat mental ca "-9, pe")

Explicatie:

Complet notație este

my_list[-9:None:None]

și să înlocuiască valorile implicite (de fapt, atunci când " pas "este negativ, "stop" 's implicită este -len(my_list) - 1, deci "Nimic" pentru a opri într-adevăr înseamnă doar a merge la oricare end pas va duce să):

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

La colon, :, este ceea ce spune Python're dându-i o felie de pizza și un index. Ca's de ce idiomatice mod de a face o copie superficială a listelor în Python 2 este

list_copy = sequence[:]

Și de compensare-le este cu:

del my_list[:]

(Python 3 primeste o lista de asteptare.copie " și " lista.clar metoda.)

Când " pas "este negativ, implicite pentru "start" și "stop" schimba

În mod implicit, atunci când " pas "argument este gol (sau "Nici unul"), este atribuit +1. Dar poți trece într-un număr întreg negativ, și lista (sau cele mai multe alte standard slicables) vor fi tăiate de la sfârșitul de la început. Astfel, un negativ felie se va schimba setările implicite pentru "start" și "stop"!

Confirmă acest lucru în sursa

Îmi place pentru a încuraja utilizatorii să citească sursă, precum și documentația. De codul sursă pentru o felie de obiecte și această logică se găsește aici. Mai întâi vom determina dacă " pas " este negativ:

step_is_negative = step_sign < 0; Dacă este așa, limita inferioară este -1, însemnând noi felie tot drumul până la și inclusiv început, iar limita superioară este lungimea minus 1, adică vom începe la sfârșitul anului. (Rețineți că semantică -1 se diferit de o -1 care utilizatorii pot trece indici în Python indică ultimul element.) dacă (step_is_negative) { mai mic = PyLong_FromLong(-1L); dacă (inferior == NULL) du-te de eroare;

sus = PyNumber_Add(lungime, mai mic); dacă (upper == NULL) du-te de eroare; } În caz contrar, " pas " este pozitiv, iar limita inferioară va fi zero și limita superioară (pe care vom merge, dar nu inclusiv) durata de felii de lista. else { mai mic = _PyLong_Zero; Py_INCREF(mai mic); sus = lungime; Py_INCREF(superioare); } Apoi, avem nevoie pentru a aplica setările implicite pentru "start" și "stop" - implicit atunci pentru "start" se calculează ca limită superioară atunci când " pas " este negativ: dacă (auto->start == Py_None) { start = step_is_negative ? superioară : inferior; Py_INCREF(începe); } și "stop", limita inferioară: dacă (auto->stop == Py_None) { stop = step_is_negative ? inferioară : superioară; Py_INCREF(stop); }

Dea felii un nume descriptiv!

S-ar putea găsi că este util pentru a separa formand felie de trece-l la listă.getitem` metoda (care's ce paranteze drepte face). Chiar daca're nu este nouă, ea păstrează codul mai ușor de citit, astfel încât alții care ar putea avea pentru a citi codul poate mai ușor de înțeles ceea ce ai're face. Cu toate acestea, puteți't atribuiți doar niște numere întregi separate prin două puncte pentru o variabilă. Aveți nevoie pentru a utiliza felie obiect:

last_nine_slice = slice(-9, None)

Cel de-al doilea argument, "Nici unul", este necesară, astfel că primul argument este interpretat ca "start" argument altfel ar fi "stop" argument. Apoi, puteți trece felie de acord cu secvența:

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

L's interesante, care variază, de asemenea, să ia felii:

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

Memorie Considerente:

Din felii de Python liste de a crea noi obiecte în memorie, o altă funcție importantă să fie conștienți de este itertools.islice. De obicei te'll vreau să itera peste o felie, nu doar l-au creat static în memorie. islice este perfect pentru acest lucru. O precizare, nu't suport negativ argumente la "start", "stop", sau "pas", deci, dacă asta's o problemă s-ar putea nevoie pentru a calcula indici sau inversa iterable în avans.

length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)

și acum:

>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]

Faptul că lista felii face o copie este o caracteristică de liste de ei înșiși. Daca're feliere avansate de obiecte ca un Panda DataFrame, acesta poate reveni la o vizualizare pe original si nu o copie.

Și un cuplu de lucruri pe care nu't imediat evident pentru mine când am văzut prima feliere sintaxa:

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

Modalitate ușoară de a inversa secvențe!

Și dacă ai vrut, pentru un motiv oarecare, fiecare al doilea element din a inversat ordinea:

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

În Python 2.7

Feliere în 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).

Înțelegerea indicele de sarcină este foarte important.

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

Când spui [a:b:c], vă spun, în funcție de semnul c (înainte sau înapoi), începe de la a și se termină la b (cu excepția element la bth index). Utilizarea indexarea regula de mai sus și amintiți-vă, veți găsi doar elemente în acest interval:

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

Dar această gamă continuă în ambele direcții infinit:

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

De exemplu:

             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

Dacă alegerea ta a, b, și c permite suprapune cu intervalul de mai sus în timp ce traversa folosind regulile pentru a,b,c de mai sus, veți obține o listă cu elemente (atins în timpul de traversare) sau veți obține o listă goală.

Un ultim lucru: dacă a și b sunt egale, atunci, de asemenea, veți obține o listă goală:

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

Găsit această mare masă de la http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python indici și felii de un șase-element de listă.
Indici enumera elementele, felii enumera spații între elemente.
Index din spate: -6 -5 -4 -3 -2 -1 a=[0,1,2,3,4,5] o[1:]==[1,2,3,4,5]
Indicele de fata: 0 1 2 3 4 5 len(a)==6 a[:5]==[0,1,2,3,4]
+---+---+---+---+---+---+ a[0]==0 o[:-2]==[0,1,2,3]
| a | b | c | d | e | f | a[5]==5 o[1:2]==[1]
+---+---+---+---+---+---+ a[-1]==5 o[1:-1]==[1,2,3,4]
Felie de fata: : 1 2 3 4 5 : o[-2]==4
Felie din spate: : -5 -4 -3 -2 -1 :
b=a[:]
b==[0,1,2,3,4,5] (copie superficială a o)

După folosind-o un pic am dat seama că cea mai simplă descriere este că acesta este exact la fel ca argumente într-o "pentru" bucla...

(from:to:step)

Oricare dintre ele sunt opționale:

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

Apoi negativ de indexare trebuie doar să adăugați lungimea șir de indici negativi, să-l înțeleagă.

Aceasta funcționează pentru mine, oricum...

Mi-e mai ușor să vă amintiți cum funcționează, și atunci îmi dau seama specifice start/stop/pas combinație.

L's instructiv pentru a înțelege intervalul()` prima:

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

Începe de la "start", sporul de "pas", nu ajunge la "stop". Foarte simplu.

Lucru de reținut despre negativ pas este ca "stop" este întotdeauna excluse din urmă, dacă-l's mai mari sau mai mici. Dacă doriți aceeași felie în ordine inversă, l's mult mai curat de a face anularea în parte: de exemplu, 'abcde'[1:-2][::-1] felii de pe un char de la stânga, doi la dreapta, apoi se inversează. (A se vedea, de asemenea, [inversat()][1].)

Secvența de feliere este același, cu excepția faptului că prima normalizeaza negativ indicii, și niciodată nu poate merge în afara secvență:

TODO: codul De mai jos a avut un bug cu "niciodată nu merg în afara secvenței" atunci când abs(pas)>1; I cred că patch-uri pentru a fi corect, dar's greu de înțeles.

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

Eu folosesc "un indice de puncte între elemente" metodă de a gândi despre mine însumi, dar și o modalitate de a descrie care, uneori, îi ajută pe ceilalți să ia-o este aceasta:

mylist[X:Y]

X este indicele primului element pe care doriți. Y este indicele primului element te nici't vrei.

Python feliere notație:

a[start:end:step]

• Pentru "start" și "end", valorile negative sunt interpretate ca fiind relativă la sfârșitul secvenței.
• Pozitiv indicii pentru "scop" indică poziția după ultimul element de a fi inclus.
• Blank valori sunt în mod implicit, după cum urmează: [+0:-0:1].
• Folosind un negativ pas inversează interpretarea de "start" și "end"

Notația se extinde la (numpy) matrice și tablouri multidimensionale. De exemplu, pentru a felie întregii coloane pe care le puteți utiliza:

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

Felii deține referințe, nu copii, de elementele de matrice. Dacă doriți să faceți o copie separată o matrice, puteți utiliza deepcopy().

Acest lucru este cum am învățat felii pentru începători:

Înțelegerea diferenței dintre indexare și feliere:

Wiki Python are această imagine uimitoare, care se distinge în mod clar de indexare și feliere.

Aceasta este o listă cu șase elemente în ea. Pentru a înțelege feliere mai bine, ia în considerare această listă ca un set de șase cutii plasate împreună. Fiecare cutie are un alfabet în ea.

Indexarea este ca de-a face cu conținutul cutiei. Puteți verifica conținutul de orice cutie. Dar poate't verificați conținutul de cutii multiple la o dată. Puteți chiar să înlocuiască conținutul cutiei. Dar poate't loc două bile într-o cutie sau înlocuiți două bile la un moment dat.

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)
 in ()
----> 1 alpha[0,1]

TypeError: list indices must be integers, not tuple

Feliere este ca de-a face cu cutii de ei înșiși. Vă puteți ridica prima cutie și puneți-l pe o altă masă. Pentru a ridica cutia, tot ce trebuie să știi este poziția de început și sfârșit de cutie.

Puteți alege chiar și până la primele trei cutii sau ultimele două cutii sau toate casetele între 1 și 4. Deci, puteți alege orice set de cutii, dacă știi de la început și se termină. Aceste poziții sunt numite porni și opri poziții.

Cel mai interesant lucru este că puteți înlocui mai multe cutii, la o dată. De asemenea, puteți plasa mai multe cutii de oriunde doriți.

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

Feliere Cu Pas:

Până acum ți-au luat cutii continuu. Dar, uneori, aveți nevoie pentru a ridica discret. De exemplu, vă puteți ridica fiecare a doua cutie. Puteți alege chiar și până la fiecare a treia caseta de la sfârșitul anului. Această valoare se numește pas dimensiune. Aceasta reprezintă diferența între succesive camionete. Dimensiunea pas ar trebui să fie pozitiv dacă se iau cutii de la început până la sfârșit și invers.

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

Cum Python Cifre Din Lipsă De Parametri:

Când feliere, dacă vă lăsați orice parametru, Python încearcă să-și dea seama în mod automat.

Dacă tu a verifica codul sursă de CPython, veți găsi o funcție numită PySlice_GetIndicesEx() care cifrele indici pentru o felie pentru orice parametri. Aici este logic cod echivalent în Python.

Această funcție are un obiect Python și parametrii opționali pentru feliere și se întoarce la pornire, oprire, pas, și felie de lungime a solicitat felie.

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)

Aceasta este inteligența care este prezent în spatele felii. Deoarece Python are o funcție built-in numit felie, puteți trece unii parametri și să verificați cât de inteligent se calculează lipsește parametri.

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]

Notă: Acest post a fost scris inițial în blog-ul meu, Inteligenței Spatele Python Felii.

Puteți folosi, de asemenea, felie misiune pentru a elimina unul sau mai multe elemente dintr-o listă:

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]

Acest lucru este doar pentru cateva informatii suplimentare... Luați în considerare lista de mai jos

>>> l=[12,23,345,456,67,7,945,467]

Alte câteva trucuri pentru inversarea lista:

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

Ca regulă generală, scrierea de cod cu o mulțime de hardcoded valorile indicelui duce la o lizibilitate și de întreținere mizerie. De exemplu, dacă te întorci la codul un an mai târziu, va uita-te la ea și mă întreb de ce te-ai gândit când ai scris-o. Soluția prezentată este pur și simplu un mod mai clar de ce codul este, de fapt face. În general, built-in felie() creează o felie obiect care poate fi folosit oriunde o felie este permis. De exemplu:

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

Dacă aveți o felie de exemplu, s, puteți obține mai multe informații despre el uitandu-se la ei s.start, s.opri, și s.pas atribute, respectiv. De exemplu:

o = o felie(10, 50, 2) un.începe 10 un.stop 50 un.pas 2

1. Felie Notație

Pentru a face simplu, amintiți-vă felie are o singură formă de:

s[start:end:step]

și aici este modul în care funcționează:

• "s": un obiect care poate fi feliat
• "start": primul indice pentru a începe repetare
• "end": ultimul index, REȚINEȚI că "sfârșitul" index nu vor fi incluse în rezultat felie
• "pas": alege elementul fiecare " pas " index

Un alt import de lucru: toate "start", "sfârșitul", " pas " poate fi omis! Și dacă sunt omise, valoarea lor implicită va fi folosit: 0,len(s),1 în mod corespunzător.

Deci, variantele posibile sunt:

# 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[:]

NOTĂ: Dacă start >= end (luând în considerare numai atunci când pas>0), Python va reveni un gol felie[]`.

2. Capcane

Partea de mai sus explică caracteristicile de bază privind modul felie de lucrări, și se va lucra pe cele mai multe ocazii. Cu toate acestea, nu poate fi capcane ar trebui să ai grijă, și această parte explică ei.

Negativ indicii

Primul lucru care confundă Python elevii este că un index poate fi negativ! Don't de panică: un indice negativ înseamnă să numeri invers.

De exemplu:

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

Negativ pas

A face lucrurile mai confuz este faptul că " pas " poate fi negativ prea!

Un negativ pas înseamnă repeta matrice invers: de la sfârșitul pentru a începe, odată cu sfârșitul index incluse, și începe index excluse din rezultatul.

NOTĂ: atunci când pas este negativ, valoarea implicită pentru start este, len(s) (în timp ce " end "nu este egal cu a 0, pentru că s[::-1] "conține" s[0]). De exemplu:

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

În afara intervalului de eroare?

Fi surprins: felie nu ridică o eroare indexerror când indicele este în afara razei de acțiune!

Dacă indicele este în afara intervalului, Python va încerca tot posibilul pentru a stabili indicele 0 sau `len(s) în funcție de situație. De exemplu:

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

3. Exemple

Las's a termina acest răspuns cu exemple, explicând tot ceea ce am discutat:

# 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, and 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 an IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
----> 1 s[11]

IndexError: list index out of range

Răspunsurile anterioare nu't a discuta despre multi-dimensional matrice feliere care este posibil, folosind celebrul NumPy pachet:

Feliere poate fi, de asemenea, aplicate pentru a matrice multi-dimensionale.

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

":2" înainte de virgulă funcționează pe prima dimensiune și "0:3:2" după virgulă operează pe cea de-a doua dimensiune.

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

Puteți rula acest script și experiment cu ea, mai jos sunt câteva probe care am primit de la script-ul.

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

Atunci când se utilizează un negativ pas, observa că răspunsul este decalat spre dreapta cu 1.