numpy 정리

numpy 문법 초간단 정리!

numpy 다양한 선언¶

In [1]:

import numpy as np

# 선언
a = np.array([1, 2, 3, 4])
print('리스트로 선언\n', a)
a = np.zeros(4, dtype=int)  # 0으로 채운 길이 4의 정수 배열
print('zeros\n', a)
a = np.ones((3, 5), dtype=float)  # 1로 채운 3x5 float 배열
print('ones\n', a)
a = np.full((3, 5), 3.14)  # 특성 element로 채움
print('full\n', a)
a = np.arange(0, 20, 2)  # 0-20, 2간격, 실수 간격도 가능
print('arange\n', a)
a = np.linspace(0, 1, 5)  # 0-1사이 사이에 일정한 간격의 다섯개의 값
print('linspace\n', a)
a = np.random.random((3, 3))  # 3x3 0-1사이 난수
print('random\n', a)
a = np.random.normal(0, 1, (3, 3))  # 정규분포 (평균 0, 표준 편차 1)의 난수 3x3
print('normal\n', a)
a = np.random.randint(0, 10, (3, 3))  # [0, 10] 구간의 임의의 정수 3x3
print('randint\n', a)
a = np.eye(3)  # 단위 행렬 3x3
print('eye\n', a)
a = np.empty(3)  # 초기화되지 않은 배열
print('empty\n', a)

리스트로 선언
 [1 2 3 4]
zeros
 [0 0 0 0]
