[엑셀자동화with파이썬] Pandas 라이브러리

| Pandas as pd : 표 데이터 처리

1. Series | 라벨(인덱스) 있는 1차원 데이터 생성 -> 리스트형

 - 구조: pd.Series(data[, index = index_data])

 - pd.Series.index # 인덱스 호출

ex) RangeIndex(start = 0, stop = 5, step = 1)

 - pd.Series.values # 값 호출

ex) array([10, 20, 30, 40, 50], dtype=int64)

 

2. date_range | 날짜 자동 생성

 - 구조: pd.date_range(start = None, end = None, periods = None, freq = 'D') # 날짜 자동 생성

 

3. reindex | index 재배열

 - 구조: pd.Series/DataFrame.reindex(self, labels = None, index = None, columns = None, axis = None, method = None, copy = True, level = None, fill_value = nan, limit = None, tolerance = None)

 - reindex([4, 2, 5, 3, 1]) # 인덱스 재배열

 - reindex(columns=['B', 'C', 'A']) # 열 재배열

 

4. DataFrame | 행과 열 표 형식으로 출력

 - 구조: pd.DataFrame(data[, index = index_data, columns = columns_data])

 - pd.DataFrame(dict)

 - pd.DataFrame(data, index, columns)

 - pd.DataFrame.index # 인덱스 호출

 - pd.DataFrame.columns # 열 호출

 - pd.Data.values # 값 호출

---

| CSV 파일 읽고 쓰기

1. read_csv | CSV 파일을 읽어와서 DataFrame 데이터 생성

 - 구조: pd.read_csv(file_name[, encoding = 인코딩_방식, index_col = 열_이름 혹은 숫자, header = 숫자(기본: 0) 혹은 None, sep = 구분자(기본: ','), names = 열_이름_리스트 ])

 - encoding: default = utf8

 - index_col: default = 0

 - header: default = 0

 - sep: 구분자, default = ','

 - header = None # CSV 파일에 열 이름이 없어서 지정하는 경우

 - header = 0 # CSV 파일의 첫 줄에 열 이름이 있지만 변경하고 싶은 경우

 - names = 새로운 열 이름 리스트

 

2. to_csv | DataFrame 데이터를 CSV 파일로 쓰기

 - 구조: pd.to_csv(file_name[, encoding = 인코딩_방식, index = True(기본) 혹은 False, header = True(기본) 혹은 False, sep = 구분자(기본: ',') ])

 - encoding: 인코딩 방식

 - index: DataFrame의 index를 csv 파일에 포함할지 여부 결정

 - header: DataFrame의 coumlns(열 이름)를 csv 파일에 포함할지 여부 결정

 - sep: 생성할 텍스트 파일의 구분자 지정

---

| 엑셀 파일 읽고 쓰기

1. read_excel | 엑셀 파일 읽기

 - 구조: pd.read_excel(excel_file[, sheet_name = 시트_이름(기본: 'Sheet1') 혹은 시트 번호(기본: 0), index_col = 숫자 혹은 열_이름, header = 숫자(기본: 0) 혹은 None, names = 열_이름_리스트 ])

 - sheet_name: 엑셀 파일의 워크시트를 시트 이름 혹은 시트 번호로 지정

 - index_col: 엑셀 파일의 워크시트에 있는 데이터 중 특정한 열을 DataFrame의 index로 지정

 - header: 엑셀 파일의 워크시트에 있는 데이터 중 특정한 행을 DataFrame의 columns(열 이름)로 지정

 - header = None # 엑셀 파일에 열 이름이 없어서 지정하는 경우

 - header = 0 # 엑셀 파일의 첫 줄에 열 이름이 있지만 변경하고 싶은 경우

 

