파이썬 확장 패키지 : numpy (2)

파이썬 Python/데이터 분석

파이썬 확장 패키지 : numpy (2)

하나비 HANABI 2022. 2. 15. 21:27

문자열 데이터 numpy 배열 형변환

import numpy

data1 = ['people', 'boy', 'girl', 'man', 'woman']
data2 = ['1.5', '2.5', '3.5', '4.5', '5.5']
data3 = ['10', '20', '30', '40', '50']

arr1 = numpy.array(data1)
arr2 = numpy.array(data2)
arr3 = numpy.array(data3)

print("arr1 :", arr1)
print("arr1 데이터 타입 :", arr1.dtype) # <U6 : 유니코드, 문자의 최대수는 6자
print("arr2 :", arr2)
print("arr2 데이터 타입 :", arr2.dtype) # <U3 : 유니코드, 문자의 최대수는 3자
print("arr3 :", arr3)
print("arr3 데이터 타입 :", arr3.dtype) # <U2 : 유니코드, 문자의 최대수는 2자
print()

# 문자열을 실수로 변환
arr4 = arr2.astype(float)
print("arr4 :", arr4)
print("arr4 데이터 타입 :", arr4.dtype) 
print()

# 문자열을 정수로 변환 : 반드시 문자열이 정수여야 함
arr5 = arr3.astype(int)
print("arr5 :", arr5)
print("arr5 데이터 타입 :", arr5.dtype) 
print()

# arr4 = arr2.astype(int) # error 발생. 실수는 정수로 변환 불가

# 숫자를 문자열로 변환
arr6 = arr5.astype(str)
print("arr6 :", arr6)
print("arr6 데이터 타입 :", arr6.dtype)
print()

arr1 : ['people' 'boy' 'girl' 'man' 'woman']
arr1 데이터 타입 : <U6
arr2 : ['1.5' '2.5' '3.5' '4.5' '5.5']
arr2 데이터 타입 : <U3
arr3 : ['10' '20' '30' '40' '50']
arr3 데이터 타입 : <U2

arr4 : [1.5 2.5 3.5 4.5 5.5]
arr4 데이터 타입 : float64

arr5 : [10 20 30 40 50]
arr5 데이터 타입 : int32

arr6 : ['10' '20' '30' '40' '50']
arr6 데이터 타입 : <U11

난수 numpy 배열 생성

import numpy

# 0 <= 실수 난수 < 1 사이의 난수 생성
f1 = numpy.random.rand()
arr2 = numpy.random.rand(2, 3)
arr3 = numpy.random.rand(2, 3, 4)
print("f1 :", f1)
print("arr2 :")
print(arr2)
print("arr3 :")
print(arr3)
print("f1 type :", type(f1))
print("arr2 type :", type(arr2))
print("arr2 배열 데이터 타입 :", arr2.dtype) 
print("arr2 배열 형태 :", arr2.shape) 
print("arr3 배열 형태 :", arr3.shape)
print()

# 정수 난수 : low <= 난수 < high
# random.randint([low,] high[, size]), 기본값 : low = 0, size = 1
n1 = numpy.random.randint(10)                   # 0~9의 정수 난수 1개 생성
arr2 = numpy.random.randint(1, 10, size=(2, 3)) # 1~9의 2x3 행렬로 정수 난수 생성
arr3 = numpy.random.randint(10, size=(2, 3, 4))
print("n1 :", n1)
print("arr2 :")
print(arr2)
print("arr3 :")
print(arr3)
print("n1 type :", type(n1))
print("arr2 type :", type(arr2))
print("arr2 배열 데이터 타입 :", arr2.dtype) 
print("arr2 배열 형태 :", arr2.shape)
print("arr3 배열 형태 :", arr3.shape)

f1 : 0.8180219262188141
arr2 :
[[0.70143542 0.83651168 0.80882758]
[0.70057787 0.34950894 0.21387394]]
arr3 :
[[[0.81915646 0.28758555 0.15883754 0.72291305]
  [0.00822344 0.72063841 0.0236434  0.8494338 ]
  [0.78139699 0.99672498 0.51678926 0.65930833]]

[[0.91431708 0.39219886 0.86225485 0.82198564]
  [0.62223915 0.66120988 0.86454185 0.87464912]
  [0.2036204  0.93094409 0.57048143 0.38013993]]]
