이펙티브 파이썬 8장 - 강건성과 성능

Better way 65 try/except/else/finally의 각 블록을 잘 활용하라

블록	용도
try	예외가 발생할 수 있는 최소한의 코드만 포함
except	예외 처리
else	예외 없이 성공한 경우의 처리 (except으로 빠진 경우 실행 X)
finally	예외 여부와 무관하게 반드시 실행되어야 하는 부분 (파일 닫는 등)

 

 

안 좋은 예시 - try문 안에 예외 발생 코드 & 안하는 코드가 섞여 있음

import threading

lock = threading.Lock()

def critical_section_basic():
    lock.acquire()
    try:
        result = 10 / 0  # ❗ 예외 발생 가능
        print("✅ 작업 성공:", result)
    except ZeroDivisionError:
        print("❌ 0으로 나눌 수 없습니다.")
    finally:
        lock.release()
        print("🔓 Lock 해제 완료")

critical_section_basic()

 

 

개선 - else를 활용하여 예외 발생 가능 코드만 try에 배치하여 가독성 향상

import threading

lock = threading.Lock()

def critical_section_better():
    lock.acquire()
    try:
        result = 10 / 2  # ❗ 예외 발생 가능
    except ZeroDivisionError:
        print("❌ 0으로 나눌 수 없습니다.")
    else:
        print("✅ 작업 성공:", result)  # 예외가 없을 때만 실행
    finally:
        lock.release()
        print("🔓 Lock 해제 완료")

critical_section_better()

 

 

Better way 66 재사용 가능한 try/finally 동작을 원한다면 contextlib과 with 문을 사용하라

@contextmanager 

• 컨텍스트 매니저 생성기
• yield
  • with 블록에 객체를 전달
• finally
  • with 블록이 끝나면 항상 실행됨

 

임시 파일 열고, 종료 시 자동 정리하는 컨텍스트 매니저 생성기

from contextlib import contextmanager

@contextmanager
def managed_file(path):
    print("📂 파일 열기")
    f = open(path, 'w')
    try:
        yield f  # 파일을 with 블록 안으로 넘김
    finally:
        print("❎ 파일 닫기")
        f.close()

# with 블록으로 사용
with managed_file("sample.txt") as f:
    f.write("Hello, contextlib!")

 

Better way 67 지역 시간에는 time보다는 datetime을 사용하라

항목	time 모듈	datetime 모듈
타임존 지원	OS 의존 (불안정)	명시적 설정 가능 (일관됨)
시간 계산	직접 timestamp 계산 필요	timedelta로 직관적 계산 가능
플랫폼 호환성	Windows/Linux 결과 다를 수 있음	플랫폼 독립적
추천 용도	타이머, 벤치마크 등 시스템 시간	로깅, 사용자 시간 표시, 시간대 처리 등

 

time 모듈은 C 표준 라이브러리 time.h를 래핑한 것이기 때문에 운영체제에 따라 시간/타임존 설정이 제대로 동작하지 않을 수 있다.

그렇기에 datetime 모듈을 사용하자

 

import time
import os

# 환경변수로 타임존을 임의로 바꿈 (Linux/macOS에서만 동작)
os.environ['TZ'] = 'Asia/Seoul'
time.tzset()  # 환경에 따라 이 함수 자체가 없음 (Windows 미지원)

