[ 2021 NIPA AI - 기본 ] 2. 데이터 분석을 위한 라이브러리 (01~05) + α

Notice

Recent Posts

Recent Comments

Link

« 2024/11 »
일	월	화	수	목	금	토
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30

Tags more

Archives

Today

Total

관리 메뉴

Development Project

[ 2021 NIPA AI - 기본 ] 2. 데이터 분석을 위한 라이브러리 (01~05) + α 본문

AI/Edu

[ 2021 NIPA AI - 기본 ] 2. 데이터 분석을 위한 라이브러리 (01~05) + α

나를 위한 시간 2021. 10. 22. 20:53

01 파이썬의 여러가지 모듈과 패키지

ㆍ 모듈

특정 목적을 가진 함수와 자료의 모임 (외부의 라이브러리)

모듈 선언

기본

import 모듈이름	#모듈이름 == 내가 만든 or 누군가 만든 파일이름

원하는 이름으로 불러오기
- ```
import 모듈이름 as 원하는이름
```

선언 후 모듈안의 메서드 사용

모듈이름.모듈에 존재하는 메서드( )

내가 만든 모듈( .py 파일 )

#여기는 main.py 파일내부!
import cal		#내가 만든 cal.py파일 불러오기
cal.plus(3, 4)	#cal.py안의 메서드 plus를 가져와 연산

ㆍ 패키지

모듈을 폴더로 구분하여 관리

( 한 모듈만 ) 기본

import 패키지이름.모듈이름 #모듈이름.모듈에 존재하는 메서드( )

( 한 모듈만 ) 원하는 이름으로 불러오기

import 패키지이름.모듈이름 as 원하는이름
#모듈이름.모듈에 존재하는 메서드( )

( 한 모듈만 ) 함수처럼 쓰기

from 패키지이름.모듈이름 import 가져올 메소드
#가져온 메소드( )

( 전체 모듈 ) 가져올때

from 패키지이름 import *	# *(별)은 "모두"를 나타냄

02 데이터 핸들링을 위한 라이브러리 NumPy

ㆍ NumPy 『 Numpy Array 』

Python에서 대규모 다차원 배열을 다룰 수 있게 도와주는 라이브러리
사용이유
- 데이터의 대부분은 숫자의 배열로 볼수있음 ex) 사진의 픽셀, 함수 그래프, ...
- 반복문없이 배열 처리가 가능하며, 파이썬 리스트보다 빠른연산을 지원하고 메모리를 효율적으로 사용함
파이썬 리스트 VS NumPy 배열
- 파이썬 리스트는 다른 자료형을 담을 수 있지만, numpy는 불가능!
- numpy 배열은 numpy 배열끼리 여러 연산 가능, 파이썬 리스트는 불가능(구성 요소가 추가될 뿐).

NumPy Array 생성

기본값 X 배열

기본) np.array( 리스트, dtype=자료형 ) 이용

import numpy as np	#보통 np로 줄여쓴다 
a = np.array(range(5), dtype = float) 
print(a)	#[0 1 2 3 4] <- 공백으로 구분! (파이썬 리스트는 콤마로 구분) 
b = np.array([([1, "2"], "3", 4), ('a', 15.2, 'c')], dtype = object) 
print(b)	#[[list([1, '2']) '3' 4] 
		# ['a' 15.2 'c']]

범위로 배열 생성

np.arrange( start, end, step ) 이용 == start부터 end까지를 step간격으로

import numpy as np	 
np_arr = np.arange(1, 13, 1)	
print(np_arr)		#[ 1  2  3  4  5  6  7  8  9 10 11 12]
np_arr.shape = 3, 4	#모양 결정 == 3행 4열
print(np_arr)	#[[ 1  2  3  4]
			# [ 5  6  7  8]
			# [ 9 10 11 12]]

np.linspace( start, end, cnt ) 이용 == start과 end에서 cnt개 만큼 균일한 간격으로

import numpy as np
np_arr = np.linspace(1, 13, 5)
print(np_arr)	#[ 1.  4.  7. 10. 13.]
print(np_arr.dtype)	#float64

