김신건의 로그 - 위키 / pandas

[Pandas] date_range / Timestamp

koa (김신건) — Fri, 17 Jul 2026 00:00:00 GMT

정의

pd.date_range : 정해진 시작/끝/간격으로 datetime 시퀀스 생성
pd.Timestamp : pandas 의 단일 datetime 객체
pd.Timedelta : 시간 차이

사용 상황

상황	사용 API
보고 기간 목록 생성	`pd.date_range('2024-01', '2024-12', freq='MS')`
DataFrame 의 누락 날짜 채우기	`.reindex(date_range, fill_value=0)`
두 날짜의 차이 계산	`Timestamp - Timestamp` -> `Timedelta`
영업일 목록 추출	`pd.date_range(start, end, freq='B')`
월 단위 더하기	`Timestamp + DateOffset(months=3)`
DatetimeIndex 용 인덱스 생성	`pd.date_range(...)` -> `.set_index(...)`

시각화

pandas 의 datetime 타입 계층:

flowchart TD
    PD["pandas datetime 생태계"]
    PD --> TS["pd.Timestamp: 단일 시점"]
    PD --> TD["pd.Timedelta: 시간 차이"]
    PD --> DO["pd.DateOffset: 달력 기반 오프셋"]
    PD --> PP["pd.Period: 기간 구간"]
    PD --> DR["pd.date_range: 시퀀스 생성"]
    DR --> DTI["DatetimeIndex: 시계열 인덱스"]
    TS --> Op["Timestamp +/- Timedelta -> Timestamp"]
    TS --> Op2["Timestamp +/- DateOffset -> Timestamp"]

date_range 파라미터 조합:

flowchart LR
    P1["start + end + freq"] --> R1["날짜 범위 내 등간격"]
    P2["start + periods + freq"] --> R2["시작부터 N개"]
    P3["end + periods + freq"] --> R3["종료 전 N개"]
    P1 --> Warn["periods 와 동시 사용 불가"]

date_range

pd.date_range(start='2024-01-01', end='2024-01-31', freq='D')
pd.date_range(start='2024-01-01', periods=10, freq='D')
pd.date_range(end='2024-01-31', periods=10, freq='D')

start, end, periods, freq 중 3 개 만 지정.

freq 옵션 (대표)

freq	의미
`D`	매일
`B`	영업일
`W`, `W-MON`	매주 (요일 지정 가능)
`MS`, `ME`	월초/월말
`QS`, `QE`	분기초/분기말
`YS`, `YE`	연초/연말
`h`, `30min`, `15s`	시간 단위 (숫자 prefix 가능)
`2D`, `3W`	곱셈

tz 지정

pd.date_range('2024-01-01', periods=10, freq='D', tz='Asia/Seoul')
pd.date_range('2024-01-01', periods=10, freq='D', tz='UTC')

Timestamp 생성

pd.Timestamp('2024-01-15')
pd.Timestamp('2024-01-15 14:30:00', tz='Asia/Seoul')
pd.Timestamp(year=2024, month=1, day=15)
pd.Timestamp.now()
pd.Timestamp.today()      # 같음 (now 와 거의 동일)

연산

ts = pd.Timestamp('2024-01-15')
ts + pd.Timedelta(days=10)         # 2024-01-25
ts + pd.DateOffset(months=1)       # 2024-02-15 (월 단위)
ts - pd.Timestamp('2023-12-25')    # Timedelta('21 days')

Timedelta 는 정해진 시간, DateOffset 은 달력 단위 (월 길이 다름 고려).

Timedelta

pd.Timedelta(days=5, hours=3)
pd.Timedelta('1 days 02:00:00')
pd.to_timedelta(['1d', '2h', '30min'])

period (기간)

p = pd.Period('2024-01', freq='M')
p.start_time, p.end_time
p + 1                                # 2024-02

pd.period_range('2024-01', periods=12, freq='M')   # 12 개월

Timestamp 는 한 순간, Period 는 구간 (시작-끝).

DatetimeIndex 의 슬라이싱

df = pd.DataFrame(..., index=pd.date_range('2024-01-01', periods=100))
df['2024-02']
df['2024-02-15':'2024-03-15']
df.loc['2024-02-15':'2024-03-15']

자주 쓰는 패턴

보고 기간 생성

report_dates = pd.date_range('2024-01-01', '2024-12-31', freq='MS')
for d in report_dates:
    run_monthly_report(d)

누락된 날짜 채우기

full_range = pd.date_range(df.index.min(), df.index.max(), freq='D')
df = df.reindex(full_range, fill_value=0)

영업일 계산

pd.date_range('2024-01-01', '2024-01-31', freq='B')   # 영업일만

특정 요일의 날짜만

# 매주 월요일
pd.date_range('2024-01-01', '2024-03-31', freq='W-MON')

# 매월 마지막 영업일
pd.date_range('2024-01-01', '2024-12-31', freq='BME')

DataFrame 에 날짜 인덱스 붙이기

idx = pd.date_range('2024-01-01', periods=len(df), freq='D')
df.index = idx

두 날짜 사이 영업일 수

bdays = pd.bdate_range('2024-01-01', '2024-01-31')
print(f"영업일 수: {len(bdays)}")

날짜 오프셋 종류

오프셋	의미
`DateOffset(days=n)`	n일 후
`DateOffset(months=n)`	n개월 후 (달력 기준)
`DateOffset(years=n)`	n년 후
`BDay(n)`	n 영업일 후
`MonthEnd(n)`	n번째 월말
`MonthBegin(n)`	n번째 월초
`BusinessMonthEnd(n)`	n번째 영업 월말

from pandas.tseries.offsets import MonthEnd, BDay

ts = pd.Timestamp('2024-01-15')
ts + MonthEnd(1)    # 2024-01-31 (이번 달 말일)
ts + MonthEnd(2)    # 2024-02-29 (다음 달 말일)
ts + BDay(5)        # 5 영업일 후

함정

1. freq 가 정해지지 않은 경우

pd.DatetimeIndex(['2024-01-01', '2024-01-15', '2024-01-30'])
# freq=None, resample 등 일부 동작이 제한

명시적 freq 가 필요하면 .asfreq('D').

2. DateOffset vs Timedelta

pd.Timestamp('2024-01-31') + pd.Timedelta(days=30)     # 2024-03-01
pd.Timestamp('2024-01-31') + pd.DateOffset(months=1)   # 2024-02-29 (윤년)

월/년 단위는 DateOffset, 절대 시간은 Timedelta.

3. periods 계산

pd.date_range('2024-01-01', '2024-01-31', freq='D')
# 31 개 (양쪽 inclusive)

4. naive vs tz-aware 혼합

ts_naive = pd.Timestamp('2024-01-01')
ts_aware = pd.Timestamp('2024-01-01', tz='UTC')

ts_naive + ts_aware   # TypeError: cannot mix tz-naive and tz-aware

[!WARNING] tz-naive 와 tz-aware Timestamp 는 더하거나 비교할 수 없다. 처음부터 통일하거나 tz_localize / tz_convert 로 변환 후 사용.

5. Timedelta 와 DateOffset 의 차이

ts = pd.Timestamp('2024-01-31')

ts + pd.Timedelta(days=30)          # 2024-03-01 (정확히 30일)
ts + pd.DateOffset(months=1)        # 2024-02-29 (1개월 후 = 2월 말)

월/년 단위 이동에는 반드시 DateOffset. Timedelta 는 절대 시간 단위라 달력 의미가 없다.

[Pandas] pipe / method chaining

koa (김신건) — Fri, 17 Jul 2026 00:00:00 GMT

정의

DataFrame.pipe(func, *args, **kwargs) 는 method chain 안에 사용자 함수를 끼워 넣기. func(df, ...) 와 동등하지만 chain 의 흐름을 유지한다.

df.pipe(my_func, arg1, arg2)
# = my_func(df, arg1, arg2)

사용 상황

상황	pipe 활용
사용자 함수를 chain 에 끼워 넣기	`.pipe(my_func)`
데이터 전처리 파이프라인 구성	`.pipe(normalize).pipe(clean)`
chain 중간에 로깅 / 검증	`.pipe(log_shape).pipe(assert_no_null)`
func 의 첫 인자가 df 가 아닐 때	`.pipe((func, 'df_kwarg'), ...)`
함수형 스타일 데이터 변환	`df -> f -> g -> h -> result`

시각화

중첩 호출 vs pipe 체이닝 비교:

flowchart TD
    A["원본 DataFrame"] --> B["중첩 함수 호출 방식"]
    A --> C["pipe 체이닝 방식"]
    B --> B1["clean_data(remove_outliers(normalize(df)))"]
    B1 --> B2["역순으로 읽혀 가독성 낮음"]
    C --> C1["df.pipe(normalize)"]
    C1 --> C2[".pipe(remove_outliers)"]
    C2 --> C3[".pipe(clean_data)"]
    C3 --> C4["위에서 아래로 흐름 명확"]

pipe 함수 실행 흐름:

flowchart LR
    DF["DataFrame"] --> Pipe["df.pipe(func, arg1, arg2)"]
    Pipe --> Call["func(df, arg1, arg2) 호출"]
    Call --> Ret["반환값 = 새 DataFrame"]
    Ret --> Next["다음 chain 단계"]

왜 pipe 인가

체이닝의 가독성을 위해.

# ❌ 중첩 함수 호출 (역순으로 읽힘)
clean_data(remove_outliers(normalize(df, cols), threshold=3))

# ✓ pipe 로 위에서 아래로
(df
 .pipe(normalize, cols)
 .pipe(remove_outliers, threshold=3)
 .pipe(clean_data))

기본 사용

def add_total(df):
    df['total'] = df['price'] * df['qty']
    return df

def filter_high_value(df, threshold):
    return df[df['total'] >= threshold]

result = (df
    .pipe(add_total)
    .pipe(filter_high_value, threshold=10000)
    .sort_values('total', ascending=False))

func 가 첫 인자가 DataFrame 이 아닐 때

df.pipe((func, 'df_arg_name'), arg1)
# func(arg1, df_arg_name=df)

func 의 첫 인자가 DataFrame 이 아닌 경우 tuple 로 위치 명시.

method chain 의 장점

result = (df
    .query('age > 18')
    .assign(year=lambda d: d['date'].dt.year)
    .groupby(['year', 'city'])
    .agg(total=('sales', 'sum'))
    .reset_index()
    .pivot(index='year', columns='city', values='total')
    .fillna(0)
    .pipe(normalize_rows))

각 단계가 명확. 디버깅 시 한 줄씩 제거/추가 쉬움.

assign 과의 조합

assign 으로 새 컬럼을 추가하면서 chain 유지.

df.assign(
    bmi=lambda d: d['weight'] / (d['height']/100)**2,
    bmi_cat=lambda d: pd.cut(d['bmi'], bins=[0,18.5,25,30,100],
        labels=['under','normal','over','obese'])
)

lambda d: ... 패턴이 chain 안에서 이전 단계 결과를 참조.

query 와 조합

df = (df
    .query('age > 18 and city in @cities')
    .assign(group=lambda d: pd.cut(d['age'], bins=[0,30,50,100]))
    .groupby('group')
    .agg({'sales': 'sum'}))

함수형 스타일

def normalize(df, cols):
    df = df.copy()
    for c in cols:
        df[c] = (df[c] - df[c].mean()) / df[c].std()
    return df

def remove_outliers(df, col, n_std=3):
    mean, std = df[col].mean(), df[col].std()
    return df[df[col].between(mean - n_std*std, mean + n_std*std)]

df.pipe(normalize, ['x', 'y']).pipe(remove_outliers, 'z')

각 함수가 DataFrame -> DataFrame, 재사용성 높음.

tap 패턴 (중간 검사)

chain 을 끊지 않고 중간 상태를 로깅하거나 검증할 때 유용하다.

def tap(df, func):
    """chain 중간에 side effect, df 그대로 반환"""
    func(df)
    return df

result = (df
    .pipe(normalize, ['x', 'y'])
    .pipe(tap, lambda d: print(f"normalize 후: {d.shape}"))
    .pipe(remove_outliers, 'z')
    .pipe(tap, lambda d: print(f"outlier 제거 후: {d.shape}"))
    .pipe(clean_data))

assert pipe

def assert_no_null(df, cols=None):
    check = df[cols] if cols else df
    null_count = check.isnull().sum().sum()
    if null_count > 0:
        raise ValueError(f"null {null_count}개 발견")
    return df

df.pipe(assert_no_null, cols=['id', 'date'])

pipe 와 assign 고급 조합

assign 내부에서 lambda 로 이전 결과를 참조하는 패턴:

df = (df
    .assign(
        revenue=lambda d: d['price'] * d['qty'],
        margin=lambda d: d['revenue'] - d['cost'],   # 방금 추가한 revenue 참조
        margin_pct=lambda d: d['margin'] / d['revenue'] * 100,
    )
    .pipe(filter_positive_margin)
    .pipe(add_segment_label, bins=[0, 20, 50, 100]))

assign 의 lambda 는 위에서 아래로 순서대로 실행되어, 같은 assign 블록 안에서도 이전 열을 참조할 수 있다.

가독성 가이드

패턴	권장
단순 한 단계	그냥 `func(df)`
2-3 단계	chain 권장
5+ 단계	chain + 변수 분리 (readability)

함정

1. inplace 함수와 안 어울림

df.pipe(lambda d: d.sort_values('x', inplace=True))
# None 반환 → chain 끊김

inplace=True 와 chain 은 호환 안 됨.

2. side effect

def add_log(df):
    print(df.shape)
    return df       # 반드시 return

df.pipe(add_log).head()

return 빠뜨리면 None.

3. 디버깅 어려움

# 중간 결과 확인 어려움
result = df.pipe(a).pipe(b).pipe(c)

# 임시 변수로 격리
step1 = df.pipe(a)
step2 = step1.pipe(b)
step3 = step2.pipe(c)

문제 단계 격리에 임시 변수가 유용.

4. copy 없는 함수 주의

def bad_normalize(df, cols):
    for c in cols:
        df[c] = (df[c] - df[c].mean()) / df[c].std()   # 원본 수정
    return df

df.copy() 없이 원본을 수정하면 예상치 못한 side effect 발생. chain 함수는 반드시 복사본을 반환하거나, 원본 수정이 의도인 경우 명시한다.

5. 큰 DataFrame 에서 pipe 마다 copy

각 pipe 단계에서 DataFrame 을 복사하면 메모리가 증가한다. 대용량 데이터에서는 적절한 단위로 묶거나 inplace 변형 후 return df 패턴을 검토.

[Pandas] PyArrow Backend

koa (김신건) — Fri, 17 Jul 2026 00:00:00 GMT

정의

pandas 2.0 부터 Apache Arrow 를 백킹으로 사용 하는 새 dtype 시스템. NumPy 기반의 한계 (메모리, 문자열, 타입 다양성) 를 크게 개선.

사용 상황

상황	pyarrow backend 이점
대용량 문자열 컬럼	메모리 1/10 수준 절감
Parquet 읽기/쓰기	Arrow - Parquet 직접 매핑, 변환 비용 없음
int + NaN 공존	NumPy 는 float 으로 강등, Arrow 는 native int
중첩 타입 (list, struct)	NumPy 불가, Arrow 는 가능
정확한 소수 (decimal)	Arrow decimal 타입 지원
Python 3.x 마이그레이션 준비	pandas 3.0 은 Arrow 기본 예정

시각화

NumPy vs Arrow 메모리 레이아웃 비교:

flowchart LR
    NP["NumPy Backend"]
    AR["Arrow Backend"]
    NP --> NP1["string: Python object 포인터 배열"]
    NP --> NP2["int + NaN: float64 로 강등"]
    NP --> NP3["중첩 타입: 지원 없음"]
    AR --> AR1["string: 연속 바이트 버퍼 + 오프셋"]
    AR --> AR2["int + NA: 비트마스크 분리 저장"]
    AR --> AR3["list, struct: 네이티브 지원"]

마이그레이션 경로:

flowchart TD
    Old["기존 NumPy dtype DataFrame"]
    Old --> A["read 시점 변환: dtype_backend='pyarrow'"]
    Old --> B["명시적 변환: convert_dtypes(dtype_backend='pyarrow')"]
    Old --> C["개별 컬럼: astype('int64[pyarrow]')"]
    A --> New["Arrow dtype DataFrame"]
    B --> New
    C --> New
    New --> Compat["기존 pandas API 대부분 호환"]

적용 방법

1. read 함수에서

df = pd.read_csv('data.csv', dtype_backend='pyarrow')
df = pd.read_parquet('data.parquet', dtype_backend='pyarrow')
df.dtypes
# id        int64[pyarrow]
# name      string[pyarrow]
# ts        timestamp[ns, UTC][pyarrow]

2. 전역 설정

pd.options.future.infer_string = True       # 문자열은 pyarrow 로 추론

3. 명시적 변환

df = df.astype({
    'id': 'int64[pyarrow]',
    'name': 'string[pyarrow]',
})
df = df.convert_dtypes(dtype_backend='pyarrow')   # 자동 변환

NumPy backend vs pyarrow backend

항목	NumPy	pyarrow
int + NaN	✗ (float 강등)	✓
string	object (Python list)	native arrow string
datetime tz	✓	✓ (정밀)
decimal	✗	✓
nested types (list, struct)	✗	✓
메모리 (string)	큼	~1/10
Parquet IO	변환 비용	직접
GIL 회피	✗	△

메모리 비교 예

15 배 절감.

문자열 처리 속도

# str accessor 메서드는 그대로 사용
df['name'].str.upper()
df['name'].str.contains('python')
df['name'].str.split(',')

pyarrow backend 에서는 내부 구현이 더 빠르다.

정밀한 타입

# DECIMAL 타입 (정확한 소수)
df = pd.DataFrame({'price': pd.array(['1.23', '4.56'], dtype='decimal128(10, 2)[pyarrow]')})

# timezone 인식 timestamp
df['ts'].dt.tz                # arrow 는 더 정확한 timezone 표현

단점 / 함정

1. 일부 메서드 호환성

대부분의 pandas API 가 동작하지만, 일부 (특히 사용자 함수 적용) 에서 fallback 발생. 점진적으로 개선 중.

2. 다른 라이브러리와의 호환

# scikit-learn 입력
X = df.values            # numpy 로 변환 (arrow → numpy 복사)
# 큰 데이터에서 비용 발생 가능

ML 파이프라인에 들어갈 때는 변환 단계가 비용일 수 있다.

3. 일부 dtype 의 표현

pd.array([1, 2, 3], dtype='int64[pyarrow]')[0]
# ArrayScalar(1) 같은 형태로 보일 수 있음

스칼라 표현이 NumPy 와 다를 수 있음.

4. NaN vs <NA>

df['x'].astype('int64[pyarrow]')
# NaN 위치 → <NA>
df['x'].isna()                # 양쪽 모두 처리

자주 쓰는 패턴

1. Parquet pipeline

df = pd.read_parquet('data.parquet', dtype_backend='pyarrow')
result = process(df)
result.to_parquet('out.parquet')

Arrow → pandas → Arrow 변환 비용 거의 없음.

2. 문자열 대용량 데이터

df = pd.read_csv('logs.csv', dtype_backend='pyarrow')
# string[pyarrow] 가 메모리 1/10
df['message'].str.contains('ERROR').sum()

3. 점진적 마이그레이션

df = df.convert_dtypes(dtype_backend='pyarrow')
# 기존 NumPy dtype → 적절한 arrow dtype 변환

dtype 변환 상세

NumPy dtype	Arrow dtype
`object` (문자열)	`string[pyarrow]`
`int64`	`int64[pyarrow]`
`float64`	`double[pyarrow]`
`bool`	`bool[pyarrow]`
`datetime64[ns]`	`timestamp[ns][pyarrow]`
`category`	`dictionary[pyarrow]`

# 개별 컬럼 변환
df['name'] = df['name'].astype('string[pyarrow]')
df['count'] = df['count'].astype('int64[pyarrow]')

# 전체 일괄 변환
df_arrow = df.convert_dtypes(dtype_backend='pyarrow')

# dtype 확인
df_arrow.dtypes
# id      int64[pyarrow]
# name    string[pyarrow]

ML 파이프라인 연동

Arrow backend 로 메모리를 절약한 뒤, ML 단계에서는 NumPy 로 변환:

# 1. 대용량 데이터: Arrow 로 로드
df = pd.read_parquet('big_data.parquet', dtype_backend='pyarrow')

# 2. 전처리: pandas API 그대로 사용
df = df.dropna().query('age > 18')
df['log_income'] = np.log(df['income'].to_numpy() + 1)

# 3. ML 입력: NumPy 변환
X = df[feature_cols].to_numpy(dtype=np.float32)
y = df['target'].to_numpy()

model.fit(X, y)

.to_numpy() 호출 시 Arrow - NumPy 복사가 발생하나, 학습 단계는 한 번만 실행되므로 허용 가능.

pandas 3.0

3.0 부터 pyarrow 가 기본 백킹 이 될 예정 (논의 중). 지금부터 적응하면 좋다.

[Pandas] resample

koa (김신건) — Fri, 17 Jul 2026 00:00:00 GMT

정의

resample(rule) 는 시계열 데이터를 다른 빈도 (월별, 일별, 시간별 등) 로 재샘플링하면서 집계한다. [[Pandas groupby]] 의 시계열 버전.

DatetimeIndex (또는 on= 으로 datetime 컬럼) 이 필수.

사용 상황

상황	resample 활용
일별 데이터를 월별로 집계	`resample('ME').sum()`
분 단위 로그를 시간 단위로 평균	`resample('h').mean()`
누락 기간 채우기 (upsampling)	`resample('D').ffill()`
OHLCV (주식 캔들스틱)	`resample('D').agg({'open','close','high','low','vol'})`
영업일 기준 집계	`resample('B').last()`
분기별 보고서	`resample('QE').sum()`

시각화

downsampling vs upsampling 개념:

flowchart LR
    Src["원본 시계열"] --> Down["Downsampling"]
    Src --> Up["Upsampling"]
    Down --> D1["간격 넓힘 + 집계: 분 단위 -> 시간 단위"]
    D1 --> D2["sum, mean, last 등 집계 함수 선택"]
    Up --> U1["간격 좁힘 + 보간: 일별 -> 시간별"]
    U1 --> U2["ffill, bfill, interpolate 등으로 채움"]

resample 처리 파이프라인:

flowchart TD
    Input["DatetimeIndex DataFrame"] --> R["resample(rule)"]
    R --> Bucket["시간 버킷 분류"]
    Bucket --> Agg["집계 함수 적용"]
    Agg --> Idx["새 DatetimeIndex 생성"]
    Idx --> Out["결과 DataFrame"]

{}

기본

df.resample('D').sum()        # 일별 합
df.resample('W').mean()        # 주별 평균
df.resample('ME').sum()        # 월말 (Month End)
df.resample('h').mean()        # 시간별 평균

date	3-day sum
2024-01-01	37 (10+15+12)
2024-01-04	63 (18+20+25)
2024-01-07	80 (22+30+28)
2024-01-10	35

빈도 (frequency) 문법

코드	의미
`s`, `min`, `h`	초, 분, 시간
`D`	일
`W`	주 (일요일 끝)
`W-MON`	주 (월요일 끝)
`ME`	월말 (pandas 2.x, 이전엔 ‘M’)
`MS`	월초
`QE`, `QS`	분기 말/초
`YE`, `YS`	연 말/초
`B`	영업일 (Business day)
`BME`	영업월말

[!IMPORTANT] pandas 2.x 에서 'M', 'Q', 'Y' 가 deprecated. 명시적으로 'ME', 'QE', 'YE' 사용.

upsampling (간격 축소 + interpolate)

df.resample('h').ffill()              # 시간별 → 분 단위 forward fill
df.resample('h').interpolate()        # 선형 보간

downsampling (집계 함수)

df.resample('W').agg({
    'sales': ['sum', 'mean'],
    'orders': 'count',
})

label / closed

df.resample('W', closed='right', label='right')
# 'right' 라벨: 주의 마지막 날 (일요일) 이 결과 index
# 'left' 라벨: 주의 첫 날

closed: 구간의 닫힌 쪽 (포함 여부)
label: 결과 index 의 위치

origin (시작 기준)

df.resample('5min', origin='start_day')
# 매일 0시부터 5분 단위

자주 쓰는 패턴

일별 → 월별 매출

monthly = df.resample('ME', on='date')['amount'].sum()

분 단위 → 시간 단위 평균

hourly = df.resample('h').mean()

영업일 기준 (주말 제외)

df.resample('B').agg({'price': 'last'})

asfreq vs resample

# asfreq: 단순 재인덱싱, 집계 없음
df.asfreq('h', fill_value=0)

# resample: 집계 동반
df.resample('h').sum()

resample vs groupby

항목	resample	groupby
기준	시간 간격	임의 키
index	DatetimeIndex 필수	어떤 컬럼도 가능
빈도 문자열	`'D'`, `'ME'`, `'h'` 등	없음
upsampling	가능 (ffill, interpolate)	불가
사용 예	일별 -> 월별 집계	카테고리별 집계

# 동일 결과 (downsampling 에서는 groupby 도 가능)
df.resample('ME').sum()
df.groupby(df.index.to_period('M')).sum()  # 더 복잡

OHLCV 패턴

주식 / 가격 데이터에서 자주 쓰는 패턴:

ohlcv = df['price'].resample('D').agg(
    open='first',
    high='max',
    low='min',
    close='last',
)
volume = df['volume'].resample('D').sum()
candle = ohlcv.join(volume)

함정

1. DatetimeIndex 필수

df.resample('D')   # TypeError if not DatetimeIndex
df.resample('D', on='date')   # 특정 datetime 컬럼 사용

2. NaN 발생

# 데이터가 없는 기간은 NaN
df.resample('h').sum()
# 일부 시간은 0 이 아닌 NaN (구분: 데이터가 없음 vs 합이 0)

fill_value=0 또는 .fillna(0).

3. timezone 영향

# tz-aware index 에서 'D' 는 자정 기준 (해당 timezone 의)
df.tz_convert('UTC').resample('D').sum()

4. pandas 2.x 빈도 문자열 변경

# 1.x 에서는 동작했지만 2.x 에서 deprecated
df.resample('M').sum()    # FutureWarning
df.resample('Q').sum()    # FutureWarning

# 올바른 표기
df.resample('ME').sum()   # Month End
df.resample('QE').sum()   # Quarter End

[!IMPORTANT] pandas 2.2 이후 'M', 'Q', 'Y' 는 deprecated. 'ME', 'QE', 'YE' 로 대체.

5. label / closed 혼동