2. to_excel | 엑셀 파일로 쓰기

 - 구조: pd.to_excel(excel)file[, index = True(기본) 혹은 False, header = True(기본) 혹은 False, sheet_name = 시트_이름(기본: 'Sheet1') 혹은 시트_번호(기본: 0), startrow = 숫자(기본: 0), startcol = 숫자(기본: 0) ])

 - index: 엑셀 파일에 DataFrame 데이터의 index 포함할지 여부 결정

 - header: 엑셀 파일에 DataFrame 데이터의 columns(열 이름) 포함할지 여부 결정

 - sheet_name: 엑셀 파일의 워크시트를 시트_이름 혹은 시트_번호로 지정

 - startrow: 워크시트에 DataFrame 데이터가 써질 왼쪽 상단 행(row) 위치를 0번부터 시작하는 숫자로 지정

 - startcol: 워크시트에 DataFrame 데이터가 써질 왼쪽 상단 열(column) 위치를 0번부터 시작하는 숫자로 지정

 

알아두기! 

파이썬이나 자바 등의 언어에서는 배열이나 리스트의 인덱스 첫 시작이 0이다.

엑셀의 좌표도 (0, 0)부터 시작하므로, 위치를 입력할 때 참고하기 바람!!

 

3. 하나의 엑셀 파일에 여러 개의 DataFrame 데이터 쓰기 | ExcelWriter 응용

# 1) 쓰기 엔진을 xlsxwriter로 지정해 판다스의 ExcelWriter로부터 객체(excel_writer)를 생성

excel_writer = pd.ExcelWriter(excel_file, engine = 'xlsxwriter')

 

# 2) 생성한 객체(excel_writer)를 이용해 DataFrame 데이터(df)를 쓰기

df.to_excel(excel_writer[, 
                    index = True(기본) 혹은 False, 
                    header = True(기본) 혹은 False, 
                    sheet_name = 시트_이름(기본: 'Sheet1') 혹은 시트_번호(기본: 0), 
                    startow = 숫자(기본: 0),  
                    startcol = 숫자(기본: 0) ])

 

# 3) 객체를 닫고 엑셀 파일로 저장

excel_writer.save()

---

# 1) with 문으로 간단히 사용도 가능!

with pd.ExcelWriter(excel_file, engine = 'xlsxwriter') as excel_writer:
        df.to_excel(excel_writer[, 
                            index = True(기본) 혹은 False, 
                            header = True(기본) 혹은 False, 
                            sheet_name = 시트_이름(기본: 'Sheet1') 혹은 시트_번호(기본: 0), 
                            startow = 숫자(기본: 0),  
                            startcol = 숫자(기본: 0) ])

주의!! to_excel()를 이용해 엑셀 파일 쓰기를 수행할 때 생성할 엑셀 파일이 열려 있으면 오류가 발생하므로 반드시 먼저 닫아야 한다.

 

---

| 표 데이터 연산

1. 표 데이터 기본 연산

연산을 할 수 있는 요소끼리만 연산을 수행하고 연산할 수 없는 요소는 NaN으로 반환

1.1 Series 데이터 연산

import pandas as pd

# Series 데이터 생성
s1 = pd.Series([10, 20, 30, 40, 50]) 
s2 = pd.Series([1, 2, 3, 4])

s1 + s2 # Series 데이터끼리 더하기
s1 -  s2 # Series 데이터끼리 빼기
s1 * s2 # Series 데이터끼리 곱하기
s1 / s2 # Series 데이터끼리 나누기
s1 + 5 # value의 각 요소에 상수 더함
s1 ** 2 # value의 각 요소에 거듭제곱
s1 > 30 # value의 각 요소에 비교 연산

1.2 DataFrame 데이터 연산

# DataFrame 데이터 생성
dict_data1 = {'A': [1, 2, 3, 4, 5],
              'B': [10, 20, 30, 40, 50],
              'C': [100, 200, 300, 400, 500]}
df1 = pd.DataFrame(dict_data1)

dict_data2 = {'A': [6, 7, 8, 9],
              'B': [60, 70, 80, 90],
              'D': [600, 700, 800, 900]}
df2 = pd.DataFrame(dict_data2)

df1 + df2 # DataFrame 데이터끼리 더하기
df1 - df2 # DataFrame 데이터끼리 빼기
df1 * df2 # DataFrame 데이터끼리 곱하기
df1 / df2 # DataFrame 데이터끼리 나누기
df1 + 5 # value의 각 요소에 값을 더함
df1 ** 2 # value의 각 요소에 거듭제곱
df1 > 30 # value의 각 요소에 비교 연산

2. 표 데이터의 집계 및 통계 연산

