[Python] 39. numpy

1. numpy : 행렬, 통계관련기본함수, 다차원배열 제공해주는 모듈

2. numpy 연산 : 각각의 요소의 값들을 연산

# -*- coding: utf-8 -*-
"""
Created on Tue Jun 28 09:37:36 2022

@author: p011v
"""

########## 1. numpy : 행렬, 통계관련기본함수, 다차원배열 제공해주는 모듈

import numpy as np
#배열 생성
a = np.arange(15).reshape(3, 5) # 2차원 배열. 0 ~ 14까지의 숫자를 3행 5열 배열로 생성
a
b = np.arange(15) # 1차원 배열. 0 ~ 14까지의 숫자를 배열로 생성.
b
#b배열을 3행5열의 배열로 변경
b = b.reshape(3, 5)
b
type(b) #numpy.ndarray
type(np.arange(15)) #numpy.ndarray

#배열 요소의 자료형
a.dtype #int32 => 4byte
b.dtype

#a,b 배열의 형태
a.shape #(3,5) 3행 5열
b.shape
np.arange(15).shape #(15,) 1차원배열.
np.arange(15).reshape(15,1).shape #(15,1) 2차원배열.

#배열 차수
a.ndim #2. 2차원배열
np.arange(15).ndim #1. 1차원배열

#배열 요소의 바이트 크기
a.itemsize #4 byte. 
#배열 요소의 갯수
a.size #a배열은 15개의 요소를 가지고 있다.
np.arange(10).size #1차원 배열, 10개 요소를 가지고 있다.

#a 배열의 참조값  
a.data #<memory at 0x000002758F84EC20>
b.data #<memory at 0x000002758F84EE90>

#리스트로 배열 생성하기
c = np.array([6,7,8]) #리스트를 이용하여 배열 생성
c
type(c)
#c = np.array(6,7,8) #오류발생
c = np.array((6,7,8)) #튜플을 이용하여 배열 생성
c

#리스트로 2차월 배열 생성하기
d = np.array([[1.5, 2, 3], [4, 5, 6]])
d
d.dtype #배열 요소의 자료형
d.shape #d배열의 형태 조회하기
d.ndim #d배열의 차원 조회하기
d.itemsize #d배열의 요소의 바이트크기. 요소의 자료형크기
d.size #d배열의 요소의 갯수

#0으로 초기화면 3행 4열 배열 e를 생성하기
e = np.array([[0,0,0,0], [0,0,0,0], [0,0,0,0]])
e.shape
e
e = np.zeros((3, 4)) #3행 4열 배열 생성. 모든 요소의 값은 0으로 채움
e
e.shape

#모든 요소의 값이 0인 100개의 요소를 가진 배열 생성
f = np.zeros(100)
f.shape

#모든 요소의 값이 1인 100개의 요소를 가진 배열 생성하기
g = np.ones(100)
g.shape
g

#모든 요소의 값이 1인 요소를 가진 10행 10열 배열 생성하기
h = np.ones((10, 10))
h.shape
h
#모든 요소의 값이 정수형 1인 요소를 가진 10행 10열 배열 생성하기
h = np.ones((10, 10), dtype = int)
h.shape
h

# 0 ~ 9999까지의 값을 가진 배열(i)을 100행 100열의 2차원 배열로 생성하기
i = np.arange(10000).reshape(100, 100)
i.shape
i[:10]

# 0 ~ 2까지의 숫자를 9개로 균등분할하여 배열로 생성하기
j = np.linspace(0, 2, 9)
j
j.size
j = np.linspace(0, 9, 20)
j

# 상수값
np.pi

########## 2. numpy 연산 : 각각의 요소의 값들을 연산

a = np.array([20, 30, 40, 50])
b = np.arange(4) # 0, 1, 2, 3
c = a - b # 배열-배열 : 각각의 요소들이 연산
c #20, 29, 38, 47

c = b**2 # b배열의 요소들을 제곱한 요소
c #0, 1, 4, 9

c = a <35 # a배열의 요소들과 각각 비교하여 True, False 값 리턴
c #True, True, False, False

c = a + b # 배열+배열 : 각각의 요소들이 연산
c #20, 31, 42, 53

#2차원 배열의 연산
a = np.array([[1, 1], [0, 1]])
b = np.array([[2, 0], [3, 4]])
a
b
c = a + b #각각의 요소들의 합
c
c = a * b #각각의 요소들의 곱
c

# @ : 행렬의 곱. dot
c = a @ b #a.dot(b)
c
'''
      a     b                            c
    [1,1] [2,0] = [1*2+1*3][1*0+1*4] = [5,4]
    [0,1] [3,4] = [0*2+1*3][0*0+1*4] = [3,4]
'''
c = a.dot(b)
c

# 난수를 이용하여 배열 생성
rg = np.random.default_rng(1) #seed값
rg #seed값 1로 가진 난수 발생 객체
a = rg.random((2, 3)) #2행 3열로 난수를 생성하여 배열로 생성
a

