etc./StackOverFlow

슬라이스 표기법 이해

청렴결백한 만능 재주꾼 2021. 9. 26. 10:52
반응형

질문자 :Simon


파이썬의 슬라이스 표기법에 대한 좋은 설명이 필요합니다(참조는 플러스입니다).

나에게 이 표기법은 약간의 이해가 필요합니다.

그것은 매우 강력해 보이지만 나는 그것에 대해 머리가 좋지 않습니다.



답변자 : Greg Hewgill


정말 간단합니다.

 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

기억해야 할 핵심 사항은 :stop 값이 선택한 슬라이스에 없는 첫 번째 값을 나타낸다는 것입니다. stopstart 의 차이는 선택한 요소의 수입니다( step 가 1인 경우 기본값).

다른 기능은 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

마찬가지로 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

파이썬은 당신이 요구하는 것보다 적은 항목이 있다면 프로그래머에게 친절합니다. 예를 들어, a[:-2] a 하나만 포함되어 있으면 오류 대신 빈 목록이 표시됩니다. 때로는 오류를 선호하므로 이런 일이 발생할 수 있음을 알아야 합니다.

slice() 객체와의 관계

슬라이싱 연산자 [] 는 실제로 위의 코드에서 : [] 내에서만 유효 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)] )과 동일합니다. a[slice(None, None, -1)] .

: 기반 표기법은 간단한 슬라이싱에 매우 유용하지만, slice() 객체를 명시적으로 사용하면 슬라이싱의 프로그래밍 방식 생성이 단순화됩니다.



답변자 : Hans Nowak


Python 튜토리얼에서 이에 대해 설명합니다(슬라이싱에 대한 부분이 나올 때까지 아래로 스크롤).

ASCII 아트 다이어그램은 슬라이스 작동 방식을 기억하는 데에도 유용합니다.

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

슬라이스가 작동하는 방식을 기억하는 한 가지 방법은 인덱스 문자 사이를 가리키는 것으로 생각하는 것입니다. 첫 번째 문자의 왼쪽 가장자리는 0으로 번호가 매겨져 있습니다. 그러면 n개의 문자로 구성된 문자열의 마지막 문자의 오른쪽 가장자리는 인덱스 n을 갖습니다.



답변자 : ephemient


문법이 허용하는 가능성 열거:

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

물론 (high-low)%stride != 0 high-1 보다 약간 낮습니다.

stride 가 음수이면 카운트다운 중이므로 순서가 약간 변경됩니다.

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

확장 슬라이싱(쉼표 및 타원 포함)은 주로 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)'


답변자 : David M. Perlman


위의 답변은 슬라이스 할당에 대해 논의하지 않습니다. 슬라이스 할당을 이해하려면 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]

이것은 또한 슬라이싱과 인덱싱의 차이점을 명확히 할 수 있습니다.



답변자 : Aaron Hall


Python의 슬라이스 표기법 설명

간단히 말해서, 아래 첨자 표기법( subscriptable[subscriptarg] : )은 슬라이스 표기법을 만듭니다. 여기에는 선택적 인수인 start , stop , step .

 sliceable[start:stop:step]

Python 슬라이싱은 데이터의 일부에 체계적으로 액세스하는 계산상 빠른 방법입니다. 제 생각에는 중급 파이썬 프로그래머가 되려면 익숙해져야 하는 언어의 한 측면입니다.

중요한 정의

먼저 몇 가지 용어를 정의해 보겠습니다.

start: 슬라이스의 시작 인덱스, stop 과 동일하지 않으면 이 인덱스의 요소를 포함합니다. 기본값은 0, 즉 첫 번째 인덱스입니다. 음수이면 끝에서 n 개 항목을 시작한다는 의미입니다.

stop: 슬라이스의 끝 인덱스, 이 인덱스에 있는 요소는 포함하지 않습니다 . 기본값은 슬라이스되는 시퀀스의 길이, 즉 끝을 포함하는 길이입니다.

단계: 인덱스가 증가하는 양, 기본값은 1입니다. 음수이면 이터러블을 반대로 슬라이싱합니다.

인덱싱 작동 방식

