[프로그래머스 겨울방학 인공지능 과정] numpy 복습

numpy 복습¶

1. 일반 list를 numpy.ndarray타입으로 바꾸기 : np.array(list)

In [1]:

import numpy as np

In [2]:

list = [1, 2, 3, 4, 5]

# numpy.ndarray 타입으로 바꾸기
np.array(list)

Out[2]:

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

1. numpy.ndarray 타입을 가진 배열의 모양 파악하기 : nparray.shape

In [6]:

# 2 * 2 * 3 형태의 np.array 생성
np_array = np.array(
    [
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]]
    ]
)

# np_array의 형태 파악 : shape
print(np_array.shape)

(2, 2, 3)

1. 영벡터 및 일벡터 만들기 : np.zeros(), np.ones()

In [7]:

# 2 * 1 * 3 형태의 일벡터 만들기 : .ones()
np.ones(shape = (2, 1, 3))

Out[7]:

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

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

In [8]:

# 3 * 4 * 5 형태의 영벡터 만들기 : .zeros()
np.zeros(shape = (3, 4, 5))

Out[8]:

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., 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.]]])

1. 가우시안 분포에 따라서 4 3 3 모양을 가진 랜덤 배열 만들기 : np.random.randn(size)

In [9]:

np.random.randn(4, 3, 3)

Out[9]:

array([[[ 1.01434512, -0.47299951, -1.49783958],
        [ 0.80254225, -0.93058938,  0.19567324],
        [-0.99300977,  0.51112061, -0.33560046]],

       [[ 0.62847241, -0.80230954, -0.14450291],
        [-0.16701719, -1.84979883, -0.87395471],
        [ 0.34945105,  1.41492207, -1.24751197]],

       [[ 1.84736238, -0.84303561, -0.06933905],
        [ 1.00255585,  0.71112579, -1.29182961],
        [ 1.7896122 ,  0.08564326, -0.19454643]],

       [[-0.15473604, -1.02745725,  1.05957579],
        [-1.10144487,  1.44025167, -1.31294   ],
        [-0.01839053, -0.89846897, -1.05496502]]])

1. 10부터 20까지 임의의 정수로 채워진 3 * 5 배열 형성 : np.random.randint(lower number, higher number, size = (size))
   • 단, lower number <= x < higher number로 채워짐

In [10]:

np.random.randint(10, 21, size = (3, 4))

Out[10]:

array([[15, 14, 10, 17],
       [13, 15, 11, 17],
       [14, 16, 10, 19]])

1. 평균 2, 표준편차 1의 5 * 10의 모양을 가진 배열을 형성합니다 : np.random.normal(loc = 평균, scale = 표준편차, size = (행, 열))

In [11]:

np.random.normal(loc = 2, scale = 1, size = (5, 10))

Out[11]:

array([[2.24135437, 1.78109042, 1.20544967, 1.35771091, 2.79024009,
        0.65527611, 3.60595163, 2.83074847, 1.22225211, 0.86862045],
       [1.36157439, 2.27517044, 2.8556296 , 2.42659495, 2.4381471 ,
        2.27921985, 1.67885349, 1.30619896, 1.2340231 , 1.90777949],
       [0.7880635 , 1.65947634, 2.39464056, 1.13792884, 4.09267758,
        3.46416073, 1.44498733, 1.38525979, 3.1349523 , 4.0259504 ],
       [1.34821816, 2.40476156, 0.64365669, 1.835949  , 1.68672891,
        1.49772394, 3.88358056, 2.35857358, 0.21635394, 1.92665957],
       [3.56620857, 2.31720988, 1.89550896, 3.11420831, 3.08552963,
        2.24865513, 1.04143024, 2.40861787, 2.78248322, 2.55140726]])

1. 배열의 접근 : 0, 1, 1번째 요소 값에 접근합니다.

In [25]:

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

print(test_arr[0][1][1])  # 5

# 값의 변경도 가능합니다.
test_arr[0][1][1] = 0

print(test_arr)   # 5였던 자리가 0으로 변합니다.

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

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

 [[13 14 15]
  [16 17 18]]]

1. 배열의 사칙연산 (동일 크기의 np.ndarray일 경우)

In [26]:

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

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

In [27]:

# 배열의 덧셈
arr_A + arr_B

Out[27]:

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

In [28]:

# 배열의 뺄셈
arr_A - arr_B

Out[28]:

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

In [30]:

# 배열의 곱셈
arr_A * arr_B

Out[30]:

array([[[ 1,  4,  9],
        [16, 25, 36]]])

In [31]:

# 배열의 나눗셈
arr_A / arr_B

Out[31]:

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

In [36]:

# 주의! np.array가 아닐 경우, 단순히 리스트가 합쳐지도록 출력됩니다.
# 두 list 다 np.array로 선언되지 않았다.
arr_A = ([
    [[1, 2, 3], [4, 5, 6]]
])

arr_B = ([
    [[1, 2, 3], [4, 5, 6]]
])

# np.array가 선언되지 않았으므로, 두 리스트 전부 list 타입이다.
type(arr_A)
type(arr_B)

Out[36]:

list

In [38]:

# 이 상태에서 단순 덧셈을 실시하면 리스트가 합쳐진다.
arr_A + arr_B

Out[38]:

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

1. 행렬곱의 수행 : np.dot()

In [42]:

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

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

In [43]:

# 행렬곱의 수행
np.dot(test_A, test_B) # 행렬곱 결과

Out[43]:

array([[ 7, 10],
       [15, 22]])

In [44]:

# 행렬곱은 단순곱과는 차이가 있다.
test_A * test_B # 단순곱 결과

Out[44]:

array([[ 1,  4],
       [ 9, 16]])

1. 1차원 배열의 슬라이싱

In [46]:

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

# 리스트 슬라이싱과 같은 방식으로 슬라이싱이 가능하다.
# [a, b]에서 a 이상 b 미만임을 기억하자.
test_C [0:4]

Out[46]:

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

In [49]:

# 슬라이싱 후 값을 바꾸어줄 수도 있다.
# 0부터 3까지의 범위를 모두 1로 변환
test_C [0:4] = np.ones(1)
test_C

Out[49]:

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

1. 2차원 배열의 슬라이싱 : array[행 시작점:행 끝점, 열 시작점 : 열 끝점]
   • 단, 이전 슬라이싱 때와 같이 이상과 미만의 약속을 지키도록 하자.

In [54]:

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

In [55]:

# (0, 0)부터 (1, 3)까지 가져온다.
test_last[0:2, 0:4]

Out[55]:

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

In [62]:

# 접근한 값을 바꿔줄 수도 있다.
# (0, 0)부터 (1, 3)까지 값을 0으로 만든다.
test_last[0:2, 0:4] = 0
test_last

Out[62]:

array([[ 0,  0,  0,  0,  5],
       [ 0,  0,  0,  0, 10],
       [11, 12, 13, 14, 15]])