220117 python 다섯번째 수업: Numpy

앞 부분에서 python응용으로 클래스, 모듈, 패키지를 배우긴 했지만 간략하게 개념설명 정도였기  때문에 Numpy에 집중해서 정리해보려한다.

 

Numpy

numpy란 numerical python의 줄임말로 고성능의 과학계산 컴퓨팅과 데이터 분석에 필요한 패키지이다. 아나콘다를 설치했거나 코랩을 사용한다면 함께 설치되어있으니 import해오기만 하면 된다.

수치데이터에 사용하는 배열 ndarray를 제공한다.

- 행렬을 만들어 수학연산을 직접 해줄 때 

- 결측치를 확인하고 조정해줄 때

사용된다.

 

1. numpy 배열 만들기

# 불러오기
import numpy as np # 불러올 때 길면 복잡하니까 약자로 불러옴

# array만들기
num = np.array(range(1, 11))
num #겉보기에는 list와 유사해보인다

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

numpy는 주로 np로 줄여준다.

 

1) list와의 차이점

array1 = np.array([1, 2, 'a', 'b'])
array1 
# 숫자가 문자로 바뀜. 문자열로 array를 만들면 datatype이 <U11이 된다
# 문자열로 자동변환

array(['1', '2', 'a', 'b'], dtype='<U11')

숫자와 문자열을 함께 데이터 안에 넣을 수 있는 리스트와 달리, array는 숫자와 문자를 함께 데이터 안에 넣는 경우에 숫자가 문자로 자동변환된다.

 

2) 배열을 만들어주는 함수들

(1) np.ones(행, 열): 배열 내 원소가 모두 1인 배열을 만들 때 사용

# 배열을 만들어주는 함수

ones = np.ones([2, 4]) #1로만 이루어진 2행 4열
ones

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

ones1 = np.ones(10) #1차원 array
ones1

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

(2) np.zeros(행, 열): 배열 내 원소가 모두 1인 배열을 만들 때 사용

# 0으로만 이루어진 행렬을 만들고 싶다
zeros = np.zeros([2, 4])
zeros

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

(3) 배열이름.shape : 배열의 구성을 출력 = (행, 열)

zeros.shape # 배열이 어떻게 구성되어있는지 출력

(2, 4)

(4) 배열이름.ndim: 배열의 차원을 출력 = 행의 수

zeros.ndim # 배열의 차원(행의 수)

2

(5) 배열이름.dtype: 배열의 원소가 어떤 데이터타입으로 구성되어있는지 출력

# 어떤 데이터타입으로 구성되어있는지 궁금하다
zeros.dtype #float

dtype('float64')

(6) np.arange(start, end+1, step)

# 간편하게 동일한 모양으로
np_nums = np.arange(1, 10)
np_nums

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

# step
np_nums = np.arange(1, 10, 0.25)
np_nums

array([1.  , 1.25, 1.5 , 1.75, 2.  , 2.25, 2.5 , 2.75, 3.  , 3.25, 3.5 ,
       3.75, 4.  , 4.25, 4.5 , 4.75, 5.  , 5.25, 5.5 , 5.75, 6.  , 6.25,
       6.5 , 6.75, 7.  , 7.25, 7.5 , 7.75, 8.  , 8.25, 8.5 , 8.75, 9.  ,
       9.25, 9.5 , 9.75])

#소수점은 버리고싶다
np_nums = np.arange(1, 10, 0.25).astype(int) #정수형
np_nums

array([1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 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])

 

2. 배열전환

1) 1차원 배열

sap = np.array(['MMM', 'ABT', 'ABBV', 'ACN', 'ACE', 'ATVI', 'ADBE', 'ADT'])
sap

array(['MMM', 'ABT', 'ABBV', 'ACN', 'ACE', 'ATVI', 'ADBE', 'ADT'],
      dtype='<U4')

sap.shape #1차원 배열

(8,)

*** 1차원 배열은 전치해도 똑같다.

전치를 하려면 2차원이상이 되어야 한다고 한다.

sap1d = sap.T
sap1d.shape

(8,)

2) 2차원 배열

sap2d = sap.reshape(2, 4) #아까의 배열을 2행 4열의 2차원배열로 변환한다.
sap2d

array([['MMM', 'ABT', 'ABBV', 'ACN'],
       ['ACE', 'ATVI', 'ADBE', 'ADT']], dtype='<U4')

dtype='<U4': 데이터타입이 문자인 경우

- 전치

# 행렬 전치가 필요할 때
sap2d.T #4행 2열짜리 행렬이 됨

array([['MMM', 'ACE'],
       ['ABT', 'ATVI'],
       ['ABBV', 'ADBE'],
       ['ACN', 'ADT']], dtype='<U4')

4행 2열짜리 행렬이 된다.

 

3) 3차원 배열

sap3d = sap.reshape(2, 2, 2)
sap3d # 두 개의 2차원 행렬이 나눠지면서 3차원이 됨

array([[['MMM', 'ABT'],
        ['ABBV', 'ACN']],

       [['ACE', 'ATVI'],
        ['ADBE', 'ADT']]], dtype='<U4')