print("🕓 time.localtime():", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

# 타임존을 UTC로 변경
os.environ['TZ'] = 'UTC'
time.tzset()

print("🌍 time.localtime() in UTC:", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

위의 코드는 Windows 에서는 정상적으로 동작하지 않는다.

 

 

from datetime import datetime, timezone, timedelta

# 명시적으로 UTC 기준
utc_now = datetime.now(timezone.utc)
print("🌍 UTC 시간:", utc_now.strftime('%Y-%m-%d %H:%M:%S %Z'))

# 한국 시간 (UTC+9)
kst = timezone(timedelta(hours=9))
local_now = utc_now.astimezone(kst)
print("🇰🇷 KST 시간:", local_now.strftime('%Y-%m-%d %H:%M:%S %Z'))

datetime은 플랫폼 독립적이기에 OS에 상관없이 작동한다.

 

 

Better way 69 정확도가 매우 중요한 경우에는 decimal을 사용하라

세금, 요금 등의 소숫점 단위의 정확한 값이 중요한 경우 decimal을 사용하자.

통화료를 계산해보자

 

• 통화료
  • 1.45 달러/분
• 시간
  • 3분 42초

 

rate = 1.45
seconds = 3*60 + 42
cost = rate * seconds / 60
print(cost) # 실제 값은 5.365
>>> 5.364999999999999

실제값 보다 0.0.0000000000000001 보다 작다.

 

 

from decimal import Decimal


rate = Decimal('1.45') # Decimal(1.45)와 결과가 다르다
seconds = Decimal(3*60 + 42)
cost = rate * seconds / Decimal(60)
print(cost) # 실제 값은 5.365
>>> 5.365

 

정확한 값이 계산된다.

 

 

 

Better way 70 최적화하기 전에 프로파일링을 하라

항목	cProfile	profile
구현 방식	C로 구현된 프로파일러	순수 파이썬으로 구현된 프로파일러
성능 오버헤드	매우 적음 (고속)	느림 (해석 단계에서 느림)
정확도	정확하고 실제 실행 환경 반영 잘됨	정확하지만 느려서 측정 대상에 영향 줄 수 있음
추천 용도	일반적인 성능 분석, 실전 코드에 적합	교육, 분석 목적, 디버깅 정도에 적합
표준 라이브러리	import cProfile	import profile

 

profile의 경우 순수 파이썬이기에 측정 성능에 영향을 줄 수 있어 cProfile을 사용하자

import cProfile

def slow_sum():
    total = 0
    for i in range(1000000):
        total += i
    return total

def fast_sum():
    return sum(range(1000000))

def run():
    slow_sum()
    fast_sum()

cProfile.run('run()')

 

출력 결과

         6 function calls in 0.135 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.102    0.102    0.123    0.123 profile_demo.py:4(slow_sum)
        1    0.000    0.000    0.011    0.011 profile_demo.py:10(fast_sum)
        1    0.000    0.000    0.135    0.135 profile_demo.py:13(run)
        1    0.000    0.000    0.135    0.135 {built-in method builtins.exec}
        1    0.000    0.000    0.135    0.135 <string>:1(<module>)

 

컬럼 이름	설명
ncalls	호출 횟수
tottime	해당 함수 자체에서 사용한 시간 (하위 함수 제외)
percall	호출당 평균 시간 (tottime / ncalls)
cumtime	해당 함수 포함 전체 실행 시간 (하위 함수 포함)
filename:lineno(function)	함수 위치

 

 

Better way 71 생산자-소비자 큐로 deque를 사용하라

연산	list 시간 복잡도	deque 시간 복잡도
append(x)	O(1)	O(1)
pop()	O(1)	O(1)
pop(0)	❌ O(n) (앞 요소들 이동)	✅ O(1)
popleft()	❌ 없음	✅ O(1)

 

import time
from collections import deque

N = 100000

# list 사용
lst = list(range(N))
start = time.time()
while lst:
    lst.pop(0)  # ❌ O(n) 연산
end = time.time()
print(f"list pop(0) 처리 시간: {end - start:.4f}초")

# deque 사용
dq = deque(range(N))
start = time.time()
while dq:
    dq.popleft()  # ✅ O(1) 연산
end = time.time()
print(f"deque popleft() 처리 시간: {end - start:.4f}초")

 

list pop(0) 처리 시간: 5.4321초
deque popleft() 처리 시간: 0.0043초

리스트는 동적 배열(array) 구조로 구현돼 있음

pop(0)을 하면

1. 첫 번째 요소를 제거한 후,
2. 남은 모든 요소들을 앞으로 한 칸씩 밀어야 함 ➜ O(n) 시간

이 작업이 많아지면 성능이 선형적으로 느려짐

 

 

 

 

Better way 72 정렬된 시퀀스를 검색할 때는 bisect를 사용하라

bisect 주요 함수

함수	설명
bisect.bisect_left(a, x)	x를 넣을 수 있는 가장 왼쪽 인덱스 반환
bisect.bisect_right(a, x)	x를 넣을 수 있는 가장 오른쪽 인덱스 반환
bisect.insort(a, x)	정렬된 리스트 a에 x를 삽입 (정렬 유지)

import time
import bisect
import random

N = 1000000
sorted_list = list(range(N))  # 0 ~ 999,999 까지 정렬된 리스트
target = random.randint(0, N)

# 선형 탐색
start = time.time()
for i, x in enumerate(sorted_list):
    if x >= target:
        linear_result = i
        break
linear_time = time.time() - start
print(f"🔍 선형 탐색 위치: {linear_result}, 시간: {linear_time:.6f}초")

# bisect 이진 탐색
start = time.time()
bisect_result = bisect.bisect_left(sorted_list, target)
bisect_time = time.time() - start
print(f"⚡ bisect 탐색 위치: {bisect_result}, 시간: {bisect_time:.6f}초")

 

🔍 선형 탐색 위치: 725394, 시간: 0.261245초
⚡ bisect 탐색 위치: 725394, 시간: 0.000015초

 

• 정렬된 리스트에서는 for 루프 대신 bisect 사용
• bisect는 이진 탐색 기반 -> O(log n)
• 리스트가 클수록 성능 차이는 압도적

 

Better way 73 우선순위 큐로 heapq를 사용하는 방법을 알아두라

import time
import heapq
import random

N = 10000
data = [random.randint(1, 100000) for _ in range(N)]

# 리스트 + sort 방식
lst = []
start = time.time()
for num in data:
    lst.append(num)
    lst.sort()  # ❌ 매번 전체 정렬
    _ = lst[0]  # 최소값 조회
end = time.time()
print(f"📉 list + sort() 방식: {end - start:.4f}초")

# heapq 방식
heap = []
start = time.time()
for num in data:
    heapq.heappush(heap, num)   # ✅ 정렬 없이 push
    _ = heap[0]  # 최소값 조회는 항상 heap[0]
end = time.time()
print(f"⚡ heapq 방식:         {end - start:.4f}초")

 

📉 list + sort() 방식: 1.3826초
⚡ heapq 방식:         0.0194초

 

 

• 우선순위가 있는 작업 처리에는 리스트 + sort 대신 heapq를 쓰자
• 삽입과 최소값 조회가 O(log n) 또는 **O(1)**로 빠르다
• 반복 삽입/조회가 많은 경우 성능이 수십 배 이상 빨라진다