데이터 분석 부트 캠프/학습 일지

[패스트캠퍼스] BDA 부트캠프 학습일지_4주차

이-다은 2023. 7. 13. 15:46
4주차 (0710-0714)
패스트캠퍼스 데이터 분석 부트캠프

 

 

 데이터 분석을 위한 핵심 Tool, Python(김상모 강사님) 

리스트 수정 기능

In : .append()  →  요소 추가

Out : .pop()  →  요소 삭제

 

- 파이썬의 자료 구조

스택: LIFO (Last in First out) or FILO (First in Last out) 구조 

 

: FIFO (First in First Out) or LILO (Last in Last Out) 구조

 


Formatting

#1. %연산자로 포메팅
a,b = map(int, input('정수를 두 개를 입력하세요: ').split())
c=a+b
print('%d + %d = %d 입니다' % (a,b,c))
>>> 정수를 두 개를 입력하세요: 40 17 >>> 40 + 17 = 57 입니다

#2. .format()으로 포메팅
print(' Hello, {0} {2} {1} '.format('python','script', 3.6))
>>> Hello, python 3.6 script

#3. f ' '으로 포메팅
language='python'
version=3.6
print(f'Hello, {language} {version}')
>>> Hello, python 3.6 

 


람다 표현식

f = lambda x : x+10    ''' :를 기준으로 왼쪽에는 매개변수를 정의하고, 오른쪽에는 함수를 작성한다.
f(1)

# x값이 한 개 일 때,
(lambda x : x+10)(1)     ''' 람다 표현식을 괄호 안에 정의하고, 뒤에 x값을 넣으면 바로 f(1) 출력이 나온다.

# x값이 여러 개 일 때,
a = [1,2,3,4,5,,,,]
list(map(lambda x : x+10, a))

# 매개변수가 여러 종류 일 때,
a=[1,2,3,4,5,,,,]
b=[2,4,6,8,10,,,,]
list(map(lambda x,y : x * y, a,b))

 

람다 표현식의 활용 방법

#1. 조건식 적용하기
list(map(lambda x: str(x) if x%3 == 0 else x ,a ))    ''' 뜻: if 식이 맞다면 str(x), 틀리다면 x로 적용하겠다.

#2. 필터 처리하기
a= [8,4,2,6,4,9,2,10]
list(filter(lambda x : x>5 and x<10, a))
>>> [8, 6, 9]

#3. 누적되어 연산하기
from functools import reduce
a = [1,2,3,4,5]
reduce(lambda x,y : x+y, a)

 


변수의 사용 범위

▷  def foo(): 밖의 변수는 전역 변수(1), 안의 변수는 지역 변수(2)임.

 

▷  다음과 같이 전역 변수, 지역 변수가 함께 쓰일 수 있음.

또한, 함수 안에 global x를 정의함으로써 전역 변수의 갱신이 가능함

 

▷  함수 안에 함수가 있는 경우, 각 함수에 지역 변수가 존재함.

함수 밖의 지역 변수에 대해 값을 변경하고자 하면 nonlocal을 사용해야 됨.

첫 번째의 경우에는 A의 지역 변수에 20을 할당함. 즉, x = 10 → 20 으로 갱신됨.

두 번째의 경우에는 x = 10 → 20 20+30, y = 100 → 100  100+300 으로 갱신됨.

 

클로저 사용하기

클로저 : 프로그램의 흐름을 특정 변수에 저장하고 싶을 때 사용함

아래 식에서는 c가 클로저가 됨.

 


파일의 입출력

파일 처리의 3단계

파일 열기 → 파일 읽기 및 쓰기 파일 닫기

1. 파일 열기

  • a(변수명) = open( '파일 위치', 'r' / 'w' / 'a' )

 

2. 파일 읽기 및 쓰기

# 코드 여러 번 반복해서 쓰기
b = a.readline()
print(b)

# While문으로 한 번 쓰기 (간단화)
b = " "
while True:
   b = a.readline()
   if b == ' ':
       break
   print(b, end ='')

# readline과 readlines의 차이
readline : 한 줄만 나옴 / readlines : 몇 줄이든 있는 문장 다 나옴

# readlines (원래 결과: aa\n bb\n)으로 한 줄씩 띄어 나오도록 (aa    bb )
inFP = None
inList = []
inStr = ''
inFP = open('C:/data/data1.txt','r',encoding='utf-8')
inList = inFP.readlines()
for inStr in inList:
     print(inStr, end ='')

 

3. 파일 닫기

  • a.close()

 


Tkinter 라이브러리

1. 

2. 

3. 이벤트

  • 버튼을 눌렀을 때 'Pushed' 출력됨.

4. 이벤트

  • label.config → 버튼을 눌렀을 때 라벨명이 Push Button에서 Pushed로 변함.

5. 이벤트

  • 전역변수 활용하여 Apple / Orange 번갈아가면서 라벨명 변경

첫 클릭: Apple → 두 번째 클릭: Orange → 세 번째 클릭: Apple → ...

6. 이벤트

  • 마우스 커서가 버튼을 벗어 났을 때 라벨명 변경 → btn.bind 안에 '<Leave>' 쓰면 이벤트 적용
  • 마우스 커서가 버튼 안에 들어갈 때 라벨명 변경 → btn.bind 안에 '<Enter>' 쓰면 이벤트 적용

왼: 커서가 밖으로 나갔을 때

7. radiobutton 만들기

  • rbvar로 같은 문자열 지정하면 rb1, rb2가 세트로 쌍을 이룰 수 있다.
  • indicatoron: radiobutton의 옵션

8. Scale 만들기

 

 

 

머리,,아프다,,,머리머리,,,,

너무나 많은 정보가 쏟아져버렸다,,,,,,ㅠ

 


0713 실강 부분

Numpy

list : 속도 느림

-> Numpy : 다차원의 배열 구조 사용 ∴ 속도 빨라짐 ( 수치해석용 파이썬 패키지 )

 

임포트 import numpy as np

 

벡터화 연산

data = [0,1,2,3,4,5,6,7,8,9]
#1. list
answer = []
for i in data:
    answer.append(2 * i)
answer
>>> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]     ''' 값으로 빼내서 사칙연산해야 됨

