넘파이(Numpy)

ndarray 생성 - np.array()

import numpy as np

list1 = [1, 2, 3]
print("list1 : {}".format(list1))
print("list1 type : {}".format(type(list1)))

array1 = np.array(list1)
print("array1 : {}".format(array1))
print("array1 type : {}".format(type(array1)))

list1 : [1, 2, 3]
list1 type : <class 'list'>
array1 : [1 2 3]
array1 type : <class 'numpy.ndarray'>

---

ndarray의 형태(shape)와 차원(dimension)

import numpy as np

list1 = [1, 2, 3]
list2 = [2, 3, 4]

array1 = np.array(list1)
array2 = np.array([list1, list2])
array3 = np.array([list1])

print("array1 : {}".format(array1))
print("array1 type : {}".format(type(array1)))
print("array1 shape : {}".format(array1.shape))
      
print("array2 : {}".format(array2))
print("array2 type : {}".format(type(array2)))
print("array3 shape : {}".format(array1.shape))
      
print("array3 : {}".format(array3))
print("array3 type : {}".format(type(array3)))
print("array3 shape : {}".format(array1.shape))

array1 : [1 2 3]
array1 type : <class 'numpy.ndarray'>
array1 shape : (3,)

array2 : [[1 2 3]
           [2 3 4]]
array2 type : <class 'numpy.ndarray'>
array2 shape : (2, 3)

array3 : [[1 2 3]]
array3 type : <class 'numpy.ndarray'>
array3 shape : (1, 3)

print("array1 : {}차원".format(array1.ndim))
print("array2 : {}차원".format(array2.ndim))
print("array3 : {}차원".format(array3.ndim))

array1 : 1차원
array2 : 2차원
array3 : 2차원

---

ndarray 데이터 값 타입

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

print("array1 type : {}".format(type(array1)))
print("array1 data type : {}".format(array1.dtype))

array1 type : <class 'numpy.ndarray'>
array1 data type : int32

list2 = [1, 2, "hi"]
list3 = [3, 4, 5.5]
#list에서는 서로 다른 데이터 타입이 포합될 수 있다.

array2 = np.array(list2)
array3 = np.array(list3)
#array에는 서로 다른 데이터 타입이 포함되면 더 크기가 큰 데이터형으로 전체가 변환된다.

print(array2)
print("array2 data type : {}".format(array2.dtype))

      
print(array3)
print("array3 data type : {}".format(array3.dtype))

['1' '2' 'hi']
array2 data type : <U11

[3. 4. 5.5]
array3 data type : float64

---

astype()을 통한 타입 변환

list1 = [1, 2, 3]
array1_int = np.array(list1)
print("array1_int : {}\t\tarray1_int data type : {}".format(array1_int, array1_int.dtype))

# array1_int라는 array를 float형으로 바꿔보자
# array1_int를 64bits flaot형으로 타입 변환해보도록 하자


array1_float = array1_int.astype("float64")
print("array1_float : {}\tarray1_float data type : {}".format(array1_float, array1_float.dtype))

# array1_float를 32bits int형으로 타입 변환해보도록 하자

array1_int32 = array1_float.astype("int32")
print("array1_int32 : {}\t\tarray1_int32 data type : {}".format(array1_int32, array1_int32.dtype))

 

array1_int : [1 2 3]
array1_int data type : int32

array1_float : [1. 2. 3.]
array1_float data type : float64

array1_int32 : [1 2 3]
array1_int32 data type : int32

---

ndarray에서 axis 기반의 연산함수 수행

list1 = [1, 2, 3]
list2 = [4, 5, 6]

array2 = np.array([list1, 
                   list2])

print(array2)

# array2에 있는 모든 원소의 합 구하기
print("array2의 모든 원소 합 : {}".format(array2.sum()))

# 행 단위로 합 구하기
print("행단위로 array2의 원소 합 : {}".format(array2.sum(axis=0)))

# 열 단위로 합 구하기
print("열단위로 array2의 원소 합 : {}".format(array2.sum(axis=1)))

[[1 2 3]
 [4 5 6]]
array2의 모든 원소 합 : 21
행단위로 array2의 원소 합 : [5 7 9]
열단위로 array2의 원소 합 : [ 6 15]

---

ndarray를 편리하게 생성하기 - arange, zeros, ones

import numpy as np

