[Python] Numpy

1. 특징

- Python에서 고성능의 과학적 계산 수행하는 패키지 (ex.선형 대수)

- Python 머신러닝 스택의 기초 패키지

- 다차원 배열인 ndarray를 제공

- 벡터화 된 연산과 Broadcasting 연산 지원

 

 

2. 설치

pip install numpy

*아나콘다는 자동 설치

*다른 패키지를 설치할 때 종속적으로 설치되는 경우가 있음 -> 버전 문제 발생

 

 

3. 사용

import numpy
import numpy as np
from numpy import * # 모듈의 모든 내용을 현재 모듈에서 사용
from numpy import ndarray # numpy 모듈 중에서 ndarray만 사용

• import *을 쓰면 nupmy 써주지 않아도 사용할 수 있지만, 내장함수인지 구분이 가지 않음!

 

 

 

4. ndarray

- array, 배열

- list나 tuple보다 생성 방법이 다양하고 가능한 작업 많음

- id의 모임이 아니라 값의 모임

• list나 tuple은 id의 모임이기 때문에 보기에는 자료형이 달라도 같은 자료형(id)으로 취급해서 생성이 가능했다.
• 그런데 ndarray는 동일한 자료형의 grid
• ndarray를 생성할 때 다른 자료형을 대입하면 추론을 통해 하나의 자료형으로 변환해서 생성

 

 

 

5. 속도

import datetime

li = range(1, 100000)

#현재 시간 저장
start = datetime.datetime.now()

#모든 요소에 10 곱하기
for i in li:
    i = i * 10
    
#현재 시간 저장
end = datetime.datetime.now()
print(start, end)

🤍

2024-02-06 12:39:02.822362 2024-02-06 12:39:03.379676

.

import numpy as np

ar = np.arange(1, 10000000)

#현재 시간 저장
start = datetime.datetime.now()

ar = ar * 10

#현재 시간 저장
end = datetime.datetime.now()
print(start, end)

🤍

2024-02-06 12:39:03.403699 2024-02-06 12:39:03.418701

• numpy가 더 빠름

 

 

 

6. 생성

numpy.array(object, dtype=None, copy=True)

• object: Vector 자료형 (데이터의 모임 - list, tuple, set 등의 데이터)
• dtype: 요소의 자료형, 생략 시 numpy가 알아서 추론
• copy: 복제 여부. 기본값은 True라서 원본 데이터를 복제해서 생성

numpy.asarray(object, dtype = None)

• object가 ndarray 자료형이면 데이터를 copy하지 않음

 

 

 

 

7. ndarray의 정보 확인 속성

- dtype: 데이터 한 개의 자료형

- ndim: 배열의 차원

- shape: 각 차원의 크기를 튜플로 리턴

- size: 데이터 개수

- itemsize: 하나의 항목이 차지하는 메모리 크기

- nbytes: 전체가 차지하는 메모리 크기

 

차원 확인

import numpy as np

#list를 이용해서 array 생성
ar = np.array([1, 2, 3])

#1차원
print(ar.ndim) 
print(ar.shape)  #1차원 3개의 데이터로 구성 (3, )

#2차원
table = np.array([[1, 2, 3], [4, 5, 6]])
print(table.ndim) 
print (table.shape) # 2행 3열의 배열 (2, 3)

 

 

 

 

8. 배열을 생성하는 다른 방법

numpy.arange(start, stop, step, dtype=None)

• start부터 stop까지 step 간격으로 생성
• dtype은 데이터 1개의 하나의 자료형
• stop 값만으로 생성할 수 있음
• 샘플 데이터 만들 때 자주 사용

ar = np.arange(1, 10, 2)
print(ar)

[1 3 5 7 9]

 

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

• start부터 stop까지 num만큼 배열로 생성
• endpoint는 마지막 값 포함 여부
• axis는 축
• 샘플 데이터 만들 때 자주 사용

numpy.zeros(), numpy.ones()

• 차원을 매개변수로 받아서 0이나 1로 채워주는 함수들

