파이썬에서 하나의 항목을 * 제외 *하는 모든 인덱스

목록 (또는 배열 등)의 모든 요소를 ​​인덱싱하는 간단한 방법이 있습니까? 특정 인덱스를 제외하고 있습니까? 예 :

• mylist[3] 위치 3의 항목을 반환합니다.

• milist[~3] 3을 제외한 전체 목록을 반환합니다.

A에 대한 목록 , 당신은 목록 빌려 사용할 수 있습니다. 예를 들어, 세 번째 요소없이 b복사본 을 만들려면 a:

a = range(10)[::-1]                       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
b = [x for i,x in enumerate(a) if i!=3]   # [9, 8, 7, 5, 4, 3, 2, 1, 0]

이것은 매우 일반적이며 numpy 배열을 포함하여 모든 이터 러블과 함께 사용할 수 있습니다. 당신이 교체하는 경우 []와 (),b 반복자 대신의 목록이 될 것입니다.

또는 다음을 사용하여이 작업을 수행 할 수 있습니다 pop.

a = range(10)[::-1]     # a = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
a.pop(3)                # a = [9, 8, 7, 5, 4, 3, 2, 1, 0]

numpy 에서는 부울 인덱싱으로이를 수행 할 수 있습니다.

a = np.arange(9, -1, -1)     # a = array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
b = a[np.arange(len(a))!=3]  # b = array([9, 8, 7, 5, 4, 3, 2, 1, 0])

일반적으로 위에 나열된 목록 이해력보다 훨씬 빠릅니다.

>>> l = range(1,10)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[:2] 
[1, 2]
>>> l[3:]
[4, 5, 6, 7, 8, 9]
>>> l[:2] + l[3:]
[1, 2, 4, 5, 6, 7, 8, 9]
>>> 

또한보십시오

Python의 슬라이스 표기법 설명

내가 찾은 가장 간단한 방법은 다음과 같습니다.

mylist[:x]+mylist[x+1:]

mylistindex에 요소없이 생성됩니다 x.

numpy를 사용하고 있다면 가장 가까운 것은 마스크를 사용하는 것입니다.

>>> import numpy as np
>>> arr = np.arange(1,10)
>>> mask = np.ones(arr.shape,dtype=bool)
>>> mask[5]=0
>>> arr[mask]
array([1, 2, 3, 4, 5, 7, 8, 9])

itertools없이 사용하여 비슷한 것을 얻을 수 있습니다.numpy

>>> from itertools import compress
>>> arr = range(1,10)
>>> mask = [1]*len(arr)
>>> mask[5]=0
>>> list(compress(arr,mask))
[1, 2, 3, 4, 5, 7, 8, 9]

사용 np.delete! 실제로 제자리에서 아무것도 삭제하지 않습니다.

예:

import numpy as np
a = np.array([[1,4],[5,7],[3,1]])                                       

# a: array([[1, 4],
#           [5, 7],
#           [3, 1]])

ind = np.array([0,1])                                                   

# ind: array([0, 1])

# a[ind]: array([[1, 4],
#                [5, 7]])

all_except_index = np.delete(a, ind, axis=0)                                              
# all_except_index: array([[3, 1]])

# a: (still the same): array([[1, 4],
#                             [5, 7],
#                             [3, 1]])

나는 그것을하는 기능적 (불변) 방법을 제공 할 것입니다.

1. 이를 수행하는 표준적이고 쉬운 방법은 슬라이싱을 사용하는 것입니다.

   index_to_remove = 3
   data = [*range(5)]
   new_data = data[:index_to_remove] + data[index_to_remove + 1:]
   
   print(f"data: {data}, new_data: {new_data}")

   산출:

   data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]

2. 목록 이해력 사용 :

   data = [*range(5)]
   new_data = [v for i, v in enumerate(data) if i != index_to_remove]
   
   print(f"data: {data}, new_data: {new_data}") 

   산출:

   data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]

3. 필터 기능 사용 :

   index_to_remove = 3
   data = [*range(5)]
   new_data = [*filter(lambda i: i != index_to_remove, data)]

   산출:

   data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]

4. 마스킹 사용. 마스킹은 표준 라이브러리의 itertools.compress 함수에 의해 제공됩니다 .

   from itertools import compress
   
   index_to_remove = 3
   data = [*range(5)]
   mask = [1] * len(data)
   mask[index_to_remove] = 0
   new_data = [*compress(data, mask)]
   
   print(f"data: {data}, mask: {mask}, new_data: {new_data}")

   산출:

   data: [0, 1, 2, 3, 4], mask: [1, 1, 1, 0, 1], new_data: [0, 1, 2, 4]

5. Python 표준 라이브러리의 itertools.filterfalse 함수 사용

   from itertools import filterfalse
   
   index_to_remove = 3
   data = [*range(5)]
   new_data = [*filterfalse(lambda i: i == index_to_remove, data)]
   
   print(f"data: {data}, new_data: {new_data}")

   산출:

   data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]

색인을 미리 모르는 경우 여기에 작동하는 기능이 있습니다.

def reverse_index(l, index):
    try:
        l.pop(index)
        return l
    except IndexError:
        return False

변수가 목록 목록이면 일부 접근 방식은 실패합니다. 예를 들면 :

v1 = [[range(3)] for x in range(4)]
v2 = v1[:3]+v1[4:] # this fails
v2

일반적인 경우에는

removed_index = 1
v1 = [[range(3)] for x in range(4)]
v2 = [x for i,x in enumerate(v1) if x!=removed_index]
v2

마지막 또는 첫 번째를 잘라내려면 다음을 수행하십시오.

list = ["This", "is", "a", "list"]
listnolast = list[:-1]
listnofirst = list[1:]

1을 2로 변경하면 처음 2 개의 문자가 두 번째가 아니라 제거됩니다. 이것이 여전히 도움이되기를 바랍니다!