콘텐츠로 이동
교육자료

AI 기초 › 03장

표 데이터 다루기: pandas

읽기 1시간 30분 · 실습 1시간 30분인쇄용 보기(PDF)

실무 데이터는 대부분 표로 온다. 표는 열마다 이름과 자료형이 다르고, 빈칸이 있고, 도시 이름 같은 문자열이 섞여 있고, 정보가 여러 표에 나뉘어 있다. 이 장에서는 pandas로 표를 읽고, 고르고, 고치고, 합쳐서 02장의 (표본 수, 특성 수) 숫자 배열로 만드는 과정을 익힌다. 그 과정에서 오류 없이 틀린 답을 만드는 함정(위치와 이름표 혼동, 연쇄 대입, 처음 보는 범주, 키 중복 병합)을 하나씩 확인한다.

목표 완료 기준
표의 구조를 읽는다 shape·dtypes·isna().sum()으로 열마다 자료형과 결측 수를 확인한다
index(이름표)와 위치를 구분한다 정렬·필터 뒤 loc·iloc·idxmax·argmax의 결과를 실행 전에 맞힌다
행을 고르고 값을 바꾼다 조건 여러 개로 행을 고르고, loc 한 번으로 값을 바꾼다(연쇄 대입을 쓰지 않는다)
결측을 처리한다 삭제·대체·결측 표시 중에서 고르고, 대체값은 훈련 데이터에서만 구한다
기술 통계를 읽는다 평균·중앙값·표준편차·분위수를 구하고, 이상치가 각각에 주는 영향을 말한다
범주를 숫자로 바꾼다 원-핫과 정수 인코딩의 차이, 정수가 만드는 순서 가정, 처음 보는 범주 처리를 설명하고 코드로 쓴다
표를 묶고 합친다 groupby로 집계하고, merge 전후 행 수·합계를 확인한다
그림으로 데이터를 본다 히스토그램·상자 그림·산점도로 분포·이상치·관계를 확인한다
선택 기준표에 줄을 더한다 결측·범주·병합 상황에서 고를 방법과 이유를 적는다
실습 노트북 03을 끝낸다 실습/문제/ch03_표_데이터_다루기_pandas.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 1시간 30분, 실습 1시간 30분.

02장의 NumPy 배열은 원소 전체가 dtype 하나다. 그런데 고객 표에는 정수(방문 수), 실수(키), 문자열(도시)이 함께 있다. pandas의 DataFrame은 이런 표를 담는다.

  • 열마다 이름과 자료형이 따로 있다.
  • 행마다 index(이름표)가 붙는다. 정렬하거나 걸러도 이름표는 행을 따라간다.
  • 결측 확인, 조건 필터, 그룹 집계, 표 합치기, 그림 그리기를 짧은 코드로 한다.

scikit-learn 모델도 DataFrame을 받지만, 결국 안에서는 숫자 배열로 계산한다. 그래서 이 장의 끝은 언제나 “숫자만 남은 (N, d) 표”다(3-10절).

이 장은 아래 고객 표 하나로 시작한다.

import numpy as np
import pandas as pd
customers = pd.DataFrame({
"고객ID": [101, 102, 103, 104, 105, 106],
"도시": ["서울", "부산", "서울", "대구", "부산", "서울"],
"등급": ["실버", "골드", "브론즈", "실버", "브론즈", "골드"],
"나이": [34, None, 27, 45, 52, None],
"방문수": [12, 30, 3, 8, 5, 41],
})
print(customers)
print(customers.shape)
print(customers.dtypes)
출력
고객ID 도시 등급 나이 방문수
0 101 서울 실버 34.0 12
1 102 부산 골드 NaN 30
2 103 서울 브론즈 27.0 3
3 104 대구 실버 45.0 8
4 105 부산 브론즈 52.0 5
5 106 서울 골드 NaN 41
(6, 5)
고객ID int64
도시 str
등급 str
나이 float64
방문수 int64
dtype: object
  • 표의 한 줄이 표본(고객 한 명), 한 열이 특성이다. shape는 (행 수, 열 수)다.
  • 왼쪽 끝 0~5가 index다. 따로 정하지 않으면 0부터 붙는다.
  • 나이는 정수를 넣었는데 float64가 됐다. 비어 있는 값인 결측(missing value) None은 NaN(Not a Number, 실수 값)으로 저장되므로 결측이 섞인 정수 열은 실수 열이 된다. 자료형을 정하지 않았을 때의 동작이고, dtype="Int64"처럼 결측을 담는 정수 자료형을 직접 지정할 수도 있다.
  • 문자열 열은 str이다. pandas 3부터 문자열 기본 자료형이 str이고, 그 전(2.x)에는 object로 표시됐다. 인터넷 예제의 문자열 열이 object로 보이는 것은 이 때문이다. 다만 object 열에는 숫자와 문자열이 섞여 있을 수도 있으므로 실제 값을 확인한다.

열 하나는 Series(값 + index)다. 02장에서 X[:, 1]과 X[:, [1]]이 달랐던 것처럼, 대괄호 안에 이름 하나를 주면 Series, 리스트를 주면 DataFrame이 나온다.

print(type(customers["도시"]).__name__, customers["도시"].shape)
print(type(customers[["도시"]]).__name__, customers[["도시"]].shape)
print(customers["도시"].value_counts())
print(customers.describe())
출력
Series (6,)
DataFrame (6, 1)
도시
서울 3
부산 2
대구 1
Name: count, dtype: int64
고객ID 나이 방문수
count 6.000000 4.000000 6.000000
mean 103.500000 39.500000 16.500000
std 1.870829 11.150486 15.424007
min 101.000000 27.000000 3.000000
25% 102.250000 32.250000 5.750000
50% 103.500000 39.500000 10.000000
75% 104.750000 46.750000 25.500000
max 106.000000 52.000000 41.000000
  • value_counts(): 범주별 개수. 범주 열을 처음 볼 때 쓴다.
  • describe(): 숫자 열의 요약 통계(3-7절). count가 행 수(6)보다 작으면 결측이 있다는 뜻이다. 고객ID도 숫자라서 요약되지만 평균에 뜻이 없다. 숫자로 적힌 이름표일 뿐이다.