numpy.zeros_like(), numpy.ones_like()

• 배열을 매개변수로 받아서 동일한 크기의 배열을 만들고 0이나 1로 채워주는 함수들

numpy.empty(), numpy.empty_like()

• 초기화하지 않은 데이터(의미없는 값)의 배열 생성

numpy.eye(N, M, k=0, dtype=None)

• N은 행의 개수, M은 열의 수, k는 대각 위치로
  k=0이면 주대각선 방향만 1로 채워주고 k != 0이면 좌우로 대각 방향을 이동해서 1을 채워주는 행렬 생성
• N과 M 둘 중 하나의 값만 입력하면 하나의 값을 복사해서 정방행렬 생성

numpy.diag(행렬)

• 행렬에서 주 대각선 방향의 데이터만 골라 행렬 생성

#주대각선 방향이 1인 3*3 정방 행렬 생성
ar = np.eye(3)
print(ar)

print()
#행렬에서 주 대각선의 데이터만 골라서 다시 배열 생성
print(np.diag(ar))

🤍

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

[1. 1. 1.]

 

 

 

 

 

9. 자료형

- numpy의 ndarray는 모든 요소의 자료형이 동일해야 한다.

• 데이터의 자료형이 다르면 하나의 자료형으로 형변환해서 생성
• 정수와 실수가 같이 있으면 실수로, 숫자와 문자열이 같이 있으면 문자열로 생성

- 요소의 자료형은 dtype 속성으로 확인 가능

 

자료형

정수: numpy .int8, int16, .int32, .int64, .unit8, .unit16, .unit32, .unit64 - unit은 양수만 저장

실수: float16, float32, float64, float128

복소수: complex64, complex128,  complex256

boolean: bool

문자열: string_

유니코드: unicode_

객체: object

 

- 만들어진 배열의 자료형을 변경해서 다시 생성

• ndarray.astype(자료형)

- 형 변환을 하는 이유

• 머신러닝에서는 숫자 데이터만 사용 가능하기 때문에
• 서로 다른 배열끼리 연산을 하는 경우에
• 메모리를 효율적으로 사용하기 위해서

색상값 0~255까지의 숫자를 표현해야 하는 경우

int8는 8비트이다. 
int는 양수와 음수를 같이 표현한다.
양수와 음수의 모양이 각각 128가지 (-128 ~ 127)이다. 그래서 색상값 표현이 안된다. 
따라서 int16을 사용해서 표현해야 함! 

그런데 unit는 마찬가지로 모양이 256가지인데
음수를 표현하지 않기 떄문에
0~255 범위의 데이터를 표현하는 것이 가능하다.
메모리 효율 달성~

 

#데이터 타입 확인과 형변환
ar = np.array([1, "2", 3]) # 숫자 -> 문자열로 바뀜
print(ar.dtype)

ar2 = np.array([1, 2.3, 3]) # 정수 -> 실수로 바뀜
print(ar2.dtype)

#ar 배열의 자료형을 정수로 변환
ar3 = ar.astype(np.int32)
print(ar3.dtype)

🤍

<U11
float64
int32

 

 

 

 

 

10. 배열 차원 변환

머신러닝이나 딥러닝을 하다보면 특정한 차원의 데이터를 요구

현재 가지고 있는 데이터가 요구하는 차원과 맞지 않으면 차원을 변경해서 사용해야 함

 

차원 변경 함수

• reshape: 차원을 튜플로 받아서 튜플에 해당하는 차원으로 변경
• flatten: 무조건 1차원 배열로 변환
• 튜플을 대입하지 않고 -1을 대입하면 1차원으로 변경
• 튜플로 숫자를 설정할 때 마지막 값을 -1로 설정하면 numpy가 알아서 마지막 값 추론하고 설정

 

10개의 데이터가 있는 1차원 1배열 -> 2차원 배열로 변경

#0부터 19까지의 숫자를 가지고 1차원 배열 생성
ar = np.arange(20)
print(ar)