np.logspace( start, end ,cnt ) 이용 == start에서 end까지 cnt개 만큼 로그 스케일로

import numpy as np
np_arr = np.logspace(1, 13, 5)
print(np_arr)	#[1.e+01 1.e+04 1.e+07 1.e+10 1.e+13]
print(np_arr.dtype)	#float64

기본값 O 배열

난수 X

np.zeros( 열 or (행, 열), dtype=자료형 ) 이용 == 배열 생성 후, 0.으로 초기화

import numpy as np
a = np.zeros((3,4))
print(a)	#[[0. 0. 0. 0.]
		# [0. 0. 0. 0.]
		# [0. 0. 0. 0.]]
print(a.dtype)	#float64

np.ones( 열 or (행, 열), dtype=자료형 ) 이용 == 배열 생성 후, 1.으로 초기화

import numpy as np
np_arr = np.ones(6)
print(np_arr)	#[[1. 1. 1. 1.]
			# [1. 1. 1. 1.]
			# [1. 1. 1. 1.]]
print(np_arr.dtype)	#float64

np.full( 열 or (행, 열), 지정할 기본값, dtype=자료형 ) 이용 == 배열 생성 후, 기본값으로 초기화

import numpy as np
np_arr = np.full((3, 4), "this")
print(np_arr)	#[['this' 'this' 'this' 'this']
			# ['this' 'this' 'this' 'this']
			# ['this' 'this' 'this' 'this']]
print(np_arr.dtype)	#<U4

np.empty( 열 or (행, 열), dtype=자료형 ) 이용 == 배열 생성 후, 초기화X (쓰레기값)

import numpy as np
np_arr = np.empty((3, 4))
print(np_arr)	#[[6.23042070e-307 4.67296746e-307 1.69121096e-306 1.29062093e-306]
			# [7.56587584e-307 1.37961302e-306 1.05699242e-307 8.01097889e-307]
			# [1.24611674e-306 1.78019354e-306 1.69120552e-306 8.45594613e-307]]
print(np_arr.dtype)	#float64

np.eye( 열, dtype=자료형 ) 이용 == 배열 생성 후, 단위행렬

import numpy as np
np_arr = np.eye(4)
print(np_arr)	#[[1. 0. 0. 0.]
			# [0. 1. 0. 0.]
			# [0. 0. 1. 0.]
			# [0. 0. 0. 1.]]
print(np_arr.dtype)	#float64

np.( zeros / ones / full / empty )_like 이용 == 기존 배열의 형태인 기본값(0, 1, 원하는 값, 없음) 배열

np.zeros_like( 열 or (행, 열) or 만든 배열, dtype=자료형 )

import numpy as np
a = np.zeros_like(4)
print(a)  		#0
print(a.dtype)	#int32

b = np.zeros_like((3, 4))
print(b)		#[0 0]
print(b.dtype)	#int32

createdArray = np.array([(1, 2, 3), (4, 5, 6)])
c = np.zeros_like(createdArray)
print(c)	#[[0 0 0]
		# [0 0 0]]
print(c.dtype)  #int32

np.ones_like( 열 or (행, 열) or 만든 배열, dtype=자료형 )

import numpy as np
a = np.ones_like(4)
print(a)		#1
print(a.dtype)	#int32

b = np.ones_like((3,4))
print(b)		#[1 1]
print(b.dtype)	#int32

createdArray = np.array([(1, 2, 3), (4, 5, 6)])
c = np.ones_like(createdArray)
print(c)	#[[1 1 1]
		# [1 1 1]]
print(c.dtype)  #int32

np.full_like( 열 or (행, 열) or 만든 배열, 기본값, dtype=자료형 )

import numpy as np
a = np.full_like(4, 3.4)
print(a)		#3
print(a.dtype)	#int32

b = np.full_like((3, 4), 5.2)
print(b)		#[5 5]
print(b.dtype)	#int32

createdArray = np.array([(1, 2, 3), (4, 5, 6)])
c = np.full_like(createdArray, 3.4)
print(c)	#[[3 3 3]
		# [3 3 3]]
print(c.dtype)  #int32