numpy
x = np.array(data)
x*2
>>> array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])   ''' 배열에서 사칙연산 가능 (빠르다)
---------------------------------------------------------------------------------------------------------------
#2. list
list_a=[1,2,3]
list_b=[10,20,30]
2*list_a+list_b
>>> [1, 2, 3, 1, 2, 3, 10, 20, 30]    ''' 단순히 list a 두 번, list b 한 번

numpy
a=np.array([1,2,3])
b=np.array([10,20,30])
2*a+b
>>> array([12, 24, 36])    ''' 벡터화 연산이 가능

 

2차원 배열

행렬 : 행 * 열

c = np.array([[0,1,2],[3,4,5]]) 
>>> array([[0, 1, 2],
                  [3, 4, 5]])

# 행 갯수
len(c)      >>> 2   ( 요소 [ ] * 2 = 2개 )

# 열 갯수
len(c[0])   >>> 3   ( 즉, [0,1,2]의 요수 개수 = 3개 )

 

3차원 배열 

d = np.array([[[1,2,3,4],
[5,6,7,8],
[9,10,11,12]],
[[11,12,13,14],
[15,16,17,18],
[19,20,21,22]]]) 

print(d.ndim)    # 배열의 차원 >>> 3
print(d.shape)  # 배열의 크기 >>> (2, 3, 4)

 

배열 슬라이싱

a = np.array([[0,1,2,3],
                     [4,5,6,7]])
a[0,:] # 첫 행 전체  >>>  array([0, 1, 2, 3])
a[:,1] #둘째 열 전체  >>> array([1, 5])
a[1,1:] # 둘째 행 전체,둘째 열부터 >>> array([5, 6, 7])

 

배열 인덱싱

a=np.array([0,1,2,3,4,5])
idx=np.array([True,False,True,False,True,False])
a[idx] 
>>> array([0, 2, 4])

np.array([0,1,2]) [ np.array([True,False,True])]
>>> array([0, 2])

 

조건문 연산

(a % 2) == 0
>>> array([ True, False, True, False, True, False])

+ 배열 인덱싱 :
a[(a%2)==0]   >>> array([0, 2, 4])
x=np.array(range(1,21))
x[(x%3==0) & (x%4 ==1)]  >>>  array([9])

Pandas

  • Series  = 값 + 인덱스
    • 데이터 형태 1차원
    • (Numpy와 차이:) 데이터의 의미를 표시하는 인덱스 붙일 수 있음 (미지정시 0,1,2,,로 됨)
  • DataFrame 

 

임포트 import pandas as pd

 

1. 시리즈

s=pd.Series([9904312,3448737,2890451,2466052],
                     index = ['서울','부산','인천','대구'])
s.name = '인구'
s.index.name = '도시'        '''시리즈 및 인덱스에 이름 지정
# 시리즈 연산
s/1000000  >>> 서울 9.904312 부산 3.448737 인천 2.890451 대구 2.466052

# 시리즈 인덱싱
s[1], s['부산'] >>> 3448737
s[3], s['대구'] >>> 2466052
s[[0,2,1]]  >>> 서울 9904312 인천 2890451 부산 3448737 (시리즈 전체 출력됨)
s[(250e4 < s) & (s < 500e4)]  >>> 부산 3448737 인천 2890451 (조건문 참인 부분의 시리즈 출력)