index는 이름표이고, 위치는 행이 지금 놓인 순번이다. 처음에는 둘이 같아 보이지만 정렬·필터를 하면 갈라진다.

방법 기준 슬라이스 1:3
df.loc[이름표, 열이름] index 이름표 지금 행 순서에서 이름표 1인 행부터 이름표 3까지, 끝 포함
df.iloc[위치, 열위치] 0부터 센 위치 위치 1, 2, 끝 제외(파이썬과 같음)
by_visit = customers.sort_values("방문수", ascending=False)
print(by_visit[["고객ID", "방문수"]])
print(by_visit.loc[0, "고객ID"], by_visit.iloc[0]["고객ID"])
print(customers.loc[1:3, "고객ID"].tolist(), customers.iloc[1:3]["고객ID"].tolist())
출력
고객ID 방문수
5 106 41
1 102 30
0 101 12
3 104 8
4 105 5
2 103 3
101 106
[102, 103, 104] [102, 103]

loc 슬라이스는 숫자 범위가 아니라 현재 행 순서를 따른다. 정렬된 by_visit에서 loc[1:3]은 이름표 1, 0, 3인 행이다(이름표 2는 그 사이에 없다). 정렬 뒤 loc[0]은 “이름표가 0인 행”(고객 101)이고 iloc[0]은 “지금 맨 위 행”(고객 106)이다. “방문수 1등 고객”을 원했다면 iloc[0]이 맞다.

최댓값의 이름표는 idxmax(), 위치는 argmax()가 준다. 걸러 낸 표에서는 둘이 다르다.

seoul = customers[customers["도시"] == "서울"]
print(seoul[["고객ID", "방문수"]])
i_label, i_pos = seoul["방문수"].idxmax(), seoul["방문수"].argmax()
print(i_label, i_pos)
print(seoul.loc[i_label, "고객ID"], seoul.iloc[i_pos]["고객ID"])
print(seoul.loc[i_pos, "고객ID"]) # 위치를 loc에 넣음: 오류 없이 다른 고객
출력
고객ID 방문수
0 101 12
2 103 3
5 106 41
5 2
106 106
103

마지막 줄이 함정이다. 위치 2를 이름표로 넣었더니 마침 이름표 2(고객 103)가 있어서 오류 없이 틀린 고객이 나왔다. 규칙: idxmax·idxmin은 loc와, argmax·argmin은 iloc와 짝을 맞춘다. 이 규칙은 이름표가 겹치지 않을 때 행 하나를 돌려준다. 이름표가 중복되면 loc가 여러 행을 내고, 최댓값이 여럿이면 처음 나온 것을 고르며, 모두 결측인 열에는 오류가 난다.

이름표를 바꾸거나 다시 매기기

섹션 제목: “이름표를 바꾸거나 다시 매기기”
by_id = customers.set_index("고객ID") # 고객ID를 이름표로
print(by_id.loc[103, "도시"])
print(seoul.reset_index(drop=True)[["고객ID", "방문수"]]) # 0부터 다시 매김, 옛 이름표는 버림
출력
서울
고객ID 방문수
0 101 12
1 103 3
2 106 41

set_index로 의미 있는 열을 이름표로 쓰면 loc[103]처럼 읽기 쉽다. 걸러 낸 뒤 0부터 다시 매기려면 reset_index(drop=True)를 쓴다(drop=True가 없으면 옛 이름표가 index 열로 남는다).

이름표는 계산에서도 쓰인다. Series끼리 계산하거나 Series를 열에 대입하면 위치가 아니라 같은 이름표끼리 맞춘다. 02장의 NumPy 배열과 다른 점이다.

a = pd.Series([1, 2], index=[0, 1])
b = pd.Series([10, 20], index=[1, 0])
print((a + b).tolist()) # 이름표 0: 1 + 20, 이름표 1: 2 + 10
출력
[21, 12]

조건식은 행마다 참/거짓인 불리언 Series를 만든다. 02장의 불리언 마스크와 같다.

mask = (customers["도시"] == "서울") & (customers["방문수"] >= 10)
print(mask.tolist())
print(customers.loc[mask, ["고객ID", "방문수"]])
print(customers[customers["등급"].isin(["골드", "실버"])]["고객ID"].tolist())
print(customers[customers["방문수"].between(5, 12)]["고객ID"].tolist()) # 5 이상 12 이하
print(customers[~(customers["도시"] == "서울")]["고객ID"].tolist()) # ~: 아닌 것
출력
[True, False, False, False, False, True]
고객ID 방문수
0 101 12
5 106 41
[101, 102, 104, 106]
[101, 104, 105]
[102, 104, 105]
  • 그리고 &, 또는 |, 아님 ~. 파이썬의 and·or·not은 Series에 쓸 수 없다.
  • 조건마다 괄호를 친다. &가 ==·>=보다 먼저 계산되기 때문이다.
try:
customers[customers["도시"] == "서울" & customers["방문수"] >= 10]
except TypeError:
print("TypeError: 괄호 없이 쓰면 \"서울\" & customers[\"방문수\"]부터 계산된다")
출력
TypeError: 괄호 없이 쓰면 "서울" & customers["방문수"]부터 계산된다

새 열은 이름에 대입하면 생긴다. 조건에 맞는 행만 바꿀 때는 df.loc[조건, 열] = 값을 한 번에 쓴다.