print()
#ar을 4*5짜리 2차원배열로 변환
#5 대신에 -1을 대입해도 결과는 동일
#20개의 데이터는 4행으로 만들려면 5열밖에 안됨
matrix = ar.reshape((4, -1))
print(matrix)

print()
#다차원 데이터를 1차원으로 변환
br = matrix.flatten()
print(br)

.

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

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

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

 

 

 

 

11. 배열의 부분 사용

1) 하나의 요소 사용 Indexing

- 일차원 배열의 경우 배열명[인덱스]의 형태로 접근

• 앞에서부터 접근할 때는 0부터 시작, 맨 뒤에서 접근할 때는 -1, -2 ...

- 이차원 배열의 경우 배열명[행번호, 열번호] 또는 배열명[행번호][열번호]

- 삼차원 배열의 경우 사용할 수 있는 번호만 늘리기

#배열에서 하나의 요소 접근
ar = np.arange(10)
matrix = ar.reshape((2, -1)) #행 2개, 열은 알아서
print(ar)
print(matrix)

#일차원 배열에 요소 접근
print(ar[0]) #첫번째 데이터
print(ar[-1]) #마지막 데이터

#이차원 배열에서 요소 접근
print(matrix[0, 2])
print(matrix[0][2])

🤍

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

 

 

2) 여러 개의 데이터 접근: Slicing

하나의 행 또는 열 단위로 접근

#배열에서 범위를 이용한 접근
ar = np.arange(10)
matrix = ar.reshape((2, -1))

print(ar[1:4]) #1에서 3까지
print(ar[5:]) #5부터 마지막값까지
print(ar[:4]) #시작위치부터 3까지
print(ar[:]) #전체

#이차원 배열에서의 접근
print(matrix[1][1:3]) 
print(matrix[1]) #1행 전체
print(matrix[:,1]) #1열 전체

🤍

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

[6 7]
[5 6 7 8 9]
[1 6]

 

 

 

3) 복사 방법

인덱싱이나 슬라이싱은 원본 데이터의 *참조만* 가져오는 것
- 인덱싱이나 슬라이싱으로 가져온 데이터를 변경하면, 원본의 데이터도 수정
- 복제를 하려면 copy()를 호출해야 함

 

- 참조 복사

• 데이터의 위치를 복사
• 원본이나 사본에 영향을 준다. 
• 지역 변수의 참조를 전역변수에 대입해서 사라지지 않도록 하기 위해 사용

- weak copy(얕은 복사)

• 데이터 참조를 한 번만 찾아가서 복사
• 데이터가 다른 데이터의 참조인 경우 원본에 영향

- deep copy(깊은 복사)

• 데이터의 참조를 재귀적으로 찾아가서 실제 데이터 복사
• 어떠한 경우에도 다른 데이터에 영향 줄 수 없음
• 데이터를 다른 변수로 참조하고자 할 때 권장하지만, 메모리가 부족한 경우 얕은 복사나 참조 복사를 하기도 함

#배열 생성
ar = np.arange(10)
print(ar)

#범위를 이용해서 데이터를 가져오는 것 - 참조를 복사
br = ar[0:4]
print(br)

#br[0]을 수정하면 ar의 데이터도 영향
br[0] = 42
print(br)
print(ar)

🤍

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

 

* 원본 데이터를 수정하는 것은 위험

#데이터를 복제해서 br이 가리키도록 하려면

ar = np.arange(10)
br = ar[0:4].copy() # 원본 데이터 영향없음
print(br)

.

[0 1 2 3]

 

 

4) Fancy Indexing

- 데이터를 선택할 때 list 이용해서 선택

- 연속된 범위가 아니더라도 선택이 가능

- 데이터는 복제됨!

ar = np.arange(10)

#Fancy Indexing
br = ar[[1, 3, 5, 7]]
print(br)
br[0] = 15700
print(br)
print(ar)

.

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

🤍

matrix = ar.reshape((2, -1))
print(matrix)

