시리즈 문장

NumPy 입문 기초 지식 NumPy의 조종ndarray의 형상 NumPy의 얕은 복사와 깊은 복사 NumPy의 색인 기교를 한꺼번에 해낸다

array를 색인으로 이용하다

인덱스 1차원ndarray

인덱스된ndarray가 1차원일 때,array를 이용하여 인덱스를 하면 인덱스된 대상에서 인덱스가 지정한 모든 요소를 한꺼번에 선택하는 것과 같으며, 인덱스된 대상은 여전히ndarray 대상이다.

>>> a = np.arange(12)**2     
>>> a
array([  0,   1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121])
>>> i = np.array( [ 1,1,3,8,5 ] )              # an array of indices
>>> a[i]                                       # the elements of a at the positions i
array([ 1,  1,  9, 64, 25])

만약 인덱스가 다차원적이라면, 검출된ndarray의shape와 인덱스의 형상이 일치하고, 인덱스의 각 숫자는 검색된ndarray의 위치를 나타낸다

>>> a = np.arange(12)**2 
>>> a
array([  0,   1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121])
>>> j = np.array( [ [ 3, 4], [ 9, 7 ] ] )      # a bidimensional array of indices
>>> a[j]                                       # the same shape as j
array([[ 9, 16],
       [81, 49]])

인덱스 다차원

인덱스 대상이 다차원적이고 하나의 인덱스만 제공하면 인덱스 중의 모든 숫자에 대응하는 요소는 인덱스 대상의 첫 번째 차원이다.

>>> palette = np.array( [ [0,0,0],                # black
...                       [255,0,0],              # red
...                       [0,255,0],              # green
...                       [0,0,255],              # blue
...                       [255,255,255] ] )       # white
>>> image = np.array( [ [ 0, 1, 2, 0 ],           # each value corresponds to a color in the palette
...                     [ 0, 3, 4, 0 ]  ] )
>>> palette[image]                            # the (2,4,3) color image
array([[[  0,   0,   0],
        [255,   0,   0],
        [  0, 255,   0],
        [  0,   0,   0]],
       [[  0,   0,   0],
        [  0,   0, 255],
        [255, 255, 255],
        [  0,   0,   0]]])

만약 색인된 대상이 다차원이고 색인된 대상에서 다차원 검색을 하려면 여러 그룹의 색인array를 제시해야 한다. 이때 모든 색인array는 색인된 대상 중의 한 차원에 대응해야 한다.색인array의 형상은 반드시 일치해야 한다. 왜냐하면 이 몇 개의 색인array의 같은 위치 (색인된 대상의 다른 차원을 구성하는 것) 를 사용하여 색인된 대상 중의 어떤 요소를 공동으로 지정해야 하기 때문이다.

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> i = np.array( [ [0,1],                        # indices for the first dim of a
...                 [1,2] ] )
>>> j = np.array( [ [2,1],                        # indices for the second dim
...                 [3,3] ] )
>>>
>>> a[i,j]                                     # i and j must have equal shape
array([[ 2,  5],
       [ 7, 11]])
>>>
>>> a[i,2]
array([[ 2,  6],
       [ 6, 10]])
>>>
>>> a[:,j]                                     # i.e., a[ : , j]
array([[[ 2,  1],
        [ 3,  3]],
       [[ 6,  5],
        [ 7,  7]],
       [[10,  9],
        [11, 11]]])

일반적으로 상기i와j를list 형식으로 써서 색인으로 사용할 수 있다

>>> l = [i,j]
>>> a[l]                                       # equivalent to a[i,j]
array([[ 2,  5],
       [ 7, 11]])

i와 j를array로 조합해서 사용할 수 없습니다. 그러면 해석기가 색인 대상의 첫 번째 차원으로 간주됩니다.

>>> s = np.array( [i,j] )
>>> a[s]                                       # not what we want
Traceback (most recent call last):
  File "", line 1, in ?
IndexError: index (3) out of range (0<=index<=2) in dimension 0
>>>
>>> a[tuple(s)]                                # same as a[i,j]
array([[ 2,  5],
       [ 7, 11]])

다음 예에서는 다차원 배열 인덱스의 응용 프로그램을 보여 줍니다.

