Dilim g├Âsterimini anlama


Al─▒nan cevaba git


Python'un dilim notasyonu hakk─▒nda iyi bir a├ž─▒klamaya (referanslar art─▒).

Bana g├Âre, bu g├Âsterim biraz toparlanma gerektiriyor.

Son derece g├╝├žl├╝ g├Âr├╝n├╝yor, ama ba┼č─▒m─▒n etraf─▒nda pek bir ┼čey yok.


2969









Cevap say─▒s─▒n─▒ say: 30






Ger├žekten ├žok basit:

 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
 

step Yukar─▒dakilerin herhangi biriyle kullan─▒labilecek bir de─čer de vard─▒r :

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

Hat─▒rlanmas─▒ gereken kilit nokta, :stop de─čerin se├žilen dilimde olmayan ilk de─čeri temsil etti─čidir. Bu nedenle, aras─▒ndaki fark stop ve start (e─čer se├žilen elemanlar─▒n─▒n say─▒s─▒ step 1, varsay─▒lan).

Di─čer bir ├Âzellik de bu start ya stop da negatif bir say─▒ olabilir; bu, ba┼člang─▒├ž ÔÇőÔÇőyerine dizinin sonundan say─▒ld─▒─č─▒ anlam─▒na gelir. Yani:

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

Benzer ┼čekilde, step negatif bir say─▒ olabilir:

 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, istedi─činden daha az ├Â─če varsa, programc─▒ya kibar davran─▒r. ├ľrne─čin, yaln─▒zca bir ├Â─če istiyor a[:-2] ve a i├žeriyorsan─▒z, hata yerine bo┼č bir liste al─▒rs─▒n─▒z. Bazen hatay─▒ tercih edersiniz, bu y├╝zden bunun olabilece─činin fark─▒nda olmal─▒s─▒n─▒z.

slice() Nesne ile ili┼čkisi

Dilimleme operat├Âr├╝ [] , yukar─▒daki kodda slice() , : notasyonu kullanan bir nesneyle (sadece i├žinde ge├žerlidir [] ) kullan─▒l─▒r, yani:

 a[start:stop:step]
 

e┼čittir:

 a[slice(start, stop, step)]
 

Dilim nesneleri ayr─▒ca, arg├╝man say─▒s─▒na ba─čl─▒ olarak range() , yani her ikisine de benzer ┼čekilde , biraz farkl─▒ ┼čekilde davran─▒r slice(stop) ve slice(start, stop[, step]) desteklenir. Belirli bir arg├╝man belirtmeyi atlamak i├žin, biri kullanabilir None , ├Ârne─čin a[start:] e┼čde─čer a[slice(start, None)] veya a[::-1] e┼čde─čerdir a[slice(None, None, -1)] .

: Temel notasyon basit dilimleme i├žin ├žok faydal─▒ olsa da , slice() nesnelerin a├ž─▒k├ža kullan─▒lmas─▒ programatik dilimleme ├╝retimini kolayla┼čt─▒rmaktad─▒r.


4027







Python ├Â─čretici bu konuda g├Âr├╝┼čmeler (biraz a┼ča─č─▒ kayd─▒rma sen dilimleme ilgili k─▒sma elde edene kadar).

ASCII sanat ┼čemas─▒, dilimlerin nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ hat─▒rlamak i├žin de yararl─▒d─▒r:

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

Dilimler ├žal─▒┼čma i┼čaret olarak endeksleri d├╝┼č├╝nmek i├žin ne kadar hat─▒rlamak bir yolu aras─▒ndaki ilk karakterin sol kenar─▒ ile, karakterlerin Sonra bir dizenin son karakterinin sa─č kenar─▒ 0'a say─▒l─▒ n karakterleri dizini vard─▒r n .


509







Dilbilgisi taraf─▒ndan izin verilen olas─▒l─▒klar─▒ saymak:

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

Tabii ki, e─čer (high-low)%stride != 0 ├Âyleyse, biti┼č noktas─▒ biraz daha d├╝┼č├╝k olacakt─▒r high-1 .

E─čer stride negatifse, sipari┼č biraz de─či┼čti beri a┼ča─č─▒ bizler sayma:

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

Geni┼čletilmi┼č dilimleme (virg├╝l ve elipslerle) ├žo─čunlukla yaln─▒zca ├Âzel veri yap─▒lar─▒ (NumPy gibi) taraf─▒ndan kullan─▒l─▒r; temel diziler onlar─▒ desteklemiyor.

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

391







Yukar─▒daki cevaplar dilim atamas─▒n─▒ tart─▒┼čmaz. Dilim atamas─▒n─▒ anlamak i├žin, ASCII sanat─▒na ba┼čka bir konsept eklemek yararl─▒ olacakt─▒r:

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

Sezgisellerden biri, s─▒f─▒rdan n'ye kadar olan bir dilim i├žin ┼čunu d├╝┼č├╝n├╝n: "S─▒f─▒r ba┼člang─▒├ž, ba┼člang─▒├žtan ba┼čla ve listedeki n maddeyi al".

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

Ba┼čka bir sezgisel, "herhangi bir dilim i├žin, ba┼člang─▒c─▒ s─▒f─▒ra de─či┼čtir, listenin sonunu almak i├žin ├Ânceki sezgisel ba┼čvuruyu uygula, sonra ilk say─▒y─▒ ba┼čtan kesmek i├žin geri say"

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

