엘리스-데이터분석(3)

Numpy

모듈 설치

----console-----
pip install numpy

import numpy as np

np.arange와 np.linspace

print(np.arange(0,10,3,dtype=float))
print(np.linspace(0,1,5))

[0. 3. 6. 9.]
[0.   0.25 0.5  0.75 1.  ]

배열의 생성

기본적으로 numpy에서 제공되는 연산들은 병렬처리 이기때문에 미리 배열을 생성 후 원하는 연산을 해주는 것이 더 빠르다!

print(np.array([x**2 for x in range(10)]))  #제일느림
print(np.array([x for x in range(10)])**2)  #중간
print(np.arange(100)**2)    #가장빠름(np.array은 병렬처리를 제공
print(np.arange(10))

[ 0  1  4  9 16 25 36 49 64 81]
[ 0  1  4  9 16 25 36 49 64 81]
[   0    1    4    9   16   25   36   49   64   81  100  121  144  169
  196  225  256  289  324  361  400  441  484  529  576  625  676  729
  784  841  900  961 1024 1089 1156 1225 1296 1369 1444 1521 1600 1681
 1764 1849 1936 2025 2116 2209 2304 2401 2500 2601 2704 2809 2916 3025
 3136 3249 3364 3481 3600 3721 3844 3969 4096 4225 4356 4489 4624 4761
 4900 5041 5184 5329 5476 5625 5776 5929 6084 6241 6400 6561 6724 6889
 7056 7225 7396 7569 7744 7921 8100 8281 8464 8649 8836 9025 9216 9409
 9604 9801]
[0 1 2 3 4 5 6 7 8 9]

2차원 배열

흔히 1차원 배열:vector 2차원 배열:matrix라고 표현하기도 한다.

array_1d=np.array([3,33,333])
array_2d=np.array([[1,2,3],[4,5,6]])
print(array_1d)
print(array_2d)

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

np.zeros()

기본적으로 0.0이라는 float64형을 반환하지만 dtype을 지정하여 미리 원하는 자료형으로 저장 할 수 있으며 나중에 astype이라는 메소드로 변경 할 수도 있다.

zero_array_2d=np.zeros((2,2))
print(zero_array_2d,zero_array_2d.dtype)
zero_array_2d=np.zeros((2,2),dtype=np.int64)
print(zero_array_2d,zero_array_2d.dtype)
print(type(zero_array_2d))
print(zero_array_2d.shape)

[[0. 0.]
 [0. 0.]] float64
[[0 0]
 [0 0]] int64
<class 'numpy.ndarray'>
(2, 2)

np.full()

나중에 array에 추가적인 연산을 하면 자동으로 캐스팅이 일어나 우선순위가 높은 자료형을 변환 후 연산이 된다.

full_array1=np.full((2,2),9.0)
print(full_array1,full_array1.dtype)
full_array2=np.ones((2,2))*9 
print(full_array2,full_array2.dtype)

[[9. 9.]
 [9. 9.]] float64
[[9. 9.]
 [9. 9.]] float64

np.ones()

2번째 인자에 dtype=을 넣음으로써 원하는 데이터타입으로 변경가능하며 기본은 float64이다.

print(np.ones((2,2),dtype=np.int64))

[[1 1]
 [1 1]]

np.eye()

원하는 크기의 단위행렬을 만들어준다.

eye_array=np.eye(2,2,dtype=np.int64)
print(eye_array)
eye_array=np.eye(2,4,dtype=np.int64)
print(eye_array)

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

np.random.random()

기본형이 float64인 랜덤한 요소를 갖춘 배열을 만들어준다!

random_array=np.random.random((2,2))
print(random_array)
print(np.random.randint(0,10,(2,2)))

[[0.53665058 0.19928855]
 [0.38952037 0.12506075]]
[[7 1]
 [6 5]]

np.arange() 와 array.reshape()

배열을 특정 모양으로 재생성할 수 있지만 총 길이는 모두 같도록 해야한다.

array1=np.arange(8)
array2=array1.reshape((2,4))
array3=array2.reshape((4,2,1))
print(array1)
print(array2)
print(array3)

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

 [[2]
  [3]]

 [[4]
  [5]]

 [[6]
  [7]]]

배열의 연산

일반적인 연산은 스칼라연산(같은자리의 요소끼리)이 이루어진다.

array1=np.arange(4).reshape((2,2))
array2=np.arange(4).reshape((2,2))
print(array1+array2)
print(array1*array2)

[[0 2]
 [4 6]]
[[0 1]
 [4 9]]

array.astype()

astype()메서드는 인플레이스 아니라 새로운 배열을 생성 후 반환한다.

array=np.zeros((3,3))
araray2=array.astype(np.int64)
print(array,array.dtype)
print(array2,array2.dtype)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]] float64
[[0 0 0]
 [0 0 0]
 [0 0 0]] int64

배열 인덱싱

array=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(array.shape)
array1=array[:2,1:3]
print(array1)
array2=array[1:3,:]
print(array2)
print(array[0][2])

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

스칼라곱과 행렬곱

일반적인 *을 통해 곱을 하면 스칼라곱,dot()메서드를 통해 곱을 하면 행렬 곱이 이루어진다.

array1=np.array([[1,2],[3,4]],dtype=np.int64)
array2=np.array([[1,2],[3,4]],dtype=np.float64)
print(array1,array2)
print(array1*array2)
print(np.dot(array1,array2))

[[1 2]
 [3 4]] [[1. 2.]
 [3. 4.]]
<class 'numpy.ndarray'>
[[ 1.  4.]
 [ 9. 16.]]
[[ 7. 10.]
 [15. 22.]]

집계함수

각 연산들은 axis라는 속성으로 원하는 축으로 계산하여 ndarray형태로 만들수도 있다.

x=np.arange(8).reshape((2,4))
print(np.sum(x,axis=0))
print(np.min(x))
print(np.max(x))
print(np.mean(x))

[ 4  6  8 10]
0
7
3.5

masking

같은 자리의 요소에 bool데이터를 넣음으로서 True인 요소들만 1차원 배열로 추출해낼 수 있다.

mask=np.eye(3,dtype=bool)
print(mask)
print()
a=np.arange(9).reshape(3,3)
print(a) 
print(a[mask])

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

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

np.concatenate와 np.split

일반적으로 axis=0은 y축기준,axis=1은 x축을 기준으로 한다.

array=np.arange(4).reshape(2,2)
print(np.concatenate([array,array],axis=1))
array=np.arange(16).reshape(4,4)
upper,lower=np.split(array,[3],axis=0)
print(upper)
print(lower)

[[0 1 0 1]
 [2 3 2 3]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[12 13 14 15]]

조건식을 이용한 masking

조건식을 이용해 bool배열 생성후 조건을 True인 요소만 데이터삽입이 가능하다.

array=np.arange(40).reshape(10,4)+2
print(array)
print((array>15))
print(array[(array>15)])
array[(array>15)]+=100
print(array)

[[ 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 35 36 37]
 [38 39 40 41]]
[[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]
 [ True  True  True  True]
 [ True  True  True  True]
 [ True  True  True  True]]
[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 40 41]
[[  2   3   4   5]
 [  6   7   8   9]
 [ 10  11  12  13]
 [ 14  15 116 117]
 [118 119 120 121]
 [122 123 124 125]
 [126 127 128 129]
 [130 131 132 133]
 [134 135 136 137]
 [138 139 140 141]]

np.where

np.where(조건)은 조건을 만족하는 요소들의 위치를 2차원배열로 반환하고,np.where(조건,인자1,인자2)는 조건이 참거짓일 떄 반환할 인자들을 설정하여 새로운 배열을 반환하며,2차원 배열에서는 이차원배열로 인덱싱이 가능하다.

array=np.arange(40).reshape(10,4)+2
print(np.where(array>15))
print(array[np.where(array>15)])
print(np.where(array>15,array,0))
print(array)
print(array[[4,4,4,4],[0,1,2,3]])

(array([3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
       9, 9, 9, 9], dtype=int64), array([2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,
       0, 1, 2, 3], dtype=int64))
[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 40 41]
[[ 0  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  0]
 [ 0  0 16 17]
 [18 19 20 21]
 [22 23 24 25]
 [26 27 28 29]
 [30 31 32 33]
 [34 35 36 37]
 [38 39 40 41]]
[[ 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 35 36 37]
 [38 39 40 41]]
[18 19 20 21]

브로드캐스트

더하는 배열들의 형태가 같지않아도 열이 같다면 브로드캐스트되어 연산이 가능하다!

array1=np.arange(9).reshape(3,3)
print(array1)
array2=np.zeros((5,5))
print(array2)
array2[:]=[0,1,2,3,4]
print(array2)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[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. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]]

*print(np.full((5, 5), np.arange(5)))으로도 표현가능