np.empty_like( 열 or (행, 열) or 만든 배열, dtype=자료형 )

import numpy as np
a = np.empty_like(3)
print(a)		#897988541
print(a.dtype)	#int32

b = np.empty_like((3, 4))
print(b)		#[0 0]
print(b.dtype)	#int32

createdArray = np.array([(1, 2, 3), (4, 5, 6)])
c = np.empty_like(createdArray)
print(c)	#[[-908123968      32760 -908119440]
		# [     32760    3866707    3866670]]
print(c.dtype)  #int32

난수 O

np.random.rand( 열 ) or ( 행, 열 )
- import numpy as np np_arr = np.random.rand(3, 4) print(np_arr) #[[0.486115 0.82756127 0.08714149 0.54526723] # [0.96816953 0.18722402 0.73853384 0.74432593] # [0.98611419 0.5042266 0.33921752 0.53748887]] print(np_arr.dtype) #float64

np.random.randint( start, end, 열 or (행, 열) ) == start부터 end까지의 난수를

import numpy as np
np_arr = np.random.randint(1, 10, (3, 4))
print(np_arr)		#[[1 1 4 7]
		# [7 1 2 8]
		# [3 2 5 4]]
print(np_arr.dtype)	#int32

np.random.randn( 열 or (행, 열) )

import numpy as np
np_arr = np.random.randn(10)
print(np_arr)		#[ 0.17287073  0.87742797 -1.54178023  0.88882218  0.21140253 -0.13571657
		# -1.13630232 -0.904898    2.68148849 -1.09157281]
print(np_arr.dtype)	#float64

np.random.normal( 평균, 표준편차, or (행, 열) ) == 평균과 표준편차를 가지는 정규분포에서 추출

import numpy as np
np_arr = np.random.normal(1, 5, 10)
print(np_arr)       #[ 3.37256689  0.18779722 -3.73055367  0.22183614  6.05174117  4.30277613
		#  0.23409445  0.43503341 11.29104268  9.02739796]
print(np_arr.dtype) #float64

NumPy Array 조작

추출 (원본유지)

인덱싱

기본

import numpy as np
np_arr = np.array(range(10))
print(np_arr[2])		#2

Boolean 인덱싱 == 배열의 각 요소의 선택 여부를 Boolean mask를 이용하여 지정하는 방식

import numpy as np
np_arr = np.array([1, 2, 3, 4, 5])
print(np_arr<3)		#[ True  True False False False]
print(np_arr[np_arr<3])	#[1 2]

Fancy 인덱싱 == 배열의 각 요소 선택을 Index 배열을 전달하여 지정하는 방식
- ```
import numpy as np
np_arr = np.arange(7)
print(np_arr[[1, 3, 5]])	#[1 3 5]
```

슬라이싱

import numpy as np
np_arr = np.arange(7)
print(np_arr)		#[0 1 2 3 4 5 6]
print(np_arr[1:4])	#[1 2 3]	-> 인덱스1 부터 : 인덱스4 전까지
print(np_arr[1:])	#[1 2 3 4 5 6]	-> 인덱스1 부터 : 끝까지
print(np_arr[:4])	#[0 1 2 3]	-> 처음부터 : 인덱스4 전까지
print(np_arr[::2])	#[0 2 4 6]	-> 처음부터 : 끝까지 : 2 간격으로

ndim( 차원 ), shape( 행, 열 )

import numpy as np

np_arr0 = np.array([1, 2, 3, 4, 5])
print(np_arr0.ndim)	#1
print(np_arr0.shape)	#(5,)	<- 5열 (1차원 == 행 X, 열 O)

np_arr1 = np.array([[1], [2], [3], [4], [5]])
print(np_arr1.ndim)	#2
print(np_arr1.shape)	#(5, 1)	<- 5행 1열 (1차원 == 행 O, 열 O)

np_arr2 = np.array([1])
print(np_arr2.ndim)	#1
print(np_arr2.shape)	#(1,)	<- 1행 (1차원 == 행 X, 열 O)

np_arr3 = np.array([[1]])
print(np_arr3.ndim)	#2
print(np_arr3.shape)	#(1, 1)	<- 1행 1열 (2차원 == 행 O, 열 O)