Dilim ├Âdevin ilk kural─▒ dilimleme beri olmas─▒d─▒r d├Ând├╝ren bir liste, dilim atama gerektirir bir liste (veya ba┼čka 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 "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
 

Yukar─▒da da g├Ârebilece─činiz ikinci dilim tahsisi kural─▒, listenin hangi k─▒sm─▒n─▒n dilim endekslemesi ile d├Ând├╝r├╝ld├╝─č├╝d├╝r, dilim tahsisi taraf─▒ndan de─či┼čtirilen ayn─▒ k─▒s─▒md─▒r:

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

Dilim atamas─▒n─▒n ├╝├ž├╝nc├╝ kural─▒, atanan listenin (yinelenebilir) ayn─▒ uzunlukta olmas─▒ gerekmez; Dizine al─▒nm─▒┼č dilim, basit├že dilimlenir ve atan─▒rsa toplu olarak de─či┼čtirilir:

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

Al─▒┼č─▒lacak en zor k─▒s─▒m bo┼č dilimlere atama. Sezgisel 1 ve 2'yi kullanarak, kafan─▒z─▒ bo┼č bir dilimi indeksleyerek dola┼čt─▒rmak kolayd─▒r :

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

Ve bir kere bunu g├Ârd├╝kten sonra, bo┼č dilime dilim atamas─▒ da mant─▒kl─▒ geliyor:

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

Dilimin ikinci say─▒s─▒n─▒ (4) de─či┼čtirmedi─čimizden, eklenen ├Â─čelerin bo┼č dilime atayken bile her zaman 'o' ├╝zerine istiflendi─čini unutmay─▒n. Bu nedenle, bo┼č dilim atamas─▒n─▒n konumu, bo┼č olmayan dilim atamalar─▒ i├žin konumlar─▒n mant─▒ksal uzant─▒s─▒d─▒r.

Bir miktar yedekleme, dilimin ba┼člang─▒c─▒n─▒ sayma alay─▒m─▒za devam edersek ne olur?

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

Dilimleme ile i┼činiz bitti─činde i┼činiz biter; geriye do─čru dilimlemeye ba┼člamaz. Python'da, negatif bir say─▒ kullanarak a├ž─▒k├ža istemedi─činiz s├╝rece, olumsuz ad─▒mlar alamazs─▒n─▒z.

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

"Bir kez bitti─činde, bitirdin" kural─▒ i├žin garip sonu├žlar var:

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

Asl─▒nda, endekslemeye k─▒yasla, Python dilimleme tuhaf bir ┼čekilde hatas─▒zd─▒r:

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

Bu bazen i┼če yarayabilir, ancak biraz garip davran─▒┼člara da yol a├žabilir:

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

Ba┼čvurunuza ba─čl─▒ olarak, orada umdu─čun ┼čey ... olabilir veya olmayabilir ...!


Orijinal cevab─▒m─▒n metni a┼ča─č─▒dad─▒r. Bir├žok insan i├žin faydal─▒ oldu, bu y├╝zden silmek istemedim.

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

Bu ayn─▒ zamanda dilimleme ve indeksleme aras─▒ndaki fark─▒ netle┼čtirebilir.


291







Python'un dilim g├Âsterimini a├ž─▒klay─▒n

K─▒saca, iki nokta ( : simge g├Âsterimde) ( subscriptable[subscriptarg] ) yapmak dilim notasyonu - iste─če ba─čl─▒ ba─č─▒ms─▒z de─či┼čkenler, start , stop , step :

 sliceable[start:stop:step]
 

Python dilimleme, verilerinizin b├Âl├╝mlerine d├╝zenli olarak eri┼čmenin hesaplama a├ž─▒s─▒ndan h─▒zl─▒ bir yoludur. Bence orta seviye bir Python programc─▒s─▒ olmak bile, a┼čina olmas─▒ gereken dilin bir y├Ân├╝.

├ľnemli tan─▒mlar

Ba┼člamak i├žin birka├ž terim tan─▒mlayal─▒m:

start: dilimin ba┼člang─▒├ž ÔÇőÔÇődizini, durdurma ile ayn─▒ olmad─▒k├ža , ilk de─čer olarak varsay─▒lan olmad─▒k├ža, bu dizindeki ├Â─čeyi i├žerecektir . Negatifse, n ├Â─čeleri ba┼čtan ba┼člatmak demektir .

Dur: dilimin biti┼č endeksi, bu yok de─čil , dizinin uzunlu─ču varsay─▒lan kadar oldu─čunu, dilimlenmi┼č ve sonunu da dahil olmak bu endeksi de eleman bulunmaktad─▒r.

ad─▒m: endeksin art─▒r─▒ld─▒─č─▒ miktar, varsay─▒lan olarak 1 olur. Negatifse, yinelemenin tersini kesersiniz.

─░ndeksleme Nas─▒l ├çal─▒┼č─▒r?

Bu pozitif veya negatif say─▒lardan herhangi birini yapabilirsiniz. Pozitif say─▒lar anlam─▒ basittir, ancak negatif say─▒lar i├žin, sadece Python endeksler gibi, sizin i├žin ucundan geriye do─čru saymak ba┼člang─▒c─▒nda ve durdurmak ve i├žin ad─▒m , sadece Endeksinizi azaltma. Bu ├Ârnek belgelerin ├Â─čreticisinden al─▒nm─▒┼čt─▒r , ancak dizindeki her ├Â─čenin hangi dizinde ba┼čvuruda bulundu─čunu belirtmek i├žin hafif├že de─či┼čtirdim:

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

Dilimleme Nas─▒l ├çal─▒┼č─▒r?

Dilim g├Âsterimini, onu destekleyen bir diziyle kullanmak i├žin diziyi takip eden k├Â┼čeli parantezlere ( Python veri modeline g├Âre dizinin y├Ântemini ger├žekten uygulayan __getitem__ k├Â┼čeli parantez) eklemelisiniz .

Dilim notasyonu ┼ču ┼čekilde ├žal─▒┼č─▒r:

 sequence[start:stop:step]
 

Ve ba┼člang─▒├ž , durma ve ad─▒m i├žin varsay─▒lanlar oldu─čunu hat─▒rlay─▒n , b├Âylece varsay─▒lanlara eri┼čmek i├žin arg├╝man─▒ d─▒┼čar─▒da b─▒rak─▒n.

Bir listeden son dokuz ├Â─čeyi (veya onu destekleyen herhangi bir diziden dize gibi) almak i├žin g├Âsterimi bu ┼čekilde yap─▒n:

 my_list[-9:]
 

Bunu g├Ârd├╝─č├╝mde, parantezdeki par├žay─▒ "u├žtan uca 9." olarak okudum. (Asl─▒nda, zihinsel olarak "-9, on" olarak k─▒salt─▒r─▒m)

A├ž─▒klama:

Tam g├Âsterim

 my_list[-9:None:None]
 

ve varsay─▒lanlar─▒ de─či┼čtirmek (asl─▒nda step negatif oldu─čunda , stop varsay─▒lan─▒d─▒r -len(my_list) - 1 , bu nedenle None durma i├žin ger├žekten sadece hangi son ad─▒m─▒n at─▒laca─č─▒ anlam─▒na gelir):

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

Kolon , : , bunu bir dilim de─čil d├╝zenli endeksi veriyoruz Python s├Âyler budur. Bu y├╝zden Python 2'deki listelerin s─▒─č bir kopyas─▒n─▒ alman─▒n aptalca yolu

 list_copy = sequence[:]
 

Ve onlar─▒ temizlemek:

 del my_list[:]
 

(Python 3 a list.copy ve list.clear y├Ântemini al─▒r .)

Ne zaman step negatif i├žin varsay─▒lan oldu─čunu start ve stop de─či┼čim

Varsay─▒lan olarak, step ba─č─▒ms─▒z de─či┼čken bo┼č oldu─čunda (veya None ), atan─▒r +1 .

Ancak, negatif bir tamsay─▒ ge├žirebilirsiniz ve liste (veya di─čer bir├žok standart dilimlenebilir) ba┼čtan ba┼ča dilimlenir.

B├Âylece negatif bir dilim start ve i├žin varsay─▒lanlar─▒ de─či┼čtirir stop !

Bunu kayna─č─▒nda onaylama

Kullan─▒c─▒lar─▒, kaynaklar─▒n yan─▒ s─▒ra belgeleri de okumalar─▒n─▒ te┼čvik ediyorum. Dilim i├žin kaynak kodu nesneleri ve bu mant─▒k burada bulunur . ─░lk ├Ânce step negatif olup olmad─▒─č─▒na karar veririz :

  step_is_negative = step_sign < 0;
 

E─čer ├Âyleyse, alt s─▒n─▒r, -1 ba┼člang─▒c─▒ da dahil olmak ├╝zere tamamen dilimlememiz anlam─▒na gelir ve ├╝st s─▒n─▒r, sonunda ba┼člad─▒─č─▒m─▒z anlam─▒na gelen uzunluk eksi 1'dir. (Not Bunun semantik yani -1 olan farkl─▒ bir gelen -1 kullan─▒c─▒lar─▒n son ├Â─čeyi g├Âsteren Python endeksler ge├žmesi olabilir.)

 if (step_is_negative) {
    lower = PyLong_FromLong(-1L);
    if (lower == NULL)
        goto error;

    upper = PyNumber_Add(length, lower);
    if (upper == NULL)
        goto error;
}
 

Aksi taktirde step pozitif olur ve alt s─▒n─▒r s─▒f─▒r olur ve ├╝st s─▒n─▒r dilimlenmi┼č listenin uzunlu─čunu (biz dahil ederiz (buna dahil de─čil) gideriz.

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

Sonra, start ve i├žin varsay─▒lanlar─▒ uygulamam─▒z gerekebilir stop - - i├žin varsay─▒lan , negatif start oldu─čunda ├╝st s─▒n─▒r olarak hesaplan─▒r step :

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

ve stop alt s─▒n─▒r:

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

Dilimlerinize a├ž─▒klay─▒c─▒ bir isim verin!

Dilimi olu┼čturman─▒n onu list.__getitem__ y├Ânteme ge├žirmesini ay─▒rmak i├žin yararl─▒ olabilir ( k├Â┼čeli parantezlerin yapt─▒─č─▒ budur ). Yeni olmasan─▒z bile, kodunuzu daha okunakl─▒ tutar, b├Âylece kodunuzu okumak zorunda kalabilecek di─čer ki┼čiler ne yapt─▒─č─▒n─▒z─▒ daha kolay anlayabilir.

Ancak, yaln─▒zca bir de─či┼čkene virg├╝lle ayr─▒lm─▒┼č baz─▒ tamsay─▒lar─▒ atayamazs─▒n─▒z. Dilim nesnesini kullanman─▒z gerekir:

 last_nine_slice = slice(-9, None)
 

─░kinci ba─č─▒ms─▒z de─či┼čken, None ilk de─či┼čken olarak yorumlan─▒r, b├Âylece, gerekli olan start de─či┼čken , aksi olurdu stop arg├╝man .

Daha sonra dilim nesnesini dizinize ge├žirebilirsiniz:

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

Aral─▒klar─▒n da dilimler almas─▒ ilgin├žtir:

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

Haf─▒za ile ilgili ├Ânemli noktalar:

Python listelerinin dilimleri bellekte yeni nesneler olu┼čturdu─čundan, dikkat edilmesi gereken bir ba┼čka ├Ânemli i┼člev de ┼čudur itertools.islice . Genellikle, sadece bellekte statik olarak olu┼čturmas─▒n─▒ sa─člamakla kalmaz, bir dilim ├╝zerinde yineleme yapmak istersiniz. islice bunun i├žin m├╝kemmel. Bir yetersizlik, bu olumsuz arg├╝manlar desteklemez start , stop veya step , bu bir sorun yani e─čer endekslerini hesaplamak veya ├Ânceden iterable ters gerekebilir.

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

ve ┼čimdi:

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

Liste dilimlerinin bir kopyas─▒n─▒ olu┼čturmas─▒, listelerin bir ├Âzelli─čidir. Bir Pandas DataFrame gibi geli┼čmi┼č nesneleri dilimliyorsan─▒z, bir kopyas─▒n─▒ de─čil orijinali g├Âr├╝nt├╝leyebilir.


236







Ve dilimleme s├Âzdizimini ilk g├Ârd├╝─č├╝mde hemen belli olmayan ┼čeyler:

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

Dizileri ters ├ževirmenin kolay yolu!

Ve e─čer bir nedenden ├Ât├╝r├╝, her ikinci ├Â─čenin tersine s─▒rayla dizilmesini istiyorsan─▒z:

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

140


2009-02-03





Python 2.7ÔÇÖde

Python'da Dilimleme

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

Dizin atamas─▒n─▒ anlamak ├žok ├Ânemlidir.

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

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

[A: b: c] derken, c i┼čaretine (ileri veya geri) ba─čl─▒ olarak, a ile ba┼člay─▒p b'de (bth indeksindeki eleman hari├ž) diyorsunuz. Yukar─▒daki indeksleme kural─▒n─▒ kullan─▒n ve yaln─▒zca bu aral─▒ktaki ├Â─čeleri bulaca─č─▒n─▒z─▒ unutmay─▒n:

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

Ancak bu aral─▒k her iki y├Ânde de s├╝rekli devam eder:

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

├ľrne─čin:

              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
 

A, b ve c se├žiminiz, yukar─▒daki a, b, c kurallar─▒n─▒ kullanarak ge├ži┼č yaparken yukar─▒daki aral─▒kla ├Ârt├╝┼čmeye izin verirse, ya ├Â─čeler aras─▒nda bir liste (ge├ži┼č s─▒ras─▒nda dokundu) ya da bo┼č bir liste al─▒rs─▒n─▒z.

Son bir ┼čey: e─čer a ve b e┼čitse, o zaman bo┼č bir liste al─▒rs─▒n─▒z:

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

95







Bu harika masay─▒ http://wiki.python.org/moin/MovingToPythonFromOtherLanguages adresinde bulabilirsiniz.

 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) 

92







Biraz kulland─▒ktan sonra, en basit tan─▒mlaman─▒n tam olarak bir for d├Âng├╝deki arg├╝manlarla ayn─▒ oldu─čunu anlad─▒m ...

 (from:to:step)
 

Bunlardan herhangi biri iste─če ba─čl─▒d─▒r:

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

Daha sonra, negatif indeksleme, dizenin uzunlu─čunu anlamak i├žin negatif endekslere eklemenizi gerektirir.

Bu zaten benim i├žin ├žal─▒┼č─▒yor ...


60







Nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ hat─▒rlamay─▒ daha kolay buluyorum ve daha sonra herhangi bir ├Âzel ba┼člat / durdur / ad─▒m kombinasyonunu ├ž├Âzebiliyorum.

range() ├ľnce bunu anlaman─▒z ├Â─čreticidir :

 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
 

Ba┼člang─▒├žtan itibaren start , art─▒┼čla step ula┼čmay─▒n stop . ├çok basit.

Olumsuz ad─▒mla ilgili hat─▒rlanmas─▒ gereken ┼čey stop , ister y├╝ksek ister d├╝┼č├╝k olsun, daima d─▒┼članan sondur. Ayn─▒ dilimi ters s─▒rayla istiyorsan─▒z tersine ├ževirmeyi ayr─▒ ayr─▒ yapmak daha kolayd─▒r: ├Ârn. 'abcde'[1:-2][::-1] Bir k├Âm├╝r├╝ sola, iki sa─ča, sonra tersine ├ževirir. (Ayr─▒ca bak─▒n─▒z reversed() .)

S─▒ra dilimleme ayn─▒d─▒r, ilk ├Ânce negatif dizinleri normalle┼čtirir ve dizinin d─▒┼č─▒na asla ├ž─▒kamaz:

TODO : A┼ča─č─▒daki kod, abs (step)> 1; Ben d├╝┼č├╝n├╝yorum ben do─čru gibi yamal─▒ ama anlamak zordur.

 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]
 

