Suprasti gabalėlių pavadinimą

Python fragmento žymoje man reikia gero paaiškinimo (nuorodos - plius).

Man tai reiškia, kad šis ženklas šiek tiek pakelia.

Jis atrodo labai galingas, bet aš ne visai jį priėmiau.

2540
04 февр. nustatė Simon 04 vasaris 2009-02-04 01:31 '09 ne 1:31 2009-02-04 01:31
@ 33 atsakymai
  • 1
  • 2

Tai gana paprasta:

 a[start:end] # items start through end-1 a[start:] # items start through the rest of the array a[:end] # items from the beginning through end-1 a[:] # a copy of the whole array 

Taip pat yra step vertė, kurią galima naudoti su vienu iš pirmiau minėtų būdų:

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

Svarbu prisiminti, kad reikšmė :end reiškia pirmąją vertę, kuri nėra pasirinktame fragmente. Taigi skirtumas tarp end ir start yra pasirinktų elementų skaičius (jei step yra 1, numatytasis).

Kitas bruožas yra tai, kad start arba end gali būti neigiamas skaičius, o tai reiškia, kad jis skaičiuojamas nuo masyvo pabaigos, o ne nuo pradžios. Taigi:

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

Panašiai step gali būti neigiamas skaičius:

 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“ yra patenkintas programuotoju, jei yra mažiau elementų nei prašote. Pavyzdžiui, jei prašote a[:-2] , o a yra tik vienas elementas, vietoj klaidos gausite tuščią sąrašą. Kartais jums patinka klaida, todėl reikia žinoti, kad tai gali įvykti.

3459
04 февр. atsakymas, kurį pateikė Greg Hewgill 04 vasaris 2009-02-04 01:48 '09 ne 1:48 2009-02-04 01:48

„Python“ pamoka apie tai kalba (šiek tiek slinkite žemyn, kol pasieksite dalį apie pjaustymą).

ASCII meno diagrama taip pat naudinga įsiminti, kaip veikia skiltelės:

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

Vienas iš būdų prisiminti, kaip skiltelės veikia, yra atsižvelgti į indeksus, rodančius tarp simbolių, o kairiojo pirmojo simbolio kraštas yra sunumeruotas 0. Tada dešiniojo simbolių eilutės paskutinio simbolio kraštas yra n.

436
04 февр. Hans Nowak atsakymas, pateiktas vasario 04 d. 2009-02-04 01:49 '09 ne 1:49 2009-02-04 01:49

Gramatikos suteiktų galimybių sąrašas:

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

Žinoma, jei (high-low)%stride != 0 , galutinis taškas bus šiek tiek mažesnis nei high-1 .

Jei stride neigiamas, užsakymas šiek tiek pasikeičia, nes skaičiuojame:

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

Išplėstos griežinėliai (su kableliais ir elipsėmis) dažniausiai naudojami tik specialiomis duomenų struktūromis (pvz., NumPy); pagrindinės sekos jų nepalaiko.

 >>> class slicee: ... def __getitem__(self, item): ... return 'item' ... >>> slicee()[0, 1:2, ::5, ...] '(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)' 
337
04 февр. atsakymą pateikė efemientas 04 vasaris. 2009-02-04 02:08 '09, 2:08 am. 2009-02-04 02:08

Anksčiau pateikti atsakymai neaptaria griežinėlių tikslą. Norint suprasti griežinėlių paskirtį, naudinga pridėti dar vieną koncepciją ASCII menui:

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

Vienas heuristinis yra tai, kad, jei pjūvis yra nuo nulio iki n, manau, kad „nulis yra pradžia, pradžia nuo pradžios ir n elementai sąraše.“

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

Kitos heuristikos: "bet kuriai pjūviui pakeiskite pradžią nuliu, taikykite ankstesnes heuristikas, kad gautumėte sąrašo pabaigą, o paskui suskaičiuokite pirmąjį skaičių, kad iš pradžių būtų išjungti elementai."

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