- 전치

sap3d.transpose((0, 2, 1)) #3차원 배열에 대한 이해가 필요하다

array([[['MMM', 'ABBV'],
        ['ABT', 'ACN']],

       [['ACE', 'ADBE'],
        ['ATVI', 'ADT']]], dtype='<U4')

 

3. 배열의 인덱싱과 슬라이싱

1) 조건을 통한 슬라이싱

(1) 조건을 통해 음수인 수를 찾고 이를 0으로 바꿔주기

# 인덱싱과 슬라이싱
# 리스트 안에 조건 넣어서 해보는거
dirty = np.array([9, 4, 1, -0.01, -0.001])
dirty

array([ 9.e+00,  4.e+00,  1.e+00, -1.e-02, -1.e-03])

dirty라는 array에서 0보다 작은 수를 w_dirty 라는 새로운 변수에 넣는다

w_dirty = dirty < 0
w_dirty #true인 값이 음수

array([False, False, False,  True,  True])

bool 자료형

dirty 중 w_dirty에 해당하는 값(음수)을 0으로 바꾸어준다.

dirty[w_dirty] = 0
#dirty[dirty < 0] #bool인덱스 사용
# 0보다 작은 값들만 0으로 바꾸어준다
dirty

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

(2) 조건을 통해 -0.5 이상 0.5이하인 수를 찾고 이를 배열에 적용하기

- 1) 배열 정의

linear = np.arange(-1, 1, 0.2)
linear

array([-1.00000000e+00, -8.00000000e-01, -6.00000000e-01, -4.00000000e-01,
       -2.00000000e-01, -2.22044605e-16,  2.00000000e-01,  4.00000000e-01,
        6.00000000e-01,  8.00000000e-01])

- 2) 조건 만들기

(linear <= 0.5) & (linear >= -0.5)

 

array([False, False, False,  True,  True,  True,  True,  True, False,
       False])

-0.5이상 0.5 이하인 수인 경우 True

 

- 3) 슬라이싱

linear[(linear <= 0.5) & (linear >= -0.5)] # 슬라이싱

array([-4.00000000e-01, -2.00000000e-01, -2.22044605e-16,  2.00000000e-01,
        4.00000000e-01])

 

(3) 스마트 인덱싱

sap = np.array(['MMM', 'ABT', 'ABBV', 'ACN', 'ACE', 'ATVI', 'ADBE', 'ADT'])
sap

array(['MMM', 'ABT', 'ABBV', 'ACN', 'ACE', 'ATVI', 'ADBE', 'ADT'],
      dtype='<U4')

#스마트 인덱싱
sap[[1, 2, -1]] # 원하는 것만

array(['ABT', 'ABBV', 'ADT'], dtype='<U4')

두번째, 세번째, 마지막 데이터만 추출

 

(4) 스마트 슬라이싱

sap2d = sap.reshape(2, 4)
sap2d

array([['MMM', 'ABT', 'ABBV', 'ACN'],
       ['ACE', 'ATVI', 'ADBE', 'ADT']], dtype='<U4')

#스마트 슬라이싱

sap2d[:, [1]] #전체 행 중 두번째 열만
#2차원 행렬

array([['ABT'],
       ['ATVI']], dtype='<U4')

:은 전체를 의미하고 인덱스번호처럼 1은 두번째 열을 의미한다.

 

- 차원 알아보기: .ndim()

#스마트 슬라이싱

sap2d[:, [1]].ndim #전체 행 중 두번째 열만
#2차원 행렬

2

- 1차원 배열로 슬라이싱(괄호를 넣지 않는 경우)

sap2d[:, 1] # 출력된 모양이 다르다
#1차원 행렬

array(['ABT', 'ATVI'], dtype='<U4')

sap2d[:, 1].ndim # 출력된 모양이 다르다
#1차원 행렬

1

Q. 2차원 배열 더 넒은 단위에서 슬라이싱 해보기

import numpy as np
array2d = np.array([[1, 2, 3],
                    [4, 5, 6],
                    [7, 8, 9]])
array2d

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

array2d[0:2, 0:2] #다른 슬라이싱과 마찬가지로 end+1이 출력된다

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

 

4.  브로드캐스팅

# 브로드캐스팅
# 리스트와의 차이와 함께 살펴보기
a = [1, 2, 3]
b = [4, 5, 6]

a + b

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

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
#배열끼리의 사칙연산이 가능해진다.
a + b

array([5, 7, 9])

a = np.array([1, 2, 3])
a * 5 #각 자리의 연산이 필요하다 할 때 np.array사용해주면 된다.

array([ 5, 10, 15])

 

5. 대각행렬에 노이즈 넣기

1) 모든 요소에 값 더하기

np.eye(4) #대각행렬 만들어주는 함수

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

noise = np.eye(4) + 0.01 * np.ones((4, )) # 모든 행렬에 0.01 더해주는 것
# 0.01 * np.ones((4, ))
noise

array([[1.01, 0.01, 0.01, 0.01],
       [0.01, 1.01, 0.01, 0.01],
       [0.01, 0.01, 1.01, 0.01],
       [0.01, 0.01, 0.01, 1.01]])