이러한 양수 또는 음수를 만들 수 있습니다. 양수의 의미는 간단하지만 음수의 경우 Python의 인덱스와 마찬가지로 시작중지에 대해 끝에서 거꾸로 계산하고 단계 에 대해 단순히 인덱스를 감소시킵니다. 이 예제는 설명서의 tutorial 에서 가져온 것이지만 각 인덱스가 참조하는 시퀀스의 항목을 나타내기 위해 약간 수정했습니다.

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

슬라이싱 작동 방식

슬라이스 표기법을 지원하는 시퀀스와 함께 사용하려면 시퀀스 다음에 오는 대괄호에 하나 이상의 콜론을 포함해야 합니다(이는 Python 데이터 모델에 따라 시퀀스 __getitem__ 메서드를 실제로 구현함 ).

슬라이스 표기법은 다음과 같이 작동합니다.

 sequence[start:stop:step]

start , stopstep 에 대한 기본값이 있으므로 기본값에 액세스하려면 인수를 생략하면 됩니다.

목록(또는 문자열과 같이 이를 지원하는 다른 시퀀스)에서 마지막 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에서 목록의 얕은 복사본을 만드는 관용적 방법은 다음과 같습니다.

 list_copy = sequence[:]

그리고 그것들을 지우는 것은 다음과 같습니다:

 del my_list[:]

(Python 3은 list.copylist.clear 메서드를 얻습니다.)

step 가 음수이면 startstop 변경의 기본값

기본적으로 step 인수가 비어 있으면(또는 None +1 할당됩니다.

그러나 음의 정수를 전달할 수 있으며 목록(또는 대부분의 다른 표준 슬라이스)은 끝에서 처음으로 슬라이스됩니다.

startstop 대한 기본값을 변경합니다!

소스에서 확인

나는 사용자가 문서뿐만 아니라 소스도 읽도록 권장하고 싶습니다. 슬라이스 개체 및 이 논리에 대한 소스 코드는 여기에서 찾을 수 있습니다 . step 가 음수인지 확인합니다.

 step_is_negative = step_sign < 0;

그렇다면 하한은 -1 로 시작을 포함하여 끝까지 슬라이스하고 상한은 길이에서 1을 빼서 끝에서 시작함을 의미합니다. -1 의 의미는 사용자가 Python에서 마지막 항목을 나타내는 인덱스를 전달할 수 있는 -1 과 다릅니다.)

 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); }

그런 다음, 우리는의 기본값 적용해야 할 수도 있습니다 startstop 위해 다음의 기본을 - 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__ 메소드에 전달하는 것을 분리하는 것이 유용할 수 있습니다 (대괄호가 하는 일입니다 ). 처음 사용하지 않더라도 코드를 더 읽기 쉽게 유지하므로 코드를 읽어야 할 수도 있는 다른 사람들이 당신이 하는 일을 더 쉽게 이해할 수 있습니다.

그러나 콜론으로 구분된 일부 정수를 변수에 할당할 수는 없습니다. 슬라이스 객체를 사용해야 합니다.

 last_nine_slice = slice(-9, None)

두 번째 인수 None 이 필요하므로 첫 번째 인수가 start 인수 로 해석되지 않으면 stop 인수가 됩니다.

그런 다음 슬라이스 객체를 시퀀스에 전달할 수 있습니다.

 >>> 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 대한 음수 인수를 지원하지 않으므로 이것이 문제라면 미리 인덱스를 계산하거나 iterable을 되돌려야 할 수도 있습니다.

 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]

목록 조각이 복사본을 만든다는 사실은 목록 자체의 기능입니다. Pandas DataFrame과 같은 고급 개체를 슬라이싱하는 경우 복사본이 아닌 원본에 대한 보기를 반환할 수 있습니다.



답변자 : Dana


슬라이싱 구문을 처음 보았을 때 즉시 명확하지 않았던 몇 가지 사항:

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


답변자 : Ankur Agarwal


파이썬 2.7에서

