NumPy (넘파이)

 안녕하세요 원시인 입니다 ㅎㅎ 

 Python에서 벡터, 행렬 등 수치 연산을 수행하는

라이브러리인 NumPy(넘파이)에 대해서 정리해봤습니다.

 

NumPy 특징

• Numerical Python의 약자
• 고성능 과학 계산용 패키지로 강력한 N차원 배열 객체
• 범용적 데이터 처리에 사용 가능한 다차원 컨테이너
• 정교한 브로드캐스팅(broadcasting) 기능
• 파이썬의 자료형 list와 비슷하지만, 더 빠르고 메모리를 효율적으로 관리
• 반복문 없이 데이터 배열에 대한 처리를 지원하여 빠르고 편리
• 데이터 과학 도구에 대한 생태계의 핵심을 이루고 있음

 

import numpy as np

 

 

 

배열 생성

 

리스트로 배열 만들기

 

arr = np.array([1,2,3])
arr
arr.shape  #  (3,) 3개의 요소 , 1차원 

(3,)

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

print(arr1[0,1],arr1[1,2])
print(arr1.shape) #  2행 3열 

2 6
(2, 3)

arr2 = np.array([ [[1,2,3],[4,5,6],[7,8,9]],
                 [[1,2,3],[4,5,6],[7,8,9]],
                 [[1,2,3],[4,5,6],[7,8,9]]])
print(arr2)
print(arr2.shape)

[[[1 2 3]
  [4 5 6]
  [7 8 9]]

 [[1 2 3]
  [4 5 6]
  [7 8 9]]

 [[1 2 3]
  [4 5 6]
  [7 8 9]]]
(3, 3, 3)

 

배열 생성 및 초기화

 

• zeros(): 모든 요소를 0으로 초기화

 

np.zeros(10)

array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

 

• ones(): 모든 요소를 1로 초기화

np.ones((3,3)) # 2차원 형태로 생성 

array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

 

• full(): 모든 요소를 지정한 값으로 초기화

np.full((3,3),5)     

 

array([[5, 5, 5],
       [5, 5, 5],
       [5, 5, 5]])

 

• eye(): 단위행렬(identity matrix) 생성
  • 주대각선의 원소가 모두 1이고 나머지 원소는 모두 0인 정사각 행렬

np.eye(5)

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

 

• tri(): 삼각행렬 생성

np.tri(4)

array([[1., 0., 0., 0.],
       [1., 1., 0., 0.],
       [1., 1., 1., 0.],
       [1., 1., 1., 1.]])

 

• empty(): 초기화되지 않은 배열 생성
  • 초기화가 없어서 배열 생성비용 저렴하고 빠름
  • 초기화되지 않아서 기존 메모리 위치에 존재하는 값이 있음

np.empty(10)

array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

 

• _like(): 지정된 배열과 shape가 같은 행렬 생성
  • np.zeros_like()
  • np.ones_like()
  • np.full_like()
  • np.empty_like()

u = np.arange(1,10).reshape(3,3)
u

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

 

np.zeros_like(u)

array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

 

np.full_like(u,3)

array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]])

 

np.empty_like(arr)

array([1, 2, 3])

 

생성한 값으로 배열 생성

 

• arange(): 정수 범위로 배열 생성

np.arange(0,30,5)

array([ 0,  5, 10, 15, 20, 25])

 

• linspace(): 범위 내에서 균등 간격의 배열 생성

np.linspace(0,30,5)

array([ 0. ,  7.5, 15. , 22.5, 30. ])

 

• logspace(): 범위 내에서 균등간격으로 로그 스케일로 배열 생성

np.logspace(1,0.1)

array([10.        ,  9.58589468,  9.18893768,  8.80841888,  8.44365757,
        8.09400122,  7.75882432,  7.43752728,  7.12953531,  6.83429746,
        6.55128557,  6.27999335,  6.01993548,  5.77064675,  5.5316812 ,
        5.30261134,  5.08302738,  4.87253651,  4.67076218,  4.47734343,
        4.29193426,  4.11420298,  3.94383164,  3.78051548,  3.62396232,
        3.47389211,  3.33003639,  3.19213781,  3.05994969,  2.93323554,
        2.8117687 ,  2.69533186,  2.58371673,  2.47672365,  2.3741612 ,
        2.27584593,  2.18160194,  2.09126064,  2.00466042,  1.92164637,
        1.84206997,  1.76578887,  1.69266662,  1.62257239,  1.5553808 ,
        1.49097166,  1.42922973,  1.37004456,  1.31331029,  1.25892541])

 

표준 데이터 타입

np.zeros(10, dtype = int)

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

 

np.ones((3,3) , dtype = bool)

array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])

 

date = np.array('2020-01-01', dtype ='datetime64[Y]')
date
date +  np.array(12)

numpy.datetime64('2032')

 

datetime = np.datetime64('2020-06-05')
datetime + np.array(15)

numpy.datetime64('2020-06-20')

 

 

 

 