Pirmoji skiltelių priskyrimo taisyklė yra ta, kad, nes skiltelės grąžina sąrašą, reikia priskirti sąrašą (arba kitus, kuriuos reikia kartoti), kad priskirtumėte skilteles:

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

Antroji skilties priskyrimo taisyklė, kurią taip pat galite matyti aukščiau, yra ta, kad bet kuri sąrašo dalis, grąžinta gabalėlių indeksavimo metu, yra tokia pati, kaip ir dalis, kuri keičiama skirstant griežinėliams:

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

Trečioji skilties priskyrimo taisyklė yra ta, kad priskirtas sąrašas (pakartojamas) neturėtų būti tokio pat ilgio; Indeksuotas fragmentas paprastai supjaustomas ir masyviai pakeičiamas tuo, ką jis priskiria:

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

Sunkiausia dalis priprasti yra tuščių griežinėlių skyrimas. Naudojant heuristinius 1 ir 2 algoritmus, lengva apeiti galvą, kai indeksuojamas tuščias fragmentas:

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

Ir tada, kai tik pamatysite, pjūvio priskyrimas tuščiam gabalui taip pat yra prasmingas:

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

Atkreipkite dėmesį, kad kadangi nepakeičiame antrojo pjūvio numerio (4), įterpti elementai visada yra tiesiai priešais „o“, net jei priskiriame tuščią gabalėlį. Taigi tuščios pjūvio priskyrimo vieta yra loginių ne tuščių gabalų užduočių pozicijų pratęsimas.

Truputį atsarginės kopijos, kas atsitiks, jei tęsite mūsų pjūvio pradžios procesą?

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

Baigę pjauti, baigsite; ji nepradeda mažinti. „Python“ nepavyks gauti neigiamų veiksmų, nebent juos aiškiai paprašytumėte naudojant neigiamą skaičių.

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

Yra keletas keistų pasekmių taisyklei „kai tik baigsite, baigsite“:

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

Iš tikrųjų, palyginti su indeksavimu, „Python“ pjaustymas yra sudėtingai apsaugotas nuo klaidų:

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

Kartais tai gali būti naudinga, tačiau tai gali sukelti šiek tiek keistą elgesį:

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

Priklausomai nuo jūsų prašymo, tai gali ... arba ... negali būti tai, ko tikėjotės!


Žemiau yra mano pirminio atsakymo tekstas. Tai buvo naudinga daugeliui žmonių, todėl nenorėjau jo ištrinti.

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

Tai taip pat gali paaiškinti skirtumą tarp sriegimo ir indeksavimo.

236
19 янв. Atsakyti David M. Perlman 19 sausis 2011-01-19 00:37 '11 prie 0:37 2011-01-19 00:37

Paaiškinkite Python fragmento žymėjimą