파이썬에서 슬라이싱

 [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(앞으로 또는 뒤로)의 부호에 따라 b에서 시작하여 b에서 끝납니다(b번째 인덱스의 요소 제외). 위의 인덱싱 규칙을 사용하고 이 범위의 요소만 찾을 수 있음을 기억하십시오.

 -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 astring -9 -8 -7 -6 -5 -4 -3 -2 -1

위의 a,b,c에 대한 규칙을 사용하여 순회할 때 a, b 및 c를 선택하여 위 범위와 겹칠 수 있는 경우 요소가 포함된 목록(순회 중에 터치됨)을 얻거나 빈 목록을 얻습니다.

마지막으로 와 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]


답변자 : AdrianoFerrari


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)


답변자 : Simon


그것을 조금 사용한 후에 나는 가장 간단한 설명이 for 루프의 인수와 정확히 동일하다는 것을 깨달았습니다...

 (from:to:step)

그 중 하나는 선택 사항입니다.

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

그런 다음 음수 인덱싱은 문자열의 길이를 음수 인덱스에 추가하여 이해하기만 하면 됩니다.

어쨌든 이것은 나를 위해 작동합니다 ...



답변자 : Beni Cherniavsky-Paskin


작동 방식을 더 쉽게 기억하고 특정 시작/중지/단계 조합을 파악할 수 있습니다.

먼저 range() 를 이해하는 것이 좋습니다.

 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 에 도달하지 않는, stop . 매우 간단합니다.

음수 단계에 대해 기억해야 할 점은 stop 가 높거나 낮거나 상관없이 항상 제외된 끝이라는 것입니다. 동일한 슬라이스를 반대 순서로 원하면 개별적으로 반전을 수행하는 것이 훨씬 더 깔끔합니다. 예를 들어 'abcde'[1:-2][::-1] 은 왼쪽에서 하나의 문자를, 오른쪽에서 두 개를 잘라낸 다음 반대로 합니다. (또한 reversed() 참조하십시오.)

시퀀스 슬라이싱은 먼저 음수 인덱스를 정규화하고 시퀀스 외부로 나갈 수 없다는 점을 제외하면 동일합니다.

TODO : 아래 코드에는 abs(step)>1일 때 "절대 시퀀스 외부로 나가지 않음"이라는 버그가 있습니다. 나는 그것을 올바른로 패치 생각하지만, 그것은 이해하기 어렵다.

 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) == [] 에도 불구하고 range(1,-2) == [] . 정규화는 때때로 "모듈로 길이"로 생각되지만 길이는 한 번만 추가됩니다. 예를 들어 'abcde'[-53:42] 는 전체 문자열일 뿐입니다.



답변자 : Steve Losh


나는 그것에 대해 스스로 생각하는 "요소 사이의 인덱스 포인트" 방법을 사용하지만 때때로 다른 사람들이 그것을 이해하는 데 도움이 되는 한 가지 설명 방법은 다음과 같습니다.

 mylist[X:Y]

X는 원하는 첫 번째 요소의 인덱스입니다.
Y는 원하지 않는 첫 번째 요소의 인덱스입니다.



답변자 : xiaoyu


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

이것이 파이썬에서 목록을 모델링하는 데 도움이 되기를 바랍니다.

참조: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages



답변자 : Brent Bradburn


Python 슬라이싱 표기법:

 a[start:end:step]
  • startend 경우 음수 값은 시퀀스의 끝을 기준으로 하는 것으로 해석됩니다.
  • end 양수 인덱스는 포함할 마지막 요소 의 위치를 나타냅니다.
  • 공백 값의 기본값은 [+0:-0:1] 입니다.
  • startend 의 해석이 반대로 됩니다.

표기법은 (numpy) 행렬 및 다차원 배열로 확장됩니다. 예를 들어 전체 열을 슬라이스하려면 다음을 사용할 수 있습니다.

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

슬라이스는 배열 요소의 복사본이 아닌 참조를 보유합니다. 별도의 복사본을 배열로 만들고 싶다면 deepcopy() 사용할 수 있습니다.



답변자 : ChillarAnand


이것이 내가 초보자에게 슬라이스를 가르치는 방법입니다.

인덱싱과 슬라이싱의 차이점 이해하기:

Wiki Python에는 인덱싱과 슬라이싱을 명확하게 구분하는 이 놀라운 그림이 있습니다.

여기에 이미지 설명 입력

6개의 요소가 포함된 목록입니다. 슬라이싱을 더 잘 이해하려면 해당 목록을 함께 배치된 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']