customers["쿠폰"] = 0
customers.loc[customers["등급"] == "골드", "쿠폰"] = 3000
print(customers[["고객ID", "등급", "쿠폰"]])
출력
고객ID 등급 쿠폰
0 101 실버 0
1 102 골드 3000
2 103 브론즈 0
3 104 실버 0
4 105 브론즈 0
5 106 골드 3000

대괄호를 두 번 이어 쓰는 연쇄 대입(chained assignment)은 원본을 바꾸지 않는다.

import warnings
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always")
customers[customers["도시"] == "부산"]["쿠폰"] = 9999 # 연쇄 대입
print(customers["쿠폰"].tolist())
print(type(caught[0].message).__name__)
customers = customers.drop(columns="쿠폰") # 예제용 열 지우기
출력
[0, 3000, 0, 0, 0, 3000]
ChainedAssignmentError

customers[조건]이 먼저 새 표를 만들고, 그 새 표의 쿠폰을 바꾼 뒤 버리기 때문이다. pandas 3부터는 Copy-on-Write가 기본이라 이 규칙이 일정하다. 골라낸 표(seoul 같은)를 고쳐도 원본은 바뀌지 않고, 원본을 바꾸려면 원본에 loc로 대입한다. 노트북에서는 위 코드가 ChainedAssignmentError 경고를 띄운다(여기서는 경고를 잡아 이름만 출력했다). pandas 2.x 예제에서 보던 SettingWithCopyWarning도 같은 문제를 알리던 경고다.

print(customers.isna().sum())
print(customers["나이"].mean(), customers["나이"].count(), len(customers))
출력
고객ID 0
도시 0
등급 0
나이 2
방문수 0
dtype: int64
39.5 4 6

count()는 결측을 뺀 개수이고, mean()은 결측을 건너뛰고 4명의 평균을 낸다. 결측은 세 가지로 다룬다.

방법 코드 언제 주의
행 삭제 dropna(subset=[열]) 결측 행이 아주 적고 무작위일 때 데이터가 준다. 테스트·제출 행은 지울 수 없다
값 대체 fillna(값) 숫자 열은 중앙값·평균, 범주 열은 최빈값이나 "없음" 대체값은 훈련 데이터에서 구한다
결측 표시 열 isna().astype(int) 결측 자체가 정보일 수 있을 때(나이를 안 적은 고객) 대체와 함께 쓴다

대체값을 훈련·테스트를 합친 데이터에서 구하면 테스트 정보가 훈련에 섞인다. 이것을 데이터 누수(data leakage)라 하고 5장에서 자세히 다룬다. 지금은 “값은 훈련 데이터에서 구하고, 같은 값을 테스트에 쓴다”만 기억한다.

train, test = customers.iloc[:4].copy(), customers.iloc[4:].copy()
age_median = train["나이"].median() # 훈련 데이터 4명 중 결측 아닌 3명의 중앙값
print("훈련 중앙값", age_median, "/ 테스트 중앙값", test["나이"].median())
for part in (train, test):
part["나이_결측"] = part["나이"].isna().astype(int)
part["나이"] = part["나이"].fillna(age_median)
print(pd.concat([train, test])[["고객ID", "나이", "나이_결측"]])
출력
훈련 중앙값 34.0 / 테스트 중앙값 52.0
고객ID 나이 나이_결측
0 101 34.0 0
1 102 34.0 1
2 103 27.0 0
3 104 45.0 0
4 105 52.0 0
5 106 34.0 1

테스트의 고객 106은 테스트 중앙값(52)이 아니라 훈련 중앙값(34)으로 채웠다. 이 과정을 sklearn에서는 SimpleImputer(strategy="median", add_indicator=True)가 fit(훈련 데이터에서 중앙값 계산)과 transform(같은 값으로 채우기)으로 나눠 해 준다(5·9장).

결측이 NaN이 아닌 모양으로 오는 경우도 많다. "-", 빈 문자열, -1, 999 같은 값이다. 숫자 열에 이런 문자가 섞이면 열이 문자열(또는 object)이 되므로 pd.to_numeric(..., errors="coerce")로 숫자로 바꾸고, 바꿀 수 없는 값은 NaN으로 만든다. -1·999처럼 숫자로 적힌 결측 표시는 숫자로 바뀐 채 남으므로, 데이터 설명에서 결측 표시라고 확인했다면 replace([-1, 999], np.nan)으로 따로 바꾼다.

raw = pd.Series(["34", "-", "27", "", "45"])
age = pd.to_numeric(raw, errors="coerce")
print(raw.dtype, "→", age.dtype, age.tolist())
출력
str → float64 [34.0, nan, 27.0, nan, 45.0]

CSV 파일이면 처음부터 pd.read_csv(경로, na_values=["-", "없음"])처럼 결측 표시를 알려 준다.

수학 상자: 평균·분산·표준편차·분위수

섹션 제목: “수학 상자: 평균·분산·표준편차·분위수”

값 x1,…,xNx_1, \dots, x_N이 있을 때:

통계 뜻 식 pandas
평균(mean) 값의 무게중심 xˉ=x1+⋯+xNN\bar{x} = \dfrac{x_1 + \dots + x_N}{N} s.mean()
분산(variance) 평균에서 떨어진 정도. 표본 분산은 편차 제곱의 합을 N−1N - 1로 나눈다 ∑i(xi−xˉ)2N−1\dfrac{\sum_i (x_i - \bar{x})^2}{N - 1} s.var()
표준편차(standard deviation) 분산의 제곱근, 원래 단위 분산\sqrt{\text{분산}} s.std()
중앙값(median) 정렬했을 때 한가운데 값 N이 짝수면 가운데 두 값의 평균 s.median()
q 분위수(quantile) 값을 정렬했을 때 비율 qq에 해당하는 위치의 값. 같은 값이 많으면 그보다 작은 값의 비율은 qq와 크게 다를 수 있다 0.5 분위수 = 중앙값 s.quantile(q)
사분위 범위(IQR) 가운데 50%가 퍼진 폭 Q3−Q1Q_3 - Q_1 (0.75 분위수 − 0.25 분위수) s.quantile(.75) - s.quantile(.25)
x = pd.Series([3, 5, 5, 6, 8, 9, 12])
print(x.mean().round(3), x.median(), x.std().round(3), x.quantile([0.25, 0.75]).tolist())
x_out = pd.Series([3, 5, 5, 6, 8, 9, 120]) # 마지막 값만 120으로
print(x_out.mean().round(3), x_out.median(), x_out.std().round(3), x_out.quantile([0.25, 0.75]).tolist())
출력
6.857 6.0 3.024 [5.0, 8.5]
22.286 6.0 43.134 [5.0, 8.5]

값 하나가 커지자 평균과 표준편차는 크게 움직였지만 중앙값과 사분위수는 그대로다. 그래서 이상치가 있을 수 있는 열의 결측은 중앙값으로 채우는 경우가 많다(3-6절). 평균이 중앙값보다 훨씬 크면 큰 값 쪽으로 꼬리가 길거나 큰 이상치가 있다는 신호다.

분산의 분모 함정. pandas의 std()·var()는 N − 1로 나누고(표본 분산), NumPy의 np.std와 sklearn StandardScaler는 N으로 나눈다. std()는 그렇게 구한 분산의 제곱근이고, N은 결측을 뺀 개수다.

print(round(x.std(), 4), round(np.std(x.to_numpy()), 4), round(x.std(ddof=0), 4))
출력
3.0237 2.7994 2.7994

ddof(자유도 보정)로 분모를 N − ddof로 정한다. 표본이 많으면 차이가 작지만, 직접 표준화한 값과 StandardScaler 결과를 비교할 때 맞지 않는 흔한 이유다. 분위수가 두 값 사이에 걸리면 pandas는 기본으로 두 값 사이를 직선으로 보간한다.

IQR 규칙: Q1−1.5×IQRQ_1 - 1.5 \times \text{IQR}보다 작거나 Q3+1.5×IQRQ_3 + 1.5 \times \text{IQR}보다 큰 값을 이상치 후보로 본다. 상자 그림(3-9절)의 수염 밖 점이 이것이다. 후보일 뿐이므로 지우기 전에 입력 오류인지 실제 값인지 확인한다.

q1, q3 = x_out.quantile(0.25), x_out.quantile(0.75)
iqr = q3 - q1
print(q1, q3, iqr, x_out[(x_out < q1 - 1.5 * iqr) | (x_out > q3 + 1.5 * iqr)].tolist())
출력
5.0 8.5 3.5 [120]

모델은 "서울"을 계산할 수 없다. 범주 열은 숫자로 바꿔야 하는데, 범주에는 두 종류가 있다.

  • 명목형(nominal): 순서가 없다. 도시, 결제 수단, 색.
  • 순서형(ordinal): 순서가 있다. 등급(브론즈 < 실버 < 골드), 옷 사이즈(S < M < L).

범주마다 정수 하나를 주는 것이 정수 인코딩이다. 짧고 열이 늘지 않지만 숫자의 크기와 간격이 생긴다.

codes, names = pd.factorize(customers["도시"], sort=True) # 가나다순으로 0, 1, 2
print(list(names), codes.tolist())
grade_order = {"브론즈": 0, "실버": 1, "골드": 2} # 순서를 사람이 정한다
print(customers["등급"].map(grade_order).tolist())
print(pd.factorize(customers["등급"], sort=True)[1].tolist()) # 자동(가나다순)은 순서가 틀린다
출력
['대구', '부산', '서울'] [2, 1, 2, 0, 1, 2]
[1, 2, 0, 1, 0, 2]
['골드', '브론즈', '실버']
  • 도시를 대구 0, 부산 1, 서울 2로 바꾸면, 선형 모델(4·6장)은 “서울 − 부산 = 부산 − 대구”이고 “서울은 대구보다 2배 떨어져 있다”고 읽는다. 가나다순일 뿐인데 없는 순서와 간격을 가정한 것이다. 명목형 범주를 선형 모델에 넣을 때는 정수 인코딩을 쓰지 않는다.
  • 등급처럼 순서가 실제로 있으면 순서를 직접 정한 매핑(map)을 쓸 수 있다. 자동으로 매기면 가나다순이라 골드 < 브론즈 < 실버가 된다. 다만 0, 1, 2를 선형 모델에 넣으면 “한 단계 오를 때마다 효과가 같다”(브론즈→실버와 실버→골드가 같은 차이)는 등간격 가정까지 들어간다. 단계마다 효과가 크게 다를 수 있으면 순서형이라도 원-핫이 더 맞을 수 있다.
  • 결정 트리(7장)는 “값이 1.5보다 작은가”처럼 기준을 나눠 가며 배우므로 정수 인코딩의 순서 가정에 덜 민감하다. 그래도 순서 없는 범주를 정수로 넣으면 나누는 횟수가 늘어날 수 있다.

원-핫(one-hot)은 범주마다 열 하나를 만들고 해당 열만 1로 둔다. 02장 텍스트의 원-핫과 같은 생각이다. 순서와 간격이 생기지 않는다.

print(pd.get_dummies(customers["도시"], prefix="도시", dtype=int))
출력
도시_대구 도시_부산 도시_서울
0 0 0 1
1 0 1 0
2 0 0 1
3 1 0 0
4 0 1 0
5 0 0 1

훈련 데이터에서 범주 목록을 정한 뒤, 테스트에 훈련에 없던 범주가 나오면 문제가 된다. get_dummies를 훈련·테스트에 따로 쓰면 열이 달라진다.

city_train = pd.Series(["서울", "부산", "서울", "대구"], name="도시")
city_test = pd.Series(["부산", "광주"], name="도시")
print(pd.get_dummies(city_train, dtype=int).columns.tolist())
print(pd.get_dummies(city_test, dtype=int).columns.tolist())
출력
['대구', '부산', '서울']
['광주', '부산']

훈련은 3열, 테스트는 2열이고 열의 뜻도 다르다. 모델은 열 순서로 값을 읽으므로 이대로 넣으면 엉뚱한 결과가 나오거나 열 수가 달라 오류가 난다. 열 목록을 훈련 데이터에서 정하고 테스트를 거기에 맞춘다.

train_cols = pd.get_dummies(city_train, dtype=int).columns
test_oh = pd.get_dummies(city_test, dtype=int).reindex(columns=train_cols, fill_value=0)
print(test_oh)
출력
대구 부산 서울
0 0 1 0
1 0 0 0

reindex는 훈련 열만 남기고(광주 열은 버림), 없는 열은 0으로 채운다. 그래서 광주 행은 모두 0이다. “아는 범주 어디에도 속하지 않음”이라는 뜻이다. sklearn OneHotEncoder는 이 일을 fit(훈련 범주 기억)과 transform으로 나눠 해 준다.

from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit(city_train.to_frame()) # 2차원 입력: (N, 1)
print(enc.get_feature_names_out().tolist())
print(enc.transform(city_test.to_frame()))
try:
OneHotEncoder(sparse_output=False).fit(city_train.to_frame()).transform(city_test.to_frame())
except ValueError as e:
print("기본값(handle_unknown='error'):", e)
출력
['도시_대구', '도시_부산', '도시_서울']
[[0. 1. 0.]
[0. 0. 0.]]
기본값(handle_unknown='error'): Found unknown categories ['광주'] in column 0 during transform
  • handle_unknown="ignore": 처음 보는 범주를 모두 0으로 둔다. 기본값 "error"는 오류를 낸다. 시험·제출처럼 테스트 행을 하나도 빼면 안 될 때는 "ignore"를 쓴다.
  • sparse_output=False: 결과를 보통 배열로. 기본값은 0이 아닌 값만 저장하는 희소 행렬이다.
  • 범주가 아주 많은 열(고객ID, 우편번호)을 원-핫하면 열이 수천 개가 된다. 표본마다 다른 ID는 새 고객에게 쓸모가 없으므로 특성에서 빼고, 드문 범주는 "기타"로 묶는다(OneHotEncoder(min_frequency=...)).

groupby: 나누고, 계산하고, 합치기

섹션 제목: “groupby: 나누고, 계산하고, 합치기”

groupby는 열 값으로 행을 나누고, 그룹마다 계산하고, 결과를 표로 합친다.

print(customers.groupby("도시")["방문수"].mean())
print(customers.groupby("도시")["나이"].agg(["size", "count", "mean"]))
summary = customers.groupby("도시").agg(고객수=("고객ID", "size"), 평균방문=("방문수", "mean"))
print(summary.sort_values("고객수", ascending=False))
출력
도시
대구 8.000000
부산 17.500000
서울 18.666667
Name: 방문수, dtype: float64
size count mean
도시
대구 1 1 45.0
부산 2 1 52.0
서울 3 2 30.5
고객수 평균방문
도시
서울 3 18.666667
부산 2 17.500000
대구 1 8.000000
  • 결과의 index는 그룹 값(도시)이다. 기본으로 가나다순 정렬된다.
  • size는 결측을 포함한 행 수, count는 결측을 뺀 개수다. 서울 고객 3명 중 나이 정보가 있는 고객은 2명이다.
  • agg(새이름=(열, 함수))로 여러 집계에 이름을 붙인다.

그룹 결과를 원래 행마다 붙이려면 transform을 쓴다. 결과가 원래 표와 같은 index를 가진다.

city_mean = customers.groupby("도시")["방문수"].transform("mean")
print(pd.DataFrame({"고객ID": customers["고객ID"], "도시평균": city_mean.round(1),
"평균대비": (customers["방문수"] - city_mean).round(1)}))
출력
고객ID 도시평균 평균대비
0 101 18.7 -6.7
1 102 17.5 12.5
2 103 18.7 -15.7
3 104 8.0 0.0
4 105 17.5 -12.5
5 106 18.7 22.3

“같은 도시 평균보다 얼마나 더 왔나” 같은 특성을 만들 때 쓴다(특성 공학, 9장).

주문 표에는 고객ID만 있고 도시는 고객 표에 있다. 공통 열(키)로 두 표를 합친다.

orders = pd.DataFrame({
"주문ID": [1, 2, 3, 4, 5, 6, 7, 8],
"고객ID": [101, 103, 101, 106, 102, 107, 103, 106],
"금액": [12000, 5000, 8000, 30000, 15000, 7000, 4000, 22000],
})
merged = orders.merge(customers[["고객ID", "도시"]], on="고객ID", how="left",
validate="many_to_one", indicator=True)
print(merged)
print(len(orders), len(merged))
출력
주문ID 고객ID 금액 도시 _merge
0 1 101 12000 서울 both
1 2 103 5000 서울 both
2 3 101 8000 서울 both
3 4 106 30000 서울 both
4 5 102 15000 부산 both
5 6 107 7000 NaN left_only
6 7 103 4000 서울 both
7 8 106 22000 서울 both
8 8
  • how="left": 왼쪽(주문) 행을 모두 남긴다. 고객 표에 없는 107은 도시가 NaN이다. how="inner"는 양쪽에 다 있는 키만 남겨 주문 6이 사라진다.
  • indicator=True: 행마다 어느 쪽에서 왔는지(both, left_only) 알려 주는 _merge 열. 짝을 못 찾은 행을 찾을 때 쓴다.
  • validate="many_to_one": “오른쪽 표의 키는 겹치지 않는다”를 확인한다. 주문은 한 고객이 여러 번 할 수 있으니 many, 고객 표는 한 고객이 한 줄이니 one이다.

키가 중복되면 행이 불어난다. 고객 표에 고객 103이 두 번 들어간 경우(주소 변경 때 새 줄을 추가했다든지)를 보자.

dup = pd.concat([customers, customers[customers["고객ID"] == 103]])
bad = orders.merge(dup[["고객ID", "도시"]], on="고객ID", how="left")
print(len(orders), len(bad), orders["금액"].sum(), bad["금액"].sum())
try:
orders.merge(dup[["고객ID", "도시"]], on="고객ID", how="left", validate="many_to_one")
except pd.errors.MergeError as e:
print("MergeError:", str(e).splitlines()[0])
print(dup["고객ID"].duplicated().sum())
출력
8 10 103000 112000
MergeError: Merge keys are not unique in right dataset; not a many-to-one merge
1

고객 103의 주문 2건이 각각 2줄이 되어 행이 8 → 10, 매출 합계가 9000원 늘었다. 오류는 나지 않는다. 그래서 합친 뒤에는 행 수와 합계를 확인하고, validate로 키 중복을 미리 막는다. 중복은 duplicated()로 찾고, 어느 줄을 남길지 정해 drop_duplicates("고객ID", keep="last")처럼 정리한다.

합친 표로 도시별 매출을 구하면 두 기능이 이어진다.

print(merged.groupby("도시", dropna=False)["금액"].sum())
출력
도시
부산 15000
서울 81000
NaN 7000
Name: 금액, dtype: int64

dropna=False를 주지 않으면 도시가 NaN인 주문(고객 107)이 집계에서 조용히 빠진다.

숫자 요약만으로는 분포 모양과 관계를 놓치기 쉽다. 모델을 만들기 전에 세 가지 그림을 먼저 본다. sklearn에 들어 있는 당뇨병 데이터(환자 442명, 1년 뒤 병 진행 정도 target)로 그린다.

import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
dia = load_diabetes(as_frame=True, scaled=False).frame
print(dia.shape)
print(dia[["age", "bmi", "target"]].describe().round(1))
dia["bmi_구간"] = pd.cut(dia["bmi"], bins=[0, 25, 30, 100], labels=["25 이하", "25 초과~30 이하", "30 초과"])
print(dia["bmi_구간"].value_counts(sort=False).tolist())
print(dia.groupby("bmi_구간", observed=True)["target"].median().tolist())
print(dia[["age", "bmi", "bp", "target"]].corr()["target"].round(2).tolist())
출력
(442, 11)
age bmi target
count 442.0 442.0 442.0
mean 48.5 26.4 152.1
std 13.1 4.4 77.1
min 19.0 18.0 25.0
25% 38.2 23.2 87.0
50% 50.0 25.7 140.5
75% 59.0 29.3 211.5
max 79.0 42.2 346.0
[190, 157, 95]
[96.0, 172.0, 230.0]
[0.19, 0.59, 0.44, 1.0]
  • pd.cut: 숫자를 구간 범주로 나눈다. bins=[0, 25, 30, 100]은 (0, 25], (25, 30], (30, 100] 세 구간이다(오른쪽 끝 포함).
  • observed=True: 구간 범주로 묶을 때 실제로 있는 그룹만 결과에 넣는다.
  • corr(): 두 열이 직선으로 함께 움직이는 정도인 상관계수(기본은 피어슨, −1~1). 양수면 같은 방향, 음수면 반대 방향이고 절댓값이 클수록 관계가 강하다. 0.59인 bmi가 target과 가장 같이 움직인다. 상관은 직선 관계만 보고, 원인을 뜻하지 않는다. 0에 가까워도 곡선 관계는 있을 수 있고, 값이 하나뿐인 열은 NaN이 나온다.
plt.rcParams["font.family"] = "Malgun Gothic" # Windows 한글 글꼴(없으면 제목 한글이 네모로 나온다)
plt.rcParams["axes.unicode_minus"] = False
fig, axes = plt.subplots(1, 3, figsize=(12, 3.4))
dia["target"].plot.hist(bins=30, ax=axes[0], title="target 분포 (히스토그램)")
dia.boxplot(column="target", by="bmi_구간", ax=axes[1])
axes[1].set_title("bmi 구간별 target (상자 그림)")
dia.plot.scatter(x="bmi", y="target", s=8, alpha=0.5, ax=axes[2], title="bmi와 target (산점도)")
fig.suptitle("")
fig.tight_layout()
print([ax.get_title() for ax in axes])
plt.close(fig)
출력
['target 분포 (히스토그램)', 'bmi 구간별 target (상자 그림)', 'bmi와 target (산점도)']
당뇨병 데이터의 target 히스토그램, bmi 구간별 target 상자 그림, bmi와 target 산점도당뇨병 데이터의 target 히스토그램, bmi 구간별 target 상자 그림, bmi와 target 산점도

그림 설명. 세 그림이 나란히 있다. 왼쪽 히스토그램은 가로축이 target(25~346), 세로축이 구간별 환자 수(Frequency)이고, 50~100 사이에 많이 몰리며(가장 높은 막대는 약 68~79 구간, 31명) 오른쪽으로 꼬리가 길다. 가운데 상자 그림은 가로축이 bmi 구간 세 개(25 이하 190명, 25 초과~30 이하 157명, 30 초과 95명), 세로축이 target이고, 상자 안 중앙값 선이 96 → 172 → 230으로 오른다. 25 이하 구간에는 수염 위쪽에 이상치 후보 점이 몇 개 있다. 오른쪽 산점도는 가로축이 bmi(18~42), 세로축이 target이고, 점들이 오른쪽 위로 퍼진 띠를 이룬다(상관계수 0.59).

그림 보는 것 위 그림에서
히스토그램(histogram) 값 하나의 분포: 모양, 치우침, 동떨어진 값 왼쪽에 몰리고 오른쪽 꼬리가 길다. 평균(152.1)이 중앙값(140.5)보다 크다
상자 그림(box plot) 그룹별 중앙값·사분위 범위·이상치 후보 비교 bmi 구간이 올라갈수록 target 중앙값이 오른다
산점도(scatter plot) 두 숫자 열의 관계 오른쪽 위로 퍼진 띠. 관계는 있지만 흩어짐이 크다

상자 그림의 상자는 Q1~Q3, 가운데 선은 중앙값, 수염은 1.5×IQR 안의 가장 먼 값, 수염 밖 점은 이상치 후보다(3-7절). 노트북에서는 plt.close(fig) 대신 셀 끝에 fig를 두거나 plt.show()로 그림을 본다.

이 장의 도구를 모으면 문자열·결측이 섞인 표를 02장의 (N, d) 숫자 배열로 만들 수 있다.

X = customers[["도시", "등급", "나이", "방문수"]].copy()
X["나이_결측"] = X["나이"].isna().astype(int)
X["나이"] = X["나이"].fillna(X["나이"].median()) # 실제로는 훈련 데이터의 중앙값(3-6절)
X["등급"] = X["등급"].map(grade_order) # 순서형: 직접 정한 정수
X = pd.get_dummies(X, columns=["도시"], dtype=int) # 명목형: 원-핫
print(X)
arr = X.to_numpy(dtype=float)
print(arr.shape, arr.dtype, X.columns.tolist())
출력
등급 나이 방문수 나이_결측 도시_대구 도시_부산 도시_서울
0 1 34.0 12 0 0 0 1
1 2 39.5 30 1 0 1 0
2 0 27.0 3 0 0 0 1
3 1 45.0 8 0 1 0 0
4 0 52.0 5 0 0 1 0
5 2 39.5 41 1 0 0 1
(6, 7) float64 ['등급', '나이', '방문수', '나이_결측', '도시_대구', '도시_부산', '도시_서울']

고객ID는 특성에서 뺐다. 고객마다 다른 이름표라 크기에 뜻이 없고, 처음 보는 고객에게 쓸 수 없기 때문이다. to_numpy()가 02장의 배열을 돌려준다. 열 이름은 배열에 없으므로 X.columns를 함께 남겨 둔다. 이 과정을 훈련·테스트에 같은 규칙으로 적용하는 방법(ColumnTransformer, Pipeline)은 9장에서 묶는다.

상황 고를 것 이유 장
숫자 열에 결측이 있다 훈련 데이터의 중앙값으로 채우고, 결측 자체가 정보일 수 있으면 결측 표시 열을 더한다 행 삭제는 데이터를 줄이고 테스트·제출 행에는 쓸 수 없다. 중앙값은 이상치에 덜 흔들린다 03
순서 없는 범주(도시·결제 수단)를 모델에 넣는다 원-핫. 범주 목록은 훈련 데이터에서 정하고 처음 보는 범주는 모두 0(handle_unknown="ignore") 정수 인코딩은 없는 순서·간격을 만든다(트리 모델은 덜 민감, 07장) 03
순서 있는 범주(등급·사이즈), 단계마다 효과가 비슷하다고 볼 수 있다 순서를 직접 정한 정수 매핑(map). 단계별 효과가 크게 다를 수 있으면 원-핫 자동 매기기는 가나다순이라 순서가 틀린다. 정수는 선형 모델에 등간격을 가정시킨다 03
범주 종류가 아주 많다(ID·우편번호) 표본마다 다른 ID는 특성에서 빼고, 드문 범주는 “기타”로 묶는다 원-핫 열이 폭발하고, ID는 새 표본에 일반화되지 않는다 03
두 표를 합친다 merge(validate=...) + 전후 행 수·합계 확인 키가 중복되면 오류 없이 행이 불어난다 03

11문항. 풀면 결과가 기록되고 복습 일정에 들어간다.

문제 1 · 빈칸

customers 표에서 도시 열 하나를 shape (6, 1)인 2차원 표로 꺼내려면 customers[____]의 빈칸에 무엇을 쓰는가?

정답과 해설

정답: ["도시"]

대괄호 안에 열 이름 하나("도시")를 주면 1차원 Series (6,), 리스트(["도시"])를 주면 2차원 DataFrame (6, 1)이 나온다. sklearn 인코더처럼 2차원 입력을 받는 곳에는 리스트로 꺼낸다.

문제 2 · 결과 예측

아래 코드의 출력은?

import pandas as pd
df = pd.DataFrame({"x": [5, 6, 7, 8]})
print(df.loc[1:2, "x"].tolist(), df.iloc[1:2]["x"].tolist())
보기
정답과 해설

정답: 1번

loc 슬라이스는 이름표 기준이고 끝을 포함하므로 이름표 1, 2의 [6, 7]이다. iloc 슬라이스는 위치 기준이고 파이썬처럼 끝을 빼므로 위치 1의 [6]만 나온다.

오답 해설: 나머지는 loc도 끝을 뺀다고 보거나 iloc도 끝을 포함한다고 본 답이다.

문제 3 · O/X

pandas 3에서 customers[customers["등급"] == "골드"]["쿠폰"] = 3000을 실행하면 골드 고객의 쿠폰 열이 3000으로 바뀐다.

보기
정답과 해설

정답: X (거짓)

대괄호를 두 번 이은 연쇄 대입이다. 앞의 customers[조건]이 새 표를 만들고, 그 새 표의 열을 바꾼 뒤 버리므로 원본은 그대로다(ChainedAssignmentError 경고). customers.loc[customers["등급"] == "골드", "쿠폰"] = 3000처럼 loc 한 번으로 쓴다.

문제 4 · 객관식

제출할 테스트 데이터의 소득 열에 결측이 있다. 소득에는 아주 큰 값이 가끔 있고, 소득을 적지 않은 것 자체가 신호일 수 있다. 어떻게 처리하는가?

