슬라이싱에 대해서
Python 슬라이싱에 대한 좋은 설명(참고문헌은 플러스)이 필요합니다.
구문은 다음과 같습니다.
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의 값 중 할 수 .이 값은 다음 중 하나와 함께 사용할 수 있습니다.
a[start:stop:step] # start through not past stop, by step
해야 할 은 '이것'이:stopvalue는 선택한 슬라이스에 없는 첫 번째 값을 나타냅니다.그래서 그 차이는stop ★★★★★★★★★★★★★★★★★」start선택한 수(만일 경우)입니다.step1로 하다)
다른 은 '하다' 입니다.start ★★★★★★★★★★★★★★★★★」stop는 음수일 수 있습니다.즉, 배열의 선두가 아닌 끝에서 카운트됩니다.그래서:
a[-1] # last item in the array
a[-2:] # last two items in the array
a[:-2] # everything except the last two items
similarly유 similarly,, similarly 、step음수일 수 있습니다.
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은 당신이 원하는 것보다 적은 아이템이 있으면 프로그래머에게 친절합니다.를 들어, 예를 들어 '다 하다'라고요?a[:-2] ★★★★★★★★★★★★★★★★★」a에는 1개의 요소만 포함되어 있으며 오류 대신 빈 목록이 나타납니다.경우에 따라서는, 에러가 발생할 가능성이 있기 때문에, 이러한 에러가 발생할 가능성이 있는 것을 의식할 필요가 있습니다.
와의 slice 표시
오브젝트는 슬라이스 연산을 나타낼 수 있습니다.즉, 다음과 같습니다.
a[start:stop:step]
는 다음과 같습니다.
a[slice(start, stop, step)]
에 따라 합니다.range()둘 다)slice(stop) ★★★★★★★★★★★★★★★★★」slice(start, stop[, step])지원되고 있습니다.인수 " " 를 합니다.None★★★★★★★★★★★★★★★★★,a[start:] a[slice(start, None)] ★★★★★★★★★★★★★★★★★」a[::-1] a[slice(None, None, -1)].
★★★★★:은 간단한이 됩니다. -based 표기법은 -based의 입니다.slice()오브젝트는 슬라이스의 프로그래밍 생성을 단순화합니다.
Python 튜토리얼에서는 이에 대해 설명합니다(슬라이싱에 대한 부분이 나올 때까지 스크롤을 조금 내립니다).
ASCII 아트 다이어그램은 슬라이스의 작동 방식을 기억하는 데도 유용합니다.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
슬라이스가 작동하는 방식을 기억하는 한 가지 방법은 인덱스를 첫 번째 문자의 왼쪽 가장자리가 0인 문자 사이를 가리키는 것으로 간주하는 것입니다.그런 다음 n자 문자열의 마지막 문자의 오른쪽 모서리에는 색인 n이 있습니다.
한다.x:
>>> x[:] # [x[0], x[1], ..., x[-1] ]
>>> x[low:] # [x[low], x[low+1], ..., x[-1] ]
>>> x[:high] # [x[0], x[1], ..., x[high-1]]
>>> x[low:high] # [x[low], x[low+1], ..., x[high-1]]
>>> x[::stride] # [x[0], x[stride], ..., x[-1] ]
>>> x[low::stride] # [x[low], x[low+stride], ..., x[-1] ]
>>> x[:high:stride] # [x[0], x[stride], ..., x[high-1]]
>>> x[low:high:stride] # [x[low], x[low+stride], ..., x[high-1]]
만약 론,, 약 of약(high-low)%stride != 0이 조금 낮아질 예요, 끝점보다 거예요.high-1.
ifstride음수입니다. 카운트다운 중이기 때문에 순서가 약간 변경됩니다.
>>> x[::-stride] # [x[-1], x[-1-stride], ..., x[0] ]
>>> x[high::-stride] # [x[high], x[high-stride], ..., x[0] ]
>>> x[:low:-stride] # [x[-1], x[-1-stride], ..., x[low+1]]
>>> x[high:low:-stride] # [x[high], x[high-stride], ..., x[low+1]]
확장 슬라이스(쉼표 및 생략 기호 포함)는 대부분 NumPy와 같은 특수 데이터 구조에서만 사용됩니다. 기본 시퀀스는 이러한 데이터 구조를 지원하지 않습니다.
>>> class slicee:
... def __getitem__(self, item):
... return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
위의 답변에서는 슬라이스 할당에 대해 설명하지 않습니다.슬라이스 할당을 이해하려면 ASCII 아트에 다른 개념을 추가하는 것이 좋습니다.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
Slice position: 0 1 2 3 4 5 6
Index position: 0 1 2 3 4 5
>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
'P'
>>> p[5]
'n'
# Slicing gives lists
>>> p[0:1]
['P']
>>> p[0:2]
['P','y']
한 가지 휴리스틱은 0에서 n까지의 슬라이스에 대해 "0은 시작이며, 시작부터 시작하여 목록의 n개 항목을 취합니다."라고 생각하는 것입니다.
>>> 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']
또 다른 휴리스틱은 "모든 슬라이스에 대해 시작 부분을 0으로 대체하고 이전 휴리스틱을 적용하여 목록의 끝을 얻은 다음 첫 번째 숫자를 다시 세어 항목을 잘라냅니다."
>>> 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.
슬라이스 할당의 첫 번째 규칙은 슬라이스는 목록을 반환하므로 슬라이스 할당에는 목록(또는 다른 반복 가능)이 필요하다는 것입니다.
>>> 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
슬라이스 할당의 두 번째 규칙은 슬라이스 인덱스에 의해 리스트가 반환되는 부분이 슬라이스 할당에 의해 변경되는 부분과 동일합니다.
>>> p[2:4]
['T','h']
>>> p[2:4] = ['t','r']
>>> p
['P','y','t','r','o','n']
슬라이스 할당의 세 번째 규칙은 할당된 목록(반복 가능)의 길이가 같을 필요가 없다는 것입니다. 인덱스된 슬라이스는 단순히 슬라이스를 잘라내고 할당된 슬라이스에 따라 일괄적으로 대체됩니다.
>>> 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']
가장 익숙해지기 어려운 부분은 빈 조각에 할당하는 것입니다.휴리스틱 1과 2를 사용하면 빈 슬라이스를 인덱싱하는 방법을 쉽게 이해할 수 있습니다.
>>> 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 = ['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
슬라이스의 두 번째 번호(4)를 변경하지 않기 때문에 빈 슬라이스에 할당하는 경우에도 삽입된 항목은 항상 'o'에 대해 바로 쌓입니다.따라서 빈 슬라이스 할당 위치는 비어 있지 않은 슬라이스 할당 위치의 논리적 확장입니다.
조금 뒤로 물러서서, 슬라이스를 세는 행렬을 계속 진행하면 어떻게 될까요?
>>> 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]
[]
슬라이스를 하면, 일단 다 자르면 끝입니다. 거꾸로 자르기 시작하지 않습니다.Python에서는 음수를 사용하여 명시적으로 요청하지 않는 한 음의 진보를 얻을 수 없습니다.
>>> p[5:3:-1]
['n','o']
"일단 완료하면 완료" 규칙에는 몇 가지 이상한 결과가 있습니다.
>>> 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
사실 인덱싱과 비교했을 때 Python 슬라이싱은 이상하게도 오류가 발생하지 않습니다.
>>> p[100:200]
[]
>>> p[int(2e99):int(1e99)]
[]
이것은 때때로 도움이 될 수 있지만, 다소 이상한 행동을 일으킬 수도 있습니다.
>>> 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']
신청서에 따라서는...그렇지 않을 수도 있고...네가 거기서 바라던 것이 될 거야!
아래는 저의 원래 답변의 본문입니다.그것은 많은 사람들에게 유용했기 때문에 나는 그것을 삭제하고 싶지 않았다.
>>> 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]
슬라이싱과 인덱스의 차이도 명확해질 수 있습니다.
Python의 슬라이스 표기법 설명
콜론colons):를 첨자 표기법 「」( )으로 나타냅니다subscriptable[subscriptarg] 표기법 인수)을 합니다.이 표기법에는 옵션의 인수가 있습니다.start,stop , , , , 입니다.step:
sliceable[start:stop:step]
Python 슬라이싱은 데이터의 일부에 체계적으로 액세스할 수 있는 빠른 계산 방법입니다.중간급 Python 프로그래머가 되기 위해서는 친해져야 할 언어의 한 측면이라고 생각합니다.
중요한 정의
먼저 몇 가지 용어를 정의하겠습니다.
start: 슬라이스의 시작 인덱스. stop과 동일하지 않은 한 이 인덱스에 요소가 포함됩니다.기본값은 0, 즉 첫 번째 인덱스가 됩니다.음성이면 시작하라는 뜻이다.n마지막 항목부터.: 슬라이스의 끝 인덱스는 이 인덱스에 요소를 포함하지 않고 기본적으로 슬라이스되는 시퀀스 길이, 즉 끝까지의 길이입니다
stop.
step: 인덱스가 증가하는 양은 기본적으로 1입니다.음수면 거꾸로 자르는 거야
인덱싱 구조
여러분은 양수나 음수 중 하나를 만들 수 있습니다.양수의 의미는 간단하지만, Python의 인덱스와 같이 음수의 경우 시작과 종료의 경우 끝에서 거꾸로 카운트하고, 스텝의 경우 인덱스를 감소시킵니다.이 예는 설명서의 튜토리얼에서 나온 것이지만, 각 인덱스가 참조하는 시퀀스의 항목을 나타내도록 약간 수정했습니다.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
슬라이스 구조
슬라이스 표기법을 지원하는 시퀀스와 함께 사용하려면 시퀀스를 따르는 대괄호 안에 콜론을 하나 이상 포함해야 합니다(Python 데이터 모델에 따라 시퀀스의 메서드를 실제로 구현).
슬라이스 표기법은 다음과 같이 동작합니다.
sequence[start:stop:step]
start, stop 및 step에는 기본값이 있으므로 기본값에 액세스하려면 인수를 생략하십시오.
리스트의 마지막 9개의 요소(또는 그것을 지원하는 다른 시퀀스(문자열 등)를 취득하는 슬라이스 표기법은 다음과 같습니다.
my_list[-9:]
이걸 보면 괄호 안에 있는 부분을 '9번째 끝, 끝까지'라고 읽습니다.(사실 정신적으로 '-9, on'으로 줄여서 읽습니다)
설명:
완전한 표기법은
my_list[-9:None:None]
는 디폴트)로 치환합니다.step 음성이에요.stop은 " " " 입니다-len(my_list) - 1, (그래서)None'는 실제로 : '정지'는 '정지'를 의미합니다.
my_list[-9:len(my_list):1]
대장,:Python에게 말하는 것은 일반 인덱스가 아니라 슬라이스를 주는 것입니다.Python 2에서은 "2"입니다.
list_copy = sequence[:]
그리고 그것들을 클리어하는 방법은 다음과 같습니다.
del my_list[:]
은 (Python 3은)를 .list.copy ★★★★★★★★★★★★★★★★★」list.clear이치노
stepnegative은 negative 입니다.기본값은start ★★★★★★★★★★★★★★★★★」stop
「」의 ,step 있다( 비어 있다).None에되어 있습니다.+1.
그러나 음의 정수를 전달하면 목록(또는 대부분의 다른 표준 슬라이서블)이 끝에서 끝까지 슬라이스됩니다.
마이너스 슬라이스를 됩니다.start ★★★★★★★★★★★★★★★★★」stop!
소스에서 확인 중
저는 사용자에게 문서뿐만 아니라 소스도 읽어보라고 권하고 싶습니다.슬라이스 객체의 소스 코드와 이 논리는 여기에 있습니다.우선은, 다음의 유무를 판단합니다.step수입니니다다
step_is_negative = step_sign < 0;
은 '아니다'입니다.-1로 끝부분부터 으로는 1은 1로 끝부분을 가리킵니다.)-1와는 다르다-1사용자가 Python에서 마지막 항목을 나타내는 인덱스를 전달할 수 있습니다.)
if (step_is_negative) { lower = PyLong_FromLong(-1L); if (lower == NULL) goto error; upper = PyNumber_Add(length, lower); if (upper == NULL) goto error; }
이외의 경우는, 「」입니다.step는 양수이며 하한은 0, 상한은 슬라이스 리스트의 길이(최상위까지 올라가지만 포함하지 않음)가 됩니다.
else { lower = _PyLong_Zero; Py_INCREF(lower); upper = length; Py_INCREF(upper); }
경우에는 기본 해야 할 .start ★★★★★★★★★★★★★★★★★」stop 로는 다음과 같습니다.start됩니다.step수입니니다다
if (self->start == Py_None) { start = step_is_negative ? upper : lower; Py_INCREF(start); }
★★★★★★★★★★★★★★★★★」stop , 한::
if (self->stop == Py_None) { stop = step_is_negative ? lower : upper; Py_INCREF(stop); }
슬라이스에 알기 쉬운 이름을 지정하십시오.
과 슬라이스를 것을 이 될 수 .list.__getitem__method(대괄호)의 기능을 수행합니다.처음 접하는 사람이 아니더라도 코드를 더 쉽게 읽을 수 있도록 하기 때문에 코드를 읽어야 하는 다른 사람이 더 쉽게 이해할 수 있습니다.
그러나 콜론으로 구분된 일부 정수를 변수에 할당할 수는 없습니다.슬라이스 개체를 사용해야 합니다.
last_nine_slice = slice(-9, None)
인수, " " " 입니다.None는 '아니다'로 할 수 '가 필요합니다start그렇지 않으면 그것은 논쟁이 될 것이다.
그런 다음 슬라이스 개체를 시퀀스로 전달할 수 있습니다.
>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]
범위도 슬라이스를 취한다는 점이 흥미롭습니다.
>>> range(100)[last_nine_slice]
range(91, 100)
메모리 고려사항:
메모리에 해야 할 또 은 Python입니다.itertools.islice일반적으로 메모리 내에서 정적 생성뿐만 아니라 슬라이스를 반복해야 합니다. islice주의 주의: 인수는 하지 않습니다.start,stop , 「」step그렇기 때문에 사전에 인덱스를 계산하거나 반복 가능 여부를 반전시켜야 할 수도 있습니다.
length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)
그리고 지금:
>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]
목록 조각이 복사본을 만드는 것은 목록 자체의 기능입니다.Panda Data Frame과 같은 고급 객체를 슬라이스할 경우 복사본이 아닌 원본 보기를 반환할 수 있습니다.
그리고 슬라이싱 구문을 처음 봤을 때 바로 알 수 없었던 몇 가지가 있습니다.
>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]
시퀀스를 되돌리는 쉬운 방법!
만약 당신이 어떤 이유로 매초마다 역순으로 항목을 원했다면:
>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]
Python 2.7에서는
Python에서의 슬라이싱
[a:b:c]
len = length of string, tuple or list
c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.
a -- When c is positive or blank, default is 0. When c is negative, default is -1.
b -- When c is positive or blank, default is len. When c is negative, default is -(len+1).
색인 할당을 이해하는 것은 매우 중요합니다.
In forward direction, starts at 0 and ends at len-1
In backward direction, starts at -1 and ends at -len
[a:b:c]라고 하는 것은 c(앞으로 또는 뒤로)의 부호에 따라 a에서 시작하여 b에서 끝(bth index의 요소 제외)이라고 하는 것입니다.위의 인덱싱 규칙을 사용하여 이 범위의 요소만 찾을 수 있음을 기억하십시오.
-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1
그러나 이 범위는 양방향으로 무한히 계속됩니다.
...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....
예를 들어 다음과 같습니다.
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, c에 대한 규칙을 사용하여 트래버스할 때 a, b, c 중 하나를 선택하면 (트래버설 중에 터치된) 요소가 포함된 목록이 나타나거나 빈 목록이 나타납니다.
마지막으로 a와 b가 같을 경우 빈 목록도 나타납니다.
>>> 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]
이 훌륭한 표는 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)해 보면, 간단한 은, 「로, 「이것」의 「」와 것을 알 수 .for★★★★★★★★★★★…
(from:to:step)
다음 중 하나를 선택할 수 있습니다.
(:to:step)
(from::step)
(from:to)
그런 다음 음의 인덱스를 이해하려면 문자열의 길이를 음의 인덱스에 추가하면 됩니다.
어쨌든 나한테는 이게 통하는데...
어떻게 동작하는지를 기억하기 쉬워지고, 그 후에 특정 시작/정지/스텝의 조합을 알아낼 수 있습니다.
하면 이 됩니다range() 번째 first:::
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의, ""step reach , " " " " 。stop아주 간단합니다.
해야 할 은 '네거티브 스텝'입니다.stop더 높든 낮든 항상 제외된 끝입니다.를 반대을 따로. 은 따로따로 하는 것이 'abcde'[1:-2][::-1]왼쪽에서 한 글자를, 오른쪽에서 두 글자를 잘라낸 후 반전합니다.( 도 참조).
시퀀스 슬라이싱은 처음에 음의 인덱스를 정규화하고 시퀀스를 벗어날 수 없다는 점을 제외하고는 동일합니다.
TODO: 아래 코드는 abs(스텝) > 1에서 "never go out the sequence"라는 버그가 발생하였습니다.정확하게 패치했다고 생각합니다만, 이해하기 어렵습니다.
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- 디테일 - 디테일 - 디테일 생략 - 디테일 생략 - 디테일 생략 - 디테일 사용 - 디테일 사용 - 디테일 사용 - 디테일 사용.start "/"/"stop모든 순서를 알려주는 건 항상 옳은 일이야
를 먼저 둘 다부터 독립적으로 할 수 있습니다.이거는 시작 또는 중지입니다.'abcde'[1:-2] == 'abcde'[1:3] == 'bc'불불에도 range(1,-2) == []는 「 length」라고되는 경우가 만, 예를 modulo the length」라고 하는 것은, 「 the length」라고 하는 해 주세요'abcde'[-53:42]그냥 전체 줄이에요.
저는 '요소 간 지수점'이라는 방법을 사용하여 직접 생각합니다만, 때때로 다른 사람이 이해하는 데 도움이 되는 한 가지 방법은 다음과 같습니다.
mylist[X:Y]
XXXXX자형입니다.
Y는 원하지 않는 첫 번째 요소의 색인입니다.
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 :
|--------------->
<---------------|
이것이 Python에서 목록을 모델링하는 데 도움이 되기를 바랍니다.
참고 자료: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages
초보자에게 슬라이스를 가르치는 방법은 다음과 같습니다.
인덱싱과 슬라이싱의 차이점 이해:
Wiki Python은 색인과 슬라이스를 명확하게 구분하는 놀라운 그림을 가지고 있습니다.
여섯 가지 요소가 들어 있는 목록입니다.슬라이싱을 더 잘 이해하려면 이 목록을 6개의 상자가 함께 배치된 세트로 간주하십시오.상자마다 알파벳이 들어 있다.
인덱싱은 상자의 내용을 다루는 것과 같습니다.모든 상자의 내용을 확인할 수 있습니다.하지만 여러 상자의 내용을 한 번에 확인할 수는 없습니다.상자의 내용물을 교체할 수도 있습니다.하지만 한 상자에 두 개의 공을 넣거나 한 번에 두 개의 공을 교체할 수는 없습니다.
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
슬라이스는 상자 자체를 다루는 것과 같습니다.첫 번째 상자를 들어 다른 테이블에 놓을 수 있습니다.상자를 집으려면 상자의 시작 위치와 끝 위치만 알면 됩니다.
처음 세 상자 또는 마지막 두 상자 또는 1에서 4 사이의 모든 상자를 선택할 수도 있습니다.그래서 처음과 끝을 알면 어떤 상자든 고를 수 있어요.이러한 위치를 시작 및 중지 위치라고 합니다.
흥미로운 점은 한 번에 여러 상자를 교체할 수 있다는 것입니다.또한 원하는 곳에 여러 상자를 놓을 수 있습니다.
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']
단계별 슬라이스:
지금까지 당신은 계속해서 상자를 골랐습니다.하지만 가끔은 따로따로 받을 필요가 있어요.예를 들어, 1초마다 상자를 픽업할 수 있습니다.심지어 마지막에서 세 번째 상자까지 집어들 수 있습니다.이 값을 스텝사이즈라고 부릅니다.이는 연속 픽업 간의 격차를 나타냅니다.처음부터 끝까지 상자를 선택할 경우 스텝 사이즈는 양수여야 합니다.또, 그 반대도 마찬가지입니다.
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이 누락된 매개 변수를 파악하는 방법:
슬라이스를 할 때 파라미터를 생략하면 Python은 자동으로 파악하려고 합니다.
CPython의 소스 코드를 체크하면 PySlice_GetIndicesEx()라는 함수를 찾을 수 있습니다.이 함수는 주어진 파라미터의 슬라이스에 대한 인덱스를 계산합니다.다음은 Python의 논리적인 동등한 코드입니다.
이 함수는 슬라이싱을 위한 Python 개체와 선택적 매개 변수를 가져와서 요청된 슬라이스의 시작, 중지, 단계 및 슬라이스 길이를 반환합니다.
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)
이것은 슬라이스 뒤에 존재하는 지능입니다.Python에는 슬라이스라는 함수가 내장되어 있기 때문에 몇 가지 파라미터를 전달하여 누락된 파라미터를 얼마나 스마트하게 계산하는지 확인할 수 있습니다.
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]
주의: 이 글은 원래 제 블로그 "The Intelligence Behind Python Slices"에 쓰여져 있습니다.
Python 슬라이싱 표기법:
a[start:end:step]
- ★★★의
start★★★★★★★★★★★★★★★★★」end으로 해석됩니다 - 의 :
end마지막으로 포함할 요소 뒤의 위치를 나타냅니다. - 과 같습니다.
[+0:-0:1]. - 하면 '이 됩니다.
start★★★★★★★★★★★★★★★★★」end
이 표기법은 (numpy) 행렬 및 다차원 배열까지 확장됩니다.예를 들어 전체 열을 슬라이스하려면 다음을 사용할 수 있습니다.
m[::,0:2:] ## slice the first two columns
슬라이스에는 배열 요소의 복사본이 아닌 참조가 저장됩니다.별도의 복사본을 배열로 만들려면 를 사용할 수 있습니다.
슬라이스 할당을 사용하여 목록에서 하나 이상의 요소를 제거할 수도 있습니다.
r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
이건 단지 몇 가지 추가 정보를 위해...아래 목록을 검토하십시오.
>>> l=[12,23,345,456,67,7,945,467]
목록을 반전하기 위한 몇 가지 다른 요령:
>>> 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]
1. 슬라이스 표기법
간단하게 하기 위해 슬라이스의 형식은 다음과 같습니다.
s[start:end:step]
동작은 다음과 같습니다.
s수 있는 : '슬라이스'start을 하는 첫 : " " " " " "end: 마지막 인덱스. 인덱스는 결과 슬라이스에 포함되지 않습니다.stepevery : 요소 선택step표시
또 다른 Import는 모두 end생략할 수 있습니다!이 값을 생략하면 기본값이 사용됩니다.0 ,len(s) ,1★★★★★★★★★★★★★★★★★★.
다음과 같은 종류가 있을 수 있습니다.
# 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[:]
의 : 만 、 만 、start >= end)step>0은 빈 Python을 [].
2. 함정
위 부분에서는 슬라이스의 동작에 관한 주요 기능에 대해 설명하고 있으며, 대부분의 경우 동작합니다.그러나 주의해야 할 함정이 있을 수 있으며, 이 부분은 그 함정에 대해 설명합니다.
마이너스 인덱스
Python 학습자를 혼란스럽게 하는 첫 번째 이유는 인덱스가 음수일 수 있다는 것이다!당황하지 마세요: 음의 지수는 거꾸로 세는 것을 의미합니다.
예를 들어 다음과 같습니다.
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].
네거티브 스텝
상황을 더 혼란스럽게 만드는 것은 부정적일 수도 있다!
마이너스 스텝은 배열을 거꾸로 반복하는 것을 의미합니다.끝에서 시작 인덱스는 포함되고 시작 인덱스는 결과에서 제외됩니다.
메모: 스텝이 음수일 경우 디폴트값:startlen(s)(일시적),end하지 않다0, 냐냐s[::-1]s[0]예를 들어 다음과 같습니다.
s[::-1] # Reversed slice
s[len(s)::-1] # The same as above, reversed slice
s[0:len(s):-1] # Empty list
범위를 벗어남 오류?
주의: 인덱스가 범위를 벗어나면 슬라이스에서 IndexError가 발생하지 않습니다.
를 Python으로 하기 위해 .0 ★★★★★★★★★★★★★★★★★」len(s)를 들어 다음과 같습니다예를 들어 다음과 같습니다.
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. 예
지금까지 설명한 내용을 모두 설명하면서 예를 들어 이 답변을 마치겠습니다.
# 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
일반적으로 다수의 하드코드된 인덱스 값을 사용하여 코드를 작성하면 가독성 및 유지관리 문제가 발생합니다.예를 들어, 1년 후에 코드로 돌아오면, 그것을 보고, 당신이 그것을 썼을 때 무슨 생각을 하고 있었는지 궁금해 할 것이다.여기에 나타내는 솔루션은 단순히 코드가 실제로 무엇을 하고 있는지를 보다 명확하게 기술하는 방법입니다.일반적으로 임베디드 슬라이스()는 슬라이스가 허용되는 곳이라면 어디서든 사용할 수 있는 슬라이스 개체를 만듭니다.예를 들어 다음과 같습니다.
>>> 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]
슬라이스 인스턴스(instance)가 있는 경우 각각 s.start, s.stop 및 s.step 속성을 확인하여 자세한 정보를 얻을 수 있습니다.예를 들어 다음과 같습니다.
>>> a = slice(10, 50, 2) >>> a.start 10 >>> a.stop 50 >>> a.step 2 >>>
이전 답변에서는 유명한 NumPy 패키지를 사용하여 가능한 다차원 배열 슬라이스에 대해서는 언급하지 않았습니다.
슬라이스는 다차원 어레이에도 적용할 수 있습니다.
# 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 번째 로 콤마가 "Coma" 가 "Coma" 가"Coma"는 ""가 "Comension으로 합니다.0:3:2표가두두 두번번후후후 후후후후후 。
슬라이스 규칙은 다음과 같습니다.
[lower bound : upper bound : step size]
I-변환upper bound ★★★★★★★★★★★★★★★★★」lower bound공통의 징후로.
II- 그럼 다음,step size양의 값 또는 음의 값입니다.
(i) 만약step size양의 값입니다.upper bound보다 커야 한다 lower bound그 이외의 경우empty string인쇄되어 있습니다.예를 들어 다음과 같습니다.
s="Welcome"
s1=s[0:3:1]
print(s1)
출력:
Wel
다만, 다음의 코드를 실행하고 있는 경우는,
s="Welcome"
s1=s[3:0:1]
print(s1)
빈 문자열이 반환됩니다.
(ii) 만약step size음의 값일 경우,upper bound보다 작아야 한다 lower bound그 이외의 경우empty string를 들면 다음과 같습니다예를 들어 다음과 같습니다.
s="Welcome"
s1=s[3:0:-1]
print(s1)
출력:
cle
하지만 다음 코드를 실행할 수 있습니다.
s="Welcome"
s1=s[0:5:-1]
print(s1)
출력은 빈 문자열이 됩니다.
코드에는 다음과 같은 것이 있습니다.
str = 'abcd'
l = len(str)
str2 = str[l-1:0:-1] #str[3:0:-1]
print(str2)
str2 = str[l-1:-1:-1] #str[3:-1:-1]
print(str2)
번째 음 in에서str2=str[l-1:0:-1] , . . . . . . . .upper bound보다 작다lower bounddcb인쇄되어 있습니다.
, ,에서는str2=str[l-1:-1:-1] , . . . . . . . .upper bound보다 작지 않다lower bound(변환시))lower bound마이너스 가치로 바꿔서-1 : 이 :index1 ㄴ 3)ㄹ 수 있다.
Python string slicing 표기법을 다음과 같이 보면 더 잘 이해하고 외울 수 있을 것 같습니다.
다음 문자열로 작업합니다.
azString = "abcdefghijklmnopqrstuvwxyz"
모르시는 '아까 하다'에서 .azString azString[x:y]
다른 프로그래밍 언어에서 온 것이므로, 그 때 상식이 손상됩니다.x와 y가 뭐죠?
저는 x와 y가 무엇인지 기억하고 첫 번째 시도에서 문자열을 올바르게 잘라내는 데 도움이 되는 암기 기술을 찾기 위해 앉아서 몇 가지 시나리오를 실행해야 했습니다.
결론적으로 x와 y는 추가하려는 문자열을 둘러싼 경계 인덱스로 간주해야 합니다. 이 을 '아까보다'라고 요.azString[index1, index2] 보다 azString[index_of_first_character, index_after_the_last_character].
다음은 ...의 시각화 예입니다.
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
따라서 index1과 index2를 원하는 서브스트링을 둘러싸는 값으로 설정하기만 하면 됩니다.들어 하려면 , 「cdefgh」를 합니다.azString[2:8] h의 c는 2로, h는 8로 되어 있습니다.
우리가 경계를 설정하고 있다는 것을 기억하십시오.그리고 그 경계는 이렇게 서브스트링에 둘러싸이는 브래킷을 배치할 수 있는 위치입니다.
a b [ c d e f g h ]ij
그 속임수는 항상 효과가 있고 외우기 쉽습니다.
는 개인적으로 그렇게 하고 있습니다.for 디세이블로그:
a[start:end:step]
# for(i = start; i < end; i += step)
「」의 해 주세요.start ★★★★★★★★★★★★★★★★★」end됩니다.given_index + a.shape[0].
#!/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)
이 스크립트를 실행하여 시험해 볼 수 있습니다.다음은 스크립트에서 얻은 샘플입니다.
+---+---+---+---+---+---+---+---+---+
| 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]
마이너스 스텝을 사용할 경우 정답이 오른쪽으로 1만큼 이동한다는 점에 유의하십시오.
는 그것을 것 같다.lst[start:end]를 포함합니다.start-thitem.- 항목입니다.나는 심지어 그것은 교육 assumption' 말할지도 모른다.나는 심지어 그것이 '자연스런 가정'이라고 말할 수도 있다.
에서 하지만 가끔 의심을 섬뜩하게 그리고 내 뇌으리라는 희망을 재확인하는 하지만을 함유하고 있지 않가끔에게 의심이 슬금슬금 다가와 내 뇌는 그 의심에 안심이 안 된다고 묻는다.end-th 요소이다.-번째 요소
이 때 나는 다음과 같은 간단한 정리에 의지한다.
for any n, lst = lst[:n] + lst[n:]
이 예쁜 재산 이내게 말해준다 물건은 예쁜라고 한다.lst[start:end]그 를 포함하지 않습니다 포함하지 않습니다.end-th 항목 때문에 아이템이 있기 때문에-에 있다.lst[end:].
에 대한이 정리는대해 참이다 것에 모든 이 정리 사실이 있다는 점에 유의하십시오.n조금도.조금도. 예를 들면,수 있습니다 체크할 that예를 들어,다음과 같이 확인할 수 있습니다.
lst = range(10)
lst[:-42] + lst[-42:] == lst
수익 돌아온다True.
초보자를 위한 슬라이스의 기본을 설명하는 Hello, World! 예를 하나 추가하겠습니다.많은 도움이 되었어요.
6값 6개의 값을가진리스트를 만들어 봅시다로 수록된 목록 합시다.['P', 'Y', 'T', 'H', 'O', 'N']:
+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
0 1 2 3 4 5
이제 그 목록의 가장 단순한 조각은 sublists 있다.이 목록에서 가장 간단한 슬라이스는 하위 목록입니다.은 「」입니다.[<index>:<index>]중요한 건 이렇게 읽는 거예요
[ start cutting before this index : end cutting before this index ]
, 을 만들면 now now now now now now now now now now now now[2:5]위의 목록 중 다음과 같은 일이 발생합니다.
| |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
0 1 | 2 3 4 | 5
인덱스가 있는 요소 앞에 절단했습니다.2그리고 색인이 있는 요소 앞에 또 다른 칼집을 냈습니다.5 그 컷 , 즉가 됩니다.['T', 'H', 'O'].
Python에서 슬라이스의 가장 기본적인 형태는 다음과 같습니다.
l[start:end]
서 ''는l 컬렉션입니다.startend을 사용하다
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]
처음부터 슬라이스할 때는 제로 인덱스를 생략할 수 있으며, 끝까지 슬라이스할 때는 용장성이 있으므로 최종 인덱스를 생략할 수 있습니다.
In [5]: l[:3] == l[0:3]
Out[5]: True
In [6]: l[7:] == l[7:len(l)]
Out[6]: True
음의 정수는 집합의 끝을 기준으로 오프셋을 수행할 때 유용합니다.
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]
슬라이스할 때 다음과 같은 범위를 벗어나는 지수를 제공할 수 있습니다.
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]
컬렉션을 슬라이스한 결과는 완전히 새로운 컬렉션이라는 점에 유의하십시오.또한 할당에서 슬라이스 표기법을 사용하는 경우 슬라이스 할당의 길이가 같을 필요는 없습니다.할당된 슬라이스 전후의 값은 유지되며 컬렉션은 축소되거나 확장되어 새 값이 포함됩니다.
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]
시작 인덱스와 종료 인덱스를 생략하면 컬렉션의 복사본이 생성됩니다.
In [14]: l_copy = l[:]
In [15]: l == l_copy and l is not l_copy
Out[15]: True
할당 작업을 수행할 때 시작 및 종료 인덱스를 생략하면 컬렉션의 전체 내용이 참조된 내용의 복사본으로 바뀝니다.
In [20]: l[:] = list('hello...')
In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']
기본 슬라이스 외에 다음과 같은 표기법을 적용할 수도 있습니다.
l[start:end:step]
서 ''는lstart' 지수입니다.end색인입니다.step모든 n번째 아이템에 사용할 수 있는 스트라이드입니다.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]
「」를 사용합니다.stepPython: Python의 유용한 은 Python: "Python" 입니다.
In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
의 정수를 .step다음 예시와 같습니다.
In[28]: l[::-2]
Out[28]: [9, 7, 5, 3, 1]
의 값을 하여 ""를 선택합니다.step매우 혼란스러울 수 있습니다.게다가, 피토닉이 되기 위해서, 당신은 피토닉을 사용하는 것을 피해야 한다.start,end , , , , 입니다.step할 에는 두 은 스트라이드로 나눠서 .이 작업이 필요한 경우 두 가지 과제(한쪽은 슬라이스, 다른 한쪽은 스트라이드)로 수행하는 것을 고려합니다.
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]
이전 답변의 대부분은 슬라이스 표기법에 대한 질문을 해결합니다.
그 확장된 색인 구문을 자를 있슬라이스에사용되는 확장다음과 같습니다 구문은 인덱싱 사용된다.aList[start:stop:step]그리고 기본적인 예는 바로및 기본적인 예는다음과 같습니다 있다.
다음과 같습니다
.
슬라이스 예: 15개의 확장 슬라이스
다음으로 문자열 인덱스의 예를 나타냅니다.
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
str="Name string"
슬라이스 예: [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
다음으로 사용 예를 나타냅니다.
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
만약 당신이 자르에 혼란스럽다 부정적인 지수를 느끼는데, 여기서 아주 쉬운 방법으로 그것에 대해 생각할:그냥 슬라이싱에서 마이너스지수가 혼란스럽다고 느낀다면, 여기 매우 쉽게와 생각할 수 있는방법이 있습니다:마이너스 지수를다음으로 대체하십시오는 부정적인 지수를 대신하게 됩니다.len - index. 예를 들어,예를 들어 -3을다음과 같이 치환합니다와-3교체한다.len(list) - 3.
슬라이싱이 내부적으로 어떤 역할을 하는지 설명하는 가장 좋은 방법은 이 작업을 구현하는 코드로 보여주는 것입니다.
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)]
Python tutorial diagram(다른 다양한 답변에 인용)은 이 제안이 긍정적인 보폭에서는 효과가 있지만 부정적인 보폭에서는 효과가 없다고 생각합니다.
그림은 다음과 같습니다.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
도표에서, 나는 도표상으로는을 기대한다.a[-4,-6,-1]되려골yP그러나 그것은그러나그것은 그렇다.ty.
>>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'
항상 기능하는 것은 문자나 슬롯으로 생각하고 인덱스를 반오픈 인터벌로 사용하는 것입니다.긍정적인 스트라이드는 오른쪽 오픈, 마이너스 스트라이드는 왼쪽 오픈입니다.
이 방법으로, 나는 하면수 있어 생각할 내가 이렇게의 생각할 수 있다.a[-4:-6:-1]~하듯이로a(-6,-4]간격 전문 용어에.간격terms로 지정합니다.
+---+---+---+---+---+---+
| 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
언급URL : https://stackoverflow.com/questions/509211/understanding-slicing
'itsource' 카테고리의 다른 글
| C에서 참조로 통과 (0) | 2022.09.28 |
|---|---|
| Python에서 epoch(unix time) 이후 datetime 개체를 밀리초로 변환하려면 어떻게 해야 합니까? (0) | 2022.09.28 |
| 라라벨 클래스 로더.php 오류: 스트림을 열지 못했습니다.해당 파일 또는 디렉터리가 없습니다. (0) | 2022.09.28 |
| PhpStorm 폴더 내용 또는 전체 프로젝트 트리를 새로 고치는 방법 (0) | 2022.09.28 |
| mysql 인덱스가 너무 많습니까? (0) | 2022.09.28 |