보다 더 나은 내일의 나를 위해

2020/05/28 - [python] - [python] Numpy

Numpy에서 zeros / ones / full / eye 함수 

import numpy as np

c = np.zeros((2, 2))
print(c, end = '\n\n')

d = np.ones((2,2))
print(d, end = '\n\n')
d = np.full((2,2 ), 10)
print(d, end = '\n\n')

e = np.eye(3) # 3행 3열짜리 단위행렬
print(e, end = '\n\n')


# 출력 결과

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

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

[[10 10]
 [10 10]]

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

np.zeros((2,2)) 는 2 행 2 열 짜리 2차원 배열을 0 으로 초기화 하겠다는 의미입니다.

np.ones ((2,2)) 는 2행 2열 짜리 2차원 배열을 1로 초기값을 설정해주는 것입니다.

np.full ((2,2), 10) 의 경우는 2행 2열 짜리 2차원 배열을 10으로 초기화 하겠다는 의미입니다.

저 위치에 다른 정수를 넣을 경우 해당 정수로 초기화하며 출력합니다.

np.eye(3) 의 경우 단위 행렬을 만드는 함수로 안의 정수값에 해당하는 단위 행렬을 출력해줍니다. 여기서는 3,3ㄷ의 단위 행렬을 출력해줍니다.현재는 3단위 행렬이지만, np.eye(2)를 할 경우, 2x2 행렬이 만들어집니다.

Numpy 난수 값 얻기

np.random.seed(0) 

print(np.random.rand(3), end = '\n\n') 

print(np.random.randn(5), end = '\n\n')

print(np.random.randint(3, size=6), end = '\n\n')
print(np.random.randint(3, size=(3,4)), end = '\n\n')
print(np.random.randint(3, size=(3,4,5)), end = '\n\n')


print(list(range(3)), end = '\n\n')
print(np.arange(3), end = '\n\n')

f = {i:np.random.randn() for i in range(3)}
print(f, end = '\n\n')



# 출력 결과

[0.5488135  0.71518937 0.60276338]

[-2.2683282   1.33354538 -0.84272405  1.96992445  1.26611853]

[2 0 1 1 1 1]

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

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

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

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

[0, 1, 2]

[0 1 2]

{0: -0.5058765397605117, 1: 0.42539339846964996, 2: -0.027971183469780222}

np.random.seed(0) 란 임의의 시드를 생성합니다. seed 안에 값을 넣으면 항상 같은 결과를 반환합니다

np.random.rand(3) 란 난수 발생 균등분포를 따르기 때문에 음수 값은 출력되지 않습니다.

np.dandom.randn(5) 란 표준 정규분포를 따르는 난수를 발생시킵니다. rand() 와는 다르게 음수도 출력합니다.

맨 처음 seed에 0을 넣줬기 때문에 현재는 반복하여 출력하여도 같은 결과만 출력하게 됩니다.

매 출력 다른 결과를 원하신다면 seed(0)에서 0을 빼시면 됩니다.

np.random.randint()는randint(정수값)의 범위 내에서 균일분포의 정수난수를 발생 시킵니다. 여기서

(np.random.randint(3, size=6) 는 0~2 사이의 정수난수를 발생기키고 size는 6개를 받도록 하였습니다.

np.random.randint(3, size=(3,4) 의 경우는 범위는 위와 동일하지만, size는 2행 3열의 2차원 배열을 출력합니다.

Numpy 란?

C언어로 개발되었으며, 계산을 위한 라이브러리로서 다차원 배열을 처리하는데 필요한 기능을 제공합니다.

Numpy 데이터 타입

# numpy : ndarray
import numpy as np

nn = [1, 2, 3.5]
nn1 = (6,7,8,9)
ss1 = ['tom', 'james', 'oscar']
ss2 = {'a' , 'b', 'c'}

print(nn, ' ', type(nn))
print(nn1, ' ' , type(nn1))
print(ss1, ' ' , type(ss1))
print(ss2, ' ' , type(ss2))

# 출력 결과

[1, 2, 3.5]   <class 'list'>
(6, 7, 8, 9)   <class 'tuple'>
['tom', 'james', 'oscar']   <class 'list'>
{'a', 'b', 'c'}   <class 'set'>

변수에 할당한 데이터와 출력 된 값 및 데이터 타입 형태를 보면 들어간 타입의 형태로 출력 되는 것을 알 수 있스니다.

서로 성격이 다른 타입일 경우 상위 타입을 따라서 출력됩니다.

- 바깥쪽이 가장 큰 상위 타입

str ( somplex ( float ( int ) ) )

Numpy 메모리 저장

파이썬과 Numpy가 차지하는 메모리에는 차이가 있다.

파이썬은 값에 상관없이 다 다른 메모리를 차지하는 특징이있습니다.

li = list(range(1,10))
print(li) # list 형태

print(id(li[0]), id(li[1]), id(li[2]), id(li[3]), id(li[4]), id(li[5]), id(li[6]), id(li[7]), id(li[8]))


# 출력 결과

[1, 2, 3, 4, 5, 6, 7, 8, 9]
10914496 10914528 10914560 10914592 10914624 10914656 10914688 10914720 10914752

출력 결과를 보시면 id 값이 전부 다른 것을 확인 할 수 있습니다.

반면, Numpy 의 경우 C의 배열을 사용하기 때문에 하나의 메모리 안에 데이터를 하나씩 쌓아두는 특징을 가지고 있습

니다.

numpy_arr = np.array(li)

print(id(numpy_arr[0]), id(numpy_arr[1]), id(numpy_arr[2]), id(numpy_arr[3]), id(numpy_arr[4]))


# 출력 결과

139921874137520 139921874137520 139921874137520 139921874137520 139921874137520

출력 되는 id의 값이 전부 동일한 것을 확인할 수 있습니다.

결과적으로, 데이터 분석을 할 경우 들어오는 데이터의 양이 많기 떄문에 python 의 list 를 사용하는 것이 아니라

Numpy의 array 배열을 사용하는 것이 더 적합한 것을 알 수 있습니다.

추가 - 위에 특징들로인해 python의 list 값에 *값 을 해주면 list를 값 만큼 반복하지만 Numpy 의 경우 각 요소들에 * 값

을 해주는 특징을 가집니다.

print('a ' * 10)

for i in li:
  print(i*10, end = ' ')
  

# 출력 결과

a a a a a a a a a a 
10 20 30 40 50 60 70 80 90 

Numpy 배열

넘파이에서 사용하는 배열은 주로 벡터와 행렬을 사용하는 선형대수 계산에 사용됩니다.

1차원 배열 - 리스트를 넣으면 배열로 변환

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


# 출력 결과

[1 2 3 4 5 6 7 8 9]   <class 'numpy.ndarray'>

2차원 배열 - 리스트의 리스트(list of list)를 이용하는 경우 2차원 배열을 생성할 수 있습니다. 가로는 행의 개수 세로는 열의 개수가 됩니다.

exarr1 = np.array([[1,2,3,4],[5,6,7,8]])
print(exarr1, ' ' , type(exarr1))


# 출력 결과

[[1 2 3 4]
 [5 6 7 8]]   <class 'numpy.ndarray'>

Numpy 에서의 배열은 다른 배열과는 다른 차이점을 가지고 있습니다.

예를들어 아래 소스에서도 보여드리겠지만, arr[0] 과 arr[[0]] dms 다른 점을 가지고 있습니다.

arr[0] 은 1차원 배열 , arr[[0]] 은 2차원 배열이라는 특징을 가지고 있습니다.

import numpy as np

arr1 = np.array([[10,20,30], [40,50,60]], dtype='float32')
print(type(arr1), ' ' , arr1.dtype, ' ' , arr1.shape, ' ' , arr1.ndim, ' ' , arr1.size, end = '\n')

print(arr1, end = '\n\n')

print(arr1[0,0], arr1[0, 1], end = '\n\n')
arr1[0] = 10
print(arr1[0,1], arr1[0,2], end = '\n\n')

print('-------------------------')

print(arr1, end = '\n\n')

print(arr1[[0]], end = '\n\n')

print(arr1[[0,1]], end = '\n\n')

print(arr1[0], end = '\n\n')


# 출력결과

<class 'numpy.ndarray'>   float32   (2, 3)   2   6
[[10. 20. 30.]
 [40. 50. 60.]]

10.0 20.0

10.0 10.0

-------------------------

[[10. 10. 10.]
 [40. 50. 60.]]

[[10. 10. 10.]]

[[10. 10. 10.]
 [40. 50. 60.]]

[10. 10. 10.]

위에 소스를 보시면 arr1[0]은 1차원 배열로 list 형태인 것을 알 수 있으며,

그 다음 줄 arr1[[0]] 인 경우는 arr1[0]과 다르게 0 행 1열의 2차원 배열을 의미하며 [[10. 10. 10]] 을 출력하였습니다.