보기
정답과 해설

정답: 2번

대체값은 훈련 데이터에서 구하고, 큰 값에 덜 흔들리는 중앙값을 쓴다. 결측 자체가 정보일 수 있으므로 결측 표시 열을 함께 둔다.

오답 해설: 테스트·제출 행은 지울 수 없다. 테스트 값으로 구한 대체값이나 합친 데이터의 중앙값은 테스트 정보가 섞이는 데이터 누수다. 평균은 큰 값에 끌려가기도 한다.

문제 5 · 결과 예측

아래 코드의 출력은?

import numpy as np
import pandas as pd
s = pd.Series([2.0, 4.0, 6.0])
print(s.std(), np.std(s.to_numpy()).round(3))
보기
정답과 해설

정답: 2번

평균 4에서의 편차 제곱합은 4 + 0 + 4 = 8이다. pandas std()는 N − 1 = 2로 나눠 4=2.0\sqrt{4} = 2.0, np.std는 N = 3으로 나눠 8/3≈1.633\sqrt{8/3} \approx 1.633이다.

오답 해설: 두 값이 같다는 답은 분모 차이를 놓친 것이다. 1.633 2.0은 pandas와 NumPy의 분모를 거꾸로 기억한 답이다.

문제 6 · 객관식

어떤 열의 Q1이 10, Q3이 20이다. IQR 규칙으로 이상치 후보가 되는 값은?

보기
정답과 해설

정답: 4번

IQR = 20 − 10 = 10이므로 경계는 10 − 15 = −5와 20 + 15 = 35다. 이 범위 밖인 36만 후보다. 후보일 뿐이라 지우기 전에 입력 오류인지 실제 값인지 확인한다.

오답 해설: 0과 −4는 아래 경계 −5보다 크고, 34는 위 경계 35보다 작아 범위 안이다.

문제 7 · O/X

옷 사이즈 열(S·M·L)을 pd.factorize(..., sort=True)로 자동 정수화하면 S < M < L 순서의 정수가 붙는다.

보기
정답과 해설

정답: X (거짓)

sort=True는 글자 순서로 정렬하므로 L, M, S 순으로 0, 1, 2가 붙어 실제 크기와 거꾸로 된다. 순서형 범주는 {"S": 0, "M": 1, "L": 2}처럼 순서를 직접 정한 매핑을 map으로 쓴다.

문제 8 · 결과 예측

아래 코드의 출력은?

import pandas as pd
df = pd.DataFrame({"팀": ["A", "A", "A", "B"], "점수": [10, None, 30, 5]})
r = df.groupby("팀")["점수"].agg(["size", "count", "mean"])
print(r.loc["A"].tolist())
보기
정답과 해설

정답: 3번

팀 A는 3행이라 size가 3, 결측을 뺀 점수는 10과 30이라 count가 2, mean은 결측을 건너뛰어 20이다. 한 행으로 꺼내면서 모두 실수로 바뀐다.

오답 해설: count가 3인 답은 결측도 센다고 본 것이다. size가 2인 답은 size도 결측을 뺀다고 본 것이다. 13.33은 결측을 0으로 보고 3으로 나눈 평균이다.

문제 9 · 객관식

bmi 구간 세 개(그룹)마다 target의 중앙값·퍼짐·이상치 후보를 한눈에 비교하려면 어떤 그림을 그리는가?

보기
정답과 해설

정답: 2번

상자 그림은 그룹마다 상자(Q1~Q3), 가운데 선(중앙값), 수염 밖 점(이상치 후보)을 나란히 보여 준다.

오답 해설: 산점도는 두 숫자 열의 관계를, 히스토그램은 값 하나의 분포 모양을 본다. 선 그래프는 시간처럼 순서가 있는 변화를 볼 때 쓰며, 그룹별 분포 비교에는 맞지 않는다.

문제 10 · O/X

당뇨병 데이터에서 bmi와 target의 상관계수가 0.59이므로, bmi가 높아지면 target이 높아진다는 원인 관계가 확인됐다.

보기
정답과 해설

정답: X (거짓)

상관계수는 두 열이 직선으로 함께 움직이는 정도만 잰다. 함께 움직이는 이유가 bmi 때문인지, 나이 같은 다른 요인 때문인지는 상관만으로 알 수 없다.

문제 11 · 객관식

주문 표의 우편번호 열에 6천 종류가 있고 대부분 한두 번만 나온다. 선택 기준표에 따르면 어떻게 하는가?

보기
정답과 해설

정답: 3번

범주가 아주 많으면 원-핫 열이 폭발하고 한두 번 나온 범주는 배울 거리가 없다. 드문 범주를 "기타"로 묶어 열 수를 줄인다(OneHotEncoder(min_frequency=...)).

오답 해설: 6천 열 원-핫은 열이 폭발한다. 우편번호는 명목형이라 정수 인코딩은 없는 순서와 간격을 만든다. 결측 표시 열은 결측 처리 방법이지 범주 인코딩이 아니다.

실습/문제/ch03_표_데이터_다루기_pandas.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안에 끝난다. 다 푼 뒤 해설 노트북과 비교한다.

번호 유형 내용
1 개념 정렬 뒤 loc·iloc·idxmin·argmin 결과 예측
2 코드 조건 필터와 loc 대입(연쇄 대입 피하기)
3 코드 훈련 중앙값으로 결측 채우기 + 결측 표시 열
4 개념 기술 통계 참/거짓(이상치, 분모, 결측)
5 코드 훈련 범주 기준 원-핫, 처음 보는 범주
6 코드 groupby 집계와 transform
7 코드 중복 키 정리 후 merge, 행 수·합계 확인
8 코드 IQR 규칙으로 이상치 후보 찾기 + 상자 그림
9 사례 병합 뒤 매출이 부푼 원인 진단
10 사례 열마다 인코딩 방법 고르기