Python 넘파이

NumPy (Numerical Python)¶

• 수학 및 과학적 연산을 쉽고 빠르게 지원
• 다차원 행렬(Array/Matrix)을 효과적으로 처리
• 일반적으로 같은 데이터 타입 값으로 구성
• https://numpy.org

In [ ]:

import warnings
warnings.filterwarnings('ignore')

I. NumPy Package import ~ as

In [ ]:

import numpy as np

• Version Check

In [ ]:

np.__version__

Out[ ]:

'1.22.4'

II. Array 생성¶

• Python List 구조를 사용

1) Scalar - 0D Array - Rank0 Tensor

In [ ]:

a0 = np.array(9)

In [ ]:

print(a0)

9

2) Vector - 1D Array - Rank1 Tensor

In [ ]:

a1 = np.array([1, 3, 5, 7, 9])

In [ ]:

print(a1)

[1 3 5 7 9]

In [ ]:

a1[2]

Out[ ]:

5

In [ ]:

a1[1:3]

Out[ ]:

array([3, 5])

3) Matrix - 2D Array - Rank2 Tensor

In [ ]:

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

In [ ]:

print(a2)

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

• a2[행]

In [ ]:

a2[1]

Out[ ]:

array([4, 5, 6])

• a2[행, 열]

In [ ]:

a2[1, 1]

Out[ ]:

5

• a2[행, 열]

In [ ]:

a2[:, 1]

Out[ ]:

array([2, 5, 8])

4) Array - 3D Array - Rank3 Tensor

In [ ]:

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

In [ ]:

print(a3)

[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]]

• a3[축]

In [ ]:

a3[1]

Out[ ]:

array([[5, 6],
       [7, 8]])

• a3[축, 행]

In [ ]:

a3[1, 1]

Out[ ]:

array([7, 8])

• a3[축, 행, 열]

In [ ]:

a3[1, 1, 1]

Out[ ]:

8

• a3[축, 행, 열]

In [ ]:

a3[:, 0, 0]

Out[ ]:

array([1, 5, 9])

• a3[축, 행, 열]

In [ ]:

a3[:, :, 0]

Out[ ]:

array([[ 1,  3],
       [ 5,  7],
       [ 9, 11]])

III. AR.shape and AR.reshape( )

In [ ]:

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

In [ ]:

AR

Out[ ]:

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

In [ ]:

print(AR)

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

1) .shape

• 행렬 크기

In [ ]:

AR.shape

Out[ ]:

(12,)

• 행렬 차원

In [ ]:

AR.ndim

Out[ ]:

1

• 행렬 원소 개수

In [ ]:

AR.size

Out[ ]:

12

2) .reshape(3, 4)

• .reshape(행, 열)

In [ ]:

AR2 = AR.reshape(3, 4)

In [ ]:

AR2

Out[ ]:

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

In [ ]:

print(AR2)

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

• 행렬 크기

In [ ]:

AR2.shape

Out[ ]:

(3, 4)

• 행렬 차원

In [ ]:

AR2.ndim

Out[ ]:

2

• 행렬 원소 개수

In [ ]:

AR2.size

Out[ ]:

12

3) .reshape(3, 2, 2)

• .reshape(축, 행, 열)

In [ ]:

AR3 = AR.reshape(3, 2, 2)

In [ ]:

print(AR3)

[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]]

• 행렬의 크기

In [ ]:

AR3.shape

Out[ ]:

(3, 2, 2)

• 행렬의 차원

In [ ]:

AR3.ndim

Out[ ]:

3

• 행렬의 원소 개수

In [ ]:

AR3.size

Out[ ]:

12

4) .reshape(-1, 1)¶

• .reshape(12, 1)

In [ ]:

AR.reshape(-1, 1)

Out[ ]:

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

• .reshape(1, 12)

In [ ]:

AR2.reshape(1, -1)

Out[ ]:

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

In [ ]:

AR2.reshape(12)

Out[ ]:

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

