[Numpy] Numpy

데이터 분석 필요성

분석을 수행하는 사람이나 데이터 형식과 목적에 따라 달라질 수 있는 분석의 품질을 관리하고 효율적으로 수행하기 위함

 

Numpy (Numeric Python)

- Python을 사용한 과학 컴퓨팅의 기본 패키지

- 현재 최신 버전은 다음과 같은 특징이 있음

• 오픈소스
• 손쉬운 사용
• 최적화된 성능
• 수치 계산 도구
• 광범위한 하드웨어 및 컴퓨팅 플랫폼 지원
• 강력한 n차원 배열을 지원 (Numpy ndarray)

- 종합적인 수학(Numeric) 함수, 난수 생성기, 선형 대수 루틴, 푸리에 변환 등을 제공

 

Numpy 버전 체크

import numpy as np
np.__version__  # '1.20.3'
np.__name__ # 'numpy'

✔️ Array 생성

• Numpy에서 Array를 만들기 위한 방법은 크게 다음과 같음

1. import numpy
2. 리스트 생성 [ . . . ] ⇒ 연산 불가
3. np.array (생성한 리스트) ⇒ numpy 배열은 연산 가능

• 1차원 배열 생성

# 1차원 배열 생성
import numpy as np    
np.array([1, 2, 3, 4])
>> array([1, 2, 3, 4])

• 2차원 배열 생성

꺽쇠 두 개 [ [] , [] , [] ]

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

• arange 함수를 이용한 배열 생성

수의 범위를 만들어 주는 함수로 range 함수와는 다르게 실수 범위도 생성 가능

np.arange(10)
>> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) # 1 <= a < 10
np.arange(0.1, 1.1, 0.1) # start, end, step | 0.1 <= a < 1.1 | 0.1 <= a <1.1을 0.1 간격으로 배열 생성
>> array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1,])

• linspace 함수

수의 범위를 균일하게 나누고자 할 때 사용

np.linspace(1, 10, 3) # 1부터 10까지의 범위를 3등분

 

• random 모듈의 난수 생성
  • random.rand(n) ⇒ n개의 일차원 난수 배열 생성
  • random.rand(n, m) ⇒ n행 m열의 다차원 난수 배열 생성
  • random.randint(최소값, 최대값) ⇒ [최소값, 최대값)의 범위에서 임의의 정수 배열 생성
  • random.randint(최소값, 최대값, size=(행, 열)) ⇒ 행 열 속성 지정하여 배열 생성
  • random.randn(n) ⇒ 표준정규분포 , 표준편차가 각각 0, 1인 정규분포의 난수 n개
  • random.randn(n, m) ⇒ 표준편차가 각각 0, 1인 정규분포의 n행 m열 난수

a = np.random.rand(5) # 0~1 까지 난수
print(a) # [0.16507806 0.07116307 0.12161234 0.85886403 0.14040601]
print(type(a)) # <class 'numpy.ndarray'>

b = np.random.randint(1, 10, 5) # 1~9 사이의 정수
print(b) # [4 2 6 3 9]
print(type(b)) # <class 'numpy.ndarray'>

c = np.random.randn(10) # 정규분포
print(c) 
''' [ 1.00175667  0.30267251  0.57002964  1.73193429  1.70272507  0.76260878
-1.03292137 -0.14066208  0.9014673  -0.42733712]
'''
print(type(c)) # <class 'numpy.ndarray'>

d = np.random.randn(3, 5) # 3행 5열 난수 생성
print(d)
'''
[[ 0.35015552  0.10296462  0.21286687  1.28763309 -0.25742989]
 [-1.03470802 -0.74683787  1.94878827  1.27605725  0.42469435]
 [-0.17701717 -1.97493268  1.3361427   0.23062184  1.68254012]]
'''
print('-----------')
e = np.random.randint(1, 10, size=(2, 5)) # 0~1 까지 난수, 2행 5열로
e = np.random.randint(10, size=(2, 5)) # starting point는 1로 고정되어 없어도 가능
e = np.random.randint(1, 10, (2, 5))
print(e)
'''
[[7 1 6 4 7]
 [1 6 8 8 4]]
'''
np.random.randint?

 

np 배열의 초기화

• zeros() : 값을 0으로 초기화, 실수형으로 만들어짐
• ones() : 값을 1로 초기화, 실수형으로 만들어짐
• arange() : range() 처럼 0부터 순차적으로 값 생성
• eye( i ) : i * i 크기의 이차원 정방형 행렬 생성 후 대각선을 1로 세팅

shape은 항상 튜플로 표현!!!!!!

# zeros() 함수는 실수형으로 만들어짐
az = np.zeros(10) # 데이터 10개를 모두 0으로 초기화
print(az) # [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

# onse() 함수도
ao = np.ones(10) # 데이터 10개를 모두 0으로 초기화
print(ao) # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# eye() 함수는 인자값 * 인자값 구조의 이차원 정방형 행렬 생성 후 대각선이 1로 세팅
ae = np.eye(3)
print(ae)
'''
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
'''

# arange() 
print(np.arange(3)) # [0 1 2]
print(np.arange(3, 7)) # [3 4 5 6]
print(np.arange(3, 10, 2)) # [3 5 7 9]  start, end, step

# 0과 1로 초기화하는 것 말고 3,4,5로 원하는 값으로 초기화 하기
ao3 = np.ones(10) * 7 # 1로 초기화 한 10개의 요소에 7을 곱한다
print(ao3) # [7. 7. 7. 7. 7. 7. 7. 7. 7. 7.]

ao3 = np.ones(10)
print(ao3 * 7)

print(np.zeros(10)+11) # 0으로 초기화한 10개의 요소에 모두 11을 더한다
# [11. 11. 11. 11. 11. 11. 11. 11. 11. 11.]

af = np.full((7, 5), 23) # 7행 5열을 23으로 채운다
print(af)
'''
[[23 23 23 23 23]
 [23 23 23 23 23]
 [23 23 23 23 23]
 [23 23 23 23 23]
 [23 23 23 23 23]
 [23 23 23 23 23]
 [23 23 23 23 23]]
'''

 

---

배열이 아닌 Numpy를 사용하는 이유

 

• Numpy Indexing
• Numpy Slicing

파이썬의 경우 리스트는 배열을 + 연산으로 더했을 때 덧붙이기 기능이다.

수학적인 연산이 필요할 땐 Numpy 패키지 사용해야 한다.

list1 = [1,2,3,4]
list2 = [5,6,7,8]
list1+list2 # 연산이 아닌 덧붙이기

array 함수

a = [1,2,3,4]
b = [4,5,6,7]

numpy_a = np.array(a)
numpy_b = np.array(b)

print(numpy_a) # [1 2 3 4]
print(numpy_b) # [4 5 6 7]

numpy_a, numpy_b # (array([1, 2, 3, 4]), array([4, 5, 6, 7]))

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

# numpy array +
sum = numpy_a + numpy_b
print(sum) # [ 5  7  9 11]

# 리스트 +
list_sum = a+b
print(list_sum) # [1, 2, 3, 4, 4, 5, 6, 7]

 

ndarray 다차원 행렬 구조를 지원하는 numpy의 핵심 클래스 ⇒ n: 다수, d: 차원

myList = [4,5,6,7]
myArr = np.array(myList)
print(myList) # [4, 5, 6, 7]
print(myArr) # [4 5 6 7]

print(type(myList)) # <class 'list'>
print(type(myArr)) # <class 'numpy.ndarray'>

 

np배열과 리스트의 차이점

1. np 배열은 원본을 바로 바꿈으로써 메모리 효율성이 뛰어나다
2. 리스트는 여러가지 자료형이 원소로 올 수 있지만 np 배열은 한 가지 자료형만 원소로 쓰일 수 있다

 

 

⭐ Numpy Array는 모든 요소가 동일한 자료형을 가짐

 

dtype을 생략하는 경우 자동으로 데이터 타입 결정

x = np.array([[1,2],[3,4]])
x = np.array([[1,2],[3,4]],dtype=int)
x = np.array([[1,2],[3,4]],dtype='int')
x = np.array([[1,2],[3,4]],dtype='int32')
x.dtype # dtype('int32')

리스트를 np.array로 변환하면 동일한 가장 큰 데이터 타입의 데이터 형으로 형 변환 되어 출력

가장 큰 데이터 타입인 문자열로 형 변환 됨!

L = [1, 2, 3.9, '4', 'kb']
print(L) # [1, 2, 3.9, '4', 'kb']
print(type(L)) # <class 'list'>

AL = np.array(L)
print(AL) # ['1' '2' '3.9' '4' 'kb']
print(type(AL)) # <class 'numpy.ndarray'>

아래 예제에서는 float이 가장 큰 데이터 타입이기 때문에 모두 실수형으로 형 변환 됨

A2 = np.array([1, 6, 3, 9.2])
print(A2) # [1.  6.  3.  9.2]

A3 = np.array([1, 2, 3, 4], dtype=float)
A3 = np.array([1, 2, 3, 4], dtype='float')
print(A3) # [1.  6.  3.  9.2]

A4 = np.array([1, 2, 3, 4], dtype=np.float64) # 데이터 타입 지정하여 array 생성
print(A4) # [1. 2. 3. 4.]

메모리상에서의 리스트와 nd배열의 가장 큰 차이점

'''
* 메모리상에서의 리스트와 nd배열의 가장 큰 차이점
리스트는 원본이 안 바뀐다. 변경하면 기존의 것을 메모리에 복사해놓고 새롭게 생성한 뷰를 사용한다.
반면, nd 배열은 데이터를 변경하면 원본 뷰가 수정된다.

->
메모리 효율성과 연관되는 부분이 발생한다.
'''

myList = [4,5,6,7]
myList_sub = myList[1:3]
print(myList_sub) # [5, 6]

myArr = np.array(myList)
myArr_sub = myArr[1:3]
print(myArr_sub) # [5 6]

myList_sub[0] = -5
print(myList_sub[0]) # -5
myArr_sub[0] = -5
print(myArr_sub[0]) # -5

print(myList_sub) # [-5, 6]
print(myArr_sub) # [-5, 6]

print(myList) # [4, 5, 6, 7]
print(myArr) # [ 4 -5  6  7]