Python'un dilim gösterimini anlama

Python'un dilim gösteriminde iyi bir açıklamaya (referanslar bir artı) ihtiyacım var.

bana, bu gösterimin biraz alması gerekiyor.

son derece güçlü görünüyor, ama etrafımda pek bir şey yok.

2385
tarihinde sordu codeforester 2009-02-04 01:31:02
kaynak

30 ответов

gerçekten oldukça basit:

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

yukarıdakilerden herhangi biriyle kullanılabilen step değeri de vardır:

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

hatırlanması gereken önemli nokta, :end değerinin, seçilen dilimde değil olan ilk değeri temsil etmesidir. Yani, end ve start arasındaki fark seçilen öğelerin sayısıdır ( step 1 ise, varsayılan).

diğer özellik start veya end negatif numarası olabilir, bu da dizinin sonundan başlayarak 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, sorduğunuzdan daha az öğe varsa, programcıya aittir. Örneğin, a[:-2] ve a sorarsanız yalnızca bir öğe içerir, bir hata yerine boş bir liste alırsınız. Bazen hatayı tercih edersiniz, bu nedenle bunun olabileceğini bilmelisiniz.

3226
cevap Greg Hewgill 2018-04-11 10:24:13
kaynak

Python eğitimi bu konuda konuşuyor (Dilimleme hakkında kısma gelene kadar biraz aşağı kaydırın).

ASCII sanat diyagramı, 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

dilimlerin nasıl çalıştığını hatırlamanın bir yolu, endeksleri ile karakterleri arasında 0 numaralı ilk karakterin sol kenarı olarak düşünmektir. Sonra sonuncunun sağ kenarı n karakter dizesinin karakteri n dizinine sahiptir .

409
cevap Hans Nowak 2017-09-18 14:02:56
kaynak

dilbilgisi tarafından izin verilen olanakları Numaralandırıyor:

>>> 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, (high-low)%stride != 0 ise, o zaman bitiş noktası high-1 biraz daha düşük olacaktır .

stride negatif ise, geri saydığımız için Sipariş biraz değişti:

>>> 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 elips ile) çoğunlukla sadece özel veri yapıları (Numpy gibi) tarafından kullanılır; temel diziler desteklemez onları.

>>> class slicee:
...     def __getitem__(self, item):
...         return `item`
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
319
cevap ephemient 2017-10-01 05:39:08
kaynak

yukarıdaki cevaplar ödevini tartışmaz. Ödevini anlamak için ascıı sanatına başka bir kavram eklemek yararlı olur:

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

bir sezgisel, sıfırdan n'ye kadar bir dilim için: "sıfır başlangıçtır, başlangıçta başlar ve bir listede n öğeleri alır".

>>> 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ıç sıfır olarak değiştirin, listenin sonuna ulaşmak için önceki sezgisel olanı uygulayın, sonra "

başından öğeleri kesmek için geri ilk numarayı Sayın
>>> 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 atama ilk kural Dilimleme beri döndürür bir liste, dilim atama gerektirir bir liste (veya diğer yinelemeli):

>>> 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 dilim atamasının ikinci kuralı, listenin herhangi bir bölümünün dilim indeksleme ile döndürülmesi, bu da aynı kısımdır. dilim atama ile değiştirilir:

>>> 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ı uzunluğa sahip olması gerekmez; dizinlenmiş dilim basitçe dilimlenir ve atanan her şeyle topluca 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ışmak için en zor kısım, dilimleri boşaltmak için kullanılır. Sezgisel 1 ve 2'yi kullanarak başınızı indeksleme etrafında boş bir dilim almak 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 bunu gördükten sonra, boş dilime dilim Atama da mantıklı:

>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # assigned list is same length as slice
>>> p 
 ['P','y','x','y','o','n'] # result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # assigned list is longer than slice
>>> p 
 ['P','y','t','x','y','o','n'] # result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # result is longer still

, dilimin (4) ikinci sayısını değiştirmediğimizden, eklenen öğelerin her zaman boş dilime atarken bile ' o ' ye karşı yığıldığını unutmayın. Yani boş dilim atama konumu, boş olmayan dilim atamaları için konumların mantıksal uzantısıdır.

