파이썬 판다스(Pandas) 성능 최적화: 벡터화, 메모리 절약, GroupBy 가속화 전략

⚡ 벡터화(Vectorization)와 Assign/Query를 활용한 연산 가속화

판다스 성능 최적화의 핵심은 벡터화(Vectorization)입니다.

파이썬에서 반복문(Loop)을 사용해 데이터프레임의 각 행(Row)을 순회하며 연산하는 것은 매우 비효율적입니다.

판다스는 내부적으로 Numpy를 기반으로 하며, 벡터화된 연산은 C 레벨에서 실행되기 때문에 일반 파이썬 반복문에 비해 압도적으로 빠릅니다.

즉, 특정 컬럼 전체에 대해 한 번에 연산을 적용하는 방식으로 코드를 작성해야 합니다.

💡 벡터화 vs. 반복문(Loop) 성능 차이

예를 들어, 두 컬럼을 더해 새로운 컬럼을 만들 때, 절대 `for` 반복문을 사용해서는 안 됩니다.

단순히 `df[‘C’] = df[‘A’] + df[‘B’]`와 같이 벡터화된 형태로 작성하는 것이 성능상 몇 배에서 수백 배까지 차이를 낼 수 있습니다.

판다스 연산 속도를 측정해보면, 벡터화된 코드가 일반 파이썬 함수를 사용하는 것보다 훨씬 빠르다는 것을 명확히 알 수 있습니다.

🎯 .assign() 메서드를 활용한 체이닝 최적화

새로운 컬럼을 추가할 때는 `.assign()` 메서드를 활용하는 것이 좋습니다.

일반적인 방법인 `df[‘new_col’] = …` 방식은 원본 데이터프레임을 계속 수정(In-place)하기 때문에 중간에 복사(Copy)가 발생할 위험이 있습니다.

`.assign()`은 새로운 데이터프레임을 반환하며, 메서드 체이닝(Method Chaining)을 가능하게 해 코드를 더 깔끔하고 읽기 쉽게 만듭니다.

복잡한 전처리 과정을 하나의 논리적 흐름으로 연결할 때 특히 유용합니다.

# 비효율적인 방식 (반복문)
# for i in range(len(df)):
#     df.loc[i, 'Total'] = df.loc[i, 'Col1'] + df.loc[i, 'Col2']

# 최적화된 벡터화 & assign 방식
df_optimized = (df
    .assign(Total = lambda x: x['Col1'] + x['Col2'])
    .assign(Ratio = lambda x: x['Total'] / x['Max_Value'])
    .query("Total > 100")
)

🔍 .query() 메서드로 필터링 가속화

데이터프레임 필터링 시 `df[df[‘Col1’] > 10]`과 같은 불리언 인덱싱(Boolean Indexing) 방식도 빠르지만, `.query()` 메서드는 더 직관적인 문법으로 성능을 개선할 수 있습니다.

`.query()`는 내부적으로 numexpr 라이브러리를 사용해 연산을 최적화하며, 특히 대규모 데이터에서 속도 향상 효과가 두드러집니다.

조건을 문자열로 전달하기 때문에 코드를 작성하기도 쉽고, 파이썬 변수를 직접 참조할 수도 있어 유연성이 높습니다.

데이터프레임의 크기가 커질수록 벡터화된 연산과 `.query()`의 조합은 데이터 처리 속도를 혁신적으로 높여줍니다.

🚫 느린 Apply(Row-wise) 회피 및 Numpy/Cython 기반 대체 전략

판다스를 사용하면서 가장 성능 저하를 일으키는 원인 중 하나는 `df.apply(axis=1)`입니다.

`axis=1`은 행(Row) 단위로 함수를 적용하라는 의미로, 본질적으로 내부에서 파이썬의 반복문(Loop)과 유사하게 작동합니다.

행 단위 연산은 벡터화의 이점을 누릴 수 없기 때문에, 데이터프레임 크기가 커질수록 처리 속도가 매우 느려집니다.

🔁 Apply(Row-wise)를 대체하는 3단계 전략

행 단위 `apply`를 사용해야 할 복잡한 로직이 있다면, 아래와 같은 순서로 대안을 모색해야 합니다.

• 1️⃣벡터화된 판다스 메서드: 가장 먼저 Pandas의 내장 함수(예: `.dt`, `.str`, 산술 연산자)로 대체 가능한지 확인합니다.
• 2️⃣Numpy 활용: Pandas에서 벡터화가 어렵다면, 내부의 Numpy 배열을 추출하여 `np.where`, `np.select` 등을 사용해 연산합니다.
• 3️⃣컴파일러 사용: 복잡한 로직이라면 Numba나 Cython을 사용해 파이썬 함수를 컴파일하여 C 수준의 속도로 실행합니다.

⚡ Numba를 이용한 파이썬 함수 가속화

Numba는 Python 코드를 실시간으로 컴파일하여 실행 속도를 높여주는 JIT(Just-In-Time) 컴파일러입니다.

특히 Numpy 배열 연산이 포함된 파이썬 함수를 최적화하는 데 매우 강력하며, 복잡한 커스텀 함수를 `apply` 대신 사용해야 할 때 유용합니다.

함수 위에 `@numba.jit` 데코레이터 하나만 추가하면, 해당 함수가 C/C++ 수준의 성능을 내게 됩니다.

Numba를 사용할 때는 판다스 객체(`Series`나 `DataFrame`)를 바로 사용하기보다 Numpy 배열(.values)로 변환하여 전달해야 가장 큰 성능 향상을 얻을 수 있습니다.

import numba as nb

@nb.jit(nopython=True)
def custom_logic_numba(col1, col2, col3):
    result = np.empty_like(col1)
    for i in range(len(col1)):
        if col1[i] > 100 and col2[i] < 50:
            result[i] = col3[i] * 2
        else:
            result[i] = col3[i] / 2
    return result

# Numba 적용: .apply 대신 Numpy 배열에 직접 적용
df['New_Col'] = custom_logic_numba(
    df['Col1'].values,
    df['Col2'].values,
    df['Col3'].values
)

🧮 Numpy의 np.where / np.select 활용

단순한 조건부 할당(Conditional Assignment)은 `apply` 대신 Numpy의 `np.where` 또는 다중 조건에서는 `np.select`를 사용하는 것이 표준입니다.

이 함수들은 모두 벡터화되어 작동하며, Python의 `if-elif-else` 구조를 Pandas Series나 Numpy Array에 빠르게 적용할 수 있습니다.

`np.where`는 세 개의 인자를 받습니다. 조건, 조건이 참일 때의 값, 조건이 거짓일 때의 값입니다.

조건이 2개 이상 복잡해지면 `np.select`를 사용해 조건 리스트와 그에 대응하는 값 리스트를 깔끔하게 정의할 수 있습니다.

💬 성능 최적화의 황금률은 ‘반복문 대신 벡터화’입니다. `apply(axis=1)`은 사실상 반복문이므로, 반드시 Numpy 기반의 벡터화 함수나 Numba/Cython 같은 컴파일된 함수로 대체하는 습관을 들여야 합니다.

💾 Categorical 타입 변환으로 메모리 사용량 절감하기

대규모 데이터를 다룰 때 성능 문제만큼 중요한 것이 메모리 사용 효율성입니다.

메모리가 부족하면 시스템이 느려지거나, 아예 작업을 처리하지 못하고 프로그램이 강제 종료될 수 있습니다.

판다스 데이터프레임에서 메모리를 가장 많이 차지하는 데이터 타입 중 하나는 문자열(Object/String)입니다.

이 문제를 해결하는 가장 강력한 방법은 Categorical 타입을 사용하는 것입니다.

📉 Categorical 타입의 작동 원리 및 이점

문자열 컬럼의 고유값(Unique Values) 개수가 전체 데이터 개수보다 훨씬 적을 때, Categorical 타입으로 변환하면 메모리 사용량을 획기적으로 줄일 수 있습니다.

일반적인 문자열(Object) 타입은 모든 문자열 값을 그대로 저장하는 반면, Categorical 타입은 다음과 같이 작동합니다.

• 🏷️모든 고유 문자열 값(Categories)을 정수형 코드(Codes)로 매핑합니다.
• 📝실제 데이터에는 긴 문자열 대신 이 작은 정수 코드만 저장합니다.
• ⬇️긴 문자열 대신 1바이트나 2바이트 정수만 저장하므로, 전체 메모리 사용량이 수십 배까지 줄어들 수 있습니다.