변경 (원본훼손)

astype( 바꿀 자료형 ) == 선언 후에 데이터타입(dtype) 변경

import numpy as np
np_arr = np.array([1, 2, 3, 4, 5], dtype=float)
print(np_arr)			#[1. 2. 3. 4. 5.]	<- 실수형은 숫자뒤에 점이 붙음
print(np_arr.astype(int))	#[1 2 3 4 5]

NumPy Array 연산

덧셈

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(a+b)	#[[ 2  4  6]
		# [ 8 10 12]
		# [14 16 18]]

뺄셈

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(a-b)	#[[0 0 0]
		# [0 0 0]
		# [0 0 0]]

곱셈

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(a*b)	#[[ 1  4  9]
		# [16 25 36]
		# [49 64 81]]

나눗셈

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(a/b)	#[[1. 1. 1.]
		# [1. 1. 1.]
		# [1. 1. 1.]]

지수

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
print(np.exp(a))	#[[2.71828183e+00 7.38905610e+00 2.00855369e+01]
		# [5.45981500e+01 1.48413159e+02 4.03428793e+02]
		# [1.09663316e+03 2.98095799e+03 8.10308393e+03]]

제곱근

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
print(np.sqrt(a))	#[[1.         1.41421356 1.73205081]
		# [2.         2.23606798 2.44948974]
		# [2.64575131 2.82842712 3.        ]]

삼각함수

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
print(np.sin(a))	#[[ 0.84147098  0.90929743  0.14112001]
		# [-0.7568025  -0.95892427 -0.2794155 ]
		# [ 0.6569866   0.98935825  0.41211849]]
print(np.cos(a))	#[[ 0.54030231 -0.41614684 -0.9899925 ]
		# [-0.65364362  0.28366219  0.96017029]
		# [ 0.75390225 -0.14550003 -0.91113026]]
print(np.tan(a))	#[[ 1.55740772 -2.18503986 -0.14254654]
		# [ 1.15782128 -3.38051501 -0.29100619]
		# [ 0.87144798 -6.79971146 -0.45231566]]

로그

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
print(np.log(a))	#[[0.         0.69314718 1.09861229]
		# [1.38629436 1.60943791 1.79175947]
		# [1.94591015 2.07944154 2.19722458]]

내적

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(np.dot(a, b))	#[[ 30  36  42]
		# [ 66  81  96]
		# [102 126 150]]

비교

import numpy as np
a = np.linspace(1, 9, 9, dtype=int).reshape(3, 3)
b = np.arange(1, 10).reshape(3, 3)
print(a>b)	#[[False False False]
		# [False False False]
		# [False False False]]
print(a<b)	#[[False False False]
		# [False False False]
		# [False False False]]
print(a==b)	#[[ True  True  True]
		# [ True  True  True]
		# [ True  True  True]]
print(a!=b)	#[[False False False]
		# [False False False]
		# [False False False]]

03 데이터 조작 및 분석을 위한 Pandas 기본 ~ 04 데이터 조작 및 분석을 위한 Pandas 심화

ㆍ Pandas 『 Series, Dataframe 』

Array계산에 특화된 NumPy를 기반으로 설계되어, 구조화된 데이터를 효과적으로 처리하고 저장하는 라이브러리
Series
- Numpy의 array가 보강된 형태로, Data와 Index를 가짐
- 사용방법
  - 선언
    - pd.Series( 리스트, dtype=자료형, index=인덱스 ) 이용
      - import pandas as pd data1 = pd.Series([1, 2, 3, 4]) print(data1) #0 1 #1 2 #2 3 #3 4 #dtype: int64 data2 = pd.Series([1, 2, 3, 4], dtype=float, index=["A", "B", "C", "D"]) print(data2) #A 1.0 #B 2.0 #C 3.0 #D 4.0 #dtype: float64 print(data2["A"]) #1.0 print(type(data2)) # <class 'pandas.core.series.Series'>
    - 파이썬 Dictionary 사용
      - import pandas as pd population_dict ={ 'china' : 141500, 'japan' : 12718, 'korea' : 5180, 'usa' : 32676 } population_series = pd.Series(population_dict) print(population_series) #china 141500 #japan 12718 #korea 5180 #usa 32676 #dtype: int64

