Pandas 3.0 완벽 가이드: Copy-on-Write, 새 문자열 타입, pd.col 표현식 총정리

서론: pandas 3.0 — 드디어 왔다, 새로운 시대

2026년 1월 21일, 드디어 pandas 3.0.0이 공식 릴리스되었습니다. 솔직히 말해서, 이번 업데이트를 꽤 오래 기다려왔거든요. pandas 2.0이 2023년 4월에 나온 이후 약 3년 만의 메이저 업그레이드인데, 이번엔 단순한 기능 추가 수준이 아닙니다. 라이브러리의 근본적인 동작 방식 자체가 바뀌었어요.

핵심 변화를 세 줄로 요약하면 이렇습니다.

첫째, Copy-on-Write(CoW)가 기본 동작이 되면서, 그 악명 높던 SettingWithCopyWarning이 역사 속으로 사라졌습니다. 둘째, 새로운 문자열 데이터 타입이 기본으로 적용되어 문자열 처리 속도가 비약적으로 빨라졌고요. 셋째, pd.col() 표현식이 등장해서 DataFrame 코드가 훨씬 깔끔해졌습니다. 이 외에도 날짜/시간 해상도 변경, Arrow PyCapsule 인터페이스 같은 굵직한 변화들이 있습니다.

그럼 하나씩 살펴보겠습니다.

Copy-on-Write (CoW) — 가장 중요한 변화

Copy-on-Write란?

Copy-on-Write(CoW)는 pandas 3.0에서 기본이자 유일한 동작 모드가 된 메모리 관리 전략입니다. 원칙은 의외로 간단해요. 인덱싱이나 메서드로 반환된 DataFrame 또는 Series는 항상 원본의 복사본처럼 동작하되, 실제 메모리 복사는 데이터가 수정될 때만 일어납니다.

PDEP-7을 통해 공식 승인된 이 변경은, pandas의 오래된 골칫거리였던 뷰(view)와 복사(copy) 동작의 불일치를 근본적으로 해결합니다.

CoW가 해결하는 문제

pandas 2.x 이하에서는 DataFrame의 부분집합을 가져올 때, 결과가 원본의 뷰인지 복사본인지 예측하기가 정말 어려웠습니다. 저도 이 때문에 수없이 고생했는데요. 결국 많은 개발자들이 방어적으로 .copy()를 호출하는 습관이 생길 수밖에 없었죠.

# pandas 2.x에서의 문제 상황
import pandas as pd

df = pd.DataFrame({"foo": [1, 2, 3], "bar": [10, 20, 30]})

# 이 코드가 원본 df를 수정할지 안 할지 예측 불가능
subset = df[df["bar"] > 10]
subset["foo"] = 999  # SettingWithCopyWarning 발생!

# 방어적 .copy() 호출이 필수적이었음
subset = df[df["bar"] > 10].copy()
subset["foo"] = 999  # 이제야 안전

CoW의 동작 방식

pandas 3.0에서는 모든 인덱싱 연산이 복사본처럼 동작합니다. 반환된 객체를 수정해도 원본에 영향을 주지 않아요. 내부적으로는 가능한 한 뷰를 활용해서 메모리 효율을 유지하고, 실제로 데이터를 수정하는 시점에만 복사가 발생합니다.

import pandas as pd

df = pd.DataFrame({"foo": [1, 2, 3], "bar": [10, 20, 30]})

# pandas 3.0: subset은 항상 복사본처럼 동작
subset = df[df["bar"] > 10]
subset["foo"] = 999

print(df)
# 원본 df는 변경되지 않음
#    foo  bar
# 0    1   10
# 1    2   20
# 2    3   30

# 방어적 .copy() 호출이 더 이상 필요 없음!

이거 하나만으로도 업그레이드할 가치가 있다고 생각합니다.

체인 할당(Chained Assignment)의 폐지

CoW 도입으로 체인 할당이 더 이상 작동하지 않습니다. 이전에는 두 단계의 인덱싱으로 값을 수정할 수 있었지만(솔직히 그때도 되는지 안 되는지 불확실했죠), 이제는 반드시 단일 단계 인덱싱을 써야 합니다.

import pandas as pd

df = pd.DataFrame({"foo": [1, 2, 3], "bar": [4, 6, 8]})

# ===== 이전 방식 (pandas 2.x) — 더 이상 작동하지 않음 =====
df["foo"][df["bar"] > 5] = 100  # 원본이 수정되지 않음!

# ===== 새로운 방식 (pandas 3.0) — 올바른 코드 =====
df.loc[df["bar"] > 5, "foo"] = 100  # 정상 작동

print(df)
#    foo  bar
# 0    1    4
# 1  100    6
# 2  100    8

SettingWithCopyWarning은 pandas 3.0에서 완전히 제거되었습니다. 더 이상 모호한 상황 자체가 없으니까요.

성능 이점

CoW의 진짜 강점은 성능 최적화에 있습니다. 예전에는 안전을 위해 불필요한 복사가 많이 일어났는데, 이제는 내부적으로 뷰를 최대한 활용하고 실제 수정이 필요할 때만 복사해요. 대규모 데이터를 다루는 ETL 파이프라인에서 효과가 특히 큽니다.

한 가지 인상적인 사례를 소개하자면, 어떤 데이터 엔지니어링 팀이 기존 ETL 파이프라인을 pandas 3.0으로 올린 후 실행 시간이 45분에서 28분으로 줄었다고 합니다. 약 38% 성능 향상인데, 코드 수정 없이 라이브러리 업그레이드만으로 달성한 결과라니 놀랍지 않나요?

import pandas as pd
import time

# 대규모 DataFrame 생성
df = pd.DataFrame({
    "id": range(1_000_000),
    "value": range(1_000_000),
    "category": ["A", "B", "C", "D"] * 250_000
})

start = time.time()

# pandas 3.0에서는 불필요한 복사가 발생하지 않아 빠름
for col in ["value", "category"]:
    subset = df[[col]]  # 내부적으로 뷰 활용
    # subset을 수정하지 않으면 실제 복사가 발생하지 않음

elapsed = time.time() - start
print(f"소요 시간: {elapsed:.4f}초")

새로운 문자열 데이터 타입

기존 문제: object dtype의 한계

pandas 2.x까지 문자열 데이터는 object dtype으로 저장되었습니다. 이건 사실 Python 객체 포인터의 배열이라서, 문자열뿐만 아니라 정수든 리스트든 뭐든 담을 수 있는 범용 컨테이너였어요. 당연히 타입 안전성은 기대할 수 없었고, 메모리 효율이나 연산 속도 면에서도 최적화가 거의 불가능한 구조였습니다.

새로운 str dtype

pandas 3.0부터는 문자열 데이터가 자동으로 전용 str dtype으로 추론됩니다. 내부적으로 PyArrow가 설치되어 있으면 PyArrow 백엔드를, 없으면 NumPy object dtype으로 폴백하는 구조예요.

import pandas as pd

# ===== pandas 2.x 동작 =====
ser = pd.Series(["hello", "world"])
print(ser.dtype)  # object

# ===== pandas 3.0 동작 =====
ser = pd.Series(["hello", "world"])
print(ser.dtype)  # str

# DataFrame에서도 자동 추론
df = pd.DataFrame({"name": ["김철수", "이영희", "박민수"],
                    "city": ["서울", "부산", "대전"]})
print(df.dtypes)
# name    str
# city    str
# dtype: object

성능 향상: 5~10배 빠른 문자열 연산

PyArrow 백엔드를 사용하는 새로운 str dtype의 최대 장점은 역시 성능입니다. PyArrow는 데이터를 연속된 메모리 블록에 저장해서 CPU 캐시 효율을 극대화하고, C++로 구현된 고성능 문자열 커널을 활용하거든요. 덕분에 문자열 연산이 기존 대비 5~10배 빠릅니다.

import pandas as pd
import numpy as np

# 100만 행의 문자열 데이터 생성
n = 1_000_000
ser = pd.Series([f"데이터_{i}" for i in range(n)])

# 문자열 연산 성능 비교
# pandas 3.0 + PyArrow 백엔드: 기존 대비 약 5~10배 빠름
result = ser.str.upper()       # 대문자 변환
result = ser.str.contains("1") # 패턴 검색
result = ser.str.len()         # 길이 계산
result = ser.str.replace("데이터", "DATA")  # 치환

벤치마크 결과를 보면 문자열 연산 전반의 속도가 평균 4.5배 향상되었고, 특정 메서드는 최대 6.6배까지 빨라졌습니다. 메모리 사용량도 최대 50% 감소했다는 점이 인상적이에요.

결측값 처리

새로운 str dtype에서 결측값은 NaN(np.nan)으로 표현됩니다. 기존 object dtype과의 호환성을 유지하면서도 타입 안전성을 높인 설계입니다.

import pandas as pd
import numpy as np

ser = pd.Series(["hello", None, "world", np.nan])
print(ser)
# 0    hello
# 1      NaN
# 2    world
# 3      NaN
# dtype: str

# 결측값 확인
print(ser.isna())
# 0    False
# 1     True
# 2    False
# 3     True
# dtype: bool

타입 안전성

기존 object dtype과 달리, 새로운 str dtype은 문자열 또는 결측값만 저장할 수 있습니다. 정수나 리스트, 딕셔너리 같은 걸 넣으려고 하면 오류가 납니다. 이게 불편하다고 느낄 수도 있지만, 장기적으로는 훨씬 안전한 코드를 작성하게 해주죠.

import pandas as pd

# str dtype은 문자열만 허용
ser = pd.Series(["hello", "world"], dtype="str")

# 다른 타입을 넣으면 자동 변환 또는 오류 발생
# ser[0] = 123  # 문자열 "123"으로 변환됨

마이그레이션 시 주의할 점

기존 코드에서 dtype == "object"로 문자열 열을 확인하던 패턴은 pandas 3.0에서 더 이상 작동하지 않습니다. 특히 라이브러리 코드나 유틸리티 함수에서 이 패턴을 쓰고 계셨다면 꼭 확인하세요.

import pandas as pd

df = pd.DataFrame({"name": ["Alice", "Bob"], "age": [30, 25]})

# ===== pandas 2.x 방식 (더 이상 작동하지 않음) =====
string_cols = df.select_dtypes(include=["object"]).columns

# ===== pandas 3.0 권장 방식 =====
string_cols = df.select_dtypes(include=["str", "object"]).columns
# 또는
string_cols = df.select_dtypes(include=["string"]).columns

참고로 PyArrow는 필수 의존성은 아니지만 강력히 권장합니다. 없으면 str dtype이 내부적으로 NumPy object 배열로 폴백하기 때문에 성능 이점을 제대로 못 누려요.

pip install pyarrow

pd.col() 표현식 — lambda를 대체하는 새 문법

pd.col()이란?

pd.col()은 pandas 3.0에서 새로 도입된 열 참조 표현식입니다. PySpark나 Polars를 써보신 분이라면 익숙한 느낌일 텐데요. DataFrame의 열을 이름으로 참조하고 표현식을 구성할 수 있게 해줍니다. 기존에 lambda를 써야 했던 많은 상황을 대체해서 코드가 훨씬 깔끔해져요.

기본 사용법

import pandas as pd

df = pd.DataFrame({"a": [1, 1, 2], "b": [4, 5, 6]})

# ===== 기존 방식: lambda 함수 사용 =====
result_old = df.assign(c=lambda df: df["a"] + df["b"])

# ===== 새로운 방식: pd.col() 사용 =====
result_new = df.assign(c=pd.col("a") + pd.col("b"))

print(result_new)
#    a  b  c
# 0  1  4  5
# 1  1  5  6
# 2  2  6  8

결과는 동일하지만, pd.col() 버전이 훨씬 직관적이죠? 특히 여러 열을 조합하는 복잡한 표현식에서는 가독성 차이가 확 느껴집니다.

지원 연산자

pd.col()은 모든 표준 산술 및 비교 연산자를 지원합니다.

import pandas as pd

df = pd.DataFrame({
    "price": [1000, 2000, 3000],
    "quantity": [5, 3, 2],
    "tax_rate": [0.1, 0.1, 0.2]
})

# 산술 연산자: +, -, *, /, //, %, **
total = df.assign(
    subtotal=pd.col("price") * pd.col("quantity"),
    tax=pd.col("price") * pd.col("quantity") * pd.col("tax_rate"),
    total=pd.col("price") * pd.col("quantity") * (1 + pd.col("tax_rate"))
)

print(total)
#    price  quantity  tax_rate  subtotal   tax   total
# 0   1000         5       0.1      5000  500.0  5500.0
# 1   2000         3       0.1      6000  600.0  6600.0
# 2   3000         2       0.2      6000 1200.0  7200.0

# 비교 연산자와 함께 사용
expensive = df.loc[pd.col("price") > 1500]
print(expensive)
#    price  quantity  tax_rate
# 1   2000         3       0.1
# 2   3000         2       0.2

Series 메서드 활용

pd.col() 표현식은 Series의 메서드와 접근자(.str, .dt 등)도 사용할 수 있습니다.

import pandas as pd

df = pd.DataFrame({
    "name": ["kim cheolsu", "lee yeonghi", "park minsu"],
    "score": [85, 92, 78]
})

# .str 접근자 사용
result = df.assign(
    upper_name=pd.col("name").str.upper(),
    name_length=pd.col("name").str.len(),
    has_lee=pd.col("name").str.contains("lee")
)

print(result)
#           name  score   upper_name  name_length  has_lee
# 0  kim cheolsu     85  KIM CHEOLSU           11    False
# 1  lee yeonghi     92  LEE YEONGHI           11     True
# 2   park minsu     78   PARK MINSU           10    False

# 집계 메서드 사용
print(pd.col("score").sum())  # 표현식 객체 반환

사용 가능한 컨텍스트

pd.col()은 현재 다음 위치에서 쓸 수 있습니다:

• DataFrame.assign() — 새 열 생성
• DataFrame.loc[] — 조건부 인덱싱
• DataFrame[] (getitem/setitem) — 열 선택 및 할당

import pandas as pd

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

# assign()에서 사용
df_new = df.assign(c=pd.col("a") * pd.col("b"))

# loc[]에서 조건부 필터링
filtered = df.loc[pd.col("a") > 1]

# setitem에서 사용
df["c"] = pd.col("a") + pd.col("b")

현재 제한 사항

아쉽게도 pd.col()은 groupby에서는 아직 못 씁니다. Polars나 PySpark에서는 group-by 내에서 열 참조를 자유롭게 쓸 수 있는데, pandas에서는 아직 구현이 안 됐어요. 향후 버전에서 지원이 확장될 예정이라고 하니 기대해봅시다.

import pandas as pd

df = pd.DataFrame({"grp": ["A", "A", "B"], "val": [1, 2, 3]})

# 아직 지원되지 않는 패턴 (향후 버전에서 지원 예정)
# df.groupby("grp").agg(total=pd.col("val").sum())  # NotImplementedError

# 현재는 기존 방식 사용
result = df.groupby("grp")["val"].sum()
print(result)
# grp
# A    3
# B    3
# Name: val, dtype: int64

날짜/시간 해상도 변경

나노초에서 입력 기반 해상도로

pandas 3.0에서는 날짜/시간 데이터의 기본 해상도가 나노초(ns)에서 마이크로초(us)로 변경되었습니다. 정확히 말하면, 입력 데이터의 해상도에 따라 적절한 해상도가 자동으로 결정되는 방식이에요.

import pandas as pd

# pandas 2.x: 항상 datetime64[ns]
# pandas 3.0: 입력 해상도에 따라 결정
ts = pd.to_datetime(["2024-03-22 11:36"])
print(ts.dtype)
# datetime64[us]  (이전: datetime64[ns])

# 나노초 정밀도가 포함된 경우에만 ns 사용
ts_nano = pd.to_datetime(["2024-03-22 11:43:01.123456789"])
print(ts_nano.dtype)
# datetime64[ns]  (나노초 정밀도가 있으므로)

# 정수 변환 시 단위 보존
ts_sec = pd.to_datetime([0], unit="s")
print(ts_sec.dtype)
# datetime64[s]  (초 단위 보존)

# NumPy 객체도 해상도 보존
import numpy as np
ts_ms = pd.Series([np.datetime64("2024-03-22", "ms")])
print(ts_ms.dtype)
# datetime64[ms]

범위 확장의 이점

기존 datetime64[ns]는 약 1678년부터 2262년까지밖에 표현하지 못했습니다. 역사 데이터를 다루거나 먼 미래 날짜를 처리할 때 OutOfBoundsDatetime 오류를 만나본 적 있으시죠? 마이크로초 해상도로 전환되면서 이 문제가 해결되었습니다.

import pandas as pd

# pandas 2.x에서는 OutOfBoundsDatetime 오류 발생
# pandas 3.0에서는 정상 처리
historical_date = pd.Timestamp("1200-01-01")
print(historical_date)
# 1200-01-01 00:00:00

future_date = pd.Timestamp("3000-12-31")
print(future_date)
# 3000-12-31 00:00:00

정수 변환 시 주의사항

한 가지 조심해야 할 부분이 있는데요. datetime을 정수로 변환할 때 값의 크기가 달라집니다. 마이크로초 해상도에서는 나노초 대비 1000분의 1 크기가 되거든요. 나노초 기반 정수 값에 의존하던 코드가 있다면 반드시 수정해야 합니다.

import pandas as pd

ts = pd.Timestamp("2024-01-01")

# pandas 3.0: 마이크로초 기반 정수값
print(ts.value)
# 이전(ns): 1704067200000000000
# 현재(us): 1704067200000000  (1000배 작음)

# 안전한 변환 방법
print(ts.as_unit("ns").value)  # 나노초 기반 값 명시적 획득

Arrow PyCapsule 인터페이스

제로 카피 데이터 교환

pandas 3.0은 Arrow PyCapsule 인터페이스를 지원합니다. 쉽게 말해서 다른 DataFrame 라이브러리와 데이터를 복사 없이(zero-copy) 주고받을 수 있게 된 거예요. Polars, DuckDB, cuDF 같은 Arrow 호환 라이브러리를 함께 쓰는 분들에게는 정말 반가운 소식입니다.

from_arrow()와 __arrow_c_stream__()

pandas 3.0에서는 DataFrame.from_arrow()와 Series.from_arrow() 메서드가 새로 추가되었고, __arrow_c_stream__()을 통해 Arrow 형식으로 데이터를 내보낼 수 있습니다.

import pandas as pd
import pyarrow as pa

# PyArrow 테이블을 pandas DataFrame으로 변환 (제로 카피)
arrow_table = pa.table({"x": [1, 2, 3], "y": ["a", "b", "c"]})
df = pd.DataFrame.from_arrow(arrow_table)
print(df)
#    x  y
# 0  1  a
# 1  2  b
# 2  3  c

# Series도 지원
arrow_array = pa.array([10, 20, 30])
ser = pd.Series.from_arrow(arrow_array)
print(ser)
# 0    10
# 1    20
# 2    30
# dtype: int64

# Arrow PyCapsule 프로토콜을 통한 내보내기
stream_capsule = df.__arrow_c_stream__()
# 다른 Arrow 호환 라이브러리에서 이 캡슐을 직접 사용 가능

대규모 데이터셋을 여러 라이브러리 간에 오가며 처리할 때, 복사가 없으니 메모리와 시간 모두 절약됩니다.

주요 API 변경 사항

Anti-Join 지원

드디어 pd.merge()에 anti-join이 생겼습니다! SQL에서는 당연히 되던 건데 pandas에서는 지금까지 우회해서 써야 했거든요. how="left_anti"는 왼쪽에만 있는 행을, how="right_anti"는 오른쪽에만 있는 행을 반환합니다.

import pandas as pd

customers = pd.DataFrame({
    "id": [1, 2, 3, 4, 5],
    "name": ["김철수", "이영희", "박민수", "최지은", "정하늘"]
})

orders = pd.DataFrame({
    "customer_id": [1, 3, 3, 5],
    "product": ["노트북", "마우스", "키보드", "모니터"]
})

# 주문이 없는 고객 찾기 (left anti-join)
no_orders = pd.merge(
    customers, orders,
    left_on="id", right_on="customer_id",
    how="left_anti"
)
print(no_orders)
#    id name
# 1   2 이영희
# 3   4 최지은

Rolling 메서드 확장

Rolling과 Expanding 윈도우에 유용한 메서드들이 추가되었습니다.

import pandas as pd

ser = pd.Series([1, 2, 3, 1, 2, 3, 1, 2, 3])

# first(): 윈도우 내 첫 번째 값
print(ser.rolling(3).first())

# last(): 윈도우 내 마지막 값
print(ser.rolling(3).last())

# nunique(): 윈도우 내 고유값 개수
print(ser.rolling(3).nunique())

# pipe(): 커스텀 함수 체이닝
result = ser.rolling(3).pipe(lambda r: r.mean() * 2)

문자열 메서드 개선

import pandas as pd

ser = pd.Series(["hello", "안녕하세요", "café", "résumé"])

# isascii(): ASCII 문자 여부 확인
print(ser.str.isascii())
# 0     True
# 1    False
# 2    False
# 3    False
# dtype: bool

# str.replace()에서 딕셔너리 사용 가능
mapping_ser = pd.Series(["apple banana", "cherry date"])
result = mapping_ser.str.replace(
    {"apple": "사과", "banana": "바나나", "cherry": "체리", "date": "대추"},
    regex=False
)
print(result)
# 0    사과 바나나
# 1     체리 대추
# dtype: str

Apache Iceberg 지원

데이터 레이크하우스를 쓰는 팀이라면 반길 소식인데요. pandas 3.0에서 Apache Iceberg 테이블의 읽기와 쓰기를 지원하는 read_iceberg()와 to_iceberg()가 추가되었습니다.

import pandas as pd

# Iceberg 테이블 읽기
df = pd.read_iceberg("catalog.database.table_name")

# Iceberg 테이블로 쓰기
df.to_iceberg("catalog.database.output_table")

NamedAgg 개선

pd.NamedAgg에서 *args와 **kwargs를 지원하게 되어, 집계 함수에 추가 인수를 전달할 수 있게 되었습니다. 이건 작은 변화 같지만 실무에서는 꽤 편리합니다.

import pandas as pd

df = pd.DataFrame({
    "group": ["A", "A", "B", "B"],
    "values": [1.0, float("nan"), 3.0, 4.0]
})

# skipna 인수를 NamedAgg를 통해 전달
result = df.groupby("group").agg(
    total=pd.NamedAgg("values", "sum", skipna=False)
)
print(result)
#        total
# group
# A        NaN
# B        7.0

최소 버전 요구 사항

pandas 3.0은 최소 의존성 버전이 올라갔으니 업그레이드 전에 확인하세요:

• Python: 3.11 이상 (기존 3.10에서 상향)
• NumPy: 1.26.0 이상
• PyArrow: 13.0.0 이상 (선택이지만 강력 권장)
• SciPy: 1.14.1 이상
• SQLAlchemy: 2.0.36 이상
• Matplotlib: 3.9.3 이상

그리고 pytz가 선택적 의존성으로 변경되면서, 표준 라이브러리의 zoneinfo가 기본으로 쓰입니다.

import pandas as pd

# pytz 대신 zoneinfo 사용
ts = pd.Timestamp(2024, 1, 1).tz_localize("Asia/Seoul")
print(type(ts.tzinfo))
# <class 'zoneinfo.ZoneInfo'>  (이전: pytz.timezone)

마이그레이션 가이드: pandas 2.x에서 3.0으로

단계별 업그레이드 절차

pandas 개발팀이 권장하는 업그레이드 순서는 다음과 같습니다. 개인적으로도 이 방법을 따라가시길 추천드려요.

1. 단계 1: pandas 2.3으로 먼저 업그레이드

   pandas 2.3은 3.0에서 변경될 동작에 대한 deprecation 경고를 제공합니다. 먼저 2.3으로 올려서 어떤 코드를 고쳐야 하는지 파악하세요.

2. 단계 2: 모든 deprecation 경고 수정

   2.3에서 나오는 FutureWarning과 DeprecationWarning을 전부 수정합니다. 체인 할당, object dtype 의존 코드, 나노초 가정 코드를 특히 잘 살펴보세요.

3. 단계 3: 테스트 수행

   수정한 코드에 대해 충분한 테스트를 돌려봅니다. 가능하면 실제 데이터로 통합 테스트까지 하시는 게 좋아요.

4. 단계 4: pandas 3.0으로 업그레이드

   모든 경고가 해결되었으면 이제 pandas 3.0으로 올립니다.

# 단계 1: pandas 2.3으로 업그레이드
pip install pandas==2.3.*

# 경고를 확인하기 위한 설정
import warnings
warnings.filterwarnings("error", category=FutureWarning)
warnings.filterwarnings("error", category=DeprecationWarning)

# 기존 코드 실행 후 경고 확인 및 수정

# 단계 4: pandas 3.0으로 업그레이드
pip install pandas==3.0.*

# 또는 conda 사용
conda install -c conda-forge pandas=3.0

자주 수정이 필요한 코드 패턴

실제로 마이그레이션하면서 가장 많이 마주치게 될 패턴들을 정리했습니다.

1. 체인 할당 제거

import pandas as pd

df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})

# [이전] 체인 할당 — 더 이상 작동하지 않음
# df["a"][df["b"] > 4] = 0

# [이후] .loc 사용
df.loc[df["b"] > 4, "a"] = 0

2. 불필요한 .copy() 제거

import pandas as pd

df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})

# [이전] 방어적 .copy() 사용
# subset = df[df["a"] > 1].copy()
# subset["c"] = subset["a"] * 2

# [이후] .copy() 불필요
subset = df[df["a"] > 1]
subset["c"] = subset["a"] * 2  # CoW 덕분에 원본 df에 영향 없음

3. dtype 확인 코드 업데이트

import pandas as pd

df = pd.DataFrame({"name": ["Alice", "Bob"], "age": [30, 25]})

# [이전] object dtype 확인
# if df["name"].dtype == "object":
#     print("문자열 열입니다")

# [이후] str dtype 확인
if pd.api.types.is_string_dtype(df["name"]):
    print("문자열 열입니다")
# 또는
if df["name"].dtype == "str":
    print("문자열 열입니다")

4. copy 매개변수 제거

많은 메서드에서 copy 매개변수가 폐지되었습니다. CoW 때문에 이 매개변수가 더 이상 의미가 없거든요.

import pandas as pd

df = pd.DataFrame({"a": [1, 2, 3]}, index=pd.date_range("2024-01-01", periods=3, tz="UTC"))

# [이전] copy 매개변수 사용
# result = df.tz_convert("Asia/Seoul", copy=True)

# [이후] copy 매개변수 제거
result = df.tz_convert("Asia/Seoul")

# 영향을 받는 주요 메서드들:
# DataFrame.truncate(), tz_convert(), tz_localize()
# DataFrame.infer_objects(), align(), astype()
# DataFrame.reindex(), rename(), set_index() 등

5. 오프셋 별칭 업데이트

import pandas as pd

# [이전] 폐지된 별칭
# pd.date_range("2024-01-01", periods=5, freq="M")   # 월말
# pd.date_range("2024-01-01", periods=5, freq="Q")   # 분기말
# pd.date_range("2024-01-01", periods=5, freq="Y")   # 연말

# [이후] 새로운 별칭
pd.date_range("2024-01-01", periods=5, freq="ME")   # MonthEnd
pd.date_range("2024-01-01", periods=5, freq="QE")   # QuarterEnd
pd.date_range("2024-01-01", periods=5, freq="YE")   # YearEnd

6. inplace=True 반환값 변화

import pandas as pd

df = pd.DataFrame({"a": [1.0, None, 3.0]})

# [이전] inplace=True는 None을 반환
# result = df.fillna(0, inplace=True)
# print(result)  # None

# [이후] inplace=True는 self를 반환
result = df.fillna(0, inplace=True)
print(result is df)  # True (이전에는 None이었음)

성능 벤치마크

Copy-on-Write 최적화 효과

CoW의 최대 성능 이점은 불필요한 복사의 제거입니다. 예전에는 .copy()를 습관적으로 호출했고, pandas 내부에서도 방어적 복사가 곳곳에 있었죠. CoW 도입 후 이런 복사가 전부 지연 복사(lazy copy)로 바뀌면서, DataFrame 수정 작업에서 약 3배 속도 향상이 관찰되었습니다.

import pandas as pd
import numpy as np
import time

# 벤치마크: 대규모 DataFrame 부분집합 추출 반복
df = pd.DataFrame(np.random.randn(1_000_000, 20),
                  columns=[f"col_{i}" for i in range(20)])

start = time.time()
for _ in range(100):
    # pandas 3.0: 뷰를 반환하므로 매우 빠름
    subset = df[["col_0", "col_1", "col_2"]]
    filtered = df[df["col_0"] > 0]
elapsed = time.time() - start

print(f"부분집합 추출 100회 소요 시간: {elapsed:.3f}초")
# pandas 2.x: ~2.1초 (매번 복사)
# pandas 3.0: ~0.7초 (뷰 활용, 수정 시에만 복사)

문자열 연산 속도 향상

PyArrow 백엔드의 새로운 str dtype은 문자열 연산에서 극적인 성능 향상을 보여줍니다. 연속 메모리 저장과 SIMD 최적화된 C++ 커널 덕분이에요.

import pandas as pd
import time

# 100만 행 문자열 데이터
n = 1_000_000
ser = pd.Series([f"user_{i}@example.com" for i in range(n)])

# 문자열 포함 여부 검색 벤치마크
start = time.time()
result = ser.str.contains("example")
elapsed = time.time() - start
print(f"str.contains() 소요 시간: {elapsed:.4f}초")
# pandas 2.x (object): ~0.45초
# pandas 3.0 (str/PyArrow): ~0.08초  (약 5.6배 빠름)

# 문자열 대문자 변환 벤치마크
start = time.time()
result = ser.str.upper()
elapsed = time.time() - start
print(f"str.upper() 소요 시간: {elapsed:.4f}초")
# pandas 2.x (object): ~0.52초
# pandas 3.0 (str/PyArrow): ~0.08초  (약 6.5배 빠름)

# 문자열 분할 벤치마크
start = time.time()
result = ser.str.split("@")
elapsed = time.time() - start
print(f"str.split() 소요 시간: {elapsed:.4f}초")
# pandas 2.x (object): ~0.90초
# pandas 3.0 (str/PyArrow): ~0.18초  (약 5배 빠름)

실전 ETL 파이프라인 성능 비교

마지막으로, 실제 ETL 시나리오를 시뮬레이션한 종합 벤치마크입니다. 데이터 로드부터 문자열 처리, 필터링, 집계까지 포함하는 전형적인 파이프라인에서 얼마나 차이가 나는지 보여드릴게요.

import pandas as pd
import numpy as np
import time

# 대규모 데이터 생성 (실제 ETL 시뮬레이션)
n = 2_000_000
df = pd.DataFrame({
    "user_id": range(n),
    "name": [f"사용자_{i}" for i in range(n)],
    "email": [f"user_{i}@company.com" for i in range(n)],
    "department": np.random.choice(["영업", "개발", "마케팅", "인사"], n),
    "salary": np.random.randint(30000, 100000, n),
    "join_date": pd.date_range("2020-01-01", periods=n, freq="min")
})

start = time.time()

# 1단계: 문자열 필터링
dev_team = df[df["department"] == "개발"]

# 2단계: 문자열 변환
dev_team = dev_team.assign(
    upper_name=dev_team["name"].str.upper(),
    email_domain=dev_team["email"].str.split("@").str[1]
)

# 3단계: 날짜 기반 필터링
recent = dev_team[dev_team["join_date"] > "2022-01-01"]

# 4단계: 집계
summary = recent.groupby("email_domain")["salary"].agg(["mean", "count"])

elapsed = time.time() - start
print(f"전체 ETL 파이프라인 소요 시간: {elapsed:.3f}초")
# pandas 2.x: ~3.2초
# pandas 3.0: ~1.1초  (약 2.9배 빠름)

종합하면, pandas 3.0은 CoW를 통한 불필요한 복사 제거, PyArrow 기반 문자열 처리 고속화, 내부 최적화의 조합으로 실제 워크로드에서 2~4배 성능 향상을 보여줍니다. 코드 한 줄 안 바꿔도 라이브러리 업그레이드만으로 체감할 수 있다는 게 정말 매력적이에요.

결론

pandas 3.0은 Python 데이터 분석 역사에서 한 획을 그은 릴리스라고 봐도 과언이 아닙니다. Copy-on-Write로 뷰/복사의 불확실성이 사라졌고, 새로운 str dtype으로 문자열 처리가 5~10배 빨라졌으며, pd.col()으로 코드 가독성이 한 단계 올라갔습니다.

날짜/시간 해상도 변경은 실용적인 범위를 크게 넓혔고, Arrow PyCapsule 인터페이스는 다른 라이브러리와의 제로 카피 교환을 현실로 만들었습니다.

업그레이드를 망설이고 계신가요? 솔직히, 지금이 적기입니다. pandas 2.3을 거치는 단계적 마이그레이션 경로가 잘 마련되어 있고, 대부분의 경우 코드 수정량은 생각보다 적습니다. 특히 대규모 데이터를 다루거나 문자열 처리가 많은 워크플로우라면, 코드 수정 없이도 성능 향상을 바로 느끼실 수 있어요.

앞으로의 로드맵을 보면, pd.col()은 groupby를 비롯한 더 많은 곳에서 쓸 수 있게 확장될 예정이고, Pandas4Warning이 이미 도입되어 다음 메이저 버전도 미리 준비할 수 있습니다. 경고 메시지를 잘 챙기면 메이저 업그레이드에서도 놀랄 일은 없을 겁니다.

pandas 3.0은 단순한 버전 업데이트가 아닙니다. 더 빠르고, 더 안전하고, 더 직관적인 데이터 분석을 위한 진짜 변화예요. 한번 써보시면 다시는 돌아가고 싶지 않을 겁니다.