f1 type : <class 'float'>
arr2 type : <class 'numpy.ndarray'>
arr2 배열 데이터 타입 : float64
arr2 배열 형태 : (2, 3)
arr3 배열 형태 : (2, 3, 4)

n1 : 6
arr2 :
[[8 5 8]
[4 9 5]]
arr3 :
[[[0 5 2 3]
  [9 6 3 9]
  [1 1 5 1]]

[[9 4 8 1]
  [5 1 1 9]
  [2 6 7 3]]]
n1 type : <class 'int'>
arr2 type : <class 'numpy.ndarray'>
arr2 배열 데이터 타입 : int32
arr2 배열 형태 : (2, 3)
arr3 배열 형태 : (2, 3, 4)

Numpy 배열의 연산

1) 사칙 연산

- 배열의 형태(shape)가 같다면 덧셈, 뺄셈, 곱셈, 나눗셈 연산을 할 수 있다.

2) 통계 연산

- 배열의 합, 평균, 표준편차, 분산, 최소값, 최대값, 누적합, 누적곱 등 통계에 많이 이용하는 메소드도 있다.

★ 편차 = 자료형 - 평균

★ 분산 = 편차^2 의 평균

★ 표준편차 = √분산

3) 행렬 연산

- Numpy는 배열의 단순 연산뿐만 아니라 선형 대수(Linear algebra)를 위한 행렬(2차원 배열) 연산도 지원한다.

- 간단하게 행렬곱, 전치행렬, 역행렬, 행렬식 등을 구할 수 있다.