# 시리즈 슬라이싱
s[1:3]  >>> 부산 3448737 인천 2890451 (숫자: 1~2행)
s['부산':'대구']   >>> 부산 3448737 인천 2890451 대구 2466052  (문자: '부산'~'대구' 까지)

# 라벨 값이 영문 문자열일 경우 → 점으로 접근 가능 (.a)
s0 = pd.Series(range(3), index = ['a', 'b', 'c'])
s0.a   >>> 0

# .items()
for i,j in s.items():
        print('%s = %d' % (i,j))
>>> 서울 = 9904312  부산 = 3448737  인천 = 2890451  대구 = 2466052


# 딕셔너리형 시리즈
s2 = pd.Series({'서울':8804312, '부산': 9948737, '인천':6690451,'대전':1166052},
                          index =['부산','서울', '인천','대전',])

# 인덱스 기반 연산
ds = s-s2 >>>  대구 NaN 대전 NaN 부산 -6500000.0 서울 1100000.0 인천 -3800000.0 
(대구,대전 안겹쳐서 NaN, 나머지는 s 값 - s2 값)

* 인구 증가율(%) 구하기
rs = (s-s2) / s2 * 100
rs = rs[rs.notnull()]     >>>  부산 -65.334926 서울 12.493878 인천 -56.797367

# 데이터의 갱신, 추가, 삭제
갱신: rs['부산'] = 1.63   >>>  부산 1.630000 서울 12.493878 인천 -56.797367
추가: rs['대구'] = 1.41   >>>  부산 1.630000 서울 12.493878 인천 -56.797367 대구 1.410000
삭제: del rs['서울']   >>>  부산 1.630000 인천 -56.797367 대구 1.410000

 

2. 데이터프레임

data = { "2015": [9904312, 3448737, 2890451, 2466052],
      "2010": [9631482, 3393191, 2632035, 2431774],
      "2005": [9762546, 3512547, 2517680, 2456016],
      "2000": [9853972, 3655437, 2466338, 2473990],
      "지역": ["수도권", "경상권", "수도권", "경상권"],
      "2010-2015 증가율": [0.0283, 0.0163, 0.0982, 0.0141] } 
columns = ["지역", "2015", "2010", "2005", "2000", "2010-2015 증가율"] 
index = ["서울", "부산", "인천", "대구"] 
df= pd.DataFrame(data, index=index, columns=columns)
# 값, 칼럼, 인덱스 출력
df.values, df.columns, df.index

# 칼럼, 인덱스 전환
df.T

# 열 시리즈의 갱신, 추가, 삭제
갱신: df['2010-2015 증가율'] = df['2010-2015 증가율'] * 100
추가: df['2005-2010 증가율'] = ((df['2010']-df['2005'])/df['2005']*100).round(2)
삭제: del df['2010-2015 증가율']

# 열 인덱싱
numpy array → DF으로 변환(자동 인덱싱)
df2 = pd.DataFrame(np.arange(12).reshape(3,4))
np_array =np.arange(12).reshape(3,4)
# reshape: np_array [:,2].reshape(3,1)   >>>  array([[ 2], 
                                                                                  [ 6],
                                                                                  [10]])

# 행 인덱싱
df[1:3]     ''' 1~2행 인덱싱

# 열/행 인덱싱
df['2015'][1:3]    ''' '2015'열 & 1~2행 인덱싱

시각화 패키지

임포트:  import matplotlib.pyplot as plt

#1
plt.title("x ticks")
plt.plot([10,20,30,40],[1,4,9,16])
plt.show()

#2
import numpy as np
X = np.linspace(-np.pi, np.pi, 256)
C = np.cos(X) plt.title("x,y tick label setting")
plt.plot(X,C)
plt.xticks([-np.pi, np.pi / 2,0,np.pi/2, np.pi])
plt.yticks([-1,0,+1])
plt.show()

Pandas로 외부 데이터 처리

1. 데이터 불러오기

import pandas as pd
df = pd.read_csv("C:/data/pima-indians-diabetes.csv",
               names = ["pregnant", "plasma", "pressure", "thickness", "insulin", "BMI", "pedigree", "age", "class"])

 

2. 데이터 조사

# 1, 2
# 3

#1. print(df.head(5))
#2. print(df.info())
#3. print(df.describe())

3. 데이터 가공하기 (분석 시작)

print(df[['pregnant','class']].groupby(['pregnant'],as_index=False).mean().sort_values(by='pregnant',ascending=True))

 

4. 그래프로 표현하기

#1
plt.figure(figsize=(12,12))
sns.heatmap(df.corr(), linewidths=0.1, vmax=0.5, cmap=plt.cm.gist_heat,linecolor='white',annot=True)

#2. df.corr()     

>>> 상관관계 알 수 있음
(그래프 : 진할수록 / 테이블 : -1,1 가까울수록 → 상관관계 높음)

 