In [ ]:

AR3.reshape(-1)

Out[ ]:

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

• .flatten( )

In [ ]:

AR3.flatten()

Out[ ]:

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

In [ ]:

dza = np.array(12)

In [ ]:

dza.shape

Out[ ]:

()

IV. 범위 지정(arange) 함수¶

1) 연속된 10개 값 생성¶

In [ ]:

np.arange(10)

Out[ ]:

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

2) 1부터 9까지 1간격으로 생성¶

In [ ]:

np.arange(1, 10)

Out[ ]:

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

3) 1부터 9까지 2간격으로 생성¶

In [ ]:

np.arange(1, 10, 2)

Out[ ]:

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

4) Array 생성 후 .reshape( ) 적용¶

In [ ]:

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

Out[ ]:

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

V. 특별한 형태의 Array 생성¶

1) 0과 1로만 구성된 Array¶

• 0으로만 구성

In [ ]:

np.zeros(9)

Out[ ]:

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

In [ ]:

np.zeros([3, 4])

Out[ ]:

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

• 1로만 구성

In [ ]:

np.ones(9)

Out[ ]:

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

In [ ]:

np.ones([4, 3])

Out[ ]:

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

• 산술연산을 적용하여 '9'로만 구성된 행렬 생성

In [ ]:

np.zeros([3, 4]) + 9

Out[ ]:

array([[9., 9., 9., 9.],
       [9., 9., 9., 9.],
       [9., 9., 9., 9.]])

2) 3 x 3 단위행렬

In [ ]:

np.eye(3)

Out[ ]:

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

3) 난수 Array 생성¶

• 실수 난수 생성

• (축, 행, 열)

In [ ]:

np.random.rand(3, 2, 2)

Out[ ]:

array([[[0.10375678, 0.48312406],
        [0.30570654, 0.95067111]],

       [[0.92518956, 0.6453263 ],
        [0.70523291, 0.55346084]],

       [[0.42195719, 0.92122968],
        [0.4864507 , 0.01922632]]])

• 주어진 정수 범위에서 난수 생성

• 1 ~ 44 사이
• 복원 추출
• (행, 열)

In [ ]:

np.random.randint(1, 45, size = (5, 6))

Out[ ]:

array([[17,  5, 38, 26, 31, 32],
       [31, 24, 30, 20, 21, 32],
       [30, 18, 35, 28, 31, 37],
       [24, 31,  5, 44,  3, 21],
       [ 3, 37, 18, 19, 40, 13]])

• np.random.seed( )

• 의사난수(Pseudo Random Number) 생성 초기값 지정
• 항상 같은 난수 생성
• 비복원 추출 (replace = False)

In [ ]:

np.random.seed(2045)

np.random.choice(np.arange(1, 46), size = (5 ,6), replace = False)

Out[ ]:

array([[ 7, 32,  6, 41,  4, 34],
       [30, 28, 16,  5, 38, 33],
       [31, 13, 25, 23, 43, 12],
       [45,  8, 29, 22, 18,  9],
       [21, 20, 40,  2, 37, 39]])

• shuffle( )

• 원소 섞기

In [ ]:

TA = np.arange(1, 10)

TA

Out[ ]:

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

In [ ]:

np.random.shuffle(TA)

TA

Out[ ]:

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

VI. Array 연산¶

In [ ]:

A1 = np.array([85, 93, 75, 97, 69])

A2 = np.array([91, 90, 85, 97, 89])

A3 = np.array([[85, 93, 75],
               [90, 84, 97],
               [99, 91, 80]])

1) 기본 연산¶

• 각각의 행과 열의 값을 매칭하여 연산 수행

In [ ]:

A1 + A2

Out[ ]:

array([176, 183, 160, 194, 158])

In [ ]:

A2 - A1

Out[ ]:

array([ 6, -3, 10,  0, 20])

In [ ]:

A1 * A2

Out[ ]:

array([7735, 8370, 6375, 9409, 6141])