biraz yedekleme, dilim başlangıç kadar sayma bizim alayı ile devam 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 bitti; geriye doğru dilimlemeye başlamıyor. Python'da, negatif bir sayı kullanarak açıkça sormadığınız sürece olumsuz adımlar atmazsınız.

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

"işiniz bittiğinde, bitirdiniz" kuralı için bazı garip sonuçlar vardır:

>>> 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, dizin oluşturma ile karşılaştırıldığında, python Dilimleme garip bir şekilde hata geçirmez:

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

Bu bazen kullanışlı gelebilir ama aynı zamanda biraz garip davranış 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']

uygulamanıza bağlı olarak, bu olabilir... ya da olmayabilir... orada ne umuyordun be!

aşağıda orijinal cevabımın metnidir, birçok kişi için yararlı olmuştur, bu yüzden istemedim sil.

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

bu aynı zamanda Dilimleme ve indeksleme arasındaki farkı netleştirebilir.

203
cevap David M. Perlman 2018-09-26 07:46:17
kaynak

Python'un dilim gösterimini açıklar

Kısacası, alt simge gösteriminde ( : ) iki nokta üst üste ( subscriptable[subscriptarg] ) isteğe bağlı argümanlara sahip dilim gösterimi yapar, start , stop , step :

sliceable[start:stop:step]

Python Dilimleme, verilerinizin parçalarına metodik olarak erişmenin hesaplama açısından hızlı bir yoludur. Benim düşünceme göre, ara bir Python programcısı bile olmak, bu bir yön aşina olmak için gerekli olan dilin.

Önemli Tanımlar

başlamak için, birkaç terim tanımlayalım:

Başlat: dilimin başlangıç dizini, dur , varsayılan 0, yani ilk dizin ile aynı olmadığı sürece bu dizinde elemanı içerecektir. Negatif ise, n öğelerini başlatmak anlamına gelir sonlandırmak.

dur: dilimin bitiş Endeksi, değil , bu dizindeki elemanı, dilimlenmiş dizinin uzunluğuna, yani sonuna kadar ve sonuna kadar içerir.

adım: dizin artar miktarı, varsayılan olarak 1. Eğer negatif ise, tekrarlanabilir tersini dilimliyorsunuz.

nasıl Dizin Oluşturma İşleri

bu pozitif veya negatif sayılardan herhangi birini yapabilirsiniz. Pozitif sayıların anlamı basittir, ancak negatif sayılar için, tıpkı Python'daki indeksler gibi, start ve stop için ve step için, dizininizi azaltmanız yeterlidir. Bu örnek, dokümantasyonun öğreticisinden , ancak bir sırayla her dizin referanslar hangi öğeyi belirtmek için hafifçe modifiye:

 +---+---+---+---+---+---+
 | 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 destekleyen bir diziyle kullanmak için, diziyi takip eden köşeli parantezlerde en az bir kolon eklemeniz gerekir (aslında , __getitem__ dizisinin yöntemini uygular, Python veri modeline göre .)

dilim gösterimi çalışır şöyle:

sequence[start:stop:step]

ve start , stop ve step için varsayılanların bulunduğunu hatırlayın, böylece varsayılanlara erişmek için argümanı bırakın.

son dokuz öğeyi bir listeden (veya bir dize gibi destekleyen başka bir diziden) almak için dilim gösterimi şöyle görünür:

my_list[-9:]

bunu gördüğümde, parantez içinde "9.uçtan uca, sonuna kadar."(Aslında, zihinsel olarak "-9, on" olarak kısaltıyorum)

Açıklama:

tam gösterim

my_list[-9:None:None]