print(matrix[:, 0])
#이차원 배열에서 list를 이용해서 행 번호나 열 번호를 지정하면 이차원 배열이 만들어짐
print(matrix[:, [0]])

🤍

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

• numpy의 ndarray나 pandas의 DataFrame에서 
  하나의 열을 선택할 때 구조를 유지하기 위해서는 list로 설정

 

5) 조건에 맞는 데이터 선택

- 브로드캐스트 연산: numpy의 ndarray는 차원이 다른 데이터끼리 연산을 수행하면 순회하면서 연산 수행

- 산술 연산 -> 결과 리턴: 수치 데이터

- 논리 연산 -> 결과 리턴: bool의 배열

- 인덱싱 때 bool 배열을 대입 -> True인 데이터만 추출

- 논리 연산을 결합할 때 and, or를 사용하지 않고 &와 |를 사용해야 함

• and, or는 하나의 연산을 하나의 결과 (True or False)로 보기 때문!
  and와 or는 좌측과 우측의 데이터를 무조건 하나의 데이터로 간주
  &와 |는 하나의 데이터끼리 연산을 하면 하나의 결과를 만들고 배열끼리 연산을 하면 배열을 만듦

- 파이썬에서 None, 숫자 0, 데이터가 없는 벡터 데이터 => False로 간주, 나머지 데이터는 True

print(matrix)
print(ar)

#브로드캐스트 연산

#numpy와 ndarray와 논리연산을 수행하면 bool의 배열이 만들어짐
print(ar==3)

#인덱스의 bool 배열을 대입하면 True인 데이터만 추출
print(ar[ar%2 ==1])

#홀수이거나 4의 배수인 데이터만 골라내기
print(ar[(ar % 2 == 1) | (ar % 4 == 0)])

• 차원이 다른경우 차원을 순회하면서 연산 수행
• 연산은 구조를 맞춰놓고 해야 한다.

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

 

 

 

 

12. 연산

1) 포함 여부를 판단하는 연산

- in: 데이터가 포함돼있으면 True, 아니면 False

- not in: 데이터가 포함돼있으면 True, 아니면 False

 

 

2) 배열의 모든 요소에 함수 적용

- numpy.vectorize(함수)를 이용해서 벡터화된 함수 생성

• 벡터화된 함수에 numpy의 배열을 대입하면 함수의 결과를 다시 배열로 만들어서 리턴
• 함수는 반드시 리턴을 해야 한다. 
• list에서 사용하는 map()함수와 동일한 작업

matrix = np.array([1, 2, 3])
print(matrix)

#요소의 제곱을 수행하는 람다 함수
square_lambda = lambda x : x * x

#함수를 배열의 모든 요소에 적용해서 결과를 배열로 만들기
vectorized_func = np.vectorize(square_lambda)

result = vectorized_func(matrix)
print(result)

🤍

[1 2 3]
[1 4 9]

 

데이터가 None 이면 0 100보다 크면 100 으로 한 결과 배열 생성
#None을 걸러내는 작업을 먼저 해야 합니다.

ar = np.array([80, 70, 80, None, 120])

def preprocessing(data) -> int:
    if data == None:
        return 0
    elif data > 100:
        return 100
    else:
        return data
    
vec_func = np.vectorize(preprocessing)
print(vec_func(ar))

🤍

[ 80  70  80   0 100]

 

 

3) 배열의 전치와 축 변경

- 전치: 행과 열 반전

- 축 변경: 3차원 이상에서 데이터의 축 순서를 바꾸는 것

- 머신러닝 등 데이터의 증강(늘리는 것)이나 다양한 패턴을 찾을 때 사용

- 행렬은 T라는 속성으로 전치 가능

- numpy의 배열에는 transpose 메소드에서 축 순서를 설정하면 축 순서를 변경

• 축의 순서는 기본적으로 행(0), 열(1), 면(2)...

- 실제적으로 3차원 이상의 데이터는 차원 변경을 잘 하지 않음

