Numpy Operation 넘파이 연산

NumPy Operation 넘파이 연산¶

In [1]:

import numpy as np

1. 산술연산¶

1. 더하기: +, add()

2. 빼기: -, subtract()

3. 나누기: /, divide()

4. 곱하기: *, multiply()

5. 지수곱: exp()

6. 제곱근: sqru()

7. 로그: log()

8. 내적(행렬곱): dot()

In [2]:

# Numpy 객체 정보를 확인하기 위한 사용자 함수 정의 : 객체타입, 구조, 차원, 데이터타입
def np_print(arr):
    text="""
    type : {}
    shape : {}
    dimension : {}
    dtype : {}
    data : \n {}""".format(type(arr), arr.shape, arr.ndim, arr.dtype, arr)
    print(text)

• 1 $\leq x <$ 10 지정범위에서 1씩 증가하는 숫자를 데이터로 가진 3행 * 3열 배열

In [3]:

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

np_print(arr_10)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

• $4 \leq x < 13$, 1씩 증가하는 정수 data, 3 rows X 3 columns 배열

In [4]:

arr_13 = np.arange(4, 13).reshape(3, 3)

np_print(arr_13)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

• $10 \leq x < 22$, x += 1, (3, 4) 배열

In [5]:

arr_22 = np.arange(10, 22).reshape(3, 4)

np_print(arr_22)

    type : <class 'numpy.ndarray'>
    shape : (3, 4)
    dimension : 2
    dtype : int32
    data : 
 [[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]

1.1. 더하기¶

• 산술연산자: arr1 + arr2

• numpy method: np.add(arr1, arr2)

In [6]:

np_print(arr_10)

np_print(arr_13)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

• 산술연산자: arr1 + arr2

In [7]:

arr_10 + arr_13

Out[7]:

array([[ 5,  7,  9],
       [11, 13, 15],
       [17, 19, 21]])

• numpy method: np.add(arr1, arr2)

In [8]:

np.add(arr_10, arr_13)

Out[8]:

array([[ 5,  7,  9],
       [11, 13, 15],
       [17, 19, 21]])

• shape$(x_1, x_2, ..., x_n)$이 다른 ndarray끼리 더하기 연산 > VauleError

In [9]:

np.add(arr_10, arr_22)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_8440\1923253017.py in <module>
----> 1 np.add(arr_10, arr_22)

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

1.2. 빼기¶

• 산술연산자: arr1 - arr2

• numpy method np.subtract(arr1, arr2)

• 산술연산자: arr1 - arr2

In [10]:

arr_10 - arr_13

Out[10]:

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

• numpy method: np.subtract(arr1, arr2)

In [11]:

np.subtract(arr_13, arr_10)

Out[11]:

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

• -, np.subtract() > parameter 순서에 따라 결과 다름

np.subtract(a, b) == a - b $\neq$ np.subtract(b, a) == b - a

In [12]:

np.subtract(arr_10, arr_13)

Out[12]:

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

1.3. 나누기¶

• 산술연산자: arr1 / arr2

• numpy method: np.divide(arr1, arr2)

• 산술연산자: arr1 / arr2

In [13]:

np_print(arr_10)

np_print(arr_13)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

In [14]:

arr_10 / arr_13

Out[14]:

array([[0.25      , 0.4       , 0.5       ],
       [0.57142857, 0.625     , 0.66666667],
       [0.7       , 0.72727273, 0.75      ]])

: $x \rightarrow \infty$에서, $\frac{x}{x-3} \rightarrow 1$

• numpy method: np.divide(arr1, arr2)

In [15]:

np.divide(arr_13, arr_10)

Out[15]:

array([[4.        , 2.5       , 2.        ],
       [1.75      , 1.6       , 1.5       ],
       [1.42857143, 1.375     , 1.33333333]])

: $x \rightarrow \infty$에서, $\frac{x - 3}{x} \rightarrow 1$

1.4. 곱하기¶

• ndarry 곱하기: arr1[i][j] * arr2[i][j] == result[i][j]

• 산술연산자: arr1 * arr2

• numpy method: np.multiply(arr1, arr2)

• 산술연산자: arr1 * arr2

In [16]:

arr_10 * arr_13

Out[16]:

array([[  4,  10,  18],
       [ 28,  40,  54],
       [ 70,  88, 108]])

In [17]:

arr_13 * arr_10

Out[17]:

array([[  4,  10,  18],
       [ 28,  40,  54],
       [ 70,  88, 108]])

• numpy method: np.multiply(arr1, arr2)

In [18]:

np.multiply(arr_10, arr_13)

Out[18]:

array([[  4,  10,  18],
       [ 28,  40,  54],
       [ 70,  88, 108]])

1.5. 지수곱 표현¶

• 지수(exponent): 부동 소수점(floating point)으로 숫자를 거듭제곱을 사용해 표현
  2.14e+2$ = 2.14 \times 10^2 = 214$, 2.98e-8$ = 2.98 \times 10^{-8} = 0.0000000298$

• numpy method: np.exp(arr): 밑 = 자연상수 $e$인 지수함수 $y = e^x$
  > $x =$ arr[i][j]일 때의 $y$값

• 지수곱 numpy method: np.exp(arr)

In [19]:

np_print(arr_10)

np.exp(arr_10)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

Out[19]:

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

1.6. 제곱근¶

• numpy method: np.sqrt(arr)

• n이하의 소수 개수 구하기 > n의 제곱근이하의 소수 개수와 동일
  :소인수분해시, 제곱근이 중심이 되어 양쪽이 곱대칭 > 제곱근까지의 소수만 계산
  

• "에라토스테네스의 체": n 이하의 소수 개수 구하기
  :$2 \leq x \leq n$, $x = $소수, $x$의 배수를 제외하면 > n 이하의 소수만 남는다

In [20]:

np.sqrt(arr_10)

Out[20]:

array([[1.        , 1.41421356, 1.73205081],
       [2.        , 2.23606798, 2.44948974],
       [2.64575131, 2.82842712, 3.        ]])

1.7. 내적(행렬곱)¶

• numpy method: np.dot(arr1, arr2) $= {A_1}{A_2} = (arr1_{ij}) \times (arr2_{ij}) $

In [21]:

np_print(np.dot(arr_10, arr_13))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 48  54  60]
 [111 126 141]
 [174 198 222]]

2. Numpy 배열 연산¶

2.1. 비교 연산¶

1. item

   • 값에 대한 비교: ==, !=

   • 크기에 대한 비교 : >, <, >=, <=

2. 배열

   • 두 배열 전체에 대한 비교: np.array_equal(arr1, arr2)

• 값에 대한 비교: ==, !=

  • 두 배열 item에 대하여 값이 동일한지 비교

  • return value: 각 item마다의 비교 결과(bool type)가 item인 배열

In [22]:

arr_10 == arr_13

Out[22]:

array([[False, False, False],
       [False, False, False],
       [False, False, False]])

In [23]:

arr_10 != arr_13

Out[23]:

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

• shape이 같은 배열에 대해서만 비교 가능

In [24]:

arr_10 == arr_22

C:\Users\EthanJ\AppData\Local\Temp\ipykernel_8440\2882259080.py:1: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.
  arr_10 == arr_22

Out[24]:

False

• 크기에 대한 비교: 배열의 item별로 각각 비교 > bool type 배열 return

In [25]:

arr_13 > arr_10

Out[25]:

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

• 두 배열 전체에 대한 비교: np.array_equal(arr1, arr2)
  > return single value(bool type)

In [26]:

np.array_equal(arr_10, arr_13)

Out[26]:

False

3. 집계 함수¶

• ndarry에 대해 집계 함수를 적용할 때 > 반드시 설정된 기준axis에 따라 연산 수행

• default: axis=None: 전체 데이터를 1차원 배열로 간주, 집계 함수의 연산 범위를 전체 배열로 지정

• axis=0: 행(row)의 축방향, $\downarrow$, column 기준으로 동일한 열에 있는 요소를 하나의 그룹으로 묶어 집계 함수의 연산 범위로 지정

• axis=1: 열(column)의 축방향, $\rightarrow$, row 기준으로 동일한 행에 있는 요소를 하나의 그룹으로 묶어 집계 함수의 연산 범위로 지정

• 집계 함수 : 배열 obj에 대한 method로 사용하거나, Numpy의 method로 사용

1. 합계 : .sum()

2. 최소값 : .min()

3. 최대값 : .max()

4. 누적 합계 : .cumsum()

5. 평균 : .mean()

6. 중앙값 : .median()
   > 크기 순으로 나열된 데이터에 대해 중앙에 위치하는 값

7. 상관계수 : .corrcoef()
   > 데이터 간의 상관관계를 나타내는 수치($-1 \leq r \leq 1$)

8. 표준편차 : .std()
   > $\sigma$, 분산의 제곱근, 각 데이터가 평균으로부터 흩어져 있는 정도

9. 고유값 : .unique()

In [27]:

np_print(arr_10)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

3.1. 합계¶

합계: 전체 기준 > 모든 요소에 대한 합

1. ndarry method: arr.sum()

2. numpy method: np.sum(arr)

In [28]:

arr_10.sum()

Out[28]:

45

In [29]:

np.sum(arr_10)

Out[29]:

45

• axis=1: 열의 축방향, $\rightarrow$, row별, 행별 합계

• arr.sum(), np.sum(arr) optional parameter: axis=1

• return: [0번 row의 합, 1번 row의 합, 2번 row의 합, ..., n번 row의 합]

In [30]:

np_print(arr_10)

print(arr_10.sum(axis=1))
print(np.sum(arr_10, axis=1))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
[ 6 15 24]
[ 6 15 24]

• axis=0: 행의 축 방향, $\downarrow$, 열별, column별 합산

• arr.sum(), np.sum(arr) optinal parameter: axis=0

• return: [index 0 column sum, index 1, ..., index n-2, index n-1]

In [31]:

print(arr_10.sum(axis=0))
print(np.sum(arr_10, axis=0))

print(np.sum(arr_10))

[12 15 18]
[12 15 18]
45

3.2. 최소값¶

1. ndarray method: arr.min()

2. numpy method: np.min(arr)

• 전체 기준 최소값: axis=None (default)

In [32]:

np_print(arr_22)

print(arr_22.min())

print(np.min(arr_22))

    type : <class 'numpy.ndarray'>
    shape : (3, 4)
    dimension : 2
    dtype : int32
    data : 
 [[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]
10
10

• c.f. Python list에서 최소값 찾기

In [33]:

x_list = [1, 2, 3, 4]

min(x_list)

Out[33]:

1

• axis=1: column의 축방향, $\rightarrow$, row 단위 기준

• arr.min(axis=1), np.min(arr, axis=1): row별 최소값 찾기

• return값 > [index 0 row min, index 1 row min, ... index n-1 row min]

In [34]:

np_print(arr_10)

print(arr_10.min(axis=1))
print(np.min(arr_10, axis=1))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
[1 4 7]
[1 4 7]

• axis=0: row의 축방향, $\downarrow$, 열 기준, column 기준

• arr.min(axis=0), np.min(arr, axis=0): 열 기준 최소값 찾기

• return값 > [0번 column min, 1번 column min, ... n-1번 column min]

In [35]:

np_print(arr_22)

print(arr_22.min(axis=0))
print(np.min(arr_22, axis=0))

    type : <class 'numpy.ndarray'>
    shape : (3, 4)
    dimension : 2
    dtype : int32
    data : 
 [[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]
[10 11 12 13]
[10 11 12 13]

3.3. 최대값¶

1. ndarray method: arr.max()

2. numpy method: np.max(arr)

• axis=None (default): 전체 기준

In [36]:

print(arr_22.max())

print(np.max(arr_22))

21
21

• axis=1: column 축 방향, $\rightarrow$, row 단위 기준

In [37]:

np_print(arr_22)

print(arr_22.max(axis=1))

    type : <class 'numpy.ndarray'>
    shape : (3, 4)
    dimension : 2
    dtype : int32
    data : 
 [[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]
[13 17 21]

• axis=0: row 축 방향, $\downarrow$, column 단위

In [38]:

np_print(arr_13)

print(np.max(arr_13, axis=0))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[10 11 12]

3.4. 누적 합계¶

1. ndarray method: arr.cumsum()

2. numpy method: np.cumsum(arr)

   > return: 누적합 item을 가진 ndarray

• default: axis=None: 배열 전체를 1차원 배열로 본 기준 > return 1차원 배열

In [39]:

np_print(arr_13)

print(arr_13.cumsum())
print(np.cumsum(arr_13))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[ 4  9 15 22 30 39 49 60 72]
[ 4  9 15 22 30 39 49 60 72]

• axis=1: column의 축 방향, $\rightarrow$, row 단위

In [40]:

np_print(arr_10)

np_print(arr_10.cumsum(axis=1))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 1  3  6]
 [ 4  9 15]
 [ 7 15 24]]

• axis=0: row의 축 방향, $\downarrow$, column 기준 연산

In [41]:

np_print(np.cumsum(arr_10, axis=0))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 1  2  3]
 [ 5  7  9]
 [12 15 18]]

3.5. 평균(mean, average)¶

1. ndarray method: arr.mean()

2. numpy method: np.mean(arr)

• default: axis=None: 전체를 1차원 배열로 본 기준 > return: single value

In [42]:

np_print(arr_10)

print(arr_10.mean())
print(np.mean(arr_10))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
5.0
5.0

• axis=1: $\rightarrow$, row 단위 기준
  > return: [row index 0 mean, row index 1 mean, ..., row index n-1 mean]

In [43]:

arr_10.mean(axis=1)

Out[43]:

array([2., 5., 8.])

• axis=0: $\downarrow$, column 기준

In [44]:

np.mean(arr_10, axis=0)

Out[44]:

array([4., 5., 6.])

3.6. 중앙값(median)¶

• numpy method: np.median(arr)

  > arr method arr.median() 사용 불가

• 첫, 끝 index 합이 짝수일 때 중앙값: index ((첫 index + 끝 index) / 2) value

• 첫, 끝 index 합이 홀수일 때 중앙값:

$$\textbf{index} \: n.5 = \frac{(\textbf{index} \: n \: \textbf{value}) + (\textbf{index} \: n+1 \: \textbf{value})}{2}$$

• 열의 축 방향, $\rightarrow$, row 단위 기준 중앙값: np.median(arr, asix=1)

In [45]:

np_print(arr_13)

print(np.median(arr_13, axis=1))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[ 5.  8. 11.]

• 행의 축 방향, $\downarrow$, column 단위 기준 중앙값: np.median(arr, axis=0)

In [46]:

np.median(arr_13, axis=0)

Out[46]:

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

3.7. 상관계수(correlation coefficient)¶

• 상관계수: 두 data간의 상관관계(positive or negative)를 수치화: $-1 \leq r \leq 1$

• numpy method: np.corrcoef(arr1, arr2)

e.g.

• 성적에 대해 사교육비와 공부시간의 추세선간, data간의 관계

• 지표 A에 대해 B data set과 C data set의 영향력간, data간의 관계

• 서로 다른 배열 2개를 활용한 상관계수 matrix

• return: 대칭형 matrix > 주대각선을 경계로 상-하위 삼각형 중 하나만 선택

• 주대각선: 자기 자신과의 상관관계 > 항상 $r = 1$

In [47]:

matrix_a = np.random.normal(size=6)
matrix_b = np.random.normal(size=6)

np_print(matrix_a)
np_print(matrix_b)

    type : <class 'numpy.ndarray'>
    shape : (6,)
    dimension : 1
    dtype : float64
    data : 
 [ 1.244538    0.43969942  0.34158317  0.67551314  2.69822542 -0.93179038]

    type : <class 'numpy.ndarray'>
    shape : (6,)
    dimension : 1
    dtype : float64
    data : 
 [-0.75880626 -1.3142966  -0.11631531 -1.22291898  0.55405489  0.32813294]

In [48]:

print(np.corrcoef(matrix_a, matrix_b))

[[1.         0.14427326]
 [0.14427326 1.        ]]

In [49]:

print(np.corrcoef(matrix_a, np.flip(matrix_b)))

[[ 1.       -0.168355]
 [-0.168355  1.      ]]

• $\left| r \right| \leq 0.3$: 관계가 거의 없는 두 data set
• $\left|r \right| \geq 0.9$: 같은 data set인지 check 필요

• 3개의 배열을 이용한 상관계수 구하기 불가능

3.8. 표준편차 $\sigma$ (Standard Deviation)¶

1. ndarray method: arr.std()

2. numpy method: np.std(arr)

• 전체를 1차원 배열로 본 표준편차(default): axis=None

In [50]:

np_print(arr_10)

print(arr_10.std())
print(np.std(arr_10))

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
2.581988897471611
2.581988897471611

• 열의 축 방향, $\rightarrow$, row 단위 기준: axis=1

In [51]:

print(arr_10.std(axis=1))

print(np.std(arr_10, axis=1))

[0.81649658 0.81649658 0.81649658]
[0.81649658 0.81649658 0.81649658]

• 행의 축 방향, $\downarrow$, column 단위 기준: axis=0

In [52]:

print(arr_10.std(axis=0))

print(np.std(arr_10, axis=0))

[2.44948974 2.44948974 2.44948974]
[2.44948974 2.44948974 2.44948974]

4. 브로드캐스팅(Broadcasting)¶

• 서로 다른 shape의 배열에 연산을 수행할 때, numpy에서 배열을 다루는 방법

• Condition

  배열의 row 개수: $r_1, r_2$, column 개수: $c_1, c_2$
  $r_1 = r_2, c_1 = c_2 \: or \: r_1, r_2, c_1, c_2 = 1$

1. 배열과 스칼라값 간의 연산

2. 서로 다른 shape의 배열 간의 연산

4.1. 배열과 스칼라값 간의 연산 (single value, scalar)¶

• scalar value를 배열의 구조로 변형하여 배열 간의 연산 수행

In [53]:

np_print(arr_10)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

• arr_10 + 10: scalar value 10 > 연산 대상 배열 shape과 동일한 배열로 변형

In [54]:

scalar_arr = np.full_like(arr_10, 10)

np_print(scalar_arr)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[10 10 10]
 [10 10 10]
 [10 10 10]]

• arr + scalar vs. arr + np.full_like(arr, scalar) > equivalent!

In [55]:

np_print(arr_10 + scalar_arr)

np_print(arr_10 + 10)

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[11 12 13]
 [14 15 16]
 [17 18 19]]

    type : <class 'numpy.ndarray'>
    shape : (3, 3)
    dimension : 2
    dtype : int32
    data : 
 [[11 12 13]
 [14 15 16]
 [17 18 19]]

4.2. 서로 다른 구조의 배열 간의 연산¶

• 두 배열 중 더 긴 length(행, 열 각각)을 기준 > 새로운 shape 배열 생성

• 확장된 row, column > 기존 배열과 동일한 데이터로 구성

In [56]:

arr_x = np.arange(1, 5).reshape(1, 4)
arr_y = np.arange(1, 5).reshape(4, 1)

np_print(arr_x)
np_print(arr_y)

    type : <class 'numpy.ndarray'>
    shape : (1, 4)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3 4]]

    type : <class 'numpy.ndarray'>
    shape : (4, 1)
    dimension : 2
    dtype : int32
    data : 
 [[1]
 [2]
 [3]
 [4]]

• 배열끼리 추가 method: np.append(arr1, arr2, axis=None)

  • 행의 축 방향, $\downarrow$, column 기준 추가: axis=0

In [57]:

apd_x = np.append(arr_x, arr_x, axis=0)

np_print(apd_x)
# 4행으로 확장
full_x = np.append(apd_x, apd_x, axis=0)

np_print(full_x)

    type : <class 'numpy.ndarray'>
    shape : (2, 4)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3 4]
 [1 2 3 4]]

    type : <class 'numpy.ndarray'>
    shape : (4, 4)
    dimension : 2
    dtype : int32
    data : 
 [[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]

• shape=(4, 1) 배열 > 4열까지 확장: axis=1

In [58]:

apd_y = np.append(arr_y, arr_y, axis=1)
full_y = np.append(apd_y, apd_y, axis=1)

np_print(full_y)

    type : <class 'numpy.ndarray'>
    shape : (4, 4)
    dimension : 2
    dtype : int32
    data : 
 [[1 1 1 1]
 [2 2 2 2]
 [3 3 3 3]
 [4 4 4 4]]

• (4, 4) + (4, 4) vs. (1, 4) + (4, 1) > equivalent

In [59]:

np_print(full_x + full_y)

np_print(arr_x + arr_y)

    type : <class 'numpy.ndarray'>
    shape : (4, 4)
    dimension : 2
    dtype : int32
    data : 
 [[2 3 4 5]
 [3 4 5 6]
 [4 5 6 7]
 [5 6 7 8]]

    type : <class 'numpy.ndarray'>
    shape : (4, 4)
    dimension : 2
    dtype : int32
    data : 
 [[2 3 4 5]
 [3 4 5 6]
 [4 5 6 7]
 [5 6 7 8]]

5. 벡터 연산(vector operation)¶

• item에 대한 연산: vector 연산으로 처리 > for loop보다 월등히 뛰어난 처리 속도

• 0부터 시작, 1,000,000개(1 million) int item을 가진 배열 생성

In [60]:

arr_huge = np.random.randint(1000000, size=1000000)

np_print(arr_huge)

    type : <class 'numpy.ndarray'>
    shape : (1000000,)
    dimension : 1
    dtype : int32
    data : 
 [941499  43912 496817 ... 805065 219783 370785]

• %%time: 해당 셀을 수행하는데 소요된 시간을 표기해주는 jupyter notebook 명령어

• 셀의 가장 상단에 위치해야 함

• $1s = 1,000ms = 1,000,000\mu s$
  (1초 = 1,000 밀리세컨드 = 1,000,000 마이크로세컨드)

• for loop를 통한 합계 연산

In [61]:

%%time

total = 0
for item in arr_huge:
    total += item

print(total)

1826370066
Wall time: 297 ms

<timed exec>:3: RuntimeWarning: overflow encountered in long_scalars

• 벡터연산을 통한 합계 연산

In [62]:

%%time

print(np.sum(arr_huge))

1826370066
Wall time: 1.02 ms