2주차 - Numerical Python (numpy)

2주차 - Numerical Python¶

1 - Array Creation¶

In [514]:

import numpy as np

In [515]:

test_array = np.array(['1', '4', 5, 8], float)

In [516]:

print(test_array)

[1. 4. 5. 8.]

In [517]:

type(test_array[3]) # 하나의 float 변수가 차지하는 메모리 공간 64bit = 8byte

Out[517]:

numpy.float64

2 - Shape¶

In [518]:

test_array = np.array(['1', '4', 5, '8'], float)

In [519]:

print(test_array)

[1. 4. 5. 8.]

In [520]:

print(type(test_array[3])) #  float 타입으로 자동으로 형변환

<class 'numpy.float64'>

In [521]:

print(test_array.dtype) # Array 전체의 자료형 type을 반환함

float64

In [522]:

print(test_array.shape) # Array의 shape을 반환함 matrix의 크기(1차원 벡터)

(4,)

In [523]:

test_array = np.array([[1, 4, 5, 6]], float)

In [524]:

print(test_array.shape) # 2차원 형식의 matrix의 크기(1 * 4의 행렬)

(1, 4)

In [525]:

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

In [526]:

print(matrix.shape) # 2차원 형식의 matrix크기 (3 * 4의 행렬)

(3, 4)

In [527]:

tensor = [[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]], [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]]

In [528]:

print(np.array(tensor, int).shape) # 3차원 형식의 matrix 크기(3 * 4의 행렬이 2개)

(2, 3, 4)

In [529]:

result = np.array(tensor, int)

In [530]:

print(result.ndim) # 3차원

3

In [531]:

print(result.size) # data의 갯수: 24개

24

3 - Array dtype¶

In [532]:

check = np.array([[1, 4, 5, 6], [4, 5, 6, 7]], dtype = np.float32)

In [533]:

print(check.nbytes) # data 1개당 4byte * 8개의 data = 32byte의 메모리 공간 차지

32

4 - Handling Shape(Array의 shape을 변경, size는 동일)¶

In [534]:

test_matrix = [[1, 2, 3, 4], [1, 2, 3, 4]]

In [535]:

print(np.array(test_matrix, int).shape)

(2, 4)

In [536]:

print(np.array(test_matrix, int).reshape(2, 2, 2)) # 2 * 2형식의 matrix가 2개(3차원 형식), data의 갯수는 8개로 동일

[[[1 2]
  [3 4]]

 [[1 2]
  [3 4]]]

In [537]:

print(np.array(test_matrix, int).reshape(-1, 2)) # 4 * 2형식의 2차원 matrix(앞의 -1의 경우 알아서 size에 따라서 자동계산)

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

In [538]:

print(np.array(test_matrix, int).reshape(2, -1).shape) # 2 * 4형식의 2차원 matrix로 변형(size를 기반으로 -1갯수 선정)

(2, 4)

In [539]:

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

In [540]:

print(test.reshape(2, -1)) # 1차원 vector형식을 2차원 형식의 행렬로 변경

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

5 - flatten(다차원 형식의 matrix를 1차원 array로 변환)¶

In [541]:

test = np.array([[[1, 2, 5, 8], [1, 2, 5, 8]],[[1, 2, 5, 8], [1, 2, 5, 8]]], np.float64) # 3차원 matrix

In [542]:

print(test.flatten()) # reshpa을 사용해도 무방함

[1. 2. 5. 8. 1. 2. 5. 8. 1. 2. 5. 8. 1. 2. 5. 8.]

In [543]:

print(test.reshape(16,)) # 위와 동일

[1. 2. 5. 8. 1. 2. 5. 8. 1. 2. 5. 8. 1. 2. 5. 8.]

6 - Indexing & Slicing¶

In [652]:

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

In [653]:

print(a)

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

In [654]:

print(a[0][0], a[0,0]) # 동일한 표현 방법, matrix일 경우 앞은 row, 뒤는 column을 의미함

1 1

In [655]:

a[0, 0] = 12 # matrix의 (0, 0)에 12를 할당

In [656]:

print(a)

[[12  2  3]
 [ 4  5  6]]

In [657]:

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

In [658]:

print(a[:,2:]) #전체 열 + column의 2행 이상

[[ 3  4  5]
 [ 8  9 10]]

In [663]:

print(a[1,1:3]) # [row 1열, 1 ~ 2행까지] 콤마를 기준으로 앞은 row 뒤는 column

[7 8]

In [664]:

print(a[1:3]) # 1 Row ~ 2Row의 전체

[[ 6  7  8  9 10]]

In [553]:

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

In [554]:

print(arr[:,::2]) # 전체 열, 전체 행에서 2스텝씩 띄어서 슬라이싱

[[ 0  2  4]
 [ 5  7  9]
 [10 12 14]]

7 - Creation Function¶

In [555]:

np.arange(30) # range함수와 동일한 기능

Out[555]:

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

In [556]:

np.arange(0, 5, 0.5) # 0부터 5까지 0.5스텝씩 증가

Out[556]:

array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])

In [557]:

np.arange(30).reshape(5, 6)

Out[557]:

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

In [558]:

np.arange(30).reshape(-1, 6) # 윗줄과 동일

Out[558]:

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

In [559]:

list(np.arange(0, 5, 0.5))

Out[559]:

[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]

In [560]:

np.arange(0, 5, 0.5).tolist() # 윗줄과 동일

Out[560]:

[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]

In [561]:

np.zeros(shape = (10, ), dtype = np.int8) # zero벡터 생성

Out[561]:

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int8)

In [562]:

np.zeros((2, 5)) # 2 * 5의 zero matrix생성

Out[562]:

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

In [563]:

np.ones((3, 5), np.int8) # 1로 초기화된 list

Out[563]:

array([[1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1]], dtype=int8)

In [564]:

np.empty(shape = (10, 0), dtype = np.int8) # shape만 주어지고 비어있는 ndarray생성(메모리 공간 차지) - 잘 안씀

Out[564]:

array([], shape=(10, 0), dtype=int8)

In [565]:

test_matrix = np.arange(30).reshape(5, 6)

In [566]:

np.ones_like(test_matrix) # test_matrix와 동일한 크기의 ones matrix를 생성해라 somthing_like

Out[566]:

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

In [567]:

np.identity(n = 3, dtype = np.int8) # 3 * 3의 단위행렬 생성

Out[567]:

array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]], dtype=int8)

In [568]:

np.eye(N = 3, M = 5, dtype = np.int8) #대각선이 1인 행렬 생성

Out[568]:

array([[1, 0, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 0, 1, 0, 0]], dtype=int8)

In [569]:

np.eye(3)

Out[569]:

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

In [570]:

np.eye(5)

Out[570]:

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

In [571]:

np.eye(3, 5, k = 2) # k는 start index

Out[571]:

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

In [572]:

matrix = np.arange(9).reshape(3, 3)

In [573]:

np.diag(matrix) # 대각 행렬의 값을 추출함

Out[573]:

array([0, 4, 8])

In [574]:

np.diag(matrix, k = 1) # 1열부터 대각행렬의 값 추출

Out[574]:

array([1, 5])

In [575]:

np.random.uniform(0, 1, 10).reshape(2, 5) # 데이터 분포에 따른 sampling으로 array를 생성(균등분포)

Out[575]:

array([[0.16355453, 0.83908747, 0.09609528, 0.56946755, 0.54228446],
       [0.78562019, 0.60418937, 0.29539395, 0.72298017, 0.82142536]])

In [576]:

np.random.normal(0, 1, 10).reshape(2, 5) # 정규분포

Out[576]:

array([[ 0.59152429, -0.87252422,  0.97611786, -0.35983112, -2.68218863],
       [ 1.17684624, -0.66764506, -1.33686745, -1.95048375,  0.64082291]])

In [577]:

test_array = np.arange(1, 11)

In [578]:

print(test_array.sum(dtype = np.float64)) # ndarray들간의 합을 구함, list의 sum기능과 동일

55.0

In [579]:

test_array = np.arange(1, 13).reshape(3, 4)

In [580]:

test_array

Out[580]:

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

In [581]:

test_array.sum(axis = 1) # column을 기준으로 더함, axis = 모든 operation function을 실행할 때, 기준이 되는 dimension 축

Out[581]:

array([10, 26, 42])

In [582]:

test_array.sum(axis = 0) # row를 기준으로 더함

Out[582]:

array([15, 18, 21, 24])

8 - Concatenate(Numpy array를 합치는 함수)¶

In [583]:

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

In [584]:

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

In [585]:

np.vstack((a, b))

Out[585]:

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

In [586]:

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

In [587]:

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

In [588]:

np.hstack((a, b))

Out[588]:

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

In [589]:

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

In [590]:

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

In [591]:

np.concatenate((a, b), axis = 0)

Out[591]:

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

In [592]:

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

In [593]:

b = np.array([[5], [6]])

In [594]:

np.concatenate((a, b), axis = 1)

Out[594]:

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

9 - Array Operation¶

In [595]:

test_a = np.array([[1, 2, 3], [4, 5, 6]], dtype = np.int8)

In [596]:

print(test_a + test_a)

[[ 2  4  6]
 [ 8 10 12]]

In [597]:

print(test_a * test_a) # 행렬의 곱셈이 아니라 같은 위치에 있는 요소끼리 곱셈

[[ 1  4  9]
 [16 25 36]]

In [598]:

print(test_a - test_a)

[[0 0 0]
 [0 0 0]]

In [599]:

test_a = np.arange(1, 7).reshape(2, 3)

In [600]:

test_b = np.arange(7, 13).reshape(3, 2)

In [601]:

print(test_a)

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

In [602]:

print(test_b)

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

In [603]:

print(test_a.dot(test_b)) # 행렬의 곱셈연산 수행

[[ 58  64]
 [139 154]]

In [604]:

test_a = np.arange(1, 7).reshape(2, 3)

In [605]:

print(test_a)

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

In [606]:

print(test_a.transpose()) # 전치행렬(대각선 축을 기준으로 뒤집기)

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

In [607]:

print(test_a.T) # 윗줄과 동일

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

9 - Broadcasting(shape이 다른 배열 간 연산을 지원하는 기능)¶

In [608]:

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

In [609]:

scalar = 3

In [610]:

print(test_matrix + scalar) # Matrix - Scalar 덧셈(모든 요소에 3을 더함)

[[4 5 6]
 [7 8 9]]

In [611]:

print(test_matrix * scalar)

[[ 3  6  9]
 [12 15 18]]

In [612]:

print(test_matrix - scalar)

[[-2 -1  0]
 [ 1  2  3]]

In [613]:

print(test_matrix / 5)

[[0.2 0.4 0.6]
 [0.8 1.  1.2]]

In [614]:

print(test_matrix ** 2)

[[ 1  4  9]
 [16 25 36]]

In [615]:

test_matrix = np.arange(1, 13).reshape(4, 3)

In [616]:

test_vector = np.arange(10, 40, 10)

In [617]:

print(test_matrix, test_vector)

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

In [618]:

print(test_matrix + test_vector) # 각각의 행에 [10, 20, 30]이 더해짐

[[11 22 33]
 [14 25 36]
 [17 28 39]
 [20 31 42]]

10 - All & Any¶

In [619]:

a = np.arange(10)

In [620]:

print(a)

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

In [621]:

np.any(a > 5), np.any(a < 0) # any - 하나라도 조건이 만족한다면 True (OR연산)

Out[621]:

(True, False)

In [622]:

np.all(a> 5), np.all(a >= 0) # all - 모두가 조건이 만족한다면 True(AND연산)

Out[622]:

(False, True)

In [623]:

print(a > 5)

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

In [624]:

a = np.array([1, 3, 0], int)

In [625]:

np.logical_and(a > 0, a < 3)

Out[625]:

array([ True, False, False])

In [626]:

b = np.array([True, False, False], bool)

In [627]:

np.logical_not(b) # logical은 잘 안씀 그냥 알고있기만 하기

Out[627]:

array([False,  True,  True])

In [628]:

c = np.array([False, True, False], bool)

In [629]:

np.logical_or(b, c) # b와 c의 OR연산(피연산자중 하나가 True라면 결과는 True)

Out[629]:

array([ True,  True, False])

In [630]:

np.where(a > 0, 3, 2) # 조건에 만족한다면 3반환, 아니라면 2반환

Out[630]:

array([3, 3, 2])

In [631]:

np.where(a > 0) # 조건에 만족하는 index값 반환

Out[631]:

(array([0, 1], dtype=int64),)

11 - Argmax & Argmin(array내에서의 최대, 최소값 index 반환)¶

In [632]:

a = np.array([1, 2, 4, 5, 6, 78, 8, 9])

In [633]:

np.argmax(a), np.argmin(a) # 최대 최소값 index반환

Out[633]:

(5, 0)

In [634]:

#axis 기반의 반환

In [635]:

a2 = np.array([[1, 2, 4, 7], [9, 88, 6, 45], [9, 76, 3, 4]])

In [636]:

np.argmax(a2, axis = 1)  # 행을 기준으로 각 행에서 최대값의 index

Out[636]:

array([3, 1, 1], dtype=int64)

In [637]:

np.argmin(a2, axis = 0) # 열을 기준으로 각 열에서 최소값의 index

Out[637]:

array([0, 0, 2, 2], dtype=int64)

In [638]:

test_array = np.array([1, 4, 0, 2, 3, 8, 9, 7], float) # boolean index

In [665]:

check = test_array > 3
print(check)

[False  True False False False  True  True  True]

In [640]:

test_array[check] # 조건이 True인 index만 추출

Out[640]:

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

In [641]:

condition = test_array < 3
test_array[condition]

Out[641]:

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

In [642]:

check.astype(np.int) # True False값을 1과 0으로 변환

Out[642]:

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

12 - fancy index¶

In [643]:

a = np.array([2, 4, 6, 8], float)

In [644]:

b = np.array([0, 0, 1, 3, 2, 1], int) # 반드시 integer로 선언

In [645]:

a[b] # b배열의 값을 index로 하여 a의 값들을 추출함

Out[645]:

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

In [646]:

a.take(b) # 윗줄과 동일한 효과, bracket index와 같은 효과

Out[646]:

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

In [647]:

a = np.array([[1, 4], [9, 16]],float)

In [648]:

b = np.array([0, 0, 1, 1, 0], int)

In [649]:

c = np.array([0, 1, 1, 1, 1], int)

In [650]:

a[b, c] # b를 row index, c를 column index로 변환하여 표시함

Out[650]:

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