⭐ Python Developer · Chặng 10Bài 1/6Bài học~60 phút

Đo và tối ưu hiệu năng Python: timeit, cProfile, Big-O

Tối ưu đúng chỗ: đo bằng timeit, perf_counter, tìm điểm nghẽn bằng cProfile, chọn cấu trúc dữ liệu đúng và hiểu độ phức tạp.

Đo và tối ưu hiệu năng Python: timeit, cProfile, Big-O

Học xong bài này, bạn sẽ

  • Đo thời gian đúng cách bằng timeit, perf_counter
  • Tìm điểm nghẽn bằng cProfile
  • Tối ưu bằng cấu trúc dữ liệu và thuật toán phù hợp

Nên học trước: Dự án chặng 9: API quản lý công việc nhóm

Nội dung bài viết
  1. 1. Đo thời gian đúng cách
  2. 2. Độ phức tạp: vì sao set nhanh hơn list
  3. 3. Tìm điểm nghẽn bằng cProfile
  4. 4. Sửa đúng chỗ, đo lại
  5. 5. Danh sách kỹ thuật theo thứ tự nên thử
  6. Tóm tắt
  7. Bài tập

"Python chậm" là câu bạn sẽ nghe nhiều. Thực tế, phần lớn chương trình chậm không phải vì Python mà vì chọn sai cấu trúc dữ liệu, lặp lại công việc thừa, hoặc tối ưu nhầm chỗ. Bài này dạy quy trình chuẩn: đo trước, tìm điểm nghẽn, sửa đúng chỗ, đo lại. Bạn sẽ thấy một chương trình chạy 6,4 giây xuống còn 0,03 giây chỉ nhờ đổi một kiểu dữ liệu.

Quy tắc vàngĐừng tối ưu khi chưa đo. Trực giác về "chỗ nào chậm" sai rất thường xuyên, kể cả với lập trình viên lâu năm. Code dễ đọc, đúng trước; nhanh sau, và chỉ ở chỗ số liệu chỉ ra.

1. Đo thời gian đúng cách

import time
import timeit

bat_dau = time.perf_counter()               # đồng hồ chính xác cao, dùng để đo khoảng thời gian
tong = sum(i * i for i in range(1_000_000))
print(f"Một lần chạy: {time.perf_counter() - bat_dau:.3f} s")   # kết quả thay đổi theo máy

ds = list(range(100_000))
tap = set(ds)
for ten, ham in [("list", lambda: 99_999 in ds), ("set", lambda: 99_999 in tap)]:
    lan = timeit.repeat(ham, number=1_000, repeat=5)               # 5 đợt × 1.000 lần
    print(f"{ten:<5} {min(lan) / 1_000 * 1e6:10.3f} µs mỗi lần tìm")
Một lần chạy: 0.071 s
list    1074.477 µs mỗi lần tìm
set        0.052 µs mỗi lần tìm
  • time.perf_counter() cho khoảng thời gian; không dùng time.time() (có thể nhảy khi đồng bộ đồng hồ hệ thống).
  • Đoạn code nhỏ chạy quá nhanh để đo một lần: timeit chạy hàng nghìn lần, lặp nhiều đợt, lấy min (đợt ít bị nhiễu nhất). Trong terminal có thể dùng nhanh: python -m timeit "99_999 in set(range(100_000))".
  • Kết quả đo phụ thuộc máy và thời điểm; so sánh tương đối giữa các cách quan trọng hơn con số tuyệt đối.

Tìm trong set nhanh hơn list khoảng 20.000 lần ở 100.000 phần tử. Đó là khác biệt giữa thuật toán, không phải giữa các dòng code.

2. Độ phức tạp: vì sao set nhanh hơn list

Thao táclistdict, set
x in ...O(n): so lần lượtO(1): tra bảng băm
Lấy theo chỉ số ds[i] / theo khóa d[k]O(1)O(1)
Thêm cuối append / thêm khóaO(1)O(1)
Chèn, xóa ở đầu insert(0, x), pop(0)O(n)(dùng deque: O(1))
Sắp xếp sortedO(n log n)

Ký hiệu O lớn mô tả thời gian tăng thế nào khi dữ liệu tăng. O(n) trong một vòng lặp n lần thành O(n²): 1.000 phần tử là 1 triệu phép so sánh, 100.000 phần tử là 10 tỷ. Mẫu lỗi phổ biến nhất: if x in danh_sach bên trong vòng for.

3. Tìm điểm nghẽn bằng cProfile

Chương trình báo cáo dưới đây chạy hơn 6 giây với 200.000 đơn hàng. Đoán xem chậm ở đâu trước khi đọc kết quả profiler:

import cProfile
import pstats
import random

random.seed(1)
DON = [{"ma": f"D{i}", "khach": f"K{random.randint(1, 20_000)}", "tien": random.randint(1, 500) * 1000}
       for i in range(200_000)]
KHACH_VIP = [f"K{i}" for i in range(1, 20_001, 7)]


def la_vip(ma_khach):
    return ma_khach in KHACH_VIP                 # tìm trong list


def chuan_hoa(don):
    return {**don, "tien_trieu": round(don["tien"] / 1e6, 3)}


def bao_cao():
    tong_vip = 0
    ket_qua = ""
    for don in DON:
        d = chuan_hoa(don)
        if la_vip(d["khach"]):
            tong_vip += d["tien"]
            ket_qua += d["ma"] + ","            # nối chuỗi trong vòng lặp
    return tong_vip, ket_qua.count(",")


cProfile.run("print(bao_cao())", "thong_ke.prof")    # kết quả thay đổi theo máy
pstats.Stats("thong_ke.prof").sort_stats("cumulative").print_stats(6)
(7148848000, 28598)
         600006 function calls in 6.440 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    6.440    6.440 {built-in method builtins.exec}
        1    0.000    0.000    6.440    6.440 <string>:1(<module>)
        1    0.131    0.131    6.440    6.440 bao_cao.py:19(bao_cao)
   200000    6.082    0.000    6.082    0.000 bao_cao.py:11(la_vip)
   200000    0.110    0.000    0.228    0.000 bao_cao.py:15(chuan_hoa)
   200000    0.117    0.000    0.117    0.000 {built-in method builtins.round}

Đọc bảng: ncalls số lần gọi, tottime thời gian trong chính hàm đó (không tính hàm con), cumtime tính cả hàm con. la_vip chiếm 6,08 trên 6,44 giây (94%): mỗi lần gọi tìm tuần tự trong list 2.858 mã VIP. Hàm chuan_hoa tạo dict mới mà nhiều người nghi ngờ chỉ tốn 0,2 giây; tối ưu nó gần như vô ích. Chạy profiler cho cả script từ terminal: python -m cProfile -s cumulative bao_cao.py.

4. Sửa đúng chỗ, đo lại

import random
import time

random.seed(1)
DON = [{"ma": f"D{i}", "khach": f"K{random.randint(1, 20_000)}", "tien": random.randint(1, 500) * 1000}
       for i in range(200_000)]
KHACH_VIP = {f"K{i}" for i in range(1, 20_001, 7)}     # set thay cho list


def bao_cao():
    don_vip = [d for d in DON if d["khach"] in KHACH_VIP]
    return sum(d["tien"] for d in don_vip), len(don_vip)


t = time.perf_counter()
print(bao_cao(), f"{time.perf_counter() - t:.3f} s")   # kết quả thay đổi theo máy
(7148848000, 28598) 0.030 s

Từ 6,44 giây xuống 0,03 giây, nhanh hơn khoảng 200 lần, cùng kết quả. Thay đổi quyết định là một ký tự: [...] thành {...}. Cùng lúc, code còn ngắn và dễ đọc hơn: bỏ hàm chuan_hoa không cần thiết, và không còn nối chuỗi trong vòng lặp (mỗi lần += trên chuỗi có thể tạo chuỗi mới; ghép nhiều chuỗi hãy dùng ",".join(...)).

Luôn kiểm tra kết quả không đổi sau khi tối ưu. Tốt nhất là có test (chặng 6) chạy trước và sau.

