Numpy

목차

Numpy란

• C언어를 기반으로 내부 반복문을 사용하여 속도가 매우 빠르다.

• 다차원 배열(ndarray)을 편리하게 처리할 수 있도록 지원해주는 파이썬 라이브러리다.

• ndarray : 적은 메모리로 데이터를 빠르게 처리하고, 모든 원소는 같은 자료형을 가진다.

• list : 속도가 매우 느리고, 원소가 각각 다른 자료형을 가질 수 있다.

ndarray

• N-dimensional Array

• 다차원 배열을 지원한다.

• 서로 다른 타입의 데이터를 담을 수 없다.

• 내부 반복문을 사용해서 속도가 빠르다.

• 배열 간에 산술 연산이 가능하다.

데이터 타입 종류

1. int(8bit, 16bit, 32bit, 64bit) i1, i2, i4, i8

• 부호가 있다.

• 비트수 만큼 크기를 가지는 정수형이다.

• 저장할 수 있는 값의 범위 : -2ⁿ⁻¹ ~ 2ⁿ⁻¹-1
 

• 부호가 없다.

• 비트수 만큼 크기를 가지는 정수형이다.

• 저장할 수 있는 값의 범위 : 0 ~ 2ⁿ-1

• 부호가 있다.

• 비트수 만큼 크기를 가지는 실수형이다.

• complex64 : 두개의 32비트 부동 소수점으로 표시되는 복소수 c8

• complex128 : 두개의 64비트 부동소수점으로 표시되는 복소수 c16

• 고정 길이 문자열 unicode

• True, False

• dtype : 자료형 확인

• astype : 자료형 변경

import numpy as np

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

a = np.array(data)
a

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

a.dtype

Out[-]
dtype('int32')

a = a.astype(np.float32)
a

Out[-]
array([[1., 2., 3.],
       [4., 5., 6.],
       [7., 8., 9.]], dtype=float32)

a[0][1]

Out[-]
2.0

a[0]

Out[-]
array([1., 2., 3.], dtype=float32)

• np.arange(start, stop, step) : step에 따라 증가하는 수열을 생성한다.

• reshape : 만들어진 배열의 데이터를 그대로 가지고 형태를 바꿔준다.

np.arange(1, 10, 2) # (start, stop, step)

Out[-]
array([1, 3, 5, 7, 9])

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

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

np.arange(1, 13).reshape(3, 2, 2)

Out[-]
array([[[ 1,  2],
        [ 3,  4]],

       [[ 5,  6],
        [ 7,  8]],

       [[ 9, 10],
        [11, 12]]])

• nan
• 자료형이 Float형이므로 Integer에서는 오류가 발생한다.
• 배열에서 연산할 경우 오류가 발생하지 않지만 결과값이 NaN이 된다.

np.nan * 10

Out[-]
nan

a[0][1] = np.nan
a

Out[-]
array([[ 1., nan,  3.],
       [ 4.,  5.,  6.],
       [ 7.,  8.,  9.]], dtype=float32)

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

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

a[0][1] = np.nan # integer에서는 nan을 사용 할 수 없다.

Out[-]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-15-10bef5bd968c> in <module>
----> 1 a[0][1] = np.nan

ValueError: cannot convert float NaN to integer

a = np.linspace(1, 10, 20) # (start, stop, num)
a

Out[-]
array([ 1.        ,  1.47368421,  1.94736842,  2.42105263,  2.89473684,
        3.36842105,  3.84210526,  4.31578947,  4.78947368,  5.26315789,
        5.73684211,  6.21052632,  6.68421053,  7.15789474,  7.63157895,
        8.10526316,  8.57894737,  9.05263158,  9.52631579, 10.        ])

연산

• 반복문을 사용하지 않아도, 배열의 모든 원소는 반복연산이 사용된다.

• 선형 대수 식을 사용하여 연산 가능하다.
• np.dot, @ : 행렬 곱 구하는 연산

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

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

data + data

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

[1, 2, 3] + [4, 5, 6] # 리스트끼리 더하면 연결된다.

Out[-]
[1, 2, 3, 4, 5, 6]

data - data

Out[-]
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

data * data

Out[-]
array([[ 1,  4,  9],
       [16, 25, 36],
       [49, 64, 81]])

data / data

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

np.dot(data, data)

Out[-]
array([[ 30,  36,  42],
       [ 66,  81,  96],
       [102, 126, 150]])

data@data 

Out[-]
array([[ 30,  36,  42],
       [ 66,  81,  96],
       [102, 126, 150]])

