python numpy 배열(array) 행렬 생성 및 사용 관련 정리

numpy는 python으로 수학/과학 관련 내용을 다루기 위한 기본 패키지로 포괄적인 수학 함수, 난수 생성기, 선형 대수 루틴, 푸리에 변환 등을 제공한다. 
폰 포스트에서는 numpy를 사용한 배열 생성 및 사용에 관한 내용을 싣고 있다. 

패키지 설치

CONDA

conda install numpy

PIP

pip install numpy

패키지 불러오기

import numpy as np

numpy 배열 속성

numpy로 만들어진 배열은 아래와 같은 속성을 가지고 있다.

ndarray.ndim - 배열의 축수 (치수) NumPy에서는 차원을 axes라고 한다.
ndarray.shape - 배열의 차원 각 차원의 배열 크기. n 개의 행과 m 개의 열이 있는 행렬의 경우 (n,m).
ndarray.size - 배열의 요소의 총수 n*m
ndarray.dtype - 배열 내의 요소의 변수 형태
ndarray.itemsize - 배열의 각 요소의 크기,바이트 단위  
ndarray.data - 배열의 실제 요소를 포함하는 버퍼 

예를 들어 아래와 같은 배열이 있을 경우 그 속성은 다음과 같다.

a = np.array([(1,2,3),(4,5,6)])
print(a)
print('ndarray.ndim',a.ndim)
print('ndarray.shape',a.shape)
print('ndarray.size',a.size)
print('ndarray.dtype',a.dtype)
print('ndarray.itemsize',a.itemsize)
print('ndarray.data',a.data)

[[1 2 3]
 [4 5 6]]
ndarray.ndim 2
ndarray.shape (2, 3)
ndarray.size 6
ndarray.dtype int32
ndarray.itemsize 4
ndarray.data <memory at 0x000002A204F85480>

numpy 배열 생성

배열은 아래와 같은 방법으로 생성할 수 있다.

a = np.array([1,2,3])

[1 2 3]

a = np.array([1.1, 2.5, 3.1])

[1.1 2.5 3.1]

a = np.array([(1,2,3), (4,5,6)])

[[1 2 3]

 [4 5 6]]

데이터 형식도 지정 가능하다.

a = np.array( [ [1,2], [3,4] ], dtype=complex )

[[1.+0.j 2.+0.j]
  [3.+0.j 4.+0.j]]

0이나 1로 채워진 배열, 혹은 임의의 데이터로 채워진 배열도 생성할 수 있다.

b = np.zeros((3, 4))

[[0. 0. 0. 0.]

 [0. 0. 0. 0.]

 [0. 0. 0. 0.]]

b = np.ones( (3,4), dtype=np.int16 )

[[1 1 1 1]

 [1 1 1 1]

 [1 1 1 1]]

b = np.empty( (4,5) )

배열 생성 당시 할당된 메모리의 데이터를 그대로 가지고 있는 것 같다.

[[6.23042070e-307 1.89146896e-307 1.37961302e-306 1.05699242e-307
  8.01097889e-307]
 [1.78020169e-306 7.56601165e-307 1.02359984e-306 1.78018403e-306
  1.37962388e-306]
 [1.37961913e-306 7.56589622e-307 1.95818994e-306 9.34603679e-307
  6.23059726e-307]
 [1.60221072e-306 6.23059726e-307 1.33511562e-306 6.89805151e-307
  2.56765117e-312]]

zeros, ones, empty는 뒤에 _like를 붙여 주어진 배열과 동일한 shape의 배열로 생성할 수도 있다.

a = np.array([(1,2,3), (4,5,6)])
b = np.zeros_like(a)

[[0 0 0]
 [0 0 0]]

a = np.array([(1,2,3), (4,5,6)])
b = np.ones_like(a)

[[1 1 1]
 [1 1 1]]

a = np.array([(1,2), (3,4)])
b = np.empty_like(a)

[[0 0]
 [0 0]]

일련의 숫자로 채워진 배열은 arange, linspace를 사용하여 생성할 수 있다.

numpy.arrange([start],stop,[step],dtype=None)
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