(a b) (c

★ 행렬곱 : ac + bd

(a b (e

c d) f)

★ 행렬곱 : ae + bf

: ce + bf

(a b (e f

c d) g h)

★ 행렬곱 : ae + bg, af + bh

: ce + dg, cf + dh

★ 전치행렬 : 행과 열을 바꿈.

a b c d e f

-> a d

b e

c f

★ 행렬식 : det(A) = ad - bc

A = (a b c d)

★ 역행렬 : 행렬식이 0이면 역행렬은 존재하지 않음.

: AB = BA 이면 역행렬

(a b ^-1 -> 1/det(A) * (d -b

c d) -c a)

import numpy

data1 = [10, 20, 30, 40]
data2 = [100, 200, 300, 400]

# numpy 배열 생성
arr1 = numpy.array(data1)
arr2 = numpy.array(data2)
arr_add = arr1 + arr2
arr_sub = arr1 - arr2
arr_mul = arr1 * arr2
arr_div = arr1 / arr2
arr_add2 = arr1 + 7
arr_square = arr1 ** 2

# numpy 배열 속성확인 
print("arr1 배열 형태 :", arr1.shape) 
print("arr2 배열 형태 :", arr2.shape)
print()

# 저장 내용 확인
print("arr1 :", arr1)
print("arr2 :", arr2)
print("arr_add :", arr_add)
print("arr_sub :", arr_sub)
print("arr_mul :", arr_mul)
print("arr_div :", arr_div)
print("arr_add2 :", arr_add2)
print("arr_square :", arr_square)

arr1 배열 형태 : (4,)
arr2 배열 형태 : (4,)

arr1 : [10 20 30 40]
arr2 : [100 200 300 400]
arr_add : [110 220 330 440]
arr_sub : [ -90 -180 -270 -360]
arr_mul : [ 1000 4000 9000 16000]
arr_div : [0.1 0.1 0.1 0.1]
arr_add2 : [17 27 37 47]
arr_square : [ 100 400 900 1600]

import numpy

arr1 = numpy.array([10, 20, 30, 40, 50, 60])
print(arr1)
print('-' * 30)

# 통계 연산 방법1
print(arr1.sum())     # 합
print(arr1.mean())    # 평균
print(arr1.std())     # 표준편차
print(arr1.var())     # 분산
print(arr1.min())     # 최소값
print(arr1.max())     # 최대값
print(arr1.cumsum())  # 누적합
print(arr1.cumprod()) # 누적곱
print()

# 통계 연산 방법2
print(numpy.sum(arr1))     # 합
print(numpy.mean(arr1))    # 평균
print(numpy.std(arr1))     # 표준편차
print(numpy.var(arr1))     # 분산
print(numpy.min(arr1))     # 최소값
print(numpy.max(arr1))     # 최대값
print(numpy.cumsum(arr1))  # 누적합
print(numpy.cumprod(arr1)) # 누적곱
print()

# 2차원 배열에서의 평균 구하기
arr2 = arr1.reshape(2, 3)
print('arr2 :')
print(arr2)

print(numpy.mean(arr2))         # 전체 평균
print(numpy.mean(arr2, axis=0)) # 열 평균
print(numpy.mean(arr2, axis=1)) # 행 평균

[10 20 30 40 50 60]
------------------------------
210
35.0
17.07825127659933
291.6666666666667
10
60
[ 10  30  60 100 150 210]
[       10       200      6000    240000  12000000 720000000]

210
35.0
17.07825127659933
291.6666666666667
10
60
[ 10  30  60 100 150 210]
[       10       200      6000    240000  12000000 720000000]

arr2 :
[[10 20 30]
[40 50 60]]
35.0
[25. 35. 45.]
[20. 50.]

import numpy

# numpy 배열 생성
arr1 = numpy.array([1, 2, 3, 4]).reshape(2, 2)
arr2 = numpy.array([10, 20, 30, 40]).reshape(2, 2)
print("arr1 :")
print(arr1)
print("arr2 :")
print(arr2)
print("arr1 배열 형태 :", arr1.shape) 
print("arr2 배열 형태 :", arr2.shape) 
print("--------------")

arr_dot = numpy.dot(arr1, arr2)       # 행렬곱
arr_transpose = numpy.transpose(arr1) # 전치 행렬
arr_inv = numpy.linalg.inv(arr1)      # 역행렬
arr_det = numpy.linalg.det(arr1)      # 행렬식

print("arr_dot :")
print(arr_dot)
print("arr_transpose :")
print(arr_transpose)
print("arr_inv :")
print(arr_inv)
print("arr_det :", arr_det)
print("--------------")

# 역행렬 확인, AB = I(단위 행렬)
arr3 = numpy.linalg.inv(arr1)
print(numpy.dot(arr1, arr3)) # 행렬곱

arr1 :
[[1 2]
[3 4]]
arr2 :
[[10 20]
[30 40]]
arr1 배열 형태 : (2, 2)
arr2 배열 형태 : (2, 2)
--------------
arr_dot :
[[ 70 100]
[150 220]]
arr_transpose :
[[1 3]
[2 4]]
arr_inv :
[[-2. 1. ]
[ 1.5 -0.5]]
arr_det : -2.0000000000000004
--------------
[[1.00000000e+00 1.11022302e-16]
[0.00000000e+00 1.00000000e+00]]

numpy 배열의 인덱싱과 슬라이싱

import numpy

arr1 = numpy.array([10, 20, 30, 40, 50, 60])
arr2 = numpy.arange(10, 100, 10).reshape(3, 3)
print("arr1 :", arr1)
print("arr2 :")
print(arr2)
print("arr1 배열 형태 :", arr1.shape)
print("arr2 배열 형태 :", arr2.shape)
print('-' * 30)

# 1차원 배열 인덱싱
print("arr1[2] :", arr1[2])
print("arr1[[1, 3, 5]] :", arr1[[1, 3, 5]]) # 원하는 인덱스값 지정
print("arr1[arr1 > 30] :", arr1[arr1 > 30]) # 조건 지정 
print('-' * 30)

arr1[2] = 555
print("arr1 :", arr1)
arr1[[0, 2, 3]] = [666, 777, 888]
print("arr1 :", arr1)
arr1[arr1 > 30] = 0
print("arr1 :", arr1)
print('-' * 30)

# 2차원 배열 인덱싱
# [행, 열]
print("arr2[0, 2] :", arr2[0, 2])
arr2[0, 2] = 35                     # 값 1개 변경
print("arr2 :")
print(arr2)
arr2[1] = numpy.array([45, 55, 65]) # 1개 행 전부 변경
print("arr2 :")
print(arr2)
arr2[2] = [75, 85, 95]              # 1개 행 전부 변경
print("arr2 :")
print(arr2)
print('-' * 30)

# 행과 열의 위치를 지정, arr2[0,0], arr2[2, 1] 선택
print("arr2[[0, 2], [0, 1]] :", arr2[[0, 2], [0, 1]]) # 0행0열, 2행1열 지정
arr2[[0, 2], [0, 1]] = [666, 777]
print("arr2 :")
print(arr2)

arr1 : [10 20 30 40 50 60]
arr2 :
[[10 20 30]
[40 50 60]
[70 80 90]]
arr1 배열 형태 : (6,)
arr2 배열 형태 : (3, 3)
------------------------------
arr1[2] : 30
arr1[[1, 3, 5]] : [20 40 60]
arr1[arr1 > 30] : [40 50 60]
------------------------------
arr1 : [ 10  20 555  40  50  60]
arr1 : [666  20 777 888  50  60]
arr1 : [ 0 20  0  0  0  0]
------------------------------
arr2[0, 2] : 30
arr2 :
[[10 20 35]
[40 50 60]
[70 80 90]]
arr2 :
[[10 20 35]
[45 55 65]
[70 80 90]]
arr2 :
[[10 20 35]
[45 55 65]
[75 85 95]]
------------------------------
arr2[[0, 2], [0, 1]] : [10 85]
arr2 :
[[666  20  35]
[ 45  55  65]
[ 75 777  95]]

import numpy

arr1 = numpy.array([10, 20, 30, 20, 50, 60])
arr2 = numpy.arange(10, 100, 10).reshape(3, 3)
print("arr1 :", arr1)
print("arr2 :")
print(arr2)
print("arr1 배열 형태 :", arr1.shape)
print("arr2 배열 형태 :", arr2.shape)
print('-' * 30)

# 1차원 배열 슬라이싱
print(arr1[1:4])
print(arr1[:4])
print(arr1[1:])
print(arr1[:])
print(arr1[::-1])
print('-' * 30)

arr1[2:5] = [35, 45, 55] # 부분 값 변경
print("arr1 :", arr1)

arr1[2:5] = 37           # 부분을 같은 값 변경
print("arr1 :", arr1)
print("--------------")

# 2차원 배열 슬라이싱
# 배열명[행슬라이싱 , 열슬라이싱] 
# => 배열명[행시작위치:행끝위치, 열시작위치:열끝위치]
print(arr2[1:3, 0:2]) # 행은 1~2, 열은 0~1 슬라이싱
print(arr2[:3, :2])   # 행은 처음~2, 열은 처음~1 슬라이싱
print("--------------")

# 특정 행의 열만 추출하기, 배열명[행위치][열시작위치:열끝위치]
print(arr2[1][0:2]) 
print("--------------")

print(arr2[:, 2])     # 특정 열만 추출하기
print(arr2[:, [1,2]]) # 특정 열만 추출하기
print(arr2[2, :])     # 특정 행만 추출하기

arr1 : [10 20 30 20 50 60]
arr2 :
[[10 20 30]
[40 50 60]
[70 80 90]]
arr1 배열 형태 : (6,)
arr2 배열 형태 : (3, 3)
------------------------------
[20 30 20]
[10 20 30 20]
[20 30 20 50 60]
[10 20 30 20 50 60]
[60 50 20 30 20 10]
------------------------------
arr1 : [10 20 35 45 55 60]
arr1 : [10 20 37 37 37 60]
--------------
[[40 50]
[70 80]]
[[10 20]
[40 50]
[70 80]]
--------------
[40 50]
--------------
[30 60 90]
[[20 30]
[50 60]
[80 90]]
[70 80 90]