ve varsayılanları değiştirmek için (aslında step negatif olduğunda, stop 'varsayılan -len(my_list) - 1 , yani None dur için gerçekten sadece hangi uç adımına gideceği anlamına gelir):

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

kolon , : , Python'a düzenli bir indeks değil, bir dilim verdiğinizi söyler. Bu nedenle Python 2'deki listelerin sığ bir kopyasını yapmanın deyimsel yolu

list_copy = sequence[:]

ve onları temizlemek ile:

del my_list[:]

(Python 3 list.copy ve list.clear yöntemini alır.)

step negatif olduğunda, start ve stop varsayılan değerleri değişir

varsayılan olarak, step bağımsız değişkeni boş olduğunda (veya None ), +1 atanır .

ancak negatif bir tamsayıya geçebilir ve liste (veya diğer birçok standart Dilimleme) baştan sonuna kadar dilimlenir.

böylece negatif bir dilim start ve stop için varsayılan değişecek !

bunu

kaynağında onaylıyor

ben kaynak yanı sıra belgeleri okumak için kullanıcıları teşvik etmek ister. Dilim nesneleri için kaynak kodu ve bu mantık burada bulunur . Önce step negatif olup olmadığını belirleriz:

 step_is_negative = step_sign < 0;

eğer öyleyse, alt sınır -1 , başlangıç dahil olmak üzere tüm yol boyunca dilimlediğimiz anlamına gelir ve üst sınır eksi 1 uzunluğudur, yani sonunda başlıyoruz. (Not: bu -1 semantiği farklı bir -1 kullanıcıların son öğeyi belirten Python'da dizinler geçirebilirsiniz.)

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

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

aksi halde step olumludur ve alt sınır sıfır olacaktır ve dilimlenmiş listenin uzunluğunu (ancak dahil değil) üst sınır olacaktır.

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

sonra, uygulamak gerekebilir start ve stop varsayılanları - start için varsayılan step negatif olduğunda üst sınır olarak hesaplanır:

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!

sen-ebilmek bulmak o kadar geçen dilim oluşturan ayırmak için yararlı list.__getitem__ yöntemi ( bu Kare parantez yapmak budur). Yeni olmasanız bile, kodunuzu daha okunabilir tutar, böylece kodunuzu okumak zorunda kalan Diğerleri ne yaptığınızı daha kolay anlayabilir.

ancak, sadece bir değişkene iki nokta üst üste ayrılmış bazı tamsayılar atayamazsınız. Dilim nesnesini kullanmanız gerekir:

last_nine_slice = slice(-9, None)

ikinci argüman, None , gereklidir, böylece ilk bağımsız değişken start bağımsız değişken olarak yorumlanır, aksi takdirde stop bağımsız değişken olacaktır .

dilim nesnesini dizinize geçirebilirsiniz:

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

ayrıca dilimleri almak ilginç:

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

Bellek Konuları:

Python listelerinin dilimleri bellekte yeni nesneler oluşturduğundan, başka bir önemli itertools.islice farkında olmak için işlev . Tipik olarak, bir dilim üzerinde yineleme yapmak isteyeceksiniz, sadece bellekte statik olarak oluşturmadınız. islice bunun için mükemmel. Bir uyarı, negatif argümanları start , stop veya step olarak desteklemiyor, bu nedenle bir sorun varsa endeksleri hesaplamanız veya yinelemeyi önceden tersine çevirmeniz 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 dilimleri bir yapmak gerçeği kopya listeleri kendilerini bir özelliğidir. Bir pandalar DataFrame gibi gelişmiş nesneleri dilimliyorsanız, orijinalde bir görünüm döndürebilir ve bir kopya değil.

198
cevap Aaron Hall 2018-06-13 23:35:35
kaynak

ve Dilimleme sözdizimini ilk gördüğümde bana hemen açık olmayan birkaç şey:

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

dizileri ters kolay yolu!

ve eğer isterseniz, herhangi bir nedenle, ters sırayla her ikinci öğe:

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]
126
cevap Dana 2009-02-04 02:15:02
kaynak

bu büyük tabloyu de buldu http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)
86
cevap AdrianoFerrari 2011-09-06 10:50:08
kaynak

Python 2.7

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 atama 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] dediğinizde, C işaretine (ileri veya geri) bağlı olarak, B'de (bth dizinindeki öğe hariç) A ve sonunda başlayın. Yukarıdaki dizin oluşturma 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

ama bu aralık her iki yönde de devam ediyor:

...,-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 için kuralları kullanarak geçerken yukarıdaki aralıkla örtüşmeye izin veriyorsa, öğelerle (geçiş sırasında dokunulduğunda) bir liste alırsınız veya boş bir liste alırsınız.