is None Ayr─▒nt─▒lar hakk─▒nda endi┼čelenmeyin - sadece t├╝m s─▒ray─▒ vermek i├žin her zaman do─čru olan─▒ atlaman─▒n start ve / veya stop her zaman do─čru olan─▒ yapt─▒─č─▒n─▒z─▒ unutmay─▒n.

Negatif endeksleri normalle┼čtirmek ilk ├Ânce ba┼člang─▒├ž ÔÇőÔÇőve / veya durdurman─▒n ba─č─▒ms─▒z olarak say─▒lmas─▒n─▒ sa─člar: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc' buna ra─čmen range(1,-2) == [] . Normalle┼čtirme bazen "uzunluk mod├╝l├╝" olarak d├╝┼č├╝n├╝l├╝r, ancak sadece bir kez uzunlu─ču ekledi─čine dikkat edin: ├Ârne─čin 'abcde'[-53:42] , sadece t├╝m dizgedir.


47







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

Umar─▒m bu, listeyi Python'da modellemenize yard─▒mc─▒ olur.

Referans: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages


37







"├ľ─čeler aras─▒nda bir indeks noktalar─▒" y├Ântemini kendim hakk─▒nda d├╝┼č├╝nme y├Ântemini kullan─▒yorum, ancak bazen ba┼čkalar─▒n─▒n anlamas─▒na yard─▒mc─▒ olan onu tarif etmenin bir yolu:

 mylist[X:Y]
 