array1 = np.arange(10)
print(array1)
print(array1.dtype, array1.shape)

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

zero_array = np.zeros((3, 2), dtype = "int32")
print(zero_array)
print(zero_array.dtype, zero_array.shape)

print("")

# one_array의 경우 data type을 지정해주지 않았으므로 64bits float형이다.
one_array = np.ones((3, 2))
print(one_array)
print(one_array.dtype, one_array.shape)

[[0 0]
 [0 0]
 [0 0]]
int32 (3, 2)

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

---

ndarray의 shape을 변경하는 reshape()

array1 = np.arange(10)

array2 = array1.reshape(2, 5)
array3 = array1.reshape(5, 2)

print("{}을 (2, 5)로 reshape하면 \n{}".format(array1, array2))
print("")
print("{}을 (5, 2)로 reshape하면 \n{}".format(array1, array3))

[0 1 2 3 4 5 6 7 8 9]을 (2, 5)로 reshape하면
[[0 1 2 3 4]
 [5 6 7 8 9]]

[0 1 2 3 4 5 6 7 8 9]을 (5, 2)로 reshape하면
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]

• 예를 들어서, 8 * 8 pixel의 이미지 파일을 1차원으로 바꿔서 처리해주는 경우가 있다.
• 이러한 경우에 reshape()을 이용해서 차원을 변환해줄 수 있다.
• 만약 10개의 원소를 가지는 1차원 array를 reshape(4, 3)으로 처리해준다면 error가 발생할 것이다.

array1= np.arange(10)
array2 = array1.reshape(-1, 5)
array3 = array1.reshape(5, -1)

print("{}를 reshape(-1, 5)를 하면\n{}".format(array1, array2))
print("")
print("{}를 reshape(5, -1)을 하면\n{}".format(array1, array3))

[0 1 2 3 4 5 6 7 8 9]를 reshape(-1, 5)를 하면
[[0 1 2 3 4]
 [5 6 7 8 9]]

[0 1 2 3 4 5 6 7 8 9]를 reshape(5, -1)을 하면
[[0 1]
 [2 3]
 [4 5]
 [6 7] 
 [8 9]]

• reshape(-1, n)을 하게 되면 열은 n으로 고정을 한 후에 행을 자동으로 정해서 변환을 해준다.
• reshape()안에는 -1이 1개만 있어야한다.

array1 = np.arange(5)

array2 = array1.reshape(-1, 1)
# 1차원 array를 2차원 array로 변환하되 컬럼 axis가 1이다.

array3 = array2.reshape(-1,)
# 2차원 array를 1차원 array로 변환

print("{}를 2차원으로 변환하기 위해 reshape(-1, 1)을 하면\n{}".format(array1, array2))
print("")
print("{}를 1차원으로 변환하기 위해 reshape(-1,)을 하면\n{}".format(array2, array3))

[0 1 2 3 4]를 2차원으로 변환하기 위해 reshape(-1, 1)을 하면
[[0]
 [1]
 [2]
 [3]
 [4]]

[[0]
 [1]
 [2]
 [3]
 [4]]를 1차원으로 변환하기 위해 reshape(-1,)을 하면
[0 1 2 3 4]

• 1차원 -> 2차원 : reshape(-1, 1)
• 2차원 -> 1차원 : reshape(-1,)

---

ndarray의 데이터 세트 선택하기 - 인덱싱(indexing)

# 1에서 9까지의 1차원 ndarray를 생성하자
array1 = np.arange(start=1, stop=10)

value = array1[2]
print(array1)
print("array1[2] = {}".format(value))

print("")

print(array1)
print("array[-1] = array의 맨 뒤의 값 = {}".format(array1[-1]))
print("array[-2] = array의 맨 뒤에서 2번째 값 = {}".format(array1[-2]))

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

[1 2 3 4 5 6 7 8 9]
array[-1] = array의 맨 뒤의 값 = 9
array[-2] = array의 맨 뒤에서 2번째 값 = 8

print("기존 array1 :      {}".format(array1))

array1[0] = 9

print("초기화 후 array1 : {}".format(array1))

기존 array1 :        [1 2 3 4 5 6 7 8 9]
초기화 후 array1 : [9 2 3 4 5 6 7 8 9]

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3, 3)
print(array2d)