5. 예측 정확도 높이기 위해 시도해보기

 


웹 크롤링

웹 페이지 긁어와서 데이터 추출

# 기본 설정
import requests
from bs4 import BeautifulSoup

# 웹페이지에서 text 추출
r=requests.get('https://wikidocs.net')
html = r.text
print(html)

# 웹페이지에서 제목 추출
res = requests.get('http://v.media.daum.net/v/20170615203441266')
soup = BeautifulSoup(res.content,'html.parser')   
 ''' res의 모든 content(매개변수)를 'html.parser'로 분석(html로 parsing) 후 soup에 넣음
title = soup.find('title')                                              ''' soup의 html에서 title 찾음
print(title.get_text())                                                ''' 그 중 text 읽음
>>> 잔금대출에도 DTI 규제 적용 검토

영화 링크 분석하기

import requests
response = requests.get('https://movie.daum.net/ranking/reservation')
html = response.text
print(html)            # html 코드 보기

from bs4 import BeautifulSoup     # beautiful soup 활용 크롤링
soup = BeautifulSoup(html, 'html.parser')
Title_html = soup.select('a[class=link_txt]')
for tag in soup.select('a[class=link_txt]'):
        print(tag)
for tag in soup.select('a[class=link_txt]'):
          print(tag.text)     # 제목만 가져오기

 

 

 


 데이터 분석을 위한 핵심 Tool, Python(온라인 강의) 

초격차 패키지 : 직장인을 위한 파이썬 데이터 분석

 

Pandas

Pandas 라이브러리 사용하기 위해 : import pandas as pd (임포트 코드 삽입)

 

입력하기 ( Ch 2 - 5 )

1. 직접 입력하는 방법

#1. 리스트로 만들기
mylists = [['야구', '류현진', '22,300,000,000'],
           ['축구', '손흥민', '15,000,000,000'],
           ['롤', '페이커', '5,200,000,000']]
df = pd.DataFrame(mylists, columns=['종목', '이름', '연봉'])

#2. 딕셔너리로 만들기
mydict = {'종목': ['야구', '축구', '롤'],
          '이름': ['류현진', '손흥민', '페이커'],
          '연봉': ['22,300,000,000', '15,000,000,000', '5,200,000,000']}
df = pd.DataFrame(mydict)

 

2. 파일 load해서 읽고 쓰는 방법 (csv, excel)

#1. csv 파일
# 불러오기
csv_path = ' 파일의 경로 '
df = pd.read_csv(csv_path)            ''' df.head() 로 잘 불러왔는지 확인 가능, ( )사이 n 써서 n개 값만 가져옴
# 저장하기
csv_path = ' 저장할 경로 '
df.to_csv(csv_path)

#2. excel파일
# 불러오기
excel_path = ' 파일의 경로 '
df = pd.read_excel(excel_path)
# 저장하기
excel_path = '  저장할 경로 '
df.to_excel(excel_path)

 

3. 크롤링 테이블 읽기

import requests
site = 'https://dbkpop.com/db/all-k-pop-idols'      ''' 사이트의 주소
r = requests.get(site)

df = pd.read_html(r.text)[0]
df.columns = df.columns.get_level_values(0)

데이터 슬라이싱 ( Ch 2 - 6 )

1. 행 선택하기

df [ 행 시작 인덱스 : 행 끝 인덱스+1 ]

 

2. 열 선택하기

  • 열 하나 가져오기
    • df[' 컬럼명 ']
    • df.컬럼명        (BUT. 컬럼명에 공백 있으면 에러)
  • 열 여러개 가져오기
    • df[[ '컬럼1', 컬럼2', ... ]])
  • 범위 설정으로 열 여러개 가져오기
    • df[df.columns[시작인덱스:끝인덱스]]

 

3. *** loc, iloc 사용해서 편하게 조회하기 → 많이 사용 !!

 

기본 특징

  • 데이터 조작을 쉽게 만들어주는 유용한 메소드임.
    • 인덱싱 방식 → 다양한 전처리 기능 ( 데이터 읽기/쓰기, 슬라이싱 등 )
    • 조건문 활용  쿼리(SQL) 문과 같이 원하는 조건에 맞는 데이터를 추출 가능
    • 인덱스를 사용해 바로 찾아내는 (Vectorization) 방식  매우 검색이 빠름
  • 기본형
    • df.loc[ '행 슬라이싱 영역' , '열 슬라이싱 영역' ]
    • df.iloc[ '행 슬라이싱 영역' , '열 슬라이싱 영역' ]

 

- loc

1. 특정 행 조회

df.loc[ [1,3,8,,,] ]   or    df.loc[ [1:10] ]  
or     df.loc[ ['컬럼명1', '컬럼명2', '컬럼명3',,,] ] 

# 문자열 인덱스로 변경
loc_df = df.copy()
loc_df.index = loc_df['Korean Name']

 

2. 조건문을 사용한 행 조회

df.loc[ '조건문' ]
ex/ df.loc[ df['Height'] >=160 ]

 

3. 특정 열 조회

df.loc[ :, [1,3,8,,,] ]   
or    df.loc[ :, ['컬럼명1', '컬럼명2', '컬럼명3',,,] ] 

 

4. 조건문을 사용한 열 조회

df.loc[ : , '조건문']
ex/ df.loc[ :, df.columns != 'Korean Name']

 

5. 행, 열 조건 조합

df.loc[ df['Korean Name'] == '임윤아', df.columns == 'Height']     ''' 행 : 임윤아 & 열 : Height 인 값을 출력

 