b = np.ones((2, 3), dtype=int)
b
c = a + b #실수형 = 실수형 + 정수형
c = b + a
c
c.dtype

a += b #실수형 = 실수형 + 정수형
a
a.dtype

# b += a #오류발생. 정수형 = 정수형 + 실수형
a
b

# a배열의 전체 요소들의 합
a.sum()
b.sum()
# a배열의 요소 중 최소값
a.min()
# a배열의 요소 중 최대값
a.max()
# a배열의 전체 요소들의 평균
a.mean()
# a배열의 전체 요소들의 중간값 
a.median #오류 발생
# a배열의 전체 요소들의 표준 편차
a.std()
a
a.shape
# a배열의 행 중 최소값
a.min(axis=1)
# a배열의 열 중 최소값
a.min(axis=0)
# a배열의 행 중 최대값
a.max(axis=1)
# a배열의 열 중 최대값
a.max(axis=0)

# a행렬의 행의 누적값
a.sum(axis=1) # 행의 값
a.cumsum(axis=1)# 행의 누적값
# a행렬의 열의 누적값
a.sum(axis=0) #열의 합계값
a.cumsum(axis=0) #열의 누적값

# 10부터 49까지의 숫자를 배열 c로 생성하기
c = np.arange(10,50)
c
# c배열의 첫번째 값 조회
c[0]
# c배열의 0번 인덱스에서 3번 인덱스까지 조회
c[0:4] # array([10, 11, 12, 13])
c[:4]  # array([10, 11, 12, 13])
# c배열의 4번 인덱스값을 100으로 저장하기
c[4]
c[4] = 100
c[:5] # array([ 10,  11,  12,  13, 100])
# c배열의 0부터 3씩 증가하여 조회하기
c[::3]
# c배열의 0부터 3씩 증가하여 10번 인덱스까지 조회하기
c[:11:3]

# 0부터 11까지의 숫자를 3행 4열 배열 d로 생성하기
d = np.arange(0,12).reshape(3,4)
d
d[1,1] #5, d배열의 1행 1열의 값 조회하기
d[0:2, 0:2] # d배열의 1행까지 1열까지의 값 조회하기
d[:2, :2] # d배열의 1행까지 1열까지의 값 조회하기
d[::2, ::2] # d배열의 0행씩부터 2씩 증가, 0열부터 2씩 증가

# 1값으로 채워진 10행 10열 배열 e 생성하기
e = np.ones((10, 10))
e
# e배열의 가장 자리는 1로 내부는 0으로 채워진 배열로 수정하기
e[1:9, 1:9] = 0
e
e[1:-1, 1:-1] = 0
e

# e배열과 같은 모양의 배열 f를 생성하기
# 1. 0으로 채워진 8행 8열 배열 생성하기
f = np.zeros((8, 8))
f
# 행과 열에 각각 1로 채워진 행과 열을 추가하기
# pad() : 배열의 행과 열을 추가.
# pad_width=1 : 추가될 행과 열의 갯수
# constant_values=1 : 추가된 행과 열의 값
f = np.pad(f, pad_width=1, constant_values=1)
f

# np.fromfunction() : 함수를 이용하여 요소의 값을 설정
def f (x, y) : # x : 행의 인덱스 값, y : 열의 인덱스 값
    return 10 * x + y
'''
    fromfunction(함수명, (행, 열), dtype=int)
    g = [[ 0,  1,  2,  3],
        [10, 11, 12, 13],
        [20, 21, 22, 23],
        [30, 31, 32, 33],
        [40, 41, 42, 43]]
'''
g = np.fromfunction(f, (5, 4), dtype=int)
g

# g배열의 0행 출력하기
g[0]
# g배열의 2행 출력하기
g[2]
# g배열의 0열 출력하기
g[:,0]
# g배열의 2열 출력하기
g[:,2]
# g배열의 0, 1행, 0, 1열 출력하기
g[0:2,0:2]
g

#g.flat: 배열의 요소들만 리턴
for i in g.flat :
    print(i) 

# 난수를 이용하여 0~9 사이의 정수값을 가진 임의의 수로 3행 4열의 배열 생성
# np.floor:  작은 근사 정수
# np.ceil: 큰 근사정수
h = np.floor(np.random.random((3, 4)) * 10)
h
h.ndim
# h배열을 1차원배열 h1으로 변경하기
h1 = h.ravel() #h배열이 변경되지 않음
h1.shape
# h배열을 6행 2열의 배열 h2로 변경하기
h2 = h.reshape(6, 2)
h2
h
# h배열 자체를 6행 2열의 배열로 변경
h.resize(6, 2)
h
# h배열을 3행 5열로 변경
#h.reshape(3, 5) #오류. 요소의 갯수가 12개이므로 3행5열로는 변경 불가
h.reshape(3, 4)
# 행을 지정하고 열의 값을 -1로 지정하면, 열을 맞춰줌
h.reshape(3, -1)
h.reshape(3, -1).shape
h.reshape(4, -1)
h.reshape(4, -1).shape
# 열을 지정하고 행의 값을 -1로 지정하면, 행을 맞춰줌
h.reshape(-1, 4)
h.reshape(-1, 4).shape