넘파이의 배열에 sum(), mean(), std(), var(), min(), max(), cumsum(), cumprod() 등의 메소드를 사용 가능!

axis=0 # DataFrame 데이터의 values에서 index 방향으로 연산 수행

axis=1 # DataFrame 데이터의 values에서 columns 방향으로 연산 수행

import pandas as pd

# CSV 파일 이름 지정
csv_file = "C:/myPyExcel/data/ch05/korea_rain1.csv"

# CSV 파일을 읽어와서 DataFrame 데이터 생성
df = pd.read_csv(csv_file, encoding="utf8", index_col='연도') 

df.mean() # df.mean(axis=0)와 동일
df.std() # df.std(axis=0)와 동일
df.mean(axis=1)
df.std(axis=1)
df.describe()

 

---

| 표 데이터 선택

1. 행 데이터 선택

1.1 loc

Series_data.loc[index_label_item]

DataFrame_data.loc[index_label_item]

지정방식

(1) index 라벨

- Series 데이터: 요소 반환

- DataFrame 데이터: Series로 반환

(2) index 라벨 리스트나 배열

(3) index 라벨 슬라이싱: 파이썬의 기존 슬라이싱과 달리 index_end가 포함된다.

 

1.2 iloc

Series_data.iloc[index_pos_item]

DataFrame_data.iloc[index_pos_item]

지정방식

(1) index 위치

- Series 데이터: 요소 반환

- DataFrame 데이터: Series로 반환

(2) index 위치 리스트나 배열

(3) index 위치 슬라이싱: 파이썬의 기존 슬라이싱과 달리 index_end가 포함된다.

예시 1

dict_data = {'A': [0, 1, 2, 3, 4],
             'B': [10, 11, 12, 13, 14],
             'C': [20, 21, 22, 23, 24]} # 딕셔너리 데이터

index_data = ['a', 'b', 'c', 'd', 'e'] # index 지정용 데이터

df = pd.DataFrame(dict_data, index=index_data) # DataFrame 데이터 생성

df.loc['a', 'A'] # loc 이용
df.iloc[0, 0] #iloc 이용
df.loc['a':'c', ['A', 'B']] # loc 이용
df.iloc[0:3, 0:2] # iloc 이용

df.loc[df['A']>2, ['A', 'B']] # loc 이용
df.loc['a':'c', ['A', 'B']] = 50 # 스칼라 값 지정
df.iloc[3:5, 1:3] = 100 # 스칼라 값 지정

df.loc[df['B']<70, 'B'] = 70 # 스칼라 값 지정
df.loc[df['C']<30, 'D'] = 40 # loc 이용. 스칼라 값 지정

예시 2

dict_data = {'A': [0, 10, 20, 30, 40],
             'B': [0, 0.1, 0.2, 0.3, 0.4],
             'C': [0, 100, 200, 300, 400]} # 딕셔너리 데이터

index_data = ['a', 'b', 'c', 'd', 'e'] # index 지정용 데이터

df1 = pd.DataFrame(dict_data, index=index_data) # 딕셔너리 데이터로부터 DataFrame 데이터 생성

df1.loc['a'] # index 라벨 지정으로 하나의 행 데이터를 선택
df1.loc[['a', 'c', 'e']] # index 라벨 리스트 지정으로 여러 행의 데이터를 선택
df1.loc['b':'d'] # index 라벨 슬라이싱으로 여러 행의 데이터를 선택

df1.iloc[2] # index 위치 지정으로 하나의 행 데이터를 선택
df1.iloc[[1, 3, 4]] # index 위치 리스트 지정으로 여러 행의 데이터를 선택
df1.iloc[1:3] # index 위치 슬라이싱으로 여러 행의 데이터를 선택

df1.loc['a':'c'] = 50 # 해당 위치 스칼라값으로 일괄 변경

1.3 Series 데이터는 loc나 iloc 없이도 행 데이터 선택 가능

index_data = ['a', 'b', 'c', 'd', 'e'] # index용 데이터
data = [0, 1, 2, 3, 4] # 데이터

s2 = pd.Series(data, index=index_data)

s2['a'] # index 라벨 지정으로 하나의 행 데이터를 선택
s2[['a', 'c']] # index 라벨 리스트 지정으로 여러 행의 데이터를 선택
s2['c':'e'] # index 라벨 슬라이싱으로 여러 행의 데이터를 선택
s2['a':'e':2] # index 라벨 슬라이싱으로 여러 행의 데이터를 선택

s2[0] # index 위치 지정으로 하나의 행 데이터를 선택
s2[[1, 2, 4]] # index 위치 리스트 지정으로 여러 행의 데이터를 선택
s2[2:5] # index 위치 슬라이싱으로 여러 행의 데이터를 선택
s2[0:5:2] # index 위치 슬라이싱으로 여러 행의 데이터를 선택

1.4 조건을 지정해 행 데이터 선택

Series_data[condition]

DataFrame_data[condition]

# Series 데이터 생성
s = pd.Series(range(-3, 6)) 

# DataFrame 데이터 생성
dict_data = {'지점': ['서울', '대전', '대구', '부산', '광주'],
             '1월': [558, 234, 340, 380, 213],
             '2월': [437, 216, 238, 290, 194], 
             '3월': [337, 196, 209, 272, 186]} # 딕셔너리 데이터

df = pd.DataFrame(dict_data) # 딕셔너리 데이터로부터 DataFrame 데이터 생성

s[s > 0] # 조건을 만족하는 행 데이터 가져오기
s[(s >= -2) & (s%2 == 0)] # 두 조건을 모두 만족하는 행 데이터 가져오기 

df[df['1월'] >= 300] # 조건을 만족하는 행 데이터 가져오기
df[(df['지점'] == '서울') | (df['지점'] == '부산')] # 둘 중 하나만 만족해도 행을 선택
df[df['지점'].isin(['서울','부산'])] # 불 인덱싱: 값이 있으면 가져오기

1.5 행과 열 출력할 열 개수 지정

DataFrame_data.head([n]) # 시작 행 일부(기본값: 5)

DataFrame_data.tail([n]) # 끝 행 일부(기본값: 5)

dict_data = { '제품ID':['P501', 'P502', 'P503', 'P504', 'P505', 'P506', 'P507'],
              '판매가격':[6400, 5400, 9400, 10400, 9800, 1200, 3400],
              '판매량':[63, 56, 98, 48, 72, 59, 43],
              '이익률':[0.30, 0.21, 0.15, 0.25, 0.45, 0.47, 0.32]}  # 딕셔너리 데이터

df2 = pd.DataFrame(dict_data)

df2.head() # 처음 5개의 행 데이터 선택
df2.head(2) # 처음 2개의 행 데이터 선택
df2.tail() # 마지막 5개의 행 데이터 선택
df2.tail(3) # 마지막 3개의 행 데이터 선택

---

2. 열 데이터 선택

DataFrame_data[columns_name_item]

dict_data = { '제품ID':['P501', 'P502', 'P503', 'P504', 'P505', 'P506', 'P507'],
              '판매가격':[6400, 5400, 9400, 10400, 9800, 1200, 3400],
              '판매량':[63, 56, 98, 48, 72, 59, 43],
              '이익률':[0.30, 0.21, 0.15, 0.25, 0.45, 0.47, 0.32]}  # 딕셔너리 데이터

df2 = pd.DataFrame(dict_data)

df2[['제품ID']]
df2[['제품ID', '이익률', '판매가격']]

# 지정한 열 데이터의 모든 값을 스칼라값으로 변경
df2['이익률'] = 0.5 # '이익률' 열 데이터를 0.5로 변경

---

3. 행과 열 데이터 선택

DataFrame_data.loc[index_label_item, columns_name_item]

DataFrame_data.iloc[index_pos_item, columns_pos_item]

dict_data = {'A': [0, 1, 2, 3, 4],
             'B': [10, 11, 12, 13, 14],
             'C': [20, 21, 22, 23, 24]} # 딕셔너리 데이터

index_data = ['a', 'b', 'c', 'd', 'e'] # index 지정용 데이터

df = pd.DataFrame(dict_data, index=index_data) # DataFrame 데이터 생성

df.loc['a', 'A'] # loc 이용
df.iloc[0, 0] #iloc 이용