단계로 슬라이싱:

지금까지 계속해서 상자를 선택했습니다. 그러나 때때로 당신은 개별적으로 픽업해야 합니다. 예를 들어 매 두 번째 상자를 선택할 수 있습니다. 끝에서 세 번째 상자를 모두 선택할 수도 있습니다. 이 값을 단계 크기라고 합니다. 이것은 연속적인 픽업 사이의 간격을 나타냅니다. 처음부터 끝까지 또는 그 반대로 상자를 선택하는 경우 단계 크기는 양수여야 합니다.

 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에는 slice라는 내장 함수가 있으므로 일부 매개변수를 전달하고 누락된 매개변수를 얼마나 똑똑하게 계산하는지 확인할 수 있습니다.

 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]

참고: 이 게시물은 원래 내 블로그인 Intelligence Behind Python Slices 에 작성되었습니다.



답변자 : dansalmo


슬라이스 할당을 사용하여 목록에서 하나 이상의 요소를 제거할 수도 있습니다.

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


답변자 : Arindam Roychowdhury


이것은 단지 추가 정보를 위한 것입니다... 아래 목록을 고려하십시오

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


답변자 : Python_Dude


일반적으로 하드코딩된 인덱스 값이 많은 코드를 작성하면 가독성과 유지 관리가 엉망이 됩니다. 예를 들어, 1년 후에 코드를 다시 보면 코드를 보고 작성했을 때 무슨 생각을 하고 있었는지 궁금할 것입니다. 표시된 솔루션은 단순히 코드가 실제로 수행하는 작업을 보다 명확하게 설명하는 방법입니다. 일반적으로 내장 slice()는 슬라이스가 허용되는 모든 곳에서 사용할 수 있는 슬라이스 객체를 만듭니다. 예를 들어:

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

슬라이스 인스턴스 s가 있는 경우 각각 s.start, s.stop 및 s.step 속성을 보면 이에 대한 자세한 정보를 얻을 수 있습니다. 예를 들어:

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


답변자 : cizixs


1. 슬라이스 표기법

간단하게 하기 위해 슬라이스에는 하나의 형식만 있음을 기억하십시오.

 s[start:end:step]

작동 방식은 다음과 같습니다.

  • s : 슬라이싱 가능한 객체
  • start : 반복을 시작할 첫 번째 인덱스
  • end : 마지막 인덱스, end 인덱스는 결과 슬라이스에 포함되지 않습니다.
  • step : 모든 step 인덱스 요소 선택

또 다른 중요한 점: 모든 start , end , step 은 생략할 수 있습니다! 그리고 생략하면 기본값이 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. 함정

위 부분은 슬라이스 작동 방식에 대한 핵심 기능을 설명하며 대부분의 경우 작동합니다. 그러나 주의해야 할 함정이 있을 수 있으며 이 부분에서 설명합니다.

음수 인덱스

파이썬 학습자를 혼란스럽게 하는 첫 번째 것은 인덱스가 음수일 수 있다는 것입니다! 당황하지 마십시오. 음수 인덱스는 거꾸로 세는 것을 의미합니다.

예를 들어:

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

네거티브 스텝

상황을 더 혼란스럽게 만드는 것은 step 도 부정적일 수 있다는 것입니다!

음수 단계는 배열을 거꾸로 반복하는 것을 의미합니다. 끝 인덱스가 포함되고 시작 인덱스가 결과에서 제외된 상태에서 끝에서 시작으로 배열을 반복합니다.