# 기본: label='left', closed='left'
df.resample('W').sum()
# 결과 index 는 주의 시작 날짜 (월요일)

df.resample('W', label='right').sum()
# 결과 index 는 주의 마지막 날짜 (일요일)

합계 자체는 동일하나 index 라벨이 다름. 시각화 시 주의.

[Pandas] rolling / expanding

koa (김신건) — Fri, 17 Jul 2026 00:00:00 GMT

정의

rolling(window) : 고정 크기 슬라이딩 윈도우 (이동 평균 등)
expanding() : 시작부터 누적 윈도우 (cumulative)
ewm(alpha=) : 지수 가중 이동 평균

사용 상황

상황	적합한 방법
노이즈 제거, smoothing	`rolling().mean()`
최근 데이터에 더 큰 가중치	`ewm(alpha=...)`
전체 기간 누적 추세 파악	`expanding().mean()`
이상치 탐지	`rolling().std()` + z-score
Bollinger Band 계산	`rolling().mean()` + `rolling().std()`
실시간 누적 집계	`expanding().sum()`
그룹별 이동 집계	`groupby().rolling()`

시각화

세 가지 윈도우 방식 비교:

flowchart LR
    Input["시계열 Series"] --> R["rolling(N)"]
    Input --> E["expanding()"]
    Input --> W["ewm(alpha=)"]
    R --> R1["고정 크기 슬라이딩, 처음 N-1개 NaN"]
    E --> E1["시작부터 현재까지 누적, 크기 증가"]
    W --> W1["지수 가중 이동 평균, 최근 강조"]

시계열 분석 파이프라인:

flowchart TD
    Raw["원시 시계열 데이터"] --> MA["이동 평균: rolling(7).mean()"]
    Raw --> Std["이동 표준편차: rolling(30).std()"]
    MA --> Z["z-score 계산"]
    Std --> Z
    Z --> Out["이상치 탐지 결과"]

{}

rolling 기본

s.rolling(window=3).mean()      # 3-point 이동 평균
s.rolling(window=7).sum()       # 7일 합계 (시계열)
s.rolling(window=5).std()
s.rolling(window=10).max()

index	value	rolling(3).mean
0	1	NaN
1	2	NaN
2	3	2.0 (1+2+3)/3
3	4	3.0 (2+3+4)/3
4	5	4.0 (3+4+5)/3
5	6	5.0
6	7	6.0
7	8	7.0

처음 N-1 개는 NaN (window 가 안 채워짐).

min_periods (최소 데이터 수)

s.rolling(window=3, min_periods=1).mean()
# [1.0, 1.5, 2.0, 3.0, 4.0, ...]  ← 처음 2 개도 계산

time-based rolling (시계열)

# index 가 DatetimeIndex 일 때
df.rolling('7D').sum()       # 지난 7일
df.rolling('30min').mean()   # 지난 30분

데이터 빈도가 불규칙해도 시간 기반으로 정확히 윈도우 형성.

center=True

s.rolling(window=3, center=True).mean()
# 중심 정렬, [NaN, 2.0, 3.0, 4.0, ..., NaN]

기본은 right-aligned (윈도우의 마지막 위치에 결과). center=True 는 중앙.

expanding (누적)

s.expanding().mean()       # 시작부터 현재까지 평균
s.expanding().sum()        # 누적합 (== cumsum)
s.expanding(min_periods=5).mean()

ewm (지수 가중)

s.ewm(alpha=0.3).mean()        # alpha 클수록 최근 가중
s.ewm(span=10).mean()           # span = (2/alpha - 1)
s.ewm(halflife=5).mean()

최근 데이터에 더 큰 가중치, 이전 데이터는 점진적 감소. 금융 / 신호 처리.

groupby + rolling

df.groupby('user_id')['amount'].rolling(window=7).sum()
# 각 user 별 7-day 합계 (MultiIndex 결과)

자주 쓰는 패턴

7일 이동 평균 (smoothing)

df['ma7'] = df['sales'].rolling(7).mean()

누적 합 / 평균

df['cumulative_revenue'] = df['revenue'].expanding().sum()
df['running_avg'] = df['revenue'].expanding().mean()

Bollinger Bands

ma = s.rolling(20).mean()
std = s.rolling(20).std()
upper = ma + 2 * std
lower = ma - 2 * std

윈도우 안에서 사용자 함수

s.rolling(window=5).apply(lambda x: x.max() - x.min(), raw=True)
# raw=True 면 numpy array 가 전달되어 빠름

rolling z-score 이상치 탐지

roll_mean = df['value'].rolling(30).mean()
roll_std  = df['value'].rolling(30).std()
df['z_score'] = (df['value'] - roll_mean) / roll_std
outliers = df[df['z_score'].abs() > 3]

두 시리즈 이동 상관계수

df['x'].rolling(30).corr(df['y'])
# 30일 구간의 이동 상관계수, -1.0 ~ 1.0

step 으로 건너뛰며 집계

# pandas 1.5+
s.rolling(window=6, step=2).mean()
# 2 칸씩 건너뛰며 집계, 결과 크기 절반

rolling 집계 함수 목록

메서드	설명
`.mean()`	이동 평균
`.sum()`	이동 합
`.std()` / `.var()`	이동 표준편차 / 분산
`.min()` / `.max()`	이동 최솟값 / 최댓값
`.median()`	이동 중앙값
`.count()`	NaN 제외 유효 수
`.corr(other)`	이동 상관계수
`.cov(other)`	이동 공분산
`.apply(func)`	사용자 함수
`.quantile(q)`	이동 분위수
`.rank()`	이동 순위
`.skew()`	이동 왜도
`.kurt()`	이동 첨도

성능 팁

# 1. numba engine (pandas 1.3+)
s.rolling(window=50).mean(engine='numba')

# 2. raw=True 로 apply 속도 개선
s.rolling(5).apply(np.mean, raw=True)  # numpy array 전달, 빠름

# 3. 큰 윈도우 + 큰 데이터에서 polars 고려
# polars: df.lazy().with_columns(pl.col('x').rolling_mean(7))

함정

1. window 가 너무 커서 NaN 만

short_series.rolling(window=100).mean()
# 데이터가 99 개라면 모두 NaN

min_periods=1 로 부분 결과.

2. shift 와 혼동

s.rolling(3).mean()       # 현재 포함 3 개
s.shift(1).rolling(3).mean()    # 이전 3 개 (오늘 제외)

미래 정보 누설 방지 (lookahead bias) 가 필요할 때 shift.

3. 성능

큰 데이터 + 작은 윈도우: 빠름
큰 데이터 + 큰 윈도우: 느림
numba engine 사용: s.rolling(window=10).mean(engine='numba') (pandas 1.x+)

4. closed 파라미터

s.rolling(3, closed='left').mean()    # 현재 제외, 이전 3개
s.rolling(3, closed='right').mean()   # 기본 (현재 포함)
s.rolling(3, closed='both').mean()    # 양쪽 포함

[!WARNING] closed 는 DatetimeIndex 기반 time-based rolling 에서만 유효. 정수 index 에서는 무시된다.

5. groupby + rolling 의 MultiIndex

result = df.groupby('cat')['val'].rolling(3).mean()
# (cat, original_index) 의 MultiIndex
result = result.reset_index(level=0, drop=True)  # 원래 index 복원

6. expanding 과 cumsum 의 차이

s.expanding().sum()   # expanding 집계, NaN 고려
s.cumsum()            # 단순 누적합, 빠름

NaN 이 포함된 데이터에서는 expanding().sum() 이 cumsum() 보다 안전. skipna=True 가 기본.

[Pandas] .dt accessor

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Series.dt 는 datetime Series 의 각 구성요소 (년/월/일/시/분/요일 등) 에 벡터로 접근하는 accessor. str 의 datetime 버전.

s.dt.year
s.dt.month
s.dt.day
s.dt.hour
s.dt.weekday

구성요소 분류 시각화

flowchart LR
    DT["datetime Series\n.dt accessor"] --> DATE["날짜 계열"]
    DT --> TIME["시간 계열"]
    DT --> PERIOD["기간/기타"]

    DATE --> D1["dt.year / dt.month / dt.day"]
    DATE --> D2["dt.dayofweek / dt.day_name()"]
    DATE --> D3["dt.quarter / dt.dayofyear"]
    DATE --> D4["dt.is_month_end / dt.is_month_start"]

    TIME --> T1["dt.hour / dt.minute / dt.second"]
    TIME --> T2["dt.floor() / dt.ceil() / dt.round()"]
    TIME --> T3["dt.tz_localize() / dt.tz_convert()"]

    PERIOD --> P1["dt.to_period() - 월/분기 집계"]
    PERIOD --> P2["dt.days / dt.total_seconds() - Timedelta"]

기본 컴포넌트

속성	의미
`dt.year`, `dt.month`, `dt.day`	년/월/일
`dt.hour`, `dt.minute`, `dt.second`	시/분/초
`dt.dayofweek` / `dt.weekday`	요일 (0=월)
`dt.day_name()`	요일 이름 (‘Monday’)
`dt.month_name()`	월 이름 (‘January’)
`dt.quarter`	분기 (1-4)
`dt.dayofyear`	그 해의 몇일째
`dt.week`, `dt.isocalendar()`	주차
`dt.is_month_end`, `dt.is_month_start`	월말/월초 boolean
`dt.days_in_month`	그 달의 일 수

사용

포맷 변환

s.dt.strftime('%Y-%m-%d')                  # 문자열로
s.dt.strftime('%Y년 %m월 %d일 (%A)')
s.dt.normalize()                           # 시간 0으로 (날짜만)
s.dt.floor('h')                            # 시간 단위 내림
s.dt.ceil('h')                             # 올림
s.dt.round('15min')                        # 반올림

timezone

s.dt.tz                                    # 현재 timezone
s.dt.tz_localize('Asia/Seoul')             # naive → aware
s.dt.tz_convert('UTC')                     # 다른 timezone 으로
s.dt.tz_convert('America/New_York')        # 시간대 변환

[!IMPORTANT] tz_localize 와 tz_convert 는 전혀 다른 연산이다. tz_localize 는 timezone 정보 없는 naive datetime 에 timezone 을 부여, tz_convert 는 이미 timezone 이 있는 aware datetime 을 변환. naive 에 tz_convert 를 부르면 TypeError.

Timedelta 의 dt

td = pd.to_timedelta(['1 days 02:30:00', '2 days 05:00:00'])
td = pd.Series(td)
td.dt.days           # [1, 2]
td.dt.seconds        # 9000, 18000 (하루 안의 초)
td.dt.total_seconds()  # 전체 초

Period accessor

# PeriodIndex 로 변환하면 .dt.start_time, .dt.end_time 등 사용 가능
s_period = s.dt.to_period('M')           # monthly Period
s_period.dt.start_time                   # 각 월의 첫째 날 Timestamp
s_period.dt.end_time                     # 각 월의 마지막 날 Timestamp
s_period.dt.quarter                      # 분기 (Period 용)

자주 쓰는 패턴

월별 집계

df['month'] = df['created_at'].dt.to_period('M')   # PeriodIndex (2024-01, ...)
monthly = df.groupby('month')['amount'].sum()

요일별 트렌드

df['weekday'] = df['date'].dt.day_name()
df.groupby('weekday')['orders'].mean()

영업일 / 주말

df['is_weekend'] = df['date'].dt.dayofweek >= 5
df['is_weekday'] = df['date'].dt.dayofweek < 5

datetime 차이

df['days_since_signup'] = (pd.Timestamp.today() - df['signup_date']).dt.days
df['age_years'] = (pd.Timestamp.today() - df['birth_date']).dt.days / 365.25

시간대별 분석

날짜 범위 필터

# 특정 월만
mask = (df['date'].dt.year == 2024) & (df['date'].dt.month == 3)
df[mask]

# 특정 요일
df[df['date'].dt.dayofweek == 0]   # 월요일만

# 영업 시간 내
df[(df['ts'].dt.hour >= 9) & (df['ts'].dt.hour < 18)]

resample 과 결합

# 일별 집계 (dt accessor + resample)
df.set_index('date').resample('D')['amount'].sum()

# 주별 집계
df.set_index('date').resample('W')['amount'].mean()

자세히는 [[Pandas resample]].

성능 팁

# dt accessor 는 벡터 연산, 루프보다 훨씬 빠름
# ❌ 느림
df['year'] = df['date'].apply(lambda x: x.year)

# ✓ 빠름
df['year'] = df['date'].dt.year

# datetime64 dtype 이면 dt 사용 가능, object 이면 to_datetime 먼저
df['date'] = pd.to_datetime(df['date_str'])
df['year'] = df['date'].dt.year

함정

1. dt 가 안 되는 경우

s = pd.Series(['2024-01-15', '2024-02-20'])
s.dt.year      # AttributeError, str 이라서
# 먼저 변환
pd.to_datetime(s).dt.year

2. tz-aware vs naive 비교

naive.tz_localize('UTC') > aware    # ✓
naive > aware                       # TypeError 가능

3. dayofweek 의 시작 (월요일 = 0)

s.dt.dayofweek    # 0=Mon ... 6=Sun
s.dt.weekday      # 같음
# Python 의 datetime.weekday() 과 동일

ISO 표준 (1=Mon) 은 s.dt.isocalendar().day.

4. dt.week 는 deprecated

s.dt.week      # DeprecationWarning (pandas 1.1+)
# 대신 사용
s.dt.isocalendar().week

[!WARNING] dt.week 와 dt.weekofyear 는 pandas 1.1 에서 deprecated, 2.x 에서 제거됐다. dt.isocalendar().week 를 사용할 것.

[Pandas] agg / aggregate

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

agg(func) 는 여러 집계 함수를 한 번에 적용 한다. GroupBy, DataFrame, Series 모두에서 사용 가능. aggregate 는 같은 함수의 별칭.

agg 처리 흐름

flowchart LR
    A["DataFrame / Series"] --> B["groupby (선택)"]
    B --> C["agg(func)"]
    A --> C
    C --> D{"출력 형태"}
    D -->|"단일 함수"| E["Series (컬럼별 결과)"]
    D -->|"함수 리스트"| F["DataFrame (함수 x 컬럼)"]
    D -->|"named aggregation"| G["DataFrame (직접 지정 컬럼명)"]
    D -->|"컬럼별 다른 함수"| H["DataFrame (MultiIndex 컬럼 가능)"]

사용 상황

상황	패턴
전체 DataFrame 요약 통계	`df.agg(['mean', 'std', 'min', 'max'])`
그룹별 여러 지표	`df.groupby(...).agg(...)`
컬럼마다 다른 집계	`df.agg({'col1': 'sum', 'col2': 'mean'})`
결과 컬럼명 제어	named aggregation: `agg(alias=('col', func))`
커스텀 통계	람다 / 사용자 함수

다양한 형태

단일 함수

df.agg('mean')                 # 모든 컬럼에 mean
df['col'].agg('sum')

함수 리스트

df.agg(['mean', 'sum', 'std'])  # 각 컬럼에 여러 함수

	a	b
mean	3.0	30.0
std	1.58	15.81
min	1	10
max	5	50

컬럼별 다른 함수

df.agg({
    'salary': ['mean', 'sum'],
    'age': ['min', 'max'],
})

groupby + agg

df.groupby('city').agg({
    'salary': ['mean', 'max'],
    'age': 'mean',
})

결과는 MultiIndex 컬럼.

named aggregation (이름 있는 집계)

df.groupby('city').agg(
    avg_salary=('salary', 'mean'),
    max_salary=('salary', 'max'),
    avg_age=('age', 'mean'),
)

city	avg_sal	max_sal	avg_age
Busan	4250	4500	35.0
Seoul	4000	5000	30.0

가장 깔끔한 권장 패턴, 컬럼 이름이 명확.

람다 / 사용자 함수

df.groupby('city').agg(
    median_sal=('salary', lambda s: s.median()),
    range_sal=('salary', lambda s: s.max() - s.min()),
    cv_sal=('salary', lambda s: s.std() / s.mean()),  # 변동계수
)

람다의 단점: 함수명이 <lambda> 로 표시. named aggregation 으로 보완.

DataFrame vs GroupBy agg 비교

import pandas as pd

df = pd.DataFrame({'a': [1, 2, 3], 'b': [10, 20, 30]})

# DataFrame.agg: 전체 컬럼에 집계
print(df.agg(['mean', 'sum']))
# 출력: 2행 (mean, sum) x 2열 (a, b)

# Series.agg: 단일 컬럼
print(df['a'].agg(['mean', 'sum']))
# 출력: 2행 Series

# GroupBy.agg: 그룹별
print(df.assign(g=['x', 'x', 'y']).groupby('g').agg(['mean', 'sum']))
# 출력: 2행 (x, y) x 4열 (a-mean, a-sum, b-mean, b-sum)

transform 과의 차이

특성	`agg`	`transform`
출력 shape	축소 (n행 → 1행)	원본 유지 (n행 → n행)
사용 목적	그룹 요약	그룹 값을 원본에 맞춰 붙이기
결과 index	그룹 key	원본 index

# agg: 요약
df.groupby('city')['salary'].agg('mean')
# city
# Busan    4250.0
# Seoul    4000.0

# transform: 원본 길이 유지 (join 없이 붙이기)
df['city_avg'] = df.groupby('city')['salary'].transform('mean')
# 각 행의 도시 평균이 그 행에 붙음

자주 쓰는 집계 함수 모음

함수	의미
`'mean'`, `'sum'`, `'std'`, `'var'`	기본 통계
`'min'`, `'max'`, `'median'`	분포
`'count'`	non-null 개수
`'size'`	전체 개수 (NaN 포함)
`'first'`, `'last'`	그룹 내 위치
`'nunique'`	고유값 개수
`'quantile'`	분위수 (default 0.5 = median)
`'idxmin'`, `'idxmax'`	최소/최대 위치
`'mode'`	최빈값 (Series of mode)
`'sem'`	표준 오차
`'skew'`	왜도
`'kurt'`	첨도

실전 패턴

기술 통계 한 번에

df.agg({
    'revenue': ['sum', 'mean', 'std', 'min', 'max'],
    'qty': ['sum', 'mean'],
    'user_id': 'nunique',
})

보고용 요약 (named agg)

summary = df.groupby(['region', 'channel']).agg(
    total_revenue=('revenue', 'sum'),
    avg_order=('revenue', 'mean'),
    order_count=('order_id', 'count'),
    unique_users=('user_id', 'nunique'),
    p90_revenue=('revenue', lambda s: s.quantile(0.9)),
)

여러 quantile 동시

import numpy as np
df.groupby('group')['value'].agg([
    ('p25', lambda s: s.quantile(0.25)),
    ('p50', lambda s: s.quantile(0.50)),
    ('p75', lambda s: s.quantile(0.75)),
    ('p99', lambda s: s.quantile(0.99)),
])

pandas 2.x: as_index 와 reset_index

# as_index=False: 그룹 key 를 컬럼으로
df.groupby('city', as_index=False).agg(
    avg_sal=('salary', 'mean'),
)
# as_index=True (기본) + reset_index() 와 같은 효과

함정

1. MultiIndex 컬럼

df.groupby('city').agg({'salary': ['mean', 'max']})
# 컬럼이 ('salary', 'mean'), ('salary', 'max') MultiIndex
# 평탄화: df.columns = ['_'.join(c) for c in df.columns]

named aggregation 이 이를 자연스럽게 회피.

2. 함수 이름의 충돌

import numpy as np
df.agg(['mean', 'sum', np.mean])    # mean 이 두 번 → 컬럼 충돌

3. groupby + agg 의 dropna

df.groupby('city', dropna=False).agg(...)
# city 가 NaN 인 그룹도 포함 (기본은 제외)

4. count vs size

df.groupby('city').agg({'salary': 'count', 'bonus': 'size'})
# count: NaN 제외, size: NaN 포함
# size 는 컬럼과 무관하게 그룹 크기

5. pandas 2.x observed 경고

# Categorical 컬럼으로 groupby 할 때
df.groupby('cat_col', observed=True).agg(...)   # 등장한 카테고리만
df.groupby('cat_col', observed=False).agg(...)  # 모든 카테고리 포함
# pandas 2.x 에서 명시 안 하면 FutureWarning

[Pandas] apply / map

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Series.map(func) : 각 원소 에 함수 적용 (또는 dict 매핑)
Series.apply(func) : 각 원소 에 함수 적용 (map 과 유사, 추가 인자 가능)
DataFrame.apply(func, axis=) : 각 행 또는 열 에 함수 적용
DataFrame.map(func) (pandas 2.1+) : 각 셀 에 함수 적용 (구 applymap)

사용 상황

상황	권장 방법	비고
값 치환 (dict 기반)	`Series.map(dict)`	없는 키는 NaN
원소별 변환	`Series.apply(fn)` 또는 벡터 연산	벡터화 가능하면 우선
행/열 집계 또는 변환	`DataFrame.apply(fn, axis=)`	`agg`, `transform` 검토
전체 셀 변환	`DataFrame.map(fn)`	셀 하나씩 호출, 느림
조건부 분기	`np.where` / `np.select`	apply 보다 빠름

어떤 메서드를 쓸지 결정 흐름

flowchart TD
    START["함수 적용 필요"] --> TARGET{"적용 대상"}
    TARGET -->|"Series 원소"| DICT{"dict 매핑인가?"}
    TARGET -->|"DataFrame 행 또는 열"| DA[".apply(fn, axis=)"]
    TARGET -->|"DataFrame 셀 전체"| VEC2{"벡터화 가능?"}
    DICT -->|"Yes"| SMAP["Series.map(dict)"]
    DICT -->|"No"| VEC{"벡터화 가능?"}
    VEC -->|"Yes"| FAST["벡터 연산 우선"]
    VEC -->|"No"| SA["Series.apply(fn)"]
    VEC2 -->|"Yes"| FAST2["벡터 연산 우선"]
    VEC2 -->|"No"| DM["DataFrame.map(fn)"]

Series.map (가장 흔함)

# dict 매핑: 없는 키는 NaN
s.map({'A': 1, 'B': 2, 'C': 3})

# 함수 적용
s.map(lambda x: x * 2)
s.map(str)

map 과 dict: 매핑 없는 값은 NaN 처리.

s = pd.Series(['A', 'B', 'Z'])
s.map({'A': 1, 'B': 2})          # [1, 2, NaN]
s.map({'A': 1, 'B': 2}, na_action='ignore')   # NaN 원소 건너뜀

Series.apply

s.apply(lambda x: x ** 2)              # 같은 길이의 Series
s.apply(some_func)

map 과 거의 같지만 apply 는 함수에 추가 인자를 줄 수 있다.

s.apply(round, ndigits=2)

def clip(x, lo, hi):
    return max(lo, min(hi, x))

s.apply(clip, lo=0, hi=100)

DataFrame.apply (행/열 단위)

df.apply(sum, axis=0)        # 각 열에 sum (default)
df.apply(sum, axis=1)        # 각 행에 sum

# 행 단위 람다
df.apply(lambda r: r['a'] + r['b'], axis=1)

result_type 파라미터

# 함수가 리스트/Series 반환할 때 결과 형태 제어
def expand(row):
    return [row['a'] * 2, row['b'] * 2]

df.apply(expand, axis=1, result_type='expand')   # DataFrame 반환
df.apply(expand, axis=1, result_type='reduce')   # Series 반환 (flatten)
df.apply(expand, axis=1, result_type='broadcast') # 원본 df 형태 유지

DataFrame.map (셀 단위, pandas 2.1+)

df.map(lambda x: x * 2)        # 모든 셀에 x*2
df.map(str)                     # 모든 셀을 str 로

# NaN 건너뜀 옵션
df.map(lambda x: x ** 0.5, na_action='ignore')

구 applymap 의 새 이름. pandas 2.1 미만에서는 applymap 사용.

벡터 연산이 항상 우선

# ❌ apply: 행마다 호출, 느림
df['c'] = df.apply(lambda r: r['a'] + r['b'], axis=1)

# ✓ 벡터 연산: 수십~수백 배 빠름
df['c'] = df['a'] + df['b']

# ❌ apply 로 문자열 붙이기
df['full_name'] = df.apply(lambda r: r['first'] + ' ' + r['last'], axis=1)

# ✓ 벡터 연산
df['full_name'] = df['first'] + ' ' + df['last']

np.where 패턴

import numpy as np

# ❌ apply: 느림
df['cat'] = df['age'].apply(lambda x: 'adult' if x >= 18 else 'minor')

# ✓ np.where: 빠름
df['cat'] = np.where(df['age'] >= 18, 'adult', 'minor')

# 더 많은 분기: np.select
conditions = [df['age'] < 13, df['age'] < 20, df['age'] < 65]
choices    = ['child', 'teen', 'adult']
df['cat']  = np.select(conditions, choices, default='senior')

그룹별 변환: transform 과의 차이

# apply: 그룹별 결과를 집계 (크기가 달라질 수 있음)
df.groupby('city')['salary'].apply(lambda s: s.nlargest(3))

# transform: 그룹별 통계를 원본 크기로 브로드캐스트
df['city_avg'] = df.groupby('city')['salary'].transform('mean')

[[Pandas transform / apply]] 참고.

map vs apply 차이

메서드	대상	dict 매핑	추가 인자	성능
`Series.map`	원소	✅	❌	빠름
`Series.apply`	원소	❌	✅	비슷
`DataFrame.apply`	행/열	❌	✅	보통
`DataFrame.map`	셀	❌	✅	느림

성능

방법	상대 속도	설명
벡터 연산 (`+`, `*`, `np.where`)	1x (기준)	C 레벨 연산
`Series.map(dict)`	~3x 느림	hash lookup
`Series.apply(fn)`	~10x 느림	Python 루프
`DataFrame.apply(fn, axis=1)`	~100x 느림	행마다 Python 호출
`DataFrame.map(fn)`	~500x 느림	셀마다 Python 호출

import pandas as pd
import numpy as np
import time

df = pd.DataFrame({'a': np.random.randn(100_000),
                   'b': np.random.randn(100_000)})

# 벡터 연산
t0 = time.time()
_ = df['a'] + df['b']
print(f'벡터: {time.time()-t0:.3f}s')

# apply (axis=1)
t0 = time.time()
_ = df.apply(lambda r: r['a'] + r['b'], axis=1)
print(f'apply: {time.time()-t0:.3f}s')

[!WARNING] DataFrame.apply(fn, axis=1) 는 100,000 행에서도 수 초가 걸릴 수 있다. 가능하면 벡터화 연산이나 np.where / np.select 로 대체한다.

함정

1. apply 의 속도