- iloc

행과 열의 데이터를 조회할 때 '숫자 인덱스(integer index)' 을 통해 접근하는 방법

 

1. 특정 행 조회

iloc_df.iloc[ [1,3,8,,,] ]   
or        iloc_df.iloc[ [1:10 ]   

 

2. 특정 열 조회

iloc_df.iloc[ :, [1,3,8,,,] ]   
or    iloc_df.iloc[  : , [1:10] ]   

 

4. Boolean Indexing, isin()

참/거짓 여부를 판단해서 특정 조건이 맞는 데이터만 추출

 

#1. Boolean Indexing
df.loc[df[' Height ']>160]

#2. isin() 을 활용한 색인
group_name = ['SNSD',,,,]       # 리스트 지정
df.loc[df[' Group '].isin(group_name)]

 

5. 행(row), 열(column) 추가 및 삭제

1. 행 추가 : df.append( 추가할 행, ignore_index=True )

  • 인덱스를 무시하는 옵션 ignore_index=True 을 반드시 추가
  • 추가 행 : dict 또는 Series/DataFrame 타입
#1. 딕셔너리로 행 추가
new_row = {'Stage Name': 'FastCampus',
           'Full Name': 'Fast Campus', ... }
df = df.append(new_row, ignore_index=True)
#2. 시리즈로 행 추가
df.append(df.iloc[-1])       ''' 시리즈 타입의 마지막 행을 추가

 

2. 열 추가 : df['추가할 열 이름'] = [ '열에 대입할 값 리스트' ]

  • 추가 열 : list 또는 Series 타입
# 리스트로 열 추가
df['Blood Type'] = 'A'

 

3. 행/열 삭제 

  • 행 삭제 : df.drop(index=['삭제 하려는 행 인덱스'])
  • 열 삭제 : df.drop(columns=['삭제 하려는 열 이름'])
# 행 삭제
df = df.drop(index=[10,11,12])

# 열 삭제
df = df.drop(columns=['Blood Type'])

 


통계값 계산 및 정렬 ( Ch 2 - 7 )

1. 요약 정보 확인 

  • df.info()    →   전체 레코드 수, 없는 값 (Null 값) 과 컬럼 수, 데이터 타입 등을 확인
  • df.shape    →     (행 수, 열 수)로 행과 열 정보 확인
  • df.head(), df.tail()    →    앞에서, 뒤에서 n개의 값을 알 수 있음
  • df.describe()    →     요약 통계 정보를 확인.
    • 갯수(count), 평균(mean), 표준편차(std), 최소값(min), 1사분위수(25%), 2사분위수(50%), 3사분위수(75%), 최대값(max)

 

2. 데이터프레임 정렬하기

1. 인덱스 기준 정렬

# 오름차순 
df.sort_index()

# 내림차순 
df.sort_index(ascending=False)

 

2. 값 기준 정렬

# 특정 컬럼 기준으로 오름차순
df.sort_values(by='Height')

# 특정 컬럼 기준으로 내림차순
df.sort_values(by='Height', ascending=False)

 

3. 복수 값 기준 정렬

  • 첫번째 값을 기준으로 우선 정렬을 하고, 그 다음 컬럼을 기준으로 정렬되어가는 형태
# 오름차순 
df.sort_values(by=['Height', 'Weight'])

# 내림차순 
df.sort_values(by=['Height', 'Weight'], ascending=False)

# 칼럼별로 다르게 지정
df.sort_values(by=['Height', 'Weight'], ascending=[True, False])

피벗 테이블, 그룹 통계 ( Ch 2 - 8 )

1. 피벗 테이블

pd.pivot_table(df, index = '행 인덱스', columns = '열 인덱스', values = '조회하고 싶은 값', aggfunc='집계 방식')

#1. 행: Group, 열: Country일 때 Height의 평균
pd.pivot_table(df, index='Group',  columns='Country',  values='Height',  aggfunc='mean')

#2. 행: Group, 열: Country일 때 Height의 수
pd.pivot_table(df, index='Group',  columns='Country',  values='Height',  aggfunc='count')

 

2. 그룹 통계 (group by)

  • 그룹으로 묶는기준 (예: 성별, 나이, 혈액형 등) 에 따라 합계, 평균, 분산, 최대/최소 값 등 그룹 통계 계산
  • 기본 사용법
    • df.groupby('그룹 구분').count() - 갯수
    • df.groupby('그룹 구분').sum() - 합계
    • df.groupby('그룹 구분').mean() - 평균
    • df.groupby('그룹 구분').var() - 분산
    • df.groupby('그룹 구분').std() - 표준편차
    • df.groupby('그룹 구분').min()/.max() - 최대/최소값
#1. 한 개의 그룹을 지정
df.groupby('Group').mean()

''' 특정 컬럼만 보고 싶을 경우
df.groupby('Group')['Height'].mean()

#2. 여러 개의 그룹을 지정
df.groupby(['Group', 'Country']).mean()

''' 인덱스 분할 ( Group, Country 열 또한 값으로 들어가고 숫자 인덱스 생성됨 )
df.groupby(['Group', 'Country']).mean().reset_index()

#3. 그룹 데이터 확인
df.groupby('Group').groups                                   >> 딕셔너리형{}으로 확인됨
df.groupby('Group').get_group('BLACKPINK')      >> 테이블형으로 확인됨

#4. 그룹 집계 방식 구분하기 (agg())
df.groupby('Group').agg({'Height': 'mean', 'Weight' : 'sum'})

데이터 합치기 ( Ch 2 - 9 )

1. Join

df1.join(df2, on='키 인덱스', how='조인 방법', sort='정렬 여부')

* Join 사용하기 위해 키로 지정할 열을 '인덱스화' 시켜줘야 함. →  set_index('키로 지정할 열')

 

#1. Left Join
df1.join(df2.set_index('Korean Name'), on='Korean Name', how='left')

#2. Right Join
df1.join(df2.set_index('Korean Name'), on='Korean Name', how='right')

#3. Inner Join
df1.join(df2.set_index('Korean Name'), on='Korean Name', how='inner')

#4. Outer Join
df1.join(df2.set_index('Korean Name'), on='Korean Name', how='outer')

 

2. Merge **

  • Join 에서 겹치는 인덱스를 따로 지정해 주어야 하는 작업이 없어짐
  • 단지 두 개 이상의 겹치는 컬럼만 있으면 O
  • pd.merge(df1, df2, on='키 컬럼', how='조인 방법', sort='정렬 여부')
#1. Left Merge
pd.merge(df1, df2, on='Korean Name', how='left')

#2. Right Merge
pd.merge(df1, df2, on='Korean Name', how='right')

#3. Inner Merge
pd.merge(df1, df2, on='Korean Name', how='inner')

#4. Outer Merge
pd.merge(df1, df2, on='Korean Name', how='outer')

 

3. Concat

두 개의 데이터 프레임(DataFrame) 을 단순히 붙이는 방법 (위의 Join, Merge 개념과 다른 개념!)

  • concat 은 행이나 열 방향으로 데이터 프레임을 붙일 수 있음
  • 행 방향 붙이기 (axis=0), 열 방향 붙이기 (aixs=1)
  • 기본 사용법
    • pd.concat([df1, df2], axis='붙이는 방향')
#1. 행 방향 붙이기
pd.concat([df1,df2], axis=0)

#2. 열 방향 붙이기
pd.concat([df1,df2], axis=1)

#3. 겹치는 값만 붙이기 (join 활용)
pd.concat([df1,df2], axis=1, join='inner')

자료형 변환, 산술 연산 ( Ch 2 - 10 )

1. 자료형 변환

  •  Pandas 자료형 : 정수(int), 실수(float), 문자열(str), 일자시간타입(datetime) 
  • datetime: 날짜/시간 데이터 처리 가능 → 날짜 슬라이싱, 시간 연산 가능
    • df['컬럼명'].astype('변환하려는 자료형') 으로 데이터 자료형을 변환
    • 일자 시간 타입은 pd.to_datetime(df['컬럼명']) 함수로 손쉽게 변환이 가능
#1. int -> str 타입 변환
df['Height'] = df['Height'].astype('str')

#2. str -> int 타입 변환
df['Height'] = df['Height'].astype('int')

#3-1. str -> datetime 타입 변환
df['Date of Birth'] = pd.to_datetime(df['Date of Birth'])

#3-2. datetime 타입 으로 날짜 슬라이싱 (월, 일, 요일 등 날짜/시간 정보를 추출)
- 연도 추출:    df['Date of Birth'].dt.year
- 월 추출:        df['Date of Birth'].dt.month
- 일 추출:        df['Date of Birth'].dt.day
- 요일 추출:     df['Date of Birth'].dt.dayofweek
- 데이터 프레임에 추가:  df['Year of Birth'] = df['Date of Birth'].dt.year

 

2. 산술 연산

1. 사칙 연산

df['Height'] + df['Weight'] ,  df['Height'] - df['Weight'] ,  df['Height'] + 10 ,,,

 

2. 데이트타임(datetime) 연산

  • 더하고 빼는 값의 자료형이 시간 간격(pd.Timedelta) 이어야 함
    • pd.to_timedelta(df['컬럼명'], unit='시간 간격 단위')
    • 시간 간격 단위: 일(day), 시(hour), 분(min), 초(sec) 등
# pd.Timedelta 자료형으로 변환 
df['Day of Birth'] = pd.to_timedelta(df['Day of Birth'], unit="day")

# 데이트타임 연산
df['Date of Birth'] + df['Day of Birth']

 

3. 통계 연산

  • 합계(sum()), 평균(mean()), 최소/최대값(min(), max())
  • 행 계산 (axis = 0), 열 계산 (axis = 1)
# 행 합계:   df.sum(axis=0)
# 행 평균:   df.mean(axis=0)
# 열 합계:   df.sum(axis=1)
# 열 평균:   df.mean(axis=1)

결측값 / 중복 처리 ( Ch 2 - 11 )

1. 결측값 처리

  • 입력이 누락된 값 (현실의 거의 모든 데이터에는 결측값이 존재 가능)
  • 결측값을 어떤 방식으로 처리하느냐에 따라 데이터 분석 결과가 달라짐
    • NaN, N/A, NULL, 0값 등 다양한 방식
순서
#1. 데이터 탐색
df = df.replace(0, np.NaN)      ''' 0값을 NaN 형으로 변환

#2. 결측 데이터 확인 (isnull(), notnull())
df.isnull().sum()      ''' 결측인 값은 (True) 1로 처리

#3. 결측 데이터 제거 (dropna())      
df.dropna(subset=['Group', 'Height'])   ''' subset=['컬럼명'] 옵션 → 해당 컬럼만 검사

#4-1. 결측 데이터를 지정 값으로 대체 (fillna('대체값'))
df['Height'] = df['Height'].fillna(160)
#4-2. 평균 값으로 대체 (fillna('평균값'))
mean_value = df['Weight'].mean()
df['Weight'] = df['Weight'].fillna(mean_value)
#4-3. 최빈 값으로 대체 (fillna('최빈값'))
df['Birthplace'].value_counts().index[0]         ''' 값을 세어주는 함수 value_counts() 를 활용 →최빈값 구함
df['Birthplace'] = df['Birthplace'].fillna( df['Birthplace'].value_counts().index[0] )

#5. reset_index() 로 인덱스 재정렬 (전처리 중 df의 인덱스가 바뀌며 이 부분 정렬)
df = df.reset_index(drop=True)     ''' 'drop=True' 옵션은 이전의 인덱스를 버린다는 의미

 

2. 중복값 처리

  • 중복으로 입력된 값 (전체 행/열이 중복된 경우, 혹은 값이 중복된 경우)
  • 중복값을 어떤 방식으로 처리하느냐에 따라 데이터 분석 결과가 달라짐
순서
#1. 중복 데이터 탐색 (duplicated())
df[df.duplicated()]   ''' 중복된 행 찾기
df['Group'].duplicated()   ''' 특정 열에 중복 값 찾기

#2. 중복 데이터 제거 (drop_duplicates())
df.drop_duplicates()   ''' 기본적으로 완벽히 중복된 행 제거
df.drop_duplicates(subset= ['Group'])    ''' 특정 열을 기준으로 제거 (default: 첫 값 남기기)
df.drop_duplicates(subset= ['Group'], keep='last')     ''' 특정 열을 기준으로 제거 (마지막 값 남기기)

고급 기능 ( Ch 2 - 12 )

1. apply 함수 

  •  데이터에 구체적인 로직을 적용 하고 싶을 경우 사용
  • 로직이 정의된 함수를 만들고, apply() 함수에 대입
#1. 구체적인 로직이 정의된 함수 만들기
def replace_zero(x):
    if x==0:
        x=165   # 값이 0일 경우 원하는 값으로 대체
    return x

#2. apply 함수에 대입
df['Height']= df['Height'].apply(replace_zero)

 

2. lambda 함수 

  • 한줄로 간편하게 작성할 수 있음  ∴ def 함수명, return 등 복잡하게 작성하지 않아도 됨
  • 로직이 복잡하지 않을 경우 (사칙연산, 간단한 문자열 추출 등) 자주 사용
  • 기본 사용법
    • lambda '입력변수': '리턴값' '조건문(옵션)'
df['Weight']= df['Weight'].apply(lambda x: 50 if x==0 else x)   ''' x=0일 때만 50으로 함수

# 집계된 컬럼 만들기
df['Weight/Height']= df.apply(lambda x: x['Weight']/x['Height'], axis=1)

 

3. map 함수 

  • 데이터 값을 특정한 값으로 매핑(mapping) 하고 싶은 경우 사용
  • 반복문을 작성하면서 값을 치환하는 방법보다 효율적임. (속도 빠르고 코드 간결)
  • (주의!) 하나의 컬럼인 Series 형으로만 적용 가능
  • 기본 사용법
    • df['컬럼명'].map('매핑 정보')
map_info = {'M' : '남자',
                     'F' : '여자'}
df['Gender'] = df['Gender'].map(map_info)     ''' 매핑 정보를 적용함 (M →남자, F→여자 변환)

데이터 프레임 시각화 ( Ch 2 - 13 )

  • 데이터 집합을 도표나 그래프로 표시하는 것
  • 파이썬에서는 여러 라이브러리(matplotlib, seaborn, pyplot 등)에서 시각화 코딩을 할때 자주 사용
    • Pandas 의 plot 은 matplotlib 의 plot 을 임포트해서 사용하는 것
  • Pandas 의plot 은 kind 라는 옵션으로 다양한 그래프를 시각화 
    • kind 옵션 인자값: 라인형(line), 바형 (bar), 히스토그램(hist), 박스형(box), 파이형(pie), 산점도(scatter), 영역형(area)

 

1. 라인형(line)

df1.plot(kind='line', figsize=(15,5), title='펭귄 라인 그래프')

# 특정 칼럼값만
df1['flipper_length_mm'].plot(kind='line', figsize=(15,5), title='펭귄 날개(지느러미) 길이')

 

2. 바형 (bar)

bar_df.plot(kind='bar', figsize=(15,5), title = '펭귄종 별 평균')

# 전치 연산(x, y축 변환)
bar_df.T.plot(kind='bar', figsize=(15,5), title = '펭귄 특성 별 평균')

 

3. 히스토그램(hist)

df1.plot(kind='hist', figsize=(15,5), title = '펭귄 특성 별 빈도수')

# 빈(bin) 개수 지정
df1.plot(bins=20, kind='hist', figsize=(15,5), title = '펭귄 특성 별 빈도수')

 

4. 박스형(box)

df1.plot(kind='box', figsize=(15,5), title = '펭귄 특성별 값 범위')

 

5. 파이형(pie)

pie_df = df2['pclass'].value_counts()  ''' 선실별 승객 수 구하기
pie_df.plot(kind='pie', figsize=(15,8), title = '선실 별 승객 수 비율')

# 레이블 추가
pie_df.plot(kind='pie', figsize=(15,8), title = '선실 별 승객 수 비율', autopct='%.1f%%', fontsize=20)

 

6. 산점도(scatter)

df2.plot(kind='scatter', figsize=(15,8) , x='age', y='fare', title='나이에 따른 타이타닉 승선 요금')

# 버블차트 (선실 정보 추가: 클수록 p class)
df2.plot(kind='scatter', figsize=(15,8) , x='age', y='fare', title='나이에 따른 타이타닉 승선 요금',s=df2['pclass']*100)

 


matplotlib

 

matplotlib 구성 요소 및 기본 그래프 (ch 3-2)

그래프 유형별 시각화 (ch 3-3)

bar형 : plt.bar(x, y)  /  가로로 그리기 - plt.barh(x, y) 

pie형 : plt.pie(카테고리 값)

히스토그램 : plt.hist(발생하는 값)

산점도 : plt,scatter(x,y)


seaborn

Matplotlib에서 색상 테마 / 통계용 차트 기능을 추가한 시각화 라이브러리

matplotlib과 seaborn , 그래프 유형별 시각화 (ch 3-5~6)

1. 기본/통계형 그래프

sns.relplot(x, y) : 라인그래프, 산점도를 모두 그릴 수 있음.

sns.lmplot(x, y) : 선형 회귀 관계 보여줌. 적합된 회귀선을 같이 표현.

sns.countplot(x, data) : 카테고리 값을 셀 수 있음.

sns.distplot(x) : 히스토그램, 추정된 확률 밀도 함수 표시 기능 O (kde = True)

sns.heatmap(a.corr()) : 상관관계 / pivot 테이블 시각화

sns.catplot(x, y, data) : 카테고리형 변수 시각화

 

2. 다차원 그래프

sns.pairplot() : 여러 데이터 차원에 대한 산점도 / 히스토그램 확인

 

3. 복합 그래프

sns.jointplot(data, x, y) : 산점도 / 히스토그램 동시에 확인

 

> 컬러팔레트 제공 sns.color_palette()  →  sns.''plot() 중 ()안에 palette = 'rainbow' / 'Reds' 등 입력

 

 

+ matplotlib과 같이 사용될 수 있음.