X, istedi─činiz ilk ├Â─čenin dizinidir.
Y ilk eleman─▒n endeksidir yok istiyorum.


36







Python dilimleme notasyonu:

 a[start:end:step]
 
  • ─░├žin start ve end negatif de─čerler dizisinin sonuna g├Âre olarak yorumlan─▒r.
  • Pozitif endeksler, dahil edilecek son elementten sonraki end pozisyonu g├Âsterir .
  • ┼×├Âyle Bo┼č de─čerler varsay─▒lan gibidir: [+0:-0:1] .
  • Olumsuz bir ad─▒m kullanmak, yorumunu de─či┼čtirir start ve end

─░┼čaret, (nemli) matrislere ve ├žok boyutlu dizilere uzan─▒r. ├ľrne─čin, s├╝tunlar─▒n tamam─▒n─▒ dilimlemek i├žin kullanabilirsiniz:

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

Dilimler, dizi ├Â─čelerinin kopyalar─▒n─▒ de─čil referanslar─▒n─▒ tutar. Bir diziyi ayr─▒ bir kopyalamak istiyorsan─▒z, kullanabilirsiniz deepcopy() .


35







Bir veya daha fazla ├Â─čeyi listeden kald─▒rmak i├žin dilim atamas─▒n─▒ da kullanabilirsiniz:

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

32







Bu ┼čekilde dilimleri yenilere ├Â─čretirim:

─░ndeksleme ve dilimleme aras─▒ndaki fark─▒ anlamak:

Wiki Python, indeksleme ve dilimlemeyi a├ž─▒k├ža ay─▒ran bu muhte┼čem resme sahiptir.


Resim tan─▒m─▒n─▒ buraya girin

─░├žinde alt─▒ element bulunan bir liste. Dilimlemeyi daha iyi anlamak i├žin, bu listeyi bir araya getirilmi┼č alt─▒ kutudan olu┼čan bir grup olarak d├╝┼č├╝n├╝n. Her kutunun i├žinde bir alfabe vard─▒r.

Endeksleme, kutunun i├žeri─čiyle ilgilenmek gibidir. Herhangi bir kutunun i├žeri─čini kontrol edebilirsiniz. Ancak ayn─▒ anda birden fazla kutunun i├žeri─čini kontrol edemezsiniz. Kutunun i├žeri─čini bile de─či┼čtirebilirsiniz. Ancak iki topu bir kutuya yerle┼čtiremez veya ayn─▒ anda iki topu de─či┼čtiremezsiniz.

 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
 

Dilimleme, kutular─▒n kendisiyle u─čra┼čmak gibidir. ─░lk kutuyu al─▒p ba┼čka bir masaya yerle┼čtirebilirsiniz. Kutuyu almak i├žin tek bilmeniz gereken kutunun ba┼člang─▒├ž ÔÇőÔÇőve biti┼č konumu.

─░lk ├╝├ž kutuyu veya son iki kutuyu veya 1 ile 4 aras─▒ndaki t├╝m kutular─▒ bile alabilirsiniz. B├Âylece, ba┼člang─▒├ž ÔÇőÔÇőve biti┼č bilgilerini biliyorsan─▒z, herhangi bir kutu k├╝mesini se├žebilirsiniz. Bu pozisyonlara start ve stop pozisyonlar─▒ denir.

─░lgin├ž olan, bir kerede birden fazla kutuyu de─či┼čtirebilmeniz. Ayr─▒ca istedi─činiz yere birden fazla kutu yerle┼čtirebilirsiniz.

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