• 3차원 이상의 차원 변경은 애니메이션에서 수행

#행렬의 전치 - 축변경
original = np.array([[1, 2, 3], [4, 5, 6]])

print(original)
print(original.T)
print(original.transpose(1, 0))

🤍

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

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

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

 

 

4) 랜덤

- 머신러닝 · 데이터 분석에서 샘플데이터 추출할 때 사용

• 정수인 seed 를 설정해서 난수표를 만들고 순서대로 데이터를 가져오는 것
• seed 값을 실시간으로 변경
  • 프로그래밍 언어 별로 seed 값이 실시간으로 변경되는 언어가 있고, 고정된 언어가 있음
  • 머신러닝에서는 seed를 고정한다.

메소드

numpy.random.seed(seed)

• 시드 설정
• seed: 시드 번호

numpy.random(데이터 개수)

• 0.0 ~ 1.0 사이의 숫자를 개수만큼 추출

numpy.randint(최소, 최대, 데이터 개수)

• 최소와 최대 사이에서 개수만큼 정수를 추출

numpy.rand(데이터 개수)

• 균등 분포에서 데이터 개수만큼 추출

numpy.randn(데이터 개수)

• 표준 편차가 1, 평균이 0인 정규 분포에서 데이터 개수만큼 추출

numpy.binomial(n, p, size)

• 이항분포에서 추출.
• n: 0부터 나올 수 있는 숫자까지의 범위
• p: 확률
• size: 개수

numpy.random.permutation(x)

• 정수를 설정해서 랜덤한 배열을 생성

numpy.random.shuffle(x)

• 랜덤한 배열을 생성

numpy.random.choice()

• 배열에서 복원 추출

 

- 복원 추출:  이번에 생성된 데이터를 그룹에 다시 포함시켜 추출하는 것

- 비복원 추출:  생성된 데이터를 그룹에 포함시키지 않고 추출

 

파이썬은 실행될 때 seed를 설정하지 않으면 seed를 실행 시간을 기준으로 설정

#랜덤한 숫자 추출의 개념

#seed를 설정하지 않으면 실행 시간을 기준으로 seed 가 설정되므로 
#실행할 때 마다 다른 숫자가 리턴
result = np.random.normal(size = 5)
print(result)

#seed를 42로 고정하면 실행할 때 마다 동일한 데이터가 리턴
np.random.seed(seed=42)
result = np.random.normal(size = 5)
print(result)

🤍

[ 0.30064545 -1.12631817  0.86785173  0.76195105  0.9716669 ]
[ 0.49671415 -0.1382643   0.64768854  1.52302986 -0.23415337]

 

 

 

13. Numpy 메소드

1) 메소드 분류

- Unary Function: 매개변수가 1개인 경우

- Binary Function: 매개변수가 2개인 경우

 

 

2)기본 통계 함수

- sum: 합계

- prod: 곱
- nanprod: None 을 1로 간주하고 곱
- nansum: None을 0으로 간주하고 합

- mean: 평균
- median: 중앙값
- max: 최대
- min: 최소

- std: 표준편차
- var: 분산

- percentile: 백분위수

• axis: 2차원 배열에서 행이나 열방향 과 관련된 옵션
• ddof: 표준 편차 와 분산은 ddof를 1로 설정해서 비편향 표준 편차 와 분산을 계산.
• 자유도는 다른 데이터의 값이 결정되면 자동으로 값이 결정되는 데이터의 개수

#4행 3열짜리 배열 생성
matrix = np.arange(1, 13).reshape((4, -1))
print(matrix)

#전체 데이터의 합계
print(np.sum(matrix))

#열의 합계
print(np.sum(matrix, axis=0))

#행의 합계
print(np.sum(matrix, axis=1))

🤍

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
78
[22 26 30]
[ 6 15 24 33]

 

 

 

- 피보나치 수열

• 첫번째 와 두번째는 무조건 1 이고 세번째부터는 앞 2개의 항의 합으로 만들어지는 수열
• 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...

#피보나치 수열