ones
 [[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
full
 [[3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]]
arange
 [ 0  2  4  6  8 10 12 14 16 18]
linspace
 [0.   0.25 0.5  0.75 1.  ]
random
 [[0.65247914 0.00739889 0.69537759]
 [0.91160802 0.45007296 0.99435091]
 [0.16296715 0.46006464 0.62365933]]
normal
 [[ 0.62306482 -1.15018925  1.41909112]
 [ 0.68762006  1.57278206 -0.71016101]
 [-1.04681225  0.49402212 -0.68509958]]
randint
 [[2 3 7]
 [0 2 3]
 [6 8 5]]
eye
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
empty
 [1. 1. 1.]

numpy 데이터 타입¶

데이터 타입	설명
bool_	1바이트로 저장된 부울 값(참 또는 거짓)
int_	기본 정수 타입(C long과 같음, 일반적으로 int64 또는 int32)
intc	C int와 동일(일반적으로 int32 또는 int64)
intp	인덱싱에 사용하는 정수(C ssize_t와 동일, 일반적으로 int32 또는 int64)
int8	바이트(-128~127)
int16	정수(-32768~32767)
int32	정수(-2147483648~2147483647)
int64	정수(-9223372036854775808~9223372036854775807)
uint8	부호 없는 정수(0~255)
uint16	부호 없는 정수(0~65535)
uint32	부호 없는 정수(0~4294967295)
uint64	부호 없는 정수(0~18446744073709551615)
float_	float64
float16	지수 5bit /가수 10bit
float32	지수 8bit /가수 23bit
float64	지수 11bit /가수 53bit
complex_	complex128의 약칭
complex64	복소수, 두개의 32비트 부동 소수점으로 표현
complex128	복소수, 두 개의 64비트 부동 소수점으로 표현

numpy attribute¶

In [2]:

x = np.random.randint(10, size=(3, 3, 2))  # 3차원 배열
print('x ndim: ', x.ndim)
print('x shape: ', x.shape)
print('x size: ', x.size)
print('itemsize: ', x.itemsize, 'bytes')
print('nbytes: ', x.nbytes, 'bytes')

x ndim:  3
x shape:  (3, 3, 2)
x size:  18
itemsize:  4 bytes
nbytes:  72 bytes

원소 접근 및 슬라이싱¶

In [3]:

x = np.random.randint(10, size=(3, 3))
print('x >\n', x)
print('x[2] >\n', x[2])
print('x[-1] >\n', x[-1])
print('x[-2] >\n', x[-2])  # 음수로 뒤에서부터 접근 가능
print('x[0][-1] >\n', x[0][-1])
x[1] = [3, 3, 3]
print('x >\n', x)

x = np.arange(10)
print('x >\n', x)
print('x[::2] >\n', x[::2])  # x[start:stop:step] step 음수시 reverse
print('x[4:7] >\n', x[4:7])

x = np.random.randint(10, size=(3, 4))
print('x >\n', x)
# 다 차원 슬라이싱, 슬라이싱 된것은 뷰(변경시 본체에도 적용, 복사시 copy() 함수 사용), 리스트 슬라이싱의 경우 copy
print('x[1:, 1:]>\n', x[1:, 1:])

x >
 [[4 7 6]
 [5 6 9]
 [3 0 4]]
x[2] >
 [3 0 4]
x[-1] >
 [3 0 4]
x[-2] >
 [5 6 9]
x[0][-1] >
 6
x >
 [[4 7 6]
 [3 3 3]
 [3 0 4]]
x >
 [0 1 2 3 4 5 6 7 8 9]
x[::2] >
 [0 2 4 6 8]
x[4:7] >
 [4 5 6]
x >
 [[4 3 5 5]
 [3 4 8 7]
 [7 8 5 5]]
x[1:, 1:]>
 [[4 8 7]
 [8 5 5]]

배열 다루기¶

In [4]:

x = np.random.randint(10, size=(3, 3))
print('x >\n', x)
x = x.reshape((9)) # 배열 재구조화
print('x >\n', x)
x = x.reshape((9, 1))
print('x>\n', x)

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
print('np.concatenate([x,y])>\n', np.concatenate([x, y]))  # 배열 축을 따라 연결
grid = np.array([x, y])
print('np.concatenate([grid, grid])>\n', np.concatenate([grid, grid]))

print('np.vstack([x, grid])>\n', np.vstack([x, grid]))  # 수직으로 쌓음(다차원 연결시 명시해주는게 좋음)
print(np.hstack([grid, x[1:].reshape((2, 1))]))  # 수평으로 쌓음

x = np.array([1,2,3,11,11,3,2,1])
x1, x2, x3 = np.split(x, [3, 5]) # 자를 기준 index를 적어줌
print(x1, x2, x3)

grid = np.arange(16).reshape((4, 4))
upper, lower = np.vsplit(grid, [2])
print(upper)
print(lower)
left, right = np.hsplit(grid, [2])
print(left)
print(right)

x >
 [[7 2 4]
 [4 6 1]
 [3 6 2]]
x >
 [7 2 4 4 6 1 3 6 2]
x>
 [[7]
 [2]
 [4]
 [4]
 [6]
 [1]
 [3]
 [6]
 [2]]
np.concatenate([x,y])>
 [1 2 3 3 2 1]
np.concatenate([grid, grid])>
 [[1 2 3]
 [3 2 1]
 [1 2 3]
 [3 2 1]]
np.vstack([x, grid])>
 [[1 2 3]
 [1 2 3]
 [3 2 1]]
[[1 2 3 2]
 [3 2 1 3]]
[1 2 3] [11 11] [3 2 1]
[[0 1 2 3]
 [4 5 6 7]]
[[ 8  9 10 11]
 [12 13 14 15]]
[[ 0  1]
 [ 4  5]
 [ 8  9]
 [12 13]]
[[ 2  3]
 [ 6  7]
 [10 11]
 [14 15]]

Numpy 유니버설 연산¶

In [5]:

a = np.array([1, 2, 3, 4])
print(a)
print(a + 2)
print(a - 2)
print(a * 2)
print(a / 2)
print(a // 2)
print(a ** 2)

[1 2 3 4]
[3 4 5 6]
[-1  0  1  2]
[2 4 6 8]
[0.5 1.  1.5 2. ]
[0 1 1 2]
[ 1  4  9 16]

삼각 함수¶

In [6]:

theta = np.linspace(0, np.pi, 3)
print("theta =", theta)
print("sin(theta) = ", np.sin(theta))
print("cos(theta) = ", np.cos(theta))
print("tan(theta) = ", np.tan(theta))

x = [-1, 0, 1]
print("x = ", x);
print("arcsin(x) = ", np.arcsin(x))
print("arccos(x) = ", np.arccos(x))
print("arctan(x) = ", np.arctan(x))

theta = [0.         1.57079633 3.14159265]
sin(theta) =  [0.0000000e+00 1.0000000e+00 1.2246468e-16]
cos(theta) =  [ 1.000000e+00  6.123234e-17 -1.000000e+00]
tan(theta) =  [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]
x =  [-1, 0, 1]
arcsin(x) =  [-1.57079633  0.          1.57079633]
arccos(x) =  [3.14159265 1.57079633 0.        ]
arctan(x) =  [-0.78539816  0.          0.78539816]

지수와 로그¶

In [7]:

x = [1, 2, 3]
print("x = ", x)
print("e^x = ", np.exp(x))
print("2^x = ", np.exp2(x))
print("3^x = ", np.power(3, x))

x = [1, 2, 4, 10]
print("x = ", x)
print("ln(x) = ", np.log(x))
print("log2(x) = ", np.log2(x))
print("log10(x) = ", np.log10(x))

x = [0, 0.001, 0.01, 0.1]
print("exp(x) -1 = ", np.expm1(x))  # x가 매우 작은값 정확도 유지를 위해 사용
print("log(1+x) = ", np.log1p(x))

x =  [1, 2, 3]
e^x =  [ 2.71828183  7.3890561  20.08553692]
2^x =  [2. 4. 8.]
3^x =  [ 3  9 27]
x =  [1, 2, 4, 10]
ln(x) =  [0.         0.69314718 1.38629436 2.30258509]
log2(x) =  [0.         1.         2.         3.32192809]
log10(x) =  [0.         0.30103    0.60205999 1.        ]
exp(x) -1 =  [0.         0.0010005  0.01005017 0.10517092]
log(1+x) =  [0.         0.0009995  0.00995033 0.09531018]

고급 Ufunc 기능¶

In [8]:

x = np.arange(5)
y = np.empty(5)
np.multiply(x, 10, out=y)  # 원하는 메모리에 직접 연산 결과 쓸수 있음
print(y)

y = np.zeros(10)
np.power(2, x, out=y[::2])  # 특정 위치에 삽입도 가능
print(y)

x = np.arange(1, 6)
print(np.add.reduce(x))  # 결과가 하나 남을때까지 해당 연산 반복
print(np.multiply.reduce(x))
print(np.multiply.accumulate(x))  # 계산 중간 결과를 모두 저장

x = np.arange(1, 6)
np.multiply.outer(x, x)  # 곱셈 테이블

[ 0. 10. 20. 30. 40.]
[ 1.  0.  2.  0.  4.  0.  8.  0. 16.  0.]
15
120
[  1   2   6  24 120]

Out[8]:

array([[ 1,  2,  3,  4,  5],
       [ 2,  4,  6,  8, 10],
       [ 3,  6,  9, 12, 15],
       [ 4,  8, 12, 16, 20],
       [ 5, 10, 15, 20, 25]])

요약 통계 계산¶

In [9]:

L = np.random.random(10)
print(L)
print(sum(L))  # 일반함수도 사용가능 but! 느림
print(np.sum(L))  # 미리 컴파일된 코드에서 실행되어 훨씬 빠름
print(np.min(L), np.max(L))

M = np.random.random((3, 4))
print(M)
print(M.sum())
print(M.min(axis=0))  # 어느 축에 따라 집계할 것인지 추가적인 인수를 취하면 해당 값 반환

print(np.prod(L))  # 곱
print(np.mean(L))  # 평균
print(np.std(L))  # 표준 편차
print(np.var(L))  # 분산
print(np.argmin(L))  # 최솟값의 인덱스
print(np.argmax(L))  # 최댓값의 인덱스
print(np.median(L))  # 중앙값
print(np.percentile(L, [0, 25, 50, 75, 100], interpolation='nearest'))  # 순위기반 백분위 수 계산
print(np.any(L))  # 요소 중에 참이 있는지 검사
print(np.all(L))  # 모든 요소가 참인지 검사

print(np.nanprod(L))  # Nan안전모드.. 누락된 값을 무시하고 계산 위에 메소드명 왼쪽에 nan붙여주면된다.

[0.38458002 0.11719387 0.74847584 0.20981365 0.84159444 0.93185746
 0.5402864  0.19461181 0.68924817 0.43040153]
5.088063178430283
5.088063178430284
0.11719386941643195 0.9318574553543983
[[0.94917271 0.32422963 0.19663225 0.38251919]
 [0.86247217 0.87786444 0.79542752 0.01884597]
 [0.1143016  0.70148436 0.03026869 0.11251023]]
5.365728751107655
[0.1143016  0.32422963 0.03026869 0.01884597]
0.0001731402831695436
0.5088063178430284
0.2727208349394404
0.07437665381006547
1
5
0.4853439638515265
[0.11719387 0.20981365 0.43040153 0.74847584 0.93185746]
True
True
0.0001731402831695436

브로드캐스팅¶

1. 두 배열의 차원 수가 다르면 더 작은 수의 차원을 가진 배열 형상의 앞쪽(왼쪽)을 1로 채운다
2. 두 배열의 형상이 어떤 차원에서도 일치하지 않는다면 해당 차원의 형상이 1인 배열이 다른 형상과 일치하도록 늘어난다.
3. 임의의 차원에서 크기가 일치하지 않고 1도 아니라면 오류가 발생한다

In [10]:

a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
print(a)
print(b)
print(a+b)  # 1x3과 3x1 연산

M = np.ones((2, 3))  # M.shape (2, 3) 
a = np.arange(3)  # a.shape (3,) -> 규칙1:(1, 3) -> 규칙2:(2, 3)
print(M+a)

M = np.ones((3, 2))  # (3, 2) 브로드캐스팅이 호환되지 않는 경우
a = np.arange(3)  # (3,) -> (1, 3) -> (3, 3) 불일치!!
print(M+a)

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

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-10-01f39659b2f8> in <module>
     11 M = np.ones((3, 2))  # (3, 2) 브로드캐스팅이 호환되지 않는 경우
     12 a = np.arange(3)  # (3,) -> (1, 3) -> (3, 3) 불일치!!
---> 13 print(M+a)

ValueError: operands could not be broadcast together with shapes (3,2) (3,) 

비교, 마스킹, 부울 로직¶

In [11]:

x = np.array([1, 2, 3, 4, 5])
print(x < 3)  # np.less
print(x >= 3)  # np.greater_equal
print(x != 3)  # np.not_equal
print((2*x) == (x**2))

[ True  True False False False]
[False False  True  True  True]
[ True  True False  True  True]
[False  True False False False]

In [12]:

x = np.array([[5, 0, 3, 3], [7, 9, 3, 5], [2, 4, 7, 6]])
print(np.count_nonzero(x < 6))  # 0이 아닌것의 개수센다!, 6보다 작은 값은 몇 개일까?

# &(np.bitwise_and), |(np.bitwise_or), ^(np.bitwise_xor), ~(np.bitwise_not)
print(x[x < 5])  # 부울 배열을 인덱스로 사용 -> 마스킹 연산, True값만 반환

8
[0 3 3 3 2 4]

팬시 인덱싱¶

In [13]:

X = np.arange(12).reshape((3, 4))
print(X)
row = np.array([0, 1, 2])
col = np.array([2, 1, 3])
print(X[row, col])  # 뽑고싶은 원소 위치
print(X[row[:, np.newaxis], col])  # 브로드 캐스팅 원칙에 따라..
print(X[2, [2, 0, 1]])  # 짝안맞아도, 단순 인덱스여도 ok

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

In [14]:

i = [2, 3, 3, 4, 4, 4]
x = np.zeros(10)
np.add.at(x, i, 1)  # x에 i에 담긴 인덱스에 반복적으로 1을 더한다.
print(x)

[0. 0. 1. 2. 3. 0. 0. 0. 0. 0.]

정렬¶

In [15]:

x = np.array([2, 1, 10, 3, 5, 4, 9])
print(np.sort(x))  # 정렬 반환
print(np.argsort(x)) # index를 순서대로 반환
print(x.sort())  # 직접 sort 할경우는 None 반환
print(x)

[ 1  2  3  4  5  9 10]
[1 0 3 5 4 6 2]
None
[ 1  2  3  4  5  9 10]

In [16]:

x = np.random.randint(0, 10, (4, 6))
print(x)
print(np.sort(x, axis=0)) # 각 열을 정렬
print(np.sort(x, axis=1)) # 각 행을 정렬

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

In [17]:

x = np.random.randint(1, 10, 10)
print(x)
print(np.partition(x, 3))  # x값중 작은거 3개 정렬 상관x

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

Numpy 구조화된 배열 Struct¶

문자	설명	예제
'b'	바이트	np.dtype('b')
'i'	부호 있는 정수	np.dtype('i4')==np.int32
'u'	부호 없는 정수	np.dtype('u1')==np.uint8
'f'	부동 소수점	np.dtype('f8')==np.int64
'c'	복소수 부동 소수점	np.dtype('c16')==np.complex128
'S', 'a'	문자열	np.dtype('S5')
'U'	유니코드 문자열	np.dtype('U')==np.str_
'V'	원시데이터(void)	np.dtype('V')==np.void

In [18]:

name = ['Alice', 'Bob', 'Cathy', 'Doug']
age = [25, 45, 37, 19]
weight = [55.0, 88.2, 69.0, 32.5]
data = np.zeros(4, dtype={'names':('name', 'age', 'weight'), 'formats':('U10', 'i4', 'f8')})
# dtype={('name', 'U10'), ('age', 'i4'), ('weight', 'f8')} 형태로도 가능
print(data.dtype)
data['name'] = name
data['age'] = age
data['weight'] = weight
print(data)
print(data['name'])  # 이름 가져오기
print(data[0])
print(data[-1]['name'])

data_rec = data.view(np.recarray)  # 딕셔너리 키 대신 속성으로 필드에 접근 가능 but 오버헤드 발생
print(data['age'])
print(data_rec.age)

[('name', '<U10'), ('age', '<i4'), ('weight', '<f8')]
[('Alice', 25, 55. ) ('Bob', 45, 88.2) ('Cathy', 37, 69. )
 ('Doug', 19, 32.5)]
['Alice' 'Bob' 'Cathy' 'Doug']
('Alice', 25, 55.)
Doug
[25 45 37 19]
[25 45 37 19]