(5min. Python) Slice / Slicing, 슬라이싱의 이해 ( ASCII art diagram )

"Life is too short, You need python"

슬라이싱(slicing) / 슬라이스(slice)는 연속적인 객체들에(예: 리스트, 튜플, 문자열) 범위를 지정해 선택해서 객체들을 가져오는 방법 및 표기법을 의미합니다. 슬라이스 작동 방식을 쉽고 간단히 이해할 수 있는 좋은 자료를 소개하겠습니다.

 

---

 

The ASCII art diagram, 아스키 아트 다이아그램

 

 

 

아주 간단명료하게 슬라이스의 작동 방식을 나타낸 자료입니다.

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)

인덱싱(indexing)이란 무언가를 가리킨다는 뜻으로 연속적인 객체(리스트, 튜플, 문자열)에 부여된 번호를 의미합니다. 쉽게 말해서 원하는 값을 가리킬 때 indexing을 사용합니다.

 

슬라이싱(slicing)이란 무언가를 잘란 낸다는 뜻으로 연속적인 객체(리스트, 튜플, 문자열)에 부여된 번호를 이용해 연속된 객체에 일부를 추출하는 작업입니다.

 

기본 사용법

 

s[ start : stop : step ]

 

1. start : 객체에서 가져올 시작 인덱스(index) 값입니다. start 인덱스(index) 값부터 객체에 일부를 가져옵니다.
2. end : end는 말 그대로 마지막 객체까지의 값을 가져올 인덱스(index) 값입니다. 여기서 주의해야 될 점은 start는 start 인덱스(index) 값부터 시작이지만 end는 end 인덱스(index) 값 전까지 객체를 가져옵니다.
3. step : step은 step 인덱스(index) 만큼 건너뛰어서 객체 값을 가져옵니다. (생략할 경우 인덱스(index) 값은 1이 됩니다.)

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

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

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

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

 

---

 

활용 예

 

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]
# 이것은 또한 슬라이싱과 인덱싱의 차이점을 명확히 할 수 있습니다.

 

---

 

마무리

 

슬라이스에 대해 한눈에 파악할 수 있는 간단한 자료와 설명을 준비해 보았습니다.

좀 더 자세한 내용이 알고 싶은 분들을 위하여 추후 자세한 자료 준비하여 올리도록 하겠습니다.