โ๐ป ๋ฐฐ์ด์
ํ์ด์ฌ์ GIL ๊ณผ ๋ฉํฐํ๋ก์ธ์ฑ์ ๋ํด ์ดํดํ ์ ์์๊ณ , ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํ ์ฌ๋ฌ ๋ฉ์๋๋ค ๊ทธ๋ฆฌ๊ณ ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ๋ค์ ๋ฐฐ์ธ ์ ์์๋ค.
๐ ๋ชฉ์ฐจ
1. map
2. reduce
3. filter
4. multiprocessing
5. ๊น๋ํ ๋ฐ์ดํฐ์ ์กฐ๊ฑด
6. locals
7. concat
8. ๊ฒฐ์ธก์น ๊ฐ์
9. DataFrame index ์ด๊ธฐํ
10. ์งํ์ฒ ์ด์ฉ ์ ๋ณด ๋ฐ์ดํฐ ํฉ์น๊ธฐ
๋ค์ด๊ฐ๋ฉฐ
์งํ์ฒ ์ด์ฉ ์ ๋ณด ๋ฐ์ดํฐ๋ 2016 ๋ ๊ธฐ์ค ๋ฐ์ดํฐ๋ก, 1์๋ถํฐ 12์๊น์ง 1๋ ๊ฐ์ ๋ฐ์ดํฐ๋ก ์ ๋ฆฌ๋์ด ์๋ ์๋ฃ๋ฅผ ์ฌ์ฉํ์ต๋๋ค.
๋ค์ ํฌ์คํ ์ ์ด์ด์ ํ์ฉํ ๊ณํ์ ๋๋ค.
map
list ์ map ์ ์ฌ์ฉํ๋ฉด, for ๋ฌธ์ ์ฌ์ฉํด์ผ ํ๋ ๊ณผ์ ์ ๊ฐ๋จํ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค.
a = [ 1.5, 2.3, 6.3 ]
# int ๋ก ๋ชจ๋ ๋ฐ๊พธ์ด ๋ฆฌ์คํธ๋ก ์ ์ฅ
a1 = list(map(int, a))
# int ๋ก ๋ฐ๊พธ๋ฉด์ * 10 ๋ฆฌ์คํธ๋ก ์ ์ฅ
a2 = list(map(lambda x : int(x) * 10, a))
์ด๋ ๊ฒ, ๊ฐ๋จํ ํ ์ค ์ฝ๋๋ก ๋ฐ๋ณต๋ฌธ ์์ด ์์์ ํตํด ์ ์ฉํ ์ ์๋ค.
reduce
ํ์ด์ฌ์์ functools ๋ชจ๋์ reduce ๋ฉ์๋๋ฅผ ํตํด, ๋ฆฌ์คํธ๋ ํํ์ ์์๋ฅผ ๋์ ์ผ๋ก ํจ์๋ฅผ ์ ์ฉํ ์ ์๋ค.
from functools import reduce
# reduce(์ ์ฉ์ํฌ ํจ์, ๋ฆฌ์คํธ ํน์ ํํ)
reduce(lambda x, y : x + y, [1, 2, 3, 4, 5])
reduce ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ, x + y ํจ์๋ฅผ ์ ์ฉํ๋ฉด,
1(0 ๋ฒ์งธ ๊ฐ) + 2(1๋ฒ์งธ ๊ฐ) = 3 (๋์ ํฉ)
3(๋์ ํฉ) + 3(2๋ฒ์งธ ๊ฐ) = 6 (๋์ ํฉ)
6(๋์ ํฉ) + 4(3๋ฒ์งธ ๊ฐ) = 10 (๋์ ํฉ)
10(๋์ ํฉ) + 5(4๋ฒ์งธ ๊ฐ) = 15 (๋์ ํฉ)
์ผ๋ก, ๊ฐ๋จํ๊ฒ 1๋ถํฐ 5๊น์ง์ ํฉ์ ๊ตฌํ ์ ์๋ค.
filter
ํ์ด์ฌ์์ filter ๋ฉ์๋๋ฅผ ํตํด, ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ๋ง ๋ฐ๋ก ๊ฐ์ ธ์ฌ ์ ์๋ค.
test = [1, 2, 3, 4, 5, 6]
# filter(์ ์ฉ์ํฌ ํจ์(์กฐ๊ฑด), ๋ฆฌ์คํธ ํน์ ํํ)
list(filter(lambda x : x % 2 == 0, test))
filter ๋ฉ์๋๋ฅผ ํตํด ํน์ ์กฐ๊ฑด์ ๋ง๋ค์ด์ฃผ๋ lambda ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ ๊ฒ ์ง์๋ง ๊ฐ์ ธ์ฌ ์ ์๋ค.
multiprocessing
ํ์ด์ฌ์์๋, ๋ฉํฐํ๋ก์ธ์ฑ์ ์ง์ํด์ฃผ๋ Pool ํด๋์ค๊ฐ ์๋ค.
from multiprocessing import Pool
Pool ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ, ๋ฉํฐํ๋ก์ธ์ฑ์ผ๋ก ๋ณ๋ ฌ์ฒ๋ฆฌ๋ฅผ ํ ์ ์์ด์, ๋์ฉ๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ์ด์ผ ํ๋ ๊ฒฝ์ฐ ์ ์ฉํ๋ค.
๋จ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ฆ๊ฐํ ์ ์๊ณ , ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ ์ ์ํด์ผ ํ๋ค.
ํนํ, ํ์ด์ฌ์์์ GIL(Global Interpreter Lock) ์ ์ํด ํ์ด์ฌ ์ธํฐํ๋ฆฌํฐ์์ ๋์์ ์ฌ๋ฌ ์ค๋ ๋๊ฐ ์คํ๋ ์ ์๋ค.
- ๋ฉํฐํ๋ก์ธ์ฑ
์ฌ๋ฌ ๊ฐ์ ํ๋ก์ธ์ค๋ฅผ ์ฌ์ฉํ์ฌ ์์ ์ฒ๋ฆฌ
์ฌ๋ฌ CPU ์ฝ์ด๋ฅผ ์ฌ์ฉํ์ฌ ๋ณ๋ ฌ๋ก ์์ ์ฒ๋ฆฌ ๊ฐ๋ฅ
- ๋ฉํฐ์ค๋ ๋ฉ
ํ๋์ ํ๋ก์ธ์ค ์์์ ์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๋ฅผ ์ฌ์ฉํ์ฌ ์์ ์ฒ๋ฆฌ
ํ์ด์ฌ์์๋ GIL ๋๋ฌธ์ ๋ฉํฐ์ค๋ ๋ฉ์ผ๋ก ์ธํ ๋ณ๋ ฌ์ฑ ํฅ์์ ์ด๋ ค์
- ์ค๋ ๋
ํ๋ก์ธ์ค ์คํ ๋จ์
ํ๋์ ํ๋ก์ธ์ค ๋ด์์ ๊ณต์ ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๊ฐ์ง๋ฏ๋ก ์์ ์ฒ๋ฆฌ์ ๋ณ๋ ฌ์ฑ์ ๊ฐ์ง ์ ์์
๊ทธ๋ฌ๋, ํ๋์ GIL ์ ์ํด ์ ํ์ ๋ฐ๊ธฐ ๋๋ฌธ์ ๋ณ๋ ฌ์ฑ ๋ณด์ฅ ์๋จ
์ฆ, ํ์ด์ฌ์์๋ ๋ฉํฐํ๋ก์ธ์ฑ์ ์ด์ฉํ ๋ณ๋ ฌ์ฒ๋ฆฌ๋ ๊ฐ๋ฅํ์ง๋ง, GIL ์ ์ํด์ ๋ฉํฐ์ค๋ ๋ฉ์ ํตํ ๋ณ๋ ฌ์ฒ๋ฆฌ๋ ์ด๋ ค์์ด ์๋ค.
๊น๋ํ ๋ฐ์ดํฐ์ ์กฐ๊ฑด
- ๋ฐ์ดํฐ ๋ถ์ ๋ชฉ์ ์ ๋ง๋ ๋ฐ์ดํฐ๋ฅผ ๋ชจ์ ์๋ก์ด table ์ ๋ง๋ค์ด์ผ ํ๋ค.
- ์ธก์ ํ ๊ฐ์ row ๋ฅผ ๊ตฌ์ฑํด์ผ ํ๋ค.
- ๋ณ์๋ columns ๋ก ๊ตฌ์ฑํด์ผ ํ๋ค.
ํญ์ ์ ์ธ ๊ฐ์ง ์กฐ๊ฑด์ ๋ง๋๋ก ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์ฑํ๋๋ก ํ์.
locals
locals() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ก์ปฌ ๋ค์์คํ์ด์ค์ ๋ณ์๋ฅผ ๋์ ์ผ๋ก ์ถ๊ฐํ ์ ์๋ค.
# data : concat_1.csv, concat_2.csv, concat_3.csv
for file in os.listdir("./data"):
locals()[f'{file.split(".")[0]}'] = pd.read_csv(f"./data/{file}")
data ๋ผ๋ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋ ํ์ผ๋ค์ ์ฝ์ด์์, ํ์ผ๋ค์ ํ์ฅ์๋ช ์ ์ ์ธํ ํ์ผ ์ด๋ฆ์ ๋ก์ปฌ ๋ณ์๋ก ํ ๋นํ๊ณ , ๊ทธ ๋ก์ปฌ ๋ณ์์ ํด๋น ํ์ผ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ ์ ์ฅํ ์ ์๋ค.
concat
pandas ์ concat ๋ฉ์๋๋ฅผ ํตํด, series ๋ df ํํ๋ผ๋ฆฌ ํน์, series ์ df ๋ผ๋ฆฌ ์ฌ๋ฌ ํํ๋ก ํฉ์น ์ ์๋ค.
import pandas as pd
row_concat = pd.concat([concat_1, concat_2, concat_3])
df = pd.concat([row_concat, pd.Series(['n1', 'n2', 'n3', 'n4'])])
์ด๋ ๊ฒ, DataFrame ๋ผ๋ฆฌ ํฉ์ณ row_concat ์ด๋ผ๋ DataFrame ์ ๋ง๋ค ์ ์๊ณ , DataFrame ๊ณผ Series ํํ๋ผ๋ฆฌ ํฉ์ณ ์๋ก์ด DataFrame์ธ df ๋ฅผ๋ง๋ค ์ ์๋ค.
๊ฒฐ์ธก์น ๊ฐ์
DataFrame ์ ๊ฒฐ์ธก์น๋ฅผ ํ์ธํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋์ธ isnull() ์ ์ฌ์ฉํ์ฌ, ๊ฒฐ์ธก์น์ ๊ฐ์๋ฅผ ํ์ธํด๋ณด์.
df.isnull().sum() # ๊ฐ ํ๊ณผ ์ด์ ๊ฒฐ์ธก์น ์
df.isnull().sum().sum() # ์ ์ฒด ๊ฒฐ์ธก์น ์
DataFrame index ์ด๊ธฐํ
DataFrame ์ index ๊ฐ๋ค์ ์ด๊ธฐํํ๋ ๋ฉ์๋์ธ reset_index() ํตํด, ๊ธฐ์กด index ๋ฅผ ์ ๊ฑฐํด์ฃผ์.
df.reset_index(drop=True, inplace=True)
drop ๊ณผ inplace ๋ฅผ ์ ์ฉํ์ฌ df ์ ๊ธฐ์กด index ๋ฅผ ์ ๊ฑฐํ๊ณ ์๋ณธ df ์ ๋ฐ๋ก ์ ์ฉํ๋๋ก ํ๋ค.
์งํ์ฒ ์ด์ฉ ์ ๋ณด ๋ฐ์ดํฐ ํฉ์น๊ธฐ
์งํ์ฒ ์ด์ฉ ์ ๋ณด๊ฐ ๋ด๊ธด csv ํ์ผ๋ค์, ๊ฐ ํ์ผ์ ์ ๋ณด๋ฅผ ํ๋์ ๋ฐ์ดํฐ๋ก ํฉ์น๋๋ก ํ์.
import pandas as pd
import numpy as np
import os
total_df = pd.DataFrame()
for file in os.listdir("./subway"):
temp = pd.read_csv(f"./subway/{file}" , encoding='euc-kr')
if temp.columns.size == 24:
temp['ํธ์ '] = np.NaN
temp['ํ ์ธ']= np.NaN
temp['04 ~ 05'] = np.NaN
temp['02 ~ 03'] = np.NaN
temp['03 ~ 04'] = np.NaN
temp.columns = ['๋ ์ง', 'ํธ์ ', '์ญ๋ช
', '๊ตฌ๋ถ', 'ํ ์ธ', '04 ~ 05', '05 ~ 06', '06 ~ 07',
'07 ~ 08', '08 ~ 09', '09 ~ 10', '10 ~ 11', '11 ~ 12', '12 ~ 13',
'13 ~ 14', '14 ~ 15', '15 ~ 16', '16 ~ 17', '17 ~ 18', '18 ~ 19',
'19 ~ 20', '20 ~ 21', '21 ~ 22', '22 ~ 23', '23 ~ 24', '00 ~ 01',
'01 ~ 02', '02 ~ 03', '03 ~ 04']
else :
temp.columns = ['๋ ์ง', 'ํธ์ ', '์ญ๋ช
', '๊ตฌ๋ถ', 'ํ ์ธ', '04 ~ 05', '05 ~ 06', '06 ~ 07',
'07 ~ 08', '08 ~ 09', '09 ~ 10', '10 ~ 11', '11 ~ 12', '12 ~ 13',
'13 ~ 14', '14 ~ 15', '15 ~ 16', '16 ~ 17', '17 ~ 18', '18 ~ 19',
'19 ~ 20', '20 ~ 21', '21 ~ 22', '22 ~ 23', '23 ~ 24', '00 ~ 01',
'01 ~ 02', '02 ~ 03', '03 ~ 04']
total_df = pd.concat([total_df, temp])
๋จผ์ , ๊ฐ ํ์ผ๋ค๋ง๋ค columns ์ ๊ฐ์์ name ์ด ์์ดํ๊ธฐ์ ์ด๋ฅผ ๋๊ฐ์ด ๋ง์ถฐ์ฃผ๋ ์์ ์ ์งํํ๊ณ , DataFrame ์ concat ๋ฉ์๋๋ฅผ ํตํด ๊ณ์ ํฉ์น๋ฉฐ ๋ชจ๋ ํ์ผ์ ์งํ์ฒ ์ด์ฉ ์ ๋ณด๊ฐ ๋ค์ด๊ฐ ํ๋์ DataFrame ์ผ๋ก ๋ง๋ค์ด์ค๋ค.
'Python > [๊ธฐ์ด ๊ฐ์ ์ ๋ฆฌ]' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
python ๊ธฐ์ด 13 (0) | 2023.03.12 |
---|---|
python ๊ธฐ์ด 12 (3) | 2023.03.06 |
python ๊ธฐ์ด 11 (0) | 2023.03.03 |
python ๊ธฐ์ด 10 (0) | 2023.03.03 |
python ๊ธฐ์ด 9 (0) | 2023.03.01 |