df.loc['a':'c', ['A', 'B']] # loc 이용
df.iloc[0:3, 0:2] # iloc 이용

df.loc[df['A']>2, ['A', 'B']] # loc 이용

df.loc['a':'c', ['A', 'B']] = 50 # 스칼라 값 지정
df.iloc[3:5, 1:3] = 100 # 스칼라 값 지정

df.loc[df['B']<70, 'B'] = 70 # 스칼라 값 지정
df.loc[df['C']<30, 'D'] = 40 # loc 이용. 스칼라 값 지정

3.1 하나의 열만 선택해서 변경

DataFrame_data[column_name][index_lable_item]

DataFrame_data[column_name][index_pos_item]

dict_data = {'A': [0, 1, 2, 3],
             'B': [4, 5, 6, 7],
             'C': [8, 9, 10, 11]} # 딕셔너리 데이터

index_data = ['a', 'b', 'c', 'd'] # index 지정용 데이터

df1 = pd.DataFrame(dict_data, index=index_data) # DataFrame 데이터 생성

df1['C']['c'] # 하나의 열 선택 후 하나의 행 선택(index 라벨)
df1['C'][2] # 하나의 열 선택 후 하나의 행 선택(index 위치)
df1['C'][[0,1,3]] # 하나의 열 선택 후 리스트로 여러 행을 선택
df1['C']['a':'d'] # 하나의 열 선택 후 슬라이싱으로 여러 행을 선택
df1['C'][df1['B']>=5] # 하나의 열 선택 후 조건을 지정해 행을 선택

df1.T # 전치 행렬(Transpose): 행과 열을 변경한다.

---

4. 행과 열 데이터 삭제

Series_data.drop(index = index_label)

DataFrame_data.drop(index = index_label 혹은 columns = columns_name)

import numpy as np
import pandas as pd

s3 = pd.Series([10, 20, 30, 40, np.nan, 60]) # Series 데이터 생성

s3.drop(index = 0) # Series 데이터에서 하나의 행을 제거
s3.drop(index = [1, 3, 5]) # Series 데이터에서 여러 행을 제거

import pandas as pd

# CSV 파일 경로
folder = 'C:/myPyExcel/data/ch05/' 
csv_file = folder + 'electric_products.csv' 

# CSV 파일을 읽어와서 DataFrame 데이터 생성
df3 = pd.read_csv(csv_file, encoding="utf-8") 

# DataFrame 데이터에서 여러 행을 제거
df3.drop(index=[1, 2]) 

# DataFrame 데이터에서 여러 열의 데이터를 제거
df3.drop(columns=['M3','M4']) 

# DataFrame 데이터에서 행과 열의 데이터를 제거
df3.drop(index=[1,2], columns=['M3','M4'])

---

| 표 데이터 통합

1. 세로나 가로 방향으로 연결: concat()

2. 세로 방향으로 연걸: append()

3. 가로 방향(index(행) 기준)으로 병합: join()

4. 가로 방향(columns(열) 기준)으로 병합: merge()

---

1. 세로나 가로 방향으로 연결: concat()

 - 구조: pd.concat(Series_data_list 혹은 DataFrame_data_list[, axis = 0(기본) 혹은 1, ignore_index = True 혹은 False(기본), join = 'outer'(기본) 혹은 'inner' ])

 - axis = 0 # 세로 방향(index 방향) 연결

 - axis = 1 # 가로 방향(columns 방향 연결

 - ignore_index: 원본 데이터의 index 사용 여부 결정

 - join: 연결 방법 선택 | 'outer': 모든 데이터, 'inner': 공통 데이터

import pandas as pd

# Series 데이터 생성
s1 = pd.Series([10, 20, 30])
s2 = pd.Series([40, 50, 60])
s3 = pd.Series([70, 80, 90])

# 세로 방향으로 연결
pd.concat([s1, s2])

# 기존 index를 무시하고 새로운 index를 생성
pd.concat([s1, s2], ignore_index=True) 

# 기존 index를 무시하고 새로운 index를 생성
pd.concat([s1, s2, s3], ignore_index=True)

# DataFrame 생성
df1 = pd.DataFrame({'물리':[95, 92, 98, 100],
                    '화학':[91, 93, 97, 99]})