참고 : 단계가 음수이면 start 의 기본값은 len(s) ( s[::-1] s[0] 가 포함되어 있기 때문에 end 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


답변자 : Statham


이전 답변에서는 유명한 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 "는 첫 번째 차원에서 0:3:2 "는 두 번째 차원에서 작동합니다.



답변자 : BitFlip


개인적으로 for 루프처럼 생각합니다.

 a[start:end:step] # for(i = start; i < end; i += step)

startend 대한 음수 값은 목록의 끝을 기준으로 하며 위의 예에서 given_index + a.shape[0] 계산됩니다.



답변자 : asiby


제 생각에는 다음과 같은 방식으로 보면 파이썬 문자열 슬라이싱 표기법을 더 잘 이해하고 기억할 수 있을 것입니다(읽기).

다음 문자열로 작업합시다 ...

 azString = "abcdefghijklmnopqrstuvwxyz"

azString[x:y] 표기법을 사용하여 azString 에서 하위 문자열을 만들 수 있습니다.

다른 프로그래밍 언어에서 온 것은 상식이 손상되는 때입니다. x와 y는 무엇입니까?

x와 y가 무엇인지 기억하고 첫 번째 시도에서 문자열을 적절하게 슬라이스하는 데 도움이 되는 암기 기술을 찾기 위해 앉아서 여러 시나리오를 실행해야 했습니다.

내 결론은 x와 y는 우리가 추가하려는 문자열을 둘러싼 경계 인덱스로 간주되어야 한다는 것입니다. 따라서 표현식을 azString[index1, index2] 또는 더 명확하게 azString[index_of_first_character, index_after_the_last_character] 합니다.

다음은 그 시각화의 예입니다 ...

 Letters abcdefghij ... ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ┊ ┊ Indexes 0 1 2 3 4 5 6 7 8 9 ... ┊ ┊ cdefgh index1 index2

따라서 index1과 index2를 원하는 부분 문자열을 둘러쌀 값으로 설정하기만 하면 됩니다. 예를 들어 "cdefgh" 하위 문자열을 가져오려면 "c"의 왼쪽 인덱스가 2이고 "h"의 오른쪽 크기 인덱스가 azString[2:8]

우리가 경계를 설정하고 있음을 기억하십시오. 그리고 그 경계는 다음과 같이 부분 문자열을 감싸는 일부 대괄호를 배치할 수 있는 위치입니다 ...

ab [ cdefgh ] ij

그 트릭은 항상 작동하고 암기하기 쉽습니다.



답변자 : mahmoh


#!/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만큼 오른쪽으로 이동하는 것에 주목하십시오.



답변자 : Robert


lst[start:end] start 항목이 포함되어 있다는 사실을 기꺼이 받아들이는 것 같습니다. '당연한 가정'이라고 할 수 있습니다.

그러나 때때로 의심이 싹트고 내 뇌는 그것이 end -th 요소를 포함하지 않는다는 확신을 요청합니다.

이 순간에 나는 다음과 같은 간단한 정리에 의존합니다.

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

이 예쁜 속성은 lst[start:end] lst[end:] 에 있기 때문에 end -th 항목을 포함하지 않는다는 것을 알려줍니다.

이 정리는 모든 n 에 대해 사실입니다. 예를 들어 다음을 확인할 수 있습니다.

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

True 반환합니다.



답변자 : Jeyekomon


Hello, World를 하나 추가하고 싶습니다! 초심자를 위한 슬라이스의 기본을 설명하는 예제입니다. 많은 도움이 되었습니다.

['P', 'Y', 'T', 'H', 'O', 'N'] 이 있는 목록이 있다고 가정해 보겠습니다.

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

이제 해당 목록의 가장 간단한 조각은 하위 목록입니다. 표기법은 [<index>:<index>] 이고 핵심은 다음과 같이 읽는 것입니다.

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

이제 위 목록의 조각 [2:5] 을 만들면 다음과 같은 일이 발생합니다.

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

당신은 인덱스 요소 전에 상처를 만들어 2 인덱스를 가진 요소 전에 다른 컷 5 . ['T', 'H', 'O'] 두 컷 사이의 슬라이스가 됩니다.



답변자 : lmiguelvargasf


Python에서 가장 기본적인 슬라이싱 형식은 다음과 같습니다.

 l[start:end]

여기서 l 은 컬렉션이고 start 는 포함 인덱스이며 end 는 배타적 인덱스입니다.

 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]

처음부터 슬라이싱할 때 0 인덱스를 생략할 수 있고, 끝까지 슬라이싱할 때 마지막 인덱스가 중복되므로 생략할 수 있으므로 장황하게 말하지 마십시오.

 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]

여기서 l 은 컬렉션, start 는 포함 인덱스, end 는 배타적 인덱스, step l 모든 n번째 항목을 가져오는 데 사용할 수 있는 보폭입니다.

 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]

step 사용하면 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 음수 값을 사용하면 매우 혼란스러울 수 있습니다. 게다가 Pythonic 이 되려면 단일 슬라이스에서 start , endstep 사용을 피해야 합니다. 이것이 필요한 경우 두 가지 할당(하나는 슬라이스, 다른 하나는 스트라이드)으로 수행하는 것을 고려하십시오.

 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]


답변자 : Roshan Bagdiya


이전 답변의 대부분은 슬라이스 표기법에 대한 질문을 해결합니다.

슬라이싱에 사용되는 확장 인덱싱 구문은 aList[start:stop:step] 이며 기본 예는 다음과 같습니다.

여기에 이미지 설명 입력 :

추가 슬라이싱 예제: 15개의 확장 슬라이스



답변자 : Prince Dhadwal


다음은 문자열 인덱스의 예입니다.

 +---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1 str="Name string"

슬라이싱 예: [시작:종료:단계]

 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


답변자 : Shital Shah


슬라이싱에서 음수 인덱스가 혼란스럽다고 생각되면 매우 쉽게 생각할 수 있습니다. 음수 인덱스를 len - index 로 바꾸면 됩니다. 예를 들어 -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)]


답변자 : Anshika Singh


슬라이스 규칙은 다음과 같습니다.

 [lower bound : upper bound : step size]

I- upper boundlower bound 을 공통 기호로 변환합니다.

II- 그런 다음 step size양수 또는 음수 값인지 확인합니다.

(ⅰ)하면 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)

빈 문자열 을 반환합니다.

(ⅱ)하면 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)

제에서 str2=str[l-1:0:-1]upper bound 댄 상대lower bound 따라서 dcb 인쇄된다.

그러나 str2=str[l-1:-1:-1] 에서 upper boundlower bound 보다 작지 않습니다 lower bound-1 음수 값 으로 변환할 때 : 마지막 요소의 index 3)과 같이.



답변자 : Babu Chandermani


기본 슬라이싱 기술은 시작점, 중지점 및 보폭이라고도 하는 단계 크기를 정의하는 것입니다.

먼저 슬라이싱에 사용할 값 목록을 만듭니다.

슬라이스할 두 개의 목록을 만듭니다. 첫 번째는 1에서 9까지의 숫자 목록(목록 A)입니다. 두 번째는 0에서 9까지의 숫자 목록(목록 B)이기도 합니다.

 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에서 숫자 3을, B에서 숫자 6을 인덱싱합니다.

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

기본 슬라이싱

슬라이싱에 사용되는 확장 인덱싱 구문은 aList[start:stop:step]입니다. 시작 인수와 단계 인수는 모두 기본값이 없음으로 설정되어 있습니다. 필요한 인수는 stop뿐입니다. 이것이 범위가 목록 A와 B를 정의하는 데 사용된 방식과 유사하다는 것을 눈치채셨나요? 이것은 slice 객체가 range(start, stop, step)로 지정된 인덱스 집합을 나타내기 때문입니다. 파이썬 3.4 문서.

보시다시피 stop만 정의하면 하나의 요소가 반환됩니다. 시작은 기본적으로 없음으로 설정되어 있으므로 이는 하나의 요소만 검색하는 것으로 해석됩니다.

첫 번째 요소는 인덱스 1이 아니라 인덱스 0이라는 점에 유의하는 것이 중요합니다. 이것이 이 연습에서 2개의 목록을 사용하는 이유입니다. 목록 A의 요소는 서수 위치에 따라 번호가 매겨집니다(첫 번째 요소는 1, 두 번째 요소는 2 등). 반면 목록 B의 요소는 색인을 만드는 데 사용되는 숫자입니다(첫 번째 요소 0의 경우 [0], 등.).

확장된 인덱싱 구문을 사용하여 값 범위를 검색합니다. 예를 들어, 모든 값은 콜론으로 검색됩니다.

 A[:]

요소의 하위 집합을 검색하려면 시작 및 중지 위치를 정의해야 합니다.

aList[start:stop] 패턴이 주어지면 List A에서 처음 두 요소를 검색합니다.



출처 : Here


출처 : http:www.stackoverflow.com/questions/509211/understanding-slice-notation">

반응형