1# 模式 1：等待外部資源（I/O 密集）
2response = requests.get(url)      # 等網路
3content = file.read()             # 等磁碟
4result = cursor.execute(query)    # 等資料庫
5
6# 模式 2：純計算（CPU 密集）
7result = sum(i * i for i in range(10_000_000))  # 沒有等待，純運算

1獨立性檢查清單：
2[ ] 任務之間沒有共享可變狀態？
3[ ] 任務執行順序不影響結果？
4[ ] 任務 B 不依賴任務 A 的輸出？
5
6如果三個都勾選，就適合並行化。

 1# 原始版本：循序處理
 2def check_directory(
 3    self,
 4    dir_path: str,
 5    recursive: bool = True
 6) -> List[LinkCheckResult]:
 7    """檢查目錄下所有 Markdown 檔案"""
 8    dir_path = self._resolve_path(dir_path)
 9
10    # 收集所有 .md 檔案
11    if recursive:
12        md_files = sorted(dir_path.rglob("*.md"))
13    else:
14        md_files = sorted(dir_path.glob("*.md"))
15
16    # 循序檢查每個檔案
17    results = []
18    for md_file in md_files:
19        results.append(self.check_file(str(md_file)))  # 一個接一個
20
21    return results

 1def check_file(self, file_path: str) -> LinkCheckResult:
 2    """
 3    檢查單個 Markdown 檔案的連結
 4
 5    特性：
 6    - 輸入：檔案路徑
 7    - 輸出：檢查結果
 8    - 沒有修改外部狀態
 9    - 沒有依賴執行順序
10    """
11    # ... 實作省略

 1from concurrent.futures import ThreadPoolExecutor, as_completed
 2
 3def check_directory_parallel(
 4    self,
 5    dir_path: str,
 6    recursive: bool = True,
 7    max_workers: int = 8
 8) -> List[LinkCheckResult]:
 9    """並行檢查目錄下所有 Markdown 檔案"""
10    dir_path = self._resolve_path(dir_path)
11
12    # 收集所有 .md 檔案
13    if recursive:
14        md_files = sorted(dir_path.rglob("*.md"))
15    else:
16        md_files = sorted(dir_path.glob("*.md"))
17
18    # 並行檢查
19    results = []
20    with ThreadPoolExecutor(max_workers=max_workers) as executor:
21        # 提交所有任務
22        futures = {
23            executor.submit(self.check_file, str(md_file)): md_file
24            for md_file in md_files
25        }
26
27        # 收集結果
28        for future in as_completed(futures):
29            results.append(future.result())
30
31    return results

 1import os
 2
 3# I/O 密集任務：可以設定較高
 4# 經驗法則：CPU 核心數的 2-4 倍
 5max_workers = min(32, (os.cpu_count() or 1) + 4)
 6
 7# 或根據檔案數量動態調整
 8def get_optimal_workers(file_count: int) -> int:
 9    """根據檔案數量決定 worker 數量"""