son bir şey: a ve b eşitse, o zaman da 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]
85
cevap abc 2017-07-10 19:59:26
kaynak

biraz kullandıktan sonra, en basit tanımın, bir for döngüsündeki argümanlarla tam olarak aynı olduğunu fark ettim...

(from:to:step)

bunlardan herhangi biri isteğe bağlıdır

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

sonra negatif indeksleme sadece bunu anlamak için negatif endeksleri dize uzunluğunu eklemek gerekiyor.

Bu zaten benim için çalışıyor...

48
cevap Simon 2009-02-19 23:52:44
kaynak

nasıl çalıştığını hatırlamayı daha kolay buluyorum, o zaman belirli bir start / stop / step kombinasyonunu bulabilirim.

ilk range() anlamak için öğretici:

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

start dan başlar, step ile artış, stop ulaşmayın . Çok basit.

negatif adım hakkında hatırlanması gereken şey, stop , daha yüksek veya daha düşük olsun, her zaman dışlanmış sondur. Eğer ters sırada aynı dilim istiyorsanız, tersini ayrı ayrı yapmak çok daha temiz: örneğin 'abcde'[1:-2][::-1] soldan bir char, sağdan iki, sonra tersine çevirir. (Ayrıca bakınız reversed() .)

dizisi Dilimleme aynıdır, ilk negatif indeksleri normalleştirir ve asla dizinin dışına çıkamaz:

' : aşağıdaki kod, "sıradan asla çıkmayın" ile bir hataya sahipti. abs (Adım)>1; ben düşünüyorum ben doğru olması yamalı, ama anlamak zor.

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 start ve / veya stop atlayarak her zaman tüm diziyi vermek için doğru şeyi yapar unutmayın.

negatif indekslerin normalleştirilmesi ilk önce başlangıç ve/veya sondan bağımsız olarak sayılmasını sağlar: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc' , range(1,-2) == [] . Bu normalleştirme bazen "modulo uzunluğu" olarak düşünülür, ancak uzunluğu sadece bir kez eklediğine dikkat edin: örneğin 'abcde'[-53:42] sadece bütün dizedir.

33
cevap Beni Cherniavsky-Paskin 2016-10-30 15:42:57
kaynak

bunu kendim düşünmek için" elemanlar arasında bir dizin noktası " yöntemini kullanıyorum, ancak bazen başkalarının bunu elde etmesine yardımcı olan bir yol şudur:

mylist[X:Y]

x, istediğiniz ilk öğenin dizinidir.

Y yok istediğiniz ilk öğenin dizinidir.

31
cevap Steve Losh 2009-02-07 00:16:28
kaynak
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, Python'daki listeyi modellemenize yardımcı olacaktır.

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

30
cevap xiaoyu 2017-02-11 22:56:15
kaynak

Python Dilimleme gösterimi:

a[start:end:step]
  • için start ve end , negatif değerler dizinin sonuna göre olarak yorumlanır.
  • için pozitif endeksler end , sonrasında pozisyonunu gösterir.
  • boş değerler aşağıdaki gibi varsayılır: [+0:-0:1] .
  • negatif bir adım kullanarak start ve end
  • yorumunu tersine çevirir

gösterimde (numpy) matrisler ve çok boyutlu diziler uzanır. Örneğin, kullanabileceğiniz tüm sütunları dilim için:

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

dilimleri, dizi öğelerinin kopyalarını değil, referansları tutar. Ayrı bir kopya bir dizi yapmak istiyorsanız, kullanabilirsiniz deepcopy() .

28
cevap nobar 2017-05-23 15:34:44
kaynak

ayrıca bir listeden bir veya daha fazla öğe kaldırmak için bir atama kullanabilirsiniz:

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
25
cevap dansalmo 2013-04-19 20:28:16
kaynak

bu sadece bazı ekstra bilgi içindir... Aşağıdaki listeyi düşünün

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

listeyi tersine çevirmek için birkaç başka hile:

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

abc'nin cevabı

25
cevap Arindam Roychowdhury 2015-03-30 22:22:51
kaynak

bu yeni başlayanlar için dilimleri öğretmek nasıl:

indeksleme ve Dilimleme arasındaki farkı anlama:

Wiki Python, indeksleme ve dilimlemeyi açıkça ayıran bu muhteşem resme sahiptir.

enter image description here

içinde 6 element bulunan bir listedir. Dilimlemeyi daha iyi anlamak için, bu listeyi bir araya yerleştirilen altı kutu kümesi olarak düşünün. Her kutu bir içinde alfabe var.

indeksleme kutunun içeriği ile ilgili gibidir. Herhangi bir kutunun içeriğini kontrol edebilirsiniz. Ama aynı anda birden fazla kutu içeriğini kontrol edemez. Kutunun içeriğini bile değiştirebilirsiniz. Ancak 2 topu 1 kutuya yerleştiremez veya bir seferde 2 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ı kendisi ile ilgili gibidir. İlk kutuyu alıp başka bir masaya yerleştirebilirsiniz. Kutuyu almak için bilmeniz gereken tek şey kutunun başlangıcı ve sonu.

ilk 3 kutu veya son 2 kutu veya 1 ve 4 arasındaki tüm kutuları bile alabilirsiniz. Yani, başlangıç ve bitiş biliyorsanız kutuları herhangi bir dizi seçebilirsiniz. Bu pozisyonlara start & stop pozisyonları denir.

ilginç olan, birden fazla kutuyu aynı anda değiştirebilmenizdir. Ayrıca hiç istediğiniz birden kutuları 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ım İle Dilimleme:

şimdiye kadar sürekli kutuları seçtiniz. Ama bazı zamanlar discretely almak gerekir. Örneğin her ikinci kutuyu alabilirsiniz. Hatta ucundan her üçüncü kutuyu alabilirsiniz. Bu değer adım boyutu denir. Bu ardışık manyetikler arasındaki boşluğu temsil eder. Eğer başından sonuna kadar kutuları toplama ve tersi ise Adım boyutu olumlu olmalıdır.

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 Nasıl Eksik Çıkıyor Parametreler:

herhangi bir parametreyi bırakırsanız, Python otomatik olarak anlamaya çalışır.

cpython kaynak kodunu kontrol ederseniz, pyslice_getındicesex adı verilen herhangi bir parametre için bir dilime işaret eden bir işlev bulacaksınız. İşte python'da mantıksal eşdeğer kod.

bu işlev, Dilimleme için bir Python nesnesi ve isteğe bağlı parametreler alır ve Başlat, Durdur, adım döndürür & istenen dilim için dilim uzunluğu.

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)

bu dilimlerin arkasında bulunan istihbarat. Python slice olarak adlandırılan dahili işleve sahip olduğundan, bazı parametreleri geçebilir ve eksik parametreleri ne kadar 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ı aslen blogumda yazılmıştır http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html

24
cevap ChillarAnand 2015-03-24 19:08:36
kaynak

genel bir kural Olarak, kodlanmış endeks değerleri bir sürü kod yazmak okunabilirliği yol açar ve bakım karmaşası. Örneğin, bir yıl sonra koda geri dönerseniz, şuna bak ve yazdığında ne düşündüğünü merak et. Gösterilen çözüm kodunuzun gerçekte ne yaptığını daha net bir şekilde belirten bir yoldur. Genel olarak, yerleşik dilim () bir dilim için kullanılabilecek bir dilim nesnesi oluşturur izin verilir. Ö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 dilim örnek s varsa, onun bakarak bu konuda daha fazla bilgi alabilirsiniz s.başla, s.dur ve s.sırasıyla adım öznitelikleri. Örneğin:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>
21
cevap Python_Dude 2013-12-07 20:52:45
kaynak

1. Dilim Gösterimi

basit hale getirmek için, unutmayın ' '

sadece bir formu vardır
s[start:end:step]

ve işte nasıl çalışır:

  • s :
  • dilimlenmiş bir nesne
  • start : yineleme başlatmak için ilk dizin
  • end : son dizin, end dizininin dahil edilmeyeceğini unutmayın sonuçlandırılmış dilim
  • step : her step dizin
  • seç

başka bir ithalat şey: tüm start , end , step ihmal edilebilir! ve atlanırsa, varsayılan değerleri kullanılacaktır: 0 , len(s) , 1 buna göre.

yani Olası varyasyonlar şunlardır:

# 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: start>=end (yalnızca step>0 göz önüne alındığında ), python boş bir dilim [] döndürür .

2. Tuzaklar

yukarıdaki bölüm, dilimin nasıl çalıştığına ilişkin temel özellikleri açıklar, çoğu durumda çalışır. Ancak dikkat etmeniz gereken tuzaklar olabilir ve bu bölüm bunları açıklar.

negatif indeksler

python öğrenicilerini karıştıran ilk şey indeks negatif olabilir! Panik yapmayın: negatif indeks geriye doğru saymak anlamına gelir.

örneğin:

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

negatif adım

şeyler daha kafa karıştırıcı yapmak step çok olumsuz olabilir!

negatif adım, diziyi geriye doğru yinelemek anlamına gelir: uçtan uca, uç dizini dahil ve başlangıç sonuç hariç dizin.

not : adım negatif olduğunda, start için len(s) için varsayılan değer ( end 0 eşit değil, çünkü s[::-1] s[0] içerir ). Örneğin:

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

Aralık hatası mı?

şaşıracaksınız: dilim dizin aralığı dışında olduğunda IndexError yükseltmez!

dizin aralık dışında ise, python en iyi duruma göre 0 veya len(s) için dizin ayarlamak çalışacağız. Örneğin:

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

3. Örnekler

bu cevabı örneklerle bitirelim tartıştığımız her şeyi açıklıyor:

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

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

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

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

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

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

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

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

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

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

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

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

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

IndexError: list index out of range
20
cevap cizixs 2017-01-18 22:03:39
kaynak

yukarıdaki cevaplar, ünlü numpy paketini kullanarak mümkün olan çok boyutlu dizi dilimini tartışmıyor:

Dilimleme de çok boyutlu diziler için geçerlidir.

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

virgül ilk boyut ve virgül ikinci boyut üzerinde çalıştıktan sonra "0:3:2" üzerinde çalışmadan önce": 2".

14
cevap Statham 2018-01-19 19:08:03
kaynak

bir yinelenebilir (bir liste gibi) belirli bir parça almak için, işte bir örnek:

variable[number1:number2]

bu örnekte, 1 numaralı olumlu bir sayı, ön taraftan kaç bileşen çıkardığınızdır. Olumsuz bir sayı tam tersi, kaç kişiden uzak duruyorsunuz. Sayı 2 için olumlu bir sayı, başlangıçtan kaç bileşen tutacağınızı gösterir ve negatif, sonunda kaç tane çıkarmayı planladığınız negatiftir. Bu biraz karşı sezgisel, ama bu liste Dilimleme son derece yararlı olduğunu varsayarak doğrudur.

11
cevap someone-or-other 2014-12-28 22:11:22
kaynak

beynim lst[start:end] start - th öğesini içerdiğini kabul etmekten mutluluk duyuyor gibi görünüyor. Hatta bunun 'doğal bir varsayım'olduğunu söyleyebilirim.

ama bazen bir şüphe sürünür ve beynim end -th öğesini içermediğini güvence ister.

bu anlarda bu basit teoreme güveniyorum:

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

bu güzel özellik lst[start:end] içermediğini söyler end - th öğesi lst[end:] olduğu için.

bu teoremin herhangi bir n için doğru olduğunu unutmayın. Örneğin,

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

döndürür True .

11
cevap Robert 2016-05-26 11:16:54
kaynak
#!/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 komut dosyasını çalıştırabilir ve deney yapabilirsiniz, aşağıda komut dosyasından aldığım bazı örnekler var.

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

olumsuz bir adım kullanırken, cevabın 1 ile sağa kaydırıldığını fark edin.

10
cevap mahmoh 2014-10-18 21:40:45
kaynak
Python'da

, Dilimleme için en temel form şudur:

l[start:end]

burada l bazı koleksiyon, start kapsayıcı bir dizin ve end özel bir dizin.

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 Dilimleme yaparken, sıfır dizini atlayabilirsiniz ve sonuna kadar Dilimleme yaparken, gereksiz olduğundan son dizini atlayabilirsiniz, bu yüzden 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

bir koleksiyonun sonuna göre uzaklıklar yaparken negatif tamsayılar yararlı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 3 elements
Out[8]: [7, 8, 9]