>>> time = np.linspace(20, 145, 5)                 #  
>>> data = np.sin(np.arange(20)).reshape(5,4)      #  4 
>>> time
array([  20.  ,   51.25,   82.5 ,  113.75,  145.  ])
>>> data
array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
       [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
       [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
       [-0.53657292,  0.42016704,  0.99060736,  0.65028784],
       [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])
>>>
>>> ind = data.argmax(axis=0)                  #  
>>> ind
array([2, 0, 3, 1])
>>>
>>> time_max = time[ind]                       #  
>>>
>>> data_max = data[ind, range(data.shape[1])] # => #  ， ， ind:[2,0,3,1]， ， [0,1,2,3]。.
>>>
>>> time_max
array([  82.5 ,   20.  ,  113.75,   51.25])
>>> data_max
array([ 0.98935825,  0.84147098,  0.99060736,  0.6569866 ])
>>>
>>> np.all(data_max == data.max(axis=0)) # data.max ， 
True

색인을 사용하여 값을 지정할 수 있지만 색인이 중복되면 마지막 값을 기준으로 합니다.

>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> a[[1,3,4]] = 0
>>> a
array([0, 0, 2, 0, 0])

>>> a = np.arange(5)
>>> a[[0,0,2]]=[1,2,3]
>>> a
array([2, 1, 3, 3, 4])

색인으로 부울 값 사용

위의 컨텐트는 인덱스로 정수를 사용하고, 부울 값을 인덱스로 사용할 때는 필요한 컨텐트와 필요하지 않은 컨텐트를 지정하여 수행합니다(True, False).다음 예는 원시적인ndarray와 같은 모양의 인덱스를 제시함으로써 매우 직관적이다.

>>> a = np.arange(12).reshape(3,4)
>>> b = a > 4                               #  
>>> b                                          # b 
array([[False, False, False, False],
       [False,  True,  True,  True],
       [ True,  True,  True,  True]])
>>> a[b]                                       #  
array([ 5,  6,  7,  8,  9, 10, 11])

이 특성은 대입 작업에 자주 적용됩니다.

>>> a[b] = 0             #  4 0                 
>>> a
array([[0, 1, 2, 3],
       [4, 0, 0, 0],
       [0, 0, 0, 0]])

또 다른 용법은 상술한 다차원 인덱스와 유사하다. 모든 차원에 대해 1차원적인array를 제공하여 이 차원의 어떤 요소가 필요한지 설명한다.

>>> a = np.arange(12).reshape(3,4)
>>> b1 = np.array([False,True,True])             # first dim selection
>>> b2 = np.array([True,False,True,False])       # second dim selection
>>>
>>> a[b1,:]                                   # selecting rows
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[b1]                                     # same thing
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[:,b2]                                   # selecting columns
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
>>>
>>> a[b1,b2]                                  #  a[[1,2],[0,2]]
array([ 4, 10])

여기b1와 b2의 길이는 각각 a의 두 차원의 길이와 일치해야 한다는 것을 주의해야 한다.

ix_() 함수

ix() 함수의 매개 변수는 N개의 1차원 수조로 하나의 조합 인덱스를 생산할 수 있다. 이 인덱스는 N차원이 있고 각 차원의 길이는 매개 변수의 길이이며 값은 각 1차원 수조의 구체적인 값에 의해 결정된다.

>>> a = np.array([2,3,4,5])
>>> b = np.array([8,5,4])
>>> c = np.array([5,4,6,8,3])
>>> ax,bx,cx = np.ix_(a,b,c)
>>> ax
array([[[2]],
       [[3]],
       [[4]],
       [[5]]])
>>> bx
array([[[8],
        [5],
        [4]]])
>>> cx
array([[[5, 4, 6, 8, 3]]])
>>> ax.shape, bx.shape, cx.shape
((4, 1, 1), (1, 3, 1), (1, 1, 5))
>>> result = ax+bx*cx  #  broadcasting ， 
>>> result
array([[[42, 34, 50, 66, 26],
        [27, 22, 32, 42, 17],
        [22, 18, 26, 34, 14]],
       [[43, 35, 51, 67, 27],
        [28, 23, 33, 43, 18],
        [23, 19, 27, 35, 15]],
       [[44, 36, 52, 68, 28],
        [29, 24, 34, 44, 19],
        [24, 20, 28, 36, 16]],
       [[45, 37, 53, 69, 29],
        [30, 25, 35, 45, 20],
        [25, 21, 29, 37, 17]]])
>>> result[3,2,4]
17
>>> a[3]+b[2]*c[4]
17
>>> ix = np.ix_([0,1],[1,2],[1,2,3]) #  ix 
>>> result[ix]    #  ix ndarray
array([[[22, 32, 42],
        [18, 26, 34]],

       [[23, 33, 43],
        [19, 27, 35]]])