10    cpu_count = os.cpu_count() or 1
11
12    # 檔案少時不需要太多 worker
13    if file_count < 10:
14        return min(file_count, cpu_count)
15
16    # 檔案多時，I/O 密集可以多開一些
17    return min(32, cpu_count * 2)

 1from concurrent.futures import ThreadPoolExecutor, as_completed
 2from typing import Callable, Optional
 3
 4def check_directory_with_progress(
 5    self,
 6    dir_path: str,
 7    recursive: bool = True,
 8    max_workers: int = 8,
 9    progress_callback: Optional[Callable[[int, int, str], None]] = None
10) -> List[LinkCheckResult]:
11    """
12    並行檢查目錄，支援進度回報
13
14    Args:
15        progress_callback: 回呼函式 (completed, total, current_file)
16    """
17    dir_path = self._resolve_path(dir_path)
18
19    if recursive:
20        md_files = list(dir_path.rglob("*.md"))
21    else:
22        md_files = list(dir_path.glob("*.md"))
23
24    total = len(md_files)
25    results = []
26
27    with ThreadPoolExecutor(max_workers=max_workers) as executor:
28        # 建立 future -> 檔案 的映射
29        futures = {
30            executor.submit(self.check_file, str(f)): f
31            for f in md_files
32        }
33
34        completed = 0
35        for future in as_completed(futures):
36            completed += 1
37            current_file = futures[future]
38
39            # 回報進度
40            if progress_callback:
41                progress_callback(completed, total, str(current_file))
42
43            results.append(future.result())
44
45    return results
46
47# 使用範例
48def print_progress(completed: int, total: int, current_file: str):
49    percent = (completed / total) * 100
50    print(f"\r[{completed}/{total}] {percent:.1f}% - {current_file}", end="")
51
52checker = MarkdownLinkChecker()
53results = checker.check_directory_with_progress(
54    "docs/",
55    progress_callback=print_progress
56)
57print()  # 換行

 1def check_directory_robust(
 2    self,
 3    dir_path: str,
 4    max_workers: int = 8
 5) -> Tuple[List[LinkCheckResult], List[Dict]]:
 6    """
 7    並行檢查，分開返回成功結果和錯誤
 8
 9    Returns:
10        (成功的結果列表, 錯誤資訊列表)
11    """
12    dir_path = self._resolve_path(dir_path)
13    md_files = list(dir_path.rglob("*.md"))
14
15    results = []
16    errors = []
17
18    with ThreadPoolExecutor(max_workers=max_workers) as executor:
19        futures = {
20            executor.submit(self.check_file, str(f)): f
21            for f in md_files
22        }
23
24        for future in as_completed(futures):
25            file_path = futures[future]
26            try:
27                result = future.result()
28                results.append(result)
29            except Exception as e:
30                # 記錄錯誤，繼續處理其他檔案
31                errors.append({
32                    "file": str(file_path),
33                    "error": str(e),
34                    "type": type(e).__name__
35                })
36
37    return results, errors
38
39# 使用範例
40results, errors = checker.check_directory_robust("docs/")
41
42print(f"成功檢查 {len(results)} 個檔案")
43if errors:
44    print(f"有 {len(errors)} 個錯誤：")
45    for err in errors:
46        print(f"  {err['file']}: {err['error']}")

 1import timeit
 2from pathlib import Path
 3
 4# 準備測試資料
 5test_dir = Path("docs/")  # 假設有 50+ 個 .md 檔案
 6checker = MarkdownLinkChecker()
 7
 8# 測量循序版本
 9def test_sequential():
10    return checker.check_directory(str(test_dir))
11
12sequential_time = timeit.timeit(test_sequential, number=3) / 3
13
14# 測量並行版本
15def test_parallel():
16    return checker.check_directory_parallel(str(test_dir), max_workers=8)
17
18parallel_time = timeit.timeit(test_parallel, number=3) / 3
19
20# 計算加速比
21speedup = sequential_time / parallel_time
22
23print(f"循序版本：{sequential_time:.2f} 秒")
24print(f"並行版本：{parallel_time:.2f} 秒")
25print(f"加速比：{speedup:.2f}x")

 1#!/usr/bin/env python3
 2"""效能比較測試腳本"""
 3
 4import os
 5import sys
 6import time
 7from pathlib import Path
 8from concurrent.futures import ThreadPoolExecutor, as_completed
 9