In [ ]:

A2 * A1

Out[ ]:

array([7735, 8370, 6375, 9409, 6141])

In [ ]:

A2 / A1

Out[ ]:

array([1.07058824, 0.96774194, 1.13333333, 1.        , 1.28985507])

In [ ]:

A2 // A1

Out[ ]:

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

In [ ]:

A2 % A1

Out[ ]:

array([ 6, 90, 10,  0, 20])

In [ ]:

A1 * 3

Out[ ]:

array([255, 279, 225, 291, 207])

In [ ]:

A1 ** 2

Out[ ]:

array([7225, 8649, 5625, 9409, 4761])

2) 통계량 연산¶

• 총합

In [ ]:

A1.sum()

Out[ ]:

419

• 평균

In [ ]:

A2.mean()

Out[ ]:

90.4

• 분산

• 'ddof = 0'

In [ ]:

A2.var()

Out[ ]:

15.040000000000001

• 표준 편차

• 'ddof = 0'

In [ ]:

A2.std()

Out[ ]:

3.8781438859330635

• 최소값

In [ ]:

A2.min()

Out[ ]:

85

• A3 전체 최소값

In [ ]:

A3.min()

Out[ ]:

75

• A3 각 열의 최소값

In [ ]:

A3.min(axis = 0)

Out[ ]:

array([85, 84, 75])

• A3 각 행의 최소값

In [ ]:

A3.min(axis = 1)

Out[ ]:

array([75, 84, 80])

In [ ]:

A3.min(axis = 1, keepdims = True)

Out[ ]:

array([[75],
       [84],
       [80]])

• 최대값

In [ ]:

A2.max()

Out[ ]:

97

• A3 전체 최대값

In [ ]:

A3.max()

Out[ ]:

99

• A3 각 열의 최대값

In [ ]:

A3.max(axis = 0)

Out[ ]:

array([99, 93, 97])

• A3 각 행의 최대값

In [ ]:

A3.max(axis = 1)

Out[ ]:

array([93, 97, 99])

In [ ]:

A3.max(axis = 1, keepdims = True)

Out[ ]:

array([[93],
       [97],
       [99]])

• 누적(Cumulative)합

In [ ]:

A1.cumsum()

Out[ ]:

array([ 85, 178, 253, 350, 419])

• 누적(Cumulative)곱

In [ ]:

A1.cumprod()

Out[ ]:

array([        85,       7905,     592875,   57508875, 3968112375])

VII. Matrix 연산¶

• M1, M2 지정

In [132]:

M1 = np.array([2, 4, 6, 8]).reshape(2, 2)

In [ ]:

print(M1)

[[2 4]
 [6 8]]

In [133]:

M2 = np.array([3, 5, 7, 9]).reshape(2, 2)

In [ ]:

print(M2)

[[3 5]
 [7 9]]

1) Matrix 곱¶

• M1 @ M2

In [ ]:

M1.dot(M2)

Out[ ]:

array([[ 34,  46],
       [ 74, 102]])

• M2 @ M1

In [ ]:

np.dot(M2, M1)

Out[ ]:

array([[ 36,  52],
       [ 68, 100]])

In [134]:

M1 @ M2

Out[134]:

array([[ 34,  46],
       [ 74, 102]])

• Warning: M1 * M2

In [ ]:

M1 * M2

Out[ ]:

array([[ 6, 20],
       [42, 72]])

In [ ]:

M2 * M1

Out[ ]:

array([[ 6, 20],
       [42, 72]])

2) 전치 행렬¶

• M1의 전치 행렬

In [ ]:

np.transpose(M1)

Out[ ]:

array([[2, 6],
       [4, 8]])

• M2의 전치 행렬

In [ ]:

M2.transpose()

Out[ ]:

array([[3, 7],
       [5, 9]])

In [ ]:

M2.T

Out[ ]:

array([[3, 7],
       [5, 9]])

¶

¶

¶

The End¶

¶

¶

¶