Ad─▒ml─▒ Dilimleme:

┼×imdiye kadar s├╝rekli olarak kutu toplad─▒n. Ama bazen iste─če ba─čl─▒ olarak toplanman gerekir. ├ľrne─čin, her ikinci kutuyu alabilirsiniz. Her ├╝├ž kutuyu da ba┼čtan alabilirsin. Bu de─čere ad─▒m boyutu denir. Bu, art arda gelen al─▒mlar─▒n─▒z aras─▒ndaki bo┼člu─ču temsil eder. Kutular─▒ ba┼čtan sona se├žiyorsan─▒z ad─▒m boyutu pozitif olmal─▒d─▒r, bunun tersi de ge├žerlidir.

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

Python Eksik Parametreleri Nas─▒l Belirler:

Dilimleme s─▒ras─▒nda herhangi bir parametreyi b─▒rak─▒rsan─▒z, Python otomatik olarak anlamaya ├žal─▒┼č─▒r.

E─čer kaynak kodunu kontrol ederse CPython , size herhangi bir parametre i├žin bir dilim endeksleri ├╝zerinden bir i┼člev ├ža─čr─▒ld─▒─č─▒nda PySlice_GetIndicesEx () rakamlar─▒ bulacaks─▒n─▒z. ─░┼čte Python'daki mant─▒ksal e┼čde─čer kod.

Bu i┼člev bir Python nesnesini ve dilimleme i├žin iste─če ba─čl─▒ parametreleri al─▒r ve istenen dilim i├žin start, stop, step ve dilim uzunlu─čunu d├Ând├╝r├╝r.

 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)
 

Dilimlerin arkas─▒nda bulunan zeka budur. Python'un dilim olarak adland─▒r─▒lan yerle┼čik bir i┼člevi oldu─čundan, baz─▒ parametreleri iletebilir ve eksik parametreleri nas─▒l ak─▒ll─▒ca hesaplad─▒─č─▒n─▒ kontrol edebilirsiniz.

 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: Bu yaz─▒ ilk olarak blogumda Python Dilimlerinin Arkas─▒ndaki ─░stihbarat olarak yaz─▒lm─▒┼čt─▒ .


32







Bu sadece baz─▒ ekstra bilgiler i├žin ... A┼ča─č─▒daki listeyi d├╝┼č├╝n├╝n

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

Listeyi tersine ├ževirmek i├žin birka├ž p├╝f noktas─▒:

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

31







Genel bir kural olarak, ├žok fazla kodlanm─▒┼č indeks de─čerine sahip kod yazmak, okunabilirlik ve bak─▒m kar─▒┼č─▒kl─▒─č─▒na yol a├žar. ├ľrne─čin, bir y─▒l sonra koda d├Ânerseniz, ona bakacak ve yazarken ne d├╝┼č├╝nd├╝─č├╝n├╝z├╝ merak edeceksiniz. G├Âsterilen ├ž├Âz├╝m, kodunuzun ger├žekte ne yapt─▒─č─▒n─▒ a├ž─▒k├ža belirtmenin bir yoludur. Genel olarak, yerle┼čik dilim () bir dilimin izin verildi─či herhangi bir yerde kullan─▒labilecek bir dilim nesnesi olu┼čturur. ├ľrne─čin:

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

Bir s dilim ├Ârne─čine sahipseniz, s─▒ras─▒yla s.start, s.stop ve s.step niteliklerine bakarak bu konuda daha fazla bilgi edinebilirsiniz. ├ľrne─čin:

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

27







1. Dilim Notasyonu

Basitle┼čtirmek i├žin dilimin yaln─▒zca bir ┼čekli oldu─čunu unutmay─▒n.

 s[start:end:step]
 

ve i┼čte nas─▒l ├žal─▒┼čt─▒─č─▒:

  • s : dilimlenebilen bir nesne
  • start : yinelemeyi ba┼člatan ilk dizin
  • end : endeks endeksi, endeksin sonu├žtaki dilime dahil edilmeyece─čini NOT end
  • step : her step indeks ├Â─česini se├ž

Ba┼čka ithalat ┼čey: hepsi start , end , step atlanabilir! Onlar atlanm─▒┼čt─▒r e─čer, varsay─▒lan de─čer kullan─▒lan olacakt─▒r: 0 , len(s) , 1 buna g├Âre.

Bu y├╝zden olas─▒ de─či┼čiklikler:

 # 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: E─čer start >= end (sadece ne zaman d├╝┼č├╝n├╝l├╝rse step>0 ), Python bo┼č bir dilim d├Ând├╝r├╝r [] .

2. Tuzaklar

Yukar─▒daki b├Âl├╝m, dilimin nas─▒l ├žal─▒┼čt─▒─č─▒yla ilgili temel ├Âzellikleri a├ž─▒klar ve ├žo─ču zaman da i┼če yarayacakt─▒r. Ancak, dikkat etmeniz gereken tuzaklar olabilir ve bu b├Âl├╝m onlar─▒ a├ž─▒klar.

Negatif endeksler

Python ├Â─črenicilerini ┼ča┼č─▒rtan ilk ┼čey, bir endeksin negatif olabilece─či! Panik yapmay─▒n: negatif bir indeks geriye saymak anlam─▒na gelir.

├ľrne─čin:

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

Olumsuz ad─▒m

─░┼čleri daha kafa kar─▒┼čt─▒r─▒c─▒ yapmak step da olumsuz olabilir!

Negatif bir ad─▒m, diziyi geriye do─čru yineleme anlam─▒na gelir: ba┼čtan sona, son dizini dahil ederek ve ba┼člang─▒├ž ÔÇőÔÇődizini sonu├žtan hari├ž tutulur.

NOT : ad─▒m negatif oldu─čunda, varsay─▒lan de─čeri start ┼čudur len(s) (buna end e┼čit de─čildir 0 , ├ž├╝nk├╝ s[::-1] i├žerir s[0] ). ├ľrne─čin:

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

Aral─▒k d─▒┼č─▒ hata?

┼×a┼č─▒rmay─▒n: endeksi aral─▒k d─▒┼č─▒nda oldu─čunda dilim bir IndexError zam yok!

Dizin aral─▒k d─▒┼č─▒ndaysa, Python, dizini duruma g├Âre 0 veya len(s) duruma g├Âre ayarlamak i├žin elinden geleni yapacakt─▒r . ├ľrne─čin:

 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. ├ľrnekler

Bu cevab─▒ ├Ârneklerle bitirelim, tart─▒┼čt─▒─č─▒m─▒z her ┼čeyi a├ž─▒klayal─▒m:

 # 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)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range
 

