본문 바로가기

[프로그래밍]/Python

[Numpy] numpy 기초

What_numpy

numpy란 무엇인가?

Numpy는 C언어로 구현된 파이썬 라이브러리로써, 고성능의 수치계산을 위해 제작되었습니다. Numerical Python의 줄임말이기도 한 Numpy는 벡터 및 행렬 연산에 있어서 매우 편리한 기능을 제공합니다.

또한 이는 데이터분석을 할 때 사용되는 라이브러리인 pandas와 matplotlib의 기반으로 사용되기도 합니다.

numpy에서는 기본적으로 array라는 단위로 데이터를 관리하며 이에 대해 연산을 수행합니다. array는 말그대로 행렬이라는 개념으로 생각하시면 됩니다.

먼저 numpy를 사용하기 위해서는 아래와 같은 코드로 numpy를 import해야 합니다.

import Library

In [4]:
import numpy as np

array 정의 및 사용

In [9]:
data1=[1,2,3,4,5]
data2=[[1,2,3,4,5]]

print(type(data1))
print(data1)

print(type(data2))
print(data2)
<class 'list'>
[1, 2, 3, 4, 5]
In [10]:
#list를 이용하여 numpy array 정의
numpy_arr=np.array(data1)
numpy_arr2=np.array(data2)
print(type(numpy_arr))
print(numpy_arr)

print(type(numpy_arr2))
print(numpy_arr2)
<class 'numpy.ndarray'>
[1 2 3 4 5]
<class 'numpy.ndarray'>
[[1 2 3 4 5]]

shape

numpy에서는 해당 array의 크기를 알 수 있다.

shape 을 확인함으로써 몇개의 데이터가 있는지, 몇 차원으로 존재하는지 등을 확인할 수 있다.

In [17]:
data=[
        [
            [1,2],[8,3],[1,2],[8,3],[1,2],[8,3]
        ],
        [
            [2,2],[7,3],[1,2],[8,3],[1,2],[8,3]
        ],
        [
            [3,2],[6,3],[1,2],[8,3],[1,2],[8,3]
        ]
     ]
np_array=np.array(data)
np_array2=np.array([[1,2,3,4,5]])
np_array3=np.array([1,2,3,4,5])

print(np_array.shape)
print(np_array2.shape)
print(np_array3.shape)
(3, 6, 2)
(1, 5)
(5,)

위와 같이 shape를 통해 몇 차원인지 확인할 수 있다. 2차원 같은 (1,5)는 열과 행의 갯수임을 알 수 있다. \ 3차원의 경우에는 (x,y,z) x는 열의 갯수 y는 항목 내 리스트의 갯수 z는 리스트 내 컬럼의 갯수로 나뉜다.

numpy 자료형

numpy 또한 자료형을 갖는다. int, uint, float, complex, bool, string, object, unicode 등 다양한 자료형에 맞게 사용된다.\ 자료형 타입을 보고 싶은 경우 혹은 타입을 정의해서 선언하고자 할 경우 다음과 같이 사용한다.

In [19]:
np_arr=np.array([[1,2,3,4,5]],dtype='float')
print(np_arr.dtype)
print(np_arr)
float64
[[1. 2. 3. 4. 5.]]

np.zeros, np.ones, np.arange

numpy에서 빈 값 혹은 값을 생성하여 array를 만들고자 할 때 사용된다.

zeros : 인자로 받는 크기 만큼 모든 배열 요소가 0인 array 생성\ ones : 인자로 받는 크기 만큼 모든 배열 요소가 1인 array 생성\ arange : 지정한 크기 만큼의 '1차원' array를 생성

In [23]:
zeros=np.zeros(10,dtype='float')
zeros1=np.zeros((3,5),dtype='float')
zeros2=np.zeros((3,5,7),dtype='float')
print(zeros,'\n')
print(zeros1,'\n')
print(zeros2,'\n')
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]] 

[[[0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0.]]] 

In [24]:
ones=np.ones(10,dtype='float')
ones1=np.ones((3,5),dtype='float')
ones2=np.ones((3,5,7),dtype='float')
print(ones,'\n')
print(ones1,'\n')
print(ones2,'\n')
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] 

[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]] 

[[[1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]]

 [[1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]]

 [[1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1. 1. 1.]]] 

In [27]:
arange=np.arange(10,dtype='float')
arange1=np.arange(3,5,dtype='float')
print(arange,'\n')
print(arange1,'\n')
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] 

[3. 4.] 

Array 연산

In [44]:
arr1=np.array([[5,4,3],[3,2,1]],dtype='float')

arr2=np.array([[5,4,3],[5,4,3]],dtype='float')

print(arr1.shape)
print(arr2.shape)
print(arr1+arr2)
print(arr1*arr2)
print(arr1/arr2)
(2, 3)
(2, 3)
[[10.  8.  6.]
 [ 8.  6.  4.]]
[[25. 16.  9.]
 [15.  8.  3.]]