Dataframe

여러개의 Series가 모여 행과 열을 이룬 데이터

데이터 프레임 생성

같은 인덱스의 다른 Series

import pandas as pd
gdp_dict = {
    'china': 1409250000,
    'japan': 516700000,
    'korea': 169320000,
    'usa': 2041280000,
}
gdp = pd.Series(gdp_dict)

population_dict ={
   'china': 141500,
   'japan': 12718,
   'korea': 5180,
   'usa': 32676
}
population = pd.Series(population_dict)

country = pd.DataFrame({'gdp': gdp, 'population': population})
print(country)	#              gdp  population
			#china  1409250000      141500
			#japan   516700000       12718
			#korea   169320000        5180
			#usa    2041280000       32676

Dictionary

import pandas as pd
data = {
    'country': ['china', 'japan', 'korea', 'usa'],
    'gdp': [1409250000, 516700000, 169320000, 2041280000],
    'population': [141500, 12718, 5180, 32676]
}
country = pd.DataFrame(data)
country = country.set_index('country')
print(country)	#                gdp  population
			#country                        
			#china    1409250000      141500
			#japan     516700000       12718
			#korea     169320000        5180
			#usa      2041280000       32676

데이터 프레임 조작

추출 (원본 유지)

ndim( 차원 ), shape( 행, 열 )

import pandas as pd
data0 = {'1': [1, 2, 3, 4],
	'10': [10, 20, 30, 40],
	'100': [100, 200, 300, 400]}
data1 = pd.DataFrame(data0)

print(data1)	#   1  10  100
	#0  1  10  100
	#1  2  20  200
	#2  3  30  300
	#3  4  40  400

print(data1.ndim)	#2
print(data1.shape)	#(4, 3)

size( 크기 )

import pandas as pd
data0 = {'1': [1, 2, 3, 4],
	'10': [10, 20, 30, 40],
	'100': [100, 200, 300, 400]}
data1 = pd.DataFrame(data0)

print(data1.size)	#12

values( 값 추출 )

import pandas as pd
data0 = {'1': [1, 2, 3, 4],
	'10': [10, 20, 30, 40],
	'100': [100, 200, 300, 400]}
data1 = pd.DataFrame(data0)

print(data1.values)	#[[  1  10 100]
		# [  2  20 200]
		# [  3  30 300]
		# [  4  40 400]]

[ loc ] 인덱싱 / 슬라이싱_명시적인 인덱스로 참조

print(country)	#              gdp  population
		#china   140925000   140925000
		#japan   516700000   516700000
		#korea   169320000   169320000
		#usa    2041280000  2041280000

print(country.loc['china'])	# gdp           140925000
		#population    140925000
		#Name: china, dtype: int64
        
print(country.loc['japan':'korea', :'population'])	#              gdp  population
			#japan  516700000   516700000
			#korea  169320000   169320000

[ iloc ] 인덱싱 / 슬라이싱_정수로 참조

print(country.iloc[0])	# gdp           140925000
		#population    140925000
		#Name: china, dtype: int64
print(country.iloc[1:3, :2])	#              gdp  population
		#japan  516700000   516700000
		#korea  169320000   169320000

컬럼 선택

#Series
print(country['gdp'])# china     140925000
		#japan     516700000
		#korea     169320000
		#usa      2041280000
		#Name: gdp, dtype: int64
        
#DataFrame
print(country[['gdp']])	#               gdp
		#china   140925000
		#japan   516700000
		#korea   169320000
		#usa    2041280000

Masking / Query 연산

#Masking
print(country[country['population']<10000])	#             gdp  population
		#korea  169320000        5180
#Query
print(country.query("population>10000"))	#              gdp  population
		#china   140925000      141500
		#japan   516700000       12718
		#usa    2041280000       32676

[데이터프레임 분석용 함수]

count 연산

# default : NaN값 제외
df.count(axis=1)	#행 기준
df.count(axis=0)	#열 기준