Trumpai tariant, dvitaškis ( : indekso žymenyje ( subscriptable[subscriptarg] ) daro pjūvio žymėjimą, kuris turi pasirinktinius argumentus, start , stop , step :

 sliceable[start:stop:step] 

Python pjaustymas yra greitas būdas apskaičiuoti prieigą prie jūsų duomenų dalių. Mano nuomone, net ir tarpinis Python programuotojas yra vienas iš kalbos aspektų, kuriuos turite žinoti.

Svarbios apibrėžtys

Pirmiausia nustatykime keletą terminų:

pradžia: pradinis pjūvio indeksas, į jį bus įtrauktas elementas šiame indekse, jei jis nėra tas pats, kas sustabdymas, numatytasis yra 0, tai yra pirmasis indeksas. Jei jis yra neigiamas, tai reiškia, kad jums reikia pradėti n elementus nuo pabaigos.

stop: galutinis skilties indeksas, kuriame nėra šio indekso elemento, pagal nutylėjimą yra fragmentuotos sekos ilgis, ty prieš ir įskaitant pabaigą.

žingsnis: skaičius, kuriuo indeksas didinamas, yra 1. Jei jis yra neigiamas, jūs supjaustysite iteraciją atvirkštine tvarka.

Kaip veikia indeksavimas

Galite padaryti bet kurį iš šių teigiamų ar neigiamų skaičių. Teigiamų skaičių vertė yra paprasta, tačiau neigiamiems skaičiams, kaip ir Python indeksams, skaičiuojate atgal nuo pradžios ir sustabdymo, ir šiam žingsniui jūs tiesiog sumažinate indeksą. Šis pavyzdys pateiktas iš dokumentacijos vadovo , tačiau aš jį šiek tiek modifikavau, kad nurodytumėte, kuris sekos elementas yra susijęs su kiekvienu indeksu:

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

Kaip pjovimas

Norėdami naudoti fragmentų žymėjimą su seka, kuri ją palaiko, turite įtraukti bent vieną dvitaškį kvadratiniuose skliaustuose, kurie seka seką (kuri iš tikrųjų įgyvendina __getitem__ sekos metodą, pagal Python duomenų modelį ).

Skaldos žymėjimas veikia taip:

 sequence[start:stop:step] 

Ir nepamirškite, kad yra numatytieji pradžios, sustabdymo ir žingsnio nustatymai, todėl norėdami pasiekti numatytuosius nustatymus, tiesiog palikite argumentą.

Fragmento pavadinimas, skirtas gauti paskutinius devynis elementus iš sąrašo (arba bet kokia kita seka, palaikanti ją, kaip ir eilutė) atrodys taip:

 my_list[-9:] 

Kai matau tai, perskaičiau dalį skliausteliuose kaip „9-oji nuo pabaigos iki galo“. (Tiesą sakant, aš psichiškai sutrumpinsiu kaip „-9, on“)

Paaiškinimas:

Visas įrašas

 my_list[-9:None:None] 

ir pakeiskite numatytuosius nustatymus (iš tikrųjų, kai step neigiamas, numatytasis stop yra -len(my_list) - 1 , taigi None sustabdymui faktiškai reiškia, kad jis priklauso nuo to, kuris galutinis žingsnis yra ):

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

Dvitaškis : - tai, ką sako Python, tai, ką jūs duodate, yra gabalas, o ne įprastas indeksas. Štai kodėl idiomatinis būdas sukurti mažas Python 2 sąrašų kopijas

 list_copy = sequence[:] 

Ir jų valymas:

 del my_list[:] 

(Python 3 gauna list.copy ir list.clear .)

Kai step neigiamas, numatytosios start ir stop vertės

Pagal numatytuosius nustatymus, kai step argumentas yra tuščias (arba None ), jam priskiriama reikšmė +1 .

Bet jūs galite pereiti prie neigiamo sveikojo skaičiaus, o sąrašas (arba daugelis kitų standartinių slankiklių) bus nukirptas nuo pabaigos iki pradžios.

Taigi, neigiama gabalas pakeis numatytąsias start ir stop reikšmes!

Tai patvirtinti šaltinyje

Norėčiau paskatinti vartotojus skaityti šaltinį ir dokumentaciją. Čia yra griežinėlių objektų šaltinio kodas ir ši logika . Pirmiausia nustatome, ar step neigiamas:

  step_is_negative = step_sign < 0; 

Jei taip yra, apatinė riba -1 reiškia, kad mes esame -1 iki pradžios, imtinai, o viršutinė riba yra ilgis, atėmus 1, tai yra, mes pradedame nuo pabaigos. (Atkreipkite dėmesį, kad šio -1 semantika skiriasi nuo -1 kad vartotojai gali perduoti indeksus Pythone su paskutiniu nurodytu elementu.)

 if (step_is_negative) { lower = PyLong_FromLong(-1L); if (lower == NULL) goto error; upper = PyNumber_Add(length, lower); if (upper == NULL) goto error; } 

Priešingu atveju step teigiamas, o apatinė riba bus lygi nuliui, o viršutinė riba (prie kurios mes einame, bet neįtraukiame) smulkinto sąrašo ilgio.

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

Tada mums gali tekti taikyti numatytasis start ir stop reikšmes - numatytoji start apskaičiuojama kaip viršutinė riba, kai step neigiamas:

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

ir stop , apatinė riba:

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

Suteikite savo fragmentams aprašomąjį pavadinimą!

Jums gali būti naudinga atskirti gabalėlių formavimą nuo jo perkėlimo į list.__getitem__ metodas ( ką daro kvadratiniai skliaustai ). Net jei nesate to naujas, jis saugo jūsų kodą, kad kiti, kurie galėtų skaityti jūsų kodą, galėtų lengviau suprasti, ką darote.

Tačiau jūs negalite tiesiog priskirti kintamųjų sveikųjų skaičių, atskirtų dvitaškiais. Turite naudoti pjūvio objektą:

 last_nine_slice = slice(-9, None) 

Antrasis argumentas yra None , todėl pirmasis argumentas aiškinamas kaip start argumentas, kitaip jis bus stop argumentas .

Tada galite perkelti objektą į sekciją savo seka:

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

Įdomu tai, kad diapazonai taip pat užima bitus:

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

Atminties problemos:

Kadangi Python sąrašų fragmentai atmintyje sukuria naujus objektus, kita svarbi funkcija, kurią reikia žinoti, yra itertools.islice . Paprastai norite kartoti per fragmentą, o ne tik statiškai ją sukurti atmintyje. islice puikiai tinka tai. Atsargiai, jis nepalaiko neigiamų argumentų dėl start , stop ar step , todėl, jei tai yra problema, jums gali tekti apskaičiuoti indeksus arba apversti elementą, kuris bus kartojamas iš anksto.

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

ir dabar:

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

Tai, kad fragmentų sąrašas sukuria kopiją, yra pačių sąrašų bruožas. Jei iškirsite pažangius objektus, pvz., „Pandas DataFrame“, jis gali grąžinti vaizdą į originalą, o ne į kopiją.

210
12 июля '14 в 16:19 2014-07-12 16:19 atsakymą pateikė Aarono salė liepos 12 d. 14, 16:19 2014-07-12 16:19

Ir keletas dalykų, kurie man nebuvo akivaizdūs, kai pirmą kartą pamačiau supjaustytą sintaksę:

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

Lengvas būdas keisti sekas!

O jei norite dėl kokios nors priežasties, kiekvienas antras elementas yra atvirkštine tvarka:

 >>> x = [1,2,3,4,5,6] >>> x[::-2] [6,4,2] 
126
04 февр. Atsakymas duotas Dana 04 vasaris. 2009-02-04 02:15 '09, 2:15 am. 2009-02-04 02:15

„Python“ 2.7

Python pjaustymas

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

Labai svarbu suprasti indekso tikslą.

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

Pasakydami [a: b: c], jūs sakote, priklausomai nuo c ženklo (pirmyn arba atgal), pradedant nuo a ir baigiant b (išskyrus bth indekso elementą). Naudokite aukščiau pateiktą indeksavimo taisyklę ir nepamirškite, kad rasite tik šio intervalo elementus:

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

Tačiau šis intervalas neribotą laiką tęsiasi abiem kryptimis:

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

Pavyzdžiui:

  0 1 2 3 4 5 6 7 8 9 10 11 astring -9 -8 -7 -6 -5 -4 -3 -2 -1 

Jei jūsų pasirinktys a, b ir c leidžia jums persidengti su aukščiau esančiu diapazonu, kai pereinate prie aukščiau pateiktų a, b, c taisyklių, galite gauti sąrašą su elementais (paveikė nuskaitymas), arba gaunate tuščią sąrašą.

Paskutinis: jei a ir b yra lygūs, taip pat gausite tuščią sąrašą:

 >>> 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] 
