PySpark · S03

지연 실행, UDF, 파티션

PySpark 면접과 실무에서 가장 자주 나오는 세 가지를 직접 재 봤습니다. 변환은 바로 실행되지 않는다는 것, 파이썬 UDF가 느린 이유, 날짜별 파티션으로 필요한 폴더만 읽는 방법입니다.


import time
from pyspark.sql import SparkSession, functions as F, Window
from pyspark.sql.types import LongType
spark = (SparkSession.builder.master("local[*]").config("spark.sql.session.timeZone", "Asia/Seoul").getOrCreate())
spark.sparkContext.setLogLevel("ERROR")
schema = "order_id BIGINT, customer_id BIGINT, product_id BIGINT, qty INT, status STRING, ordered_at TIMESTAMP, updated_at TIMESTAMP"
raw = spark.read.csv("landing/orders/*.csv", header=True, schema=schema)
products = spark.read.csv("landing/products.csv", header=True, inferSchema=True)


# 1) 지연 실행: 변환은 즉시 끝나고, 액션에서 실제로 돈다
t = time.perf_counter(); big = spark.range(3_000_000).withColumn("x", F.col("id") * 7 % 1000); print(f"변환 정의: {time.perf_counter()-t:.3f}초")
t = time.perf_counter(); print("합계:", big.agg(F.sum("x")).first()[0], f"/ 액션 실행: {time.perf_counter()-t:.2f}초")

# 2) 파이썬 UDF vs 내장 함수 (같은 계산, 300만 행)
@F.udf(LongType())
def times7_mod(v):
    return v * 7 % 1000
def best(f, n=3):
    ts = []
    for _ in range(n):
        t = time.perf_counter(); f(); ts.append(time.perf_counter() - t)
    return min(ts)
r = spark.range(3_000_000)
t_udf = best(lambda: r.select(F.sum(times7_mod("id"))).first())
t_builtin = best(lambda: r.select(F.sum(F.col("id") * 7 % 1000)).first())
print(f"파이썬 UDF {t_udf:.2f}초 / 내장 함수 {t_builtin:.2f}초")

# 3) 날짜별 파티션으로 Parquet 저장 → 하루만 읽기
orders = raw.withColumn("order_date", F.to_date("ordered_at"))
orders.write.mode("overwrite").partitionBy("order_date").parquet("out/orders")
import os
print("폴더:", sorted(os.listdir("out/orders"))[:4], "...")
one = spark.read.parquet("out/orders").filter(F.col("order_date") == "2026-11-03")
print("11/03 행 수:", one.count())
plan = one._jdf.queryExecution().executedPlan().toString()
print([l.strip()[:160] for l in plan.splitlines() if "PartitionFilters" in l])
spark.stop()

1. 지연 실행 (lazy evaluation)

단계걸린 시간
300만 행 변환 정의 (range, withColumn)0.017초
합계 계산 (액션 first())0.71초

변환은 계획만 세우고 끝납니다. count(), show(), first(), write 같은 액션을 부를 때 계획 전체를 최적화해서 한 번에 돌립니다. 그래서 디버깅하면서 count()를 여러 번 부르면 같은 계산이 여러 번 돕니다.

2. 파이썬 UDF와 내장 함수

같은 계산 (300만 행, x*7 % 1000의 합)3번 중 가장 빠른 값
파이썬 UDF (@F.udf)0.22초
내장 함수 (F.col(...) * 7 % 1000)0.05초

파이썬 UDF는 행마다 JVM과 파이썬 사이로 데이터를 보내야 해서 느립니다. 작은 실습에서도 4배 넘게 차이가 났고, 데이터가 커지면 더 벌어집니다. 먼저 pyspark.sql.functions에 같은 기능이 있는지 찾고, 없을 때만 UDF를 씁니다.

3. 날짜별 파티션 저장

orders.write.mode("overwrite").partitionBy("order_date").parquet("out/orders")
# out/orders/order_date=2026-11-01/, order_date=2026-11-02/, ...

one = spark.read.parquet("out/orders").filter(F.col("order_date") == "2026-11-03")
one.count()            # 4453  (11/3 주문 4,450 + 같은 날 주문의 변경분 3)
one.explain()          # ... PartitionFilters: [isnotnull(order_date), (order_date = 2026-11-03)]

실행 계획의 PartitionFilters는 Spark가 order_date=2026-11-03 폴더만 읽었다는 뜻입니다. 클라우드에서는 읽은 양만큼 비용과 시간이 들기 때문에, 자주 거르는 컬럼(보통 날짜)으로 파티션을 나눕니다. 다만 값 종류가 너무 많은 컬럼(고객 번호 등)으로 나누면 작은 파일이 수만 개 생겨 오히려 느려집니다.

collect / toPandas 주의

모든 데이터를 드라이버 한 곳으로 가져옵니다. 결과가 큰 DataFrame에 쓰면 메모리가 터집니다. 집계·샘플링 뒤에만 씁니다.

셔플

join, groupBy는 데이터를 노드 사이로 다시 나눕니다(셔플). 느린 작업의 대부분은 셔플입니다. 작은 테이블은 broadcast join으로 셔플을 줄입니다.

explain()

느릴 때 먼저 실행 계획을 봅니다. 파티션 필터, 조인 방식, 셔플 단계가 보입니다.

이것만 기억하세요

변환은 액션 때 한 번에 돈다, UDF보다 내장 함수, 자주 거르는 날짜로 파티션. 느리면 explain()부터 봅니다.

다음
S04. 셔플·브로드캐스트·쏠림
이어보기 →