10# 假設這是 markdown_link_checker 的簡化版
11class MarkdownChecker:
12    def check_file(self, file_path: str) -> dict:
13        """模擬檔案檢查（包含 I/O 延遲）"""
14        path = Path(file_path)
15        content = path.read_text(encoding="utf-8")
16        # 模擬一些處理時間
17        time.sleep(0.01)  # 10ms I/O 延遲
18        return {
19            "file": file_path,
20            "lines": len(content.splitlines()),
21            "chars": len(content)
22        }
23
24    def check_sequential(self, files: list) -> list:
25        """循序檢查"""
26        return [self.check_file(f) for f in files]
27
28    def check_parallel(self, files: list, max_workers: int = 8) -> list:
29        """並行檢查"""
30        results = []
31        with ThreadPoolExecutor(max_workers=max_workers) as executor:
32            futures = {executor.submit(self.check_file, f): f for f in files}
33            for future in as_completed(futures):
34                results.append(future.result())
35        return results
36
37def benchmark(func, *args, iterations: int = 3) -> float:
38    """測量函式執行時間"""
39    times = []
40    for _ in range(iterations):
41        start = time.perf_counter()
42        func(*args)
43        elapsed = time.perf_counter() - start
44        times.append(elapsed)
45    return sum(times) / len(times)
46
47def main():
48    # 收集測試檔案
49    test_dir = Path(".")  # 替換為你的目錄
50    files = list(test_dir.rglob("*.md"))[:100]  # 取前 100 個
51
52    if len(files) < 10:
53        print("需要至少 10 個 .md 檔案來測試")
54        sys.exit(1)
55
56    print(f"測試檔案數量：{len(files)}")
57
58    checker = MarkdownChecker()
59
60    # 測試不同 worker 數量
61    print("\n效能比較：")
62    print("-" * 50)
63
64    seq_time = benchmark(checker.check_sequential, files)
65    print(f"循序版本：{seq_time:.3f} 秒")
66
67    for workers in [2, 4, 8, 16]:
68        par_time = benchmark(checker.check_parallel, files, workers)
69        speedup = seq_time / par_time
70        print(f"並行 ({workers:2d} workers)：{par_time:.3f} 秒 ({speedup:.2f}x)")
71
72if __name__ == "__main__":
73    main()

1# 不好：只有 3 個檔案還用並行
2files = ["a.md", "b.md", "c.md"]
3with ThreadPoolExecutor(max_workers=8) as executor:
4    results = list(executor.map(check_file, files))
5
6# 問題：建立執行緒池的開銷可能比省下的時間還多

1def check_files_smart(files: list) -> list:
2    """根據檔案數量選擇處理方式"""
3    if len(files) < 10:
4        # 少量檔案：循序處理
5        return [check_file(f) for f in files]
6    else:
7        # 大量檔案：並行處理
8        with ThreadPoolExecutor(max_workers=8) as executor:
9            return list(executor.map(check_file, files))

1# 不好：任務 B 依賴任務 A 的結果
2def process_a():
3    return fetch_config()
4
5def process_b(config):  # 需要 A 的結果
6    return validate(config)
7
8# 強行並行化會出錯或需要額外同步

 1# 不好：多個執行緒修改同一個列表
 2shared_results = []
 3
 4def bad_worker(file):
 5    result = check_file(file)
 6    shared_results.append(result)  # 競爭條件！
 7
 8# 正確做法：讓 worker 返回結果，由主執行緒收集
 9def good_worker(file):
10    return check_file(file)
11
12with ThreadPoolExecutor() as executor:
13    results = list(executor.map(good_worker, files))

 1# 不好：CPU 密集任務受 GIL 限制
 2def compute_heavy(n):
 3    return sum(i * i for i in range(n))
 4
 5# ThreadPoolExecutor 對 CPU 密集任務沒有加速效果
 6with ThreadPoolExecutor(max_workers=8) as executor:
 7    results = list(executor.map(compute_heavy, [10_000_000] * 8))
 8
 9# 正確：CPU 密集應該用 ProcessPoolExecutor
10from concurrent.futures import ProcessPoolExecutor
11
12with ProcessPoolExecutor(max_workers=8) as executor:
13    results = list(executor.map(compute_heavy, [10_000_000] * 8))

11. 測量基準效能
2       ↓
32. 找出瓶頸（cProfile）
4       ↓
53. 針對瓶頸優化
6       ↓
74. 驗證優化效果
8       ↓
95. 評估維護成本

 1class HookValidator:
 2    """Hook 合規性驗證器"""
 3
 4    # 共用模組導入模式
 5    HOOK_IO_PATTERNS = [
 6        r"from\s+hook_io\s+import",
 7        r"from\s+lib\.hook_io\s+import",
 8    ]
 9
10    HOOK_LOGGING_PATTERNS = [
11        r"from\s+hook_logging\s+import",
12        r"from\s+lib\.hook_logging\s+import",
13    ]
14
15    # ... 更多模式 ...
16
17    def _has_import(self, content: str, patterns: list[str]) -> bool:
18        """檢查是否有符合任一模式的導入"""
19        return any(
20            re.search(pattern, content)
21            for pattern in patterns
22        )

 1import cProfile
 2import pstats
 3import re
 4from pstats import SortKey
 5
 6def generate_test_content(num_lines: int = 500) -> str:
 7    """生成測試用的 Hook 腳本內容"""
 8    lines = [
 9        '#!/usr/bin/env python3',
10        '"""Test hook script"""',
11        'import os',
12        'import sys',
13        'from hook_io import read_hook_input, write_hook_output',
14        'from hook_logging import setup_hook_logging',
15        '',
16    ]
17
18    # 加入更多程式碼行
19    for i in range(num_lines):
20        if i % 10 == 0:
21            lines.append(f'def function_{i}():')
22            lines.append(f'    """Function {i}"""')
23        lines.append(f'    x_{i} = {i}')
24
25    return '\n'.join(lines)
26
27def benchmark_original(content: str, iterations: int = 100):
28    """測量原始版本的效能"""
29
30    # 原始實作：每次呼叫都重新編譯正則表達式
31    patterns = [
32        r"from\s+hook_io\s+import",
33        r"from\s+lib\.hook_io\s+import",
34    ]
35
36    def has_import_original(content: str, patterns: list[str]) -> bool:
37        return any(
38            re.search(pattern, content)
39            for pattern in patterns
40        )
41
42    # 執行效能分析
43    profiler = cProfile.Profile()
44    profiler.enable()
45
46    for _ in range(iterations):
47        has_import_original(content, patterns)
48
49    profiler.disable()
50
51    stats = pstats.Stats(profiler)
52    stats.sort_stats(SortKey.CUMULATIVE)
53    stats.print_stats(10)
54
55    return stats
56
57# 執行測試
58content = generate_test_content(1000)
59print("=== 原始版本效能 ===")
60benchmark_original(content)

1=== 原始版本效能 ===
2         501 function calls in 0.0234 seconds
3
4   Ordered by: cumulative time
5
6   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
7      100    0.001    0.000    0.023    0.000 test.py:30(has_import_original)
8      200    0.022    0.000    0.022    0.000 {method 'search' of 're.Pattern'}
9      100    0.000    0.000    0.000    0.000 {built-in method builtins.any}

 1class HookValidator:
 2    """Hook 合規性驗證器"""
 3
 4    # 模式定義為字串列表
 5    HOOK_IO_PATTERNS = [
 6        r"from\s+hook_io\s+import",
 7        r"from\s+lib\.hook_io\s+import",
 8    ]
 9
10    HOOK_LOGGING_PATTERNS = [
11        r"from\s+hook_logging\s+import",
12        r"from\s+lib\.hook_logging\s+import",
13    ]
14
15    CONFIG_LOADER_PATTERNS = [
16        r"from\s+config_loader\s+import",
17        r"from\s+lib\.config_loader\s+import",
18    ]
19
20    GIT_UTILS_PATTERNS = [
21        r"from\s+git_utils\s+import",
22        r"from\s+lib\.git_utils\s+import",
23    ]
24
25    # 輸出函式使用模式
26    OUTPUT_PATTERNS = [
27        r"write_hook_output\s*\(",
28        r"create_pretooluse_output\s*\(",
29        r"create_posttooluse_output\s*\(",
30    ]
31
32    # 不推薦的輸出模式
33    BAD_OUTPUT_PATTERNS = [
34        r'print\s*\(\s*json\.dumps\s*\(',
35        r'sys\.stdout\.write\s*\(\s*json\.dumps\s*\(',
36    ]
37
38    def _has_import(self, content: str, patterns: list[str]) -> bool:
39        """檢查是否有符合任一模式的導入"""
40        return any(
41            re.search(pattern, content)  # 每次都要編譯！
42            for pattern in patterns
43        )

 1import re
 2from typing import Pattern
 3
 4class HookValidatorOptimized:
 5    """優化版 Hook 驗證器"""
 6
 7    # 預編譯的正則表達式模式
 8    HOOK_IO_PATTERNS: list[Pattern] = [
 9        re.compile(r"from\s+hook_io\s+import"),
10        re.compile(r"from\s+lib\.hook_io\s+import"),
11    ]
12
13    HOOK_LOGGING_PATTERNS: list[Pattern] = [
14        re.compile(r"from\s+hook_logging\s+import"),
15        re.compile(r"from\s+lib\.hook_logging\s+import"),
16    ]
17
18    CONFIG_LOADER_PATTERNS: list[Pattern] = [
19        re.compile(r"from\s+config_loader\s+import"),
20        re.compile(r"from\s+lib\.config_loader\s+import"),
21    ]
22
23    GIT_UTILS_PATTERNS: list[Pattern] = [
24        re.compile(r"from\s+git_utils\s+import"),
25        re.compile(r"from\s+lib\.git_utils\s+import"),
26    ]
27
28    OUTPUT_PATTERNS: list[Pattern] = [
29        re.compile(r"write_hook_output\s*\("),
30        re.compile(r"create_pretooluse_output\s*\("),
31        re.compile(r"create_posttooluse_output\s*\("),
32    ]
33
34    BAD_OUTPUT_PATTERNS: list[Pattern] = [
35        re.compile(r'print\s*\(\s*json\.dumps\s*\('),
36        re.compile(r'sys\.stdout\.write\s*\(\s*json\.dumps\s*\('),
37    ]
38
39    def _has_import(self, content: str, patterns: list[Pattern]) -> bool:
40        """檢查是否有符合任一模式的導入"""
41        return any(
42            pattern.search(content)  # 直接使用預編譯的 pattern
43            for pattern in patterns
44        )

 1import re
 2import time
 3
 4def compare_regex_performance():
 5    """比較預編譯 vs 非預編譯的效能"""
 6
 7    content = generate_test_content(1000)
 8    iterations = 1000
 9
10    # 字串 pattern
11    str_patterns = [
12        r"from\s+hook_io\s+import",
13        r"from\s+lib\.hook_io\s+import",
14    ]
15
16    # 預編譯 pattern
17    compiled_patterns = [re.compile(p) for p in str_patterns]
18
19    # 測試 1：使用字串 pattern
20    start = time.perf_counter()
21    for _ in range(iterations):
22        any(re.search(p, content) for p in str_patterns)
23    str_time = time.perf_counter() - start
24
25    # 測試 2：使用預編譯 pattern
26    start = time.perf_counter()
27    for _ in range(iterations):
28        any(p.search(content) for p in compiled_patterns)
29    compiled_time = time.perf_counter() - start
30
31    print(f"字串 pattern:    {str_time:.4f}s")
32    print(f"預編譯 pattern:  {compiled_time:.4f}s")
33    print(f"加速比:          {str_time / compiled_time:.2f}x")
34
35compare_regex_performance()

1字串 pattern:    0.1234s
2預編譯 pattern:  0.0987s
3加速比:          1.25x

 1import fnmatch
 2
 3# 保護分支列表（支援 glob 模式）
 4PROTECTED_BRANCHES = [
 5    "main",
 6    "master",
 7    "develop",
 8    "release/*",
 9    "production",
10]
11
12def is_protected_branch(branch: str) -> bool:
13    """
14    檢查是否為保護分支
15
16    Args:
17        branch: 分支名稱
18
19    Returns:
20        bool: 如果是保護分支返回 True
21    """
22    for pattern in PROTECTED_BRANCHES:
23        if fnmatch.fnmatch(branch, pattern):
24            return True
25    return False

 1from functools import lru_cache
 2import fnmatch
 3
 4PROTECTED_BRANCHES = [
 5    "main",
 6    "master",
 7    "develop",
 8    "release/*",
 9    "production",
10]
11
12@lru_cache(maxsize=128)
13def is_protected_branch(branch: str) -> bool:
14    """
15    檢查是否為保護分支（帶快取）
16
17    Args:
18        branch: 分支名稱
19
20    Returns:
21        bool: 如果是保護分支返回 True
22    """
23    for pattern in PROTECTED_BRANCHES:
24        if fnmatch.fnmatch(branch, pattern):
25            return True
26    return False

 1from functools import lru_cache
 2import fnmatch
 3
 4@lru_cache(maxsize=128)
 5def is_protected_branch(branch: str) -> bool:
 6    for pattern in PROTECTED_BRANCHES:
 7        if fnmatch.fnmatch(branch, pattern):
 8            return True
 9    return False
10
11def analyze_cache_performance():
12    """分析快取命中率"""
13
14    # 模擬真實的呼叫模式
15    branches = [
16        "main", "main", "main",  # 重複檢查 main
17        "feat/new-feature",
18        "main",
19        "fix/bug-123",
20        "main",
21        "release/1.0",
22        "feat/new-feature",  # 重複
23    ]
24
25    # 清除快取統計
26    is_protected_branch.cache_clear()
27
28    for branch in branches:
29        result = is_protected_branch(branch)
30        print(f"檢查 {branch}: {result}")
31
32    # 查看快取統計
33    info = is_protected_branch.cache_info()
34    print(f"\n快取統計:")
35    print(f"  命中: {info.hits}")
36    print(f"  未命中: {info.misses}")
37    print(f"  命中率: {info.hits / (info.hits + info.misses) * 100:.1f}%")
38    print(f"  快取大小: {info.currsize}/{info.maxsize}")
39
40analyze_cache_performance()

 1檢查 main: True
 2檢查 main: True
 3檢查 main: True
 4檢查 feat/new-feature: False
 5檢查 main: True
 6檢查 fix/bug-123: False
 7檢查 main: True
 8檢查 release/1.0: True
 9檢查 feat/new-feature: False
10
11快取統計:
12  命中: 5
13  未命中: 4
14  命中率: 55.6%
15  快取大小: 4/128

 1# 1. 參數必須是可雜湊的（hashable）
 2@lru_cache
 3def process(data: list):  # 錯誤！list 不可雜湊
 4    pass
 5
 6@lru_cache
 7def process(data: tuple):  # 正確，tuple 可雜湊
 8    pass
 9
10# 2. 注意快取大小
11@lru_cache(maxsize=None)  # 無限制，可能耗盡記憶體
12def expensive_function(x):
13    pass
14
15@lru_cache(maxsize=128)  # 建議設定合理上限
16def expensive_function(x):
17    pass
18
19# 3. 可以手動清除快取
20expensive_function.cache_clear()
21
22# 4. 查看快取統計
23info = expensive_function.cache_info()
24# CacheInfo(hits=10, misses=5, maxsize=128, currsize=5)

 1def check_test_exists(self, hook_path: Path) -> list[ValidationIssue]:
 2    """檢查對應的測試檔案是否存在"""
 3    issues = []
 4
 5    hook_name = hook_path.stem
 6    test_name = f"test_{hook_name.replace('-', '_')}.py"
 7
 8    # 測試檔案可能在這些位置
 9    possible_test_paths = [
10        self.project_root / ".claude" / "lib" / "tests" / test_name,
11        self.project_root / ".claude" / "hooks" / "tests" / test_name,
12    ]
13
14    test_exists = any(p.exists() for p in possible_test_paths)
15    # ...

 1# 不好的做法：用 list，O(n) 查詢
 2existing_tests = [
 3    "test_branch_verify.py",
 4    "test_hook_io.py",
 5    "test_config_loader.py",
 6    # ... 可能有幾十個
 7]
 8
 9def has_test_slow(test_name: str) -> bool:
10    return test_name in existing_tests  # O(n)
11
12# 好的做法：用 set，O(1) 查詢
13existing_tests_set = {
14    "test_branch_verify.py",
15    "test_hook_io.py",
16    "test_config_loader.py",
17    # ...
18}
19
20def has_test_fast(test_name: str) -> bool:
21    return test_name in existing_tests_set  # O(1)

 1import time
 2from pathlib import Path
 3
 4def compare_data_structures():
 5    """比較 list vs set 的查詢效能"""
 6
 7    # 模擬測試檔案列表
 8    test_files_list = [f"test_hook_{i}.py" for i in range(100)]
 9    test_files_set = set(test_files_list)
10
11    # 要查詢的檔案
12    queries = [f"test_hook_{i}.py" for i in range(50, 150)]  # 50 個存在，50 個不存在
13
14    iterations = 10000
15
16    # 測試 list
17    start = time.perf_counter()
18    for _ in range(iterations):
19        for q in queries:
20            _ = q in test_files_list
21    list_time = time.perf_counter() - start
22
23    # 測試 set
24    start = time.perf_counter()
25    for _ in range(iterations):
26        for q in queries:
27            _ = q in test_files_set
28    set_time = time.perf_counter() - start
29
30    print(f"List 查詢: {list_time:.4f}s")
31    print(f"Set 查詢:  {set_time:.4f}s")
32    print(f"加速比:    {list_time / set_time:.1f}x")
33
34compare_data_structures()

1List 查詢: 0.8234s
2Set 查詢:  0.0123s
3加速比:    66.9x

 1# 不值得優化的情況
 2
 3# 1. 執行次數很少
 4def setup_once():
 5    """只在程式啟動時執行一次"""
 6    config = load_all_configs()  # 即使慢也只執行一次
 7    return config
 8
 9# 2. 已經夠快了
10def check_single_file(path: str) -> bool:
11    """檢查單一檔案是否存在"""
12    return Path(path).exists()  # 0.0001s，不需要優化
13
14# 3. I/O 才是真正的瓶頸
15def process_files(paths: list[str]):
16    for path in paths:
17        content = Path(path).read_text()  # 瓶頸在這裡
18        result = process(content)  # 這裡快 10 倍也沒用

 1import cProfile
 2import pstats
 3from pstats import SortKey
 4
 5# 替換為你要分析的函式
 6def your_function():
 7    pass
 8
 9profiler = cProfile.Profile()
10profiler.enable()
11
12# 執行多次以獲得可靠數據
13for _ in range(100):
14    your_function()
15
16profiler.disable()
17stats = pstats.Stats(profiler)
18stats.sort_stats(SortKey.CUMULATIVE)
19stats.print_stats(10)

 1from functools import wraps
 2from typing import Callable, TypeVar
 3from collections import defaultdict
 4import time
 5
 6T = TypeVar('T')
 7
 8def cached_with_stats(maxsize: int = 128):
 9    """
10    帶統計資訊的快取裝飾器
11
12    統計項目：
13    - 命中/未命中次數
14    - 平均執行時間
15    - 各參數的呼叫次數
16    """
17    def decorator(func: Callable[..., T]) -> Callable[..., T]:
18        # 你的實作
19        pass
20    return decorator

 1keywords = ["error", "warning", "critical", "fatal"]
 2
 3# 方法 1：多個 in 檢查
 4def method1(text: str) -> bool:
 5    return any(kw in text for kw in keywords)
 6
 7# 方法 2：正則表達式
 8import re
 9pattern = re.compile("|".join(keywords))
10def method2(text: str) -> bool:
11    return bool(pattern.search(text))
12
13# 方法 3：set 交集
14keywords_set = set(keywords)
15def method3(text: str) -> bool:
16    words = set(text.lower().split())
17    return bool(words & keywords_set)
18
19# 測試並比較效能
20# ...