88
22 окт. atsakymas pateikiamas abc 22 okt. 2012-10-22 08:33 '12 at 8:33 2012-10-22 08:33

Po tam tikro naudojimo aš suprantu, kad paprasčiausias aprašymas yra tas pats, kaip argumentai „ for loop“ ...

 (from:to:step) 

Bet kuris iš jų yra neprivalomas:

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

Tada neigiamam indeksavimui reikia tiesiog pridėti eilutės ilgį į neigiamus indeksus, kad išsiaiškintumėte.

Bet kokiu atveju jis veikia man ...

49
19 февр. Simono atsakymas, pateiktas vasario 19 d. 2009-02-19 23:52 '09 at 11:52 AM 2009-02-19 23:52

Man lengviau prisiminti, kaip tai veikia, ir tada galiu nustatyti bet kokį konkretų starto / sustabdymo / žingsnio derinį.

Pirmiausia reikia suprasti range() :

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

Pradėkite nuo start , žingsnis po step , nepasiekite stop . Labai paprasta.

Reikėtų prisiminti neigiamą žingsnį, kad stop visada yra išimtis, nepriklausomai nuo to, ar jis yra didesnis ar mažesnis. Jei norite, kad ta pati gabalas būtų priešinga tvarka, inversiją yra daug lengviau atlikti atskirai: pvz., 'abcde'[1:-2][::-1] perkelia vieną ženklą į kairę, du - į dešinę ir invertuoja. (Žr. Taip pat reversed() .)