[[1.         1.         1.        ]
 [0.6        0.5        0.33333333]]

Array Indexing [중요]

numpy에서의 인덱싱은 python의 리스트 인덱싱과 동일하다.

In [84]:
arr1=np.array([
                [5,9,10,17],
                [4,8,11,16],
                [2,7,12,15],
                [1,6,13,18],
            ],dtype='float')

#이렇게 보면 편하다
#[행:열]
#[특정행,행:열]
#[행:열,행:열]

#4번째 요소 출력
print(arr1[3],'\n')

# 1번째 ~ 3번째 요소 꺼내기
print(arr1[0:3],'\n')

#3행의 모든 요소 꺼내기
print(arr1[2,:],'\n')

#3행에서 지정된 인덱싱부터 모든 요소 꺼내기
print(arr1[2,1:],'\n')

#모든 열의 2번째 요소 꺼내기
print(arr1[:,1],'\n')

#모든 열의 마지막 요소 꺼내기
print(arr1[:,-1],'\n')

#마지막 열을 제외한 모든 요소 꺼내기 라벨 꺼낼때 많이 사용
print(arr1[:,:-1],'\n')
[ 1.  6. 13. 18.] 

[[ 5.  9. 10. 17.]
 [ 4.  8. 11. 16.]
 [ 2.  7. 12. 15.]] 

[ 2.  7. 12. 15.] 

[ 7. 12. 15.] 

[9. 8. 7. 6.] 

[17. 16. 15. 18.] 

[[ 5.  9. 10.]
 [ 4.  8. 11.]
 [ 2.  7. 12.]
 [ 1.  6. 13.]] 

numpy 계산 함수

numpy에서는 array에 관해 지원되는 함수가 다양하다.

In [92]:
#random 함수
#랜덤한 5,3 배열 크기를 갖는 array 생성
arr1=np.random.randn(5,3)
print(arr1)
print(arr1.shape)
[[ 1.08034983  0.66945691  0.78903607]
 [-0.61316901 -0.37184038 -0.98106307]
 [ 2.29861568 -1.20361671 -0.32577112]
 [-0.45663594  0.93741256 -1.07031015]
 [ 1.0842993   1.53757714  0.73267487]]
(5, 3)
In [93]:
#각 성분 절댓값으로 변환
np.abs(arr1)
[[1.08034983 0.66945691 0.78903607]
 [0.61316901 0.37184038 0.98106307]
 [2.29861568 1.20361671 0.32577112]
 [0.45663594 0.93741256 1.07031015]
 [1.0842993  1.53757714 0.73267487]]
In [94]:
#각 성분에 대해 제곱근을 구함
np.sqrt(arr1)
[[1.03939878 0.81820346 0.88827702]
 [       nan        nan        nan]
 [1.51611862        nan        nan]
 [       nan 0.96820068        nan]
 [1.04129693 1.23999078 0.85596429]]
C:\Users\msi\Anaconda3\lib\site-packages\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in sqrt
  
In [95]:
#각 성분의 제곱 계산하기
np.square(arr1)
Out[95]:
array([[1.16715576, 0.44817255, 0.62257792],
       [0.37597624, 0.13826527, 0.96248474],
       [5.28363406, 1.44869319, 0.10612682],
       [0.20851638, 0.8787423 , 1.14556381],
       [1.17570496, 2.36414347, 0.53681247]])
In [96]:
#각 성분을 무리수 e의 지수로 삼은 값을 계산
np.exp(arr1)
Out[96]:
array([[2.94570987, 1.95317627, 2.20127353],
       [0.54163171, 0.68946428, 0.37491233],
       [9.96038459, 0.30010685, 0.72197042],
       [0.6334109 , 2.55336618, 0.34290215],
       [2.95736685, 4.65330231, 2.08063861]])
In [97]:
#각 성분을 자연로그, 상용로그, 밑이 2인 로그를 씌운 값을 계산
np.log(arr1)
C:\Users\msi\Anaconda3\lib\site-packages\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log
  
Out[97]:
array([[ 0.07728491, -0.40128848, -0.23694324],
       [        nan,         nan,         nan],
       [ 0.83230707,         nan,         nan],
       [        nan, -0.0646318 ,         nan],
       [ 0.08093397,  0.43020789, -0.31105323]])