df2 = pd.DataFrame({'물리':[87, 89],
                    '화학':[85, 90]})
df3 = pd.DataFrame({'물리':[72, 85]})
df4 = pd.DataFrame({'생명과학':[94, 91, 94, 83],
                    '자구과학':[86, 94, 89, 93]})

# 세로 방향으로 연결하되 기존 index를 무시
pd.concat([df1, df2], ignore_index=True)

# 세로 방향으로 연결하되 기존 index를 무시
pd.concat([df2, df3], ignore_index=True) 

# 세로 방향으로 공통 데이터만 연결 (기존 index를 무시)
pd.concat([df2, df3], ignore_index=True, join='inner')

# 가로 방향으로 연결
pd.concat([df1, df4], axis=1)

# 가로 방향으로 모든 데이터 연결
pd.concat([df2, df4], axis=1) 

# 가로 방향으로 공통 데이터만 연결
pd.concat([df2, df4], axis=1, join='inner')

---

2. 세로 방향으로 연걸: append()

- 구조

Series_data.append(other_Series_data[, ignore_index = True 혹은 False(기본) ])

DataFrame_data.append(other_DataFrame_data[, ignore_index = True 혹은 False(기본) ])

 - 이전 concat 옵션 내용과 동일

# s1에 s2를 세로 방향으로 연결하되 기존 index를 무시하고 새로운 index를 생성
s1.append(s2, ignore_index=True) 

# s1에 s2, s3를 세로 방향으로 연결하되 기존 index를 무시하고 새로운 index를 생성
s1.append([s2, s3], ignore_index=True) 

# df1에 df2를 세로 방향으로 연결하되 기존 index를 무시하고 새로운 index를 생성
df1.append(df2, ignore_index=True) 

# df2에 df3를 세로 방향으로 연결하되 기존 index를 무시하고 새로운 index를 생성
df2.append(df3, ignore_index=True)

# df1에 df2, df3를 세로 방향으로 연결하되 기존 index를 무시하고 새로운 index를 생성
df1.append([df2, df3], ignore_index=True)

---

3. 가로 방향(index(행) 기준)으로 병합: join()

 - 구조: DataFrame_data.join(other_DataFrame_data[, lsuffix = str_left, rsuffix = str_right, how = join_method(기본: 'left') ])

# DataFrame 생성
dict_data = {'A': ['a0', 'a1', 'a2'], 
             'B': ['b0', 'b1', 'b2']} 

df_left1 = pd.DataFrame(dict_data)

dict_data = {'C': ['c0', 'c1', 'c2'], 
             'D': ['d0', 'd1', 'd2']}

df_right1 = pd.DataFrame(dict_data, index = [1, 2, 3])

dict_data = {'A': ['a0', 'a1', 'a2'], 
             'D': ['d0', 'd1', 'd2']}

df_right2 = pd.DataFrame(dict_data)

# 왼쪽 데이터는 모두 선택, 왼쪽 index와 연관된 항목이 있는 오른쪽 데이터만 병합
df_left1.join(df_right1, how='left') # df_left1.join(df_right1)와 동일

# 오른쪽 데이터는 모두 선택, 오른쪽 index와 연관된 항목이 있는 왼쪽 데이터만 병합
df_left1.join(df_right1, how='right')

# index를 기준으로 왼쪽과 오른쪽 열 데이터를 모두 병합
df_left1.join(df_right1, how='outer')

# index를 기준으로 왼쪽과 오른쪽에 연관된 항목이 모두 있는 데이터만 병합
df_left1.join(df_right1, how='inner')

# lsuffix와 rsuffix 옵션 추가
df_left1.join(df_right2, lsuffix ='_1', rsuffix='_2')

pd.concat([df_left1, df_right2], axis=1) # 가로 방향으로 연결

---

4. 가로 방향(columns(열) 기준)으로 병합: merge()

 - 구조: DataFrame_left.merge(DataFrame_right[, how = merge_method(기본: 'inner'), on = key_label, left_on = left_key_label, right_on = right_key_label, suffixes = (str_left, str_right) ])

 - on: DataFrame 데이터 DataFrame_left와 DataFrame_right에서 공통으로 있는 열 중에서 키(key)로 지정하고 싶은 열 이름(key_label)을 지정합니다.

 - left_on과 right_on: DataFrame 데이터 DataFrame_left와 DataFrme_right에서 키(key)로 지정하고 싶은 열 이름(left_key_label과 right_key_label)을 지정합니다.

 - how: 지정한 열(key)을 기준으로 두 DataFrame 데이터끼리 병합 방법(merge_method)을 지정합니다.

 - suffixes: 지정한 열(key)외에 공통된 열 이름이 있을 경우에 DataFrame 데이터 DataFrame_left와 DataFrame_right의 공통 열 이름 다음에 들어갈 문자열(str_left과 str_right)을 튜플 형식으로 지정합니다. 기본값 ('_x', '_y')

| 예시 1

# DataFrame 생성
df_left3 = pd.DataFrame({'key': ['k0', 'k1', 'k2', 'k3'],
                         'A': ['a0', 'a1', 'a2', 'a3']})

df_right3 = pd.DataFrame({'key': ['k2', 'k3', 'k4', 'k5'],
                          'B': ['b2', 'b3', 'b4', 'b5']})

df_left3.merge(df_right3, how='left', on='key')
df_left3.merge(df_right3, how='right', on='key')
df_left3.merge(df_right3, how='outer', on='key')
df_left3.merge(df_right3, how='inner', on='key') # df_left3.merge(df_right3)와 동일
df_left3.merge(df_right3) # df_left3.merge(df_right3, how='inner', on='key')와 동일

| 예시 2

# DataFrame 생성
df_left4 = pd.DataFrame({'key': ['k0', 'k1', 'k2', 'k3'],
                         'A': ['a0', 'a1', 'a2', 'a3'],
                         'C': ['c0', 'c1', 'c2', 'c3']})

df_right4 = pd.DataFrame({'key': ['k0', 'k1', 'k2', 'k3'],
                          'A': ['a0', 'a1', 'a4', 'a5'],
                          'D': ['d0', 'd1', 'd2', 'd3']})

df_left4.merge(df_right4, how='inner')
df_left4.merge(df_right4, how='inner', on=['key', 'A'])
df_left4.merge(df_right4, how='outer', on='key')
df_left4.merge(df_right4, how='outer', on='key', suffixes=('_left', '_right'))

| 예시 3

# DataFrame 생성
df_left5 = pd.DataFrame({'key_left': ['k0', 'k1', 'k2', 'k3'],
                         'A': ['a0', 'a1', 'a2', 'a3']})

df_right5 = pd.DataFrame({'key_right': ['k1', 'k2', 'k3'],
                          'A': ['a1', 'a4', 'a5']}, index=[2,3,4])

# 두 개의 DataFrame 데이터를 통합 
df_left5.merge(df_right5, how='left', left_on='key_left', right_on='key_right')

| 예시 4

code_list = ['LS05', 'SM10', 'BP70', 'LS10', 'BP70', 'SM10', 'LS05']
sales_list = [29, 25, 30, 22, 19, 38, 45]
store_list = ['강남','강남','강남','대학로','대학로','인천공항','인천공항']

# 제품의 코드와 매장별 판매량이 있는 DataFrame 데이터 생성
df_sales = pd.DataFrame({'code': code_list, 
                         'sales': sales_list, 
                         'store': store_list})

# 제품의 코드와 제품 이름이 있는 DataFrame 데이터 생성
df_ref = pd.DataFrame({'code': ['LS05', 'SM10', 'BP70', 'LS10'],
                       'name': ['브리오슈', '베이글', '치아바타', '바게트']})

df_sales.merge(df_ref, how='left', on='code') # 두 개의 DataFrame 데이터를 병합

---

해당 내용은 일 잘하는 직장인을 위한 엑셀 자동화 with 파이썬 책의 내용을 기반으로 정리한 것입니다.

출처: https://github.com/wikibook/pyexcel/blob/master/notebooks/Chapter_05_NumPy_pandas.ipynb

GitHub - wikibook/pyexcel: 《일 잘하는 직장인을 위한 엑셀 자동화 with 파이썬》 예제 코드