차원

• 0차원 : Scalar (하나의 데이터 값으로만 존재하는 것)

• 1차원 : Vector (숫자들의 배열 (1D array))

• 2차원 : Matrix (숫자들의 2D array (rows: 행, columns: 열))

• 3차원 이상 : Tensor (숫자들의 다차원 배열)

# 0차원
a = np.array(1)
print(a)
print(a.shape)
print(a.ndim)

Out[-]
1
()
0

# 1차원
a = np.array([1])
print(a)
print(a.shape)
print(a.ndim)

Out[-]
[1]
(1,)
1

# 1차원
a = np.array([1, 2, 3, 4, 5])
print(a)
print(a.shape)
print(a.ndim)

Out[-]
[1 2 3 4 5]
(5,)
1

# 2차원
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(a.shape)
print(a.ndim)

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

# 2차원
a = np.array([[1]])
print(a)
print(a.shape)
print(a.ndim)

Out[-]
[[1]]
(1, 1)
2

# 3차원
a = np.array([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]])
print(a)
print(a.shape)
print(a.ndim)

Out[-]
[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]]

(2, 3, 2)

3

matrix 유형

• zeros : 0으로 초기화된 배열 생성

• ones : 1로 초기화 된 배열 생성

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

• empty : 초기화 하지 않고 배열만 생성, 기존에 메모리에 저장되어 있는 값으로 나타남

• full : 지정한 숫자로 초기화

• linespace(start, end(포함), number, endpoint = ) : 선형 구간을 지정한 개수만큼 분할한다.
• endpoint = True or False : 마지막 값을 포함시킬지 시키지 않을지 선택

a = np.arange(12).reshape(2,3,2)
a

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

       [[ 6,  7],
        [ 8,  9],
        [10, 11]]])

b = np.ones(12)
b

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

b = np.ones(12).reshape(2, 3, 2)
b

Out[-]
array([[[1., 1.],
        [1., 1.],
        [1., 1.]],

       [[1., 1.],
        [1., 1.],
        [1., 1.]]])

c = np.zeros(12).reshape(2, 3, 2)
c

Out[-]
array([[[0., 0.],
        [0., 0.],
        [0., 0.]],

       [[0., 0.],
        [0., 0.],
        [0., 0.]]])

d = np.eye(3)
d

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

e = np.zeros([3, 4])
e

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

e = np.zeros([3, 4, 2])
e

Out[-]
array([[[0., 0.],
        [0., 0.],
        [0., 0.],
        [0., 0.]],

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

       [[0., 0.],
        [0., 0.],
        [0., 0.],
        [0., 0.]]])

f = np.empty([2, 3])
f

Out[-]
array([[2.12199579e-314, 6.36598737e-314, 1.06099790e-313],
       [1.48539705e-313, 1.90979621e-313, 2.33419537e-313]])

g = np.full((3, 4), 1000)
g

Out[-]
array([[1000, 1000, 1000, 1000],
       [1000, 1000, 1000, 1000],
       [1000, 1000, 1000, 1000]])

h = np.linspace(2, 10, 6)
h

Out[-]
array([ 2. ,  3.6,  5.2,  6.8,  8.4, 10. ])

집계함수

• mean : 평균을 구하는 함수

• median : 데이터를 크기로 정렬하고 그 중 가운데 수 출력하는 함수
※ 만약 데이터 개수가 짝수일 경우 가장 가운데의 두 수의 평균을 구한다.

• var : 분산 구하는 함수

• std : 표준편차 구하는 함수

• sum : 합계 구하는 함수

• max : 가장 큰 수를 구하는 함수

• min : 가장 작은 수를 구하는 함수

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

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

a[0][0] = 100
a

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

a[0, 1] = 1000
a

Out[-]
array([[ 100, 1000,    2,    3,    4],
       [   5,    6,    7,    8,    9]])

np.mean(a)

Out[-]
114.4

np.median(a)

Out[-]
6.5

np.std(a)

Out[-]
296.5485457728633

np.var(a)

Out[-]
87941.04

np.sum(a)

Out[-]
1144

sum(a)

Out[-]
array([ 105, 1006,    9,   11,   13])

a

Out[-]
array([[ 100, 1000,    2,    3,    4],
       [   5,    6,    7,    8,    9]])

np.sum(a, axis=0)

Out[-]
array([ 105, 1006,    9,   11,   13])

np.sum(a, axis=1)

Out[-]
array([1109,   35])

np.max(a)

Out[-]
1000

np.min(a)

Out[-]
2