# 1,000 행 × 10 컬럼 → 10,000 호출
df.apply(complex_function, axis=1)    # 수초
df.map(complex_function)              # 더 느림 (셀마다 호출)
# 벡터화 가능하면 그게 훨씬 빠름

2. axis 0 vs 1 의 의미

df.apply(fn, axis=0)    # 각 열에 fn (기본값)
df.apply(fn, axis=1)    # 각 행에 fn

axis=0 은 “행을 collapse” 하여 열별 결과, axis=1 은 “열을 collapse” 하여 행별 결과. 헷갈리기 쉽다.

3. 결과 타입 추론

result = df.apply(some_func, axis=1)
# 함수 반환이 scalar 면 Series, dict/Series 면 DataFrame
# 일관성 없는 반환 타입은 예외 발생

복잡한 함수에서 결과 타입이 불일치하면 예외가 난다. result_type 파라미터로 명시.

4. map 의 NaN 처리

# dict map: 없는 키는 NaN 으로 채워짐
s = pd.Series(['A', 'B', 'X'])
s.map({'A': 1, 'B': 2})    # [1, 2, NaN]

의도치 않은 NaN 이 생길 수 있으니 매핑 dict 에 모든 값이 들어 있는지 확인.

5. applymap 이름 변경 (pandas 2.1)

# pandas < 2.1
df.applymap(fn)

# pandas >= 2.1
df.map(fn)        # applymap 은 FutureWarning

[Pandas] clip / where / mask

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

clip(lower, upper) : 범위 밖 값을 경계로 자르기 (outlier 처리)
where(cond, other) : cond 가 True 면 유지, False 면 other 로 치환
mask(cond, other) : where 의 반대 (cond True 가 치환)

어떤 것을 쓸까

flowchart TD
    A["값을 조건부로 바꾸고 싶다"] --> B{"어떤 목적?"}
    B -->|"범위 제한 (outlier clamp)"| C["clip(lower, upper)"]
    B -->|"True 면 유지 / False 면 치환"| D["where(cond, other)"]
    B -->|"True 면 치환 / False 면 유지"| E["mask(cond, other)"]
    B -->|"if-elif-else 다중 분기"| F["np.select(conditions, choices)"]
    B -->|"단순 2분기 (numpy)"| G["np.where(cond, a, b)"]

    C --> H["s.clip(0, 100)"]
    D --> I["s.where(s > 0, 0)"]
    E --> J["s.mask(s < 0, 0)"]
    F --> K["np.select([c1, c2], [v1, v2], default)"]

사용 상황

상황	도구
음수 값을 0 으로 고정	`s.clip(lower=0)`
백분위 기준 이상치 제거	`s.clip(q1, q99)`
조건 불만족 행 NaN 처리	`s.where(cond)`
특정 조건 행을 다른 값으로	`s.mask(cond, replacement)`
여러 조건 분기 (연령대 분류 등)	`np.select`

clip

s.clip(lower=0)               # 0 미만 → 0
s.clip(upper=100)              # 100 초과 → 100
s.clip(lower=0, upper=100)     # [0, 100] 범위로

original	clipped (0, 100)
-5	0
0	0
50	50
150	100
200	100

컬럼별 다른 경계

df.clip(lower={'a': 0, 'b': -10}, upper={'a': 100, 'b': 10})

분위수 기반 clip

lower = df['amount'].quantile(0.01)
upper = df['amount'].quantile(0.99)
df['amount_clipped'] = df['amount'].clip(lower, upper)

실무에서 outlier 처리 패턴으로 자주 쓰인다.

where

s.where(cond, other)        # cond True 면 그대로, False 면 other

[!IMPORTANT] s.where(cond, other) 는 cond 가 True 일 때 그대로 유지. numpy 의 np.where(cond, a, b) 와 의미가 정반대다.

<CodeWithOutput language=“python” outputLanguage=“text” code={import pandas as pd s = pd.Series([10, 20, 30, 40]) print(s.where(s > 20, 0).tolist())} output={[0, 0, 30, 40]} />

s > 20 이 False 인 위치 (10, 20) 가 0 으로 치환됨.

where 의 함수 형태

s.where(lambda x: x > 0, 0)              # cond 도 callable
s.where(s > 0, lambda x: -x)             # other 도 callable

where 로 NaN 마킹

# 조건 불만족 행을 NaN 으로
df['score'] = df['score'].where(df['score'] >= 0)
# other 생략 시 기본값 NaN

mask

s.mask(cond, other)         # where 의 반대

cond True 인 곳을 치환. 의미가 더 직관적인 경우가 많다.

# salary 가 100k 이상이면 'high', 아니면 원본 유지
df['salary_label'] = df['salary'].mask(df['salary'] >= 100_000, 'high')

mask 로 이상치 NaN 처리

df['amount'] = df['amount'].mask(
    (df['amount'] < 0) | (df['amount'] > 10_000),
    other=pd.NA,
)

np.where 와의 비교

import numpy as np
np.where(s > 20, s, 0)        # cond True → s, False → 0
s.where(s > 20, 0)             # cond True → s, False → 0 (같음)

같은 결과지만 pandas API 는 other 가 cond False 일 때, numpy 는 x 가 True 일 때.

np.select (다중 분기)

import numpy as np
conditions = [df['age'] < 13, df['age'] < 20, df['age'] < 65]
choices = ['child', 'teen', 'adult']
df['stage'] = np.select(conditions, choices, default='senior')

여러 if-elif-else 를 벡터화.

# 실무 예: 매출 등급 분류
conditions = [
    df['revenue'] < 1_000,
    df['revenue'] < 10_000,
    df['revenue'] < 100_000,
]
choices = ['bronze', 'silver', 'gold']
df['tier'] = np.select(conditions, choices, default='platinum')

실전 패턴

outlier 처리

# 1, 99 percentile 로 clip
lower = df['amount'].quantile(0.01)
upper = df['amount'].quantile(0.99)
df['amount_clipped'] = df['amount'].clip(lower, upper)

조건부 컬럼 생성

df['discount'] = df['price'].where(df['vip'], df['price'] * 0.9)
# vip 이면 그대로, 아니면 10% 할인

연속 mask 체인

df['value'] = (
    df['value']
    .where(df['value'] >= 0, 0)         # 음수 → 0
    .where(df['value'] <= 1_000, 1_000) # 1000 초과 → 1000
)
# 또는 clip 으로 동일하게:
df['value'] = df['value'].clip(0, 1_000)

pandas 2.x CoW 와 where / mask

# pandas 2.x Copy-on-Write 환경
# where / mask 는 항상 새 Series 반환 → 원본 불변
s2 = s.where(s > 0, 0)    # s 는 그대로, s2 가 변경된 버전
s.where(s > 0, 0, inplace=True)   # inplace: 원본 수정 (CoW 에서 경고 가능)

DataFrame.where (축 방향)

df.where(df > 0)             # 모든 셀: 0 이하 → NaN
df.where(df.notna(), -999)   # NaN 인 셀 → -999
df.mask(df < 0, 0)           # 음수 셀 → 0

함정

1. where / mask 의 의미 헷갈림

기억법: where 는 when True 유지. mask 는 masks True (가린다).

2. cond 의 shape 일치

df.where(some_bool_df)        # 같은 shape DataFrame
df.where(df['x'] > 0)         # broadcast (행 단위)

3. other 의 dtype 강등

s = pd.Series([1, 2, 3], dtype='int64')
s.where(s > 1, 'small')       # dtype 이 object 로 강등
# 의도했으면 괜찮지만, 수치 연산 이후 예상치 못한 결과 가능

4. np.where 의미 혼동

# np.where(cond, x, y): cond True → x, False → y
# s.where(cond, other): cond True → s 그대로, False → other
# 반대처럼 보이지만 실제로는 동일한 결과

s.where(s > 0, -1)            # 양수 유지, 나머지 -1
np.where(s > 0, s, -1)        # 동일한 결과

5. clip 과 where 의 NA 처리

s = pd.Series([pd.NA, 5, 10], dtype='Int64')
s.clip(0, 8)      # [<NA>, 5, 8]  (NA 는 그대로)
s.where(s <= 8)   # [<NA>, 5, 8]  (NA 는 False 처리 → 치환)
# NA 에 대한 동작이 다름. clip 은 NA 보존, where 는 NA 를 False 로

6. inplace 와 체이닝

# ❌ 체이닝 중 inplace
df['col'].where(cond, 0, inplace=True)   # SettingWithCopyWarning 가능

# ✓ 직접 할당
df['col'] = df['col'].where(cond, 0)

[Pandas] concat

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pd.concat(objs, axis=0) 는 여러 DataFrame/Series 를 세로 (axis=0) 또는 가로 (axis=1) 로 단순 연결. SQL 의 UNION (axis=0) 또는 column-level concatenation (axis=1).

key 매칭이 아닌 위치 기반 결합 이라 [[Pandas merge]] / [[Pandas join]] 과 구분된다.

사용 상황

행 단위 쌓기: 같은 구조의 DataFrame 여러 개를 하나로 합칠 때
가로 붙이기: 같은 index 를 공유하는 feature 그룹을 열 방향으로 결합할 때
계층 라벨 부여: 시기/그룹별 데이터를 묶어 [[Pandas MultiIndex]] 로 분석할 때
df.append 대체: pandas 2.0 에서 append 가 제거됨, pd.concat 으로 완전 대체

merge / join 과 달리 key 매칭이 없으므로, 스키마가 같거나 의도적으로 다른 경우에 쓴다.

axis 동작 시각화

flowchart TD
    subgraph "axis=0, 세로 연결"
        A1["df1: 2행"] --> R1["결과: 4행 쌓기"]
        A2["df2: 2행"] --> R1
    end

    subgraph "axis=1, 가로 연결"
        B1["df1: 2열"] --> R2["결과: 4열 붙이기"]
        B2["df2: 2열"] --> R2
    end

join 파라미터 시각화

flowchart LR
    subgraph "join='outer' 기본"
        O1["df1: 열 a, b"] --> OR["결과: a, b, c 합집합 / NaN 채움"]
        O2["df2: 열 a, c"] --> OR
    end

    subgraph "join='inner'"
        I1["df1: 열 a, b"] --> IR["결과: a 교집합만"]
        I2["df2: 열 a, c"] --> IR
    end

세로 연결 (axis=0, 기본)

result = pd.concat([df1, df2])

index 가 중복됨 (0, 1, 0, 1). ignore_index=True 로 재설정:

pd.concat([df1, df2], ignore_index=True)
# index: 0, 1, 2, 3

가로 연결 (axis=1)

pd.concat([df1, df2], axis=1)
# 컬럼이 옆으로 붙음, index 기준 정렬

index 가 다르면 NaN 이 생긴다:

left = pd.DataFrame({'a': [1, 2]}, index=[0, 1])
right = pd.DataFrame({'b': [10, 20]}, index=[1, 2])
pd.concat([left, right], axis=1)
#     a     b
# 0  1.0   NaN
# 1  2.0  10.0
# 2  NaN  20.0

컬럼이 다를 때

df1 = pd.DataFrame({'a': [1,2], 'b': [3,4]})
df2 = pd.DataFrame({'a': [5,6], 'c': [7,8]})

pd.concat([df1, df2])
# a: 1,2,5,6
# b: 3,4,NaN,NaN
# c: NaN,NaN,7,8

기본 join='outer', 합집합. join='inner' 면 교집합 컬럼만:

pd.concat([df1, df2], join='inner')
# 공통 컬럼 a 만 남음

keys (계층적 라벨)

pd.concat([df1, df2], keys=['Q1', 'Q2'])
# 결과의 index 가 MultiIndex: (Q1, 0), (Q1, 1), (Q2, 0), (Q2, 1)

여러 시기/그룹의 데이터를 한 번에 모아 분석할 때 유용:

combined = pd.concat([q1, q2, q3], keys=['Q1', 'Q2', 'Q3'])

# 특정 분기만 추출
combined.loc['Q2']

# 분기별 집계
combined.groupby(level=0).sum()

names 파라미터로 MultiIndex 레벨 이름도 지정:

pd.concat(
    [df_2024, df_2025],
    keys=[2024, 2025],
    names=['year', 'original_idx'],
)

자주 쓰는 패턴

여러 파일을 하나로

import glob
dfs = [pd.read_csv(f) for f in glob.glob('data/*.csv')]
big = pd.concat(dfs, ignore_index=True)

새 행 추가 (pandas 2.x)

# pandas 1.x 의 df.append 는 pandas 2.0 에서 제거됨
new_row = pd.DataFrame([{'name': 'E', 'age': 50}])
df = pd.concat([df, new_row], ignore_index=True)

컬럼 추가 (가로 결합)

features = compute_features(df)  # 별도 feature DataFrame
result = pd.concat([df, features], axis=1)

딕셔너리에서 concat

frames = {'train': df_train, 'val': df_val, 'test': df_test}
combined = pd.concat(frames)
# MultiIndex: ('train', 0), ('val', 0), ...
combined.loc['train']   # 학습 데이터만 추출

조건부 분기 처리 후 재결합

premium = df[df['tier'] == 'premium'].copy()
standard = df[df['tier'] != 'premium'].copy()
premium['discount'] = 0.2
standard['discount'] = 0.05
result = pd.concat([premium, standard]).sort_index()

Nullable dtype 유지 (pandas 2.x)

# int 컬럼에 NaN 이 섞여도 float 강등을 방지
df1 = pd.DataFrame({'count': pd.array([1, 2], dtype='Int64')})
df2 = pd.DataFrame({'count': pd.array([None, 4], dtype='Int64')})
pd.concat([df1, df2], ignore_index=True)
# count 컬럼: Int64 (nullable) 유지

성능

concat 은 전체 결과 메모리를 미리 할당 한 뒤 복사. 큰 데이터를 루프 안에서 반복 concat 하면 O(n²) 비용 가능.

# 느림: 루프 안에서 반복 concat
result = pd.DataFrame()
for df in dfs:
    result = pd.concat([result, df])

# 빠름: 한 번에 리스트 전달
result = pd.concat(dfs, ignore_index=True)

대용량 concat 에서 dtype 을 미리 지정하면 메모리 절약:

dtypes = {'id': 'int32', 'value': 'float32', 'label': 'category'}
dfs = [pd.read_csv(f, dtype=dtypes) for f in files]
result = pd.concat(dfs, ignore_index=True)

[!TIP] pandas 2.x 에서는 pd.concat 결과가 항상 새 메모리를 할당한다. 임시 리스트를 concat 직후 del dfs 로 해제하면 피크 메모리를 줄일 수 있다.

pandas 2.x 변경점

항목	pandas 1.x	pandas 2.x
`df.append`	지원	제거됨 (`pd.concat` 으로 대체)
`sort` 기본값	`False`	`False` (유지)
Copy-on-Write	미지원	기본 활성화
Nullable int + NaN concat	float 강등	`Int64` 유지 가능

merge / join / concat 비교

동작	함수
key 매칭	`merge`
index 매칭	`join`
단순 연결 (위/옆)	`concat`

함정

1. index 중복

pd.concat([df1, df2])
# 0, 1, 0, 1 -> .loc[0] 이 두 행 반환
# 해법: ignore_index=True 또는 reset_index(drop=True)

2. dtype 강등

# a 가 int 인 df1 에 NaN 이 포함된 df2 를 concat 하면 float 으로 강등
# 해법: Nullable dtype 사용
df1 = pd.DataFrame({'a': pd.array([1, 2], dtype='Int64')})
df2 = pd.DataFrame({'a': pd.array([None], dtype='Int64')})
pd.concat([df1, df2])  # Int64 유지

3. 컬럼 순서

# 합집합이지만 순서는 첫 DataFrame 우선
# df1 의 컬럼 + df2 의 새 컬럼 (뒤에 추가)
# 의도치 않은 순서를 원하면 .reindex(columns=원하는_순서) 로 정렬

4. axis=1 에서 index 불일치

left = pd.DataFrame({'a': [1, 2]}, index=[0, 1])
right = pd.DataFrame({'b': [10]}, index=[0])
pd.concat([left, right], axis=1)
# NaN 생성: right.b 의 index 1 은 NaN

[!WARNING] axis=1 concat 시 두 DataFrame 의 index 가 완전히 일치하지 않으면 NaN 이 생긴다. join='inner' 로 교집합 index 만 유지하거나, 사전에 index 를 정렬/재설정하라.

5. df.append() 제거 (pandas 2.0)

# AttributeError
df = df.append(new_row)

# 대체
df = pd.concat([df, new_row], ignore_index=True)

6. sort 파라미터

# pandas 2.x 기본: sort=False (첫 DataFrame 컬럼 순서 유지)
# sort=True 하면 알파벳 정렬
pd.concat([df1, df2], sort=False)

[Pandas] crosstab

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pd.crosstab(index, columns) 는 두 (또는 그 이상의) Series 로 교차 빈도표 (contingency table) 를 만든다. SQL 의 PIVOT 또는 Excel 의 피벗 테이블과 비슷.

pd.crosstab(df['gender'], df['plan'])

사용 상황

범주형 변수 간 분포 탐색: 성별 x 구독 플랜, 지역 x 연령대 등 교차 분포 파악
비율 분석: normalize='index' 로 행 기준 비율, normalize='all' 로 전체 비율
데이터 검증: 특정 조합의 존재 여부, 결측 조합 탐지
집계 보고서: values + aggfunc 로 빠른 요약 테이블 생성

pivot_table 과 기능이 비슷하지만, 입력이 DataFrame 컬럼명이 아닌 Series 직접 전달이라는 점이 다르다.

분석 흐름 시각화

flowchart LR
    S1["index Series"] -->|"pd.crosstab()"| CT["교차 빈도표"]
    S2["columns Series"] -->|"pd.crosstab()"| CT

    CT -->|"normalize='index'"| NR["행 기준 비율"]
    CT -->|"margins=True"| MR["소계 포함"]
    CT -->|"values + aggfunc='sum'"| AG["합계 집계"]

기본 (count)

gender \ plan	basic	pro
F	1	2
M	2	1

margins (소계 / 총계 행)

pd.crosstab(df['gender'], df['plan'], margins=True, margins_name='Total')

normalize (비율)

pd.crosstab(df['gender'], df['plan'], normalize='index')    # 행 기준 비율
pd.crosstab(df['gender'], df['plan'], normalize='columns')  # 열 기준
pd.crosstab(df['gender'], df['plan'], normalize='all')      # 전체

각 행 합이 1. 행 기준 분포를 보여준다.

values + aggfunc (합계, 평균 등)

pd.crosstab(
    df['gender'],
    df['plan'],
    values=df['amount'],
    aggfunc='sum',
)

count 가 아닌 sum/mean 등의 집계. 사실상 [[Pandas pivot_table]] 과 같다.

다중 index / 다중 columns

pd.crosstab(
    [df['gender'], df['region']],
    df['plan']
)
# MultiIndex 행

pd.crosstab(
    df['gender'],
    [df['plan'], df['region']]
)
# MultiIndex 컬럼

crosstab vs pivot_table

항목	crosstab	pivot_table
입력	Series (또는 array)	DataFrame + 컬럼명
기본 aggfunc	count	mean
margins	`margins=`	`margins=`
다중 그룹	list 전달	list 전달
normalize	`normalize=`	없음 (수동 계산)

# 같은 결과
pd.crosstab(df['gender'], df['plan'])
df.pivot_table(index='gender', columns='plan', aggfunc='size')

실전 패턴

EDA: 범주형 변수 간 관계 탐색

import pandas as pd

df = pd.read_csv('customers.csv')

# 성별 x 구독 플랜 분포
ct = pd.crosstab(df['gender'], df['plan'])
print(ct)

# 행 기준 비율로 패턴 파악
ct_pct = pd.crosstab(df['gender'], df['plan'], normalize='index')
print(ct_pct.round(2))

결측 조합 탐지

# 특정 조합이 존재하는지 확인
ct = pd.crosstab(df['region'], df['product_code'])
# 0 인 셀: 해당 지역에 그 제품 주문 없음
missing_combos = (ct == 0).stack()
missing_combos[missing_combos].reset_index()[['region', 'product_code']]

고급 집계: 여러 aggfunc 동시 적용

# crosstab 자체는 단일 aggfunc 만 지원
# 여러 집계가 필요하면 pivot_table 사용
summary = df.pivot_table(
    index='gender',
    columns='plan',
    values='amount',
    aggfunc=['sum', 'mean', 'count'],
)
# MultiIndex 컬럼: ('sum', 'basic'), ('sum', 'pro'), ...

비율 히트맵 시각화 준비

import pandas as pd

ct_pct = pd.crosstab(
    df['age_group'],
    df['plan'],
    normalize='index'
).round(3)

# 시각화 (matplotlib / seaborn)
# import seaborn as sns
# sns.heatmap(ct_pct, annot=True, fmt='.1%', cmap='Blues')

다중 레벨 교차표 + margins

ct = pd.crosstab(
    [df['region'], df['gender']],
    df['plan'],
    values=df['revenue'],
    aggfunc='sum',
    margins=True,
    margins_name='합계',
)

성능

상황	권장
단순 count	`pd.crosstab()` 간결, 빠름
count + normalize	`pd.crosstab(normalize=...)` 한 번에
다중 집계	`pivot_table(aggfunc=['sum', 'mean'])`
대용량 + 다중 그룹	`groupby().unstack()` 이 더 빠를 수 있음
범주형 컬럼	`Categorical` dtype 으로 변환 후 crosstab -> 속도 향상

# 대용량: groupby + unstack 이 더 빠를 수 있음
result = (
    df.groupby(['gender', 'plan'])
    .size()
    .unstack('plan', fill_value=0)
)

# Categorical 변환으로 속도 향상
df['plan'] = pd.Categorical(df['plan'], categories=['basic', 'pro', 'enterprise'])
pd.crosstab(df['gender'], df['plan'])
# 카테고리 순서 보장 + 속도 향상

자주 만나는 함정

1. 합산 vs 카운트

pd.crosstab(df['gender'], df['plan'])                                            # count
pd.crosstab(df['gender'], df['plan'], values=df['amount'], aggfunc='sum')        # sum

values 와 aggfunc 를 같이 줘야 합산 가능. 어느 하나만 주면 에러.

2. 결측치

pd.crosstab(df['gender'], df['plan'], dropna=False)
# NaN 도 그룹으로 포함

기본으로 dropna=True 라 NaN 카테고리가 보이지 않는다. 데이터 품질 검증 시 dropna=False 권장.

3. normalize 의 유효값

'index' / 'columns' / 'all' / True / False 만 유효. True 는 'all' 과 같다.

4. 다중 aggfunc 불가

# ❌ crosstab 은 단일 aggfunc 만 허용
pd.crosstab(..., aggfunc=['sum', 'mean'])  # TypeError

# ✓ pivot_table 사용
df.pivot_table(..., aggfunc={'amount': ['sum', 'mean']})

[!WARNING] crosstab 은 normalize 와 values + aggfunc 를 동시에 사용할 수 없다. 비율 집계가 필요하면 수동으로 나눠야 한다.

[Pandas] DataFrame

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pandas.DataFrame 은 2차원 레이블 테이블. 각 열이 [[Pandas Series]], 모든 열이 같은 [[Pandas Index]] (행 라벨) 를 공유. SQL 테이블 / Excel 시트 / R data.frame 의 Python 대응체.

구조 시각화

flowchart LR
    subgraph "DataFrame"
        direction LR
        IDX["Index\n(행 라벨)"]
        C1["Series: name"]
        C2["Series: age"]
        C3["Series: city"]
    end
    IDX -->|"공유"| C1
    IDX -->|"공유"| C2
    IDX -->|"공유"| C3

각 열(column)은 독립적인 [[Pandas Series]] 이고, 모든 Series 가 동일한 Index 를 공유한다. 열마다 dtype 이 달라도 된다.

생성

다른 생성 방식

# list of dicts
pd.DataFrame([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}])

# 2D array + columns
pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])

# from records
pd.DataFrame.from_records([(1, 'A'), (2, 'B')], columns=['id', 'name'])

# CSV 등 파일
pd.read_csv('data.csv')

# SQL 쿼리 결과 (pandas 2.x)
pd.read_sql("SELECT * FROM users", con=engine)

핵심 속성

속성	의미
`df.shape`	`(n_rows, n_cols)`
`df.columns`	Index 객체 (열 이름)
`df.index`	Index 객체 (행 라벨)
`df.dtypes`	각 열의 타입
`df.values`	2D numpy array
`df.size`	원소 총 개수
`df.T`	전치 (transpose)
`df.ndim`	차원 수 (항상 2)
`df.empty`	원소가 없으면 True
`df.memory_usage()`	열별 메모리 사용량 (bytes)

빠른 탐색 메서드

df.head()         # 상위 5개
df.tail(3)
df.info()         # 메모리, dtype, null 개수
df.describe()     # 수치형 통계
df.sample(5)      # 무작위 5개
df.value_counts() # Series 만, 빈도

열 추가 / 수정 / 삭제

df['bmi'] = df['weight'] / (df['height']/100) ** 2   # 새 열
df['age'] = df['age'] + 1                            # 수정
df['constant'] = 100                                  # broadcast
df.drop(columns=['bmi'], inplace=False)              # 삭제 (사본 반환)

# assign 으로 method chain
df_new = (
    df
    .assign(bmi=lambda d: d['weight'] / (d['height']/100)**2)
    .assign(category=lambda d: pd.cut(d['bmi'], bins=[0, 18.5, 25, 30, 100]))
)

행 추가

# Modern pandas 2.x
new_row = pd.DataFrame([{'name': 'Dave', 'age': 28}])
df = pd.concat([df, new_row], ignore_index=True)

# (pandas 1.x 의 df.append 는 deprecated)

자주 쓰는 변환

df.rename(columns={'old': 'new'})
df.astype({'age': 'int64', 'city': 'category'})
df.set_index('name')
df.reset_index()
df.sort_values('age')
df.sort_index()

DataFrame vs Series 의 관계

df['name']           # Series
df[['name', 'age']]  # DataFrame (대괄호 2개)
df.iloc[0]           # Series (한 행)
df.iloc[[0]]         # DataFrame (한 행이지만 2D)

대괄호 개수 / iloc 단일 vs 리스트 가 반환 타입을 결정.

Copy vs View

pandas 의 가장 흔한 혼란 중 하나. 슬라이싱 결과가 원본의 뷰(view) 인지 복사본(copy) 인지 불명확하다.

flowchart TD
    DF["원본 DataFrame"] --> SLICE["df[mask] / df[cols]"]
    SLICE -->|"view 일 때"| V["수정 시 원본도 변경"]
    SLICE -->|"copy 일 때"| C["수정해도 원본 불변"]
    V --> WARN["SettingWithCopyWarning"]