# i배열 : 0 ~ 9사이의 난수 정수값을 가진 2행 2열 배열
# randint : 정수형 난수 리턴. 10 : 0 ~ 9사이의 임의의 값
i = np.random.randint(10, size=(2, 2))
i
j = np.random.randint(10, size=(2, 2))
j
# 2개의 배열 합치기
np.vstack((i, j)) #행을 합하기. 열의 갯수가 같아야 함.
np.hstack((i, j)) #열을 합하기. 행의 갯수가 같아야 함.

#배열 분리하기
import numpy as np
k=np.random.randint(10,size=(2,12))
k
np.hsplit(k,3)
np.vsplit(k,2)
k
#k배열에 모든 요소값을 100으로 변경하기
#k=100 #k변수에 100값을 저장. 배열변수가 아님.
k[:]=100
k #array([[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100]])
#0~19사이의 임의의 정수를 가진 5행 4열 배열 1을 생성하기.
l=np.random.randint(20,size=(5,4))
l
#l배열의 각 행의 최대값들을 조회하기.
l.max() #전체 값 중 최대값
l.max(axis=1) # 각 행의 최대값
#l배열의 각 열의 최대값을 조회하기
l.max(axis=0)

#l배열의 각 행의 최대값의 인덱스들을 조회하기. (알규맥스 argmax)
l.argmax(axis=1)
#l배열의 각 열의 최대값의 인덱스들을 조회하기.
l.argmax(axis=0)

#l배열의 각 행의 최소값의 인덱스들을 조회하기. (알규민 argmin)
l.argmin(axis=1)
#l배열의 각 열의 최소값의 인덱스들을 조회하기.
l.argmin(axis=0)

#단위행렬: 대각선 부분의 요소값만 1인 배열 (10행 10열짜리 단위행렬)
m=np.eye(10,10)
m
#array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
#       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
#       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
#       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
#       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
#       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
#       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
#       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
#       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
#       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

# m배열의 요소의 값이 0이 아닌 배열의 인덱스 출력하기
np.nonzero(m)
n=[1,2,0,4,0]
np.nonzero(n)

# 정규분포값을 가진 임의의 수료 배열 o 생성하기
# 정규분포 : 평균:0, 표준편차:1 데이터 10000개의 모임.
o = np.random.normal(0, 1, 10000)
o
o.mean()
o.std()
# 히스토그램을 이용하여 정규분포를 확인하기
import matplotlib.pyplot as plt
plt.hist(o, bins = 50)

# 정규분포 : 평균:2, 표준편차:2 데이터 10000개의 모임.
o = np.random.normal(2, 2, 10000)
o
len(o)
o.mean()
o.std

# 0~9사이의 임의 정수 5개를 중복 없이 선택. (choice 함수)
# choice(값의범위, 갯수, 재선택여부)
# 10: 0~9사이의 값
# 5: 5개 선택
# relpace=True/False : 재선택(중복가능)/재선택안함.
q=np.random.choice(10,5,replace=False)
q

# 1~45사이의 수를 중복없이 6개를 선택하기
r=np.random.choice(45,6,replace=False) + 1
r.sort() #정렬
r

# 0~3사이의 수를 중복없이 5개를 선택하여 s 배열에 저장하기.
#s=np.random.choice(4,5,replace=False) #오류발생. 중복없이는 불가
# 0~3사이의 수를 5개를 선택하여 s 배열에 저장하기.
s=np.random.choice(4,5,replace=True)
s

# 확률을 적용하여 난수 추출
# 0 ~ 5사이의 숫자 100개를 추출
# p=[0.1, 0.2, 0.3, 0.2, 0.1, 0.1] : 확률값. p요소의 합은 1이어야 함.
# 0값 : 0.1. 약 10개 정도
# 1값 : 0.2. 약 20개 정도도
# 2값 : 0.3. 약 30개 정도도
t = np.random.choice(6, 100, p=[0.1, 0.2, 0.3, 0.2, 0.1, 0.1])
t
listt = list(t) #리스트 <= 배열
listt.count(0)
listt.count(1)
listt.count(2)
listt.count(3)
listt.count(4)
listt.count(5)

fruits = ['apple', 'banana', 'cherries', 'durian', 'grapes']
u = np.random.choice(fruits, 100, p=[0.1, 0.2, 0.3, 0.2, 0.2])
listu = list(u) #리스트 <= 배열
for d in fruits:
    print(d, "=", listu.count(d))