26







├ľnceki cevaplar, ├╝nl├╝ NumPy paketini kullanarak m├╝mk├╝n olan ├žok boyutlu dizi dilimlemeyi tart─▒┼čm─▒yor :

Dilimleme ayr─▒ca ├žok boyutlu dizilere de uygulanabilir.

 # 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 Virg├╝l ├Âncesi " " birinci boyutta 0:3:2 i┼člemektedir ve virg├╝l sonras─▒ " " ikinci boyutta i┼člemektedir.


22







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

Bu beti─či ├žal─▒┼čt─▒rabilir ve onunla deney yapabilirsiniz, a┼ča─č─▒da beti┼čten ald─▒─č─▒m baz─▒ ├Ârnekler verilmi┼čtir.

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

Negatif bir ad─▒m kullan─▒rken, cevab─▒n 1 ile sa─ča kayd─▒r─▒ld─▒─č─▒na dikkat edin.


14







Beynim, onu lst[start:end] i├žeren start maddeyi kabul etmekten mutlu g├Âr├╝n├╝yor . Bunun 'do─čal bir varsay─▒m' oldu─čunu bile s├Âyleyebilirim.

Ancak bazen bir ku┼čku duyulur ve beynim, onu- end elementi i├žermedi─čine dair g├╝vence ister .

Bu anlarda bu basit teoremi temel al─▒r─▒m:

 for any n,    lst = lst[:n] + lst[n:]
 

Bu g├╝zel ├Âzellik bana i├žinde lst[start:end] bulundu─čundan end -th maddeyi i├žermedi─čini s├Âyl├╝yor lst[end:] .

Bu teoremin n herkes i├žin ge├žerli oldu─čunu unutmay─▒n . ├ľrne─čin, bunu kontrol edebilirsiniz

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

d├Âner True .


14







├ľnceki cevaplar─▒n ├žo─ču dilim g├Âsterimi hakk─▒ndaki sorular─▒ temizler.

Dilimleme i├žin kullan─▒lan geni┼čletilmi┼č dizinleme s├Âzdizimi aList[start:stop:step] ve temel ├Ârnekler:


Resim tan─▒m─▒n─▒ buraya girin

:

Daha fazla dilimleme ├Ârne─či: 15 Geni┼čletilmi┼č Dilim


12







Python'da dilimleme i├žin en temel bi├žim ┼čudur:

 l[start:end]
 

l Baz─▒ koleksiyon nerede , start kapsay─▒c─▒ bir indeks ve end ├Âzel bir indeks.

 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]
 

Ba┼čtan itibaren dilimleme yaparken, s─▒f─▒r dizinini ├ž─▒kartabilirsiniz ve sonuna dilimleme yaparken, son dizini gereksiz oldu─čundan ihmal edebilirsiniz, bu nedenle ayr─▒nt─▒l─▒ olmay─▒n:

 In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True
 

Negatif tamsay─▒lar, koleksiyonun sonuna g├Âre ofsetler yaparken kullan─▒┼čl─▒d─▒r:

 In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]
 

Dilimleme yap─▒l─▒rken s─▒n─▒rlar─▒ a┼čmayan endeksler sa─člamak m├╝mk├╝nd├╝r:

 In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 

Bir koleksiyonun dilimleme sonucunun tamamen yeni bir koleksiyon oldu─čunu unutmay─▒n. Ayr─▒ca, atamalardaki dilim g├Âsterimi kullan─▒l─▒rken, dilim atamas─▒n─▒n uzunlu─ču ayn─▒ olmak zorunda de─čildir. Atanan dilimden ├Ânceki ve sonraki de─čerler korunur ve koleksiyon yeni de─čerleri i├žerecek ┼čekilde k├╝├ž├╝l├╝r veya b├╝y├╝r:

 In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]
 

Ba┼člang─▒├ž ÔÇőÔÇőve biti┼č endeksini ├ž─▒kar─▒rsan─▒z, koleksiyonun bir kopyas─▒n─▒ ├ž─▒kar─▒rs─▒n─▒z:

 In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True
 

Bir atama i┼člemi ger├žekle┼čtirilirken ba┼člang─▒├ž ÔÇőÔÇőve biti┼č dizinleri atlan─▒rsa, koleksiyonun i├žeri─či ba┼čvurulan─▒n bir kopyas─▒ ile de─či┼čtirilir:

 In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']
 

Temel dilimlemenin yan─▒ s─▒ra, a┼ča─č─▒daki notasyonu da uygulamak m├╝mk├╝nd├╝r:

 l[start:end:step]
 

Nerede l bir koleksiyon olan start kapsay─▒c─▒ endeksidir, end ├Âzel bir endeks olup, step her ├žekmek i├žin kullan─▒labilecek bir ad─▒m oldu─čunu n'inci ├Â─čeyi 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]
 

Kullan─▒m─▒ step Python bir koleksiyon tersine ├ževirmek i├žin yararl─▒ bir hile sa─člar:

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

step A┼ča─č─▒daki ├Ârnek olarak negatif tamsay─▒lar kullanmak da m├╝mk├╝nd├╝r :

 In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]
 

Ancak, i├žin negatif bir de─čer kullanmak step ├žok kafa kar─▒┼čt─▒r─▒c─▒ olabilir. ├ťstelik olabilmek i├žin Pythonic , sen kullanmaktan ka├ž─▒nmal─▒s─▒n─▒z start , end ve step tek bir dilim i├žinde. Bu gerekliyse, bunu iki atamada yapmay─▒ d├╝┼č├╝n├╝n (biri dilimleyin, di─čeri ise ad─▒m ad─▒m).

 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]
 

11







Bir tane Merhaba, D├╝nya eklemek istiyorum ! Yeni ba┼člayanlar i├žin dilimlerin temellerini a├ž─▒klayan bir ├Ârnek. Bana ├žok yard─▒mc─▒ oldu.

Alt─▒ de─čere sahip bir liste yapal─▒m ['P', 'Y', 'T', 'H', 'O', 'N'] :

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

┼×imdi bu listenin en basit dilimleri alt listeleri. G├Âsterim [<index>:<index>] ve anahtar bu ┼čekilde okumakt─▒r:

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

┼×imdi [2:5] yukar─▒daki listenin bir dilimini yaparsan─▒z , bu olur:

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

Bir kesim yap─▒lm─▒┼č ├Ânce indeksi ile eleman 2 ve ba┼čka kesim ├Âncesi indeksi eleman─▒ 5 . B├Âylece sonu├ž, bu iki kesim aras─▒nda bir dilim olacak, bir liste ['T', 'H', 'O'] .