Sekos seka yra tokia pati, išskyrus tai, kad ji pirmą kartą normalizuoja neigiamus indeksus ir niekada neviršija sekos:

TODO : Toliau pateiktame kode, „abs“ (žingsnis)> 1, įvyko „niekada neviršyti sekos“ klaidos; Manau, kad ją pataisiau, kad būtų teisinga, tačiau sunku suprasti.

 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] 

Nesijaudinkite dėl detalių is None - tiesiog nepamirškite, kad praleidžiant start ir (arba) stop visada teisingai, kad suteiktumėte jums visą seką.

Neigiamų indeksų normalizavimas leidžia jums savarankiškai pradėti ir (arba) sustoti nuo pabaigos: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc' nepaisant range(1,-2) == [] . Normalizavimas kartais laikomas „modulio ilgiu“, tačiau atkreipkite dėmesį, kad jis prideda ilgį tik vieną kartą: pavyzdžiui, 'abcde'[-53:42] yra tik visa eilutė.

34
29 марта '12 в 13:15 2012-03-29 13:15 Atsakymą pateikė Beni Cherniavsky-Paskin kovo 12 d., 13:15 2012-03-29 13:15

Naudoju „žymeklio taškus tarp elementų“ metodą, galvoju apie tai, bet vienas iš būdų jį apibūdinti, kuris kartais padeda kitiems jį gauti, yra:

 mylist[X:Y] 

X yra pirmojo norimo elemento indeksas. Y yra pirmojo elemento, kurio jums nereikia, indeksas.

31
07 февр. Atsakymą pateikė Steve Losh 07 vasaris 2009-02-07 00:16 '09 ne 0:16 2009-02-07 00:16
 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 : |---------------> <---------------| 

Tikimės, kad tai padės jums modeluoti Python sąrašą.

Nuoroda: http://wiki.python.org/moin/MovingToPythonFromOther>

04 февр. atsakymas pateikiamas xiaoyu 04 vasaris. 2013-02-04 10:20 '13, 10:20, 2013-02-04 10:20

Python Cut žymėjimas:

 a[start:end:step] 
  • start ir end neigiamos reikšmės aiškinamos kaip susijusios su sekos pabaiga.
  • Teigiami indekso rodikliai rodo padėtį po paskutinio elemento įtraukimo.
  • Nulinės vertės nevykdomos taip: [+0:-0:1] .
  • Naudojant neigiamą žingsnį viršijama start ir end interpretacija

Pavadinimas taikomas (numpy) matricoms ir daugiamatėms matricoms. Pvz., Norėdami sumažinti visą stulpelį, galite naudoti:

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

Lieka laikyti nuorodas, o ne masyvo elementų kopijas. Jei norite sukurti atskirą masyvo kopiją, galite naudoti deepcopy() .

28
28 апр. atsakymas pateikiamas nobar 28 Bal 2013-04-28 22:49 '13, 10:49 PM 2013-04-28 22:49

Štai kaip aš mokau naujokai:

Suprasti skirtumus tarp indeksavimo ir pjovimo: