김신건의 로그 - 위키 / pandas

[Pandas] pipe / method chaining

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

.pipe(func) 는 DataFrame 자체를 함수의 첫 인자로 넘겨 method chaining 을 확장. functional style Pandas.

문제: 중간 변수 남발

step1 = filter_rows(df, min_age=18)
step2 = add_column(step1, source='v2')
step3 = normalize(step2, cols=['x', 'y'])
final = summarize(step3)

가독성 나쁘고 중간 변수 이름 관리 부담.

pipe 로 chain

final = (df
    .pipe(filter_rows, min_age=18)
    .pipe(add_column, source='v2')
    .pipe(normalize, cols=['x', 'y'])
    .pipe(summarize)
)

또는 built-in method 만 사용:

result = (df
    .query('age >= 18')
    .assign(source='v2')
    .astype({'x': 'float32'})
    .groupby('country')
    .agg({'value': 'sum'})
    .reset_index()
)

왜 좋은가

불변식: 각 단계가 순수 함수
테스트 용이: 각 함수 단위 테스트
가독성: 위에서 아래로 pipeline
디버깅: 중간에 .pipe(print) 삽입 가능

함정

inplace=True 지양: chain 이 깨짐. 항상 새 DataFrame 반환.
긴 chain 은 성능 손해: 각 단계마다 새 DataFrame 생성 (메모리)

참고

[[pandas-apply-map|apply / map]]
[[pandas-performance|성능 최적화]]

[Pandas] .at / .iat

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

.at[] : 단일 스칼라 (한 행, 한 열) 의 라벨 기반 접근
.iat[] : 단일 스칼라의 정수 위치 기반 접근

[[Pandas .loc / .iloc]] 의 단일 셀 전용 빠른 버전. 내부 검증 단계를 단순화해 가장 빠른 셀 접근을 제공.

사용

import pandas as pd
df = pd.DataFrame(
    {'age': [25, 30], 'salary': [3000, 4500]},
    index=['Alice', 'Bob']
)

df.at['Alice', 'age']     # 25, label 기반
df.iat[0, 0]               # 25, 위치 기반

df.at['Alice', 'age'] = 99
df.iat[0, 0] = 99

.loc / .iloc 와의 차이

항목	`.loc` / `.iloc`	`.at` / `.iat`
슬라이스	✓	✗ (단일 셀만)
리스트	✓	✗
boolean mask	✓ (loc만)	✗
단일 셀 속도	보통	더 빠름

루프 안에서 셀을 자주 읽는다면 .at / .iat 이 유의미하게 빠르다.

벤치마크 감

.iat 가 .iloc 보다 빠르지만, 루프 자체가 비싸다. 벡터 연산 (df['x'].sum()) 이 압도적으로 빠르다.

[!IMPORTANT] .at / .iat 가 .loc / .iloc 보다 빠른 건 사실 이지만, 그래도 pandas 의 정답은 루프 회피, 벡터 연산. 루프가 정말 필요한 경우에만 .at/.iat 의 미세 최적화가 의미 있다.

사용 예

행/열 단일 셀 값 수정

df.at[user_id, 'last_login'] = pd.Timestamp.now()
df.iat[-1, df.columns.get_loc('status')] = 'DONE'

마지막 행의 특정 컬럼

df.iat[-1, df.columns.get_loc('value')]

함정

1. 슬라이스 / 리스트 불가

df.at['Alice':'Bob', 'age']    # ❌ TypeError
df.loc['Alice':'Bob', 'age']   # ✓

여러 셀이 필요하면 .loc / .iloc.

2. 존재하지 않는 라벨 → KeyError

df.at['Unknown', 'age']    # KeyError

.loc 도 같다, 하지만 .at 은 더 엄격하게 즉시 throw.

3. dtype 변경

df.iat[0, 0] = 'hello'     # int 컬럼에 str 할당, 컬럼 dtype 이 object 로 변경됨

참고

[[Pandas DataFrame]]
[[Pandas .loc / .iloc]]
[[Pandas 컬럼 선택]]

[Pandas] .dt accessor

koa (김신건) — Thu, 18 Jun 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

기본 컴포넌트

속성	의미
`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 으로

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()  # 전체 초

자주 쓰는 패턴

월별 분석

df['month'] = df['created_at'].dt.to_period('M')   # PeriodIndex (2024-01, 2024-02, ...)
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

datetime 차이

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

함정

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.

참고

[[Pandas to_datetime]]
[[Pandas resample]]
[[Pandas date_range]]

[Pandas] .loc / .iloc

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

.loc[] : 라벨 기반 인덱싱 (index/column 이름)
.iloc[] : 정수 위치 기반 인덱싱 (0-based)

이 두 indexer 가 pandas 선택의 표준. df[] 만으로는 헷갈리는 경우가 많아 명시적인 .loc / .iloc 권장.

기본 비교

import pandas as pd
df = pd.DataFrame(
    {'age': [25, 30, 35], 'salary': [3000, 4500, 6000]},
    index=['Alice', 'Bob', 'Charlie']
)

df.loc['Bob']               # 라벨 → Series
df.iloc[1]                  # 위치 1 → Series

df.loc['Bob', 'age']        # 스칼라
df.iloc[1, 0]               # 스칼라

df.loc[['Alice', 'Bob']]    # 여러 라벨
df.iloc[[0, 1]]             # 여러 위치

슬라이싱 (가장 중요한 차이)

df.loc['Alice':'Bob']       # ✓ 'Bob' 포함 (양쪽 inclusive!)
df.iloc[0:2]                # ✗ 위치 2 미포함 (Python 표준)

[!IMPORTANT] .loc 의 슬라이스는 양쪽 inclusive. .iloc 는 Python list 처럼 right-exclusive. 자주 헷갈리니 주의.

행 + 열 동시 선택

	a	c
x	2	200
y	3	300
z	4	400

위 .loc 는 ‘z’ 포함, 아래 .iloc[1:3] 은 위치 3 (z) 미포함.

boolean mask 와 결합

df.loc[df['age'] > 30]                        # 행 필터
df.loc[df['age'] > 30, 'salary']              # 행 필터 + 컬럼
df.loc[df['age'] > 30, ['name', 'salary']]    # 행 필터 + 여러 컬럼
df.loc[df['age'] > 30, 'salary'] *= 1.1       # 조건부 갱신

값 할당

df.loc[df['age'] > 30, 'bonus'] = 500           # 조건부 추가
df.loc['Alice', 'salary'] = 9999                # 단일 셀
df.loc['Alice':'Bob', 'salary'] = [9999, 8888]  # 슬라이스 + 리스트
df.iloc[0, 1] = 99                              # 위치 기반

함정

1. boolean mask 에 `.iloc` 사용 불가

df.iloc[df['age'] > 30]     # ❌ NotImplementedError 또는 의미 다름
df.loc[df['age'] > 30]      # ✓

.iloc 은 정수 (또는 정수 array) 만. boolean array 는 라벨처럼 취급되는 .loc 만.

2. SettingWithCopyWarning

df[df['age'] > 30]['salary'] = 999    # ⚠️ chained indexing
df.loc[df['age'] > 30, 'salary'] = 999  # ✓

한 줄에 indexer 두 번 쓰면 결과가 view 인지 copy 인지 모호. 항상 .loc[행, 열] 한 번에 처리.

3. 정수 index 의 모호함

s = pd.Series([10, 20, 30], index=[5, 6, 7])
s.loc[5]      # label 5 → 10
s.iloc[5]     # IndexError
s[5]          # label 5 → 10 (Future 에 deprecate 예정 경고)

명확하려면 항상 .loc 또는 .iloc.

4. 단일 row 의 반환 타입

df.loc['Alice']        # Series (1차원)
df.loc[['Alice']]      # DataFrame (2차원, 한 행)

다중 행을 유지하려면 리스트로 감싼다.

참고

[[Pandas DataFrame]]
[[Pandas 컬럼 선택]]
[[Pandas .at / .iat]]
[[Pandas Boolean Indexing]]

[Pandas] .str accessor

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

Series.str 는 Series 의 각 문자열 원소에 벡터화된 문자열 메서드 를 적용하는 accessor. Python str 의 거의 모든 메서드를 NaN-aware 로 제공.

s.str.lower()
s.str.contains('python')
s.str.split(',')
s.str.replace('a', 'A')

기본 메서드

메서드	의미
`.lower()`, `.upper()`, `.title()`, `.capitalize()`	대소문자
`.strip()`, `.lstrip()`, `.rstrip()`	공백 제거
`.len()`	문자열 길이
`.startswith(s)`, `.endswith(s)`	시작/끝 검사
`.contains(pat)`	부분 문자열 (정규식 가능)
`.replace(pat, repl)`	치환
`.split(sep)`, `.rsplit(sep)`	분리
`.join(sep)`	결합 (list of str)
`.slice(start, stop)`, `.slice_replace(...)`	슬라이싱
`.pad(width, side)`, `.zfill(width)`	패딩
`.cat(sep=)`	Series 연결

기본 사용

NaN 은 NaN 으로 유지 (Python str 의 메서드는 NaN 에서 에러).

chaining

df['email_clean'] = (df['email']
    .str.lower()
    .str.strip()
    .str.replace(r'\s+', '', regex=True))

체이닝이 자연스럽다.

새 컬럼 분리

s = pd.Series(['Alice,30', 'Bob,25'])
df = s.str.split(',', expand=True)
df.columns = ['name', 'age']

expand=True 가 DataFrame 반환, expand=False (기본) 는 list of list.

get / getitem

s = pd.Series(['Alice,30', 'Bob,25'])
s.str.split(',').str.get(0)   # 첫 원소
s.str.split(',').str[0]        # 같음, indexer 형태
s.str[0]                       # 첫 글자
s.str[-1]                      # 마지막 글자

category 자동 보존

s = pd.Series(['A', 'B', 'A']).astype('category')
s.str.lower()    # category dtype 유지 (유한 cardinality)

함정

1. NaN 의 비교

s.str.contains('a')         # NaN 행 → NaN
s.str.contains('a', na=False)  # NaN → False (필터에 안전)

mask 로 쓸 때 na=False 필수.

2. 정규식의 escape

s.str.contains('.')         # 정규식 메타문자 → 모두 매칭
s.str.contains('.', regex=False)
s.str.contains(r'\.', regex=True)

3. 모든 문자열을 str 로 캐스트

s = pd.Series([1, 2, 3])
s.str.lower()    # AttributeError
s.astype(str).str.lower()    # ✓

참고

[[Pandas Series]]
[[Pandas str pattern]]
[[Pandas str regex]]

[Pandas] agg / aggregate

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

다양한 형태

단일 함수

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()),
)

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

자주 쓰는 집계 함수 모음

함수	의미
`'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)

함정

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. 함수 이름의 충돌

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

3. groupby + agg 의 dropna

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

참고

[[Pandas groupby]]
[[Pandas transform / apply]]
[[Pandas pivot_table]]

[Pandas] apply / map

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

Series.map (가장 흔함)

s.map({'A': 1, 'B': 2, 'C': 3})        # dict 매핑
s.map(lambda x: x * 2)                  # 함수
s.map(some_func)

Series.apply

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

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

s.apply(round, ndigits=2)

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)

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

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

구 applymap 의 새 이름.

벡터 연산이 항상 우선

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

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

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')

map vs apply 차이

메서드	대상	dict 매핑	추가 인자
`Series.map`	원소	✓	✗
`Series.apply`	원소	✗	✓
`DataFrame.apply`	행/열	✗	✓
`DataFrame.map`	셀	✗	✓

함정

1. apply 의 속도

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

2. axis 0 vs 1 의 의미

df.apply(fn, axis=0)    # 각 열에 fn (default)
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

복잡한 함수의 결과 타입은 일정하지 않을 수 있음.

참고

[[Pandas Series]]
[[Pandas DataFrame]]
[[Pandas transform / apply]]

[Pandas] between / 다중 조건

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

.between(left, right) 는 SQL BETWEEN 과 같이 두 값 사이 인지 검사하는 Series 메서드. 다중 조건 조합은 &, |, ~ 비트연산자로.

between 기본

df[df['age'].between(20, 30)]                  # 20 ≤ age ≤ 30 (양쪽 inclusive)
df[df['age'].between(20, 30, inclusive='left')]  # [20, 30)
df[df['age'].between(20, 30, inclusive='right')] # (20, 30]
df[df['age'].between(20, 30, inclusive='neither')] # (20, 30)

다중 조건 조합

# AND
df[(df['age'] > 25) & (df['city'] == 'Seoul')]

# OR
df[(df['city'] == 'Seoul') | (df['city'] == 'Busan')]

# NOT
df[~(df['city'] == 'Seoul')]

# 복잡한 조합
df[((df['age'] > 25) & (df['city'] == 'Seoul')) | (df['salary'] > 5000)]

[!IMPORTANT] 각 조건은 괄호로 감싼다. &, | 의 우선순위가 비교 연산자보다 높아서 괄호 없으면 잘못 평가된다.

가독성을 위한 변수 분리

긴 조건은 변수로 쪼개라.

is_adult = df['age'] >= 18
is_capital = df['city'].isin(['Seoul', 'Tokyo', 'Beijing'])
has_premium = df['plan'] == 'premium'

df[is_adult & is_capital & has_premium]

[[Pandas query]] 도 가독성 대안.

df.query("age >= 18 and city in ['Seoul', 'Tokyo', 'Beijing'] and plan == 'premium'")

any / all

여러 조건 중 하나라도 / 모두 만족하는지를 axis 기준으로 집계.

conditions = pd.concat([
    df['age'] > 30,
    df['salary'] > 5000,
    df['city'] == 'Seoul'
], axis=1)

df[conditions.any(axis=1)]       # 하나라도 True
df[conditions.all(axis=1)]       # 모두 True

함정

1. between 의 NaN 처리

df['age'].between(20, 30)
# NaN 인 행은 False

NaN 을 명시적으로 처리하려면 isna() 와 조합.

2. 문자열도 between 가능

df['name'].between('A', 'C')    # 알파벳 순서로 'A' ≤ name ≤ 'C'

사전순 비교. 한글은 유니코드 순.

3. inclusive 의 string 값

pandas 1.x: inclusive=True/False, 2.x: inclusive='both' / 'left' / 'right' / 'neither'.

df['age'].between(20, 30, inclusive='both')      # 권장 (명시적)

다중 조건의 성능

대규모 데이터에서 boolean mask 가 누적되는 비용. 다음 패턴이 빠를 때가 있다.

# 가장 selective 한 조건 먼저
result = df[df['rare_value'] == 'X']         # 작은 결과로 줄임
result = result[result['common'] > 100]       # 그 다음 필터

[[Pandas query]] 는 numexpr 가속으로 큰 DataFrame 에서 종종 더 빠르다.

참고

[[Pandas Boolean Indexing]]
[[Pandas isin / isna]]
[[Pandas query]]

[Pandas] Boolean Indexing

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

Boolean Indexing 은 True/False 의 Series 를 인덱서로 전달 해 행을 선택하는 패턴. pandas 의 가장 흔한 필터링 방법.

mask = df['age'] > 30      # bool Series
df[mask]                    # True 인 행만
df.loc[mask]                # 동등

기본

<CodeWithOutput language=“python” outputLanguage=“text” code={`import pandas as pd df = pd.DataFrame({ ‘name’: [‘Alice’, ‘Bob’, ‘Charlie’, ‘Dave’], ‘age’: [25, 30, 35, 40], })

mask = df[‘age’] >= 30 print(mask.tolist()) print(df[mask])} output={[False, True, True, True] name age 1 Bob 30 2 Charlie 35 3 Dave 40`} />

	name	age
1	Bob	30
2	Charlie	35
3	Dave	40

복합 조건

df[(df['age'] > 25) & (df['age'] < 40)]    # AND
df[(df['city'] == 'Seoul') | (df['city'] == 'Busan')]    # OR
df[~(df['city'] == 'Seoul')]               # NOT

[!IMPORTANT] and / or / not 대신 & / | / ~ 를 써야 한다. Python 키워드는 single boolean 만 처리, pandas 는 array 비교라 비트연산자를 사용. 각 조건은 괄호로 감싼다 (연산자 우선순위 때문).

isin / isna / notna / between

df[df['city'].isin(['Seoul', 'Busan'])]
df[df['age'].notna()]
df[df['age'].isna()]
df[df['age'].between(25, 35)]      # 양쪽 inclusive
df[df['age'].between(25, 35, inclusive='left')]   # [25, 35)

[[Pandas isin / isna]] 참고.

행 + 컬럼 동시 필터

df.loc[df['age'] > 30, 'salary']                 # Series
df.loc[df['age'] > 30, ['name', 'salary']]       # DataFrame
df.loc[df['age'] > 30, 'salary'] = df.loc[df['age'] > 30, 'salary'] * 1.1

조건부 갱신 (where / mask)

df['salary'] = df['salary'].where(df['age'] > 30, df['salary'] * 0.9)
# age > 30 이면 그대로, 아니면 * 0.9

df['salary'] = df['salary'].mask(df['age'] < 25, 0)
# age < 25 인 경우 0 으로

.where 는 조건이 True 면 유지, False 면 치환. .mask 는 반대.

numpy.where 패턴

import numpy as np
df['category'] = np.where(df['age'] > 30, 'senior', 'junior')

벡터화된 if-else, 빠르다.

함정

1. `and` / `or` 사용

df[df['age'] > 25 and df['age'] < 40]    # ❌ ValueError
df[(df['age'] > 25) & (df['age'] < 40)]  # ✓

2. 괄호 빠뜨림

df[df['a'] > 1 & df['b'] > 2]            # ❌ `1 & df['b']` 가 먼저 평가됨
df[(df['a'] > 1) & (df['b'] > 2)]        # ✓

& 가 > 보다 우선순위가 높아서 사고가 자주 난다.

3. SettingWithCopyWarning

sub = df[df['age'] > 30]
sub['new'] = 1     # ⚠️ Warning
# 해법
sub = df[df['age'] > 30].copy()
sub['new'] = 1

4. NaN 의 boolean 처리

mask = df['age'] > 30
# age 가 NaN 인 행 → mask 도 NaN (Falsy 가 아님!)
# 명시적 처리
mask = (df['age'] > 30) & df['age'].notna()

참고

[[Pandas DataFrame]]
[[Pandas .loc / .iloc]]
[[Pandas query]]
[[Pandas isin / isna]]

[Pandas] Categorical

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

Categorical 은 제한된 고유값 만 가질 수 있는 dtype. 내부적으로 정수 코드로 저장되어 메모리 절약 과 속도 향상.

사용

df['city'] = df['city'].astype('category')

# 정렬 가능한 카테고리
df['grade'] = pd.Categorical(df['grade'], categories=['F','D','C','B','A'], ordered=True)

<CodeWithOutput language=“python” outputLanguage=“text” code={`import pandas as pd import numpy as np np.random.seed(0) cities = np.random.choice([‘Seoul’,‘Busan’,‘Daegu’], size=100000) df = pd.DataFrame({‘city’: cities})

mem_object = df.memory_usage(deep=True).sum() df[‘city’] = df[‘city’].astype(‘category’) mem_cat = df.memory_usage(deep=True).sum() print(f’object : {mem_object:>10,} bytes’) print(f’category: {mem_cat:>10,} bytes’) print(f’절감: {(1 - mem_cat/mem_object)*100:.1f}%‘)} output={object : 6,300,128 bytes category: 100,468 bytes 절감: 98.4%`} />

언제 유리한가

고유값이 적고 반복이 많음 (예: 도시 3개 × 100만 행)
groupby / merge / sort 가 더 빠름
명시적 카테고리 순서 가능

언제 비효율

거의 모든 값이 unique (ID, free-form text)
자주 카테고리가 추가됨

ordered categorical

grades = pd.Categorical(
    df['grade'],
    categories=['F','D','C','B','A'],
    ordered=True,
)
df['grade'] = grades

# 비교 연산 가능
df[df['grade'] > 'C']        # 'D' > 'C' 가 False (사전순 아니라 정의 순)

.cat accessor

s = pd.Series(['low','high','med'], dtype='category')
s.cat.categories                # Index(['high', 'low', 'med'])
s.cat.codes                     # 정수 코드 [1, 0, 2]
s.cat.rename_categories(['L','H','M'])
s.cat.add_categories(['extra'])
s.cat.remove_categories(['low'])
s.cat.set_categories(['L','M','H'], ordered=True)

groupby 의 성능

df.groupby('city')['amount'].sum()
# city 가 object → 매번 string 비교
# city 가 category → 정수 비교, 훨씬 빠름

함정

1. category 의 연산

s = pd.Series([1, 2, 3], dtype='category')
s + 10        # ❌ TypeError (category 는 산술 X)
s.astype(int) + 10    # ✓

수치형 데이터는 보통 그대로 두는 것이 자연스러움. category 는 저-cardinality 라벨용.

2. 새 값 할당 시 에러

df['city'] = df['city'].astype('category')
df.loc[0, 'city'] = 'NewCity'    # ❌ (categories 에 없음)

# 해법: add_categories 먼저
df['city'] = df['city'].cat.add_categories('NewCity')
df.loc[0, 'city'] = 'NewCity'    # ✓

3. CSV 저장 시 dtype 소실

df.astype({'city': 'category'}).to_csv('out.csv')
# read_csv 로 다시 읽으면 object 가 됨
# 명시: pd.read_csv('out.csv', dtype={'city': 'category'})

Parquet / Feather 는 dtype 보존.

참고

[[Pandas DataFrame]]

[Pandas] clip / where / mask

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

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})

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

mask

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

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

# salary 가 100k 이상이면 'high', 아니면 NaN
df['tier'] = df['salary'].mask(df['salary'] < 100000, 'low')
df['tier'] = df['salary'].mask(df['salary'] >= 100000, 'high')

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 를 벡터화.

자주 쓰는 패턴

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)

NaN 으로 outlier 마킹

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

조건부 컬럼 생성

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

함정

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 로 강등

참고

[[Pandas Boolean Indexing]]
[[Pandas replace / astype]]

[Pandas] concat

koa (김신건) — Thu, 18 Jun 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]] 과 구분된다.

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

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

index 가 중복됨 (0, 1, 0, 1).

pd.concat([df1, df2], ignore_index=True)
# index 가 0, 1, 2, 3 으로 재생성

가로 연결 (axis=1)

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

컬럼이 다를 때

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' 면 교집합 컬럼만.

keys (계층적 라벨)

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

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

자주 쓰는 패턴

여러 파일을 하나로

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

새 행 추가

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

컬럼 추가 (가로 결합)

pd.concat([df, extra_features], axis=1)

성능

concat 은 전체 결과 메모리를 미리 할당 한 뒤 복사. 큰 데이터를 여러 번 concat 하면 O(n²) 비용 가능.

# ❌ 느림
result = pd.DataFrame()
for df in dfs:
    result = pd.concat([result, df])

# ✓ 한 번에
result = pd.concat(dfs, ignore_index=True)

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

2. dtype 강등

# df1 의 a 는 int, df2 의 a 는 float → 결과는 float
# df1 의 a 는 int, df2 에 NaN 행이 추가 → float 으로 강등

3. 컬럼 순서

# 컬럼 합집합이지만 순서는 첫 DataFrame 우선
pd.concat([df1, df2]).columns
# df1 의 컬럼 순서 + df2 의 새 컬럼 (뒤에)

참고

[[Pandas merge]]
[[Pandas join]]
[[Pandas DataFrame]]

[Pandas] crosstab

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

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

기본 (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 행

crosstab vs pivot_table

항목	crosstab	pivot_table
입력	Series (또는 array)	DataFrame + 컬럼명
기본 aggfunc	count	mean
margins	margins=	margins=
다중 그룹	list 전달	list 전달

기능은 거의 같다. 입력 형태로 선택.

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

자주 만나는 함정

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 도 그룹으로 포함

3. normalize 의 string 값

'index' / 'columns' / 'all' / True / False 만 유효.

참고

[[Pandas groupby]]
[[Pandas pivot]]
[[Pandas pivot_table]]

[Pandas] cumsum / cummax / cummin / cumprod

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

누적 (cumulative) 연산. 각 위치까지의 누적 결과를 반환, 결과 길이는 원본과 동일.

함수	의미
`cumsum()`	누적 합
`cumprod()`	누적 곱
`cummax()`	누적 최댓값
`cummin()`	누적 최솟값
`cumcount()` (groupby)	그룹 내 누적 카운트

사용

DataFrame.cumsum

df.cumsum()              # 각 컬럼별 누적
df.cumsum(axis=1)        # 각 행 누적
df.cumsum(skipna=True)   # NaN 처리

month	sales	cumulative
Jan	100	100
Feb	200	300
Mar	150	450
Apr	300	750

groupby + cumsum

df['user_cumulative'] = df.groupby('user_id')['amount'].cumsum()
# 각 user 의 누적 결제액

cumcount (그룹 내 순번)

df.groupby('user_id').cumcount()
# 각 user 의 0, 1, 2, ... 순번 (첫 결제, 두 번째 결제, ...)

SQL: ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY ...).

expanding 과의 차이

s.cumsum()                 # 시작부터 현재까지 합
s.expanding().sum()         # 같음
s.expanding().mean()        # 누적 평균 (cumsum 으로는 불가능)

cumsum 은 단순 누적, expanding() 은 더 일반적 (mean, std 등 가능).

자주 쓰는 패턴

누적 매출 차트

df['cumulative_revenue'] = df['revenue'].cumsum()
df.plot(x='date', y='cumulative_revenue')

running max (drawdown 계산)

df['peak'] = df['portfolio_value'].cummax()
df['drawdown'] = (df['portfolio_value'] - df['peak']) / df['peak']

누적 비율 (Pareto)

counts = df['category'].value_counts()
cumulative_pct = (counts / counts.sum()).cumsum()
# 상위 N 카테고리가 80% 를 차지하는지

첫 N 명까지의 그룹 통계

df.groupby('cohort').cumcount()

함정

1. NaN 처리

s = pd.Series([1, None, 3])
s.cumsum()                  # [1, NaN, NaN+3=NaN? 아니, [1, NaN, 4]]
# skipna 기본 True, NaN 무시하고 누적
s.cumsum(skipna=False)      # [1, NaN, NaN]

2. 정렬 후 cumsum

df = df.sort_values('date')
df['cum'] = df['amount'].cumsum()    # 시간 순 누적

정렬 안 된 상태에서 누적은 의미가 달라진다.

3. cumprod 의 overflow

df['cumulative_growth'] = (1 + df['return']).cumprod()
# 수치가 너무 작거나 클 경우 부동소수점 오차

참고

[[Pandas rolling]]
[[Pandas groupby]]
[[Pandas shift / diff]]

[Pandas] cut / qcut

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

pd.cut(s, bins) : 값 기반 binning (구간을 직접 지정)
pd.qcut(s, q) : 빈도 기반 binning (분위수로 같은 크기)

연속형 변수를 범주형으로 변환. ML 의 feature engineering, 통계 보고서에 자주 사용.

cut, 값 기반

pd.cut(s, bins=[0, 18, 30, 50, 100])
pd.cut(s, bins=4)                      # 같은 간격 4 구간 자동
pd.cut(s, bins=[0,18,30,50,100], labels=['child','young','adult','senior'])

age	bin
5	child
17	child
25	young
35	adult
55	senior
80	senior

qcut, 빈도 기반

pd.qcut(s, q=4)                       # 4분위 (각 25%)
pd.qcut(s, q=10, labels=False)        # 십분위, 정수 라벨
pd.qcut(s, q=[0, 0.5, 0.9, 1.0])      # 사용자 지정 quantile

각 그룹에 같은 수의 원소.

cut vs qcut 비교

항목	cut	qcut
분할 기준	값 (예: 0~~18, 18~~30)	빈도 (각 25%)
그룹 크기	다를 수 있음	같음 (대략)
적합	절대 기준 (나이, 가격대)	상대 기준 (분위수, 등급)

right / include_lowest

pd.cut(s, bins=[0, 18, 30], right=True)        # (left, right]
pd.cut(s, bins=[0, 18, 30], right=False)       # [left, right)
pd.cut(s, bins=[0, 18, 30], include_lowest=True)   # 가장 작은 구간이 [0, ...]

기본 right=True → (0, 18]. 경계값이 어느 쪽에 들어가는지 명확히.

retbins (bin 경계도 반환)

bins_arr, edges = pd.qcut(s, q=4, retbins=True)
# 새 데이터에 같은 경계 적용 가능
pd.cut(new_s, bins=edges)

결과 활용

# 카테고리 dtype 반환
result = pd.cut(s, bins=[0, 18, 30, 50])
result.dtype                  # CategoricalDtype
result.value_counts()         # 각 구간의 빈도

# 정수 라벨이 필요하면
pd.cut(s, bins=4, labels=False)    # 0, 1, 2, 3

자주 쓰는 패턴

연령대별 통계

df['age_group'] = pd.cut(df['age'], bins=[0, 18, 30, 50, 100],
    labels=['미성년','청년','중년','노년'])
df.groupby('age_group')['spending'].mean()

동일 빈도 분위수 등급

df['percentile'] = pd.qcut(df['score'], q=10, labels=False)
# 0 ~ 9 의 십분위 라벨

사용자 정의 quantile

pd.qcut(df['price'], q=[0, 0.25, 0.5, 0.75, 0.9, 1.0],
    labels=['cheap','low','mid','high','luxury'])

함정

1. NaN 처리

pd.cut(s, bins=...)
# NaN 은 NaN 카테고리로 유지

2. duplicates (qcut)

pd.qcut(s, q=4)
# 데이터가 한 값에 몰려 있으면 quantile 경계 중복 → ValueError
pd.qcut(s, q=4, duplicates='drop')   # 중복 경계 자동 제거

3. labels 의 길이

pd.cut(s, bins=[0, 18, 30, 50], labels=['a','b','c'])
# bins n+1 개, labels n 개
# 잘못 맞추면 ValueError

참고

[[Pandas value_counts]]
[[Pandas Categorical]]
[[Pandas groupby]]

[Pandas] DataFrame

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

생성

	name	age	city
0	Alice	30	Seoul
1	Bob	25	Busan
2	Charlie	35	Seoul

다른 생성 방식

# 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')

핵심 속성

속성	의미
`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.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)              # 삭제 (사본 반환)

행 추가

# Modern pandas
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 리스트 가 반환 타입을 결정.

참고

[[Pandas Overview]]
[[Pandas Series]]
[[Pandas Index]]
[[Pandas read_csv]]

[Pandas] DataFrame.style

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

자주 쓰는 메서드

메서드	효과
`.format(...)`	숫자/날짜 포맷팅
`.applymap(fn)` / `.map(fn)` (2.1+)	셀별 스타일
`.apply(fn, axis=)`	컬럼/행 단위 스타일
`.background_gradient(cmap=)`	색상 그라데이션
`.bar()`	막대 시각화
`.highlight_max(color=)`	최댓값 강조
`.highlight_null()`	NaN 강조
`.set_caption(...)`	제목
`.to_html()` / `.to_excel()`	내보내기

format

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

포맷	의미
`{:.2f}`	소수 2 자리
`{:,.0f}`	천 단위 콤마
`{:.2%}`	백분율
`{:>10}`	우측 정렬 (10 칸)

conditional 색상

df.style.background_gradient(cmap='RdYlGn', subset=['profit'])
# 빨강(낮) → 노랑 → 초록(높)

highlight

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

사용자 정의 스타일

def color_negative(v):
    return 'color: red' if v < 0 else ''

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

apply (행/열 단위)

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

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

bar (셀 안 막대)

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

보고서 내보내기

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

# Excel (서식 포함)
df.style.background_gradient().to_excel('styled.xlsx')

# LaTeX
df.style.to_latex()

자주 쓰는 패턴

매출 보고서

report = monthly.style \
    .format({'sales': '{:,.0f}', 'growth': '{:.1%}'}) \
    .background_gradient(cmap='Greens', subset=['sales']) \
    .applymap(lambda x: 'color: red' if x < 0 else 'color: green',
              subset=['growth']) \
    .highlight_max(subset=['sales'], color='gold')
report.to_excel('monthly_report.xlsx')

결측치 검사

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

percentile 시각화

df.style.bar(color='lightblue', vmin=0, vmax=df.max().max())

함정

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

styled = df.style.format('{:.2f}')
type(styled)        # Styler (not DataFrame)
styled.data         # 원본 DataFrame 접근

2. format 후 Excel 저장 시 dtype

df.style.format('{:.2f}').to_excel('out.xlsx')
# Excel 셀에는 그대로 숫자, 단지 표시 형식만

3. 무거운 스타일

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

참고

[[Pandas DataFrame]]
[[Pandas read_excel]]

[Pandas] date_range / Timestamp

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

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')   # 영업일만

함정

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)

참고

[[Pandas to_datetime]]
[[Pandas dt accessor]]
[[Pandas resample]]

[Pandas] drop_duplicates / duplicated

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

duplicated() : 각 행이 중복인지 boolean Series 반환
drop_duplicates() : 중복 행 제거 후 DataFrame 반환

[[Pandas unique / nunique]] 와는 다르다. 그건 Series 의 고유값 추출, 이건 행 단위 처리.

기본

subset (특정 컬럼만)

df.drop_duplicates(subset=['email'])           # email 기준 중복
df.drop_duplicates(subset=['name', 'phone'])   # 두 컬럼 조합

keep (어느 행을 남길지)

keep	동작
`'first'` (기본)	첫 등장 유지
`'last'`	마지막 등장 유지
`False`	모든 중복 제거 (단일 등장만 남김)

df.drop_duplicates(keep='first')
df.drop_duplicates(keep='last')
df.drop_duplicates(keep=False)   # 단 한 번만 나오는 행만

duplicated 활용

df[df.duplicated()]                   # 중복 행만
df[df.duplicated(keep=False)]         # 중복된 모든 행 (원본 포함)
df['is_dup'] = df.duplicated('email')  # boolean 컬럼 추가
df.duplicated().sum()                  # 중복 행 개수

index 다루기

df.drop_duplicates()                  # 원래 index 유지
df.drop_duplicates().reset_index(drop=True)   # 0,1,2,... 재배치

그룹별 첫 번째 / 마지막 행

drop_duplicates 는 빠른 그룹별 첫/마지막 선택 idiom.

# 각 user 의 가장 최근 주문
df.sort_values('date', ascending=False).drop_duplicates('user_id')

# 각 user 의 첫 주문
df.sort_values('date').drop_duplicates('user_id')

groupby('user_id').head(1) 보다 약간 빠를 때가 있다.

SQL 비교

-- DISTINCT
SELECT DISTINCT name, age FROM table
-- pandas: df[['name','age']].drop_duplicates()

-- 중복 제거 후 첫 번째 (window function)
SELECT * FROM table
WHERE id IN (
  SELECT MIN(id) FROM table GROUP BY user_id
)
-- pandas: df.sort_values('id').drop_duplicates('user_id')

함정

1. NaN 의 중복 처리

df = pd.DataFrame({'x': [1, 1, None, None]})
df.duplicated()       # [False, True, False, True]
# NaN == NaN 이 일반적으로 False 인데, duplicated 는 NaN 도 같은 것으로 취급

2. 컬럼 순서

df.drop_duplicates(['a', 'b'])     # (a, b) 조합으로 비교
df.drop_duplicates(['b', 'a'])     # 결과는 같음, 순서 무관

3. inplace=True 의 함정

df.drop_duplicates(inplace=True)   # 옛 코드
df = df.drop_duplicates()           # 권장 (명시성)

참고

[[Pandas unique / nunique]]
[[Pandas value_counts]]
[[Pandas DataFrame]]

[Pandas] dropna / fillna

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

dropna() : NaN 이 있는 행/열 제거
fillna() : NaN 을 특정 값으로 대체

데이터 분석의 가장 기본적인 결측치 처리.

dropna 기본

df.dropna()                    # 어느 컬럼이든 NaN 있는 행 제거
df.dropna(how='all')           # 모든 컬럼이 NaN 인 행만
df.dropna(subset=['col1'])      # 특정 컬럼만 검사
df.dropna(axis=1)              # NaN 있는 열 제거
df.dropna(thresh=3)            # NaN 이 아닌 값이 3 개 이상인 행만

fillna 기본

df.fillna(0)                     # 모든 NaN → 0
df.fillna({'a': 0, 'b': 'unknown'})  # 컬럼별 다른 값
df.fillna(method='ffill')         # forward fill (이전 값으로)
df.fillna(method='bfill')         # backward fill (다음 값으로)
df['salary'].fillna(df['salary'].mean())   # 평균으로

[!IMPORTANT] pandas 2.2+ 에서 method='ffill' / 'bfill' 는 deprecated. 새 코드는 df.ffill(), df.bfill() 직접 호출 권장.

ffill / bfill 시각화

index	original	ffill	bfill
0	1.0	1.0	1.0
1	NaN	1.0	4.0
2	NaN	1.0	4.0
3	4.0	4.0	4.0
4	NaN	4.0	6.0
5	6.0	6.0	6.0

컬럼별 다양한 전략

# 수치형은 평균, 범주형은 'unknown'
fills = {
    'age': df['age'].mean(),
    'salary': df['salary'].median(),
    'city': 'unknown',
    'note': '',
}
df = df.fillna(fills)

groupby + fillna (그룹 평균으로 채우기)

df['salary'] = df.groupby('dept')['salary'].transform(
    lambda s: s.fillna(s.mean())
)

각 부서의 평균으로 그 부서의 NaN 채우기.

함정

1. dropna 가 너무 공격적

df.dropna()           # 어느 컬럼이든 NaN 있으면 제거 → 행이 거의 안 남을 수 있음
df.dropna(subset=['중요컬럼'])   # 그 컬럼만 검사

2. inplace=True 의 안 좋은 습관

df.dropna(inplace=True)        # 권장 안 함
df = df.dropna()               # ✓ 명시적

3. fillna 의 한계

df['age'].fillna(df['age'].mean())
# NaN 비율이 높으면 평균이 의미를 잃음
# 더 정교한 imputation 은 scikit-learn 의 SimpleImputer, KNNImputer 등

4. NA dtype 의 처리

pandas 1.x+ 의 nullable dtype (Int64, boolean 등) 에서는 np.nan 대신 pd.NA 가 사용됨. fillna(0) 은 둘 다 처리.

참고

[[Pandas isin / isna]]
[[Pandas interpolate]]
[[Pandas groupby]]

[Pandas] expanding / ewm

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

[[Pandas rolling]] 외의 윈도우 연산.

expanding() : 시작부터 현재까지 누적 윈도우
ewm() : exponentially weighted (지수 가중)

expanding

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

index	s	expanding mean
0	10	10
1	20	15
2	30	20
3	40	25
4	50	30

rolling 과 달리 윈도우 크기가 무한히 커진다.

ewm, 지수 가중

s.ewm(alpha=0.3).mean()
s.ewm(span=10).mean()
s.ewm(halflife=5).mean()
s.ewm(com=4).mean()

파라미터	의미
`alpha`	직접 가중치 (0 < α ≤ 1)
`span`	평균적 윈도우 크기 (α = 2/(span+1))
`halflife`	가중치가 절반이 되는 거리
`com`	center of mass (α = 1/(1+com))

alpha 가 클수록 최근 값에 가중.

span=3 이 작아서 최근 값에 더 빨리 반응, span=7 은 smoother.

ewm 의 수식

$$ y_t = \alpha \cdot x_t + (1 - \alpha) \cdot y_{t-1} $$

지수 감쇠 가중. 모든 과거 값을 고려하지만 가중치가 지수적으로 감소.

rolling vs expanding vs ewm

항목	윈도우	가중치
`rolling(n)`	고정 n	같음
`expanding()`	1 → ∞	같음
`ewm(span=n)`	사실상 무한	지수 감쇠

자주 쓰는 패턴

누적 평균 / 표준편차

df['avg_so_far'] = df['x'].expanding().mean()
df['std_so_far'] = df['x'].expanding().std()

ML 의 online 통계, 게임 점수 누적 평균 등.

지수 이동 평균 (EMA)

df['ema_short'] = df['close'].ewm(span=12, adjust=False).mean()
df['ema_long'] = df['close'].ewm(span=26, adjust=False).mean()
df['macd'] = df['ema_short'] - df['ema_long']

금융 지표 MACD.

Bollinger Bands

ma = df['close'].rolling(20).mean()
std = df['close'].rolling(20).std()
df['upper'] = ma + 2 * std
df['lower'] = ma - 2 * std

(rolling 기반)

시계열 smoothing

df['smoothed'] = df['signal'].ewm(span=10).mean()
# noise 줄이기

adjust 옵션

s.ewm(span=3, adjust=True).mean()    # 기본, 더 정확한 평균
s.ewm(span=3, adjust=False).mean()   # 재귀식 사용 (online 계산용)

adjust=True : 시작 부분의 가중치도 보정
adjust=False : 단순 재귀 (실시간 처리에 적합)

함정

1. expanding 의 첫 N 개

s.expanding(min_periods=5).std()
# 처음 4 개는 NaN

표본 크기가 작으면 표준편차가 불안정.

2. ewm 의 가중치 합

adjust=False 면 초기 가중치 합이 1 미만, bias 발생 가능.

3. groupby 결합

df['ema'] = df.groupby('user')['x'].transform(
    lambda s: s.ewm(span=10).mean()
)

apply 보다 transform 권장 (원본 shape 유지).

참고

[[Pandas rolling]]
[[Pandas cumulative]]
[[Pandas resample]]

[Pandas] explode

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

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

기본

user	tags
Alice	py
Alice	pandas
Bob	py
Charlie	go
Charlie	rust
Charlie	ts

같은 index 가 반복됨. 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

str.split + explode

문자열을 list 로 분리 후 explode 가 흔한 idiom.

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

groupby 의 역연산

# group → list
df.groupby('user').agg({'tag': list})
# list → row (explode)
df_grouped.explode('tag')

자주 쓰는 패턴

1. JSON 의 배열 펼치기

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

2. tags 분석

df = pd.DataFrame({
    'post_id': [1, 2, 3],
    'tags': ['python,pandas,data', 'python', 'go,rust'],
})
exploded = df.assign(tag=df['tags'].str.split(',')).explode('tag')
exploded['tag'].value_counts()
# 가장 인기있는 태그

3. 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')

함정

1. index 중복

df.explode('tags')             # index 가 0, 0, 1, 2, 2, 2
df.explode('tags').reset_index(drop=True)   # 0, 1, 2, ...

2. dtype 강등

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

3. 컬럼이 list 가 아니면 unchange

df = pd.DataFrame({'x': [1, 2, 3]})
df.explode('x')             # 그대로

참고

[[Pandas str regex]]
[[Pandas melt]]
[[Pandas groupby]]

[Pandas] get_dummies / from_dummies

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

pd.get_dummies(df) 는 범주형 컬럼을 원-핫 인코딩 (one-hot encoding). ML 전처리의 가장 흔한 단계.

기본

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

drop_first

pd.get_dummies(df['city'], drop_first=True)
# 첫 카테고리 제거 (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)
# 희소 행렬, 메모리 크게 절약 (특히 카테고리 多)

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)
간편성	✓	△

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

자주 쓰는 패턴

학습 / 테스트 일관성 유지

# 학습 시 카테고리 저장
train_cols = pd.get_dummies(train_df).columns

# 테스트 시 같은 컬럼으로 reindex
test_encoded = pd.get_dummies(test_df).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 에 적합.

함정

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

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

ID 같은 high-cardinality 컬럼은 인코딩하지 말 것.

2. NaN 처리

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

기본은 NaN 행에 모두 0.

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

위의 reindex 패턴이 표준 해결.

참고

[[Pandas Categorical]]
[[Pandas replace / astype]]
[[Pandas mode / factorize]]

[Pandas] groupby

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

DataFrame.groupby(key) 는 데이터를 그룹으로 나누고 (split), 각 그룹에 함수를 적용 (apply), 결과를 합쳐 (combine) 새 DataFrame 으로 만드는 split-apply-combine 패턴의 구현.

SQL 의 GROUP BY 와 같은 개념, 더 풍부한 API.

시각화

{}

기본

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

city	salary mean
Busan	4250.00
Seoul	3833.33

여러 컬럼 그룹

df.groupby(['city', 'dept'])['salary'].mean()

결과는 MultiIndex Series. .reset_index() 또는 .unstack() 으로 평탄화.

agg 로 여러 함수

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

[[Pandas agg]] 참고.

자주 쓰는 메서드

메서드	의미
`.sum()`, `.mean()`, `.median()`, `.std()`	통계
`.min()`, `.max()`	극값
`.count()`	non-null 개수
`.size()`	그룹별 행 수 (NaN 포함)
`.first()`, `.last()`, `.nth(i)`	위치 기반
`.head(n)`, `.tail(n)`	그룹 내 상위/하위 N
`.cumsum()`, `.cumcount()`	누적
`.transform(fn)`	그룹별 변환, 원본 shape 유지
`.apply(fn)`	임의 함수, 가장 유연
`.filter(fn)`	그룹 단위 필터

groupby 결과는 lazy

g = df.groupby('city')      # GroupBy 객체만, 아직 계산 안 함
g.groups                     # {'Seoul': [0, 2, 4], 'Busan': [1, 3]}
g.get_group('Seoul')         # 한 그룹의 DataFrame
list(g)                      # [(name, df), ...]

명시적으로 집계 함수를 호출해야 계산 발생.

그룹별 정렬 후 head (top N per group)

df.sort_values(['city', 'salary'], ascending=[True, False]) \
   .groupby('city').head(2)

각 city 별 salary 상위 2 명.

그룹별 정규화 (transform)

df['salary_z'] = df.groupby('dept')['salary'].transform(
    lambda x: (x - x.mean()) / x.std()
)

각 부서 내에서 z-score, 원본 DataFrame 의 shape 유지.

함정

1. as_index 의 의미

df.groupby('city')['salary'].mean()             # MultiIndex Series
df.groupby('city', as_index=False)['salary'].mean()   # DataFrame, city 가 컬럼

2. NaN 그룹

기본은 NaN 그룹 제외. dropna=False 로 포함 가능.

df.groupby('city', dropna=False)['salary'].mean()

3. groupby + apply 의 느림

df.groupby('x').apply(complex_function)
# apply 는 가장 느림, 가능하면 agg / transform / 벡터 연산

4. SettingWithCopyWarning

group = df.groupby('city').get_group('Seoul')
group['new'] = 1     # ⚠️
group = group.copy()

참고

[[Pandas DataFrame]]
[[Pandas agg]]
[[Pandas transform / apply]]
[[Pandas pivot_table]]

[Pandas] idxmax / idxmin

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

idxmax() : 최댓값의 index 라벨 반환
idxmin() : 최솟값의 index 라벨

max(), min() 이 값 을 반환한다면 이 함수들은 위치 를 반환. SQL 에서 “max 인 행의 다른 컬럼” 을 가져올 때 idiom.

기본

label index ‘b’ 가 최댓값의 위치.

DataFrame.idxmax (각 컬럼 / 행)

df.idxmax()              # 각 컬럼의 최댓값 행 label (default axis=0)
df.idxmax(axis=1)        # 각 행의 최댓값 컬럼 label

자주 쓰는 패턴

1. max 값을 가진 행 전체 가져오기

df.loc[df['salary'].idxmax()]
# salary 가 최대인 행 (Series)

2. groupby 의 각 그룹 최댓값 행

df.loc[df.groupby('city')['salary'].idxmax()]
# 각 도시의 최고 연봉자 행 전체

이게 SQL 의 SELECT * FROM t WHERE (city, salary) IN (SELECT city, MAX(salary) FROM t GROUP BY city) 패턴.

3. 가장 자주 등장하는 값

df['category'].value_counts().idxmax()
# 또는 df['category'].mode().iloc[0]

NaN 처리

s = pd.Series([1, None, 3])
s.idxmax()                  # NaN 자동 skip → 3 의 index
s.idxmax(skipna=False)      # NaN 있으면 에러 또는 NaN 반환

numpy argmax 와의 비교

함수	반환	NaN 처리
`np.argmax(arr)`	정수 위치	NaN 도 비교
`s.idxmax()`	index 라벨	NaN skip
`s.argmax()`	정수 위치	NaN skip (pandas 0.25+)

s.idxmax() 가 라벨 기반이라 .loc[] 와 즉시 호환된다.

함정

1. 모두 NaN 이면

pd.Series([None, None]).idxmax()
# ValueError 또는 NaN

2. 동률

pd.Series([1, 1, 1]).idxmax()
# 0 (첫 번째)

여러 개가 최대면 첫 등장 위치 만 반환.

3. 빈 Series

pd.Series([], dtype=float).idxmax()    # ValueError

참고

[[Pandas Series]]
[[Pandas mode / factorize]]
[[Pandas groupby]]

[Pandas] Index

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

pandas.Index 는 행 / 열 라벨을 보관하는 객체. [[Pandas Series]] / [[Pandas DataFrame]] 의 모든 라벨은 Index. 정렬, 정합성, 빠른 lookup 의 기반.

기본은 RangeIndex (0, 1, 2, …) 지만 set_index 로 임의 열을 index 로 승격 가능.

종류

종류	용도
RangeIndex	기본 0-based 정수
Int64Index	임의 정수
Index (object)	문자열 / 혼합 타입
DatetimeIndex	시계열
PeriodIndex	기간 (`2024-Q1`)
TimedeltaIndex	시간 차이
[[Pandas MultiIndex]]	계층형 (multi-level)
CategoricalIndex	범주형
IntervalIndex	구간 (bin)

자주 쓰는 동작

set_index / reset_index

정렬

df.sort_index()                # index 기준 정렬
df.sort_index(axis=1)          # 열 이름 기준 정렬
df.reindex(['c', 'a', 'b'])    # 명시적 재배치 (없으면 NaN)

이름 부여

df.index.name = 'id'
df.columns.name = 'feature'

정합성 자동 정렬

a = pd.Series([1, 2, 3], index=['x', 'y', 'z'])
b = pd.Series([10, 20], index=['y', 'z'])
print(a + b)
# x     NaN
# y    12.0
# z    23.0

연산 시 같은 index 끼리만 매칭. 없는 곳은 NaN.

고유성

기본 Index 는 중복 허용. 그러나 lookup 효율과 의미상 unique 권장.

df.index.is_unique     # True / False
df.index.duplicated()  # 중복 위치 boolean

MultiIndex (간단 소개)

df = pd.DataFrame(
    {'sales': [100, 200, 150, 300]},
    index=pd.MultiIndex.from_tuples(
        [('Q1', 'Seoul'), ('Q1', 'Busan'),
         ('Q2', 'Seoul'), ('Q2', 'Busan')],
        names=['quarter', 'city']
    )
)

자세한 내용은 [[Pandas MultiIndex]] 참고.

자주 만나는 함정

1. 정수 index 의 .loc

s = pd.Series([10, 20, 30], index=[5, 6, 7])
s.loc[5]      # label 5 → 10
s.iloc[5]     # IndexError (위치 5 없음)
s[5]          # label 5 → 10 (deprecated 경고 가능)

label 과 위치를 명확히 구분.

2. set_index 후 원본 컬럼 사라짐

df2 = df.set_index('name')
# df2 에는 'name' 컬럼이 없음, df2.index 가 'name'

원래대로 돌리려면 reset_index().

참고

[[Pandas Series]]
[[Pandas DataFrame]]
[[Pandas MultiIndex]]

[Pandas] info / memory_usage / describe

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

DataFrame 의 메타데이터 / 메모리 / 통계를 빠르게 조회하는 도구.

메서드	목적
`df.info()`	컬럼별 dtype + non-null count + 메모리
`df.memory_usage(deep=True)`	컬럼별 정확한 메모리
`df.describe()`	수치형 통계 (count, mean, std, percentile)
`df.shape`	(rows, cols)
`df.dtypes`	컬럼별 dtype
`df.head()`, `df.tail()`	상/하 5 개
`df.sample()`	무작위
`df.nunique()`	컬럼별 unique 수

info

df.info()
df.info(memory_usage='deep')   # object 컬럼 정확히

<CodeWithOutput language=“python” outputLanguage=“text” code={import pandas as pd df = pd.DataFrame({ 'name': ['Alice','Bob','Charlie'], 'age': [30, 25, 35], 'city': ['Seoul','Busan','Seoul'], }) df.info()} output={`<class ‘pandas.core.frame.DataFrame’> RangeIndex: 3 entries, 0 to 2 Data columns (total 3 columns):

Column Non-Null Count Dtype

0 name 3 non-null object 1 age 3 non-null int64 2 city 3 non-null object dtypes: int64(1), object(2) memory usage: 200.0+ bytes`} />

memory_usage

df.memory_usage()                # 컬럼별 (object 부정확)
df.memory_usage(deep=True)       # object 의 Python str 까지 계산
df.memory_usage(deep=True).sum()  # 전체

object (string) 컬럼이 큰 차이를 만든다.

describe

df.describe()                          # 수치형만, 8 가지 통계
df.describe(include='object')          # 문자형
df.describe(include='all')             # 전체
df.describe(percentiles=[.25, .5, .75, .95, .99])
df.describe(datetime_is_numeric=True)  # 날짜

info 의 메모리 정보

200.0+ bytes 의 + : object 컬럼 정확도 보장 안 됨
memory_usage='deep' 시 + 사라짐

자주 쓰는 탐색 시퀀스

df = pd.read_csv('data.csv')
df.shape                                    # 크기
df.head(20)                                  # 어떻게 생겼는지
df.info(memory_usage='deep')                 # dtype + 메모리
df.describe()                                # 수치형
df.describe(include='object')                # 문자형
df.isna().sum()                              # 결측 수
df.nunique()                                 # unique 수
df.duplicated().sum()                        # 중복 행
df.select_dtypes('number').corr()            # 상관관계

메모리 절약 빠른 체크

def memory_report(df):
    mem = df.memory_usage(deep=True)
    pct = (mem / mem.sum() * 100).round(1)
    return pd.DataFrame({'bytes': mem, 'pct': pct, 'dtype': df.dtypes})
memory_report(df)

어느 컬럼이 메모리 hog 인지 즉시 파악.

profiling

탐색을 자동화하는 라이브러리.

# pip install ydata-profiling
from ydata_profiling import ProfileReport
ProfileReport(df).to_file('report.html')

EDA 자동화. 대규모 데이터는 sample 후 사용.

함정

1. memory_usage 의 inaccuracy

object dtype 은 deep=True 없이는 정확하지 않다. 항상 deep=True 권장.

2. describe 의 default

df.describe()        # numeric 만 (기본)
df.describe(include='all')   # 모든 컬럼

object 컬럼이 분석 대상이면 include 명시.

3. info 의 `+` 의 의미

df.info()
# memory usage: 5.0+ MB    ← + 는 deep 안 계산했다는 표시
df.info(memory_usage='deep')
# memory usage: 12.3 MB    ← 정확

참고

[[Pandas DataFrame]]
[[Pandas 성능 / 메모리 최적화]]
[[Pandas value_counts]]

[Pandas] interpolate

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

interpolate() 는 NaN 을 주변 값을 사용해 보간 으로 채운다. 시계열, 측정 데이터의 작은 결측을 자연스럽게 채울 때 유용.

기본

s.interpolate()                       # 기본 linear
s.interpolate(method='polynomial', order=2)
s.interpolate(method='time')          # index 가 DatetimeIndex 일 때
s.interpolate(method='spline', order=3)

linear 보간 예

index	original	interpolate
0	1.0	1.0
1	NaN	2.0
2	NaN	3.0
3	4.0	4.0
4	NaN	5.0
5	6.0	6.0

1 → 4 사이의 NaN 2 개를 직선 보간으로 2, 3 으로 채움.

다양한 method

method	설명
`linear` (기본)	직선 보간
`time`	시간 간격 가중 (DatetimeIndex 필요)
`index`	index 값을 X축으로
`nearest`	가장 가까운 값
`polynomial`	다항식 (order 필요)
`spline`	스플라인 (order 필요, scipy 의존)
`pchip`, `akima`	비단조 스플라인
`from_derivatives`	기울기 기반

time-based 보간

ts = pd.Series([1, np.nan, np.nan, 10],
    index=pd.date_range('2024-01-01', periods=4, freq='D'))
ts.interpolate()                # 균등 간격 가정 → [1, 4, 7, 10]
ts.interpolate(method='time')    # 같은 결과 (간격이 균일하므로)

# 불균등 시계열
ts2 = pd.Series([1, np.nan, 10],
    index=pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-10']))
ts2.interpolate()                # 균등 가정 → [1, 5.5, 10]
ts2.interpolate(method='time')    # 시간 거리 가중 → [1, 2.0, 10]

time method 가 실제 거리 기반이라 더 자연스럽다.

양 끝의 NaN

s = pd.Series([np.nan, np.nan, 1, 2, np.nan, np.nan])
s.interpolate()
# [NaN, NaN, 1.0, 2.0, NaN, NaN]  ← 양 끝은 못 채움
s.interpolate(limit_direction='both')
# [1.0, 1.0, 1.0, 2.0, 2.0, 2.0]

limit_direction='backward' / 'forward' / 'both' 로 한 방향 채우기 가능.

limit (연속 NaN 개수 제한)

s.interpolate(limit=2)
# 연속 NaN 2 개까지만 채움, 그 이상은 NaN 유지

사용 시 주의

1. 잘못된 method 선택

outlier 가 많은 경우: linear 가 outlier 사이로 보간해 이상해질 수 있음
시계열: time method 가 더 자연스러움 (불규칙 간격)
곡선 트렌드: spline 또는 polynomial

2. interpolate 가 만능은 아님

# 연속 NaN 이 너무 많을 때
[1, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, 10]
# linear 보간하면 너무 큰 가정

데이터 특성에 따라 보간 자체가 부적절할 수 있음.

3. method=‘time’ 인데 datetime index 아님 → 오류

s.interpolate(method='time')   # TypeError if not DatetimeIndex

참고

[[Pandas dropna / fillna]]
[[Pandas to_datetime]]

[Pandas] isin / isna / notna

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

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

isin

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

	name	city
0	Alice	Seoul
1	Bob	Busan
3	Dave	Seoul

부정 (NOT IN)

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

dict / DataFrame 전달

df.isin({'city': ['Seoul'], 'name': ['Alice']})
# 컬럼별로 다른 set

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, None, NaT 의 차이

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

.isna() 는 위 모두를 True 로 본다.

함정

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 인지 검사
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])                  # ✓

참고

[[Pandas Boolean Indexing]]
[[Pandas dropna / fillna]]
[[Pandas query]]

[Pandas] iterrows / itertuples

koa (김신건) — Thu, 18 Jun 2026 00:00:00 GMT

정의

iterrows() : (index, Series) 순회
itertuples() : NamedTuple 순회 (빠름, 권장)
items() : (column_name, Series) 순회

기본

for idx, row in df.iterrows():
    print(idx, row['name'], row['age'])

for row in df.itertuples():
    print(row.Index, row.name, row.age)

성능 비교 (강한 권고: 가능하면 벡터 연산)

itertuples 가 iterrows 보다 ~20 배 빠르고, 벡터 연산은 다시 그 200 배 빠르다.

[!IMPORTANT] 거의 모든 경우 iterrows / itertuples 를 피하라. 벡터 연산 / apply / np.where / groupby 로 같은 결과를 만들 수 있는지 먼저 검토. 정 필요하면 itertuples.

itertuples 옵션

df.itertuples()                # NamedTuple with Index
df.itertuples(index=False)     # Index 제거
df.itertuples(name='Row')      # NamedTuple 이름 지정

iterrows 의 함정

1. dtype 손실

iterrows 는 각 행을 Series 로 반환. 같은 컬럼이 다른 dtype 이면 모두 object 로 강등.

for _, r in df.iterrows():
    type(r['age'])    # 원래 int 였어도 object 일 수 있음

itertuples 는 컬럼별 dtype 보존.

2. row 수정해도 원본에 반영 안 됨

for _, r in df.iterrows():
    r['age'] = r['age'] + 1     # ❌ 원본 df 안 바뀜

3. 매우 느림

CPython 루프 + Series 생성 비용.

items, 컬럼 순회

for name, col in df.items():
    print(name, col.dtype, col.sum())

이건 보통 빠르고 의미가 명확.

진짜로 행 단위 처리가 필요할 때

apply(fn, axis=1) : iterrows 보다 빠름
itertuples() : 가장 빠른 Python 루프
numpy / numba / cython : 더 빠르게

# apply
df['c'] = df.apply(lambda r: r['a'] + r['b'], axis=1)

# numpy 벡터화 (가장 빠름)
df['c'] = df['a'].values + df['b'].values

# 한 번의 함수가 모든 입력을 받게
@np.vectorize
def my_fn(a, b):
    return a + b
df['c'] = my_fn(df['a'], df['b'])

그래도 iterrows 가 필요한 경우

API 가 dict / NamedTuple 입력을 요구
디버깅 / 한 번만 도는 작은 데이터
외부 시스템에 한 행씩 전송

참고

[[Pandas apply / map]]
[[Pandas 성능 / 메모리 최적화]]

김신건의 로그 - 위키 / pandas

[Pandas] pipe / method chaining

정의

문제: 중간 변수 남발

pipe 로 chain

왜 좋은가

함정

참고

[Pandas] .at / .iat

정의

사용

.loc / .iloc 와의 차이

벤치마크 감

사용 예

행/열 단일 셀 값 수정

마지막 행의 특정 컬럼

함정

1. 슬라이스 / 리스트 불가

2. 존재하지 않는 라벨 → KeyError

3. dtype 변경

참고

[Pandas] .dt accessor

정의

기본 컴포넌트

사용

포맷 변환

timezone

Timedelta 의 dt

자주 쓰는 패턴

월별 분석

요일별 트렌드

영업일 / 주말

datetime 차이

함정

1. dt 가 안 되는 경우

2. tz-aware vs naive 비교

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

참고

[Pandas] .loc / .iloc

정의

기본 비교

슬라이싱 (가장 중요한 차이)

행 + 열 동시 선택

boolean mask 와 결합

값 할당

함정

1. boolean mask 에 .iloc 사용 불가

2. SettingWithCopyWarning

3. 정수 index 의 모호함

4. 단일 row 의 반환 타입

참고

[Pandas] .str accessor

정의

기본 메서드

기본 사용

chaining

새 컬럼 분리

get / getitem

category 자동 보존

함정

1. NaN 의 비교

2. 정규식의 escape

3. 모든 문자열을 str 로 캐스트

참고

[Pandas] agg / aggregate

정의

다양한 형태

단일 함수

함수 리스트

컬럼별 다른 함수

groupby + agg

named aggregation (이름 있는 집계)

람다 / 사용자 함수

자주 쓰는 집계 함수 모음

함정

1. MultiIndex 컬럼

2. 함수 이름의 충돌

3. groupby + agg 의 dropna

참고

[Pandas] apply / map

1. boolean mask 에 `.iloc` 사용 불가

1. `and` / `or` 사용