print("(row=0, col=0) index 가리키는 값 : {}".format(array2d[0, 0]))
print("(row=0, col=1) index 가리키는 값 : {}".format(array2d[0, 1]))
print("(row=1, col=0) index 가리키는 값 : {}".format(array2d[1, 0]))
print("(row=2, col=2) index 가리키는 값 : {}".format(array2d[2, 2]))

[[1 2 3]
 [4 5 6]
 [7 8 9]]
(row=0, col=0) index 가리키는 값 : 1
(row=0, col=1) index 가리키는 값 : 2
(row=1, col=0) index 가리키는 값 : 4
(row=2, col=2) index 가리키는 값 : 9

---

슬라이싱(slicing)

array1 = np.arange(start=1, stop=10)
print(array1)

array3 = array1[0:3]
print(array3)

array4 = array1[:3]
print(array4)

array5 = array1[3:]
print(array5)

array6 = array1[:]
print(array6)

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

array1 = np.arange(start=1, stop=10)
print(array1)
print("")

array2d = array1.reshape(3, 3)
print(array2d)
print("")

print(array2d[0:2, 0:2])
print("")

print(array2d[2, 0:2])
print("")

print(array2d[0:3, 2])
print("")

print(array2d[1:3, 1])

[1 2 3 4 5 6 7 8 9]

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

[[1 2]
 [4 5]]

[7 8]

[3 6 9]

[5 8]

---

팬시 인덱싱(fancy indexing)

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3, 3)
print(array2d)

array3 = array2d[[0, 1], 2]
print("array2d[[0, 1], 2] => {}".format(array3.tolist()))

array4 = array2d[[0, 2], 0:2]
print("array2d[[0, 2], 0:2] => {}".format(array4.tolist()))

array5 = array2d[[0, 2], [0, 2]]
print("array2d[[0, 2], [0, 2]] => {}".format(array5.tolist()))

array6 = array2d[[0, 1], 0:3]
print("array2d[[0, 1], 0:3] => {}".format(array6.tolist()))

[[1 2 3] [4 5 6] [7 8 9]]
array2d[[0, 1], 2] => [3, 6]
array2d[[0, 2], 0:2] => [[1, 2], [7, 8]]
array2d[[0, 2], [0, 2]] => [1, 9]
array2d[[0, 1], 0:3] => [[1, 2, 3], [4, 5, 6]]

---

불린 인덱싱(Boolean indexing)

array1 = np.arange(start=1, stop= 10)
print(array1)

print("")

print(array1 > 5)
var1 = array1 > 5
print("var1 : {}".format(var1))

print("")

array3 = array1d[array1d > 5]
print("'array1d > 5'로 불린 인덱싱 결과 값 : {}".format(array3))

 

[1 2 3 4 5 6 7 8 9]
[False False False False False True True True True]
var1 : [False False False False False True True True True]

'array1d > 5'로 불린 인덱싱 결과 값 : [6 7 8 9]

array1d = np.arange(start=1, stop=10)
print(array1)

TorF = np.array([False, False, False, False, False, True, True, True, True])
print(TorF)

array3 = array1d[TorF]
print("불린 인덱싱으로 필터링한 결과 : {}".format(array3))

[1 2 3 4 5 6 7 8 9]
[False False False False False True True True True]
불린 인덱싱으로 필터링한 결과 : [6 7 8 9]

array1d = np.arange(start=1, stop=10)
print(array1d)

indexes = np.array([5, 6, 7, 8])
array4 = array1d[ indexes ]

print("일반 인덱싱으로 필터링한 결과 : {}".format(array4))

[1 2 3 4 5 6 7 8 9]
일반 인덱싱으로 필터링한 결과 : [6 7 8 9]

array1d = np.arange(start=1, stop=10)
print(array1d)

print(array1d[array1d > 5])

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

---

행렬의 정렬 - sort()와 argsort()

sort()

origin = np.array([3, 1, 9, 5])
print("원본 행렬 : {}".format(origin))

print("")

# np.sort()로 정렬
sort1 = np.sort(origin)
print("np.sort() 호출 후 반환된 정렬 행렬 : {}".format(sort1))
print("np.sort() 호출 후 원본 행렬 : {}".format(origin))

print("")

# ndarray.sort()로 정렬
sort2 = origin.sort()
print("origin.sort() 호출 후 반환된 정렬 행렬 : {}".format(sort2))
print("origin.sort() 호출 후 원본 행렬 : {}".format(origin))