특히 ‘지역’, ‘제품 코드’, ‘성별’ 등 반복되는 범주형 데이터에서 이 최적화는 필수적입니다.

메모리 절약뿐만 아니라, Categorical 타입은 GroupBy 연산이나 병합(Merge) 연산 시 문자열 비교 대신 정수 비교를 수행하므로 연산 속도 향상에도 기여합니다.

🔄 데이터 타입 최적화 실전 적용

데이터프레임의 메모리 사용량을 확인하려면 `.info(memory_usage=’deep’)`를 사용하고, 각 컬럼의 고유값 비율을 확인한 뒤 Categorical 타입으로 변환을 진행하는 것이 일반적인 워크플로우입니다.

# 1. 현재 메모리 사용량 확인
df.info(memory_usage='deep')

# 2. 고유값 비율이 낮은 컬럼을 Categorical 타입으로 변환
df['City'] = df['City'].astype('category')
df['Product_Code'] = df['Product_Code'].astype('category')

# 3. 변환 후 메모리 사용량 재확인 (대폭 감소 확인 가능)
df.info(memory_usage='deep')

📊 GroupBy 최적화: Transform, Apply 대신 Aggregation 활용법

데이터 분석에서 가장 많이 사용되는 연산 중 하나는 `groupby()`입니다.

그룹별 통계를 계산하거나, 그룹 내 데이터에 기반한 새로운 컬럼을 만들 때 필수적이지만, 대규모 데이터에서는 이 `groupby` 연산이 병목 현상(Bottleneck)의 주범이 되기도 합니다.

효율적인 `groupby` 사용은 데이터 처리 속도를 결정하는 핵심 요소입니다.

📈 Aggregation(.agg)을 활용한 다중 통계 계산

여러 개의 그룹별 통계(평균, 합계, 개수 등)를 한 번에 계산할 때는 `df.groupby().agg()`를 사용하는 것이 가장 효율적입니다.

이는 각 통계 연산을 개별적으로 수행하는 것보다 훨씬 빠르며, 결과 데이터프레임의 구조를 명확하게 제어할 수 있습니다.

딕셔너리 형태로 컬럼별로 적용할 통계 함수를 지정하면, 판다스는 내부적으로 한 번의 그룹화(Grouping) 과정만 거치고 모든 계산을 병렬적으로 처리하려고 시도합니다.

# 비효율적: 통계를 따로따로 계산
# df.groupby('Group')['Sales'].mean()
# df.groupby('Group')['Sales'].sum()

# 최적화: .agg()를 활용한 다중 통계
aggregated_df = df.groupby('Group').agg(
    Avg_Sales=('Sales', 'mean'),
    Total_Quantity=('Quantity', 'sum'),
    Unique_Items=('Item_ID', 'nunique')
)

✨ 그룹별 값 채우기: .transform()의 강력함

그룹별로 계산된 통계 값을 원본 데이터프레임에 다시 매핑하여 새로운 컬럼을 만들 때, `groupby().apply()` 대신 `.transform()`을 사용해야 합니다.

`.transform()`은 그룹별 연산 결과를 원본 데이터프레임의 인덱스와 정렬하여 반환하기 때문에, 별도의 병합(Merge) 과정이 필요 없습니다.

예를 들어, 각 지역별 평균 급여를 구하여 원래 데이터프레임의 ‘Avg_Salary_Region’ 컬럼에 추가하는 작업에서 `.transform()`은 가장 빠르고 깔끔한 방법입니다.

# 각 그룹별 평균 값을 원본 데이터프레임에 새로운 컬럼으로 추가
df['Group_Mean'] = df.groupby('Group_Col')['Value_Col'].transform('mean')

# 그룹별 순위(Rank) 매기기
df['Group_Rank'] = df.groupby('Group_Col')['Value_Col'].rank(method='dense')

🚫 GroupBy().Apply()를 최대한 피해야 하는 이유

`groupby().apply()`는 그룹별로 복잡한 커스텀 함수를 적용할 때 매우 유연하지만, 성능 측면에서는 최악의 선택일 수 있습니다.

`.apply()`는 판다스가 결과를 어떻게 처리해야 할지 미리 알 수 없기 때문에, 내부적으로 그룹을 쪼개고(Split), 함수를 적용(Apply)한 후, 결과를 다시 합치는(Combine) 과정에서 상당한 오버헤드(Overhead)가 발생합니다.

대부분의 경우 `.apply()`로 가능한 작업은 벡터화된 `.transform()`, `.agg()`, 또는 Numba가 적용된 함수를 Numpy 배열에 직접 적용하는 방식으로 대체될 수 있으며, 이는 성능을 몇 배 이상 향상시킵니다.

💬 GroupBy 연산을 사용할 때는 항상 `apply` 대신 `agg`나 `transform`을 먼저 고려하세요. 특히 그룹별 통계 결과를 원본에 추가하는 경우, `.transform()`이 `.apply()`보다 압도적으로 빠르고 코드가 간결해집니다.

🔗 효율적인 Merge 전략: 인덱스 활용 및 데이터 타입 일치

데이터 분석 과정에서 데이터프레임 두 개 이상을 결합하는 `merge` 연산은 필수적입니다.

하지만 대용량 데이터프레임에서 비효율적인 `merge`는 전체 작업의 속도를 크게 떨어뜨릴 수 있습니다.

`merge` 연산의 성능은 기본적으로 병합의 키(Key)로 사용되는 컬럼을 찾는 속도에 달려있으며, 이를 최적화하는 전략이 필요합니다.

🔑 인덱스를 활용한 Merge 가속화

판다스는 인덱스가 설정된 컬럼에 대해서는 해시 테이블(Hash Table)을 사용하여 검색 속도를 획기적으로 높입니다.

따라서 `merge`를 수행할 때, 결합 키를 일반 컬럼(`on=’key’`)으로 지정하기보다 인덱스(Index)로 설정하여 병합하는 것이 훨씬 빠릅니다.

특히 결합 키가 고유한 값이거나 빈번하게 사용되는 키라면, 미리 `.set_index()`를 사용하여 인덱스로 지정해 두면 좋습니다.

왼쪽 데이터프레임의 컬럼을 기준으로 병합하려면 `left_on=’key_col’`과 오른쪽 데이터프레임의 인덱스를 기준으로 병합하려면 `right_index=True` 옵션을 활용합니다.

# Merge를 위한 데이터프레임 셋업
df_right_indexed = df_right.set_index('ID')

# 인덱스를 활용한 병합 (훨씬 빠름)
merged_df = pd.merge(
    df_left, 
    df_right_indexed, 
    left_on='ID', 
    right_index=True, 
    how='inner'
)

✔️ 병합 키의 데이터 타입 일치

`merge` 성능에 결정적인 영향을 미치는 또 다른 요소는 결합 키로 사용되는 컬럼의 데이터 타입입니다.

두 데이터프레임의 결합 키 컬럼이 완벽하게 동일한 데이터 타입이어야 최적의 속도를 보장합니다.

예를 들어, 한쪽은 정수형(`int64`)이고 다른 쪽은 객체형(`object`, 즉 문자열)이거나, 혹은 한쪽은 `float64`인데 다른 쪽은 `int64`인 경우, 판다스는 병합 전에 타입을 통일하는 과정을 거치게 되어 성능이 저하됩니다.

특히 숫자형 ID를 문자열로 읽어오는 경우가 잦은데, 이럴 경우 `df[‘ID’].astype(‘int64’)` 등으로 미리 타입을 맞춰주는 전처리 과정이 필수입니다.

✂️ 병합 전 불필요한 컬럼 제거

데이터프레임을 병합할 때, 실제 분석에 필요하지 않은 컬럼들까지 포함하여 병합하면 메모리 사용량도 늘어나고 연산 시간도 길어집니다.

병합 전에는 `.drop()`을 사용하여 불필요한 컬럼을 미리 제거하고, 오직 결합 키와 필요한 정보만 남기는 것이 좋습니다.

이러한 사전 필터링 작업은 병합 과정의 효율성을 크게 높여주고, 메모리 절약에도 도움을 줍니다.

마찬가지로, 앞서 언급한 Categorical 타입으로 변환된 키 컬럼을 사용하면 문자열 기반의 병합보다 훨씬 빠르게 처리할 수 있습니다.

❓ 자주 묻는 질문 (FAQ)