2) 랜덤으로 노이즈 넣기

#랜덤으로 노이즈를 넣어주고 싶다
noise = np.eye(4) + 0.01 * np.random.random((4, 4)) # 모든 행렬에 0.01 더해주는 것
# 0.01 * np.ones((4, ))
noise

array([[1.00273293e+00, 1.66365626e-04, 4.26882375e-03, 9.22039716e-03],
       [9.83491909e-03, 1.00924700e+00, 2.96549952e-03, 5.57734733e-03],
       [9.62003490e-05, 5.96847200e-03, 1.00866951e+00, 9.10315542e-03],
       [4.84039608e-03, 4.80561871e-03, 1.60205933e-03, 1.00507080e+00]])

- 출력할 때 소수점 정리하기: .round()

noise = np.eye(4) + 0.01 * np.random.random((4, 4)) # 모든 행렬에 0.01 더해주는 것
# 0.01 * np.ones((4, ))
np.round(noise, 2)

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

 

6. 유니버셜 함수를 사용해 떨어진 주식파악하기

1) .greater()

stocks = np.array([140.49, 0.97, 40.68, 41.53, 55.7, 57.21, 98.2, 40.49, 0.97, 40.68, 41.53, 55.7, 57.21, 98.2, 30.22, 30.91])
stocks

array([140.49,   0.97,  40.68,  41.53,  55.7 ,  57.21,  98.2 ,  40.49,
         0.97,  40.68,  41.53,  55.7 ,  57.21,  98.2 ,  30.22,  30.91])

#주말동안 어떤 주식이 떨어졌는지

stocks = stocks.reshape(8, 2).T
stocks

array([[140.49,  40.68,  55.7 ,  98.2 ,   0.97,  41.53,  57.21,  30.22],
       [  0.97,  41.53,  57.21,  40.49,  40.68,  55.7 ,  98.2 ,  30.91]])

fall = np.greater(stocks[0], stocks[1]) #전, 후(행 기준) # 떨어진 것만 포함

sap[fall] #sap에 적용
#주가의 전 후 비교. 떨어진 주식만 뽑아줌

array(['MMM', 'ACN', 'ATVI', 'ADT'], dtype='<U4')

2) 평균: mean()

#평균보다 변동폭이 큰 주식 고르기
sap[np.abs(stocks[0] - stocks[1]) > np.mean(stocks[0] - stocks[1])] #절댓값이므로 변동폭만 계산

array(['MMM', 'ACN', 'ACE', 'ATVI', 'ADBE'], dtype='<U4')

3) 누적합, 누적곱

누적합: cumsum(x)

누적곱: cumprod(x)

RATE = 0.0375
TERM = 30
#단리이자
simple = (RATE * np.ones(TERM)).cumsum() #기간마다의 이자율 계산
#복리이자
compound = ((1 + RATE) * np.ones(TERM)).cumprod()-1

 

7. 조건부 함수(where)

|이후 - 이전| 해서 평균인 20보다 큰 값만 true. false인 값(두 값의 차가 20이하인 값은 0으로 변환)

changes = np.where(np.abs(stocks[1] - stocks[0])>20.00, stocks[1] - stocks[0], 0) #전후가격을 빼줌
#abs: 절댓값
#true, false 판단 후에 어떤걸 값으로 할건지 작성
#다른 연산까지 한번에 하고 싶을 때
changes

#부가설명
"""Docstring:
where(condition, [x, y])

Return elements chosen from `x` or `y` depending on `condition`."""

sap[np.nonzero(changes)]

array(['MMM', 'ACN', 'ACE', 'ADBE'], dtype='<U4')

np.nonzero(): 배열의 요소들 중 0이 아닌 값들의 index를 반환해주는 함수

즉, 평균보다 큰 값을 sap에 적용시켜 해당 주식명을 출력

 

8. 배열 다루기

1) np.unique(): 중복되지 않은 요소로만 구성된 새로운 배열

dna = "AGTCCGCGAATACAGGCTCGGT"
#문자열을 넘파이 ARRAY로
dna_array = np.array(list(dna))
dna_array

array(['A', 'G', 'T', 'C', 'C', 'G', 'C', 'G', 'A', 'A', 'T', 'A', 'C',
       'A', 'G', 'G', 'C', 'T', 'C', 'G', 'G', 'T'], dtype='<U1')

#unique함수: 중복되지 않은 요소로만 구성된 새로운 배열
np.unique(dna_array)

array(['A', 'C', 'G', 'T'], dtype='<U1')

2) np.in1d([찾아볼 문자열], 비교할 배열) --> 교집합 찾기

np.in1d(["MSFT", "MMM", "AAPL"], sap)

array([False,  True, False])

*** np.in2d()는 따로 없다.일차원만 계산.이차원은 일차원으로 펼치던지,다르게 해주던지

*** in1d(): 포함하고 있는지, union1d() : 합집합, intersect1d(): 교집합
set()에서 교집합 합집합 구하는 것보다 속도가 2배 이상 빠르기 때문에 잘 활용하면 좋다!