10







A┼ča─č─▒da bir dizgenin indeksi ├Ârne─či verilmi┼čtir:

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

str="Name string"
 

Dilimleme ├Ârne─či: [ba┼člang─▒├ž: biti┼č: ad─▒m]

 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
 

├ľrnek kullan─▒m a┼ča─č─▒dad─▒r:

 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
 

9







Benim d├╝┼č├╝nceme g├Âre, e─čer ┼ču ┼čekilde bakarsan─▒z (okuma) Python string dilimleme g├Âsterimini daha iyi anlayacak ve ezberleyeceksiniz.

A┼ča─č─▒daki dizeyle ├žal─▒┼čal─▒m ...

 azString = "abcdefghijklmnopqrstuvwxyz"
 

Bilmeyenler azString i├žin, notasyonu kullanarak herhangi bir alt dize olu┼čturabilirsiniz. azString[x:y]

Di─čer programlama dillerinden gelince, sa─čduyulu taviz verildi─či zamand─▒r. X ve y nedir?

X ve y'nin ne oldu─čunu hat─▒rlamama yard─▒mc─▒ olacak ve ilk denemede d├╝zg├╝n bir ┼čekilde dilimleme yapmama yard─▒mc─▒ olacak bir ezberleme tekni─či aray─▒┼č─▒ma girip birka├ž senaryo y├╝r├╝tmek zorunda kald─▒m.

Benim sonucum, x ve y'nin, eklemek istedi─čimiz dizeleri ├ževreleyen s─▒n─▒r endeksleri olarak g├Âr├╝lmesi gerekti─čidir. Bu y├╝zden ifadeyi, oldu─ču gibi azString[index1, index2] veya daha net olarak g├Ârmeliyiz azString[index_of_first_character, index_after_the_last_character] .

─░┼čte bunun bir g├Ârselle┼čtirme ├Ârne─či ...

 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
 

Bu y├╝zden yapman─▒z gereken tek ┼čey index1 ve index2'yi istenen alt dize saracak de─čerlere ayarlamak. ├ľrne─čin, "cdefgh" alt dizgesini almak i├žin azString[2:8] , "c" nin sol taraf─▒ndaki indeks 2 ve "h" nin do─čru boyutundaki 8 oldu─ču i├žin kullanabilirsiniz.

S─▒n─▒rlar─▒ belirledi─čimizi unutmay─▒n. Ve bu s─▒n─▒rlar, altbant─▒n etraf─▒na sar─▒lacak baz─▒ parantezleri yerle┼čtirebilece─činiz konumlard─▒r ...

ab [ cdefgh ] ij

Bu numara her zaman i┼če yarar ve ezberlemek kolayd─▒r.


8







Dilimlemede negatif endekslerin kafa kar─▒┼čt─▒r─▒c─▒ oldu─čunu d├╝┼č├╝n├╝yorsan─▒z, i┼čte bunu d├╝┼č├╝nmenin ├žok kolay bir yolu: sadece negatif dizini ile de─či┼čtirin len - index . ├ľrne─čin, -3 ile de─či┼čtirin len(list) - 3 .

Dilimlemenin dahili olarak ne yapt─▒─č─▒n─▒ g├Âstermenin en iyi yolu bu i┼člemi uygulayan kodda g├Âstermektir:

 def slice(list, start = None, end = None, step = 1):
  # Take care of missing start/end parameters
  start = 0 if start is None else start
  end = len(list) if end is None else end

  # Take care of negative start/end parameters
  start = len(list) + start if start < 0 else start
  end = len(list) + end if end < 0 else end

  # Now just execute a for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]
 

5







Temel dilimleme tekni─či ba┼člang─▒├ž ÔÇőÔÇőnoktas─▒, durma noktas─▒ ve ad─▒m boyutunu tan─▒mlamakt─▒r - ayr─▒ca ad─▒m olarak da bilinir.

─░lk ├Ânce dilimlemede kullan─▒lacak bir de─čerler listesi olu┼čturaca─č─▒z.

Dilimlemek i├žin iki liste olu┼čturun. ─░lki, 1'den 9'a kadar olan bir say─▒sal listedir (Liste A). ─░kincisi de 0 ila 9 aras─▒nda bir say─▒sal listedir (B Listesi):

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

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

AÔÇÖdan 3, BÔÇÖden 6

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

Temel Dilimleme

Dilimleme i├žin kullan─▒lan geni┼čletilmi┼č indeksleme s├Âzdizimi aList [start: stop: step]. Start arg├╝man─▒ ve step arg├╝man─▒ hem varsay─▒lan olarak hi├žbiridir - sadece gerekli arg├╝man durur. Bunun, A ve B listelerini tan─▒mlamak i├žin kullan─▒lan aral─▒─č─▒n kullan─▒ld─▒─č─▒na benzer oldu─čunu fark ettiniz mi? Bunun nedeni dilim nesnesinin aral─▒k taraf─▒ndan belirtilen dizin k├╝mesini temsil etmesidir (start, stop, step). Python 3.4 belgeleri.

G├Ârd├╝─č├╝n├╝z gibi, sadece stop tan─▒mlamak bir element d├Ând├╝r├╝r. Ba┼člang─▒├ž ÔÇőÔÇőhi├žbiri i├žin varsay─▒lan olmad─▒─č─▒ndan, bu yaln─▒zca bir ├Â─čenin al─▒nmas─▒ anlam─▒na gelir.

─░lk ├Â─čenin, indeks 1 de─čil , dizin 0 oldu─čunu not etmek ├Ânemlidir . Bu nedenle, bu al─▒┼čt─▒rma i├žin 2 liste kullan─▒yoruz. Liste A'n─▒n elemanlar─▒ s─▒radaki pozisyona g├Âre numaraland─▒r─▒l─▒r (birinci eleman 1, ikinci eleman 2, vb.), List B elemanlar─▒ onlar─▒ indekslemek i├žin kullan─▒lacak say─▒lard─▒r ([0], birinci eleman 0 i├žin, vb.).

Geni┼čletilmi┼č dizin olu┼čturma s├Âzdizimi ile bir dizi de─čer al─▒r─▒z. ├ľrne─čin, t├╝m de─čerler iki nokta ├╝st├╝ste al─▒n─▒r.

 A[:]
 

Bir eleman alt k├╝mesini almak i├žin ba┼člang─▒├ž ÔÇőÔÇőve durma konumlar─▒n─▒n tan─▒mlanmas─▒ gerekir.

AList modeli g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda [start: stop], ilk iki eleman─▒ A Listesinden al─▒n.


4







Python ├Â─čretici diyagram─▒n─▒n (di─čer baz─▒ cevaplarda belirtilen), bu ├Âneriyi pozitif ad─▒m i├žin ├žal─▒┼čt─▒─č─▒ i├žin iyi oldu─čunu d├╝┼č├╝n├╝yorum , ancak olumsuz ad─▒m i├žin de─čil.

Bu ┼čemad─▒r:

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

 

Diyagram, ben bekliyoruz a[-4,-6,-1] olmak yP ama ├Âyle ty .

 >>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'
 

Her zaman i┼če yarayan ┼čey karakterleri veya bo┼čluklar─▒ d├╝┼č├╝nmek ve yar─▒ a├ž─▒k aral─▒k olarak indekslemeyi kullanmakt─▒r - pozitif ad─▒mda sa─ča, negatif ad─▒mda sola.

Bu ┼čekilde, terminolojideki a[-4:-6:-1] gibi d├╝┼č├╝nebilirim a(-6,-4] .

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

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

3







Dilimlemeyle ili┼čkili olup olmad─▒─č─▒n─▒ range , endeksleri veren ┼čeyleri anlamak kolayd─▒r . Dilimlemeyi a┼ča─č─▒daki iki kategoriye ay─▒rabiliriz:


1. Ad─▒m veya ad─▒m yok> 0. ├ľrne─čin, [i:j] veya [i:j:k] (k> 0)

Dizinin oldu─čunu varsayal─▒m s=[1,2,3,4,5] .

  • e─čer 0<i<len(s) ve 0<j<len(s) sonra [i:j:k] -> range(i,j,k)

├ľrne─čin, [0:3:2] -> range(0,3,2) -> 0, 2

  • e─čer i>len(s) veya j>len(s) , sonra i=len(s) veya j=len(s)

├ľrne─čin, [0:100:2] -> range(0,len(s),2) -> range(0,5,2) -> 0, 2, 4

  • e─čer i<0 veya j<0 , sonra i=max(0,len(s)+i) veya j=max(0,len(s)+j)

├ľrne─čin, [0:-3:2] -> range(0,len(s)-3,2) -> range(0,2,2) -> 0

Ba┼čka bir ├Ârnek i├žin, [0:-1:2] -> range(0,len(s)-1,2) -> range(0,4,2) -> 0, 2

  • e─čer i belirtilmemi┼čse, daha sonra i=0

├ľrne─čin, [:4:2] -> range(0,4,2) -> range(0,4,2) -> 0, 2

  • e─čer j belirtilmemi┼čse, daha sonra j=len(s)

├ľrne─čin, [0::2] -> range(0,len(s),2) -> range(0,5,2) -> 0, 2, 4


2. Ad─▒m <0. ├ľrne─čin, [i:j:k] (k <0)

Dizinin oldu─čunu varsayal─▒m s=[1,2,3,4,5] .

  • e─čer 0<i<len(s) ve 0<j<len(s) sonra [i:j:k] -> range(i,j,k)

├ľrne─čin, [5:0:-2] -> range(5,0,-2) -> 5, 3, 1

  • e─čer i>len(s) veya j>len(s) , sonra i=len(s)-1 veya j=len(s)-1

├ľrne─čin, [100:0:-2] -> range(len(s)-1,0,-2) -> range(4,0,-2) -> 4, 2

  • e─čer i<0 veya j<0 , sonra i=max(-1,len(s)+i) veya j=max(-1,len(s)+j)

├ľrne─čin, [-2:-10:-2] -> range(len(s)-2,-1,-2) -> range(3,-1,-2) -> 3, 1

  • e─čer i belirtilmemi┼čse, daha sonra i=len(s)-1

├ľrne─čin, [:0:-2] -> range(len(s)-1,0,-2) -> range(4,0,-2) -> 4, 2

  • e─čer j belirtilmemi┼čse, daha sonra j=-1

├ľrne─čin, [2::-2] -> range(2,-1,-2) -> 2, 0

Ba┼čka bir ├Ârnek i├žin, [::-1] -> range(len(s)-1,-1,-1) -> range(4,-1,-1) -> 4, 3, 2, 1, 0


├ľzetle


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


2



─░lgili yay─▒nlar


ÔÇťB├╝y├╝k OÔÇŁ yaz─▒m─▒na dair basit bir ─░ngilizce a├ž─▒klama nedir?

Dosya evrenseldir (├╝├ž dilim), ancak yine de baypas etmek i├žin iOS'taki statik kitapl─▒klar i├žin bir (n) ARMv7-s dilim hatas─▒ i├žermiyor mu?

JavaScript ├Âzellik eri┼čimi: nokta g├Âsterimi vs. parantez?

Big-O ve Little-O Notasyonu Aras─▒ndaki Fark

Angular.js belgeyi derler / enterpolasyonlar yapmadan ├Ânce ├žift ka┼čl─▒ ayra├ž notasyonunun anl─▒k olarak g├Âr├╝nt├╝lenmesini ├Ânleyin

Numpy.array'in bilimsel g├Âsterime gerek kalmadan ve belirli bir hassasiyetle nas─▒l g├╝zel bas─▒laca─č─▒?

Regex:?: Notasyonu (Soru i┼čareti ve kolon notasyonu) [kopya]

Dilim beyan etmek veya dilimlemek?

Nokta notasyonu ve bildirilen ├Âzellikler i├žin mesaj notasyonu

Oracle'─▒n art─▒ (+) notasyonu ile ansi JOIN notasyonu aras─▒ndaki fark?

Etiketle ilgili di─čer sorular [python]


Bir dosyan─▒n istisnalar olmadan var olup olmad─▒─č─▒n─▒ nas─▒l kontrol ederim?

ArrayList'in bir sat─▒rda ba┼člat─▒lmas─▒

Birinin ya┼č─▒n─▒ C# ile nas─▒l hesaplar─▒m?

HTTP POST iste─činde parametreler nas─▒l g├Ânderilir?

PHP ayr─▒┼čt─▒rma / s├Âzdizimi hatalar─▒; ve nas─▒l ├ž├Âz├╝l├╝r?

├çok par├žal─▒ / form-veri iste─či g├Ânderme arac─▒ [kapal─▒]

ENOENT neden ÔÇťB├Âyle bir dosya veya dizin yokÔÇŁ anlam─▒na geliyor?

Python'da neden ++ ve - operat├Ârleri yok?

Linux sisteminde h─▒zla b├╝y├╝k bir dosya olu┼čturun

MongoDB koleksiyonundaki bir nesne dizisindeki yaln─▒zca sorgulanan ├Â─čeyi al