a= np.arange( 10, 30, 5 )
b= np.arange( 0, 2, 0.3 )

[10 15 20 25]

[0.  0.3 0.6 0.9 1.2 1.5 1.8]

b = np.linspace( 0, 2, 9 ) # 9 numbers from 0 to 2

[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]

배열의 기본 연산

a = np.arange(1,5)
b = np.arange(1,1.4,0.1)

a = [1 2 3 4]

b = [1.  1.1 1.2 1.3]

c = a+b

[2.  3.1 4.2 5.3]

c = a-b

[0.  0.9 1.8 2.7]

c = a*b    #배열의 같은 인덱스 요소들의 곱 = [1*1. 2*1.1 3*1.2 4*1.3]

[1.  2.2 3.6 5.2]

c = a/b

[1.         1.81818182 2.5        3.07692308]

c = a**2

[ 1  4  9 16]

c = b*10

[10. 11. 12. 13.]

c = a <= 2

[ True  True False False]

a += b

TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'

'+='의 경우 데이터 형식이 다르면 TypeError가 발생한다.

b += b

[2.  2.2 2.4 2.6]

a *= 3

[ 3  6  9 12]

행렬 곱셈(matrix product)은 아래와 같이 수행할 수 있다.

a = np.array( [[1,0.1],
               [0,1]] )
b = np.array( [[1,2],
               [3,4]] )
c = a@b
c = a.dot(b)

c = [[1.3 2.4]
      [3.  4. ]]

배열 요소의 합 및 최대 최소 값을 받아오는 방법은 아래와 같다.

a = np.array( [[1,2],
               [3,4]] )
print(a,'.sum()=',a.sum())
print(a,'.min()=',a.min())
print(a,'.max()=',a.max())
# axis 매개 변수를 지정하면 배열의 지정된 축을 따라 작업을 적용 할 수 있다
print(a,'.sum(axis=0)=',a.sum(axis=0))
print(a,'.min(axis=1)=',a.min(axis=1))
print(a,'.max(axis=0)=',a.max(axis=0))

[[1 2]
 [3 4]] .sum()= 10
[[1 2]
 [3 4]] .min()= 1
[[1 2]
 [3 4]] .max()= 4
[[1 2]
 [3 4]] .sum(axis=0)= [4 6]
[[1 2]
 [3 4]] .min(axis=1)= [1 3]
[[1 2]
 [3 4]] .max(axis=0)= [3 4]

수학 함수

numpy는 sin, cos, exp, sqrt, cov, mean, std, var 등의 수학 함수도 지원한다.

a = np.array( [[1,2],
               [3,4]] )
b = np.array( [[5,6],
               [7,8]] )

print('np.exp(a) = ',np.exp(a))
print('np.sqrt(a) = ',np.sqrt(a))
print('np.cos(a) = ',np.cos(a))
print('np.cov(a) = ',np.cov(a))#covariance 
print('np.mean(a) = ',np.mean(a))
print('np.std(a) = ',np.std(a))

np.exp(a) = [[ 2.71828183 7.3890561 ]
             [20.08553692 54.59815003]]
np.sqrt(a) = [[1. 1.41421356]
             [1.73205081 2. ]]
np.cos(a) = [[ 0.54030231 -0.41614684]
             [-0.9899925 -0.65364362]]
np.cov(a) = [[0.5 0.5]
             [0.5 0.5]]
np.mean(a) = 2.5
np.std(a) = 1.118033988749895

인덱싱

배열 행/열의 인덱싱은 아래의 예와 같은 방법으로 수행할 수 있다. 인덱스의 시작은 0이다.

a = np.arange(10)
print('a=',a)
print('a[2]=',a[2])
print('a[2:7]=',a[2:7])
print('a[-1]=',a[-1])

a = [0 1 2 3 4 5 6 7 8 9]
a[2]= 2
a[2:7]= [2 3 4 5 6]
a[-1]= 9

인덱싱을 이용해 특정 위치 값을 정할 수도 있으며,

a[1:6:2] = -1

[ 0 -1  2 -1  4 -1  6  7  8  9]

배열의 값을 뒤집을 수도 있다.

a = a[ : :-1]