# pandas 2.0 CoW (Copy-on-Write) 이전
sub = df[df['age'] > 30]          # view 일 수도, copy 일 수도
sub['new'] = 1                     # ⚠️ SettingWithCopyWarning

# 올바른 방법: 명시적 .copy()
sub = df[df['age'] > 30].copy()
sub['new'] = 1                     # 원본 안전

# pandas 2.0+ CoW: 항상 copy 처럼 동작 (view 수정 불가)

[!WARNING] pandas 2.0 부터 Copy-on-Write (CoW) 가 기본 도입됐다. df[...] 로 선택한 결과에 대입하면 ChainedAssignmentError. 조건부 수정은 반드시 .loc[행, 열] = 한 번에.

성능 팁

# dtype 을 명시해 메모리 절약
df = pd.DataFrame({
    'age': pd.array([25, 30, 35], dtype='int8'),     # int64 대신 1/8 메모리
    'city': pd.Categorical(['Seoul', 'Busan', 'Seoul']),  # category 타입
})

# 컬럼 많을 때 필요한 것만 read_csv
df = pd.read_csv('data.csv', usecols=['name', 'age'])

# inplace 는 메모리 절약 아님 (사본 생성 후 교체)
df.sort_values('age', inplace=True)   # 권장 안 함
df = df.sort_values('age')            # 더 명확

자세히는 [[Pandas 성능 / 메모리 최적화]].

함정

1. SettingWithCopyWarning

sub = df[df['age'] > 20]
sub['new'] = 1      # ⚠️ view 인지 copy 인지 모름

# 해법: .loc 한 번에 처리
df.loc[df['age'] > 20, 'new'] = 1    # ✓

2. inplace 의 오해

df.drop(columns=['a'], inplace=True)
# inplace 는 내부적으로 복사 후 교체, 메모리 절약 없음
# 그리고 method chain 불가, 디버깅 어려움
# 반환값 None 이라 실수 유발

[!CAUTION] inplace=True 는 실질적 이점이 없다. 반환값이 None 이라 df = df.sort_values(...) 처럼 쓰려다 데이터를 잃을 수 있다.

3. dtypes 혼용

df = pd.DataFrame({'a': [1, 2, None]})
df.dtypes    # float64 (int + None → float)

# pandas 2.0 nullable int
df = pd.DataFrame({'a': pd.array([1, 2, None], dtype='Int64')})
df.dtypes    # Int64 (nullable)

4. 빈 DataFrame 생성 후 루프 append

# ❌ 매우 느림
results = pd.DataFrame()
for row in data:
    results = pd.concat([results, pd.DataFrame([row])])

# ✓ 리스트에 모아 한 번에
rows = []
for row in data:
    rows.append(row)
df = pd.DataFrame(rows)

[Pandas] DataFrame.style

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

DataFrame.style 는 HTML/CSS 기반 서식을 DataFrame 에 적용하는 API. Jupyter 노트북, 보고서, Excel 출력에 활용. 데이터 자체는 변하지 않고 표시만 바뀐다.

import pandas as pd

df = pd.DataFrame({'sales': [1200, 950, 1800], 'growth': [0.12, -0.05, 0.25]})
df.style.format({'sales': '{:,.0f}', 'growth': '{:.1%}'})
# DataFrame 이 아닌 Styler 객체 반환

사용 상황

용도	적합 여부	비고
Jupyter 보고서 시각화	✅	셀 출력 시 자동 렌더링
Excel 서식 있는 출력	✅	`to_excel()` + openpyxl
HTML 대시보드	✅	`to_html()`
대용량 df 시각화	❌	10만 행 이상 느림
데이터 변환	❌	표시만 바뀜, df 값 불변

Styler API 파이프라인

flowchart LR
    DF["DataFrame"] -->|"df.style"| ST["Styler 객체"]
    ST --> FM[".format()"]
    ST --> MP[".map(fn)"]
    ST --> AP[".apply(fn)"]
    ST --> BG[".background_gradient()"]
    ST --> HL[".highlight_max()"]
    FM --> CH["체이닝 가능"]
    MP --> CH
    AP --> CH
    BG --> CH
    HL --> CH
    CH --> E1[".to_html()"]
    CH --> E2[".to_excel()"]
    CH --> E3["Jupyter 렌더링"]

메서드는 모두 Styler 객체를 반환하므로 .format().map().highlight_max() 처럼 체이닝 가능.

자주 쓰는 메서드

메서드	효과
`.format(...)`	숫자/날짜 포맷팅
`.map(fn)`	셀별 스타일 함수
`.apply(fn, axis=)`	컬럼/행 단위 스타일
`.background_gradient(cmap=)`	색상 그라데이션
`.bar(...)`	셀 안 막대 시각화
`.highlight_max(color=)`	최댓값 강조
`.highlight_min(color=)`	최솟값 강조
`.highlight_null(color=)`	NaN 강조
`.highlight_between(left=, right=)`	범위 내 값 강조
`.set_caption(...)`	표 제목
`.set_properties(**kwargs)`	모든 셀 CSS 속성
`.to_html()` / `.to_excel()`	내보내기

format

숫자, 날짜, 문자열 표시 형식 지정.

import pandas as pd

df.style.format({
    'price': '{:,.0f} 원',
    'rate': '{:.2%}',
    'date': lambda x: x.strftime('%Y-%m-%d'),
    'score': '{:.1f}',
})

포맷 문자열	의미	예시
`{:.2f}`	소수 2 자리	`3.14`
`{:,.0f}`	천 단위 콤마	`1,234`
`{:.2%}`	백분율	`12.50%`
`{:>10}`	우측 정렬 10 칸	`text`
`{:+.1f}`	부호 포함	`+3.1` / `-3.1`

NaN 처리:

df.style.format('{:.1f}', na_rep='N/A')   # NaN 을 'N/A' 로 표시

conditional 색상

# 색상 맵: RdYlGn (빨강 낮음, 초록 높음)
df.style.background_gradient(cmap='RdYlGn', subset=['profit'])

# 특정 범위만
df.style.background_gradient(cmap='Blues', vmin=0, vmax=100, subset=['score'])

자주 쓰는 cmap: RdYlGn, Greens, Blues, Reds, coolwarm, viridis.

highlight

df.style.highlight_max(color='lightgreen', subset=['sales'])
df.style.highlight_min(color='salmon', subset=['sales'])
df.style.highlight_null(color='yellow')
df.style.highlight_between(left=0, right=100, color='lightblue', subset=['score'])

사용자 정의 스타일 (map)

셀 단위로 CSS 문자열을 반환하는 함수.

def color_negative(v):
    return 'color: red; font-weight: bold' if v < 0 else 'color: green'

df.style.map(color_negative)                       # 모든 숫자 셀
df.style.map(color_negative, subset=['profit'])     # 특정 컬럼만

# NaN 포함 데이터에 안전하게 적용
def safe_color(v):
    if pd.isna(v):
        return ''
    return 'color: red' if v < 0 else ''

df.style.map(safe_color, subset=['growth'])

[!IMPORTANT] pandas 2.1 부터 applymap 이 map 으로 이름 변경됐다. pandas 2.1 미만 환경에서는 applymap 을 써야 한다. df.style.applymap(fn) → df.style.map(fn).

apply (행/열 단위)

행 또는 열 전체를 받아 CSS 리스트를 반환하는 함수.

def highlight_max_in_row(s):
    is_max = s == s.max()
    return ['background-color: gold' if v else '' for v in is_max]

df.style.apply(highlight_max_in_row, axis=1)    # 각 행의 max 강조

def shade_col(s):
    return ['background-color: #e0f0ff'] * len(s)

df.style.apply(shade_col, axis=0, subset=['revenue'])   # 열 배경 고정

bar (셀 안 막대)

df.style.bar(subset=['sales'], color='lightgreen')

# 음수/양수 양방향 막대
df.style.bar(
    subset=['profit'],
    color=['#ffcccc', '#ccffcc'],   # 음수색, 양수색
    align='zero',
)

# 너비 조절
df.style.bar(subset=['score'], vmin=0, vmax=100, width=80)

속성 일괄 지정 (set_properties)

# 모든 셀에 동일한 CSS 적용
df.style.set_properties(**{
    'text-align': 'right',
    'font-size': '12px',
    'border': '1px solid #ddd',
})

# 특정 컬럼만
df.style.set_properties(subset=['name'], **{'text-align': 'left'})

보고서 내보내기

# HTML
df.style.format('{:.2f}').to_html('report.html')

# Excel (서식 포함, openpyxl 필요)
df.style.background_gradient().to_excel('styled.xlsx', engine='openpyxl')

# Excel: 여러 시트에 쓸 때
with pd.ExcelWriter('report.xlsx', engine='openpyxl') as writer:
    df.style.highlight_max().to_excel(writer, sheet_name='Sheet1')

# LaTeX
df.style.to_latex()

자주 쓰는 패턴

매출 보고서

report = monthly.style \
    .format({'sales': '{:,.0f}', 'growth': '{:.1%}'}) \
    .background_gradient(cmap='Greens', subset=['sales']) \
    .map(lambda x: 'color: red' if x < 0 else 'color: green',
         subset=['growth']) \
    .highlight_max(subset=['sales'], color='gold') \
    .set_caption('월별 매출 현황')

report.to_excel('monthly_report.xlsx', engine='openpyxl')

결측치 검사

df.style.highlight_null(color='red')

조건부 행 하이라이트

def highlight_high_sales(row):
    return ['background-color: #fffacd' if row['sales'] > 1000 else ''
            for _ in row]

df.style.apply(highlight_high_sales, axis=1)

등급별 색상

grade_colors = {'A': '#c3e6cb', 'B': '#fff3cd', 'C': '#f5c6cb'}

df.style.map(lambda g: f'background-color: {grade_colors.get(g, "")}',
             subset=['grade'])

성능

# 행 수별 스타일 적용 시간 (기준치)
# 1,000 행 → ~0.1초
# 10,000 행 → ~1초
# 100,000 행 → 수십 초, 메모리 급증

접근	적합 행 수	비고
`background_gradient`	10,000 이하	행마다 색상 계산
`highlight_*`	100,000 이하	max/null 계산 비교적 빠름
`format`	제한 없음	표시 변환만
`map(fn)`	50,000 이하	셀마다 fn 호출

[!CAUTION] 보고용 요약 DataFrame (수백~수천 행) 에 쓰는 것이 적합하다. 원시 데이터 전체에 적용하는 용도가 아니다.

함정

1. Style 은 Styler, 데이터 자체는 안 바뀜

styled = df.style.format('{:.2f}')
type(styled)        # pandas.io.formats.style.Styler (DataFrame 아님)
styled.data         # 원본 DataFrame 접근
df                  # 원본 값 그대로

2. 체이닝 순서가 결과에 영향

# highlight_max 가 background_gradient 보다 나중에 오면 덮어씀
df.style.background_gradient(cmap='Greens').highlight_max(color='gold')

3. format 후 Excel 저장 시 dtype

df.style.format('{:.2f}').to_excel('out.xlsx')
# Excel 셀에는 원래 숫자 값, 단지 표시 형식만 변경됨
# 문자열로 저장되지 않음

4. NaN 이 있는 셀의 fn 처리

# ❌ NaN 에 float 연산 → TypeError
df.style.map(lambda x: 'red' if x < 0 else '')

# ✓ NaN 방어
df.style.map(lambda x: '' if pd.isna(x) else ('color: red' if x < 0 else ''))

5. 무거운 스타일

수만 행에 그라데이션 적용 → 느림. 보고용 요약 데이터에 쓴다.

[Pandas] explode

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

explode(column) 는 list / set / tuple 등의 시퀀스 값을 가진 컬럼을 각 원소가 별도 행 이 되도록 펼친다.

JSON / 로그 / 다중 태그 데이터 처리의 핵심.

사용 상황

JSON 배열 컬럼 정규화: items, tags, labels 처럼 배열 형태의 컬럼을 행 단위로 풀어야 할 때
로그 파싱: 한 이벤트에 여러 속성이 list 로 저장된 구조 처리
집계 역연산: groupby + agg(list) 로 만든 그룹 결과를 다시 원래 행 단위로 되돌릴 때
태그/라벨 빈도 분석: 콤마 구분 문자열을 split 후 explode 해서 value_counts

explode 흐름 시각화

flowchart LR
    IN["한 행: user=Alice, tags=['py','pandas']"] --> EX["explode('tags')"]
    EX --> R1["행1: user=Alice, tags='py'"]
    EX --> R2["행2: user=Alice, tags='pandas'"]

기본

같은 index 가 반복됨 (0, 0, 1, 2, 2, 2). reset_index(drop=True) 로 깨끗하게:

df.explode('tags').reset_index(drop=True)

여러 컬럼 동시 explode (pandas 1.3+)

df.explode(['tags', 'scores'])
# 두 컬럼이 같은 길이여야 함

빈 list / NaN 처리

df = pd.DataFrame({'x': [[1, 2], [], None]})
df.explode('x')
#    x
# 0  1
# 0  2
# 1  NaN     <- 빈 list 는 NaN 한 행
# 2  NaN     <- None 도 NaN

빈 리스트를 아예 제거하려면:

df.explode('x').dropna(subset=['x'])

str.split + explode

문자열을 list 로 분리 후 explode 는 가장 흔한 패턴:

df = pd.DataFrame({'tags_str': ['py,pandas', 'py', 'go,rust,ts']})
df['tags'] = df['tags_str'].str.split(',')
exploded = df.explode('tags')

assign 으로 체인:

(
    df
    .assign(tag=df['tags_str'].str.split(','))
    .explode('tag')
    .drop(columns=['tags_str'])
    .reset_index(drop=True)
)

groupby 의 역연산

# group -> list
grouped = df.groupby('user')['tag'].apply(list).reset_index()

# list -> row (explode)
grouped.explode('tag').reset_index(drop=True)

자주 쓰는 패턴

JSON 의 배열 펼치기

import pandas as pd
data = [
    {'order': 1, 'items': ['apple', 'banana']},
    {'order': 2, 'items': ['cherry']},
]
df = pd.DataFrame(data)
df.explode('items').reset_index(drop=True)

tags 빈도 분석

df = pd.DataFrame({
    'post_id': [1, 2, 3],
    'tags': ['python,pandas,data', 'python', 'go,rust'],
})
tag_counts = (
    df.assign(tag=df['tags'].str.split(','))
    .explode('tag')
    ['tag']
    .value_counts()
)

range 펼치기

df = pd.DataFrame({
    'start': [1, 5, 10],
    'end':   [3, 6, 12],
})
df['range'] = df.apply(lambda r: list(range(r['start'], r['end'] + 1)), axis=1)
df.explode('range').reset_index(drop=True)

중첩 JSON 정규화

import json

df = pd.DataFrame({
    'id': [1, 2],
    'attributes': ['[{"k":"color","v":"red"},{"k":"size","v":"M"}]', '[{"k":"color","v":"blue"}]'],
})
df['attrs_list'] = df['attributes'].apply(json.loads)
exploded = df.drop(columns=['attributes']).explode('attrs_list')
attrs = pd.json_normalize(exploded['attrs_list'])
result = pd.concat([exploded.drop(columns=['attrs_list']).reset_index(drop=True), attrs], axis=1)

이벤트 로그 파싱

# 한 이벤트에 여러 액션이 기록된 경우
df = pd.DataFrame({
    'session_id': [1001, 1002],
    'actions': [['click', 'scroll', 'purchase'], ['view', 'click']],
})
(
    df.explode('actions')
    .reset_index(drop=True)
    .rename(columns={'actions': 'action'})
)

성능

explode 는 내부적으로 NumPy 를 활용해 효율적으로 행을 복제한다.

# 피해야 할 패턴: 반복문으로 행 단위 처리
rows = []
for _, row in df.iterrows():
    for tag in row['tags']:
        rows.append({'user': row['user'], 'tag': tag})
result = pd.DataFrame(rows)   # 느림

# 권장: explode
result = df.explode('tags').reset_index(drop=True)

대용량 데이터에서 explode 전 불필요한 컬럼을 먼저 제거하면 메모리 절약:

subset = df.loc[:, ['user', 'tags']]
subset.explode('tags').reset_index(drop=True)

[!TIP] explode 결과의 행 수는 원본 리스트 길이의 합과 같다. 10 만 행의 DataFrame 에서 평균 list 길이가 5 라면 explode 후 50 만 행이 된다. 메모리와 후속 처리 비용을 미리 계산하고, 필터를 explode 전에 최대한 적용하라.

함정

1. index 중복

df.explode('tags')
# index: 0, 0, 1, 2, 2, 2
# .loc[0] 이 첫 user 의 모든 태그를 반환
df.explode('tags').reset_index(drop=True)   # 권장

2. dtype 강등

df = pd.DataFrame({'nums': [[1, 2], [3]]})
exploded = df.explode('nums')
exploded.dtypes
# nums: object 가 될 가능성
exploded['nums'] = pd.to_numeric(exploded['nums'])  # 다시 int

3. 컬럼이 list 가 아니면 그대로

df = pd.DataFrame({'x': [1, 2, 3]})
df.explode('x')   # 행 수 변화 없음

[!WARNING] 컬럼의 dtype 이 object 라도 원소가 list 가 아니라 str 이면 explode 는 각 문자를 분리하지 않고 그냥 그대로 둔다. str.split 후 explode 를 해야 문자열을 분리할 수 있다.

4. 여러 컬럼 동시 explode 시 길이 불일치

df = pd.DataFrame({
    'tags':   [['a', 'b'], ['c']],
    'scores': [[10],        [20]],  # 첫 행이 길이 불일치
})
df.explode(['tags', 'scores'])   # ValueError 발생
# 두 컬럼의 list 길이가 반드시 일치해야 함

[Pandas] get_dummies / from_dummies

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pd.get_dummies(df) 는 범주형 컬럼을 원-핫 인코딩 (one-hot encoding) 한다. 범주 값 하나당 새 컬럼 (0/1 또는 True/False) 이 생성된다. ML 전처리의 가장 흔한 단계.

인코딩 흐름 시각화

flowchart LR
    RAW["city 컬럼\nSeoul / Busan / Daegu"] --> DUMMIES["get_dummies"]
    DUMMIES --> C1["city_Seoul\n1 / 0 / 0"]
    DUMMIES --> C2["city_Busan\n0 / 1 / 0"]
    DUMMIES --> C3["city_Daegu\n0 / 0 / 1"]
    C1 --> DROP["drop_first=True\nSeoul 제거"]
    DROP -->|"결과"| C2
    DROP -->|"결과"| C3

기본

index	Busan	Daegu	Seoul
0	F	F	T
1	T	F	F
2	F	T	F
3	F	F	T

DataFrame 전체

pd.get_dummies(df)        # 모든 object/category 컬럼 자동 인코딩
pd.get_dummies(df, columns=['city', 'plan'])   # 특정 컬럼만

prefix / sep

pd.get_dummies(df['city'], prefix='city')
# 컬럼: city_Busan, city_Daegu, city_Seoul

pd.get_dummies(df, columns=['city', 'plan'], prefix=['c', 'p'], prefix_sep='_')
# c_Seoul, p_basic ...

drop_first

pd.get_dummies(df['city'], drop_first=True)
# 첫 카테고리 제거 (n-1 컬럼)
# 회귀 모델의 multicollinearity 방지

[!IMPORTANT] 선형 회귀 / 로지스틱 회귀에서는 drop_first=True 가 기본 관행이다. n 개 카테고리를 n-1 개 더미 변수로 표현해야 다중공선성(multicollinearity) 을 피할 수 있다.

dtype 지정

pd.get_dummies(df, dtype='int8')        # bool 대신 int (메모리 효율)
pd.get_dummies(df, dtype='uint8')

pandas 2.x 기본은 bool. ML 라이브러리 호환을 위해 int 권장.

sparse 옵션

pd.get_dummies(df, sparse=True)
# 희소 행렬, 메모리 크게 절약 (특히 카테고리 多)

카테고리 수가 수백 이상이면 sparse 가 메모리를 대폭 절감한다.

from_dummies (역변환, pandas 2.0+)

dummies = pd.get_dummies(df['city'], prefix='city')
restored = pd.from_dummies(dummies, sep='_')
# 다시 단일 컬럼 city 로

scikit-learn 의 OneHotEncoder 와 비교

항목	`pd.get_dummies`	`OneHotEncoder`
학습/추론 일관성	새 데이터에 카테고리 없으면 컬럼 mismatch	`fit` 시 카테고리 기록, `transform` 시 일관
미지의 카테고리	에러 또는 누락	`handle_unknown='ignore'`
pipeline 통합	✗	✓ (sklearn Pipeline)
간편성	✓	△
sparse 지원	✓	✓

탐색/분석 에는 get_dummies, 프로덕션 ML 에는 OneHotEncoder.

실전 패턴

학습 / 테스트 일관성 유지

# 학습 시 카테고리 저장
train_encoded = pd.get_dummies(train_df, dtype='int8')
train_cols = train_encoded.columns

# 테스트 시 같은 컬럼으로 reindex
test_encoded = pd.get_dummies(test_df, dtype='int8').reindex(
    columns=train_cols, fill_value=0
)

MultiLabel 인코딩

df = pd.DataFrame({'tags': [['python', 'pandas'], ['python']]})
dummies = df['tags'].str.join('|').str.get_dummies(sep='|')
# python  pandas
#   1       1
#   1       0

str.get_dummies 가 list/multilabel 에 적합.

Category 타입으로 메모리 절약 후 인코딩

df['city'] = df['city'].astype('category')
encoded = pd.get_dummies(df, dtype='int8')
# category 타입 컬럼은 get_dummies 가 자동 인식

역변환 후 검증

성능

# 카테고리 수 C, 행 수 N 이라 할 때
# 메모리: N x C x dtype_bytes
# 예: 1M 행 x 100 카테고리 x int8 = 100MB

# sparse 로 절감
pd.get_dummies(df, dtype='uint8', sparse=True)
# 95% 0 인 경우 10배 이상 절약 가능

Categorical dtype 선처리의 효과

# category 타입으로 선처리하면 get_dummies 가 더 빠름 (카테고리 목록 사전 인식)
df['city'] = df['city'].astype('category')
df['city'].cat.categories    # Index(['Busan', 'Daegu', 'Seoul'], dtype='object')

# get_dummies 가 category 타입에서 known categories 만 사용
result = pd.get_dummies(df, dtype='int8')

get_dummies 사용 흐름 요약

flowchart TD
    DATA["원본 DataFrame\n범주형 컬럼 포함"] --> CHECK{"카테고리 수"}
    CHECK -->|"낮음 (< 20)"| BASIC["get_dummies 직접 적용\ndtype='int8', drop_first 결정"]
    CHECK -->|"높음 (20+)"| SPARSE["sparse=True 또는\ntarget encoding 고려"]
    BASIC --> TRAIN["학습 데이터 컬럼 저장\ntrain_cols = encoded.columns"]
    TRAIN --> TEST["테스트 데이터 reindex\n(fill_value=0)"]
    TEST --> MODEL["ML 모델 입력"]
    SPARSE --> MODEL

대안 인코딩 방법

방법	언제	패키지
`get_dummies`	탐색/분석, 낮은 cardinality	pandas
`OneHotEncoder`	프로덕션 ML pipeline	sklearn
Target Encoding	높은 cardinality, 회귀	category_encoders
Label Encoding	순서 있는 범주형	sklearn
Embedding	매우 높은 cardinality	PyTorch/TF

함정

1. unique 카테고리가 너무 많음

pd.get_dummies(df['user_id'])   # ❌ 수만 컬럼 폭증

ID 같은 high-cardinality 컬럼은 인코딩하지 말 것. target encoding 이나 embedding 을 고려.

2. NaN 처리

pd.get_dummies(df, dummy_na=True)
# NaN 도 별도 컬럼 (None 이라는 의미가 있을 때)

기본은 NaN 행에 모두 0 (NaN 이 특정 카테고리가 아닌 것으로 취급).

3. 학습/추론 컬럼 불일치

위의 reindex 패턴이 표준 해결책. sklearn pipeline 에서는 OneHotEncoder(handle_unknown='ignore') 가 더 안전.

[!WARNING] get_dummies 를 학습/추론 양쪽에 따로 호출하면 카테고리 순서나 존재 여부가 달라져 컬럼 수/순서 불일치 가 발생한다. 프로덕션 피처 파이프라인에서는 반드시 reindex 또는 OneHotEncoder 를 사용.

4. pandas 2.x 기본 dtype 변경

pandas 2.0 이전은 기본 uint8, 2.0+ 는 bool. ML 라이브러리에 넘길 때 dtype='int8' 로 명시하는 게 안전하다.

[Pandas] isin / isna / notna

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

메서드	의미
`.isin(values)`	각 원소가 values 안에 있는지 (boolean Series)
`.isna()`	NaN/NaT/None 여부 (`isnull` 별칭)
`.notna()`	위의 반대 (`notnull` 별칭)

사용 상황

isin: SQL IN (...) 처럼 여러 값 중 하나에 해당하는 행을 걸러낼 때
isna / notna: 결측치 유무 확인, 결측치가 있는/없는 행 선택 또는 집계 시
any / all 조합: 특정 컬럼 조합에 하나라도 결측치가 있는 행을 찾을 때

필터 흐름 시각화

flowchart TD
    DF["DataFrame / Series"] --> IsNull{"결측치 확인?"}
    IsNull -->|"예"| NA["isna / notna"]
    IsNull -->|"아니오, 값 목록 비교"| IN["isin(values)"]

    NA --> NAF["df[df['col'].isna()]"]
    NA --> NANF["df[df['col'].notna()]"]

    IN --> INF["df[df['col'].isin(list)]"]
    IN --> INNF["df[~df['col'].isin(list)]"]

isin

여러 값 중 하나에 해당하는지 검사. SQL 의 IN (...) 과 같음.

부정 (NOT IN)

df[~df['city'].isin(['Seoul'])]    # Seoul 아닌 것

dict 전달로 컬럼별 조건

df.isin({'city': ['Seoul'], 'name': ['Alice']})
# city == 'Seoul' AND name == 'Alice' 각각 별도 boolean

Series.isin vs DataFrame.isin

# Series.isin -> boolean Series (행 필터에 바로 사용)
mask = df['city'].isin(['Seoul', 'Busan'])
df[mask]

# DataFrame.isin -> boolean DataFrame (같은 shape)
# 각 셀이 values 에 있는지 여부
df.isin(['Seoul', 'Alice'])

실전: 승인된 카테고리만 필터

ALLOWED_STATUSES = {'approved', 'pending'}
valid = df[df['status'].isin(ALLOWED_STATUSES)]
invalid = df[~df['status'].isin(ALLOWED_STATUSES)]

실전: 다른 DataFrame 의 키로 필터

# whitelist DataFrame 의 id 와 일치하는 행만 추출
valid_ids = whitelist_df['id'].tolist()
df[df['id'].isin(valid_ids)]

isna / notna

df = pd.DataFrame({'a': [1, None, 3], 'b': [None, 2, 3]})

df.isna()                # 같은 shape 의 boolean DataFrame
df['a'].isna()           # Series
df['a'].notna()          # 반대

df[df['a'].notna()]      # a 가 not null 인 행만
df.dropna()              # 어느 컬럼이든 NaN 있는 행 제거
df.dropna(subset=['a'])  # a 컬럼만 검사

any / all 과 결합

# 어느 컬럼이든 NaN 인 행
df[df.isna().any(axis=1)]

# 모든 컬럼이 NaN 인 행
df[df.isna().all(axis=1)]

# 컬럼별로 NaN 비율
df.isna().mean()

# 전체 NaN 개수
df.isna().sum().sum()

NaN, None, NaT, pd.NA 차이

값	타입	대응
`np.nan`	float	수치형 결측
`None`	NoneType	object dtype 결측, 자동 NaN 변환
`pd.NaT`	NaTType	datetime 결측
`pd.NA`	NAType	nullable dtype 의 결측 (pandas 1.x+)

.isna() 는 위 모두를 True 로 판단한다.

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, None, pd.NaT, pd.NA], dtype=object)
s.isna()
# 0    False
# 1     True
# 2     True
# 3     True
# 4     True

실전 패턴

결측치 비율 리포트

null_report = pd.DataFrame({
    'count': df.isna().sum(),
    'pct': (df.isna().mean() * 100).round(2),
})
print(null_report[null_report['count'] > 0])

결측치가 있는 컬럼 목록

cols_with_null = df.columns[df.isna().any()].tolist()

특정 컬럼 조합 모두 비어 있는 행 제거

# name 또는 email 중 하나라도 있으면 유지
df = df.dropna(subset=['name', 'email'], how='all')

조건부 fillna (isna + where)

# status 가 NaN 인 행의 status 를 'unknown' 으로
df['status'] = df['status'].where(df['status'].notna(), 'unknown')
# 또는
df['status'] = df['status'].fillna('unknown')

isin + isna 동시 조건

# city 가 서울/부산이고 age 가 null 이 아닌 행
mask = df['city'].isin(['Seoul', 'Busan']) & df['age'].notna()
df[mask]

그룹별 결측치 비율

df.groupby('region')['sales'].apply(lambda s: s.isna().mean())

성능

# isin 은 내부적으로 set lookup
# 리스트보다 set 을 직접 전달하면 약간 빠름 (중복 없을 때)
values = {'Seoul', 'Busan', 'Daegu'}
df['city'].isin(values)

# isna 는 NumPy 연산이므로 매우 빠름 (C 레벨)
# 대량 데이터에서도 병목이 되지 않음

# 주의: object dtype 컬럼에서 isin 은 값 비교가 느릴 수 있음
# category dtype 으로 변환하면 속도 개선
df['city'] = df['city'].astype('category')
df['city'].isin(['Seoul', 'Busan'])  # 더 빠름

[!TIP] 대용량 DataFrame 에서 isin 을 자주 쓴다면 해당 컬럼을 category dtype 으로 변환하라. 메모리 절약 + 비교 속도 향상 두 가지 이점이 있다.

함정

1. `== np.nan` 안 됨

df[df['a'] == np.nan]    # 항상 False
df[df['a'].isna()]        # 올바름

NaN != NaN 이라는 IEEE 754 규약 때문.

2. `is None` 도 권장 안 함

df['a'] is None    # Series 가 None 인지 비교 (항상 False)
df['a'].isna()     # 각 원소 검사

3. isin 의 dtype 불일치

df = pd.DataFrame({'id': [1, 2, 3]})  # int
df['id'].isin(['1', '2'])              # 모두 False (str vs int)
df['id'].isin([1, 2])                  # 올바름

[!WARNING] isin 에 전달하는 리스트의 dtype 이 컬럼의 dtype 과 다르면 일치하는 값이 없어 모두 False 가 된다. 특히 CSV 로 읽은 데이터에서 숫자 id 가 str 로 파싱된 경우 자주 발생.

4. isna 와 dropna 의 미묘한 차이

# isna().any(axis=1) 과 dropna 의 기본 동작은 동일
df[~df.isna().any(axis=1)]
df.dropna()              # 같은 결과 (how='any', axis=0)

# 하지만 subset 지정에서 차이
df.dropna(subset=['a'])
df[df['a'].notna()]      # 위와 같음

5. pd.NA vs np.nan (nullable dtype)

# nullable Int64 컬럼에서 isna 는 pd.NA 도 True 로 처리
s = pd.array([1, pd.NA, 3], dtype='Int64')
pd.Series(s).isna()
# True 로 정상 처리

[Pandas] melt

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

DataFrame.melt() 는 [[Pandas pivot]] 의 역방향. wide-format → long-format 변환. 여러 컬럼을 두 컬럼 (variable, value) 으로 합친다.

장기간 시계열 데이터나 시각화 라이브러리 (seaborn, plotly) 입력에 적합하다.

사용 상황

상황	적합 여부	비고
seaborn / plotly 에 hue 그룹 필요	✅	long format 이 표준
tidy data 변환	✅	분석 파이프라인 표준
여러 기간 컬럼을 하나로	✅	`2020, 2021, 2022` 컬럼 → `year, value`
설문 문항별 응답 집계	✅	`q1, q2, q3` → `question, answer`
pivot 의 역방향 복원	✅	`pivot()` 결과 되돌리기
이미 long format 인 데이터	❌	불필요

wide vs long 구조

flowchart LR
    WIDE["wide format\n과목별 별도 컬럼"]
    LONG["long format\nsubject + score 컬럼"]
    WIDE -->|"melt()"| LONG
    LONG -->|"pivot()"| WIDE

wide	name	math	english	science
행 수	2	-	-	-

long	name	subject	score
행 수	6	-	-

행 수가 컬럼 수 × 원본 행 수 로 늘어난다.

시각화

{}

기본

Before (wide):

	name	math	english	science
0	Alice	90	85	95
1	Bob	80	75	70

After (long):

	name	subject	score
0	Alice	math	90
1	Bob	math	80
2	Alice	english	85
3	Bob	english	75
4	Alice	science	95
5	Bob	science	70

파라미터

파라미터	의미	기본값
`id_vars`	유지할 컬럼 (key 역할)	-
`value_vars`	melt 할 컬럼 (생략 시 id_vars 외 모두)	모두
`var_name`	melt 된 컬럼명	`'variable'`
`value_name`	값 컬럼명	`'value'`
`ignore_index`	True 면 새 index, False 면 원본 유지	`True`

일부 컬럼만 melt

df.melt(
    id_vars=['name', 'grade'],
    value_vars=['math', 'english'],   # science 는 제외
    var_name='subject',
    value_name='score',
)

시각화 라이브러리와의 궁합

import seaborn as sns

melted = df.melt(id_vars='name', var_name='subject', value_name='score')
sns.barplot(data=melted, x='subject', y='score', hue='name')
# long format 이라 seaborn 이 자동으로 그룹화

plotly 에서도 동일하게 long format 을 기대한다:

import plotly.express as px

melted = df.melt(id_vars='name', var_name='subject', value_name='score')
fig = px.bar(melted, x='subject', y='score', color='name', barmode='group')
fig.show()

pivot 과의 역관계

import pandas as pd

wide = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'math': [90, 80],
    'english': [85, 75],
})

# wide → long
long = wide.melt(id_vars='name', var_name='subject', value_name='score')

# long → wide (원래대로)
recovered = long.pivot(index='name', columns='subject', values='score')
recovered.columns.name = None   # 컬럼 이름 제거
recovered = recovered.reset_index()

pd.wide_to_long 대안

컬럼명에 숫자 suffix 가 있을 때 더 간결하다.

# 컬럼: sales_2020, sales_2021, cost_2020, cost_2021
pd.wide_to_long(df, stubnames=['sales', 'cost'], i='company', j='year', sep='_')
# melt 보다 컬럼 분리가 자동화됨

stack 과 비교

# melt 결과: 컬럼화 (subject, score 두 컬럼)
df.melt(id_vars='name', var_name='subject', value_name='score')

# stack 결과: MultiIndex Series
df.set_index('name').stack()
# MultiIndex (name, subject) → value

항목	`melt()`	`stack()`
결과 구조	DataFrame (컬럼화)	Series (MultiIndex)
id_vars 처리	명시적으로 지정	index 로 설정 필요
시각화 라이브러리	바로 사용 가능	reset_index 필요

자주 만나는 패턴

1. 연도별 와이드 데이터 → 시계열 차트

df = pd.DataFrame({
    'company': ['A사', 'B사'],
    '2022': [1000, 800],
    '2023': [1200, 850],
    '2024': [1400, 900],
})
long = df.melt(id_vars='company', var_name='year', value_name='revenue')
# year 컬럼을 int 로 변환
long['year'] = long['year'].astype(int)

2. 설문 응답 데이터

# 컬럼: respondent_id, q1, q2, q3, q4
survey.melt(
    id_vars=['respondent_id', 'age', 'gender'],
    var_name='question',
    value_name='answer'
)

3. A/B 테스트 지표 long format 변환

ab = pd.DataFrame({
    'user_id': ['u1', 'u2'],
    'control_conv': [0.12, 0.15],
    'treatment_conv': [0.14, 0.18],
})
ab_long = ab.melt(
    id_vars='user_id',
    value_vars=['control_conv', 'treatment_conv'],
    var_name='group',
    value_name='conversion_rate'
)

4. groupby 후 집계

# 과목별 평균 점수
melted.groupby('subject')['score'].agg(['mean', 'std', 'count'])

성능

import pandas as pd
import numpy as np

# 1,000 행 × 20 컬럼 melt → 20,000 행
df = pd.DataFrame(
    np.random.randn(1_000, 20),
    columns=[f'col{i}' for i in range(20)]
)
df.insert(0, 'id', range(1_000))

long = df.melt(id_vars='id', var_name='feature', value_name='value')
# 결과: 20,000 행 × 3 컬럼
print(long.shape)   # (20000, 3)

입력 크기	melt 시간	결과 행 수
1,000 × 10	~0.001s	10,000
10,000 × 20	~0.01s	200,000
100,000 × 50	~0.5s	5,000,000

대용량 데이터에서 melt 후 분석은 메모리 주의. 가능하면 필요한 컬럼만 value_vars 로 지정한다.

[!WARNING] 100,000 행 × 100 컬럼 melt = 10,000,000 행. 메모리 부족이 날 수 있다. value_vars 로 필요한 컬럼만 선택해서 melt 하라.

함정

1. value_vars 안 주면 모든 비-id 컬럼 melt

df.melt(id_vars='name')   # math, english, science, timestamp 모두 melt

원치 않은 컬럼 (예: timestamp, 내부 key) 도 묶일 수 있다.

2. 결과 행 수 폭증

# 1,000 행 × 10 melt 컬럼 = 10,000 행

큰 데이터에서 melt 후 분석은 메모리 주의.

3. var_name 의 default 가 ‘variable’

df.melt(id_vars='name')          # 컬럼명: 'variable', 'value' (불명확)
df.melt(id_vars='name',
        var_name='subject',
        value_name='score')       # 명시적 이름 권장

4. 컬럼 타입 혼합 시 value 컬럼 dtype

# int 컬럼과 str 컬럼이 섞이면 value 가 object 로 업캐스팅
df.melt(id_vars='name')   # value 컬럼이 object dtype

타입이 일관된 컬럼끼리만 melt 하거나, melt 후 타입 변환을 한다.

[Pandas] merge

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pandas.merge(left, right, ...) 는 두 DataFrame 을 SQL join 처럼 결합. 4 가지 join 타입 (inner / left / right / outer) 지원.

사용 상황

두 테이블 키 기반 결합: users + orders 테이블을 user_id 로 병합
다중 키 결합: ['region', 'date'] 같은 복합 키로 결합
데이터 보강: 기본 DataFrame 에 코드 테이블, 마스터 테이블 붙이기
join 타입 선택: left (기준 유지), inner (교집합), outer (합집합)

join 타입 선택 시각화

flowchart TD
    START["두 DataFrame 결합"] --> Q1{"매칭 키만 필요?"}
    Q1 -->|"Yes"| INNER["how='inner'"]
    Q1 -->|"No"| Q2{"왼쪽 DataFrame 기준?"}
    Q2 -->|"Yes"| LEFT["how='left'"]
    Q2 -->|"No"| Q3{"오른쪽 DataFrame 기준?"}
    Q3 -->|"Yes"| RIGHT["how='right'"]
    Q3 -->|"No"| OUTER["how='outer'"]

4 가지 join 타입

how	설명	SQL
`inner` (기본)	양쪽 모두 있는 키만	INNER JOIN
`left`	왼쪽 모두 + 오른쪽 매칭	LEFT JOIN
`right`	오른쪽 모두 + 왼쪽 매칭	RIGHT JOIN
`outer`	양쪽 합집합, NaN 채움	FULL OUTER JOIN
`cross`	모든 조합	CROSS JOIN

기본

{}

	id	name	user_id	amount
0	1	Alice	1	100
1	1	Alice	1	200
2	2	Bob	2	150

users 3 명 중 Alice (id=1, 주문 2개), Bob (id=2, 주문 1개) 만 매칭. Charlie 와 orders 의 user_id=4 는 제외.

left join

pd.merge(users, orders, left_on='id', right_on='user_id', how='left')
# Charlie 도 포함, amount 는 NaN

outer join + indicator

pd.merge(a, b, on='key', how='outer', indicator=True)
# _merge 컬럼이 추가됨: left_only, right_only, both

매칭 여부를 시각화하기에 유용.

on / left_on, right_on / left_index, right_index

pd.merge(a, b, on='id')                            # 양쪽 컬럼 이름 같을 때
pd.merge(a, b, left_on='id', right_on='uid')       # 다른 이름
pd.merge(a, b, left_index=True, right_index=True)  # index 기반
pd.merge(a, b, left_on='id', right_index=True)     # 혼합

다중 키

pd.merge(a, b, on=['region', 'date'])
pd.merge(a, b, left_on=['region', 'date'], right_on=['reg', 'dt'])

suffixes

같은 이름의 컬럼이 양쪽에 있으면 suffix 가 붙는다.

pd.merge(a, b, on='id')
# 양쪽에 'name' 있으면 -> name_x, name_y
pd.merge(a, b, on='id', suffixes=('_a', '_b'))
# -> name_a, name_b

validate (1:1, 1:m, m:1, m:m 검증)

pd.merge(a, b, on='id', validate='one_to_one')
pd.merge(a, b, on='id', validate='many_to_one')
# 가정이 깨지면 MergeError

데이터 가정을 명시적으로 검증, 디버깅에 매우 유용. 실무에서 validate 를 항상 붙이는 습관을 들이면 데이터 품질 버그를 조기에 잡을 수 있다.

실전 패턴

코드 테이블 보강

import pandas as pd

# 트랜잭션 데이터에 상품 마스터 붙이기
txn = pd.DataFrame({
    'product_code': ['P001', 'P002', 'P001', 'P003'],
    'amount': [100, 200, 150, 300],
})
products = pd.DataFrame({
    'code': ['P001', 'P002', 'P003'],
    'name': ['Widget', 'Gadget', 'Doohickey'],
    'category': ['A', 'B', 'A'],
})

enriched = pd.merge(
    txn,
    products,
    left_on='product_code',
    right_on='code',
    how='left',
    validate='many_to_one',
)

outer + indicator 로 누락 탐색

# 어느 쪽에만 있는 키 찾기
merged = pd.merge(
    users, orders,
    left_on='id', right_on='user_id',
    how='outer', indicator=True
)

# 주문이 없는 유저
no_orders = merged[merged['_merge'] == 'left_only']
# 유저 없는 주문 (고아 레코드)
orphan_orders = merged[merged['_merge'] == 'right_only']

날짜 범위 join (merge_asof)

# 정확한 날짜가 아니라 가장 가까운 날짜로 매핑
pd.merge_asof(
    trades.sort_values('time'),
    quotes.sort_values('time'),
    on='time',
    by='ticker',
    direction='backward',  # 직전 시세
)

다중 키 + suffix 패턴

# 이번 달 vs 지난 달 비교
this_month = df[df['month'] == '2025-07'].rename(columns={'sales': 'sales_cur'})
last_month = df[df['month'] == '2025-06'].rename(columns={'sales': 'sales_prev'})

comparison = pd.merge(
    this_month[['region', 'product', 'sales_cur']],
    last_month[['region', 'product', 'sales_prev']],
    on=['region', 'product'],
    how='outer',
)
comparison['growth'] = comparison['sales_cur'] / comparison['sales_prev'] - 1

성능

방법	속도	비고
`pd.merge()`	기준	hash join 기반
`DataFrame.join()`	빠름	index 기반, 내부적으로 merge 사용
`pd.merge_asof()`	빠름	sort 된 키 필요, 시계열에 특화
중복 키 많은 outer join	느림	결과 크기 폭증 주의

# 대용량에서 dtype 맞추면 빠름
users['id'] = users['id'].astype('int32')
orders['user_id'] = orders['user_id'].astype('int32')

# sort 된 키 + merge_asof 는 매우 빠름
pd.merge_asof(a.sort_values('key'), b.sort_values('key'), on='key')

함정

1. 다대다 폭증

# users: id 가 1, 1 (중복)
# orders: user_id 가 1, 1, 1 (중복)
pd.merge(users, orders, ...)
# 2 x 3 = 6 행 생성, 의도 아닐 가능성

# 해법: validate 로 사전 검증
pd.merge(users, orders, ..., validate='many_to_one')  # MergeError 로 경고

2. dtype 불일치

users['id']        # int64
orders['user_id']  # object (문자열로 저장됨)
pd.merge(...)      # 매칭 안 됨!

# 해법
orders['user_id'] = orders['user_id'].astype('int64')

3. NaN 끼리 매칭 안 됨

# 양쪽에 NaN key 가 있어도 매칭 안 됨: NaN != NaN
# 필요하면 fillna 후 merge
a['key'] = a['key'].fillna('UNKNOWN')
b['key'] = b['key'].fillna('UNKNOWN')
pd.merge(a, b, on='key')

4. 결과에 불필요한 컬럼 잔류

pd.merge(a, b, left_on='id', right_on='user_id')
# 결과에 'id' 와 'user_id' 가 모두 남음
# 원하면 merge 후 drop
merged = pd.merge(...).drop(columns=['user_id'])

[!CAUTION] validate 없이 merge 하면 다대다 폭증이 조용히 발생한다. 특히 ETL 파이프라인에서 중복 데이터가 대량 생성될 수 있다. 항상 validate 를 붙이는 습관을 들여라.

merge vs join vs concat

동작	함수
key 기반 결합	`merge`
index 기반 결합 (간편 버전)	`DataFrame.join`
단순 위/옆 붙이기	`concat`

[Pandas] merge_asof

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pd.merge_asof(left, right, on, by=, direction=) 는 가장 가까운 키 기준 join. 일반 [[Pandas merge]] 가 정확히 일치하는 키만 매칭하는 반면, merge_asof 는 이전 (또는 가장 가까운) 키를 찾는다.

시계열 데이터 (가격, 이벤트) 와 다른 시계열 데이터 (참조 데이터, 다른 채널) 를 매칭할 때 핵심.

사용 상황

가격 + 거래 매칭: 분 단위 가격 데이터와 초 단위 거래 데이터를 시간 기준으로 결합
이벤트 + 상태 매칭: 이벤트 발생 시각 직전의 사용자 상태나 컨텍스트를 조인
센서 + 메타데이터: 다른 주기로 기록된 두 센서 스트림을 가장 가까운 시각에 맞춰 결합
tolerance 기반 fuzzy join: 허용 오차 이내에서만 매칭하고 그 외에는 NaN 처리

as-of join 흐름 시각화

flowchart LR
    subgraph "left - 거래"
        L1["09:00:30, qty=100"]
        L2["09:01:15, qty=200"]
        L3["09:02:45, qty=150"]
    end

    subgraph "right - 가격"
        R1["09:00:00, price=100"]
        R2["09:01:00, price=101"]
        R3["09:02:00, price=102"]
        R4["09:03:00, price=103"]
    end

    L1 -->|"직전 가격 09:00:00"| R1
    L2 -->|"직전 가격 09:01:00"| R2
    L3 -->|"직전 가격 09:02:00"| R3

기본

pd.merge_asof(left, right, on='time')
# 양쪽 모두 time 으로 정렬되어 있어야 함
# left 의 각 행에 대해 right.time <= left.time 중 가장 가까운 행 join

각 trade 시각의 직전 가격이 매칭됨.

direction

direction	의미
`'backward'` (기본)	이전 시각 매칭 (`<=`)
`'forward'`	이후 시각 매칭 (`>=`)
`'nearest'`	더 가까운 쪽

pd.merge_asof(trades, prices, on='time', direction='nearest')
pd.merge_asof(trades, prices, on='time', direction='forward')

direction='forward' 는 이후 시각 기준 매칭, 예측 모델에서 다음 이벤트를 미리 붙일 때 사용.

tolerance (허용 차이)

pd.merge_asof(
    trades, prices,
    on='time',
    tolerance=pd.Timedelta('5min')
)
# 5 분 이상 떨어지면 매칭 안 됨 (NaN)

tolerance 는 numeric 키에도 사용 가능:

pd.merge_asof(
    orders, catalog,
    on='price_level',
    tolerance=5,    # 가격 5 이내에서만 매칭
    direction='nearest',
)

by (그룹별 매칭)

pd.merge_asof(left, right, on='time', by='symbol')
# 같은 symbol 내에서만 시간 매칭

각 종목별로 독립적 as-of join:

정렬 필수

left = left.sort_values('time')
right = right.sort_values('time')
pd.merge_asof(left, right, on='time')

정렬되지 않으면 ValueError. 두 DataFrame 모두 on 키 기준으로 오름차순 정렬해야 한다.

left_on / right_on (키 이름이 다를 때)

pd.merge_asof(
    trades.rename(columns={'trade_time': 'time'}),
    prices,
    on='time',
)
# 또는 left_on / right_on 으로 명시
pd.merge_asof(trades, prices, left_on='trade_time', right_on='quote_time')

자주 쓰는 패턴

가격 데이터 + 트랜잭션

# 분 단위 가격 + 초 단위 거래
result = pd.merge_asof(
    trades.sort_values('timestamp'),
    prices.sort_values('timestamp'),
    on='timestamp',
    by='symbol',
)

이벤트 + 직전 컨텍스트

result = pd.merge_asof(
    events.sort_values('event_time'),
    user_state.sort_values('recorded_at'),
    left_on='event_time',
    right_on='recorded_at',
    by='user_id',
    tolerance=pd.Timedelta('1h'),   # 1 시간 이내 상태만 사용
)

다중 시계열 통합

df = pd.merge_asof(sales.sort_values('date'), weather.sort_values('date'), on='date')
df = pd.merge_asof(df, marketing.sort_values('date'), on='date')
df = pd.merge_asof(df, holiday_calendar.sort_values('date'), on='date')

수치 키 fuzzy join

# 주문 가격과 카탈로그 가격이 정확히 일치하지 않을 때
pd.merge_asof(
    orders.sort_values('unit_price'),
    catalog.sort_values('list_price'),
    left_on='unit_price',
    right_on='list_price',
    direction='nearest',
    tolerance=1.0,   # 단가 1원 이내 매칭
)

merge 와의 비교

메서드	매칭 방식	사용처
`merge`	정확 일치	일반 join
`merge_asof`	가장 가까운 키	시계열, fuzzy join

성능

merge_asof 는 정렬된 데이터에서 이진 탐색으로 동작하므로 O(n log m) 복잡도 (n: left 행 수, m: right 행 수).

# 성능 팁: 정렬을 최대한 앞에 두고 재사용
trades_sorted = trades.sort_values(['symbol', 'time'])
prices_sorted = prices.sort_values(['symbol', 'time'])

# by 를 쓰면 그룹별로 처리하므로 시간이 더 걸릴 수 있음
# 심볼 수가 많으면 groupby + merge_asof 루프가 더 빠를 때도 있음
results = []
for sym, grp in trades_sorted.groupby('symbol'):
    prc = prices_sorted[prices_sorted['symbol'] == sym]
    results.append(pd.merge_asof(grp, prc, on='time'))
result = pd.concat(results, ignore_index=True)

[!TIP] by 파라미터는 편리하지만 내부적으로 그룹마다 별도 처리를 한다. 그룹 수가 매우 많다면 직접 groupby 루프를 작성하고 각 그룹에 merge_asof 를 적용하는 방식이 더 제어하기 쉽다.

함정

1. 정렬 안 되면 에러

pd.merge_asof(unsorted_left, sorted_right, on='time')   # ValueError

2. on 컬럼의 dtype 불일치

pd.merge_asof(a, b, on='date')
# date 가 한 쪽은 datetime64, 다른 쪽은 str 이면 TypeError
a['date'] = pd.to_datetime(a['date'])
b['date'] = pd.to_datetime(b['date'])

3. by 의 dtype

pd.merge_asof(a, b, on='time', by='symbol')
# 양쪽 symbol 이 같은 dtype 이어야 함
# category dtype 권장 (메모리 + 속도)

4. 결과의 NaN (tolerance 초과 시)

result = pd.merge_asof(trades, prices, on='time', tolerance=pd.Timedelta('1min'))
# 1 분 이상 차이나면 price 가 NaN
result['price'].isna().sum()   # 매칭 실패 수 확인

[!WARNING] tolerance 를 설정하면 매칭 범위 밖의 right 행은 결과에 NaN 으로 채워진다. tolerance 기반 join 후 반드시 NaN 개수를 확인하고, 비율이 높으면 tolerance 설정이나 데이터 품질을 점검하라.

[Pandas] MultiIndex

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

MultiIndex 는 여러 단계(level)의 라벨로 구성된 [[Pandas Index]]. SQL의 composite key와 비슷하며, 그룹화된 데이터를 자연스럽게 표현한다. groupby, pivot_table, stack 등이 자동으로 생성하는 인덱스 형태.

사용 상황

MultiIndex가 자연스럽게 등장하는 상황:

groupby 집계: df.groupby(['city', 'dept']).sum() 결과는 (city, dept) MultiIndex 행
pivot_table: index=['year', 'quarter'] 조합 시 MultiIndex 행 생성
stack: DataFrame 컬럼을 행 레벨로 내릴 때 자동 생성
패널 데이터: 날짜 + 종목 같은 2차원 식별자 구조
계층 보고서: 지역 > 부서 > 제품 같은 계층적 집계 결과

데이터가 평탄한 구조면 MultiIndex 없이 일반 컬럼으로 두는 게 간단하다. 행/열 변환이 필요하거나, 계층 구조를 그대로 보존해야 할 때 MultiIndex가 빛난다.

구조 시각화

flowchart LR
    subgraph "MultiIndex 2-level 예시"
        C1["Seoul"] --> D1["dept A"]
        C1 --> D2["dept B"]
        C2["Busan"] --> D3["dept A"]
        C2 --> D4["dept B"]
    end
    D1 --> V1["sales: 100"]
    D2 --> V2["sales: 200"]
    D3 --> V3["sales: 150"]
    D4 --> V4["sales: 250"]

생성

import pandas as pd

# from_tuples
mi = pd.MultiIndex.from_tuples(
    [('Seoul', 'A'), ('Seoul', 'B'), ('Busan', 'A')],
    names=['city', 'dept']
)

# from_product (직교곱): 모든 조합 자동 생성
mi = pd.MultiIndex.from_product(
    [['Seoul', 'Busan'], ['A', 'B']],
    names=['city', 'dept']
)

# from_arrays
mi = pd.MultiIndex.from_arrays(
    [['Seoul', 'Seoul', 'Busan'], ['A', 'B', 'A']],
    names=['city', 'dept']
)

# groupby 결과: 자동으로 MultiIndex
df.groupby(['city', 'dept']).sum().index

인덱싱

city	dept	sales
Seoul	A	100
Seoul	B	200
Busan	A	150
Busan	B	250

slice / cross-section

df.xs('Seoul', level='city')          # cross-section
df.xs('A', level='dept')

# IndexSlice: 더 직관적인 다차원 슬라이스
idx = pd.IndexSlice
df.loc[idx[:, 'A'], :]                # 모든 city 의 dept='A'
df.loc[idx['Seoul':, 'A':'B'], :]     # city 범위 + dept 범위

stack / unstack 으로 변환

df.unstack('dept')                    # dept 가 컬럼 level 로
df.unstack()                          # 가장 안쪽 index level -> 컬럼
df.stack()                            # 컬럼 -> index (역변환)

상세 사용법: [[Pandas stack-unstack]]

level 조작

df.reset_index()                              # MultiIndex 해제 -> 일반 컬럼
df.reset_index(level='dept')                  # 일부만 해제
df.swaplevel('city', 'dept')                  # level 순서 바꿈
df.sort_index(level=['city', 'dept'])         # level 별 정렬
df.droplevel('dept')                          # level 제거
df.rename_axis(index=['도시', '부서'])        # level 이름 변경

groupby 와의 자연스러운 결합

# groupby 결과는 자동 MultiIndex
result = df.groupby(['city', 'dept'])['sales'].sum()
result.unstack('dept')              # 시각화에 좋은 wide format

# agg 결과도 MultiIndex
agg = df.groupby(['city', 'dept']).agg({'sales': ['sum', 'mean']})
# 컬럼이 ('sales', 'sum'), ('sales', 'mean') MultiIndex

MultiIndex 컬럼

행뿐 아니라 컬럼도 multi-level 가능.

df.pivot_table(index='city', columns=['dept', 'quarter'], values='sales')
# 컬럼이 (dept, quarter) MultiIndex

평탄화

# 컬럼 MultiIndex -> 단일 컬럼명
df.columns = ['_'.join(map(str, c)) for c in df.columns]
# ('sales', 'A') -> 'sales_A'

# reset_index 로 행 MultiIndex 해제
df_flat = df.reset_index()

실전 패턴

교차 집계 후 wide 변환

import pandas as pd

data = {
    'city': ['Seoul', 'Seoul', 'Busan', 'Busan', 'Seoul', 'Busan'],
    'dept': ['A', 'B', 'A', 'B', 'A', 'B'],
    'q': ['Q1', 'Q1', 'Q1', 'Q1', 'Q2', 'Q2'],
    'sales': [100, 200, 150, 250, 120, 180],
}
df = pd.DataFrame(data)

# groupby -> MultiIndex -> unstack 으로 wide format
pivot = (
    df.groupby(['city', 'dept', 'q'])['sales']
    .sum()
    .unstack('q')
    .fillna(0)
)
print(pivot)

특정 level 필터 후 집계

# dept='A' 인 행만 선택 후 city 별 합계
df_mi = df.groupby(['city', 'dept'])['sales'].sum()
dept_a = df_mi.xs('A', level='dept')
# 결과: city 별 A dept 합계 Series

IndexSlice 로 범위 선택

df_mi = df.groupby(['city', 'dept'])['sales'].sum()
df_mi = df_mi.sort_index()

idx = pd.IndexSlice
# Seoul 만, 모든 dept
seoul_sales = df_mi.loc[idx['Seoul', :]]

두 기간 MultiIndex 비교

# pandas 2.x 스타일: 작년 vs 올해 비교
this_year = (
    df[df['year'] == 2025]
    .groupby(['city', 'dept'])['sales']
    .sum()
)
last_year = (
    df[df['year'] == 2024]
    .groupby(['city', 'dept'])['sales']
    .sum()
)

diff = this_year.subtract(last_year, fill_value=0)
pct  = diff / last_year.replace(0, float('nan')) * 100

MultiIndex 컬럼 평탄화 후 저장

result = df.groupby(['region', 'dept']).agg({'sales': ['sum', 'mean', 'std']})
# 컬럼: ('sales', 'sum'), ('sales', 'mean'), ('sales', 'std')

result.columns = ['_'.join(c) for c in result.columns]
# 'sales_sum', 'sales_mean', 'sales_std'

result.reset_index().to_csv('output.csv', index=False)

성능

상황	권장
정렬되지 않은 MultiIndex 슬라이스	`sort_index()` 선행 필수, `PerformanceWarning` 방지
`xs()` vs `loc[idx]`	`xs()` 가독성 좋으나 `loc[]` 가 약간 빠름
`unstack()` 후 sparse한 경우	NaN 폭증 주의, `fillna()` 또는 long-format 유지
수백만 행 MultiIndex	`reset_index()` 후 일반 컬럼 처리가 간편한 경우 많음
반복 필터	`IndexSlice` 캐싱보다 `reset_index()` 후 boolean mask 가 빠를 수 있음

# PerformanceWarning 방지: 슬라이스 전 반드시 정렬
df = df.sort_index()
df.loc['Seoul':'Busan']

# 대용량: reset_index 후 boolean mask 가 더 빠를 수 있음
df_flat = df.reset_index()
df_flat[(df_flat['city'] == 'Seoul') & (df_flat['dept'] == 'A')]

함정

1. tuple vs list

df.loc[('Seoul', 'A')]      # 단일 인덱스 -> Series
df.loc[[('Seoul', 'A')]]    # 리스트 -> DataFrame 유지
df.loc['Seoul', 'A']        # 행 라벨 + 컬럼 라벨로 해석 (다른 의미!)

2. SettingWithCopyWarning / ChainedAssignmentError

[!WARNING] MultiIndex에서 체이닝 인덱싱 사고가 더 자주 발생한다. pandas 2.x 에서는 ChainedAssignmentError 로 바뀐다. .loc[idx, col] = 한 줄로 처리해야 한다.

# ❌ 체이닝 인덱싱 (pandas 2.x: ChainedAssignmentError)
df.loc['Seoul']['sales'] = 999

# ✓ 단일 loc
df.loc[('Seoul', 'A'), 'sales'] = 999

3. 정렬 안 된 MultiIndex 슬라이스

df.loc['Seoul':'Busan']    # PerformanceWarning: lexsort 안 됨
df = df.sort_index()       # 정렬 후 사용

4. level 이름 없는 MultiIndex

# names 가 None -> xs(level=0) 등 위치로 참조해야 해 불편
mi = pd.MultiIndex.from_tuples([('Seoul', 'A'), ('Busan', 'B')])
# ✓ 항상 names 지정
mi = pd.MultiIndex.from_tuples(
    [('Seoul', 'A'), ('Busan', 'B')],
    names=['city', 'dept']
)

5. groupby 후 MultiIndex 해제 필망

# groupby 결과를 일반 DataFrame 으로 쓰려면 reset_index 필요
result = df.groupby(['city', 'dept'])['sales'].sum()
result_df = result.reset_index()   # 일반 컬럼 DataFrame

[Pandas] nlargest / nsmallest / rank

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

nlargest(n, cols) : 상위 N 개 행 (sort_values + head 보다 빠름)
nsmallest(n, cols) : 하위 N 개 행
rank() : 각 원소의 순위 (1, 2, 3, …)

rank method 비교 시각화

flowchart TD
    INPUT["값: 75, 88, 92, 92, 95"] --> AVG["method='average'\n75→1, 88→2, 92→3.5, 92→3.5, 95→5"]
    INPUT --> MIN["method='min'\n75→1, 88→2, 92→3, 92→3, 95→5"]
    INPUT --> MAX["method='max'\n75→1, 88→2, 92→4, 92→4, 95→5"]
    INPUT --> DENSE["method='dense'\n75→1, 88→2, 92→3, 92→3, 95→4"]
    INPUT --> FIRST["method='first'\n75→1, 88→2, 92→3, 92→4, 95→5"]

    AVG --> SQL_RANK["SQL RANK()"]
    DENSE --> SQL_DENSE["SQL DENSE_RANK()"]
    FIRST --> SQL_ROW["SQL ROW_NUMBER()"]

nlargest / nsmallest

df.nlargest(5, 'salary')
df.nsmallest(3, 'age')
df.nlargest(5, ['salary', 'age'])   # 다중 키 (salary 우선, 동률 시 age)

	name	score
4	E	95
1	B	92
3	D	92

keep 옵션

df.nlargest(3, 'score', keep='first')   # 동률 시 먼저 등장 우선 (기본)
df.nlargest(3, 'score', keep='last')    # 나중 등장 우선
df.nlargest(3, 'score', keep='all')     # 동률 모두 포함 (3 개 초과 가능)

왜 sort + head 보다 빠른가

nlargest 는 N 크기의 힙으로 부분 정렬, O(n log k). 전체 정렬은 O(n log n).

n = 1,000,000, k = 10 일 때 차이 큼

rank

각 원소에 순위를 매긴다.

df['rank'] = df['score'].rank(ascending=False)

method 옵션 비교

method	92, 92 인 경우	다음 순위	SQL 대응
`average`	3.5, 3.5	5	-
`min`	3, 3	5	`RANK()`
`max`	4, 4	5	-
`dense`	3, 3	4	`DENSE_RANK()`
`first`	3, 4	5	`ROW_NUMBER()`

그룹별 순위 (SQL 의 ROW_NUMBER OVER PARTITION BY)

df['rank_in_dept'] = df.groupby('dept')['salary'].rank(ascending=False)

[[Pandas groupby]] + rank.

분위수

df['quartile'] = pd.qcut(df['score'], 4, labels=['Q1','Q2','Q3','Q4'])
df['percentile'] = df['score'].rank(pct=True)   # 0.0~1.0

rank(pct=True) 는 백분위 (0~1).

실전 패턴

Top-N 필터 (그룹별)

# 부서별 연봉 상위 2명
df['rank'] = df.groupby('dept')['salary'].rank(method='min', ascending=False)
top2 = df[df['rank'] <= 2]

증가율 Top-N

df['growth'] = df['revenue'].pct_change()
growth_cols = ['name', 'revenue', 'growth']
top5_growth = df.nlargest(5, 'growth')[growth_cols]

순위 변동 추적

# 이번 달 순위 - 지난 달 순위
df['rank_change'] = df['rank_prev'] - df['rank_curr']
df.nlargest(5, 'rank_change')   # 가장 많이 오른 항목

분위수 기반 세그먼트

성능

# nlargest vs sort + head
import timeit

# sort_values + head: O(n log n)
# nlargest: O(n log k), k << n 일 때 크게 유리

# 1M 행에서 Top-10 추출
# nlargest: ~0.05s
# sort_values + head: ~0.3s

# 다중 컬럼 정렬은 nlargest 에서도 내부 sort 사용 가능
df.nlargest(10, ['col_a', 'col_b'])   # col_a 우선, 동률 시 col_b

자주 만나는 함정

1. rank 의 기본 method

rank() 의 기본은 'average', 동률을 평균값으로 둔다. 정수 순위를 원하면 method='min' 또는 'dense'.

[!IMPORTANT] rank() 기본 method='average' 는 동률 시 float 값을 반환한다 (3.5 등). 정수 순위가 필요하면 method='min' (SQL RANK) 또는 method='dense' (SQL DENSE_RANK) 를 명시.

2. NaN 처리

s.rank(na_option='keep')      # NaN 은 NaN (기본)
s.rank(na_option='top')       # NaN 을 가장 높은 순위 (가장 큰 값처럼)
s.rank(na_option='bottom')    # NaN 을 가장 낮은 순위 (가장 작은 값처럼)

3. nlargest 의 다중 키

df.nlargest(3, ['a', 'b'])
# 'a' 가 더 우선, 'b' 는 동률일 때만 결정

4. ascending 방향 혼동

df['rank'] = df['score'].rank(ascending=False)
# ascending=False 면 높은 점수가 낮은 순위 번호 (1위, 2위...)
# ascending=True (기본) 면 낮은 값이 1위

[!WARNING] rank(ascending=True) 가 기본값이다. 점수가 높을수록 1위가 되게 하려면 반드시 ascending=False. 이를 빠뜨리면 순위가 반전된다.

[Pandas] Nullable Types (Int64, boolean, string[pyarrow])

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Nullable dtypes 는 NaN/None 을 타입 그대로 표현할 수 있는 pandas 의 새 타입 시스템. NumPy 기반의 int64 (NaN 미허용) 의 한계를 극복.

Int8, Int16, Int32, Int64 : nullable 정수 (대문자 I)
UInt8, …, UInt64 : unsigned
Float32, Float64 : nullable 실수
boolean : nullable bool
string : 명시적 문자열 (object 대신)

dtype 계열 시각화

flowchart TD
    A["pandas dtype 계열"] --> B["NumPy 계열 (기존)"]
    A --> C["Nullable 계열 (pandas 1.0+)"]
    A --> D["Arrow 계열 (pandas 2.0+)"]

    B --> B1["int64 / float64 / bool / object"]
    C --> C1["Int64 / boolean / string"]
    C --> C2["Float32 / Float64"]
    D --> D1["int64[pyarrow] / string[pyarrow]"]
    D --> D2["timestamp[ns][pyarrow]"]

사용 상황

상황	권장 dtype
NaN 포함 정수 컬럼	`Int64` (nullable)
DB 에서 읽어 온 bool	`boolean`
문자열 메모리 절약	`string[pyarrow]`
Arrow 파이프라인 통합	`dtype_backend='pyarrow'`
단순 수치 연산 (NaN 없음)	`int64` / `float64` (NumPy, 빠름)

왜 필요한가

NaN 이 있으면 int → float 강등 문제

import pandas as pd
import numpy as np
df = pd.DataFrame({'count': [1, 2, None, 4]})
df['count'].dtype     # float64 (NaN 때문에 int 못 함)

NumPy 의 int64 는 NaN 표현 불가 → NaN 행이 하나라도 있으면 float 로 변환.

nullable 로 해결

df['count'] = df['count'].astype('Int64')   # 대문자 I
df['count']
# 0       1
# 1       2
# 2    <NA>
# 3       4
# dtype: Int64

정수 유지 + NaN 표현.

사용

df = df.astype({
    'id': 'Int32',
    'is_active': 'boolean',
    'name': 'string',
})

# read_csv 에서 직접
df = pd.read_csv('data.csv', dtype={
    'id': 'Int32',
    'is_active': 'boolean',
})

# pyarrow backend (pandas 2.0+)
df = pd.read_csv('data.csv', dtype_backend='numpy_nullable')

pd.NA

nullable dtype 의 결측치 표현.

pd.NA
# 산술: any op with pd.NA = pd.NA
pd.NA + 1            # <NA>
pd.NA == pd.NA       # <NA> (NaN 처럼)

NaN 과 다르게 boolean context 에서 ambiguous → 명시적 비교 필요.

df['x'] == 5     # 결과에 pd.NA 가 섞일 수 있음
# 필터링은 isna() / notna() 활용
df[df['x'].notna() & (df['x'] == 5)]

string dtype

df['name'] = df['name'].astype('string')   # 명시적 string
df['name'] = df['name'].astype('string[pyarrow]')   # arrow 백킹 (더 빠름)

object vs string vs string[pyarrow]

dtype	저장	str accessor	메모리
`object`	Python str 리스트	✓	큼
`string`	pandas 내부	✓	중간
`string[pyarrow]`	Arrow 백킹	✓	작음

문자열 컬럼은 가능하면 string[pyarrow] 권장.

pyarrow backend (pandas 2.0+)

pd.options.mode.dtype_backend = 'pyarrow'
df = pd.read_csv('data.csv', dtype_backend='pyarrow')
df.dtypes
# id            int64[pyarrow]
# name          string[pyarrow]
# created_at    timestamp[ns][pyarrow]

Arrow 백킹의 장점:

메모리 효율
빠른 IO (Parquet 와 호환)
정밀한 dtype (timezone, decimal 등)

[[Pandas pyarrow backend]] 참고.

타입별 메모리 비교

import pandas as pd

s_obj = pd.Series(['hello'] * 10_000, dtype='object')
s_str = pd.Series(['hello'] * 10_000, dtype='string')
s_arrow = pd.Series(['hello'] * 10_000, dtype='string[pyarrow]')

# deep=True 로 실제 Python 객체 포함 측정
print(s_obj.memory_usage(deep=True))    # ~590000 bytes
print(s_str.memory_usage(deep=True))    # ~590000 bytes
print(s_arrow.memory_usage(deep=True))  # ~50000 bytes (10x 이상 절약)

pandas 2.x 전환 패턴

# 전체 DataFrame 을 nullable 로 일괄 전환
df = df.convert_dtypes()
# int64 -> Int64, object -> string, float64 -> Float64 (자동 추론)

# pyarrow 전환
df = df.convert_dtypes(dtype_backend='pyarrow')
# int64 -> int64[pyarrow], string -> large_string[pyarrow]

특정 컬럼만 선택적 전환

int_cols = df.select_dtypes('int').columns
df[int_cols] = df[int_cols].astype('Int64')

str_cols = df.select_dtypes('object').columns
df[str_cols] = df[str_cols].astype('string')

타입 간 연산 동작

s_int = pd.array([1, 2, pd.NA, 4], dtype='Int64')
s_float = pd.array([1.5, 2.5, pd.NA, 4.5], dtype='Float64')

# 산술: NA 전파
s_int + 10           # [11, 12, <NA>, 14]
s_int + s_float      # [2.5, 4.5, <NA>, 8.5]

# 비교
s_int > 2            # [False, False, <NA>, True] (boolean dtype 반환)

# 집계: NA 자동 무시
s_int.sum()          # 7  (1+2+4)
s_int.mean()         # 2.333...  (NA 제외)

NA 처리 흐름

flowchart LR
    A["NA 포함 컬럼"] --> B{"어떤 연산?"}
    B -->|"필터링"| C["isna() / notna()"]
    B -->|"집계"| D["sum() / mean() NA 자동 무시"]
    B -->|"boolean context"| E["fillna(False) 명시"]
    B -->|"numpy 함수"| F["fillna 후 변환"]

    C --> G["df[df['x'].notna()]"]
    D --> H["skipna=False 로 NA 포함 집계 가능"]
    E --> I["mask.fillna(False).any()"]
    F --> J["np.where 에는 fillna 선행"]

자주 만나는 함정

1. Int64 (NumPy) vs Int64 (nullable)

df['x'].astype('int64')        # NumPy, NaN 미허용
df['x'].astype('Int64')        # nullable, NaN 허용

대소문자가 의미를 바꾼다.

2. boolean 의 truthiness

mask = df['active']            # boolean dtype, pd.NA 가능
if mask.any():                  # ambiguous (NA 때문에 TypeError)
mask.fillna(False).any()        # ✓ 명시적

3. 일부 NumPy 함수 미지원

일부 numpy 함수는 pandas nullable 을 직접 처리 못 함. 변환이 필요.

np.where(df['flag'], 'A', 'B')  # boolean dtype 에서 동작 안 할 수 있음
np.where(df['flag'].fillna(False), 'A', 'B')   # 회피

4. arrow string 의 일부 regex

대부분 동작하지만 일부 특수 regex 옵션은 fallback 가능. 표준 str 메서드만 쓰는 것이 안전.

5. to_parquet / to_csv 호환성

# nullable dtype 은 parquet 로 저장할 때 pyarrow 가 알아서 처리
df.to_parquet('out.parquet')   # ✓ 정상 동작

# CSV 는 pd.NA 가 빈 문자열로 출력됨
df.to_csv('out.csv')           # <NA> -> 빈 문자열

6. groupby + nullable key

# pandas 2.x 에서 groupby key 가 nullable 이면 NA 그룹 처리
df.groupby('id_nullable', dropna=False).sum()
# dropna=False 로 NA 그룹 포함 (기본은 NA 그룹 제외)

7. concat 후 dtype 변화

df1 = pd.DataFrame({'x': pd.array([1, 2], dtype='Int64')})
df2 = pd.DataFrame({'x': [3, 4]})          # int64 (NumPy)
pd.concat([df1, df2])['x'].dtype            # float64 (강등 가능)

# 안전하게
df2['x'] = df2['x'].astype('Int64')
pd.concat([df1, df2])['x'].dtype            # Int64 유지

pandas 3.0 의 미래

pandas 3.0 부터 Arrow 가 기본 백킹이 될 예정. 지금부터 nullable dtype 에 익숙해지면 마이그레이션이 쉽다.

[Pandas] pivot_table

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

DataFrame.pivot_table(...) 는 [[Pandas pivot]] 의 확장. 집계 함수를 동반 해 중복 (index, columns) 도 처리. Excel 의 피벗 테이블과 가장 가까운 기능.

pivot_table 처리 흐름

flowchart LR
    A["원본 DataFrame\n(행이 많고 중복 존재)"] --> B["index 로 행 분류"]
    B --> C["columns 로 열 분류"]
    C --> D["aggfunc 로 집계"]
    D --> E["2D 요약 테이블"]
    D --> F["margins=True 로 합계 행/열 추가"]

사용 상황

상황	패턴
월별/카테고리별 매출 요약	`index='month', columns='category'`
두 차원 교차 분석	`index=A, columns=B, aggfunc='count'`
Excel 피벗과 동일한 결과	`margins=True`
코호트 분석	`index='cohort', columns='period'`
결측 조합을 0 으로 채우기	`fill_value=0`

기본

df.pivot_table(
    index='date',
    columns='product',
    values='sales',
    aggfunc='sum',
)

date	A	B
2024-01	150 (= 100+50)	200
2024-02	150	250

여러 aggfunc

df.pivot_table(
    index='date',
    columns='product',
    values='sales',
    aggfunc=['sum', 'mean', 'count'],
)

결과는 최상위 컬럼이 함수 이름인 MultiIndex.

margins (총계)

df.pivot_table(
    index='date',
    columns='product',
    values='sales',
    aggfunc='sum',
    margins=True,
    margins_name='Total',
)

date	A	B	Total
2024-01	150	200	350
2024-02	150	250	400
Total	300	450	750

Excel 의 총계 행/열과 동일.

여러 index / values

df.pivot_table(
    index=['region', 'date'],
    columns='product',
    values=['sales', 'qty'],
    aggfunc='sum',
)

MultiIndex 행 + MultiIndex 컬럼.

fill_value

df.pivot_table(..., fill_value=0)   # NaN 을 0 으로

groupby 와의 관계

pivot_table 은 사실 groupby + unstack 의 단축형.

# 둘은 같음
df.pivot_table(index='date', columns='product', values='sales', aggfunc='sum')
df.groupby(['date', 'product'])['sales'].sum().unstack('product')

crosstab 과의 관계

[[Pandas crosstab]] 은 pivot_table 의 빈도 특화 버전.

# 두 컬럼의 빈도 교차표
pd.crosstab(df['region'], df['product'])
# pivot_table 로 동일하게:
df.pivot_table(index='region', columns='product', aggfunc='size', fill_value=0)

실전 패턴

월별/카테고리별 매출 보고서

report = df.pivot_table(
    index='month',
    columns='category',
    values='revenue',
    aggfunc='sum',
    margins=True,
    fill_value=0,
)
report.to_excel('monthly_report.xlsx')

코호트 분석

df['cohort'] = df['signup_month']
df['period'] = (df['active_month'] - df['cohort']).dt.days // 30
cohort_table = df.pivot_table(
    index='cohort',
    columns='period',
    values='user_id',
    aggfunc='nunique',
)

여러 값 동시 + 누락 컬럼 채우기

pivot = df.pivot_table(
    index='week',
    columns='channel',
    values=['revenue', 'orders'],
    aggfunc={'revenue': 'sum', 'orders': 'count'},
    fill_value=0,
    margins=True,
)

결과 컬럼 평탄화

pivot = df.pivot_table(
    index='date',
    columns='product',
    values='sales',
    aggfunc=['sum', 'mean'],
)
# MultiIndex 컬럼 평탄화
pivot.columns = ['_'.join(c).strip() for c in pivot.columns]
# ['sum_A', 'sum_B', 'mean_A', 'mean_B']

pandas 2.x: 정렬 + reset

result = (
    df.pivot_table(
        index='date',
        columns='region',
        values='revenue',
        aggfunc='sum',
        fill_value=0,
    )
    .sort_index()
    .reset_index()
)

함정

1. 기본 aggfunc 가 mean

df.pivot_table(index='date', columns='product', values='sales')
# 명시 안 하면 'mean'

매출 같은 경우 ‘sum’ 을 명시하자.

2. observed (categorical)

df.pivot_table(index='cat_col', ..., observed=False)
# Categorical index 의 모든 카테고리 포함 (등장 안 한 것도)

pandas 2.x 에서는 observed=False 가 deprecated, 명시 권장.

3. dropna

df.pivot_table(index='date', columns='product', values='sales', dropna=False)
# NaN 행을 보존 (기본은 드롭)

4. values 생략 시 전체 컬럼

df.pivot_table(index='date', columns='product', aggfunc='sum')
# values 생략 시 수치 컬럼 전부 집계 → 과도한 MultiIndex 컬럼