불리언 인덱싱(Boolean Indexing)

• 배열 각 요소의 선택 여부를 불리언(True or False)로 지정
• True 값인 인덱스의 값만 조회

 

ar = np.random.randint(0,10,(3,3))
bol = np.array(([[1,2,3],[4,5,6],[7,8,9]]), dtype = bool).reshape(3,3)

ar[bol]

 

array([2, 5, 8, 3, 0, 9, 8, 4, 2])

 

팬시 인덱싱(Fancy Indedxing)

 

a = np.arange(9).reshape(3,3)
ind = ([0,2])
print(a)
a[ind]

[[0 1 2]
 [3 4 5]
 [6 7 8]]

array([[0, 1, 2],
       [6, 7, 8]])

row = ([2,0]) 
col = ([0,1])

a[row , :]
a[:1, col]

array([[0, 1]])

 

 

 

배열 값 삽입/수정/삭제/복사

 

배열 값 삽입

• insert(): 배열의 특정 위치에 값 삽입
• axis를 지정하지 않으면 1차원 배열로 변환
• 추가할 방향을 axis로 지정
• 원본 배열 변경없이 새로운 배열 반환

 

ins = np.insert(a,1,2, axis =0)
print(a)
ins

[[0 1 2]
 [3 4 5]
 [6 7 8]]

array([[0, 1, 2],
       [2, 2, 2],
       [3, 4, 5],
       [6, 7, 8]])

np.insert(a,0,7, axis = 1)

array([[7, 0, 1, 2],
       [7, 3, 4, 5],
       [7, 6, 7, 8]])

 

배열 값 수정

• 배열의 인덱싱으로 접근하여 값 수정

a[0][1]= 3
a

array([[0, 3, 2],
       [3, 4, 5],
       [6, 7, 8]])

a[:,1:]=2
a

array([[0, 2, 2],
       [3, 2, 2],
       [6, 2, 2]])

 

배열 값 삭제

• delete(): 배열의 특정 위치에 값 삭제
• axis를 지정하지 않으면 1차원 배열로 변환
• 삭제할 방향을 axis로 지정
• 원본 배열 변경없이 새로운 배열 반환

 

de = np.delete(a ,0)
de

array([2, 2, 3, 2, 2, 6, 2, 2])

np.delete(a,0 ,axis = 1)

array([[2, 2],
       [2, 2],
       [2, 2]])

 

배열 복사

• 리스트 자료형과 달리 배열의 슬라이스는 복사본이 아님

 

import copy as cp

 

• copy(): 배열이나 하위 배열 내의 값을 명시적으로 복사

 

a.copy

 

<function ndarray.copy>

 

 

 

배열 재구조화

 

• reshape(): 배열의 형상을 변경

np.arange(20).reshape(4,5)

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

 

배열 크기 변경

 

• 배열 모양만 변경

n2 = np.random.randint(0,10,(2,5))
n2.resize((5,2))
n2

array([[9, 9],
       [9, 4],
       [8, 3],
       [8, 2],
       [4, 4]])

 

• 배열 크기 증가
• 남은 공간은 0으로 채워짐

 

np.resize(n2,(5,5))

array([[9, 9, 9, 4, 8],
       [3, 8, 2, 4, 4],
       [9, 9, 9, 4, 8],
       [3, 8, 2, 4, 4],
       [9, 9, 9, 4, 8]])

 

• 배열 크기 감소
• 포함되지 않은 값은 삭제됨

 

np.resize(n2,(1,1))

array([[9]])

 

배열 추가

• append(): 배열의 끝에 값 추가

a1 =np.arange(1,10).reshape(3,3)
a2 = np.arange(10,19).reshape(3,3)

ap = np.append(a1,a2)
ap

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18])

 

• axis 지정이 없으면 1차원 배열 형태로 변형되어 결합

ap = np.append(a1,a2, axis = 0)
ap

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12],
       [13, 14, 15],
       [16, 17, 18]])

 

• axis를 0으로 지정
• shape[0]을 제외한 나머지 shape은 같아야 함

 

ap = np.append(a1,a2, axis = 1)
ap

array([[ 1,  2,  3, 10, 11, 12],
       [ 4,  5,  6, 13, 14, 15],
       [ 7,  8,  9, 16, 17, 18]])

 

• axis를 1로 지정
• shape[1]을 제외한 나머지 shape은 같아야 함

 

배열 연결

 

• concatenate(): 튜플이나 배열의 리스트를 인수로 사용해 배열 연결

 

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

array([1, 2, 3, 4, 5, 6])