gibi Dilimleme yaparken sınırların dışında endeksleri sağlamak mümkündür
In [9]: l[:20] # 20 is out of index bounds, l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

bir koleksiyon Dilimleme sonucu yepyeni bir koleksiyon olduğunu unutmayın. Buna ek olarak, Atamalarda dilim gösterimi kullanıldığında, dilim atamasının uzunluğu aynı olması gerekmez. Önce ve sonra değerleri atanan dilim tutulacak ve koleksiyon küçülecek veya yeni değerleri içerecek şekilde büyüyecek:

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

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

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

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

başlangıç ve bitiş dizinini atlarsanı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ştirirken başlangıç ve bitiş dizinleri atlanırsa, koleksiyonun tüm içeriği başvurulan bir kopyası ile değiştirilir:

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

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

temel Dilimleme yanında, aşağıdaki notasyonu uygulamak da mümkündür:

l[start:end:step]

nerede l bir koleksiyon, start kapsayıcı bir dizin, end özel bir dizin ve step her almak için kullanılabilecek bir adım nth öğe 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]

kullanarak step Python'da bir koleksiyonu 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]

Aşağıdaki örnek olarak step için negatif tamsayılar kullanmak da mümkündür:

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

ancak, step için negatif bir değer kullanarak çok kafa karıştırıcı olabilir. Dahası, Pythonic olmak için, start , end ve step tek bir dilimde kullanmaktan kaçınmalısınız. Bunun gerekli olması durumunda, bunu iki atamada yapmayı düşünün (biri dilim, diğeri adım atmak).

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]
7
cevap lmiguelvargasf 2017-09-04 19:00:44
kaynak

aşağıda

dizesinin dizin örneğidir
 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

Dilimleme örneği: [start:end: step]

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

aşağıda örnek kullanım

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
6
cevap Prince Dhadwal 2017-07-28 13:12:10
kaynak

yukarıdaki cevapların çoğu dilim gösterimi hakkında temizler. Dilimleme için kullanılan genişletilmiş dizin oluşturma sözdizimi aList[start:stop:step] temel örnekler

enter image description here :

daha Dilimleme örnekleri: 15 Genişletilmiş dilimler

6
cevap Roshan Bagdiya 2017-10-07 01:30:17
kaynak

yeni başlayanlar için dilimlerin temellerini açıklayan bir Merhaba Dünya örneği eklemek istiyorum. Bana çok yardımcı oldu.

altı değerleri ile bir liste atalı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 listeleridir. Gösterim [<index>:<index>] ve anahtar şu şekilde okumaktır:

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

şimdi yukarıdaki listenin bir dilim [2:5] yaparsanız, bu olur:

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

sen önce dizin 2 ve önce dizin 5 ile eleman bir kesim yaptı . Sonuç, bu iki kesim arasında bir dilim olacak, bir liste ['T', 'H', 'O'] .

4
cevap Jeyekomon 2018-05-14 10:49:11
kaynak

Hehehe, kendimi Hewgill'den doğru cevap olarak işaretlenen 2600 + oydan sonra daha iyi ve daha basit bir açıklama sağlamaya çalışırken görmek biraz garip.

İşte başlıyoruz ...

benim görüşüme göre, aşağıdaki şekilde bakarsanız Python dize Dilimleme gösterimini daha iyi anlayacaksınız ve ezberleyeceksiniz (okumaya devam edin).

aşağıdaki dizeyle çalışalım ...

azString = "abcdefghijklmnopqrstuvwxyz"

bilmeyenler için azString azString[x:y]

notasyonunu kullanarak azString dan herhangi bir alt dizge oluşturabilirsiniz

diğer programlama dillerinden geliyor, sağduyu tehlikeye girdiğinde. X ve y nedir?

X ve Y'nin ne olduğunu hatırlamama ve ilk denemede dizeleri düzgün bir şekilde kesmeme yardımcı olacak bir ezberleme tekniği arayışımda oturup birkaç senaryo çalıştırmak zorunda kaldım.