항상 values 를 명시하는 것이 안전.

5. sort=False 와 컬럼 순서

df.pivot_table(index='date', columns='product', values='sales',
               aggfunc='sum', sort=False)
# sort=False: 원본 등장 순서 유지 (기본은 정렬)

6. margins + 여러 aggfunc

df.pivot_table(
    ...,
    aggfunc=['sum', 'mean'],
    margins=True,
)
# margins 의 'All' 행/열은 sum 에만 적용됨
# mean 의 'All' 은 예상과 다를 수 있음 (행 평균의 평균)

[Pandas] read_parquet / to_parquet

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Parquet 은 column-oriented binary 포맷. CSV 대비 수십 배 빠르고 작다. dtype 보존, 압축, 부분 컬럼 읽기 지원. 데이터 분석의 사실상 표준.

df.to_parquet('out.parquet')
df = pd.read_parquet('out.parquet')

CSV vs Parquet 저장 구조

flowchart LR
    subgraph "CSV (행 지향)"
        R1["row1: id=1, name=A, val=10"]
        R2["row2: id=2, name=B, val=20"]
        R3["row3: id=3, name=C, val=30"]
    end

    subgraph "Parquet (열 지향)"
        C1["id col: 1, 2, 3"]
        C2["name col: A, B, C"]
        C3["val col: 10, 20, 30"]
    end

    CSV --> P1["컬럼 선택 읽기 시 전체 파싱 필요"]
    Parquet --> P2["필요 컬럼만 읽기 가능"]

사용 상황

상황	CSV	Parquet
사람이 직접 열어 봐야 함	✓	✗
반복 분석 / 대용량	✗	✓
dtype 그대로 유지	✗	✓
컬럼 일부만 읽기	✗	✓
빠른 IO	느림	빠름
스트리밍 / Arrow 파이프라인	✗	✓

왜 CSV 가 아닌가

항목	CSV	Parquet
크기	100%	10-30%
읽기 속도	100%	5-20x faster
dtype 보존	✗ (재추론)	✓
컬럼 선택 읽기	✗ (전체 파싱)	✓
압축	gz 별도	내장 (snappy/gzip/zstd)
사람이 읽기	✓	✗ (binary)
부분 schema	✗	✓

대규모 데이터 / 반복 분석에는 Parquet 이 명백한 정답.

의존성

pip install pyarrow      # 가장 흔함 (Apache Arrow)
pip install fastparquet  # 대안

df.to_parquet('out.parquet', engine='pyarrow')   # 기본
df.to_parquet('out.parquet', engine='fastparquet')

기본 사용

df.to_parquet('data.parquet')
df = pd.read_parquet('data.parquet')

# 일부 컬럼만
df = pd.read_parquet('data.parquet', columns=['a', 'b'])

압축 옵션

df.to_parquet('out.parquet', compression='snappy')   # 빠름, 기본
df.to_parquet('out.parquet', compression='zstd')      # 가장 작음
df.to_parquet('out.parquet', compression='gzip')      # 호환성
df.to_parquet('out.parquet', compression=None)

zstd 가 압축률/속도 균형 가장 좋음.

partitioned dataset

df.to_parquet('events/', partition_cols=['year', 'month'])
# events/year=2024/month=01/part-0.parquet
# events/year=2024/month=02/part-0.parquet

읽을 때 자동으로 필터링.

import pandas as pd
df = pd.read_parquet('events/', filters=[
    ('year', '==', 2024),
    ('month', '>=', 6),
])

수십 GB 데이터에서도 메모리 효율적.

dtype 보존

df = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['A', 'B', 'C'],
    'ts': pd.to_datetime(['2024-01-01', '2024-02-01', '2024-03-01']),
    'flag': [True, False, True],
})
df.to_parquet('out.parquet')

df2 = pd.read_parquet('out.parquet')
df2.dtypes
# id        int64
# name      object
# ts        datetime64[ns]
# flag      bool

CSV 는 모든 dtype 정보가 사라진다.

pyarrow backend

df = pd.read_parquet('out.parquet', dtype_backend='pyarrow')
# Arrow 기반 dtype (string[pyarrow], Int64 등)
# 메모리 효율 + 빠름

[[Pandas pyarrow backend]] 참고.

대용량 파일 전략

컬럼 선택 읽기

# 100 컬럼 중 3 컬럼만 읽어도 그 3 컬럼 비용만
df = pd.read_parquet('big.parquet', columns=['user_id', 'event', 'ts'])

CSV 는 전체를 파싱해야 함.

row group 필터 (pyarrow)

import pyarrow.parquet as pq

# 스캔 없이 조건 필터 (row group 수준)
table = pq.read_table(
    'events.parquet',
    filters=[('date', '>=', '2024-01-01'), ('date', '<', '2024-02-01')],
)
df = table.to_pandas()

반복 청크 처리

import pyarrow.parquet as pq

pf = pq.ParquetFile('large.parquet')
for batch in pf.iter_batches(batch_size=100_000):
    chunk = batch.to_pandas()
    # 청크 단위 처리

pandas 2.x 권장 패턴

# pyarrow backend + nullable dtype 통합
df = pd.read_parquet('data.parquet', dtype_backend='pyarrow')
# 모든 컬럼이 arrow dtype
# string[pyarrow], int64[pyarrow], bool[pyarrow] 등

# 처리 후 저장
df.to_parquet('result.parquet', compression='zstd', index=False)

S3 / 클라우드 활용

import s3fs

# S3 에서 읽기
df = pd.read_parquet('s3://bucket/prefix/data.parquet')

# S3 에 쓰기
df.to_parquet('s3://bucket/prefix/output.parquet')

# partitioned S3
df.to_parquet('s3://bucket/events/', partition_cols=['year', 'month'])

s3fs 패키지만 설치하면 pandas 가 자동 감지.

자주 만나는 함정

1. 사람이 못 읽음

binary 포맷이라 cat data.parquet 으로 못 본다. CSV 로 변환:

pd.read_parquet('data.parquet').to_csv('data.csv', index=False)

2. 일부 dtype 미지원

df.to_parquet('out.parquet')
# category, period, sparse 등은 일부 변환 또는 미지원

engine='pyarrow' 가 가장 호환성 좋음.

3. partitioned 컬럼이 string 으로 복원

df.to_parquet('events/', partition_cols=['year'])
# 읽을 때 'year' 는 string dtype 으로 복원 (path 파싱이므로)
pd.read_parquet('events/').dtypes
# year: object (string)

# 수동으로 복원
df['year'] = df['year'].astype('int64')

4. index 포함 여부

df.to_parquet('out.parquet', index=True)   # 기본: index 포함
df.to_parquet('out.parquet', index=False)  # index 제외 (불필요한 컬럼 회피)

RangeIndex 는 어차피 재생성 가능하므로 index=False 권장.

5. row group size 와 필터 효율

# 기본 row group 크기 (pyarrow: 약 128MB)
# 필터링 효율은 row group 이 작을수록 좋음

import pyarrow as pa
import pyarrow.parquet as pq

table = pa.Table.from_pandas(df)
pq.write_table(table, 'out.parquet', row_group_size=50_000)

6. 스키마 불일치

# 여러 parquet 파일을 합칠 때 스키마가 달라 오류 가능
pd.read_parquet('dir/')  # schema 불일치 시 ArrowInvalid

# 강제 합치기
import pyarrow.dataset as ds
dataset = ds.dataset('dir/', format='parquet')
df = dataset.to_table(schema=...).to_pandas()

[Pandas] read_sql / to_sql

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

pd.read_sql(query, con) : SQL 결과 -> DataFrame
DataFrame.to_sql(name, con) : DataFrame -> DB 테이블

SQLAlchemy 의 connection / engine 객체를 사용. 직접 sqlite3, psycopg2 의 Connection 도 가능 (제한적).

사용 상황

분석 환경: DB 쿼리 결과를 바로 DataFrame 으로 받아 pandas 분석 시작
ETL 파이프라인: 가공된 DataFrame 을 DB 에 to_sql 로 적재
대용량 처리: chunksize 옵션으로 메모리 부담 없이 스트리밍 처리
데이터 이관: 테이블 복사, 백업, 변환 후 저장

pd.read_csv -> to_sql 조합으로 CSV를 DB에 올리거나, 반대로 DB 결과를 CSV로 내려받을 때도 자주 쓰인다.

DB I/O 흐름 시각화

flowchart LR
    DB["Database"] -->|"pd.read_sql()"| DF["DataFrame"]
    DF -->|"df.to_sql()"| DB

    subgraph "read_sql 흐름"
        Q["SQL Query"] --> E["SQLAlchemy Engine"]
        E --> DF
    end

    subgraph "to_sql 옵션"
        DF --> OPT["if_exists: replace / append / fail"]
        OPT --> DB
    end

의존성

pip install sqlalchemy psycopg2-binary  # PostgreSQL
pip install sqlalchemy pymysql           # MySQL
pip install sqlalchemy                   # SQLite (내장 sqlite3)

기본 사용

from sqlalchemy import create_engine
import pandas as pd

engine = create_engine('postgresql://user:pwd@host:5432/db')
df = pd.read_sql('SELECT * FROM users WHERE active = true', engine)
df.to_sql('users_backup', engine, if_exists='replace', index=False)

read_sql 옵션

옵션	의미
`sql`	쿼리 문자열 또는 SQLAlchemy Selectable
`con`	engine / connection
`params`	parameterized query 값
`parse_dates`	날짜 컬럼 파싱
`chunksize`	청크 단위 (generator)
`dtype_backend`	`'numpy_nullable'` / `'pyarrow'`

parameterized query (SQL injection 방지)

df = pd.read_sql(
    'SELECT * FROM events WHERE user_id = %(uid)s AND date > %(d)s',
    engine,
    params={'uid': 42, 'd': '2024-01-01'},
)

[!WARNING] f-string 또는 문자열 포맷으로 직접 값을 주입하면 SQL injection 위험이 있다. 반드시 params 를 사용해야 한다.

to_sql 옵션

옵션	의미
`if_exists`	`'fail'` (기본) / `'replace'` / `'append'`
`index`	DataFrame index 도 저장? (보통 `False`)
`dtype`	SQLAlchemy 타입 명시
`chunksize`	청크 단위 INSERT
`method`	`'multi'` (한 INSERT 에 여러 row), psycopg2 의 `psql_insert_copy`

빠른 대량 삽입

df.to_sql('events', engine, if_exists='append', index=False,
    chunksize=10000, method='multi')

PostgreSQL 은 COPY 가 가장 빠르다.

import csv
from io import StringIO

def psql_insert_copy(table, conn, keys, data_iter):
    raw = conn.connection
    with raw.cursor() as cur:
        buf = StringIO()
        writer = csv.writer(buf)
        writer.writerows(data_iter)
        buf.seek(0)
        cur.copy_expert(
            f'COPY {table.name} ({", ".join(keys)}) FROM STDIN WITH CSV',
            buf
        )

df.to_sql('events', engine, if_exists='append',
    index=False, method=psql_insert_copy)

청크로 대용량 처리

total = 0
for chunk in pd.read_sql('SELECT * FROM huge_table', engine, chunksize=50_000):
    total += chunk['amount'].sum()

수백만 행도 메모리 부담 없이.

SQLAlchemy 2.0+ 의 변화

# pandas 2.0+ 와 SA 2.0+
from sqlalchemy import text
with engine.connect() as conn:
    df = pd.read_sql(text('SELECT * FROM t'), conn)

문자열 대신 text(...) 권장.

실전 패턴

조건부 적재 (upsert 대체)

import pandas as pd
from sqlalchemy import create_engine

engine = create_engine('sqlite:///example.db')
df_new = pd.DataFrame({'id': [1, 2, 3], 'value': [10, 20, 30]})

# 기존 테이블 삭제 후 재적재 (소규모)
df_new.to_sql('my_table', engine, if_exists='replace', index=False)

# 증분 추가 (대규모)
df_new.to_sql('my_table', engine, if_exists='append', index=False)

dtype 명시로 안전한 스키마 보장

from sqlalchemy import types as sa_types

dtype_map = {
    'user_id': sa_types.Integer(),
    'created_at': sa_types.DateTime(),
    'amount': sa_types.Numeric(10, 2),
    'name': sa_types.String(255),
}

df.to_sql('events', engine, if_exists='replace',
    index=False, dtype=dtype_map)

청크 + 집계 패턴

from sqlalchemy import create_engine, text
import pandas as pd

engine = create_engine('postgresql://user:pwd@host:5432/db')

results = []
query = text('SELECT date, region, amount FROM sales WHERE year = :y')

with engine.connect() as conn:
    for chunk in pd.read_sql(query, conn, chunksize=100_000,
                             params={'y': 2025}):
        agg = chunk.groupby(['date', 'region'])['amount'].sum()
        results.append(agg)

final = pd.concat(results).groupby(level=[0, 1]).sum()

read_sql + parse_dates

df = pd.read_sql(
    'SELECT id, created_at, amount FROM orders',
    engine,
    parse_dates=['created_at'],
)
# created_at 이 datetime64 로 자동 변환
df['month'] = df['created_at'].dt.to_period('M')

pyarrow backend 로 성능 향상

# pandas 2.x: pyarrow backend 사용
df = pd.read_sql(
    'SELECT * FROM large_table',
    engine,
    dtype_backend='pyarrow',
)
# 메모리 효율적, nullable 타입 지원

성능 비교

방법	속도	비고
`to_sql` 기본	느림	row-by-row INSERT
`to_sql(method='multi')`	보통	한 번에 여러 row INSERT
`to_sql(chunksize=N, method='multi')`	빠름	청크 단위 multi-row INSERT
PostgreSQL `COPY` (psql_insert_copy)	매우 빠름	10-100x 빠름
`read_sql(chunksize=N)`	메모리 효율	generator, 합계/필터 스트리밍

# 속도 비교 (예시)
# 1M 행 기준:
# 기본 to_sql: ~60초
# method='multi' chunksize=10000: ~10초
# COPY: ~2초

함정

1. SQL injection

# ❌ 위험
df = pd.read_sql(f"SELECT * FROM t WHERE id = {user_input}", engine)
# ✓ 안전
df = pd.read_sql(
    "SELECT * FROM t WHERE id = %(id)s",
    engine,
    params={'id': user_input}
)

2. to_sql 의 속도

기본 to_sql 은 매 row INSERT, 매우 느림. chunksize + method='multi' 또는 native bulk loader 필수.

3. dtype mapping

int64 (pandas) -> BIGINT (SQL)
object (str) -> TEXT
pandas datetime -> TIMESTAMP
명시적 dtype={'col': sa.types.Integer()} 권장

4. timezone 처리

# DB 의 TIMESTAMP WITH TIMEZONE 가 naive 로 들어올 수 있음
df['ts'] = df['ts'].dt.tz_localize('UTC').dt.tz_convert('Asia/Seoul')

5. SQLAlchemy 2.x 호환성

[!IMPORTANT] SQLAlchemy 2.x 에서 engine.execute() 가 제거됐다. pandas 2.x 와 SA 2.x 사용 시 반드시 with engine.connect() as conn: 패턴으로 쿼리를 전달해야 한다.

# ❌ SA 1.x 스타일 (deprecated)
df = pd.read_sql('SELECT ...', engine)

# ✓ SA 2.x 스타일
from sqlalchemy import text
with engine.connect() as conn:
    df = pd.read_sql(text('SELECT ...'), conn)

[Pandas] SettingWithCopyWarning

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

SettingWithCopyWarning 은 pandas 가 가장 자주 던지는 경고. chained indexing 으로 view 인지 copy 인지 모호한 상태에 값을 할당 할 때 발생.

sub = df[df['age'] > 30]
sub['new'] = 1                    # ⚠️ SettingWithCopyWarning
# sub 가 view 인지 copy 인지 pandas 가 모름
# 원본 df 가 영향받을 수도, 안 받을 수도

사용 상황

다음 상황에서 가장 자주 발생한다.

상황	예시 패턴	발생 이유
필터링 후 컬럼 추가	`df[mask]['col'] = v`	chained indexing
슬라이스 후 수정	`df[5:10]['x'] = 1`	slice 가 view 일 수 있음
groupby 결과 수정	`get_group(...)` 후 할당	view/copy 불확실
함수 인자 df 수정	받은 df 에 직접 컬럼 추가	호출자 df 변경 여부 불확실
함수형 체이닝 후 수정	`.sort_values()[...] = v`	체이닝 결과가 copy

원인: view vs copy 흐름

flowchart TD
    A["df[mask] 실행"] --> B{"내부 메모리 구조"}
    B -->|"연속 블록"| C["view 반환"]
    B -->|"불연속 또는 복합 dtype"| D["copy 반환"]
    C --> E["원본 df 도 수정됨"]
    D --> F["원본 df 는 변경 없음"]
    E --> WARN["결과 비결정적, 경고 발생"]
    F --> WARN

pandas 는 어떤 경우에 view 가, 어떤 경우에 copy 가 반환될지 버전마다, dtype 마다, 메모리 레이아웃마다 다르다. 사용자는 예측할 수 없다.

왜 위험한가

sub 가 copy 면: sub['new'] = 1 은 sub 만 변경, 원본 df 는 안 바뀜
sub 가 view 면: 원본 df 도 함께 변경됨 (의도일 수도, 아닐 수도)

두 경우 모두 조용히 지나가기 때문에 버그를 늦게 발견하는 경우가 많다.

4 가지 해결 패턴

1. `.loc[]` 한 줄에 통합 (가장 권장)

# ❌ chained indexing: 두 번의 indexing
df[df['age'] > 30]['salary'] = 0

# ✓ loc 로 한 번에: 행 + 열 동시 지정
df.loc[df['age'] > 30, 'salary'] = 0

행 / 열을 한 번의 indexer 로 처리. [[Pandas .loc / .iloc]] 참고.

2. 명시적 `.copy()`

sub = df[df['age'] > 30].copy()   # 명시적 copy
sub['new'] = 1                     # sub 만 변경, 원본 df 불변

원본 보존 의도가 명확. 단, 대용량 df 에서 메모리 복사 비용 발생.

3. `.assign()` 으로 method chaining

# 새 컬럼 추가 / 기존 컬럼 변환
df = df.assign(
    salary=lambda d: d['salary'].where(d['age'] > 30, 0),
    is_senior=lambda d: d['age'] > 30,
)

원본 df 를 직접 변경하지 않고 새 df 를 반환한다. [[Pandas pipe / method chaining]] 참고.

4. `np.where` / `np.select` 벡터화

import numpy as np

# 조건부 컬럼 생성: apply 보다 훨씬 빠름
df['category'] = np.where(df['age'] > 30, 'senior', 'junior')

# 다중 분기
conditions = [df['age'] < 20, df['age'] < 60, df['age'] >= 60]
choices    = ['youth', 'adult', 'senior']
df['age_group'] = np.select(conditions, choices, default='unknown')

흔한 함정 패턴

chained indexing

df[df['age'] > 30]['salary'] = 0
# 내부 동작: df.__getitem__(mask).__setitem__('salary', 0)
# 첫 번째 __getitem__ 결과가 view/copy 불확실

slice 후 수정

sub = df[5:10]      # slice 는 view (대부분의 경우)
sub['x'] = 1         # 원본 df 의 5~10 행도 영향받을 수 있음

loc + chained

df.loc[df['age'] > 30]['salary'] = 0   # ❌ 여전히 chained
df.loc[df['age'] > 30, 'salary'] = 0   # ✓ 한 번에

.loc 를 썼더라도 두 번의 indexing 이면 같은 문제가 발생한다.

view vs copy 판별 (비공식)

pandas 내부 동작이 복잡하고 버전마다 다르다. 확신할 수 없으면 항상 .copy() 또는 한 줄 .loc[행, 열] 을 쓴다.

df._is_view       # 비공식 속성, 의존하지 마라
df._is_copy       # 동일

pandas 2.x Copy-on-Write (CoW)

pandas 2.0 부터 CoW 가 opt-in 으로 도입됐고, pandas 3.0 부터 기본 활성화.

# pandas 2.x: 수동 활성화
import pandas as pd
pd.options.mode.copy_on_write = True

# CoW 동작 원리: lazy copy
sub = df[df['age'] > 30]    # 아직 실제 복사 없음
sub['new'] = 1               # write 시점에 물리적 복사 수행
# 원본 df 는 항상 불변

CoW 활성화 환경에서의 동작 변화:

코드 패턴	pandas 2.x 이전	CoW 활성화 후
`df[mask]['col'] = v`	SettingWithCopyWarning	ChainedAssignmentError
`df.loc[mask, 'col'] = v`	정상	정상
`sub = df[mask].copy()` 후 수정	정상	정상

# pandas 3.0+ (CoW 기본)
df[df['age'] > 30]['salary'] = 0          # ChainedAssignmentError
df.loc[df['age'] > 30, 'salary'] = 0       # ✓ 정상 동작

[!IMPORTANT] pandas 3.0 에서는 SettingWithCopyWarning 이 에러로 격상된다. 지금부터 .loc[행, 열] 패턴으로 작성하는 습관을 들여야 한다.

성능

방법	메모리 비용	속도	비고
`.loc[행, 열] = v`	없음	빠름	인플레이스 수정
`.copy()` 후 수정	df 전체 복사	중간	명확한 의도 표현
`.assign()`	새 df 생성	중간	함수형 style
`np.where` / `np.select`	없음	빠름	벡터 연산

대용량 DataFrame 에서 .copy() 는 메모리 / 시간 비용이 크다. 원본 수정이 목적이면 .loc[행, 열] = v 가 최선.

import pandas as pd
import numpy as np

# 1,000,000 행 DataFrame 테스트 (예시)
df = pd.DataFrame({'age': np.random.randint(20, 60, 1_000_000),
                   'salary': np.random.randint(3000, 8000, 1_000_000)})

# 빠름: 메모리 추가 없음
df.loc[df['age'] > 30, 'bonus'] = 500

# 느림: 전체 복사
sub = df[df['age'] > 30].copy()
sub['bonus'] = 500

자주 묻는 질문

Q. 경고를 무시해도 되나?

A. 무시하지 마라. 경고는 의도와 다른 결과를 낳을 수 있다는 신호. pandas 3.0 에서는 에러로 바뀐다.

Q. `inplace=True` 가 해결인가?

A. 별 도움 안 됨. inplace 자체도 deprecation 방향. 명시적 할당을 권장.

Q. `.copy()` 가 항상 안전한가?

A. ✓. 단, 큰 DataFrame 에서 메모리 / 시간 비용이 있다. 원본 수정이 목적이라면 .loc[] 가 낫다.

Q. pandas 2.x 에서 CoW 를 켜면 경고가 사라지나?

A. 경고가 ChainedAssignmentError 에러로 격상된다. 체이닝 자체를 원천 차단한다.

Q. 경고 없이 코드가 돌아가는데 결과가 이상하다면?

A. 체이닝으로 copy 에 썼기 때문에 원본이 변경되지 않은 것. .loc[행, 열] = v 로 고쳐야 한다.

함정

[!WARNING] 아래 함정들은 데이터가 기대와 다르게 수정(또는 미수정)되어 조용한 버그로 이어질 수 있다.

1. groupby 결과 수정

# ❌
g = df.groupby('city').get_group('Seoul')
g['new'] = 1

# ✓
g = df.groupby('city').get_group('Seoul').copy()
g['new'] = 1

2. boolean mask + 컬럼 추가

# ❌
sub = df[df['age'] > 30]
sub.loc[:, 'flag'] = True    # 여전히 경고

# ✓
sub = df[df['age'] > 30].copy()
sub['flag'] = True

3. 경고 출처가 다른 줄

경고 메시지의 라인 정보가 실제 원인 라인과 다를 수 있다. 한 단계 앞에서 발생한 chained indexing 이 진짜 원인인 경우가 많다.

4. 함수 인자로 받은 df

# ❌ 호출자의 df 도 변경될 수 있음
def add_flag(df):
    df['flag'] = True   # ⚠️ 체이닝 아니어도 경고

# ✓ 명시적 copy 후 반환
def add_flag(df):
    df = df.copy()
    df['flag'] = True
    return df

5. 경고 억제 (권장하지 않음)

# 경고를 억제하는 것은 문제를 숨기는 것
import warnings
pd.options.mode.chained_assignment = None   # 비권장

[Pandas] shift / diff / pct_change

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

shift(n) : 값을 n 칸 밀기 (lag/lead 생성)
diff(n) : n 칸 차이 (= s - s.shift(n))
pct_change(n) : 변화율 (= s.diff(n) / s.shift(n))

시계열 분석의 기본 도구. 전일 대비 / 전월 대비 / lag feature 생성 등에 광범위하게 쓰인다.

사용 상황

상황	방법	예시
전일 대비 변화량 계산	`diff(1)`	매일 판매량 변화
전월 대비 변화율 계산	`pct_change(1)`	월 매출 증감률
주간 동기 비교	`shift(7)` / `diff(7)`	7일 전 대비
ML lag feature 생성	`shift(1)`, `shift(7)`	과거 값을 feature 로
미래 타깃 생성	`shift(-1)`	내일 close 를 타깃으로
그룹별 이전 값 비교	`groupby().shift(1)`	user 별 이전 주문

shift 시각화

flowchart LR
    subgraph "원본 Series"
        A0["0: 10"]
        A1["1: 12"]
        A2["2: 15"]
        A3["3: 14"]
    end
    subgraph "shift(1) - lag"
        B0["0: NaN"]
        B1["1: 10"]
        B2["2: 12"]
        B3["3: 15"]
    end
    subgraph "shift(-1) - lead"
        C0["0: 12"]
        C1["1: 15"]
        C2["2: 14"]
        C3["3: NaN"]
    end
    A0 -.-> B1
    A1 -.-> B2
    A2 -.-> B3
    A1 -.-> C0
    A2 -.-> C1
    A3 -.-> C2

shift(1) 은 값을 한 칸 아래로 (과거 값 참조). shift(-1) 은 한 칸 위로 (미래 값 참조).

shift

s.shift(1)                  # 한 칸 아래로 (lag, NaN 채움)
s.shift(-1)                 # 한 칸 위로 (lead)
s.shift(7)                  # 일주일 전 값
s.shift(1, fill_value=0)    # NaN 대신 0

index	s	shift(1)	shift(-1)
0	10	NaN	12
1	12	10	15
2	15	12	14
3	14	15	18
4	18	14	NaN

diff

s.diff()        # = s - s.shift(1), 1차 차분
s.diff(2)       # 2 step 차분
s.diff(-1)      # 다음 값 - 현재 값 (역방향)

2차 차분

s.diff().diff()     # 2차 차분: 변화량의 변화량
# 시계열 stationarity 확보에 사용