[ 9  8  7  6 -1  4 -1  2 -1  0]

다차원인 경우 ','를 넣어 다음 차를 인덱싱할 수 있으며, 축의 수보다 적은 인덱스인 경우 해당 열을 인덱싱한다.

a = np.arange(10).reshape(5,-1)

print(a,'\na[1,1] = ',a[1,1])

print('a[3]=',a[3])

[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
a[1,1] =  3
a[3]= [6 7]

reshape

배열의 shape을 변형하는 기능도 지원하고 있다.

a = np.array([(1,2,3,4),(5,6,7,8),(9,10,11,12)])
print(a)
print('a.ravel() =',a.ravel())
print('a.T =',a.T)#transposed
print('a.reshape(6,2) =',a.reshape(6,2))
print('a.reshape(4,-1) =',a.reshape(4,-1))
a.resize((2,6))
print('a=',a)

[[ 1  2  3  4]

 [ 5  6  7  8]

 [ 9 10 11 12]]

ravel()은 행렬을 풀어 1차원 배열을 반환한다. 

a.ravel() = [ 1  2  3  4  5  6  7  8  9 10 11 12]

.T 는 Transposed를 의미한다.

a.T = [[ 1  5  9]

         [ 2  6 10]

         [ 3  7 11]

         [ 4  8 12]]

reshape은 shape을 변환해 반환 한다. 

a.reshape(6,2) = [[ 1  2]

                     [ 3  4]

                     [ 5  6]

                     [ 7  8]

                     [ 9 10]

                     [11 12]]

-1을 넣으면 자동으로 추론되어 변환해 반환 한다. 

a.reshape(4,-1) = [[ 1  2  3]

                         [ 4  5  6]

                         [ 7  8  9]

                         [10 11 12]]

resize는 행렬 자체의 shape을 변환한다.

a = [[ 1  2  3  4  5  6]

      [ 7  8  9 10 11 12]]

배열 쌓기 / 나누기

numpy.vstack numpy.hstack을 사용해 수직,수평 방향으로 행렬을 쌓아 올릴 수 있다.

a = np.arange(4).reshape(2,2)

b = np.arange(1,1.4,0.1).reshape(2,2)

print('a=',a)

print('b=',b)

c = np.vstack((a,b))

print('np.vstack((a,b))=',c)

c = np.hstack((a,b))

print('np.hstack((a,b))=',c)

a= [[0 1]

    [2 3]]

b= [[1.  1.1]

    [1.2 1.3]]

np.vstack((a,b))= [[0.  1. ]

  [2.  3. ]

  [1.  1.1]

  [1.2 1.3]]

np.hstack((a,b))= [[0.  1.  1.  1.1]

[2.  3.  1.2 1.3]]

numpy.hsplit, numpy.vsplit을 사용해 수평, 수직 방행으로 행렬을 나눌 수 있다.

a = np.arange(12).reshape(2,6)
print('a=',a)

b = np.hsplit(a, 3)#3개로 분리
print('np.hsplit(a, 3)=',b)

b = np.hsplit(a, (2,5)) # index 2, index 5 에서 각각 분리
print('np.hsplit(a, (2,5))=',b)

a = np.arange(12).reshape(6,2)
print('a=',a)

b = np.vsplit(a, 3)#3개로 분리
print('np.vsplit(a, 3)=',b)

a= [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

np.hsplit(a, 3)= [array([[0, 1],
       [6, 7]]), array([[2, 3],
       [8, 9]]), array([[ 4,  5],
       [10, 11]])]

np.hsplit(a, (2,5))= [array([[0, 1],
       [6, 7]]), array([[ 2,  3,  4],
       [ 8,  9, 10]]), array([[ 5],
       [11]])]

a= [[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 6  7]
 [ 8  9]
 [10 11]]

np.vsplit(a, 3)= [array([[0, 1],
       [2, 3]]), array([[4, 5],
       [6, 7]]), array([[ 8,  9],
       [10, 11]])]

np.vsplit(a, (2,5))= [array([[0, 1],
       [2, 3]]), array([[4, 5],
       [6, 7],
       [8, 9]]), array([[10, 11]])]