In [98]:
np.log2(arr1)
C:\Users\msi\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in log2
  """Entry point for launching an IPython kernel.
Out[98]:
array([[ 0.11149855, -0.57893691, -0.34183684],
       [        nan,         nan,         nan],
       [ 1.20076528,         nan,         nan],
       [        nan, -0.09324397,         nan],
       [ 0.11676303,  0.62065879, -0.44875496]])
In [99]:
#각 성분의 부호 계산 (+ == 1 , - == -1 , 0 == 0)
np.sign(arr1) 
Out[99]:
array([[ 1.,  1.,  1.],
       [-1., -1., -1.],
       [ 1., -1., -1.],
       [-1.,  1., -1.],
       [ 1.,  1.,  1.]])
In [100]:
#각 성분의 소수 첫 번째 자리에서 올림한 값 계산
np.ceil(arr1)
Out[100]:
array([[ 2.,  1.,  1.],
       [-0., -0., -0.],
       [ 3., -1., -0.],
       [-0.,  1., -1.],
       [ 2.,  2.,  1.]])
In [101]:
#각 성분의 소수 첫 번째 자리에서 내림한 값 계산
np.floor(arr1)
Out[101]:
array([[ 1.,  0.,  0.],
       [-1., -1., -1.],
       [ 2., -2., -1.],
       [-1.,  0., -2.],
       [ 1.,  1.,  0.]])
In [102]:
#각 성분이 NaN인 경우 True를 아닌 경우 False 반환
np.isnan(np.log(arr1))
C:\Users\msi\Anaconda3\lib\site-packages\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log
  
Out[102]:
array([[False, False, False],
       [ True,  True,  True],
       [False,  True,  True],
       [ True, False,  True],
       [False, False, False]])
In [103]:
#각 성분이 무한대인 경우 True 아닌 경우 False
np.isinf(arr1)
Out[103]:
array([[False, False, False],
       [False, False, False],
       [False, False, False],
       [False, False, False],
       [False, False, False]])
In [104]:
#각 성분에 대한 삼각함수 계산(cos,cosh,sin,sinh,tan,tanh)
np.cos(arr1)
Out[104]:
array([[ 0.4710198 ,  0.7841588 ,  0.70452972],
       [ 0.81782848,  0.93166026,  0.55613936],
       [-0.66524309,  0.35898447,  0.94740422],
       [ 0.89754089,  0.59187556,  0.47985214],
       [ 0.46753222,  0.03321308,  0.74338795]])
In [105]:
np.tan(arr1)
Out[105]:
array([[ 1.87279312,  0.79137058,  1.00730241],
       [-0.70364638, -0.38998192, -1.49438992],
       [-1.12233685, -2.59995514, -0.33780664],
       [-0.49126589,  1.36182234, -1.82837439],
       [ 1.8907275 , 30.09201257,  0.89974621]])

두개의 array 에 적용되는 함수

In [106]:
arr1=np.random.randn(5,3)
arr2=np.random.randn(5,3)

#두 개의 array에 대해 동일한 위치의 성분끼리 연산 수행
#add, subtract, multiply,divede
np.add(arr1,arr2)
Out[106]:
array([[ 0.60850099, -1.72385954,  0.55701761],
       [-0.49151566,  0.8459033 , -0.96853924],
       [-0.78082804,  1.18204967, -3.80975333],
       [-1.78710193,  0.95615519, -0.5814644 ],
       [ 2.00453782, -3.18472921,  1.45381169]])
In [107]:
arr1=np.random.randn(5,3)
arr2=np.random.randn(5,3)

#두 개의 array에 대해 동일한 위치의 성분끼리 비교 수행
#maximum, minimum
np.maximum(arr1,arr2)
Out[107]:
array([[ 0.75489932,  0.4991358 ,  0.65613048],
       [ 1.25389237,  0.9115395 , -0.10104175],
       [-1.18181949, -0.05495756,  0.2634612 ],
       [-0.74651277, -0.30720314,  0.65044733],
       [ 0.03588562,  1.34771727,  1.86375392]])

통계함수

In [109]:
#전체 성분 합 계산
arr1=np.random.randn(5,3)
np.sum(arr1)
Out[109]:
-1.8526372198819208
In [110]:
#열 간의 합을 계산
arr1=np.random.randn(5,3)
np.sum(arr1,axis=1)
Out[110]:
array([ 0.71056254, -0.1454874 , -1.02572303, -1.33128319, -0.8132159 ])
In [111]:
#행 간의 합을 계산
arr1=np.random.randn(5,3)
np.sum(arr1,axis=0)
Out[111]:
array([-0.76492457, -0.91103715,  4.47132381])
In [112]:
#전체 성분의 평균을 계산
arr1=np.random.randn(5,3)
np.mean(arr1)
Out[112]:
-0.14088876391467958
In [113]:
#행 간의 평균을 계산
arr1=np.random.randn(5,3)
np.mean(arr1,axis=0)
Out[113]:
array([-0.18304634, -0.94393137, -0.47660452])
In [ ]:
#전체 성분의 표준편차 분산,최소값,최대값 계산
#std, var, min, max
arr1=np.random.randn(5,3)
np.std(arr1)
np.var(arr1)
np.min(arr1)
np.max(arr1)
In [119]:
#전체 성분의 최솟값, 최댓값이 위치한 인덱스를 반환(argmin,argmax)
arr1=np.random.randn(5,3)
np.argmax(arr1)
np.argmin(arr1)
Out[119]:
10
In [118]: