[Data Mining] Introduction to Numpy part.1

Introduction to Numpy

 

Numpy는 numberal Python의 약자로, 수치 계산을 지원하기 위한 Python 라이브러리 패키지 입니다.

• Numpy에서 기본적인 데이터 구조는 ndarray라는 다차원 배열 객체입니다.
• Numpy는 ndarray의 요소들을 효율적으로 조작할 수 있는 일련의 함수들을 제공한다는 특징이 있습니다.
• 설명서를 보려면 아래 링크를 참고하세요.

NumPy documentation — NumPy v2.0 Manual

• 글면 한번 Numpy의 기본 구성 요소를 소개해 보겠습니다.
• 특정 기능을 사용하려면 항상 구글링을 시도하거나 help()를 사용합니다.

---

Creating ndarray

ndarray는 list 또는 tuple 개체에서 작성할 수 있습니다.

• numpy.array는 생성 및 배열을 위한 편의 기능일 뿐 입니다.
• numpy.ndarray는 클래스입니다.

Tensor는 다차원 배열로 표현할 수 있는 "어떤 것"입니다.
Tensorflow는 딥러닝을 위한 구글 제품입니다.
Tensorflow 코딩의 경우, numpy 차원 배열에 매우 능숙해야 합니다.

import numpy

import numpy as np

oneDim = np.array([1.0,2,3,4,5])   # a 1-dimensional array (vector)
print(oneDim)
print("#Dimensions =", oneDim.ndim)
print("Dimension =", oneDim.shape)
print("Size =", oneDim.size)
print("Array type =", oneDim.dtype)

[1. 2. 3. 4. 5.]
#Dimensions = 1
Dimension = (5,)
Size = 5
Array type = float64

 

• 아래 예시를 보면 Numpy Element에 C 배열과 같은 유형이 하나만 존재합니다.

twoDim = np.array([[1,2],[3,4],[5,6],[7,8]])  # a two-dimensional array (matrix)
print(twoDim)
print("#Dimensions =", twoDim.ndim)
print("Dimension =", twoDim.shape)
print("Size =", twoDim.size)
print("Array type =", twoDim.dtype)

[[1 2]
 [3 4]
 [5 6]
 [7 8]]
#Dimensions = 2
Dimension = (4, 2)
Size = 8
Array type = int32

 

arrFromTuple = np.array([(1,'a',3.0),(2,'b',3.5)])  # create ndarray from tuple
print(arrFromTuple)
print("#Dimensions =", arrFromTuple.ndim)
print("Dimension =", arrFromTuple.shape)
print("Size =", arrFromTuple.size)
print("Array type =", arrFromTuple.dtype)

[['1' 'a' '3.0']
 ['2' 'b' '3.5']]
#Dimensions = 2
Dimension = (2, 3)
Size = 6
Array type = <U11

 

# Guess what is printed
print(np.array([1]).shape)
print(np.array([1,2]).shape)
print(np.array([[1],[2]]).shape)
print(np.array([[[1,2,3],[1,2,3]]]).shape)
print(np.array([[[[]]]]).shape)

(1,)
(2,)
(2, 1)
(1, 2, 3)
(1, 1, 1, 0)

 

1. np.array([1]).shape: 배열 [1]은 요소가 하나인 1차원 배열입니다. 따라서 shape는 (1,)입니다.
2. np.array([1,2]).shape: 배열 [1,2]은 요소가 두 개인 1차원 배열입니다. 따라서 shape는 (2,)입니다.
3. np.array([[1],[2]]).shape: 배열 [[1], [2]]은 두 개의 요소가 각각 하나씩 들어있는 2차원 배열입니다. 따라서 shape는 (2,1)입니다.
4. np.array([[[1,2,3],[1,2,3]]]).shape:
   • 배열 [[[1,2,3], [1,2,3]]]은 1차원 요소(리스트)가 2개의 하위 리스트를 가지고 있으며, 각 하위 리스트는 3개의 요소를 포함합니다. 따라서 shape는 (1,2,3)입니다.
5. np.array([[[[]]]]).shape:
   • 배열 [[[]]]은 4차원 배열입니다. 1개의 요소(리스트)가 있고, 그 안에 다시 1개의 리스트가 포함되며, 그 안에 1개의 빈 리스트가 포함됩니다. 따라서 shape는 가장 깊은 차원까지 각 차원에서 하나의 요소를 가지므로 (1,1,1,0)입니다.

---

• Numpy에는 배열을 만드는 데 사용할 수 있는 여러 기능이 내장되어 있습니다.

print(np.random.rand(5))      # [0,1] 사이의 균등 분포에서 무작위 숫자 생성
print(np.random.randn(5))     # 평균 0, 표준 편차 1의 정규 분포에서 무작위 숫자 생성
print(np.arange(-10,10,2))    # range와 비슷하지만 리스트 대신 ndarray 반환 (범위 지정)
print(np.arange(12).reshape(3,4))  # 배열을 3행 4열 행렬로 재구성
print(np.linspace(0,1,10))    # [0,1] 구간을 10개의 균등하게 나눈 값으로 분할
print(np.logspace(-3,3,7))    # 10^-3에서 10^3까지 로그 스케일로 균등하게 분할된 숫자 생성
# logspace는 로그 스케일에서 균등하게 간격을 둔 숫자를 반환합니다.

[0.39549071 0.83200035 0.21630632 0.92803293 0.71053543]
[0.89132678 0.0393841  0.36250086 0.04464502 1.31660902]
[-10  -8  -6  -4  -2   0   2   4   6   8]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
[1.e-03 1.e-02 1.e-01 1.e+00 1.e+01 1.e+02 1.e+03]

 

print(np.zeros((2,3)))        # 2 x 3 크기의 영행렬
print(np.ones((3,2)))         # 3 x 2 크기의 일행렬
print(np.eye(3))              # 3 x 3 단위행렬

[[0. 0. 0.]
 [0. 0. 0.]]
[[1. 1.]
 [1. 1.]
 [1. 1.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

---

요소별 작업

ndarray의 각 요소에 덧셈, 곱셈 등의 표준 연산자를 적용할 수 있습니다.

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

print(x + 1)      # 덧셈
print(x - 1)      # 뺄셈
print(x * 2)      # 곱셈
print(x // 2)     # 정수 나눗셈
print(x ** 2)     # 제곱
print(x % 2)      # 나머지
print(1 / x)      # 나눗셈

[2 3 4 5 6]
[0 1 2 3 4]
[ 2  4  6  8 10]
[0 1 1 2 2]
[ 1  4  9 16 25]
[1 0 1 0 1]
[1.         0.5        0.33333333 0.25       0.2       ]

---

 

Why Numpy?

import time
start = time.time()  # 시작 시간 측정

# 반복적인 합 계산
total = 0
# 1.5백만 개의 숫자를 반복하여 합 계산
for item in range(0, 1500000):
    total = total + item
    
print('sum is: ' + str(total))  # 합의 결과 출력
end = time.time()  # 종료 시간 측정
print(end - start)  # 실행 시간 출력

sum is: 1124999250000
0.1862163543701172

 

x = np.array([2,4,6,8,10])
y = np.array([1,2,3,4,5])

print(x + y)  # 배열 x와 배열 y의 각 요소에 대한 덧셈
print(x - y)  # 배열 x와 배열 y의 각 요소에 대한 뺄셈
print(x * y)  # 배열 x와 배열 y의 각 요소에 대한 곱셈
print(x / y)  # 배열 x와 배열 y의 각 요소에 대한 나눗셈
print(x // y)  # 배열 x와 배열 y의 각 요소에 대한 정수 나눗셈
print(x ** y)  # 배열 x와 배열 y의 각 요소에 대한 거듭제곱 계산

[ 3  6  9 12 15]
[1 2 3 4 5]
[ 2  8 18 32 50]
[2. 2. 2. 2. 2.]
[2 2 2 2 2]
[     2     16    216   4096 100000]

 

import numpy as np  # numpy 모듈 임포트

start = time.time()  # 시작 시간 측정

# 벡터화된 합 계산 - 벡터화를 위해 numpy 사용
# np.arange는 0부터 1499999까지의 숫자 시퀀스를 생성
print(np.sum(np.arange(1500000)))

end = time.time()  # 종료 시간 측정
print(end - start)  # 실행 시간 출력

-282181552
0.005002021789550781

 

import numpy as np  # numpy 모듈 임포트
import pandas as pd  # pandas 모듈 임포트

# 0에서 50 사이의 정수로 이루어진 5,000,000 x 4 크기의 배열 생성
# 배열을 데이터 프레임으로 변환하고 열 이름을 'a', 'b', 'c', 'd'로 설정
df = pd.DataFrame(np.random.randint(0, 50, size=(5000000, 4)), columns=('a','b', 'c', 'd'))

# df.shape: 데이터 프레임의 크기 (형태)를 확인
# 주석에는 df.shape를 실행하여 데이터 프레임의 모양을 확인할 수 있다는 암시가 있지만,
# 코드는 df.shape를 호출하지 않습니다.

# 데이터 프레임의 처음 몇 행을 출력
df.head()

	a	b	c	d
0	33	31	6	23
1	40	30	35	17
2	42	25	10	45
3	10	36	15	45
4	5	28	23	39

 

import time
start = time.time()  # 시작 시간 측정

# DataFrame을 iterrows()를 사용하여 반복
for idx, row in df.iterrows():
    # 새로운 열 생성
    # 각 행에 대해 'd' 열을 'c' 열로 나누고 100을 곱하여 'ratio' 열에 저장
    df.at[idx, 'ratio'] = 100 * (row["d"] / row["c"])

end = time.time()  # 종료 시간 측정
print(end - start)  # 실행 시간 출력

<ipython-input-3-ebe2cacf263b>:7: RuntimeWarning: divide by zero encountered in scalar divide
  df.at[idx,'ratio'] = 100 * (row["d"] / row["c"])
<ipython-input-3-ebe2cacf263b>:7: RuntimeWarning: invalid value encountered in scalar divide
  df.at[idx,'ratio'] = 100 * (row["d"] / row["c"])
387.2491133213043

 

import time

start = time.time()  # 시작 시간 측정

# 벡터화된 연산을 사용하여 'ratio' 열 생성
# 'd' 열을 'c' 열로 나누고 100을 곱하여 'ratio' 열에 저장
df['ratio'] = 100 * (df['d'] / df['c'])

end = time.time()  # 종료 시간 측정
print(end - start)  # 실행 시간 출력

0.12962055206298828

---

Indexing & Slicing

배열이 있는 특정 요소를 선택하는 방법은 다양합니다.

x = np.arange(-5, 5)  # -5부터 4까지의 숫자를 포함하는 배열 생성
print(x)  # 배열 x 출력

y = x[3:5]  # y는 배열 x의 부분 배열에 대한 슬라이스(포인터)입니다.
print(y)  # y 출력
y[:] = 1000  # y의 값을 수정하면 배열 x도 변경됩니다.
print(y)  # 수정된 y 출력
print(x)  # y의 수정을 통해 변경된 배열 x 출력

z = x[3:5].copy()  # 부분 배열을 복사하여 z를 만듭니다.
print(z)  # z 출력
z[:] = 500  # z의 값을 수정해도 배열 x에는 영향을 주지 않습니다.
print(z)  # 수정된 z 출력
print(x)  # 배열 x 출력 (y의 수정으로 변경된 후의 상태를 확인할 수 있습니다)

주목할 점은 y는 x의 슬라이스로, y의 변경이 x에도 영향을 준다는 점입니다. 반면, z는 x의 슬라이스를 복사한 것이므로 z의 변경은 x에 영향을 주지 않습니다.

[-5 -4 -3 -2 -1  0  1  2  3  4]
[-2 -1]
[1000 1000]
[  -5   -4   -3 1000 1000    0    1    2    3    4]
[1000 1000]
[500 500]
[  -5   -4   -3 1000 1000    0    1    2    3    4]

 

비고: List를 슬라이싱하면 하위 List(sublist)의 복사본이 생성되지만 Numpy 배열을 슬라이싱하면 복사본이 생성되지 않습니다.

x = list(range(-5,5))
print(x)

y = x[3:5]     # y is a slice, i.e., not a pointer to a list in x
print(y)
y[1] = 1000    # modifying the value of y does not change x
print(y)
print(x)

[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
[-2, -1]
[-2, 1000]
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

 

my2dlist = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]  # 2차원 리스트
print(my2dlist)  # 2차원 리스트 출력
print(my2dlist[2])  # 세 번째 하위 리스트에 접근

# `my2dlist[:][2]`는 각 하위 리스트의 세 번째 요소에 접근하려고 하지만, 제대로 된 작동을 하지 않습니다.
# 대신 my2dlist[2][2]를 사용하여 세 번째 하위 리스트의 세 번째 요소에 접근할 수 있습니다.

my2darr = np.array(my2dlist)  # 2차원 리스트를 NumPy 배열로 변환
print(my2darr)  # NumPy 배열 출력
print(my2darr[2][:])  # 세 번째 행에 접근
print(my2darr[2, :])  # 세 번째 행에 접근 (위와 동일한 방법)
print(my2darr[:][2])  # 잘못된 방식; 각 하위 리스트의 세 번째 요소가 아니라 세 번째 행에 접근함
print(my2darr[:, 2])  # 세 번째 열에 접근
print(my2darr[:2, 2:])  # 첫 두 행과 마지막 두 열에 접근
print(my2darr[::2, 2:])  # 두 행씩 건너뛰어 마지막 두 열에 접근

• my2darr[2][:]은 my2darr 배열의 세 번째 행에 접근하는 연산.
  • my2darr[2]: my2darr 배열에서 세 번째 행(인덱스 2)을 선택합니다.
    • 인덱싱은 0부터 시작하므로 my2darr[2]는 세 번째 행을 선택하는 것입니다.
  • [:]: 이 부분은 슬라이스 연산자로, 해당 행의 모든 열을 선택합니다.
    • 예를 들어, my2darr[2][:]은 세 번째 행의 모든 열을 포함하는 배열을 반환합니다.

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

 

• Remark again: It's indexing, not copying (복사가 아니라 인덱싱입니다)

my2darr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])  # 2차원 리스트를 NumPy 배열로 변환
print(my2darr)  # NumPy 배열 출력

print()
sliced = my2darr[::2, 2:]  # 두 행씩 건너뛰어 마지막 두 열을 슬라이스
print(sliced)  # 슬라이스된 배열 출력
print(type(sliced))  # 슬라이스의 타입 출력 (NumPy 배열임)

print()
sliced[:,:] = 1000  # 슬라이스된 배열의 모든 요소를 1000으로 변경
print(my2darr)  # 원래 배열이 변경됨을 확인 (슬라이스는 원본 배열의 뷰이므로)

print()
sliced[0,0] = 2000  # 슬라이스된 배열의 첫 번째 행 첫 번째 열 요소를 2000으로 변경
print(my2darr)  # 원래 배열이 변경됨을 확인 (슬라이스는 원본 배열의 뷰이므로)

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

[[ 3  4]
 [11 12]]
<class 'numpy.ndarray'>

[[   1    2 1000 1000]
 [   5    6    7    8]
 [   9   10 1000 1000]]

[[   1    2 2000 1000]
 [   5    6    7    8]
 [   9   10 1000 1000]]

 

비고: list을 슬라이싱하면 하위 목록의 복사본이 생성되지만 Numpy array를 슬라이싱하면 복사본이 생성되지 않습니다.

# 주: 리스트 슬라이싱은 하위 리스트의 복사본을 만듭니다.
x = list(range(-5, 5))  # -5부터 4까지의 정수로 이루어진 리스트 생성
print(x)  # 리스트 x 출력

y = x[3:5]  # y는 리스트 x의 하위 리스트에 대한 슬라이스(복사본)입니다.
print(y)  # y 출력

y[1] = 1000  # y의 두 번째 요소를 1000으로 변경
print(y)  # 수정된 y 출력

print(x)  # 리스트 x 출력 (y의 수정을 통해 변경되지 않음)

[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
[-2, -1]
[-2, 1000]
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

 

my2dlist = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]  # 2차원 리스트
print(my2dlist)  # 2차원 리스트 출력
print(my2dlist[2])  # 세 번째 하위 리스트에 접근

# `my2dlist[:][2]`는 하위 리스트를 반환하지만, 하위 리스트의 세 번째 요소에 직접적으로 접근하지 못합니다.
# 대신, `my2dlist[2][2]`를 사용하여 세 번째 하위 리스트의 세 번째 요소에 접근할 수 있습니다.
# `my2dlist[:, 2]`는 파이썬의 리스트에서는 사용할 수 없는 구문입니다.

my2darr = np.array(my2dlist)  # 2차원 리스트를 NumPy 배열로 변환
print(my2darr)  # NumPy 배열 출력
print(my2darr[2][:])  # 세 번째 행에 접근 (모든 열 선택)
print(my2darr[2, :])  # 세 번째 행에 접근 (위와 동일한 방법)
print(my2darr[:][2])  # 이 코드는 NumPy 배열에서는 세 번째 행에 접근합니다.
                      # 하지만 파이썬의 2차원 리스트에서는 권장되지 않는 방식입니다.
print(my2darr[:, 2])  # 세 번째 열에 접근
print(my2darr[:2, 2:])  # 첫 두 행과 마지막 두 열에 접근
print(my2darr[::2, 2:])  # 두 행씩 건너뛰어 마지막 두 열에 접근

[ , , ] → 이런 형식으로 사용됩니다.

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

 

• Remark again: It's indexing, not copying.

my2darr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])  # 2차원 리스트를 NumPy 배열로 변환
print(my2darr)  # NumPy 배열 출력

print()
sliced = my2darr[::2, 2:]  # 행을 두 행씩 건너뛰어 마지막 두 열을 슬라이스
print(sliced)  # 슬라이스된 배열 출력
print(type(sliced))  # 슬라이스된 배열의 타입 출력 (NumPy 배열임)

print()
sliced[:,:] = 1000  # 슬라이스된 배열의 모든 요소를 1000으로 변경
print(my2darr)  # 원본 배열 출력 (슬라이스는 원본 배열의 뷰이므로 변경됨)

print()
sliced[0,0] = 2000  # 슬라이스된 배열의 첫 번째 행 첫 번째 열 요소를 2000으로 변경
print(my2darr)  # 원본 배열 출력 (슬라이스의 변경이 원본 배열에도 영향을 미침)

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

[[ 3  4]
 [11 12]]
<class 'numpy.ndarray'>

[[   1    2 1000 1000]
 [   5    6    7    8]
 [   9   10 1000 1000]]

[[   1    2 2000 1000]
 [   5    6    7    8]
 [   9   10 1000 1000]]

 

• ndarray는 부울 인덱싱(마스킹이라고도 함)도 지원합니다.

x = np.array([1, 2, 3])  # 1, 2, 3으로 이루어진 NumPy 배열
print(x[1:])  # 슬라이싱: 인덱스 1부터 배열의 끝까지 반환
print(x[1:][0])  # 슬라이싱 후 첫 번째 요소 반환

print()
print(x[[True, False, True]])  # 불리언 마스킹: True 값이 있는 인덱스의 요소만 반환

print()
print(x[[2, 1]])  # 정수 배열 인덱싱: 인덱스 2와 1의 요소를 반환
print(x[[2, 1, 1, 1, 0]])  # 정수 배열 인덱싱: 인덱스 2, 1, 1, 1, 0의 요소를 순차적으로 반환

print()
x[[2, 1, 1, 1, 0]] = 0  # 정수 배열 인덱싱을 사용하여 인덱스 2, 1, 1, 1, 0의 요소를 0으로 변경
print(x)  # 수정된 NumPy 배열 출력

결과적으로 x 배열은 인덱싱을 통해 일부 요소를 0으로 변경하게 됩니다.

[2 3]
2

[1 3]

[3 2]
[3 2 2 2 1]

[0 0 0]

 

 

y = np.arange(35).reshape(5, 7)  # 0부터 34까지의 숫자를 5x7 형태의 NumPy 배열로 생성
b = y > 20  # y 배열의 각 요소가 20보다 큰지 비교하여 불리언 배열 생성
print(b)  # 불리언 배열 출력

print()
t = y[b]  # 불리언 마스킹을 사용하여 y 배열에서 20보다 큰 요소를 필터링
          # 필터링 결과는 항상 1차원 배열이며, 복사본이 생성됩니다. 인덱싱은 아닙니다.
print(t)  # 필터링 결과 출력

print()
t[:3] = 1000  # 필터링된 배열의 첫 세 요소를 1000으로 변경
print(t)  # 수정된 필터링 결과 출력
print(y)  # 원본 배열 y 출력

필터링된 배열 t는 y의 복사본이므로, t의 수정은 y에 영향을 미치지 않습니다.

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

[21 22 23 24 25 26 27 28 29 30 31 32 33 34]

[1000 1000 1000   24   25   26   27   28   29   30   31   32   33   34]
[[ 0  1  2  3  4  5  6]
 [ 7  8  9 10 11 12 13]
 [14 15 16 17 18 19 20]
 [21 22 23 24 25 26 27]
 [28 29 30 31 32 33 34]]

 

• LAB: 값이 2-d 배열의 짝수인 경우 0으로 설정합니다.

import numpy as np

M = np.arange(35).reshape(5,7)
M

array([[ 0,  1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12, 13],
       [14, 15, 16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25, 26, 27],
       [28, 29, 30, 31, 32, 33, 34]])

 

M[M % 2 == 0] = 0
M

array([[ 0,  1,  0,  3,  0,  5,  0],
       [ 7,  0,  9,  0, 11,  0, 13],
       [ 0, 15,  0, 17,  0, 19,  0],
       [21,  0, 23,  0, 25,  0, 27],
       [ 0, 29,  0, 31,  0, 33,  0]])

 

# First Boolean masking

np.where(M % 2 == 0, M, -M)

array([[  0,  -1,   0,  -3,   0,  -5,   0],
       [ -7,   0,  -9,   0, -11,   0, -13],
       [  0, -15,   0, -17,   0, -19,   0],
       [-21,   0, -23,   0, -25,   0, -27],
       [  0, -29,   0, -31,   0, -33,   0]])

 

• More indexing examples: Integer array indexing

my2darr = np.arange(1, 13, 1).reshape(4, 3)  # 1부터 12까지의 숫자를 4x3 형태의 NumPy 배열로 생성
print(my2darr)  # 배열 출력

indices = [2, 1, 0, 3]  # 선택한 행 인덱스
print(my2darr[indices, :])  # 선택한 행 인덱스에 따라 전체 열을 포함하는 배열을 반환

rowIndex = [0, 0, 1, 2, 3]  # my2darr에 대한 행 인덱스 배열
columnIndex = [0, 2, 0, 1, 2]  # my2darr에 대한 열 인덱스 배열
print(my2darr[rowIndex, columnIndex])  # 요소별로 인덱싱하여 배열 요소 출력

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

---

Numpy 산술 및 통계 함수

nd-array의 요소를 조작하는 데 사용할 수 있는 많은 수학 기능이 내장되어 있습니다.

y = np.array([-1.4, 0.4, -3.2, 2.5, 3.4])  # 무작위로 생성된 벡터
print(y)  # 배열 출력
print()

print(np.abs(y))  # 각 요소를 절대값으로 변환
print(np.sqrt(np.abs(y)))  # 각 요소의 절대값에 대한 제곱근 적용
print(np.sign(y))  # 각 요소의 부호 구하기
print(np.exp(y))  # 각 요소에 대한 지수함수(e^y) 적용
print(np.sort(y))  # 배열 정렬; 배열의 정렬된 복사본 반환
print(y)  # 원본 배열 y 출력; 원본 배열은 변하지 않음

[-1.4  0.4 -3.2  2.5  3.4]

[1.4 0.4 3.2 2.5 3.4]
[1.18321596 0.63245553 1.78885438 1.58113883 1.84390889]
[-1.  1. -1.  1.  1.]
[ 0.24659696  1.4918247   0.0407622  12.18249396 29.96410005]
[-3.2 -1.4  0.4  2.5  3.4]
[-1.4  0.4 -3.2  2.5  3.4]

 

x = np.arange(-2, 3)  # -2부터 2까지의 정수 배열 생성
y = np.random.randn(5)  # 5개의 임의의 표준 정규분포 값 배열 생성
print(x)  # 배열 x 출력
print(y)  # 배열 y 출력

print(np.add(x, y))  # 요소별 덧셈: x + y
print(np.subtract(x, y))  # 요소별 뺄셈: x - y
print(np.multiply(x, y))  # 요소별 곱셈: x * y
print(np.divide(x, y))  # 요소별 나눗셈: x / y
print(np.maximum(x, y))  # 요소별 최대값: max(x, y)

[-2 -1  0  1  2]
[-0.5915882   0.86652443 -0.76206247 -0.18749133 -0.65986152]
[-2.5915882  -0.13347557 -0.76206247  0.81250867  1.34013848]
[-1.4084118  -1.86652443  0.76206247  1.18749133  2.65986152]
[ 1.1831764  -0.86652443 -0.         -0.18749133 -1.31972304]
[ 3.38073005 -1.15403555 -0.         -5.33357984 -3.03093897]
[-0.5915882   0.86652443  0.          1.          2.        ]

 

y = np.array([-3.2, -1.4, 0.4, 2.5, 3.4])  # 무작위로 생성된 벡터
print(y)  # 배열 y 출력

print("Min =", np.min(y))  # 배열의 최소값
print("Max =", np.max(y))  # 배열의 최대값
print("Average =", np.mean(y))  # 배열의 평균/평균값
print("Std deviation =", np.std(y))  # 배열의 표준편차
print("Sum =", np.sum(y))  # 배열의 합계

[-3.2 -1.4  0.4  2.5  3.4]
Min = -3.2
Max = 3.4
Average = 0.34000000000000014
Std deviation = 2.432776191925595
Sum = 1.7000000000000006

 

More on filtering

M = np.arange(25).reshape(5, 5)  # 0부터 24까지의 숫자를 5x5 형태의 배열로 생성
print(M)  # 배열 M 출력

print(M[M % 2 == 1])  # 일반적인 필터링: M 배열의 요소 중 홀수(조건을 충족하는 요소)만 필터링하여 반환
print(np.argwhere(M >= 20))  # 조건을 충족하는 요소의 인덱스 반환
print(np.where(M % 2 == 1, M, 0))  # 조건에 따라 M 요소는 그대로, 조건에 맞지 않으면 0으로 대체

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
[ 1  3  5  7  9 11 13 15 17 19 21 23]
[[4 0]
 [4 1]
 [4 2]
 [4 3]
 [4 4]]
[[ 0  1  0  3  0]
 [ 5  0  7  0  9]
 [ 0 11  0 13  0]
 [15  0 17  0 19]
 [ 0 21  0 23  0]]

---

 

New axis

• 기존 배열의 차원을 한 차원 더 늘리는 데 사용됩니다
• 모양 변경 예: n x (새 축) x m ⇒ n x 1 x m

t = np.array([1,2,3])  # 1차원 배열 생성
print(t.shape)  # 배열 t의 형상(차원) 출력

x = t[:, np.newaxis]  # np.newaxis를 사용하여 차원 확장 (x 1)
print(x.shape)  # 배열 x의 형상 출력

y = t[np.newaxis, :]  # np.newaxis를 사용하여 차원 확장
print(y.shape)  # 배열 y의 형상 출력

• t.shape는 배열 t의 형상을 출력합니다. t는 1차원 배열이므로 형상은 (3,)입니다.
• x = t[:, np.newaxis]는 np.newaxis를 사용하여 t 배열의 차원을 확장합니다. 기존의 1차원 배열 t가 (3,)에서 (3,1)의 2차원 배열로 확장됩니다. 이 때 : 는 전체 배열을 선택하고, np.newaxis는 새로운 차원을 추가합니다.
• y = t[np.newaxis, :]는 np.newaxis를 사용하여 t 배열의 차원을 확장합니다. 기존의 1차원 배열 t가 (3,)에서 (1,3)의 2차원 배열로 확장됩니다. 이 때 np.newaxis는 새로운 차원을 추가하고, :는 전체 배열을 선택합니다.

(3,)
(3, 1)
(1, 3)

 

print(t)
print(x)
print(y)

[1 2 3]
[[1]
 [2]
 [3]]
[[1 2 3]]

t 배열은 1차원 배열로, [1, 2, 3]의 값을 갖습니다.
x 배열은 t 배열에 np.newaxis를 사용하여 열 차원을 추가한 결과로, (3, 1)의 2차원 배열이 됩니다. 따라서 출력 결과는 각 요소가 개별적으로 한 줄에 위치한 열 형태의 2차원 배열 [[1], [2], [3]]이 됩니다.
y 배열은 t 배열에 np.newaxis를 사용하여 행 차원을 추가한 결과로, (1, 3)의 2차원 배열이 됩니다. 따라서 출력 결과는 t 배열의 요소들이 한 행에 위치한 형태의 2차원 배열 [[1, 2, 3]]이 됩니다.

 

• x and y are broadcasted (it is explained below)

x + y

# Result
array([[2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])

 

• 위치에 따라 Dimension 위치가 달라지는지?

t = np.array([[1,2,3],[4,5,6]])  # 2차원 배열 생성 (2, 3)

# 1. 차원을 확장하여 결과의 형상을 확인합니다.
print(t[:, :, np.newaxis].shape)  # (2, 3, 1) 모양의 3차원 배열
print(t[:, :, np.newaxis])  # 차원을 확장한 배열 출력
print()

# 2. 차원을 확장하여 결과의 형상을 확인합니다.
print(t[np.newaxis, :, :].shape)  # (1, 2, 3) 모양의 3차원 배열
print(t[np.newaxis, :, :])  # 차원을 확장한 배열 출력
print()

# 3. 행 차원을 확장하여 결과를 확인합니다.
print(t[:, np.newaxis, :])

1. t[:, :, np.newaxis]
- : 를 사용하여 전체 행과 열을 선택합니다.
- np.newaxis는 열 차원을 확장합니다.
- 결과는 (2, 3, 1) 형상의 3차원 배열이 됩니다.
2. t[np.newaxis, :, :]
- np.newaxis**를 사용하여 행 차원을 확장합니다.
- : 를 사용하여 전체 배열을 선택합니다.
결과는 (1, 2, 3) 형상의 3차원 배열이 됩니다.
3. t[:, np.newaxis, :]
- : 를 사용하여 전체 행을 선택합니다.
- np.newaxis를 사용하여 새로운 축을 추가합니다.
- : 를 사용하여 전체 열을 선택합니다.
- 결과는 np.array([[1,2,3],[4,5,6]])의 3차원 배열이 됩니다.

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

 [[4]
  [5]
  [6]]]

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

[[[1 2 3]]

 [[4 5 6]]]

 

N-d array axis view