def fibo(n: int) -> int:
    if n == 1 or n == 2:
        return 1
    else:
        return fibo(n-1) + fibo(n-2)
print(fibo(6))

def norecursion_fibo(n:int) -> int:
    n1 = 1
    n2 = 1
    v = 1
    for i in range(3, n+1):
        v = n1 + n2
        n2 = n1
        n1 = v
    return v
print(norecursion_fibo(6))

8

8

 

- 표준 편차와 분산

• 표준 편차 와 분산은 ddof 옵션에 따라 값이 다르게 나옴
• 표준 편차 와 분산은 평균이 결정되고 전체 데이터 개수 - 1 만큼의 값을 알게되면
• 나머지 1개의 값은 자동으로 결정된다.
• 자동으로 결정되는 값을 빼고 계산하거나 포함시켜 계산할 수 있다.
• 이 옵션이 ddof 옵션

matrix = np.arange(1, 13).reshape((4, -1))
print(np.var(matrix))
print(np.var(matrix, ddof=1))

🤍

11.916666666666666
13.0

 

 

3) 기술 통계

- argmin, argmax: 최소값 과 최대값의 인덱스

- cumsum: 누적합

- cumprod: 누적곱

- diff: 차분은 이전 값을 뺀 값, n 이라는 옵션으로 차수를 설정할 수 있습니다.

 

 

4) 소수 관련 함수

- 소수를 버리거나 올림하거나 반올림해주는 함수를 제공

 

 

5) 숫자 처리 관련 함수

- 절대값, 제곱, 제곱근, 부호 판별 함수를 제공

 

 

6) 논리 함수

- numpy.isnan(배열): 배열에 None, NULL 등이 포함 여부를 리턴

- numpy.nan:  None을  표현

- logical_not( ): 조건에 맞지 않는 데이터 인지 여부를 리턴

#배열 생성
ar = np.array([10, 2, 3, 4, np.nan, 32, 42])

#배열에 None 데이터가 있는지 확인
print(np.isnan(ar)) #결측치 확인

#결측치를 제외하고 가져오기
result = ar[np.logical_not(np.isnan(ar))]
print(result)

#결측치를 제외하고 가져오기 - 결측치를 제거하지 않고 수행하면 nan 이 포함됩니다.
#ar을 가지고 수행하면 np.nan 이 포함되고 result를 가지고 수행하면 np.nan이 제거
result = result[np.logical_not(result > 10)]
print(result)

ar = np.array([2, 5, 23, 34, 21, 42, np.nan, 25])
print(ar)
#3의 배수이거나 4의 배수인 데이터만 추출 np.nan을 제거
temp = ar[np.logical_not(np.isnan(ar))]
result = temp[(temp % 3 == 0) | (temp % 4 ==0)]
print(result)

🤍

[False False False False  True False False] #결측치 확인
[10.  2.  3.  4. 32. 42.] #결측치 제외한 값
[10.  2.  3.  4.]
[ 2.  5. 23. 34. 21. 42. nan 25.]
[21. 42.]

 

 

7) 2개의 배열로 작업하는 함수

- add, subtract, multiply, divide, floor_divide(몫만 가져오기), mod

- power

- maximum, fmax, minimum, fmin

• f 가 붙는 함수는 np.nan을 무시

- greater, greater_equal, less, less_equal, equal, not_equal: 결과가 bool 의 배열

- logical_and, logical_or, logical_xor

• eXclusive OR(배타적 논리합, 같으면 False 다르면 True, True 와 True 또는 False 와 False 이면 False 가 되고 True 와 False로 데이터가 다르면 True 가 되는 연산)

- where(bool 배열, True 일 때 선택할 배열, False 일 때 선택할 배열)

 

 

8) 집합 관련 함수

- unique(): 중복을 제거

• 범주형에서 이상치를 찾는 데 사용

- intersect1d(): 교집합

- union1d(): 합집합

- in1d(): 데이터의 존재 여부를 bool 배열로 리턴