benim sonuç, X ve Y'nin, görmek istediğimiz dizeleri çevreleyen sınır indeksleri olarak görülmesi gerektiğidir. Bu yüzden ifadeyi azString[index1, index2] veya azString[index_of_first_character, index_after_the_last_character] olarak daha net görmeliyiz .

burada bunun bir örnek görselleştirme olduğunu ...

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 nedenle, ındex1 ve ındex2'yi istenen alt dizeyi çevreleyen değerlere ayarlarsanız yapmanız gereken tek şey. Örneğin, alt dizeyi almak için "cdefgh", azString[2:8] kullanabilirsiniz, çünkü" c "nin sol tarafındaki dizin 2'dir ve" h " nin sağ boyutundaki dizin 8'dir.

unutmayın, sınırları belirliyoruz.

hile her zaman çalışır ve ezberlemek kolaydır.

Hopefuly bu yardımcı olacaktır.

3
cevap asiby 2017-12-12 07:13:53
kaynak

' : - yılan ayağının yakınında görünür. Görünmez ile görünür arasında hareket eder. Vizyonumuz (bir dilim gibi) dünyanın sadece bir kısmını ortaya koymaktadır. benzer şekilde, bir Python dilimi, bir başlangıç ve durdurma temel alınarak öğeleri ayıklar. Python'da birçok türde dilimler alıyoruz. İsteğe bağlı bir ilk dizin, isteğe bağlı bir son dizin ve isteğe bağlı bir adım belirtiyoruz.

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

aşağıdaki linkten iyi örnekler alabilirsiniz:- python dilim gösterimi örnek

3
cevap SHASHI BHUSAN 2018-04-12 22:17:47
kaynak

dilimlemedeki negatif endekslerin kafa karıştırıcı olduğunu düşünüyorsanız, bunu düşünmenin çok kolay bir yolu var: sadece negatif indeksi len - index ile değiştirin . Örneğin, -3 len(list) - 3 ile değiştirin .

dilimlemenin DAHİLİ 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 for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]
3
cevap ShitalShah 2018-05-22 02:16:38
kaynak

temel Dilimleme tekniği başlangıç noktasını, durma noktasını ve adım boyutunu tanımlamaktır-ayrıca adım olarak da bilinir.

ilk olarak, dilimlememizde kullanılacak değerlerin bir listesini oluşturacağız.

dilim için iki liste oluşturun, birincisi 1'den 9'a (liste a) sayısal bir listedir. İkincisi de 0'dan 9'a (liste B)

sayısal bir listedir
A = list(range(1,10,1)) # start,stop,step
B = list(range(9))

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

dizin numara 3 A ve numara 6 B.

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

Temel Dilimleme

Dilimleme için kullanılan genişletilmiş dizin oluşturma sözdizimi aList[start:stop:step] ' dir. Start bağımsız değişkeni ve step bağımsız değişkeni her ikisi de varsayılan olarak hiçbiri - tek gerekli bağımsız değişken dur. Bunun, A ve b listelerini tanımlamak için aralığın nasıl kullanıldığına benzediğini fark ettiniz mi? Bunun nedeni, slice nesnesi tarafından belirtilen dizin kümesini temsil eder range (start, stop, step). Python 3.4 Dokümantasyon

Gördüğünüz gibi, yalnızca stop tanımlama bir öğe döndürür. Başlangıç hiçbiri varsayılan olduğundan, bu yalnızca bir öğe alma çevirir.

not etmek önemlidir, ilk öğe dizin 0, dizin 1 değil. Bu nedenle bu egzersiz için 2 liste kullanıyoruz. Liste A'nın öğeleri sıra konumuna göre numaralandırılır (ilk öğe 1, ikinci öğe 2, vb.), liste B'nin öğeleri ise bunları indekslemek için kullanılacak sayılardır ([0] ilk için eleman 0, vb.).

genişletilmiş dizin oluşturma sözdizimi ile bir dizi değer alırız. Örneğin, tüm değerler bir kolon ile alınır.

A[:]

öğelerin bir alt kümesini almak için başlangıç ve durdurma pozisyonlarının tanımlanması gerekir.

desen aList verilen [start: stop], listeden ilk iki öğeyi almak a

0
cevap Babu Chandermani 2018-07-23 16:49:16
kaynak

Diğer sorular python list slice