max, min 연산

# default : 열 기준, NaN값 제외
df.max()
df.min()

sum, mean 연산

# default : 열기준, NaN값 제외
df.sum()
df.mean()

# axis, skipna 사용 :  행기준, NaN값 포함(포함하면 계산이 불가능하므로 NaN값이 나옴)
df.sum(axis=1)
df.mean(axis=1, skipna = False)

# NaN값 대체
df['컬럼명1'] = df['컬럼명1'].fillna(대체할 값)

[ group by ] 그룹으로 묶기

# groupby 기본형태 
df.groupby('컬럼명').조건부집계함수()
df.groupby(['컬럼명1','컬럼명2'].조건부집계함수()

# aggregate : 집계를 한번에 계산하는 방법
df.groupby('key').aggregate(['min', np.median, max])
df.groupby('key').aggregate({'data1' :'min', 'data2':np.sum})

# filter : 그룹속성을 기준으로 데이터 필터링
def filter_by_mean(x):
    return x['데이터2'].mean()>3
df.groupby('key').mean()
df.groupby('key').filter(filter_by_mean)

# apply, lambda : 묶인 데이터에 함수 적용
df.groupby('key')/apply(lambda x:x.max() - x.min())

# get_group : groupby로 묶인 데이터에서 key값으로 데이터를 가져올 수 있음
df.groupby("컬럼명").get_group("key값")

저장 및 불러오기

country.to_csv("./country.csv")
country.to_excel("counry.xlsx")

country = pd.read_csv("./country.csv")
country = pd.read_excel("country.xlsx")

변경(원본 훼손)

index, column 이름지정

country.index.name = "Country"
country.columns.name = "Info"

print(country.index)	#Index(['china', 'japan', 'korea', 'usa'], dtype='object', name='Country')
print(country.columns)	#Index(['gdp', 'population'], dtype='object', name='Info')
print(country)	# Info            gdp  population
		#Country                        
		#china     140925000   140925000
		#japan     516700000   516700000
		#korea     169320000   169320000
		#usa      2041280000  2041280000

정렬

index값 기준으로

#행 인덱스 이름 기준 오름차순 정렬 (default)
df.sort_index(axis = 0)

#열 인덱스 이름 기준 내림차순 정렬
df.sort_index(axis = 1, ascending = False)

column값 기준으로

#col1 컬럼 기준 오름차순 정렬 (default)
df.sort_values('col1')		

#col1 컬럼 기준 내림차순 정렬
df.sort_values('col1', ascending = False)

#col2 컬럼 기준 오름차순 정렬 후 col2 컬럼 기준 내림차순 정렬
df.sort_values(['col2', 'col1'], ascending = [True, False])

05 Matplotlib 데이터 시각화

ㆍ Matplotlib

사용방법

그래프 생성

pyplot 직접 이용
- 선
  - import matplotlib.pyplot as plt import numpy as np x = np.arange(15) y1 = x**2 y2 = x*2 plt.plot(x, y1) plt.plot(x, y2) plt.show()

객체 이용

선

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(15) 
 y1 = x**2 
 y2 = x*2
 
 fig = plt.subplots() 
 ax = fig.subplots() 
 ax.plot(x, y1) 
 ax.plot(x, y2) 
 
 plt.show()

편의 함수 이용

선

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(15)
y1 = x**2
y2 = x*2

fig, ax = plt.subplots()
ax.plot(x, y1)
ax.plot(x, y2)

plt.show()

막대

기본형

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(15)
y1 = x**2

fig, ax = plt.subplots(figsize=(12, 4))
ax.bar(x, y1)

plt.show()

응용형

import numpy as np
import matplotlib.pyplot as plt

x = np.random.rand(3)
y = np.random.rand(3)
z = np.random.rand(3)
data = [x, y, z]
fig, ax = plt.subplots()
ax.set_ylim(0, 3)
x_ax = np.arange(3)
for i in x_ax:
    ax.bar(x_ax, data[i],
    bottom = np.sum(data[:i], axis=0))

ax.set_xticks(x_ax)
ax.set_xticklabels(["A", "B", "C"])

plt.show()

히스토그램

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
data = np.random.randn(1000)
ax.hist(data, bins=50)

plt.show()

그래프 조작

그래프 속성

추가 속성

선 스타일

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
x = np.arange(15)
ax.plot(x, x, linestyle="-")
ax.plot(x, x+2, linestyle="--")
ax.plot(x, x+4, linestyle="-.")
ax.plot(x, x+6, linestyle=":")

plt.show()

마커 스타일

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
x = np.arange(15)
ax.plot(x, x, marker=".")
ax.plot(x, x+2, marker="o")
ax.plot(x, x+4, marker="v")
ax.plot(x, x+6, marker="s")
ax.plot(x, x+8, marker="*")

plt.show()

색상

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
x = np.arange(15)
ax.plot(x, x, color="r")
ax.plot(x, x+2, color="green")
ax.plot(x, x+4, color="0.8")
ax.plot(x, x+6, color="#524FA1")

plt.show()

축 경계 조절

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
x = np.arange(10)
ax.plot(x, x)
ax.set_xlim(-2, 12)
ax.set_ylim(-2, 12)

plt.show()

범례

x = np.arrange(10)
fig, ax = plt.subplots()
ax.plot(x, x, label='y=x')
ax.plot(x, x**2, label='y=x^2')
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend(loc='upper right',
	shadow=True,
  	fancybox=True,
   	borderpad=2)

그래프 영역 속성

제목 및 x, y 레이블 지정

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(15)
y = x**2
plt.plot(x, y)

plt.title("SQUARE")
plt.xlabel("0~14", fontsize=13)
plt.ylabel("RESULTS")

plt.show()

범례 지정

import matplotlib.pyplot as plt
import numpy as np

x1 = np.arange(15)
y1 = x1**2
y2 = x1*2
plt.plot(x1, y1, label="SQUARE")
plt.plot(x1, y2, label="DOUBLE")

plt.title("NUMBERS")
plt.xlabel("0~14", fontsize=13)
plt.ylabel("RESULTS")
plt.legend()

plt.show()

ㆍ Matplotlib with pandas

크롤링 등을 이용해 엑셀 파일에 데이터를 저장하고 가져와서 처리할때 자주 사용함

import pandas as pd
import matplotlib.pyplot as plt

# 현재 파이썬을 실행시키고있는 파일명.py위치에 넣어두고 가져오기
df = pd.read_csv("C:/Users/fsm12/PycharmProjects/pythonTest_individual/pokemon.csv")

# 'Type 1'과 'Type 2' 둘중 하나가 원하는 속성이면 가져온다.
fire = df[(df['Type 1']=='Fire') | ((df['Type 2'])=='Fire')]
water = df[(df['Type 1']=='Water') | ((df['Type 2'])=='Water')]

# 그래프 만들기
fig, ax = plt.subplots()
ax.scatter(fire['Attack'], fire['Defense'], color='r', label = 'Fire', marker="*", s=50)
ax.scatter(water['Attack'], water['Defense'], color='b', label = 'Water', s=25)
ax.set_xlabel("Attack")
ax.set_ylabel("Defense")
ax.legend(loc="upper right")

# 그래프 그려서 보여주기
plt.show()]

'AI > Edu' 카테고리의 다른 글

[ 2021 NIPA AI - 기본 ] 3. 공공데이터를 활용한 파이썬 데이터분석 프로젝트 - 2. 지하철 승하차 인원 정보를 활용한 역별 혼잡도 분석 (0)	2021.12.16
[ 2021 NIPA AI - 기본 ] 3. 공공데이터를 활용한 파이썬 데이터분석 프로젝트 - 1. 코로나 데이터 분석하기 (0)	2021.12.16
[ 2021 NIPA AI - 응용 ] 2. 딥러닝 시작하기 (01~05) + α (0)	2021.12.13
[ 2021 NIPA AI - 응용 ] 1. 머신러닝 시작하기 (01~05) + α (0)	2021.12.11
[ 2021 NIPA AI - 기본 ] 1. 핵심 파이썬 기초 프로그래밍 (01~05) + α (0)	2021.10.19