원본 행렬 : [3 1 9 5]

np.sort() 호출 후 반환된 정렬 행렬 : [1 3 5 9]
np.sort() 호출 후 원본 행렬 : [3 1 9 5]

origin.sort() 호출 후 반환된 정렬 행렬 : None
origin.sort() 호출 후 원본 행렬 : [1 3 5 9]

• np.sort() : 원 행렬 ~> 유지 , 반환 행렬 ~> 정렬
• ndarray.sort() : 원 행렬 ~> 정렬 , 반환 행렬 ~> None

origin = np.array([3, 1, 9, 5])
print("원본 행렬 : {}".format(origin))

asend_array = np.sort(origin)
print("오름차순 정렬된 origin : {}".format(asend_array))

desend_array = np.sort(origin)[::-1]
print("내림차순 정렬된 origin : {}".format(desend_array))

원본 행렬 : [3 1 9 5]
오름차순 정렬된 origin : [1 3 5 9]
내림차순 정렬된 origin : [9 5 3 1]

• 내림차순 정렬을 위해선 [::-1]을 후미에 붙여준다

array2d = np.array([[8, 12],
                  [7, 1] ])
print("원본 행렬 : \n{}".format(array2d))

print("")


sort_array2d_axis0 = np.sort(array2d, axis=0)
print("row 방향으로 오름차순 정렬 : \n{}".format(sort_array2d_axis0))

print("")

sort_array2d_axis1 = np.sort(array2d, axis=1)
print("col 방향으로 오름차순 정렬 : \n{}".format(sort_array2d_axis1))

원본 행렬 :
[[ 8 12]
 [ 7 1]]

row 방향으로 오름차순 정렬 :
[[ 7 1]
 [ 8 12]]

col 방향으로 오름차순 정렬 :
[[ 8 12]
 [ 1 7]]

---

argsort() : 정렬하고 난 후, 반환 값은 해당 원소의 인덱스 번호이다.

origin = np.array([3, 1, 9, 5])
print("원본 행렬 : {}".format(origin))

sort1 = np.argsort(origin)
print("오름차순 정렬 시 원본 행렬의 인덱스 : {}".format(sort1))

sort2 = np.argsort(origin)[::-1] 
print("내림차순 정렬 시 원본 행렬의 인덱스 : {}".format(sort2))

원본 행렬 : [3 1 9 5]
오름차순 정렬 시 원본 행렬의 인덱스 : [1 0 3 2]
내림차순 정렬 시 원본 행렬의 인덱스 : [2 3 0 1]

• argsort()가 쓰이는 상황은 Key-Value 형태의 데이터가 주어졌을 때이다. John은 70, Mike는 95, Sarah는 84, Kate는 98, Samuel은 88점이다. 위 상황을 ndarray로 만들고 argsort()를 이용해서 key값(사람)을 점수가 낮은 순으로 정렬해보자

name_array = np.array(["John", "Mike", "Sarah", "Kate", "Samuel"])
score_array = np.array([78, 95, 84, 98, 88])

sort_indices = np.argsort(score_array)
print("sort indices : {}".format(sort_indices))

name_array_sort = name_array[sort_indices]
score_array_sort = score_array[sort_indices]

print("학생을 점수가 낮은 순서로 정렬 : {}".format(name_array_sort))
print("그 학생들의 점수를 정렬 : {}".format(score_array_sort))

sort indices : [0 2 4 1 3]
학생을 점수가 낮은 순서로 정렬 : ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']
그 학생들의 점수를 정렬 : [78 84 88 95 98]

---

선형대수 연산 - 행렬 내적과 전치 행렬

행렬내적

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

B = np.array([[7, 8],
             [9,  10],
             [11,  12]])

dot_product = np.dot(A, B)
print("A와 B의 내적 : \n{}".format(dot_product))

A와 B의 내적 :
[[ 58 64]
 [139 154]]

전치 행렬

A = np.array([[1, 2], [3, 4]])
transpose_mat = np.transpose(A)
print("A의 원본행렬 : \n{}".format(A))

print("")

print("A의 전치행렬 : \n{}".format(transpose_mat))

A의 원본행렬 :
[[1 2]
 [3 4]]

A의 전치행렬 :
[[1 3]
 [2 4]]