Python Language
인덱싱 및 분할

통사론

• obj [시작 : 중지 : 단계]
• 슬라이스 (정지)
• 슬라이스 (시작, 중지 [, 단계])

매개 변수

비고

기본 슬라이싱

어떤 반복 가능한 (예 : 문자열,리스트 등) 경우, 파이썬은 데이터의 하위 문자열이나 하위 목록을 슬라이스하여 반환 할 수 있습니다.

조각화 형식 :

iterable_name[start:stop:step]

어디에,

• start 는 슬라이스의 첫 번째 인덱스입니다. 기본값은 0 (첫 번째 요소의 인덱스)입니다.
• stop 슬라이스의 마지막 인덱스 과거를. 기본값은 len (iterable)입니다.
• step 은 단계 크기입니다 (아래 예제에서 더 잘 설명 됨).

예 :

a = "abcdef"
a            # "abcdef" 
             # Same as a[:] or a[::] since it uses the defaults for all three indices
a[-1]        # "f"
a[:]         # "abcdef" 
a[::]        # "abcdef" 
a[3:]        # "def" (from index 3, to end(defaults to size of iterable)) 
a[:4]        # "abcd" (from beginning(default 0) to position 4 (excluded)) 
a[2:4]       # "cd" (from position 2, to position 4 (excluded)) 

또한 위에 정의 된 단계 중 하나를 정의 된 단계 크기와 함께 사용할 수 있습니다.

a[::2]       # "ace" (every 2nd element)
a[1:4:2]     # "bd" (from index 1, to index 4 (excluded), every 2nd element)

인덱스는 음수 일 수 있습니다.이 경우 시퀀스의 끝에서 계산됩니다.

a[:-1]     # "abcde" (from index 0 (default), to the second last element (last element - 1))
a[:-2]     # "abcd" (from index 0 (default), to the third last element (last element -2))
a[-1:]     # "f" (from the last element to the end (default len()) 

단계 크기도 음수 일 수 있습니다.이 경우 슬라이스는 목록을 역순으로 반복합니다.

a[3:1:-1]   # "dc" (from index 2 to None (default), in reverse order)

이 구조체는 반복 가능한 (iterable)

a[::-1]     # "fedcba" (from last element (default len()-1), to first, in reverse order(-1))

음수 단계의 경우 기본 end_index 는 None ( http://stackoverflow.com/a/12521981 참조 ).

a[5:None:-1] # "fedcba" (this is equivalent to a[::-1])
a[5:0:-1]    # "fedcb" (from the last element (index 5) to second element (index 1)

배열의 얕은 사본 만들기

배열의 복사본을 만드는 빠른 방법은 (원래 배열에 다른 참조로 변수를 할당하는 것과는 대조적으로) 다음과 같습니다.

arr[:]

구문을 살펴 보겠습니다. [:] 은 start , end 및 slice 가 모두 생략되었음을 의미합니다. 그것들은 각각 기본값 0 , len(arr) , 1 의미합니다. 즉, 우리가 요청한 부분 배열은 처음부터 끝까지 arr 모든 요소를 ​​갖습니다.

실제로이 모양은 다음과 같습니다.

arr = ['a', 'b', 'c']
copy = arr[:]
arr.append('d')
print(arr)    # ['a', 'b', 'c', 'd']
print(copy)   # ['a', 'b', 'c']

보시다시피 arr.append('d') 가 arr 에 d 를 추가했지만 copy 은 변경되지 않았습니다.

이것은 얕은 복사본을 arr.copy() 와 동일합니다.

객체 반전

슬라이스를 사용하면 str , list 또는 tuple (또는 기본적으로 step 매개 변수로 슬라이스를 구현하는 모든 콜렉션 객체)을 쉽게 되돌릴 수 있습니다. 다음은 위에 나열된 다른 유형에도 똑같이 적용되지만 문자열을 뒤집는 예제입니다.

s = 'reverse me!'
s[::-1]    # '!em esrever'

구문을 빨리 살펴 보겠습니다. [::-1] 은 슬라이스가 문자열의 처음부터 끝까지 ( start 과 end 이 생략되었으므로) 있어야하고 -1 의 단계는 문자열을 역순으로 이동해야한다는 것을 의미합니다.

맞춤 클래스 인덱싱 : __getitem__, __setitem__ 및 __delitem__

class MultiIndexingList:
    def __init__(self, value):
        self.value = value
        
    def __repr__(self):
        return repr(self.value)
    
    def __getitem__(self, item):
        if isinstance(item, (int, slice)):
            return self.__class__(self.value[item])
        return [self.value[i] for i in item]
    
    def __setitem__(self, item, value):
        if isinstance(item, int):
            self.value[item] = value
        elif isinstance(item, slice):
            raise ValueError('Cannot interpret slice with multiindexing')
        else:
            for i in item:
                if isinstance(i, slice):
                    raise ValueError('Cannot interpret slice with multiindexing')
                self.value[i] = value
    
    def __delitem__(self, item):
        if isinstance(item, int):
            del self.value[item]
        elif isinstance(item, slice):
            del self.value[item]
        else:
            if any(isinstance(elem, slice) for elem in item):
                raise ValueError('Cannot interpret slice with multiindexing')
            item = sorted(item, reverse=True)
            for elem in item:
                del self.value[elem]

이렇게하면 요소 액세스에 대한 분할 및 인덱싱이 가능합니다.

a = MultiIndexingList([1,2,3,4,5,6,7,8])
a
# Out: [1, 2, 3, 4, 5, 6, 7, 8]
a[1,5,2,6,1]
# Out: [2, 6, 3, 7, 2]
a[4, 1, 5:, 2, ::2]
# Out: [5, 2, [6, 7, 8], 3, [1, 3, 5, 7]]
#       4|1-|----50:---|2-|-----::2-----   <-- indicated which element came from which index

요소를 설정하고 삭제하는 동안에는 쉼표로 구분 된 정수 인덱싱 만 허용됩니다 (슬라이스 없음).

a[4] = 1000
a
# Out: [1, 2, 3, 4, 1000, 6, 7, 8]
a[2,6,1] = 100
a
# Out: [1, 100, 100, 4, 1000, 6, 100, 8]
del a[5]
a
# Out: [1, 100, 100, 4, 1000, 100, 8]
del a[4,2,5]
a
# Out: [1, 100, 4, 8]

조각 지정

슬라이스를 사용하는 또 다른 깔끔한 기능은 슬라이스 할당입니다. 파이썬은 한 번의 작업으로 새로운 슬라이스를 할당하여리스트의 오래된 슬라이스를 대체합니다.

즉, 목록이있는 경우 단일 할당에서 여러 멤버를 바꿀 수 있습니다.

lst = [1, 2, 3]
lst[1:3] = [4, 5]
print(lst) # Out: [1, 4, 5]

할당이 크기가 일치해서는 안되기 때문에 이전 슬라이스를 크기가 다른 새 슬라이스로 바꾸려면 다음을 수행 할 수 있습니다.

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6]
print(lst) # Out: [1, 6, 5]

또한 알려진 슬라이싱 구문을 사용하여 전체 목록을 바꾸는 것과 같은 작업을 수행 할 수도 있습니다.

lst = [1, 2, 3]
lst[:] = [4, 5, 6]
print(lst) # Out: [4, 5, 6]

아니면 그냥 마지막 두 멤버 :

lst = [1, 2, 3]
lst[-2:] = [4, 5, 6]
print(lst) # Out: [1, 4, 5, 6]

조각 개체

조각은 자체 개체이며 slice() 함수가 내장 된 변수에 저장할 수 있습니다. 슬라이스 변수는 코드를 읽기 쉽도록 만들고 재사용을 촉진하는 데 사용할 수 있습니다.

>>> programmer_1 = [ 1956, 'Guido', 'van Rossum', 'Python', 'Netherlands']
>>> programmer_2 = [ 1815, 'Ada', 'Lovelace', 'Analytical Engine', 'England']
>>> name_columns = slice(1, 3)
>>> programmer_1[name_columns]
['Guido', 'van Rossum']
>>> programmer_2[name_columns]
['Ada', 'Lovelace']

기본 인덱싱

파이썬리스트는 0을 기본으로합니다. 즉 , 목록의 첫 번째 요소는 인덱스 0 으로 액세스 할 수 있습니다

arr = ['a', 'b', 'c', 'd']
print(arr[0])
>> 'a'

목록에서 두 번째 요소는 인덱스 1 , 세 번째 요소는 인덱스 2 액세스 할 수 있습니다.

print(arr[1])
>> 'b'
print(arr[2])
>> 'c'

음수 인덱스를 사용하여 목록의 끝에서 요소에 액세스 할 수도 있습니다. 예. 색인 -1 은 목록의 마지막 요소를 제공하고 색인 -2 는 목록의 두 번째 - 마지막 요소를 제공합니다.

print(arr[-1])
>> 'd'
print(arr[-2])
>> 'c'

목록에없는 색인에 액세스하려고하면 IndexError 가 발생합니다.

print arr[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range