안녕하세요!
파이썬(Python)으로 코딩하다 보면 "음... 생각보다 좀 느린데?" 싶은 순간, 다들 한 번쯤 겪어보셨을 겁니다.
맞습니다.
파이썬은 인터프리터 방식의 동적 타입 언어라서, C언어처럼 미리 컴파일되는 언어들에 비해 실행 속도가 느릴 수 있습니다.
하지만! 그렇다고 실망하기엔 이릅니다. 몇 가지 기술과 전략만 잘 활용하면, 우리 파이썬 코드도 훨씬 빠르고 효율적으로 만들 수 있거든요!
이번 글에서는 어떻게 하면 파이썬 코드를 더 빠르게 쌩쌩 달리게 할 수 있는지, 다양한 최적화 방법들을 알아보겠습니다.
코드 실행 시간을 정확하게 측정하기 위해 파이썬의 timeit 모듈도 함께 사용해 볼 건데요.
준비되셨나요?
그럼 출발해 봅시다!
(참고: timeit 모듈은 기본적으로 코드를 백만 번 반복 실행해서 측정 결과의 정확성과 안정성을 높인다는 점! 기억해 주세요.)
import timeit # 코드 실행 시간 측정을 위한 모듈
# 간단한 함수 정의
def print_hi(name):
# f-string을 사용해 문자열 포맷팅
print(f'Hi, {name}')
if __name__ == '__main__':
# 'print_hi("leapcell")' 함수 실행 시간을 측정 준비
# setup: 측정 전에 실행될 코드 (여기서는 함수 임포트)
# stmt: 실제로 시간을 측정할 코드
t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
# timeit() 메소드를 호출하여 실제 측정을 수행 (기본 백만 번 반복)
# 측정된 총 시간을 반환하지만, 여기서는 실행 자체에 의미를 둡니다.
execution_time = t.timeit()
print(f"timeit 측정 결과 (백만 번 실행 총 시간): {execution_time} 초") # 실제 출력은 환경마다 다릅니다.
잠깐! 코드 전체 실행 시간은 어떻게 잴까요?
timeit은 특정 코드 조각의 반복 실행 시간을 재는 데 좋지만, 스크립트 전체의 실행 시간을 재고 싶을 땐 time 모듈의 perf_counter()를 사용하는 것이 더 편리합니다.
아주 정밀한 시계를 제공해서 짧은 시간 간격 측정에 딱 좋습니다.
import time
# 프로그램 시작 시간 기록
start_time = time.perf_counter()
# --------------------
# 여기에 여러분의 파이썬 코드를 넣습니다!
# 예: 복잡한 계산, 파일 처리 등
time.sleep(1) # 예시로 1초 동안 잠시 멈춤
# --------------------
# 프로그램 종료 시간 기록
end_time = time.perf_counter()
# 실행 시간 계산 (종료 시간 - 시작 시간)
run_time = end_time - start_time
print(f"프로그램 총 실행 시간: {run_time} 초")
자, 이제 본격적으로 파이썬 성능을 끌어올리는 팁들을 알아볼까요?
1. 느림보의 주범? IO(입출력) 작업 주의보!
IO 집약적 작업(I/O-Intensive Operation) 이란, 프로그램 실행 시간의 대부분을 입력/출력 작업이 완료되기를 기다리는 데 사용하는 경우를 말합니다.
디스크에서 파일을 읽거나 쓰는 것, 네트워크로 데이터를 주고받는 것 등이 대표적인 IO 작업인데요.
이런 작업들은 보통 하드웨어 장치와 관련이 있어서, 하드웨어 성능이나 데이터 전송 속도(대역폭)에 의해 실행 속도가 제한되는 경우가 많습니다.
IO 집약적 작업의 특징:
- 기다림의 시간: IO 작업을 실행하면, 외부 장치에서 메모리로 데이터가 오거나 메모리에서 외부 장치로 데이터가 나갈 때까지 프로그램 실행이 잠시 멈추고 기다려야 할 수 있습니다(블로킹).
- CPU는 낮잠 중: IO 작업을 기다리는 동안 CPU는 할 일이 없어서 놀게 되고, 결국 CPU 자원을 효율적으로 사용하지 못하게 됩니다.
- 성능의 발목: 특히 처리할 데이터 양이 많거나 전송 속도가 느릴 때, 이 IO 작업 속도가 프로그램 전체 성능의 발목을 잡는 주범(병목 현상)이 됩니다.
예를 들어, 단순히 화면에 출력하는 print() 함수도 IO 작업에 속합니다.
이걸 백만 번 실행하면 얼마나 걸릴까요?
import time
import timeit
def print_hi(name):
print(f'Hi, {name}') # 화면 출력(IO) 작업
return
if __name__ == '__main__':
start_time = time.perf_counter()
t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
t.timeit() # 백만 번 실행
end_time = time.perf_counter()
run_time = end_time - start_time
# 환경에 따라 다르지만, 제 컴퓨터에서는 약 3초 정도 걸렸습니다.
print(f"print() 백만 번 실행 시간: {run_time} 초")
그런데 만약 print() 호출 부분을 주석 처리하고, 즉 IO 작업 없이 함수 호출만 백만 번 하면 어떻게 될까요?
def print_hi(name):
# print(f'Hi, {name}') # IO 작업 주석 처리!
return
# (timeit 실행 코드는 위와 동일)
# 실행 결과: 0.0x 초 수준으로 훨씬 빨라집니다!
결과가 엄청나게 차이 나죠? IO 작업이 얼마나 시간을 많이 잡아먹는지 알 수 있는 부분입니다.
IO 집약적 작업 최적화 방법 (맛보기):
만약 코드에서 파일 읽기/쓰기 같은 IO 작업이 꼭 필요하다면, 다음과 같은 방법들을 고려해볼 수 있습니다. (오늘은 간단히 소개만 할게요!)
- 비동기 IO (Asynchronous I/O):
asyncio같은 비동기 프로그래밍 모델을 사용하면, IO 작업을 기다리는 동안 CPU가 다른 일을 할 수 있게 해서 효율을 높일 수 있습니다. (지난 Node.js 글에서 본 논블로킹과 비슷하죠?) - 버퍼링 (Buffering): 데이터를 임시 저장 공간(버퍼)에 모았다가 한 번에 처리해서 실제 IO 작업 횟수를 줄입니다.
- 병렬 처리 (Parallel Processing): 여러 IO 작업을 동시에 실행해서 전체 데이터 처리 속도를 높입니다.
- 자료구조 최적화: 적절한 자료구조를 선택해서 데이터 읽기/쓰기 횟수 자체를 줄입니다.
2. 리스트/딕셔너리 만들 땐 '컴프리헨션'이 국룰!
파이썬 2.7 이후 버전부터는 리스트(list), 딕셔너리(dict), 세트(set)를 만드는 더 간결하고 효율적인 방법인 컴프리헨션(Comprehension) 이 도입되었습니다.
특히 리스트 컴프리헨션은 정말 많이 쓰이죠!
1. 전통적인 방법 (for 루프 + append)
import timeit
import time
def fun1():
my_list = [] # 빈 리스트 생성
for i in range(100): # 0부터 99까지 반복
my_list.append(i) # 리스트 끝에 i 추가
# 아래 main 함수 부분 코드는 이후 예제에서는 설명을 위해 생략하겠습니다.
if __name__ == '__main__':
start_time = time.perf_counter()
t = timeit.Timer(setup='from __main__ import fun1', stmt='fun1()')
# timeit()은 총 실행 시간을 반환합니다.
total_time = t.timeit()
end_time = time.perf_counter()
run_time = end_time - start_time
print(f"전통적 방법 실행 시간 (측정 코드 포함): {run_time} 초")
# 제 환경 실행 결과: 약 3.363 초 (timeit 백만 번 반복 기준)
2. 리스트 컴프리헨션으로 최적화!
import timeit
import time
def fun1():
# 대괄호 안에 for 루프를 넣어 리스트를 바로 생성!
my_list = [i for i in range(100)]
# (main 함수 실행 시간 측정 코드는 위와 동일)
# 제 환경 실행 결과: 약 2.094 초 (timeit 백만 번 반복 기준)
결과를 보면 컴프리헨션을 사용했을 때 시간이 훨씬 단축된 것을 볼 수 있습니다! 코드가 더 간결하고 읽기 쉬워지는 것은 덤이고요.
내부적으로 더 효율적으로 처리되기 때문에, 리스트(뿐만 아니라 딕셔너리, 세트)를 만들 때는 컴프리헨션을 우선적으로 사용하는 것이 좋습니다.
3. 문자열 합칠 땐 + 대신 join() 사용하기!
문자열 여러 개를 하나로 합쳐야 할 때, 무심코 + 연산자를 반복해서 사용하는 경우가 많은데요.
사실 이건 성능 면에서 꽤 비효율적인 방법입니다. + 연산자로 문자열을 합칠 때마다 새로운 문자열 객체가 계속해서 메모리에 만들어지기 때문입니다.
특히 많은 문자열을 합칠 때는 이 부담이 커집니다.
더 좋은 방법은 바로 문자열의 join() 메소드를 사용하는 것입니다!
join() 메소드의 장점:
- 고효율: 특히 많은 문자열을 합칠 때
+연산 반복보다 훨씬 빠릅니다. 내부적으로 더 효율적인 방식으로 처리됩니다. - 메모리 절약: 중간 단계의 임시 문자열 생성을 최소화하여 메모리를 더 효율적으로 사용합니다.
- 간결함: 코드가 더 깔끔해집니다.
- 유연성: 원하는 구분자(separator) 문자열을 지정하여 요소들을 합칠 수 있습니다.
- 넓은 적용 범위: 문자열뿐만 아니라, 리스트나 튜플 등 반복 가능한(iterable) 객체의 요소들을 합칠 때도 사용할 수 있습니다 (단, 요소들이 문자열로 변환 가능해야 함).
예시 비교:
import timeit
import time
# + 연산자로 문자열 합치기
def fun_plus():
obj = ['hello', 'this', 'is', 'leapcell', '!']
s = ""
for i in obj:
s += i # 반복할 때마다 새 문자열 객체 생성
return s # 결과 확인용 return 추가
# join() 메소드로 문자열 합치기
def fun_join():
obj = ['hello', 'this', 'is', 'leapcell', '!']
# 빈 문자열 ""을 구분자로 사용하여 obj의 모든 요소를 합침
return "".join(obj)
# 시간 측정 (fun_plus)
# 제 환경 실행 결과: 약 0.35186 초
# 시간 측정 (fun_join)
# 제 환경 실행 결과: 약 0.1822 초
join()을 사용하니 실행 시간이 거의 절반으로 줄어든 것을 볼 수 있습니다!
문자열을 여러 개 합쳐야 한다면 join()을 꼭 기억하세요.
4. 반복 작업엔 map() 함수도 고려해보기!
리스트 같은 반복 가능한(iterable) 객체의 모든 요소에 특정 함수를 적용하고 싶을 때, for 루프를 사용하는 것이 일반적입니다.
하지만 파이썬의 내장 고차 함수(higher-order function)인 map() 함수를 사용하면 더 간결하고 때로는 더 효율적으로 처리할 수 있습니다.
map(함수, 반복가능객체) 형태로 사용하며, 지정된 함수를 반복 가능한 객체의 각 요소에 적용한 결과를 반환하는 map 객체(이터레이터)를 만들어 줍니다.
1. 전통적인 for 루프 방식
import timeit
import time
def fun1():
arr = ["hello", "this", "is", "leapcell", "!"]
new_list = []
for i in arr:
new_list.append(i.upper()) # 각 요소를 대문자로 바꿔서 추가
return new_list
# 시간 측정 (fun1)
# 제 환경 실행 결과: 약 0.3067 초 (upper() 적용 예시)
2. map() 함수 사용하기
import timeit
import time
# map에 적용할 함수 (예: 대문자로 변경)
def to_upper(x):
return x.upper()
def fun_map():
arr = ["hello", "this", "is", "leapcell", "!"]
# map(to_upper, arr) 만 호출하면 map 객체만 생성됩니다.
# 실제 연산을 수행하고 결과를 리스트로 만들려면 list()로 감싸야 합니다.
return list(map(to_upper, arr))
# 시간 측정 (fun_map)
# 제 환경 실행 결과: 약 0.1875 초 (upper() 적용 예시, list() 변환 포함)
이 경우에도 map() 함수를 사용했을 때 시간이 단축되는 것을 볼 수 있습니다.
map()은 내부적으로 더 최적화된 방식으로 반복 작업을 처리할 수 있기 때문입니다.
(물론, 요즘은 비슷한 작업을 리스트 컴프리헨션 [x.upper() for x in arr] 으로 처리하는 것이 더 '파이썬스럽다(Pythonic)'고 여겨지며, 성능 차이도 크지 않거나 오히려 더 좋을 때도 있습니다. 하지만 map도 유용한 옵션이라는 것을 알아두세요!)
5. 상황에 맞는 '최적의 도구' 선택: 자료구조 활용하기!
파이썬 코드를 효율적으로 만들려면 상황에 맞는 적절한 자료구조를 선택하는 것이 정말 중요합니다!
각 자료구조는 특정 연산(검색, 추가, 삭제 등)에 최적화되어 있기 때문에, 어떤 작업을 주로 하느냐에 따라 알맞은 자료구조를 선택하면 프로그램 전체의 성능을 크게 향상시킬 수 있습니다.
예시 1: 특정 요소가 있는지 확인할 때 (멤버십 검사 in) - 리스트(list) vs 세트(set)/딕셔너리(dict)
어떤 요소가 컨테이너 안에 들어있는지 in 연산자로 확인할 때, 데이터 양에 따라 효율적인 자료구조가 다릅니다.
- 세트(set) / 딕셔너리(dict): 내부적으로 해시(hash) 테이블을 사용하기 때문에, 데이터 양이 아무리 많아져도 특정 요소가 있는지 찾는 속도가 거의 일정하게 빠릅니다 (평균적으로 O(1) 시간 복잡도).
- 리스트(list): 처음부터 끝까지 하나씩 비교하며 찾아야 하므로, 데이터 양이 많아질수록 검색 속도가 느려집니다 (평균적으로 O(n) 시간 복잡도).
데이터 양이 적을 때 테스트:
# 리스트 사용
def fun_list_small():
arr = ["hello", "this", "is", "leapcell", "!"]
'hello' in arr # True 반환
'my' in arr # False 반환
# 세트 사용 (딕셔너리도 비슷합니다)
def fun_set_small():
arr = {"hello", "this", "is", "leapcell", "!"}
'hello' in arr # True 반환
'my' in arr # False 반환
# 시간 측정 (fun_list_small): 약 0.1127 초
# 시간 측정 (fun_set_small): 약 0.1702 초
# => 데이터가 적을 때는 리스트가 약간 더 빠를 수도 있습니다. (set 생성 오버헤드 등)
데이터 양이 많을 때 테스트 (예: 100만 개 랜덤 정수)
import random
# 리스트 사용 (100만 개)
def fun_list_large():
nums = [random.randint(1, 2000000) for _ in range(1000000)]
target = 500000 # 찾을 값
target in nums
# 세트 사용 (100만 개)
def fun_set_large():
nums = {random.randint(1, 2000000) for _ in range(1000000)}
target = 500000 # 찾을 값
target in nums
# 시간 측정 (fun_list_large): 훨씬 오래 걸립니다! (제 환경: 수 초 이상)
# 시간 측정 (fun_set_large): 훨씬 빠릅니다! (제 환경: 0.1초 미만)
결론: 데이터 양이 많을 때 특정 요소의 존재 여부를 자주 확인해야 한다면, 리스트보다는 세트나 딕셔너리를 사용하는 것이 압도적으로 유리합니다!
예시 2: 앞뒤에서 데이터를 자주 추가/삭제할 때 - 리스트(list) vs 덱(deque)
리스트는 맨 뒤에 요소를 추가(append)하거나 제거(pop)하는 것은 빠릅니다(O(1)).
하지만 맨 앞에 요소를 추가(insert(0, ...))하거나 제거(pop(0))하는 것은 매우 비효율적입니다(O(n)).
왜냐하면 뒤따라오는 모든 요소들의 위치를 한 칸씩 이동시켜야 하기 때문이죠.
만약 리스트의 양쪽 끝에서 데이터를 추가하거나 삭제하는 작업이 빈번하다면, collections 모듈의 deque (덱, double-ended queue)를 사용하는 것이 훨씬 효율적입니다.
deque는 양쪽 끝에서의 추가/삭제 연산을 모두 O(1) 시간 복잡도로 빠르게 처리할 수 있도록 설계되었습니다.
from collections import deque
import timeit
import time
# deque 사용 (백만 번 append)
def fun_deque_append():
arr = deque() # 빈 deque 생성
for i in range(1000000):
arr.append(i)
# list 사용 (백만 번 append)
def fun_list_append():
arr = []
for i in range(1000000):
arr.append(i)
# 시간 측정 (fun_deque_append): 약 0.0558 초
# 시간 측정 (fun_list_append): 약 0.06077 초
# => append만 할 때는 큰 차이 없어 보이지만...
# deque 사용 (백만 번 appendleft - 앞에 추가)
def fun_deque_appendleft():
arr = deque()
for i in range(100000): # 횟수 줄임 (너무 오래 걸려서)
arr.appendleft(i)
# list 사용 (백만 번 insert(0, ...) - 앞에 추가)
def fun_list_insert_zero():
arr = []
for i in range(100000): # 횟수 줄임
arr.insert(0, i)
# 시간 측정 (fun_deque_appendleft): 비교적 빠름 (제 환경: 0.01초 미만)
# 시간 측정 (fun_list_insert_zero): 매우 매우 느림! (제 환경: 수 초 이상)
결론: 리스트의 맨 앞에서 추가/삭제 작업을 자주 해야 한다면 collections.deque를 사용하는 것을 강력히 추천합니다!
(참고: 정렬된 상태를 유지하면서 검색을 빠르게 하고 싶다면 bisect 모듈 활용도 고려해볼 수 있습니다.)
6. 불필요한 함수 호출은 그만!
함수 호출에는 생각보다 비용이 듭니다.
함수를 호출할 때마다 파이썬은 해당 함수를 찾고, 인자를 전달하고, 함수 내부의 지역 변수를 위한 공간을 마련하고, 함수 실행이 끝나면 결과를 반환하는 등의 과정을 거치는데요.
이런 과정들이 쌓이면 무시 못 할 오버헤드(overhead)가 됩니다.
특히 반복문 안에서 결과값이 항상 똑같은 함수를 불필요하게 계속 호출하고 있지는 않은지 확인해 보세요.
가능하다면 반복문 밖에서 한 번만 호출하거나, 여러 번의 함수 호출을 하나의 작업으로 합칠 수 있는지 고민해 보는 것이 좋습니다. (이 내용은 아래 10번 팁과도 연결됩니다!)
7. import도 꼭 필요한 만큼만!
파이썬의 import 문은 비교적 빠르지만, 공짜는 아닙니다.
모듈을 임포트할 때는 해당 모듈 파일을 찾고, (아직 실행된 적 없다면) 모듈 코드를 실행하고, 모듈 객체를 현재 네임스페이스(이름 공간)에 등록하는 과정이 필요한데요. 이 모든 과정에 약간의 시간과 메모리가 소모됩니다.
따라서 사용하지 않을 모듈을 미리 임포트해두거나, 너무 광범위하게 import * 를 사용하는 것은 피하는 것이 좋습니다.
꼭 필요한 모듈, 또는 모듈 내의 특정 함수나 클래스만 임포트하는 습관을 들이세요. (아래 9번 팁과도 연결됩니다!)
8. 전역 변수보다는 지역 변수를 애용하자!
import math
import timeit
import time
size = 10000 # 전역 변수
def fun_global():
# 전역 변수 size를 사용
for i in range(size):
# 간단한 예시를 위해 내부 루프 제거
z = math.sqrt(i)
# 시간 측정 (fun_global): 약 1.5 초 (sqrt 호출 반복 기준, 환경따라 크게 다름)
많은 분들이 간단한 스크립트를 작성할 때 변수를 함수 밖에 전역(global) 변수로 선언하는 경우가 많습니다.
하지만 파이썬 내부적으로 전역 변수에 접근하는 것은 지역(local) 변수에 접근하는 것보다 느립니다.
변수를 찾는 방식에 차이가 있기 때문인데요.
위 코드를 아래처럼 함수 안에서 지역 변수를 사용하도록 바꾸면, 보통 15% ~ 30% 정도의 속도 향상을 기대할 수 있습니다!
import math
import timeit
import time
def fun_local():
size = 10000 # 지역 변수
for i in range(size):
z = math.sqrt(i)
# 시간 측정 (fun_local): 약 1.3 초 (fun_global보다 빨라짐!)
가능하다면 전역 변수 사용을 최소화하고, 함수 내에서 필요한 변수는 지역 변수로 선언하거나 파라미터로 전달받아 사용하는 것이 성능에 유리합니다.
9. 모듈/함수 속성 접근 최소화: . 점 찍는 횟수 줄이기!
import math # 비추천 방식 (전체 모듈 임포트)
import timeit
import time
def fun_dot_access():
size = 100000 # 횟수 늘림
result = []
for i in range(size):
# 매번 math 모듈 객체를 통해 sqrt 함수를 찾아야 함 (점 연산)
result.append(math.sqrt(i))
return result
# 시간 측정 (fun_dot_access): 약 0.015 초
파이썬에서 . (점) 연산자를 사용하여 모듈이나 객체의 속성(메소드나 변수)에 접근할 때마다, 내부적으로는 __getattribute__() 나 __getattr__() 같은 특별한 메소드가 호출되면서 딕셔너리 검색과 유사한 작업이 일어납니다.
이게 반복되면 미미하지만 시간 오버헤드가 쌓이게 되는데요.
from ... import ... 구문을 사용하면 이런 추가적인 속성 접근 단계를 없앨 수 있습니다.
필요한 함수나 클래스를 현재 네임스페이스로 직접 가져오기 때문이죠.
from math import sqrt # 추천 방식 (필요한 함수만 직접 임포트)
import timeit
import time
def fun_direct_import():
size = 100000
result = []
for i in range(size):
# sqrt 함수가 현재 네임스페이스에 바로 있으므로 점 연산 불필요
result.append(sqrt(i))
return result
# 시간 측정 (fun_direct_import): 약 0.012 초 (fun_dot_access보다 빨라짐!)
자주 사용하는 함수라면 from ... import ... 를 사용해서 직접 임포트하는 것이 약간이나마 성능 향상에 도움이 될 수 있습니다.
10. 반복문 안쪽 계산은 최대한 다이어트 시키자!
이 팁은 정말 중요하고 효과도 큰 경우가 많습니다! 특히 중첩된 for 루프(이중 루프)를 사용할 때 주의 깊게 봐야 하는데요.
안쪽 루프에서 반복될 필요가 없는 계산이나 함수 호출이 있는지 확인해 보세요.
import math
import timeit
import time
def fun_inner_calc():
size = 1000 # 루프 크기 줄임 (시간이 너무 오래 걸려서)
sqrt = math.sqrt # Tip 9 적용
total = 0
for x in range(size):
for y in range(size):
# 안쪽 루프에서 sqrt(x)가 size번 불필요하게 반복 계산됨!
z = sqrt(x) + sqrt(y)
total += z # 계산 결과를 사용하는 척
return total
# 시간 측정 (fun_inner_calc): 약 1.4 초
위 코드에서 안쪽 y 루프를 보세요. sqrt(x) 값은 x 값이 바뀔 때만 변하고, y 값에는 영향을 받지 않습니다.
그런데도 y 루프가 돌 때마다 매번 sqrt(x)를 새로 계산하고 있죠. 이건 엄청난 낭비입니다!
이 sqrt(x) 계산을 바깥쪽 x 루프로 빼내면 어떻게 될까요?
import math
import timeit
import time
def fun_outer_calc():
size = 1000
sqrt = math.sqrt
total = 0
for x in range(size):
sqrt_x = sqrt(x) # x 루프에서 한 번만 계산!
for y in range(size):
# 미리 계산된 sqrt_x 사용
z = sqrt_x + sqrt(y)
total += z
return total
# 시간 측정 (fun_outer_calc): 약 0.8 초 (거의 절반으로 줄어듦!)
결과 보이시나요? 안쪽 루프에서 불필요한 계산을 한 번만 바깥으로 빼냈을 뿐인데 실행 시간이 크게 단축되었습니다!
반복문, 특히 중첩 반복문 안에서는 최대한 계산 횟수를 줄이는 것이 성능 최적화의 핵심 중 하나입니다.
마무리하며
오늘은 파이썬 코드의 성능을 끌어올릴 수 있는 다양한 팁들을 알아봤습니다.
IO 작업 최소화부터 컴프리헨션 활용, join() 사용, 적절한 자료구조 선택, 함수 호출 및 임포트 최적화, 그리고 반복문 최적화까지! 생각보다 우리가 신경 쓸 수 있는 부분이 꽤 많죠?
물론 모든 상황에 이 팁들이 항상 정답은 아닐 수 있습니다. 때로는 코드의 가독성이나 유지보수가 더 중요할 수도 있고요.
가장 중요한 것은 실제로 성능 문제가 발생하는 부분을 정확히 측정(timeit, perf_counter 또는 프로파일러 사용)하고, 그 부분에 맞는 최적화 기법을 적용하는 것입니다.
'Python' 카테고리의 다른 글
| 파이썬 리스트 정렬의 숨겨진 비밀: 팀소트(Timsort)는 왜 빠를까요? (0) | 2025.05.05 |
|---|---|
| 파이썬 함수형 프로그래밍 완전 정복: 핵심 원리부터 `map`, `filter`, `reduce` 활용법까지 깔끔 정리! (0) | 2025.04.27 |
| Python 로그 라이브러리 비교: loguru가 logging보다 좋은 이유는? (0) | 2025.04.25 |
| Flask 완전 정복: 파이썬 웹 프레임워크의 모든 것 (1) | 2025.04.12 |
| 파이썬 데코레이터 활용법: 로깅부터 권한 검증까지 완벽 가이드 (0) | 2025.03.24 |