5. Danh sách kỹ thuật theo thứ tự nên thử

  1. Cấu trúc dữ liệu đúng: set, dict cho tra cứu; collections.deque cho hàng đợi; Counter để đếm.
  2. Bớt việc thừa: đưa phép tính không đổi ra khỏi vòng lặp; dùng functools.cache cho hàm thuần gọi lặp với cùng tham số (chặng 5); dùng generator thay vì tạo list trung gian khổng lồ.
  3. Để thư viện viết bằng C làm việc: hàm dựng sẵn (sum, sorted, max), comprehension, pandas và NumPy với phép toán vector hóa (chặng 8) thay cho vòng lặp Python trên từng phần tử.
  4. Giảm I/O: gom truy vấn CSDL (tránh N+1), gửi theo lô, đọc file một lần. Chương trình chờ mạng, chờ đĩa thì tối ưu CPU vô ích; bài sau và bài asyncio giải quyết việc chờ.
  5. Chạy song song khi việc thật sự nặng CPU và chia được (bài sau).
  6. Cuối cùng mới đến công cụ đặc biệt: Cython, mypyc, viết phần lõi bằng Rust (PyO3)...

Tóm tắt

  • Đo bằng time.perf_counter; đoạn nhỏ dùng timeit lặp nhiều lần, lấy min.
  • Hiểu O lớn: in trên list là O(n), trên set, dict là O(1); tránh O(n²) ẩn trong vòng lặp.
  • cProfile + pstats (hoặc python -m cProfile -s cumulative) để tìm hàm chiếm thời gian; sửa hàm đứng đầu.
  • Sau khi tối ưu: đo lại và kiểm tra kết quả không đổi.

Bài tập

Bài 1. list và set ở các kích thước

Đo thời gian tìm phần tử cuối trong list và set với 1.000, 10.000 và 100.000 phần tử. Thời gian của mỗi loại tăng thế nào khi dữ liệu tăng 10 lần?

Xem đáp án
import timeit

for n in (1_000, 10_000, 100_000):
    ds = list(range(n))
    tap = set(ds)
    t_list = min(timeit.repeat(lambda: n - 1 in ds, number=200, repeat=5)) / 200
    t_set = min(timeit.repeat(lambda: n - 1 in tap, number=200, repeat=5)) / 200
    print(f"n={n:>7,}: list {t_list * 1e6:8.2f} µs, set {t_set * 1e6:5.3f} µs")   # kết quả thay đổi theo máy
n=  1,000: list    10.71 µs, set 0.051 µs
n= 10,000: list   107.30 µs, set 0.050 µs
n=100,000: list  1076.15 µs, set 0.052 µs

List tăng khoảng 10 lần mỗi khi dữ liệu tăng 10 lần: đúng là O(n). Set gần như không đổi: O(1). Với dữ liệu nhỏ (vài chục phần tử) khác biệt không đáng kể; với dữ liệu lớn và nằm trong vòng lặp, đó là khác biệt giữa vài mili giây và vài phút.

Bài 2. Profile chương trình của bạn

Chạy python -m cProfile -s cumulative trên dự án phân tích bán hàng (chặng 8) hoặc dự án báo cáo tỷ giá (chặng 7). Hàm nào chiếm nhiều thời gian nhất? Có đáng tối ưu không?

Xem gợi ý

Với dự án tỷ giá, gần như toàn bộ thời gian nằm trong lời gọi mạng (các hàm của requests, socket, ssl) và trong openpyxl khi lưu file: code của bạn chỉ chiếm phần rất nhỏ. Kết luận đúng là "không cần tối ưu", và đó cũng là một kết quả có giá trị của việc đo: bạn không mất thời gian sửa thứ không phải vấn đề.

Nguồn tham khảo: timeit; The Python Profilers (cProfile, pstats); Python Wiki: TimeComplexity.

Bài tập thực hành

  1. Đo và so sánh tìm phần tử trong list và set với 100.000 phần tử, giải thích kết quả.
  2. Chạy cProfile trên chương trình mẫu trong bài, tìm hàm tốn thời gian nhất và tối ưu nó.

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.