pct_change (변화율)

s.pct_change()        # 직전 대비 비율 변화
s.pct_change(7)       # 7 step 변화율 (주간 단위 등)
s.pct_change(fill_method=None)    # NaN 을 채우지 않음 (pandas 2.2+)

20% → 20% → 25% 증가.

fill_method 주의 (pandas 2.2+)

# pandas 2.2 부터 fill_method 기본값 변경
# NaN 을 앞 값으로 채워 계산하는 동작이 deprecated
s.pct_change()                      # FutureWarning (pandas 2.2+)
s.pct_change(fill_method=None)      # 명시적, 경고 없음

time-based shift

DatetimeIndex 일 때 freq 지정 가능.

import pandas as pd

ts = pd.Series(
    [100, 110, 120],
    index=pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-07'])
)

ts.shift(1, freq='D')      # 1 일 이동 (날짜 이동, 값은 그대로)
ts.shift(1, freq='W')      # 1 주 이동
ts.shift(-1, freq='ME')    # 한 달 뒤로

freq 지정 시 값이 이동하는 게 아니라 인덱스(날짜) 가 이동한다.

자주 쓰는 패턴

전월 대비 매출

df['mom'] = df['monthly_sales'].pct_change()
df['yoy'] = df['monthly_sales'].pct_change(12)   # 전년 동월 대비

lag features (ML)

for lag in [1, 7, 14, 30]:
    df[f'sales_lag{lag}'] = df['sales'].shift(lag)

# diff feature
df['sales_diff1'] = df['sales'].diff(1)
df['sales_diff7'] = df['sales'].diff(7)

룩어헤드 방지

# 오늘 데이터로 내일을 예측하는 모델
df['target'] = df['close'].shift(-1)   # 내일 종가 (타깃)
# 학습 feature 는 shift 안 함 (현재 또는 과거 데이터)
df = df.dropna()    # 마지막 행 NaN 제거

누적 증가율

df['daily_return'] = df['close'].pct_change()
df['cumulative_return'] = (1 + df['daily_return']).cumprod()

그룹별 shift

# 같은 user 안에서 이전 주문 참조
df = df.sort_values(['user_id', 'date'])
df['prev_amount'] = df.groupby('user_id')['amount'].shift(1)
df['amount_diff']  = df.groupby('user_id')['amount'].diff(1)

이동 평균과 결합

# 단기 이동 평균 vs 장기 이동 평균 교차 (golden cross / dead cross)
df['ma5']  = df['close'].rolling(5).mean()
df['ma20'] = df['close'].rolling(20).mean()
df['cross_signal'] = (df['ma5'] > df['ma20']) & (df['ma5'].shift(1) <= df['ma20'].shift(1))

변화 감지

# 값이 바뀐 위치 탐지
df['changed'] = df['status'] != df['status'].shift(1)
df['run_id'] = df['changed'].cumsum()   # 연속 구간 ID

성능

연산	속도	비고
`shift(n)`	빠름	단순 메모리 오프셋
`diff(n)`	빠름	내부적으로 shift + 빼기
`pct_change(n)`	빠름	diff / shift
`groupby().shift(n)`	중간	그룹 기준 분할 후 shift

import pandas as pd
import numpy as np

# 대용량에서도 빠름
df = pd.DataFrame({'value': np.random.randn(1_000_000)})
df['lag1'] = df['value'].shift(1)      # 거의 즉시
df['diff1'] = df['value'].diff(1)      # 거의 즉시

함정

[!WARNING] shift / diff / pct_change 를 쓸 때 다음 상황을 주의한다.

1. NaN 의 첫/마지막

shift(1) 은 첫 행이 NaN, shift(-1) 은 마지막 행이 NaN.

df['lag1'] = df['value'].shift(1)
df = df.dropna()                    # 첫 행 제거
# 또는
df['lag1'] = df['value'].shift(1, fill_value=0)   # 0 으로 채움

2. 시간 freq 가 일정하지 않을 때

# index 가 불규칙 시계열 (2024-01-01, 01-03, 01-10 등)
df.shift(1)           # 위치 기반: 바로 앞 행
df.shift(1, freq='D') # 시간 기반: 정확히 1일 전 (없으면 NaN)

불규칙 시계열에서는 위치 기반 shift 와 시간 기반 shift 의 결과가 완전히 다르다.

3. groupby + shift 의 정렬

# 정렬 없이 shift 하면 의미가 달라짐
df = df.sort_values(['user_id', 'date'])   # 반드시 정렬 먼저
df['prev'] = df.groupby('user_id')['amount'].shift(1)

4. pct_change 의 inf / 분모 0

s = pd.Series([0, 10, 5])
s.pct_change()   # [NaN, inf, -0.5]
# 분모(이전 값)가 0 이면 inf 발생

5. 타입 변화

# int Series 에 shift(1) 적용 시 float 으로 변환 (NaN 때문)
s = pd.Series([1, 2, 3], dtype='int64')
s.shift(1).dtype    # float64

pandas 2.x Nullable Int 타입 사용 시 Int64 로 선언하면 NaN 을 보존하면서 정수 유지.

s = pd.Series([1, 2, 3], dtype='Int64')   # Nullable Int
s.shift(1)    # [<NA>, 1, 2] dtype: Int64

[Pandas] sort_values / sort_index

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

sort_values(): 컬럼 값 기준 정렬
sort_index(): index (행 또는 열 라벨) 기준 정렬

기본은 오름차순, ascending=False 로 내림차순.

사용 상황

단일 컬럼 정렬: 날짜, 점수, 금액 등 단순 순위 정렬
다중 컬럼 정렬: 그룹 내 부분 정렬 (예: 지역별 내림차순 매출)
nlargest / nsmallest: 전체 정렬 없이 상위/하위 N 개만 빠르게 추출
sort_index: 합병/pivot 후 흐트러진 index 를 원래 순서로 복구

정렬 흐름 시각화

flowchart TD
    Q{"무엇 기준으로 정렬?"}
    Q -->|"컬럼 값"| SV["sort_values(by='col')"]
    Q -->|"index 라벨"| SI["sort_index()"]

    SV --> MC{"다중 컬럼?"}
    MC -->|"예"| ML["sort_values(['col1','col2'], ascending=[True, False])"]
    MC -->|"아니오"| SS["sort_values('col', ascending=True/False)"]

    SS --> NL{"Top-N 만 필요?"}
    NL -->|"예"| NLS["nlargest / nsmallest"]
    NL -->|"아니오"| FULL["전체 정렬"]

sort_values 기본

여러 컬럼 정렬

df.sort_values(['city', 'age'])
df.sort_values(['city', 'age'], ascending=[True, False])
# city 오름차순, 같은 city 안에서 age 내림차순

NaN 위치

df.sort_values('age', na_position='last')    # 기본: NaN 을 마지막에
df.sort_values('age', na_position='first')   # NaN 을 맨 앞에

NaN 은 비교 불가. na_position 으로 위치를 명시해야 의도한 결과를 얻을 수 있다.

stable sort

df.sort_values('age', kind='stable')        # 같은 값의 상대 순서 유지

기본 kind='quicksort'. stable 이 필요한 경우: multi-pass 정렬, 카테고리별 누적 순서 유지 시 kind='stable' 명시.

key 함수

# 대소문자 무시 정렬
df.sort_values('name', key=lambda s: s.str.lower())

# 절댓값 기준
df.sort_values('balance', key=lambda s: s.abs())

# 한글 초성 기준 정렬 (사용자 정의 매핑 필요)
CHOSEONG_ORDER = {'가': 'ㄱ', '나': 'ㄴ', ...}
df.sort_values('name', key=lambda s: s.map(lambda x: CHOSEONG_ORDER.get(x[0], x)))

sort_index

df.sort_index()                    # 행 라벨 정렬
df.sort_index(axis=1)              # 컬럼 이름 정렬
df.sort_index(ascending=False)     # 내림차순
df.sort_index(level=0)             # MultiIndex 의 특정 level

pivot / merge 후 index 가 흐트러졌을 때 sort_index() 로 복원:

pivoted = df.pivot_table(index='date', columns='product', values='sales')
pivoted.sort_index()  # 날짜 순으로 복원

sorted 결과를 in-place 로

df = df.sort_values('age')           # 사본 (권장)
df.sort_values('age', inplace=True)  # in-place (deprecated 방향)

[!TIP] 새 pandas 에서는 in-place 가 더 빠르지 않다. 명시성과 method chain 을 위해 df = df.sort_values(...) 형태를 권장.

reset_index 와 함께

정렬 후 index 가 뒤섞이는 게 싫다면 reset_index(drop=True):

df_sorted = df.sort_values('age').reset_index(drop=True)

nlargest / nsmallest

상위/하위 N 개만 필요하면 sort 후 head 보다 nlargest / nsmallest 가 빠르다.

df.nlargest(3, 'salary')            # 상위 3 명
df.nsmallest(3, 'salary')           # 하위 3 명
df.nlargest(3, ['salary', 'age'])   # 다중 키 Top-N

[[Pandas nlargest / rank]] 참고.

실전 패턴

그룹별 Top-N

# 각 도시에서 매출 상위 2 명
top2_per_city = (
    df.sort_values('sales', ascending=False)
    .groupby('city')
    .head(2)
)

날짜 내림차순으로 최신 N 개

df.sort_values('created_at', ascending=False).head(10)

특정 값을 맨 앞으로

# status == 'urgent' 를 맨 앞에 배치
order_map = {'urgent': 0, 'normal': 1, 'low': 2}
df.sort_values('status', key=lambda s: s.map(order_map))

정렬 후 순위 컬럼 추가

df_sorted = df.sort_values('score', ascending=False)
df_sorted['rank'] = range(1, len(df_sorted) + 1)

다중 DataFrame 정렬 후 concat

import pandas as pd
result = pd.concat([
    df_jan.sort_values('date'),
    df_feb.sort_values('date'),
], ignore_index=True)

성능

방법	복잡도	용도
`sort_values`	O(n log n)	전체 정렬
`nlargest(k)`	O(n + k log k)	상위 k 개
`sort_values().head(k)`	O(n log n)	전체 정렬 후 잘라냄

Top-N 만 필요하다면 nlargest 가 항상 빠르다.

# 1000 만 행에서 상위 10 개: nlargest 가 sort_values().head() 보다 빠름
df.nlargest(10, 'score')

함정

1. 정렬 후 index 가 섞임

df.sort_values('age')
# index: 1, 3, 0, 2 같이 뒤섞임
# .iloc[0] 은 정렬 결과의 첫 행 (의도한 동작)
# .loc[0] 은 라벨 0 인 행 (정렬 전 첫 번째 행)
df.sort_values('age').reset_index(drop=True).iloc[0]   # 명확

2. inplace=True 의 부작용

df.sort_values('age', inplace=True)
# 이후 모든 view 가 영향받음
# method chain 도 끊김

3. 한글 정렬

# 기본은 유니코드 순. 한글의 사전순이 항상 직관적이지는 않음
# 특히 초성 구분이 안 될 때: 별도 정렬 키 또는 locale 사용

[!WARNING] sort_values 에 inplace=True 를 쓰면 pandas 2.x Copy-on-Write 환경에서 경고가 발생할 수 있다. 새 DataFrame 을 할당하는 방식 (df = df.sort_values(...)) 을 사용하라.

4. NaN 과 ascending=False 의 조합

# ascending=False + na_position='last' (기본): NaN 이 맨 마지막
# ascending=True + na_position='last' (기본): NaN 이 맨 마지막
# na_position 은 ascending 과 독립적
df.sort_values('score', ascending=False, na_position='last')

[Pandas] stack / unstack

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

stack() : 가장 안쪽 컬럼 레벨 -> 행 레벨 (DataFrame -> Series 또는 더 좁은 DataFrame)
unstack() : 가장 안쪽 행 레벨 -> 컬럼 레벨

[[Pandas pivot]] / [[Pandas melt]] 의 MultiIndex 기반 버전.

사용 상황

groupby 결과 wide 변환: groupby(['region', 'product']).sum() 후 unstack('product') 로 product 별 컬럼
시계열 패널 -> wide format: 날짜 + 종목 MultiIndex를 날짜 행 + 종목 컬럼으로
wide -> long 변환: 여러 컬럼 (Q1, Q2, Q3, Q4)을 stack() 으로 긴 형태로
pivot_table 결과 정리: MultiIndex 컬럼이 생겼을 때 stack() 으로 조정

pivot/melt 가 이미 있는 경우 대부분 충분하다. stack/unstack 은 이미 MultiIndex가 있거나 자동 생성된 경우에 가장 자연스럽다.

변환 흐름 시각화

flowchart LR
    W["Wide DataFrame"] -->|"stack()"| L["Long MultiIndex Series"]
    L -->|"unstack()"| W

    P["pivot 결과"] -.->|"unstack 과 동일"| W
    M["melt 결과"] -.->|"stack 과 동일"| L

stack 기본

DataFrame 의 2 컬럼이 MultiIndex Series 로 합쳐졌다.

unstack 기본

s.unstack()                  # 가장 안쪽 index level -> columns
s.unstack(level=0)           # 0번 level 을 columns 로
s.unstack(level='product')   # 이름으로 지정 (권장)

# 역변환: stack 으로 복원
multi = df.stack()           # Series
multi.unstack()              # 원래 DataFrame 으로 복원

다단계 unstack

df = pd.DataFrame({
    'region': ['Seoul', 'Seoul', 'Busan', 'Busan'],
    'product': ['A', 'B', 'A', 'B'],
    'sales': [100, 200, 150, 250],
}).set_index(['region', 'product'])['sales']

df.unstack()                # product 가 컬럼
df.unstack(level='region')  # region 이 컬럼

region \ product	A	B
Busan	150	250
Seoul	100	200

pivot / melt 와의 비교

동작	DataFrame API	MultiIndex API
long -> wide	`pivot`, `pivot_table`	`unstack`
wide -> long	`melt`	`stack`

대부분의 경우 pivot / melt 가 더 직관적. stack / unstack 은 MultiIndex 가 이미 있는 경우 자연스럽다.

# 같은 결과 (다른 경로)
df.pivot(index='region', columns='product', values='sales')
df.set_index(['region', 'product'])['sales'].unstack('product')

groupby + unstack 패턴

# groupby 가 MultiIndex 결과를 반환 -> unstack 으로 wide 형태
df.groupby(['region', 'product'])['sales'].sum().unstack('product')

이 패턴은 실무에서 매우 자주 쓰인다. groupby + agg + unstack 조합:

result = (
    df.groupby(['region', 'product', 'quarter'])['sales']
    .sum()
    .unstack('quarter')
    .fillna(0)
)

fill_value

s.unstack(fill_value=0)      # NaN 을 0 으로

stack 의 dropna

df.stack(dropna=False)       # NaN 도 결과에 포함 (기본은 제거)

pandas 2.x 에서 stack 의 기본 동작이 변경됨: future_stack=True 모드가 기본이 됨. NaN 처리 방식 확인 필요.

실전 패턴

분기별 wide 보고서

import pandas as pd

data = {
    'region': ['Seoul', 'Seoul', 'Seoul', 'Busan', 'Busan', 'Busan'],
    'quarter': ['Q1', 'Q2', 'Q3', 'Q1', 'Q2', 'Q3'],
    'revenue': [100, 120, 130, 80, 90, 95],
}
df = pd.DataFrame(data)

# long -> wide: region 행, quarter 컬럼
wide = (
    df.groupby(['region', 'quarter'])['revenue']
    .sum()
    .unstack('quarter')
    .fillna(0)
)
print(wide)
# quarter    Q1     Q2     Q3
# region
# Busan    80.0   90.0   95.0
# Seoul   100.0  120.0  130.0

wide -> long 정리

# 여러 시점 컬럼을 long format 으로
df_wide = pd.DataFrame({
    'region': ['Seoul', 'Busan'],
    'Q1': [100, 80],
    'Q2': [120, 90],
    'Q3': [130, 95],
}).set_index('region')

df_long = df_wide.stack().reset_index()
df_long.columns = ['region', 'quarter', 'revenue']

MultiIndex 컬럼 unstack 후 평탄화

result = df.groupby(['region', 'product']).agg({'sales': ['sum', 'mean']})
# 컬럼: MultiIndex ('sales', 'sum'), ('sales', 'mean')

# unstack 으로 region 을 컬럼 레벨로
wide = result['sales'].unstack('region')
# 컬럼: MultiIndex ('sum', 'Seoul'), ('sum', 'Busan'), ('mean', 'Seoul'), ...

# 평탄화
wide.columns = ['_'.join(c) for c in wide.columns]

pandas 2.x 스타일: stack() 동작 확인

import pandas as pd

# pandas 2.x 에서 stack 은 MultiIndex 컬럼도 처리
df = pd.DataFrame(
    {'A': {'x': 1, 'y': 2}, 'B': {'x': 3, 'y': 4}}
)
# pandas 2.x default: future_stack=True
stacked = df.stack(future_stack=True)

성능

상황	권장
`unstack()` 후 sparse	NaN 폭증 주의, long-format 유지 권장
대용량 wide -> long	`melt()` 가 `stack()` 보다 빠를 수 있음
대용량 long -> wide	`pivot_table()` 또는 `unstack()` 비슷, 테스트 후 선택
반복 `stack()` / `unstack()`	중간 결과 캐싱: 인터미디어트 DataFrame 저장

# 대용량에서 unstack NaN 폭증 방지: sparse 확인
before = s.memory_usage(deep=True)
after = s.unstack().memory_usage(deep=True).sum()
print(f"메모리 증가: {after / before:.1f}x")

함정

1. stack 한 결과의 타입

DataFrame.stack() -> Series (일반: 컬럼이 1개 레벨)
DataFrame.stack(level=0) -> DataFrame (남은 컬럼 레벨이 있으면)

2. unstack 의 level 지정

s.unstack()                 # 가장 안쪽 level (기본)
s.unstack(level=-1)         # 같음
s.unstack(level=0)          # 가장 바깥 level
s.unstack(level='product')  # 이름으로 (권장, 명확)

3. 데이터가 너무 sparse 하면 NaN 폭증

# 10 region x 1000 product 의 unstack -> 10000 셀 대부분 NaN
# 이런 경우 long-format 유지가 메모리 효율적

4. pandas 2.x stack() 변경사항

[!WARNING] pandas 2.x 에서 stack() 의 기본 동작이 변경됐다. FutureWarning 가 발생하면 future_stack=True 를 명시적으로 전달하라.

# pandas 2.x: FutureWarning 방지
df.stack(future_stack=True)   # 새 동작 명시적 사용

[Pandas] 컬럼 선택

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

DataFrame 에서 하나 또는 여러 컬럼을 선택 하는 방법들. 가장 기본이자 가장 자주 쓰는 동작.

선택 방법 분류

flowchart TD
    DF["DataFrame"] --> BY_NAME["이름으로 선택"]
    DF --> BY_PATTERN["패턴으로 선택"]
    DF --> BY_DTYPE["dtype 으로 선택"]

    BY_NAME --> SINGLE["df['col'] - Series"]
    BY_NAME --> MULTI["df - 여러 컬럼 DataFrame"]
    BY_NAME --> ATTR["df.col - attribute (제한적)"]

    BY_PATTERN --> FILTER_LIKE["df.filter(like='amount')"]
    BY_PATTERN --> FILTER_REGEX["df.filter(regex='^col_')"]

    BY_DTYPE --> SELECT_DTYPES["df.select_dtypes(include='number')"]

4 가지 기본 방식

df['name']             # 단일 컬럼 → Series
df[['name']]            # 한 컬럼이지만 DataFrame
df[['name', 'age']]    # 여러 컬럼 → DataFrame
df.name                 # attribute (제한적)

단일 vs 다중 (반환 타입 차이)

대괄호 1 개 → Series, 대괄호 2 개 (리스트) → DataFrame.

attribute 접근의 제한

df.name      # ✓ 동작
df.class     # ❌ Python 예약어
df['1st']    # ✓ 동작
df.1st       # ❌ 문법 오류

attribute 는 일관성이 없으므로 df['col'] 권장.

컬럼 순서 변경

df[['c', 'a', 'b']]      # 명시적 순서로 재정렬한 새 DataFrame
df.reindex(columns=['c', 'a', 'b'])  # 같음

패턴으로 선택

# 이름이 'amount_' 로 시작하는 컬럼만
df.filter(like='amount_')

# 정규식
df.filter(regex='^(name|age)$')

# dtype 기반
df.select_dtypes(include='number')
df.select_dtypes(include=['int64', 'float64'])
df.select_dtypes(exclude='object')

동적 컬럼 목록

# 런타임에 컬럼 목록 결정
target_cols = ['name', 'age', 'salary']
df[target_cols]

# 특정 컬럼 제외
exclude = ['id', 'created_at']
cols = [c for c in df.columns if c not in exclude]
df[cols]

# 또는 drop 으로
df.drop(columns=exclude)

컬럼 추가 / 삭제

df['bmi'] = df['weight'] / (df['height'] / 100) ** 2
df['constant'] = 100
df = df.drop(columns=['old_col'])
df = df.drop(columns=['a', 'b'])

# in-place 도 가능하지만 권장 안 함
df.drop(columns=['a'], inplace=True)

assign 으로 method chain

df_new = (df
    .assign(bmi=lambda d: d['weight'] / (d['height']/100)**2)
    .assign(category=lambda d: d['bmi'].apply(categorize))
)

체인 방식으로 새 컬럼을 추가, 원본 보존.

컬럼 이름 변경

df.rename(columns={'old_name': 'new_name'})
df.rename(columns=str.lower)              # 모든 컬럼 소문자
df.columns = ['a', 'b', 'c']              # 직접 할당

컬럼 타입 확인 및 일괄 변환

df.dtypes                                   # 각 컬럼 dtype
df.dtypes[df.dtypes == 'object']            # object 타입만

# 일괄 변환
df = df.astype({
    'age': 'int32',
    'city': 'category',
    'score': 'float32',
})

# object -> category (메모리 절약)
cat_cols = df.select_dtypes(include='object').columns
df[cat_cols] = df[cat_cols].astype('category')

loc / iloc 으로 컬럼 범위 선택

import pandas as pd
df = pd.DataFrame({'a': [1], 'b': [2], 'c': [3], 'd': [4]})

df.loc[:, 'b':'d']       # 컬럼 b, c, d (label 슬라이스, 양쪽 포함)
df.iloc[:, 1:3]          # 컬럼 위치 1, 2 (position 슬라이스, 오른쪽 미포함)
df.iloc[:, ::2]          # 짝수 위치 컬럼 (a, c)

자세히는 [[Pandas .loc / .iloc]].

성능 팁

# 필요한 컬럼만 read_csv 할 때
df = pd.read_csv('large.csv', usecols=['name', 'age', 'salary'])
# 불필요한 컬럼을 메모리에 올리지 않음

# object 컬럼이 많으면 category 변환으로 선택 연산 속도 향상
df['city'] = df['city'].astype('category')

함정

1. SettingWithCopyWarning

sub = df[df['age'] > 20]
sub['new'] = 1      # ⚠️ SettingWithCopyWarning
# 해법: .copy() 명시
sub = df[df['age'] > 20].copy()
sub['new'] = 1      # ✓

[!WARNING] pandas 2.0 부터 CoW(Copy-on-Write) 기본 도입. 체이닝 인덱싱(df[mask]['col'] = ...) 은 ChainedAssignmentError. .loc[mask, col] = 패턴 사용.

2. attribute 가 메서드와 충돌

df.shape, df.values, df.index 같은 attribute 가 있으면 같은 이름의 컬럼은 attribute 로 못 부른다.

df['shape']    # ✓ 컬럼
df.shape        # DataFrame 의 shape attribute

3. 컬럼 이름에 공백 / 특수문자

df['first name']           # ✓ 대괄호 필수
df.first name              # ❌ 문법 오류
df.query("`first name` > 0")   # query 에서는 backtick 으로 이스케이프

4. filter(like=…) 의 동작 범위

df.filter(like='name')    # 컬럼명에 'name' 이 포함된 것 (행 이름 아님)
# df.filter(axis=0, like='2024') 으로 행 필터 가능

filter 는 기본 axis=1 (컬럼). 혼동 주의.

pipe 와 method chain 에서 컬럼 선택

# 파이프라인에서 동적으로 컬럼 가공
result = (
    df
    .assign(bmi=lambda d: d['weight'] / (d['height']/100)**2)
    .pipe(lambda d: d.loc[:, ['name', 'age', 'bmi']])   # 필요한 컬럼만 유지
    .rename(columns={'bmi': 'body_mass_index'})
)

자세히는 [[Pandas pipe]].

김신건의 로그 - 위키 / pandas

[Pandas] date_range / Timestamp

정의

사용 상황

시각화

date_range

freq 옵션 (대표)

tz 지정

Timestamp 생성

연산

Timedelta

period (기간)

DatetimeIndex 의 슬라이싱

자주 쓰는 패턴

보고 기간 생성

누락된 날짜 채우기

영업일 계산

특정 요일의 날짜만

DataFrame 에 날짜 인덱스 붙이기

두 날짜 사이 영업일 수

날짜 오프셋 종류

함정

1. freq 가 정해지지 않은 경우

2. DateOffset vs Timedelta

3. periods 계산

4. naive vs tz-aware 혼합

5. Timedelta 와 DateOffset 의 차이

관련 위키

[Pandas] pipe / method chaining

정의

사용 상황

시각화

왜 pipe 인가

기본 사용

func 가 첫 인자가 DataFrame 이 아닐 때

method chain 의 장점

assign 과의 조합

query 와 조합

함수형 스타일

tap 패턴 (중간 검사)

assert pipe

pipe 와 assign 고급 조합

가독성 가이드

함정

1. inplace 함수와 안 어울림

2. side effect

3. 디버깅 어려움

4. copy 없는 함수 주의

5. 큰 DataFrame 에서 pipe 마다 copy

관련 위키

[Pandas] PyArrow Backend

정의

사용 상황

시각화

적용 방법

1. read 함수에서

2. 전역 설정

3. 명시적 변환

NumPy backend vs pyarrow backend

메모리 비교 예

문자열 처리 속도

정밀한 타입

단점 / 함정

1. 일부 메서드 호환성

2. 다른 라이브러리와의 호환

3. 일부 dtype 의 표현

4. NaN vs <NA>

자주 쓰는 패턴

1. Parquet pipeline

2. 문자열 대용량 데이터

3. 점진적 마이그레이션

dtype 변환 상세

ML 파이프라인 연동

pandas 3.0

관련 위키

[Pandas] resample

정의

사용 상황

시각화

기본