a2= np.arange(1,10).reshape(3,3)
a22 = np.concatenate([a2,a2])
a22

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9],
       [1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

a22 = np.concatenate([a2,a2],axis = 1)
a22

array([[1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6],
       [7, 8, 9, 7, 8, 9]])

 

배열 분할

 

• split(): 배열 분할

a1 = np.arange(0,10)
b1 ,c1= np.split(a1,[5])
print(b1,c1)
b1,c1,d1,e1,f1 =np.split(a1,[2,4,6,8])
print(b1,c1,d1,e1,f1)

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

 

 

 

배열 연산

• NumPy의 배열 연산은 벡터화(vectorized) 연산을 사용
• 일반적으로 NumPy의 범용 함수(universal functions)를 통해 구현
• 배열 요소에 대한 반복적인 계산을 효율적으로 수행

 

브로드캐스팅(Broadcasting)

*일정조건을 부합하는 다른형태의 배열들과 연산을 수행한다는 것을 의미
특정 제약조건에 따라, 더 작은 배열은 더 큰 배열에 '브로드캐스트'되어 호환되는 모양을 가집니다.

 

from IPython.display import Image

Image('http://www.astroml.org/_images/fig_broadcast_visual_1.png')

 

 

Broadcasting 가능조건

• 두 배열 간의 연산에서 최소한 하나의 배열의 차원이 1이라면 가능합니다.
• 두번째로 차원에 대해 축의 길이가 동일하면 가능합니다.

 

1차원(3X1) 배열과 정수 5 를 합한 결과

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

arr.shape

(3,)

 

for i in range(3) :  
     print(arr[i] + 5)

6
7
8

일반적으로는 위의 for문을 사용해서 연산하지만
Broadcasting 을 이용하면 밑에 연산 처리처럼 간단하게 수행이 가능해집니다.

 

 

arr + 5 # Broadcasting 첫번째 조건을 만족하여 연산 수행

array([6, 7, 8])

 

2차원 (3x3) 배열과 연산

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

arr2.shape

(3, 3)

 

arr2 + arr # Broadcasting 첫번째 ,두번째 조건을 만족하여 연산 수행

array([[ 2,  4,  6],
       [ 5,  7,  9],
       [ 8, 10, 12]])

 

3차원(3X3X3X) 배열과 2차원(3X3) 연산

 

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

arr3.shape

(3, 3, 3)

arr3 +arr2 #  Broadcasting 두번째 조건을 만족하여 연산 수행

array([[[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]],

       [[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]],

       [[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]]])

 

산술연산

 

x =np.arange(10).reshape(2,5)
x

array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

 

x + 1

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

 

x - 3

array([[-3, -2, -1,  0,  1],
       [ 2,  3,  4,  5,  6]])

 

x * 2

array([[ 0,  2,  4,  6,  8],
       [10, 12, 14, 16, 18]])

 

x ** 2 # 제곱 

array([[ 0,  1,  4,  9, 16],
       [25, 36, 49, 64, 81]], dtype=int32)

 

x / 2

array([[0. , 0.5, 1. , 1.5, 2. ],
       [2.5, 3. , 3.5, 4. , 4.5]])

 

x // 2 # 나누기 연산 후 소수점 이하의 수를 버리고, 정수 부분의 수만 구함

array([[0, 0, 1, 1, 2],
       [2, 3, 3, 4, 4]], dtype=int32)

 

y = np.random.randn(10).reshape(2,5)
y

array([[ 0.52594949,  0.91431955,  1.19091874, -0.36302457, -1.02727814],
       [-2.15659132,  0.01584823, -1.44626828,  0.52804571, -0.93951101]])

 

# 배열간 연산 
print(x+y )
print(x-y)
print(x*y)
print(x/y)

[[0.52594949 1.91431955 3.19091874 2.63697543 2.97272186]
 [2.84340868 6.01584823 5.55373172 8.52804571 8.06048899]]
[[-0.52594949  0.08568045  0.80908126  3.36302457  5.02727814]
 [ 7.15659132  5.98415177  8.44626828  7.47195429  9.93951101]]
[[  0.           0.91431955   2.38183748  -1.0890737   -4.10911257]
 [-10.78295658   0.09508939 -10.12387799   4.22436571  -8.45559909]]
[[  0.           1.09370952   1.6793757   -8.26390353  -3.89378478]
 [ -2.31847359 378.59113208  -4.84004253  15.15020347  -9.57945134]]

 

절대값 함수(Absolute Function)

• absolute(), abs(): 내장된 절대값 함수

x = np.array([-1.23,2.55,3,-5])
np.abs(x)

array([1.23, 2.55, 3.  , 5.  ])

 

제곱/제곱근 함수

• square, sqrt: 제곱, 제곱근 함수

x = np.arange(1,10)
np.square(x)

array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

 

지수와 로그 함수 (Exponential and Log Function)

np.exp(x)

array([2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,
       1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,
       8.10308393e+03])

 

np.power(x,2) # 거듭제곱 계산 

array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

 

np.log(x)

array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791,
       1.79175947, 1.94591015, 2.07944154, 2.19722458])

 

배열 정렬

 

a = np.random.randint(0,10 , size = 10)
print(np.sort(a))

[0 1 2 3 3 6 6 8 9 9]

b = np.random.randint(0,10 ,size = (3,3))
print(np.sort(b))

[[0 5 5]
 [1 7 9]
 [1 2 9]]