- setdiff1d(): 차집합

- setxor1d(): 한쪽에만 존재하는 데이터의 집합

#아래 데이터는 1, 2, 3, 4 중에 하나를 선택하는 범주형 데이터의 집합
#이상한 값이 있는지 확인
ar = np.array([2, 1, 3, 4, 5, 1, 2, 3])
print(np.unique(ar))

🤍

[1 2 3 4 5]

 

 

9) ndarray.sort()

• numpy sort는 리턴,  ndarray sort는 리턴X
• 내림차순 정렬은 numpy의 sort를 이용
• 2차원 배열은 numpy에서는 sort 를 잘 사용하지 않음 - (데이터의 인덱스가 깨짐)

ar = np.array([2, 1, 3, 4, np.nan])
print(ar.sort())
print(ar)
print(np.sort(ar)[::-1])
matrix = np.array([[1, 3, 2, 4], [9, 4, 1, 8]])
matrix.sort(axis = 0)
print(matrix)

🤍

None #리턴X
[ 1.  2.  3.  4. nan]
[nan  4.  3.  2.  1.]
[[1 3 1 4]
 [9 4 2 8]]

 

 

 

10)배열 분할

- numpy.split: 배열 그리고 개수 와 axis 옵션을 설정

 

 

 

11) 배열 결합

- numpy.concatenate ( 배열 2개, axis )

- hstack, vstack, dstack, stack, r_, c_, tile 함수

 

* hstack, vstack 자주 씀

테이블의 데이터가 너무 많아서 조회가 느린 경우 테이블을 분할해서 저장할 수 있는데
열을 분할하거나 행을 분할(Partition)한다.

열 단위로 분할할 때, 기본키를 양쪽 테이블에 갖게 하고 자주 사용하는 열과 자주 사용하지 않는 열로 나눈다.
1:1의 관계를 갖는 구조.

데이터베이스에서는 조인을 통해 하나의 테이블로 변환하는데
hstack은 행의 개수가 같을 때 옆으로 갖다 붙이자! 
vstack은 열의 개수가 같을 때 위아래로 갖다 붙이자! 

 

hstack: 행의 개수가 같은 두개 이상의 배열을 옆으로 연결하는 함수

vstack:  열의 개수가 같은 두개 이상의 배열을 상하로 연결하는 함수

dstack: 차원을 늘려서 결합

stack: dstack 함수를 확장한 것으로 차원의 위치(axis)를 직접 설정

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

r_: hstack과 유사한 예전 API

c_: vstack과 유사한 예전 API

tile: 배열을 반복해서 하나의 배열을 만드는 것     tile(배열, 반복횟수)

 

#htstack
ar = np.array([[1, 2, 3], [4, 5, 6]])
print(ar)
br = np.array([[11, 22, 33], [44, 55, 66]])
print(br)
print(np.hstack([ar, br]))
print(np.vstack([ar, br]))
print(np.dstack([ar, br]))

🤍

[[1 2 3]
 [4 5 6]]
 
[[11 22 33]
 [44 55 66]]
 
[[ 1  2  3 11 22 33]
 [ 4  5  6 44 55 66]]
 
[[ 1  2  3]
 [ 4  5  6]
 [11 22 33]
 [44 55 66]]
 
[[[ 1 11]
  [ 2 22]
  [ 3 33]]

 [[ 4 44]
  [ 5 55]
  [ 6 66]]]

 

 

 

 

14. 배열의 저장과 불러오기

1) 배열을 저장

numpy.save('파일 경로', 배열)

• 파일의 확장자는 관습적으로 npy 를 사용

2) 배열의 데이터 불러오기

numpy.load('파일 경로')

3) 여러 개의 배열을 저장

numpy.savez('파일 경로', 이름 = 데이터, ...

이렇게 저장한 데이터는 불러올 때 numpy.load('파일 경로', '이름') 사용

4) 머신 러닝 중 자주 사용하는 데이터가 있다면 npy 로 저장한 후 호출하는 것이 효율적