Cpython on Tarragon

案例：效能分析實戰

Wed, 21 Jan 2026 00:00:00 +0000

本案例基於 .claude/lib/markdown_link_checker.py 的實際程式碼，展示如何用 cProfile 和 line_profiler 進行效能分析。

先備知識

模組四基礎章節
Python 正則表達式基礎

問題背景

現有設計

markdown_link_checker.py 是一個 Markdown 連結檢查工具，核心功能是解析文件中的連結並驗證其有效性。以下是關鍵的解析方法：

 1import re
 2from typing import List, Dict
 3
 4class MarkdownLinkChecker:
 5    """Markdown link checker with precompiled regex patterns"""
 6
 7    # Precompiled regex patterns at class level (good practice!)
 8    INLINE_LINK_PATTERN = re.compile(
 9        r'(?
10    )
11
12    REFERENCE_DEF_PATTERN = re.compile(
13        r'^\s*\[([^\]]+)\]:\s*(.+)$',
14        re.MULTILINE
15    )
16
17    REFERENCE_USE_PATTERN = re.compile(
18        r'\[([^\]]+)\]\[([^\]]+)\]'
19    )
20
21    def parse_markdown_links(self, content: str) -> List[Dict]:
22        """
23        Parse all links in Markdown content
24
25        Args:
26            content: Markdown content string
27
28        Returns:
29            list[dict]: List of links with text, target, line
30        """
31        links = []
32        lines = content.split('\n')
33
34        # First, collect reference-style link definitions
35        reference_defs = {}
36        for match in self.REFERENCE_DEF_PATTERN.finditer(content):
37            ref_name = match.group(1).lower()
38            ref_target = match.group(2).strip()
39            reference_defs[ref_name] = ref_target
40
41        # Track code block state
42        in_code_block = False
43
44        # Parse inline links line by line
45        for line_num, line in enumerate(lines, start=1):
46            # Check for code block boundaries
47            if line.strip().startswith("```"):
48                in_code_block = not in_code_block
49                continue
50
51            # Skip links inside code blocks
52            if in_code_block:
53                continue
54
55            # Inline links: [text](/python-advanced/04-cpython-internals/case-studies/profiling/target)
56            for match in self.INLINE_LINK_PATTERN.finditer(line):
57                links.append({
58                    "text": match.group(1),
59                    "target": match.group(2),
60                    "line": line_num
61                })
62
63            # Reference-style links: [text][ref]
64            for match in self.REFERENCE_USE_PATTERN.finditer(line):
65                ref_name = match.group(2).lower()
66                if ref_name in reference_defs:
67                    links.append({
68                        "text": match.group(1),
69                        "target": reference_defs[ref_name],
70                        "line": line_num
71                    })
72
73        return links

效能問題

處理大型文件時可能出現：

正則表達式效率問題：複雜的 pattern 可能導致回溯
重複編譯正則表達式：若 pattern 在方法內定義，每次呼叫都會重新編譯
不必要的字串操作：split() 會建立新的字串列表
多次遍歷：分別處理引用定義和行內連結

進階解決方案

分析目標

找出效能瓶頸所在
量化各部分的時間消耗
驗證優化效果

實作步驟

步驟 1：使用 cProfile 進行函式級分析

cProfile 是 Python 標準庫的效能分析工具，可以測量每個函式的呼叫次數和執行時間。

 1import cProfile
 2import pstats
 3from io import StringIO
 4from pathlib import Path
 5
 6def profile_link_checker():
 7    """Profile the markdown link checker with cProfile"""
 8
 9    # Create test content with many links
10    test_content = generate_test_content(num_links=1000)
11
12    checker = MarkdownLinkChecker()
13
14    # Create profiler
15    profiler = cProfile.Profile()
16
17    # Run profiling
18    profiler.enable()
19    for _ in range(100):  # Run multiple times for better statistics
20        checker.parse_markdown_links(test_content)
21    profiler.disable()
22
23    # Analyze results
24    stream = StringIO()
25    stats = pstats.Stats(profiler, stream=stream)
26    stats.sort_stats('cumulative')  # Sort by cumulative time
27    stats.print_stats(20)  # Show top 20 functions
28
29    print(stream.getvalue())
30
31    return stats
32
33def generate_test_content(num_links: int) -> str:
34    """Generate test Markdown content with specified number of links"""
35    lines = ["# Test Document\n"]
36
37    for i in range(num_links):
38        if i % 3 == 0:
39            # Inline link
40            lines.append(f"Check out [Link {i}](https://example.com/{i})\n")
41        elif i % 3 == 1:
42            # Reference-style link
43            lines.append(f"See [Reference {i}][ref{i}]\n")
44        else:
45            # Plain text with potential regex traps
46            lines.append(f"This is paragraph {i} with some [text] that looks like links.\n")
47
48    # Add reference definitions at the end
49    for i in range(num_links):
50        if i % 3 == 1:
51            lines.append(f"[ref{i}]: https://example.com/ref/{i}\n")
52
53    return "".join(lines)
54
55if __name__ == "__main__":
56    profile_link_checker()

執行方式：

1# Direct execution
2python profile_link_checker.py
3
4# Using cProfile from command line
5python -m cProfile -s cumulative markdown_link_checker.py --dir ./docs/

步驟 2：使用 pstats 分析結果

pstats 模組提供更細緻的結果分析功能：

 1import cProfile
 2import pstats
 3from pstats import SortKey
 4
 5def detailed_analysis():
 6    """Perform detailed analysis with pstats"""
 7
 8    # Profile the code
 9    profiler = cProfile.Profile()
10    profiler.enable()
11
12    # Run the target function
13    checker = MarkdownLinkChecker()
14    content = generate_test_content(500)
15    for _ in range(50):
16        checker.parse_markdown_links(content)
17
18    profiler.disable()
19
20    # Create Stats object
21    stats = pstats.Stats(profiler)
22
23    # Different sorting options
24    print("=" * 70)
25    print("Top 10 by CUMULATIVE time (including sub-calls)")
26    print("=" * 70)
27    stats.sort_stats(SortKey.CUMULATIVE).print_stats(10)
28
29    print("\n" + "=" * 70)
30    print("Top 10 by TOTAL time (excluding sub-calls)")
31    print("=" * 70)
32    stats.sort_stats(SortKey.TIME).print_stats(10)
33
34    print("\n" + "=" * 70)
35    print("Top 10 by CALL count")
36    print("=" * 70)
37    stats.sort_stats(SortKey.CALLS).print_stats(10)
38
39    # Filter by function name
40    print("\n" + "=" * 70)
41    print("Functions containing 'parse' or 'match'")
42    print("=" * 70)
43    stats.sort_stats(SortKey.TIME).print_stats('parse|match', 10)
44
45    # Show callers of a specific function
46    print("\n" + "=" * 70)
47    print("Who calls 'finditer'?")
48    print("=" * 70)
49    stats.print_callers('finditer')
50
51    # Save stats to file for later analysis
52    stats.dump_stats('link_checker.prof')
53
54    return stats
55
56def load_and_compare_profiles():
57    """Load and compare saved profile data"""
58    try:
59        # Load saved profile
60        stats = pstats.Stats('link_checker.prof')
61
62        # Add another profile for comparison
63        stats.add('link_checker_optimized.prof')
64
65        # Print combined stats
66        stats.sort_stats(SortKey.CUMULATIVE).print_stats(20)
67    except FileNotFoundError:
68        print("Profile files not found. Run detailed_analysis() first.")

步驟 3：使用 line_profiler 進行行級分析

line_profiler 可以分析每一行程式碼的執行時間，適合精確定位瓶頸。

首先安裝 line_profiler：

1pip install line_profiler

使用裝飾器標記要分析的函式：

  1# profile_lines.py
  2from line_profiler import profile
  3
  4@profile
  5def parse_markdown_links_profiled(self, content: str):
  6    """
  7    Line-by-line profiled version of parse_markdown_links
  8    """
  9    links = []
 10    lines = content.split('\n')
 11
 12    # Collect reference definitions
 13    reference_defs = {}
 14    for match in self.REFERENCE_DEF_PATTERN.finditer(content):
 15        ref_name = match.group(1).lower()
 16        ref_target = match.group(2).strip()
 17        reference_defs[ref_name] = ref_target
 18
 19    in_code_block = False
 20
 21    for line_num, line in enumerate(lines, start=1):
 22        if line.strip().startswith("```"):
 23            in_code_block = not in_code_block
 24            continue
 25
 26        if in_code_block:
 27            continue
 28
 29        # These regex operations might be slow
 30        for match in self.INLINE_LINK_PATTERN.finditer(line):
 31            links.append({
 32                "text": match.group(1),
 33                "target": match.group(2),
 34                "line": line_num
 35            })
 36
 37        for match in self.REFERENCE_USE_PATTERN.finditer(line):
 38            ref_name = match.group(2).lower()
 39            if ref_name in reference_defs:
 40                links.append({
 41                    "text": match.group(1),
 42                    "target": reference_defs[ref_name],
 43                    "line": line_num
 44                })
 45
 46    return links
 47
 48# Alternative: Manual timing for specific sections
 49import time
 50
 51def parse_with_timing(self, content: str):
 52    """Manual timing for detailed analysis"""
 53    timings = {}
 54
 55    # Time: split lines
 56    start = time.perf_counter()
 57    lines = content.split('\n')
 58    timings['split_lines'] = time.perf_counter() - start
 59
 60    # Time: parse reference definitions
 61    start = time.perf_counter()
 62    reference_defs = {}
 63    for match in self.REFERENCE_DEF_PATTERN.finditer(content):
 64        ref_name = match.group(1).lower()
 65        ref_target = match.group(2).strip()
 66        reference_defs[ref_name] = ref_target
 67    timings['parse_refs'] = time.perf_counter() - start
 68
 69    # Time: main parsing loop
 70    start = time.perf_counter()
 71    links = []
 72    in_code_block = False
 73
 74    for line_num, line in enumerate(lines, start=1):
 75        if line.strip().startswith("```"):
 76            in_code_block = not in_code_block
 77            continue
 78
 79        if in_code_block:
 80            continue
 81
 82        for match in self.INLINE_LINK_PATTERN.finditer(line):
 83            links.append({
 84                "text": match.group(1),
 85                "target": match.group(2),
 86                "line": line_num
 87            })
 88
 89        for match in self.REFERENCE_USE_PATTERN.finditer(line):
 90            ref_name = match.group(2).lower()
 91            if ref_name in reference_defs:
 92                links.append({
 93                    "text": match.group(1),
 94                    "target": reference_defs[ref_name],
 95                    "line": line_num
 96                })
 97
 98    timings['main_loop'] = time.perf_counter() - start
 99
100    return links, timings

執行 line_profiler：

1# Run with kernprof
2kernprof -l -v profile_lines.py
3
4# Or use the newer approach
5python -m line_profiler profile_lines.py

步驟 4：分析正則表達式效能

正則表達式是常見的效能瓶頸，需要特別分析：

  1import re
  2import time
  3from typing import Callable
  4
  5def benchmark_regex_patterns():
  6    """Compare different regex pattern implementations"""
  7
  8    # Test content with various edge cases
  9    test_lines = [
 10        "Check out [Link](https://example.com)",
 11        "See [Text with [brackets]](/python-advanced/04-cpython-internals/case-studies/profiling/url)",
 12        "Multiple [link1](/python-advanced/04-cpython-internals/case-studies/profiling/url1) and [link2](/python-advanced/04-cpython-internals/case-studies/profiling/url2)",
 13        "No links here, just plain text",
 14        "Tricky [text](/python-advanced/04-cpython-internals/case-studies/profiling/url) with more [text](/python-advanced/04-cpython-internals/case-studies/profiling/url) links",
 15        "![Image](/python-advanced/04-cpython-internals/case-studies/profiling/image.png) should be ignored",
 16        "[Link with spaces]( url with spaces )",
 17    ] * 1000
 18
 19    test_content = "\n".join(test_lines)
 20
 21    # Pattern 1: Original pattern
 22    pattern1 = re.compile(r'(?)
 23
 24    # Pattern 2: Possessive-like (using atomic group simulation)
 25    # Note: Python re doesn't support possessive quantifiers directly
 26    pattern2 = re.compile(r'(?)
 27
 28    # Pattern 3: More specific pattern
 29    pattern3 = re.compile(r'(?)
 30
 31    # Pattern 4: Non-capturing groups where possible
 32    pattern4 = re.compile(r'(?)
 33
 34    patterns = {
 35        "original": pattern1,
 36        "non_greedy": pattern2,
 37        "more_specific": pattern3,
 38        "optimized": pattern4,
 39    }
 40
 41    results = {}
 42
 43    for name, pattern in patterns.items():
 44        # Warmup
 45        for _ in range(10):
 46            list(pattern.finditer(test_content))
 47
 48        # Benchmark
 49        start = time.perf_counter()
 50        for _ in range(100):
 51            matches = list(pattern.finditer(test_content))
 52        elapsed = time.perf_counter() - start
 53
 54        results[name] = {
 55            "time": elapsed,
 56            "matches": len(matches),
 57        }
 58
 59    # Print comparison
 60    print("Regex Pattern Performance Comparison")
 61    print("=" * 60)
 62    print(f"{'Pattern':<20} {'Time (s)':<12} {'Matches':<10}")
 63    print("-" * 60)
 64
 65    baseline = results["original"]["time"]
 66    for name, data in results.items():
 67        speedup = baseline / data["time"]
 68        print(f"{name:<20} {data['time']:<12.4f} {data['matches']:<10} ({speedup:.2f}x)")
 69
 70    return results
 71
 72def analyze_regex_backtracking():
 73    """Analyze potential regex backtracking issues"""
 74    import re
 75
 76    # Patterns that might cause backtracking
 77    problematic_patterns = [
 78        (r'\[(.+)\]\((.+)\)', "Greedy .+ can backtrack"),
 79        (r'\[([^\]]+)\]\(([^)]+)\)', "Negated class - better"),
 80        (r'\[(.*?)\]\((.*?)\)', "Non-greedy - still may backtrack"),
 81    ]
 82
 83    # Pathological input that triggers backtracking
 84    pathological = "[" + "a" * 100 + "]"  # No closing bracket pattern
 85
 86    print("Regex Backtracking Analysis")
 87    print("=" * 60)
 88
 89    for pattern_str, description in problematic_patterns:
 90        pattern = re.compile(pattern_str)
 91
 92        start = time.perf_counter()
 93        try:
 94            # Set a timeout using signal (Unix only)
 95            result = pattern.search(pathological)
 96            elapsed = time.perf_counter() - start
 97            print(f"Pattern: {pattern_str}")
 98            print(f"  Description: {description}")
 99            print(f"  Time: {elapsed:.4f}s")
100            print(f"  Match: {result}")
101            print()
102        except Exception as e:
103            print(f"Pattern: {pattern_str} - Error: {e}")
104
105def compare_compile_vs_inline():
106    """Compare precompiled vs inline regex performance"""
107
108    test_content = generate_test_content(500)
109    iterations = 100
110
111    # Test 1: Precompiled pattern (recommended)
112    compiled_pattern = re.compile(r'(?)
113
114    start = time.perf_counter()
115    for _ in range(iterations):
116        list(compiled_pattern.finditer(test_content))
117    compiled_time = time.perf_counter() - start
118
119    # Test 2: Inline pattern (compiled each time by re module cache)
120    start = time.perf_counter()
121    for _ in range(iterations):
122        list(re.finditer(r'(?, test_content))
123    inline_time = time.perf_counter() - start
124
125    # Test 3: Pattern compiled inside loop (worst case)
126    start = time.perf_counter()
127    for _ in range(iterations):
128        pattern = re.compile(r'(?)
129        list(pattern.finditer(test_content))
130    loop_compile_time = time.perf_counter() - start
131
132    print("Compile Strategy Comparison")
133    print("=" * 60)
134    print(f"{'Strategy':<25} {'Time (s)':<12} {'Relative':<10}")
135    print("-" * 60)
136    print(f"{'Precompiled (class)':<25} {compiled_time:<12.4f} {'1.00x':<10}")
137    print(f"{'Inline (re cache)':<25} {inline_time:<12.4f} {inline_time/compiled_time:.2f}x")
138    print(f"{'Compile in loop':<25} {loop_compile_time:<12.4f} {loop_compile_time/compiled_time:.2f}x")

步驟 5：優化建議與驗證

根據分析結果，實作優化版本並驗證效果：

  1import re
  2from typing import List, Dict, Tuple
  3from dataclasses import dataclass
  4
  5@dataclass(slots=True)  # Python 3.10+ optimization
  6class LinkInfo:
  7    """Link information with memory-efficient storage"""
  8    text: str
  9    target: str
 10    line: int
 11
 12class OptimizedLinkChecker:
 13    """Optimized Markdown link checker based on profiling results"""
 14
 15    # Precompiled patterns at class level
 16    INLINE_LINK_PATTERN = re.compile(r'(?)
 17    REFERENCE_DEF_PATTERN = re.compile(r'^\s*\[([^\]]+)\]:\s*(.+)$', re.MULTILINE)
 18    REFERENCE_USE_PATTERN = re.compile(r'\[([^\]]+)\]\[([^\]]+)\]')
 19    CODE_BLOCK_PATTERN = re.compile(r'^```')
 20
 21    def parse_markdown_links_optimized(self, content: str) -> List[LinkInfo]:
 22        """
 23        Optimized link parsing with reduced memory allocation
 24
 25        Optimizations:
 26        1. Use dataclass with slots for link storage
 27        2. Single pass where possible
 28        3. Avoid repeated string operations
 29        4. Use local variables for frequently accessed attributes
 30        """
 31        links = []
 32
 33        # Cache pattern references for faster access
 34        inline_pattern = self.INLINE_LINK_PATTERN
 35        ref_use_pattern = self.REFERENCE_USE_PATTERN
 36        ref_def_pattern = self.REFERENCE_DEF_PATTERN
 37
 38        # Collect reference definitions first (single pass over content)
 39        reference_defs = {
 40            match.group(1).lower(): match.group(2).strip()
 41            for match in ref_def_pattern.finditer(content)
 42        }
 43
 44        # Process line by line
 45        in_code_block = False
 46        line_start = 0
 47
 48        for line_num, line_end in enumerate(
 49            self._find_line_positions(content), start=1
 50        ):
 51            line = content[line_start:line_end]
 52
 53            # Fast code block check
 54            if line.lstrip().startswith("```"):
 55                in_code_block = not in_code_block
 56                line_start = line_end + 1
 57                continue
 58
 59            if not in_code_block:
 60                # Parse inline links
 61                for match in inline_pattern.finditer(line):
 62                    links.append(LinkInfo(
 63                        text=match.group(1),
 64                        target=match.group(2),
 65                        line=line_num
 66                    ))
 67
 68                # Parse reference links
 69                for match in ref_use_pattern.finditer(line):
 70                    ref_name = match.group(2).lower()
 71                    target = reference_defs.get(ref_name)
 72                    if target:
 73                        links.append(LinkInfo(
 74                            text=match.group(1),
 75                            target=target,
 76                            line=line_num
 77                        ))
 78
 79            line_start = line_end + 1
 80
 81        return links
 82
 83    def _find_line_positions(self, content: str):
 84        """Generator that yields line end positions"""
 85        pos = 0
 86        while True:
 87            newline = content.find('\n', pos)
 88            if newline == -1:
 89                yield len(content)
 90                break
 91            yield newline
 92            pos = newline + 1
 93
 94def verify_optimization():
 95    """Verify that optimizations maintain correctness and improve performance"""
 96    import time
 97
 98    # Generate test content
 99    test_content = generate_test_content(1000)
100
101    # Original implementation
102    original = MarkdownLinkChecker()
103
104    # Optimized implementation
105    optimized = OptimizedLinkChecker()
106
107    # Verify correctness
108    original_links = original.parse_markdown_links(test_content)
109    optimized_links = optimized.parse_markdown_links_optimized(test_content)
110
111    # Compare results
112    assert len(original_links) == len(optimized_links), \
113        f"Link count mismatch: {len(original_links)} vs {len(optimized_links)}"
114
115    for orig, opt in zip(original_links, optimized_links):
116        assert orig["text"] == opt.text, f"Text mismatch: {orig['text']} vs {opt.text}"
117        assert orig["target"] == opt.target, f"Target mismatch"
118        assert orig["line"] == opt.line, f"Line mismatch"
119
120    print("Correctness verified!")
121
122    # Benchmark
123    iterations = 100
124
125    # Original
126    start = time.perf_counter()
127    for _ in range(iterations):
128        original.parse_markdown_links(test_content)
129    original_time = time.perf_counter() - start
130
131    # Optimized
132    start = time.perf_counter()
133    for _ in range(iterations):
134        optimized.parse_markdown_links_optimized(test_content)
135    optimized_time = time.perf_counter() - start
136
137    print(f"\nPerformance Comparison ({iterations} iterations)")
138    print("=" * 50)
139    print(f"Original:  {original_time:.4f}s")
140    print(f"Optimized: {optimized_time:.4f}s")
141    print(f"Speedup:   {original_time / optimized_time:.2f}x")

完整程式碼

以下是整合所有分析功能的完整腳本：

  1#!/usr/bin/env python3
  2"""
  3Performance Profiling Script for Markdown Link Checker
  4
  5This script demonstrates various profiling techniques:
  61. cProfile for function-level analysis
  72. pstats for detailed statistics
  83. line_profiler for line-by-line analysis
  94. Regex pattern benchmarking
 105. Optimization verification
 11
 12Usage:
 13    python profiling_demo.py [--full|--quick|--regex|--verify]
 14"""
 15
 16import argparse
 17import cProfile
 18import pstats
 19import re
 20import sys
 21import time
 22from dataclasses import dataclass
 23from io import StringIO
 24from pathlib import Path
 25from pstats import SortKey
 26from typing import Dict, List, Optional
 27
 28# ===== Original Implementation =====
 29
 30class MarkdownLinkChecker:
 31    """Original Markdown link checker for comparison"""
 32
 33    INLINE_LINK_PATTERN = re.compile(r'(?)
 34    REFERENCE_DEF_PATTERN = re.compile(r'^\s*\[([^\]]+)\]:\s*(.+)$', re.MULTILINE)
 35    REFERENCE_USE_PATTERN = re.compile(r'\[([^\]]+)\]\[([^\]]+)\]')
 36
 37    def parse_markdown_links(self, content: str) -> List[Dict]:
 38        links = []
 39        lines = content.split('\n')
 40
 41        reference_defs = {}
 42        for match in self.REFERENCE_DEF_PATTERN.finditer(content):
 43            ref_name = match.group(1).lower()
 44            ref_target = match.group(2).strip()
 45            reference_defs[ref_name] = ref_target
 46
 47        in_code_block = False
 48
 49        for line_num, line in enumerate(lines, start=1):
 50            if line.strip().startswith("```"):
 51                in_code_block = not in_code_block
 52                continue
 53
 54            if in_code_block:
 55                continue
 56
 57            for match in self.INLINE_LINK_PATTERN.finditer(line):
 58                links.append({
 59                    "text": match.group(1),
 60                    "target": match.group(2),
 61                    "line": line_num
 62                })
 63
 64            for match in self.REFERENCE_USE_PATTERN.finditer(line):
 65                ref_name = match.group(2).lower()
 66                if ref_name in reference_defs:
 67                    links.append({
 68                        "text": match.group(1),
 69                        "target": reference_defs[ref_name],
 70                        "line": line_num
 71                    })
 72
 73        return links
 74
 75# ===== Test Data Generation =====
 76
 77def generate_test_content(num_links: int) -> str:
 78    """Generate test Markdown content"""
 79    lines = ["# Test Document\n\n"]
 80
 81    for i in range(num_links):
 82        if i % 3 == 0:
 83            lines.append(f"Check out [Link {i}](https://example.com/{i})\n")
 84        elif i % 3 == 1:
 85            lines.append(f"See [Reference {i}][ref{i}]\n")
 86        else:
 87            lines.append(f"Paragraph {i} with some text.\n")
 88
 89    lines.append("\n")
 90    for i in range(num_links):
 91        if i % 3 == 1:
 92            lines.append(f"[ref{i}]: https://example.com/ref/{i}\n")
 93
 94    return "".join(lines)
 95
 96# ===== Profiling Functions =====
 97
 98def run_cprofile_analysis(iterations: int = 50, num_links: int = 500):
 99    """Run cProfile analysis"""
100    print("Running cProfile Analysis")
101    print("=" * 70)
102
103    content = generate_test_content(num_links)
104    checker = MarkdownLinkChecker()
105
106    profiler = cProfile.Profile()
107    profiler.enable()
108
109    for _ in range(iterations):
110        checker.parse_markdown_links(content)
111
112    profiler.disable()
113
114    stats = pstats.Stats(profiler)
115    stats.sort_stats(SortKey.CUMULATIVE)
116
117    print(f"\nTop 15 functions by cumulative time:")
118    print("-" * 70)
119    stats.print_stats(15)
120
121    return stats
122
123def run_regex_benchmark():
124    """Benchmark different regex patterns"""
125    print("\nRegex Pattern Benchmark")
126    print("=" * 70)
127
128    content = generate_test_content(500)
129
130    patterns = {
131        "Original": re.compile(r'(?),
132        "Non-greedy inner": re.compile(r'(?),
133        "Anchored": re.compile(r'(?),
134    }
135
136    print(f"{'Pattern':<25} {'Time (ms)':<12} {'Matches':<10}")
137    print("-" * 50)
138
139    for name, pattern in patterns.items():
140        # Warmup
141        list(pattern.finditer(content))
142
143        # Benchmark
144        start = time.perf_counter()
145        for _ in range(100):
146            matches = list(pattern.finditer(content))
147        elapsed = (time.perf_counter() - start) * 1000
148
149        print(f"{name:<25} {elapsed:<12.2f} {len(matches):<10}")
150
151def run_compile_comparison():
152    """Compare precompiled vs inline regex"""
153    print("\nCompile Strategy Comparison")
154    print("=" * 70)
155
156    content = generate_test_content(500)
157    iterations = 100
158    pattern_str = r'(?
159
160    # Precompiled
161    compiled = re.compile(pattern_str)
162    start = time.perf_counter()
163    for _ in range(iterations):
164        list(compiled.finditer(content))
165    compiled_time = time.perf_counter() - start
166
167    # Inline (uses re module cache)
168    start = time.perf_counter()
169    for _ in range(iterations):
170        list(re.finditer(pattern_str, content))
171    inline_time = time.perf_counter() - start
172
173    print(f"{'Strategy':<25} {'Time (ms)':<12} {'Relative':<10}")
174    print("-" * 50)
175    print(f"{'Precompiled':<25} {compiled_time*1000:<12.2f} {'1.00x':<10}")
176    print(f"{'Inline (cached)':<25} {inline_time*1000:<12.2f} {inline_time/compiled_time:.2f}x")
177
178def main():
179    parser = argparse.ArgumentParser(description="Profiling Demo")
180    parser.add_argument('--full', action='store_true', help='Run full analysis')
181    parser.add_argument('--quick', action='store_true', help='Run quick analysis')
182    parser.add_argument('--regex', action='store_true', help='Run regex benchmark')
183    args = parser.parse_args()
184
185    if args.regex:
186        run_regex_benchmark()
187        run_compile_comparison()
188    elif args.quick:
189        run_cprofile_analysis(iterations=10, num_links=100)
190    else:
191        run_cprofile_analysis()
192        run_regex_benchmark()
193        run_compile_comparison()
194
195if __name__ == "__main__":
196    main()

分析結果範例

執行 cProfile 分析後的典型輸出：

 1Running cProfile Analysis
 2======================================================================
 3
 4Top 15 functions by cumulative time:
 5----------------------------------------------------------------------
 6         125003 function calls in 0.892 seconds
 7
 8   Ordered by: cumulative time
 9
10   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
11       50    0.012    0.000    0.892    0.018 checker.py:45(parse_markdown_links)
12    25000    0.234    0.000    0.567    0.000 {method 'finditer' of 're.Pattern'}
13       50    0.089    0.002    0.089    0.002 {method 'split' of 'str' objects}
14    50000    0.156    0.000    0.156    0.000 {method 'append' of 'list' objects}
15    25000    0.098    0.000    0.098    0.000 {method 'group' of 're.Match'}
16    12500    0.045    0.000    0.045    0.000 {method 'lower' of 'str' objects}
17    12500    0.034    0.000    0.034    0.000 {method 'strip' of 'str' objects}
18    25000    0.067    0.000    0.067    0.000 {method 'startswith' of 'str' objects}
19       50    0.023    0.000    0.023    0.000 {built-in method builtins.enumerate}

從上述結果可以觀察到：

finditer 佔用最多時間：正則表達式匹配是主要瓶頸
split 操作耗時明顯：每次解析都建立新的行列表
append 呼叫頻繁：大量的字典建立和列表操作

line_profiler 的典型輸出：

 1Timer unit: 1e-06 s
 2
 3Total time: 0.456 s
 4File: checker.py
 5Function: parse_markdown_links at line 45
 6
 7Line #      Hits         Time  Per Hit   % Time  Line Contents
 8==============================================================
 9    45                                           def parse_markdown_links(self, content):
10    46        50       1234.0     24.7      0.3      links = []
11    47        50      89012.0   1780.2     19.5      lines = content.split('\n')
12    48
13    49        50         56.0      1.1      0.0      reference_defs = {}
14    50      2500      45678.0     18.3     10.0      for match in self.REFERENCE_DEF_PATTERN.finditer(content):
15    51      2450       3456.0      1.4      0.8          ref_name = match.group(1).lower()
16    52      2450       2345.0      1.0      0.5          ref_target = match.group(2).strip()
17    53      2450       1234.0      0.5      0.3          reference_defs[ref_name] = ref_target
18    54
19    55        50         34.0      0.7      0.0      in_code_block = False
20    56
21    57     25050      12345.0      0.5      2.7      for line_num, line in enumerate(lines, start=1):
22    58     25000      34567.0      1.4      7.6          if line.strip().startswith("```"):
23    59                                                       in_code_block = not in_code_block
24    60                                                       continue
25    61
26    62     25000       5678.0      0.2      1.2          if in_code_block:
27    63                                                       continue
28    64
29    65     25000     156789.0      6.3     34.4          for match in self.INLINE_LINK_PATTERN.finditer(line):
30    66      8350      23456.0      2.8      5.1              links.append({...})
31    67
32    68     25000      78901.0      3.2     17.3          for match in self.REFERENCE_USE_PATTERN.finditer(line):
33    69      2450       1234.0      0.5      0.3              ref_name = match.group(2).lower()
34    70      2450        567.0      0.2      0.1              if ref_name in reference_defs:
35    71      2450       1234.0      0.5      0.3                  links.append({...})
36    72
37    73        50         23.0      0.5      0.0      return links

關鍵發現：

第 65 行（行內連結匹配）佔 34.4%：這是最大的瓶頸
第 47 行（split）佔 19.5%：字串分割是第二大消耗
第 68 行（引用連結匹配）佔 17.3%：也是重要的優化目標

設計權衡

面向	不分析	使用 cProfile	使用 line_profiler
開發時間	少	中等	較多
分析粒度	無	函式級	行級
效能開銷	無	低	較高
適用場景	簡單程式	一般優化	精確定位
學習成本	無	低	中等
結果準確度	-	高	非常高

什麼時候該做效能分析？

適合分析：

程式明顯變慢
處理大量資料
發布前的效能驗證
正則表達式複雜時
有迴圈處理大量項目

不建議過早優化：

功能還在開發中
使用頻率很低
效能已經足夠
可讀性更重要時

練習

基礎練習：用 cProfile 分析排序函式

 1"""
 2Exercise 1: Profile different sorting approaches
 3"""
 4import cProfile
 5import pstats
 6import random
 7from pstats import SortKey
 8
 9def bubble_sort(arr):
10    """Bubble sort implementation"""
11    n = len(arr)
12    arr = arr.copy()
13    for i in range(n):
14        for j in range(0, n - i - 1):
15            if arr[j] > arr[j + 1]:
16                arr[j], arr[j + 1] = arr[j + 1], arr[j]
17    return arr
18
19def quick_sort(arr):
20    """Quick sort implementation"""
21    if len(arr) <= 1:
22        return arr
23    pivot = arr[len(arr) // 2]
24    left = [x for x in arr if x < pivot]
25    middle = [x for x in arr if x == pivot]
26    right = [x for x in arr if x > pivot]
27    return quick_sort(left) + middle + quick_sort(right)
28
29def profile_sorting():
30    """Profile and compare sorting algorithms"""
31    data = [random.randint(0, 10000) for _ in range(1000)]
32
33    # Profile bubble sort
34    profiler = cProfile.Profile()
35    profiler.enable()
36    bubble_sort(data)
37    profiler.disable()
38
39    print("Bubble Sort Profile:")
40    stats = pstats.Stats(profiler)
41    stats.sort_stats(SortKey.TIME).print_stats(5)
42
43    # Profile quick sort
44    profiler = cProfile.Profile()
45    profiler.enable()
46    quick_sort(data)
47    profiler.disable()
48
49    print("\nQuick Sort Profile:")
50    stats = pstats.Stats(profiler)
51    stats.sort_stats(SortKey.TIME).print_stats(5)
52
53if __name__ == "__main__":
54    profile_sorting()

進階練習：用 line_profiler 找出熱點程式碼

 1"""
 2Exercise 2: Use line_profiler to find hotspots
 3
 4Instructions:
 51. Install line_profiler: pip install line_profiler
 62. Add @profile decorator to functions you want to analyze
 73. Run: kernprof -l -v exercise2.py
 8"""
 9from line_profiler import profile
10
11@profile
12def find_primes(n):
13    """Find all prime numbers up to n"""
14    primes = []
15    for num in range(2, n + 1):
16        is_prime = True
17        for i in range(2, int(num ** 0.5) + 1):
18            if num % i == 0:
19                is_prime = False
20                break
21        if is_prime:
22            primes.append(num)
23    return primes
24
25@profile
26def find_primes_sieve(n):
27    """Find primes using Sieve of Eratosthenes"""
28    sieve = [True] * (n + 1)
29    sieve[0] = sieve[1] = False
30
31    for i in range(2, int(n ** 0.5) + 1):
32        if sieve[i]:
33            for j in range(i * i, n + 1, i):
34                sieve[j] = False
35
36    return [i for i, is_prime in enumerate(sieve) if is_prime]
37
38if __name__ == "__main__":
39    print("Finding primes up to 10000...")
40    primes1 = find_primes(10000)
41    primes2 = find_primes_sieve(10000)
42    print(f"Found {len(primes1)} primes (basic)")
43    print(f"Found {len(primes2)} primes (sieve)")

挑戰題：比較不同正則表達式寫法的效能差異

 1"""
 2Exercise 3: Compare regex pattern performance
 3
 4Task: Parse email addresses from text using different patterns
 5and measure their performance.
 6"""
 7import re
 8import time
 9
10def benchmark_email_patterns():
11    """Compare different email regex patterns"""
12
13    # Test content with mixed valid and invalid emails
14    test_text = """
15    Contact us at support@example.com or sales@company.org
16    Invalid: not.an.email, @missing.com, missing@
17    Valid: user.name+tag@domain.co.uk, test123@sub.domain.com
18    Edge cases: "quoted"@domain.com, user@[192.168.1.1]
19    """ * 1000
20
21    patterns = {
22        # Simple pattern (may miss some valid emails)
23        "simple": re.compile(r'\b[\w.-]+@[\w.-]+\.\w+\b'),
24
25        # More comprehensive pattern
26        "comprehensive": re.compile(
27            r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
28        ),
29
30        # RFC 5322 inspired (complex but thorough)
31        "rfc_inspired": re.compile(
32            r'(?:[a-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&\'*+/=?^_`{|}~-]+)*'
33            r'|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]'
34            r'|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")'
35            r'@(?:(?:[a-z0-9](/python-advanced/04-cpython-internals/case-studies/profiling/?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](/python-advanced/04-cpython-internals/case-studies/profiling/?:[a-z0-9-]*[a-z0-9])?'
36            r'|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}'
37            r'(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:'
38            r'(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]'
39            r'|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])',
40            re.IGNORECASE
41        ),
42    }
43
44    print("Email Pattern Performance Comparison")
45    print("=" * 60)
46    print(f"{'Pattern':<20} {'Time (ms)':<12} {'Matches':<10}")
47    print("-" * 60)
48
49    for name, pattern in patterns.items():
50        # Warmup
51        list(pattern.findall(test_text))
52
53        # Benchmark
54        start = time.perf_counter()
55        for _ in range(100):
56            matches = pattern.findall(test_text)
57        elapsed = (time.perf_counter() - start) * 1000
58
59        print(f"{name:<20} {elapsed:<12.2f} {len(matches):<10}")
60
61    # Your task: Add more patterns and analyze the results
62    # Consider: What trade-offs exist between accuracy and speed?
63
64if __name__ == "__main__":
65    benchmark_email_patterns()

延伸閱讀

下一章：記憶體優化

3.1 PyObject 與物件模型

Tue, 20 Jan 2026 00:00:00 +0000

Python 中「一切皆物件」不只是一句口號，而是 CPython 實現的核心設計。理解 PyObject 是深入 Python 內部的第一步。

先備知識

進階系列模組二：元編程
基本的 C 語言知識（結構體、指標）

本章目標

學完本章後，你將能夠：

理解 PyObject 結構
理解參考計數的工作原理
解釋「一切皆物件」的實現方式
觀察物件的記憶體佈局

【原理層】一切皆物件

什麼是「一切皆物件」？

在 Python 中，所有東西都是物件：

 1# 數字是物件
 2x = 42
 3print(type(x))        # 
 4print(x.__class__)    # 
 5print(x.bit_length()) # 6（呼叫方法）
 6
 7# 函式是物件
 8def hello():
 9    pass
10print(type(hello))    # 
11print(hello.__name__) # hello
12
13# 類別是物件
14class MyClass:
15    pass
16print(type(MyClass))  # 
17
18# 甚至 type 本身也是物件
19print(type(type))     #

PyObject 結構

在 C 語言層面，所有 Python 物件都基於 PyObject 結構：

1// CPython 原始碼中的定義（簡化版）
2typedef struct _object {
3    Py_ssize_t ob_refcnt;  // 參考計數
4    PyTypeObject *ob_type; // 型別指標
5} PyObject;

每個 Python 物件在記憶體中至少包含這兩個欄位：

1┌─────────────────────────────────────┐
2│           PyObject                   │
3├─────────────────────────────────────┤
4│  ob_refcnt (參考計數)    8 bytes    │
5│  ob_type   (型別指標)    8 bytes    │
6├─────────────────────────────────────┤
7│  ... 物件特定的資料 ...              │
8└─────────────────────────────────────┘

變長物件：PyVarObject

對於長度可變的物件（如 list、str），使用 PyVarObject：

1typedef struct {
2    PyObject ob_base;
3    Py_ssize_t ob_size;  // 元素數量
4} PyVarObject;

1┌─────────────────────────────────────┐
2│         PyVarObject                  │
3├─────────────────────────────────────┤
4│  ob_refcnt (參考計數)    8 bytes    │
5│  ob_type   (型別指標)    8 bytes    │
6│  ob_size   (元素數量)    8 bytes    │
7├─────────────────────────────────────┤
8│  ... 元素資料 ...                    │
9└─────────────────────────────────────┘

【設計層】參考計數

工作原理

Python 使用參考計數來追蹤物件的使用：

 1import sys
 2
 3a = [1, 2, 3]
 4print(sys.getrefcount(a))  # 2（a 本身 + getrefcount 的參數）
 5
 6b = a  # 增加參考
 7print(sys.getrefcount(a))  # 3
 8
 9del b  # 減少參考
10print(sys.getrefcount(a))  # 2

參考計數的增減時機

 1# 增加參考計數的操作
 2x = obj          # 賦值
 3container.append(obj)  # 加入容器
 4func(obj)        # 作為參數傳遞
 5
 6# 減少參考計數的操作
 7del x            # 刪除變數
 8x = other        # 重新賦值
 9container.remove(obj)  # 從容器移除
10函式返回         # 區域變數離開作用域

參考計數的優缺點

優點	缺點
即時回收	無法處理循環參考
可預測的記憶體使用	每次操作都要更新計數
簡單易理解	多執行緒下需要鎖（GIL 的原因之一）

【實作層】觀察物件

使用 id() 觀察記憶體位址

 1a = [1, 2, 3]
 2b = a
 3c = [1, 2, 3]
 4
 5print(id(a))  # 140234567890112
 6print(id(b))  # 140234567890112（同一物件）
 7print(id(c))  # 140234567890176（不同物件）
 8
 9print(a is b)  # True
10print(a is c)  # False
11print(a == c)  # True（值相等）

小整數快取

CPython 對 -5 到 256 的整數進行快取：

 1a = 256
 2b = 256
 3print(a is b)  # True（同一物件）
 4
 5a = 257
 6b = 257
 7print(a is b)  # False（不同物件）
 8
 9# 但在同一行的情況可能會被編譯器優化
10a, b = 257, 257
11print(a is b)  # True（編譯時優化）

字串駐留（String Interning）

簡單的字串會被自動駐留：

 1a = "hello"
 2b = "hello"
 3print(a is b)  # True（駐留）
 4
 5a = "hello world"
 6b = "hello world"
 7print(a is b)  # False（含空格，不駐留）
 8
 9# 手動駐留
10import sys
11a = sys.intern("hello world")
12b = sys.intern("hello world")
13print(a is b)  # True

使用 ctypes 觀察記憶體

 1import ctypes
 2import sys
 3
 4def get_refcount(obj_id):
 5    """直接從記憶體讀取參考計數"""
 6    return ctypes.c_long.from_address(obj_id).value
 7
 8a = [1, 2, 3]
 9obj_id = id(a)
10
11print(f"sys.getrefcount: {sys.getrefcount(a)}")
12print(f"ctypes 直接讀取: {get_refcount(obj_id)}")
13# 注意：sys.getrefcount 會多 1（因為參數傳遞）

觀察物件大小

 1import sys
 2
 3# 基本物件大小
 4print(sys.getsizeof(None))      # 16
 5print(sys.getsizeof(True))      # 28
 6print(sys.getsizeof(0))         # 28
 7print(sys.getsizeof(1))         # 28
 8print(sys.getsizeof(10**100))   # 72（大整數）
 9
10# 容器大小（不包含元素）
11print(sys.getsizeof([]))        # 56
12print(sys.getsizeof([1, 2, 3])) # 88
13print(sys.getsizeof({}))        # 64
14
15# 注意：getsizeof 不遞迴計算
16nested = [[1, 2], [3, 4]]
17print(sys.getsizeof(nested))    # 只計算外層 list

【深入】PyTypeObject

型別物件的結構

每個型別（int、str、list 等）都是 PyTypeObject 的實例：

 1// 簡化版
 2typedef struct _typeobject {
 3    PyObject_VAR_HEAD
 4    const char *tp_name;       // 型別名稱
 5    Py_ssize_t tp_basicsize;   // 基本大小
 6    Py_ssize_t tp_itemsize;    // 元素大小（變長物件）
 7
 8    // 方法槽（slots）
 9    destructor tp_dealloc;     // 解構函式
10    reprfunc tp_repr;          // __repr__
11    hashfunc tp_hash;          // __hash__
12    // ... 更多方法槽
13} PyTypeObject;

在 Python 中觀察型別資訊

 1# 型別的基本資訊
 2print(int.__name__)       # int
 3print(int.__basicsize__)  # 28（64-bit 系統）
 4
 5# 方法解析順序
 6class A: pass
 7class B(A): pass
 8class C(B): pass
 9
10print(C.__mro__)
11# (, , , )
12
13# 型別的型別
14print(type(int))    # 
15print(type(type))   # （type 是自己的實例）

為什麼 is 比 == 快？

 1# is 只比較記憶體位址（一個指標比較）
 2# == 需要呼叫 __eq__ 方法（可能很複雜）
 3
 4import timeit
 5
 6a = [1, 2, 3]
 7b = a
 8c = [1, 2, 3]
 9
10# is 比較（非常快）
11print(timeit.timeit('a is b', globals=globals(), number=1000000))
12# 約 0.02 秒
13
14# == 比較（需要比較內容）
15print(timeit.timeit('a == c', globals=globals(), number=1000000))
16# 約 0.05 秒

【實戰】效能影響

避免不必要的物件建立

 1# 不好：每次迭代都建立新的 tuple
 2for i in range(1000):
 3    point = (i, i * 2)
 4
 5# 好：如果結構固定，考慮使用 __slots__ 的類別
 6class Point:
 7    __slots__ = ['x', 'y']
 8    def __init__(self, x, y):
 9        self.x = x
10        self.y = y
11
12# 或者使用 namedtuple
13from collections import namedtuple
14Point = namedtuple('Point', ['x', 'y'])

使用物件池

 1# 對於頻繁建立的小物件，考慮重複使用
 2class ObjectPool:
 3    def __init__(self, factory, max_size=100):
 4        self._factory = factory
 5        self._pool = []
 6        self._max_size = max_size
 7
 8    def acquire(self):
 9        if self._pool:
10            return self._pool.pop()
11        return self._factory()
12
13    def release(self, obj):
14        if len(self._pool) < self._max_size:
15            self._pool.append(obj)
16
17# 使用
18pool = ObjectPool(list)
19lst = pool.acquire()
20lst.extend([1, 2, 3])
21# 使用完畢
22lst.clear()
23pool.release(lst)

思考題

為什麼 CPython 選擇 -5 到 256 作為小整數快取的範圍？
如果參考計數是 Python 物件的核心，那多執行緒時會發生什麼問題？
None 是單例，這是如何實現的？

實作練習

寫一個函式，計算一個巢狀資料結構的「真實」記憶體使用量
使用 ctypes 觀察 list 物件的內部結構
實驗不同大小的整數的 is 行為

延伸閱讀

下一章：記憶體管理與垃圾回收

案例：記憶體優化

Wed, 21 Jan 2026 00:00:00 +0000

本案例基於 .claude/lib/config_loader.py 的實際程式碼，展示如何用 __slots__ 和 weakref 優化記憶體使用。

先備知識

問題背景

現有設計

config_loader.py 使用全域字典作為快取，這是一個常見的設計模式：

 1# Global cache variables
 2_agents_config_cache: Optional[dict] = None
 3_quality_rules_cache: Optional[dict] = None
 4
 5def load_agents_config() -> dict:
 6    """
 7    載入代理人配置
 8
 9    使用模組層級變數作為快取，避免重複讀取檔案。
10    """
11    global _agents_config_cache
12    if _agents_config_cache is None:
13        try:
14            _agents_config_cache = load_config("agents")
15        except FileNotFoundError:
16            _agents_config_cache = _get_default_agents_config()
17    return _agents_config_cache
18
19def clear_config_cache() -> None:
20    """清除配置快取（用於測試或配置熱更新）"""
21    global _agents_config_cache, _quality_rules_cache
22    _agents_config_cache = None
23    _quality_rules_cache = None

這種設計簡單直觀，但當系統需要快取更複雜的物件時，會遇到記憶體問題。

記憶體問題

當快取大量物件時：

Python 字典有額外開銷：每個字典需要維護 hash table、keys、values
物件的 __dict__ 佔用記憶體：每個實例都有自己的屬性字典
快取可能導致記憶體洩漏：強引用阻止物件被回收

讓我們用一個更複雜的快取場景來說明問題：

 1import sys
 2
 3class ConfigItem:
 4    """配置項目，模擬複雜的快取物件"""
 5    def __init__(self, key: str, value: str, metadata: dict):
 6        self.key = key
 7        self.value = value
 8        self.metadata = metadata
 9        self.access_count = 0
10        self.last_accessed = None
11
12# Create a config item and measure memory
13item = ConfigItem("database.host", "localhost", {"type": "string"})
14
15# Object size
16print(f"ConfigItem size: {sys.getsizeof(item)} bytes")
17# ConfigItem size: 48 bytes
18
19# But the real cost is in __dict__
20print(f"__dict__ size: {sys.getsizeof(item.__dict__)} bytes")
21# __dict__ size: 184 bytes

當快取數萬個這樣的物件時，記憶體開銷會非常可觀。

進階解決方案

優化目標

減少每個物件的記憶體佔用
避免快取導致的記憶體洩漏
保持 API 不變

實作步驟

步驟 1：使用 `slots` 減少物件大小

__slots__ 告訴 Python 這個類別只會有哪些屬性，讓直譯器可以用更緊湊的方式儲存資料：

 1import sys
 2
 3class ConfigItemWithoutSlots:
 4    """標準類別，使用 __dict__"""
 5    def __init__(self, key: str, value: str, metadata: dict):
 6        self.key = key
 7        self.value = value
 8        self.metadata = metadata
 9        self.access_count = 0
10        self.last_accessed = None
11
12class ConfigItemWithSlots:
13    """使用 __slots__ 優化記憶體"""
14    __slots__ = ['key', 'value', 'metadata', 'access_count', 'last_accessed']
15
16    def __init__(self, key: str, value: str, metadata: dict):
17        self.key = key
18        self.value = value
19        self.metadata = metadata
20        self.access_count = 0
21        self.last_accessed = None
22
23# Compare memory usage
24item_without = ConfigItemWithoutSlots("db.host", "localhost", {"type": "str"})
25item_with = ConfigItemWithSlots("db.host", "localhost", {"type": "str"})
26
27print(f"Without __slots__: {sys.getsizeof(item_without)} bytes")
28print(f"With __slots__:    {sys.getsizeof(item_with)} bytes")
29
30# The real difference is __dict__
31print(f"__dict__ overhead: {sys.getsizeof(item_without.__dict__)} bytes")
32# item_with has no __dict__!
33try:
34    item_with.__dict__
35except AttributeError as e:
36    print(f"No __dict__: {e}")

記憶體結構比較

 1沒有 __slots__:
 2┌──────────────────────────────────┐
 3│ PyObject header         (16 B)   │
 4│ __dict__ 指標            (8 B)   │
 5│ __weakref__ 指標         (8 B)   │
 6│                                  │
 7│ __dict__ (separate object):      │
 8│   - hash table          (64 B)   │
 9│   - keys array          (40 B)   │
10│   - values array        (40 B)   │
11│   - key strings        (~80 B)   │
12│                                  │
13│ Total: ~256 bytes per object     │
14└──────────────────────────────────┘
15
16有 __slots__:
17┌──────────────────────────────────┐
18│ PyObject header         (16 B)   │
19│ key slot                 (8 B)   │
20│ value slot               (8 B)   │
21│ metadata slot            (8 B)   │
22│ access_count slot        (8 B)   │
23│ last_accessed slot       (8 B)   │
24│                                  │
25│ Total: ~56 bytes per object      │
26└──────────────────────────────────┘

大量物件的記憶體節省

 1import sys
 2import tracemalloc
 3
 4def measure_memory(cls, count=10000):
 5    """Measure memory for creating multiple objects"""
 6    tracemalloc.start()
 7
 8    objects = [
 9        cls(f"key_{i}", f"value_{i}", {"index": i})
10        for i in range(count)
11    ]
12
13    current, peak = tracemalloc.get_traced_memory()
14    tracemalloc.stop()
15
16    return current, peak, objects
17
18# Measure both classes
19mem_without, peak_without, _ = measure_memory(ConfigItemWithoutSlots)
20mem_with, peak_with, _ = measure_memory(ConfigItemWithSlots)
21
22print(f"Without __slots__: {mem_without / 1024 / 1024:.2f} MB")
23print(f"With __slots__:    {mem_with / 1024 / 1024:.2f} MB")
24print(f"Savings:           {(mem_without - mem_with) / 1024 / 1024:.2f} MB")
25print(f"Ratio:             {mem_without / mem_with:.1f}x")
26
27# Typical output:
28# Without __slots__: 3.82 MB
29# With __slots__:    1.15 MB
30# Savings:           2.67 MB
31# Ratio:             3.3x

步驟 2：使用 weakref 避免強引用

weakref 讓我們可以引用物件，但不阻止它被垃圾回收：

 1import weakref
 2
 3class CacheableConfig:
 4    """可以被弱引用的配置物件"""
 5    __slots__ = ['key', 'value', '_data', '__weakref__']  # Note: __weakref__ slot
 6
 7    def __init__(self, key: str, value: str):
 8        self.key = key
 9        self.value = value
10        self._data = None
11
12    def __repr__(self):
13        return f"CacheableConfig({self.key!r}, {self.value!r})"
14
15# Create object and weak reference
16config = CacheableConfig("app.name", "MyApp")
17weak_ref = weakref.ref(config)
18
19print(f"Object exists: {weak_ref()}")
20# Object exists: CacheableConfig('app.name', 'MyApp')
21
22# Delete the strong reference
23del config
24
25print(f"After del: {weak_ref()}")
26# After del: None

使用 callback 追蹤物件回收

 1import weakref
 2
 3def on_finalize(ref):
 4    """Callback when object is garbage collected"""
 5    print(f"Object was garbage collected!")
 6
 7config = CacheableConfig("db.port", "5432")
 8weak_ref = weakref.ref(config, on_finalize)
 9
10print("Deleting object...")
11del config
12# Output: Object was garbage collected!

步驟 3：使用 WeakValueDictionary

WeakValueDictionary 是實作自動清理快取的利器：

 1import weakref
 2from typing import Callable, TypeVar, Generic
 3
 4T = TypeVar('T')
 5
 6class WeakCache(Generic[T]):
 7    """
 8    Auto-cleaning cache using weak references.
 9
10    Objects are automatically removed from cache when no strong
11    references exist outside the cache.
12    """
13
14    def __init__(self):
15        self._cache: weakref.WeakValueDictionary[str, T] = (
16            weakref.WeakValueDictionary()
17        )
18        self._hits = 0
19        self._misses = 0
20
21    def get(self, key: str, factory: Callable[[], T]) -> T:
22        """
23        Get item from cache, creating it if necessary.
24
25        Args:
26            key: Cache key
27            factory: Function to create value if not cached
28
29        Returns:
30            Cached or newly created value
31        """
32        value = self._cache.get(key)
33        if value is not None:
34            self._hits += 1
35            return value
36
37        self._misses += 1
38        value = factory()
39        self._cache[key] = value
40        return value
41
42    def __len__(self) -> int:
43        return len(self._cache)
44
45    def stats(self) -> dict:
46        """Return cache statistics"""
47        total = self._hits + self._misses
48        hit_rate = self._hits / total if total > 0 else 0
49        return {
50            "hits": self._hits,
51            "misses": self._misses,
52            "hit_rate": f"{hit_rate:.1%}",
53            "size": len(self._cache),
54        }
55
56# Demo: automatic cleanup
57cache = WeakCache[CacheableConfig]()
58
59# Create and cache object
60config1 = cache.get("app.name", lambda: CacheableConfig("app.name", "MyApp"))
61config2 = cache.get("app.name", lambda: CacheableConfig("app.name", "MyApp"))  # Cache hit
62
63print(f"Cache size: {len(cache)}")  # 1
64print(f"Same object: {config1 is config2}")  # True
65print(f"Stats: {cache.stats()}")  # hits=1, misses=1
66
67# Delete strong reference
68del config1
69del config2
70
71# Object is garbage collected, cache is auto-cleaned
72import gc
73gc.collect()
74
75print(f"Cache size after cleanup: {len(cache)}")  # 0

步驟 4：測量記憶體使用

使用 sys.getsizeof 和 tracemalloc 進行精確測量：

 1import sys
 2import tracemalloc
 3from pympler import asizeof  # pip install pympler
 4
 5def measure_object_size(obj, label="Object"):
 6    """Measure object size using different methods"""
 7
 8    # Basic size (doesn't include referenced objects)
 9    basic = sys.getsizeof(obj)
10
11    # Deep size (includes all referenced objects)
12    # Using pympler for accurate measurement
13    deep = asizeof.asizeof(obj)
14
15    print(f"{label}:")
16    print(f"  sys.getsizeof: {basic:,} bytes")
17    print(f"  pympler deep:  {deep:,} bytes")
18
19    return basic, deep
20
21# Compare different object types
22item_without = ConfigItemWithoutSlots("key", "value", {"a": 1, "b": 2})
23item_with = ConfigItemWithSlots("key", "value", {"a": 1, "b": 2})
24
25measure_object_size(item_without, "Without __slots__")
26measure_object_size(item_with, "With __slots__")
27
28# Using tracemalloc for allocation tracking
29def track_allocations():
30    """Track memory allocations during execution"""
31    tracemalloc.start()
32
33    # Simulate creating many cached objects
34    items = []
35    for i in range(1000):
36        items.append(ConfigItemWithSlots(
37            f"config.item.{i}",
38            f"value_{i}",
39            {"index": i, "active": True}
40        ))
41
42    # Get snapshot
43    snapshot = tracemalloc.take_snapshot()
44    top_stats = snapshot.statistics('lineno')
45
46    print("\nTop 5 memory allocations:")
47    for stat in top_stats[:5]:
48        print(f"  {stat}")
49
50    # Get traced memory
51    current, peak = tracemalloc.get_traced_memory()
52    print(f"\nCurrent memory: {current / 1024:.1f} KB")
53    print(f"Peak memory:    {peak / 1024:.1f} KB")
54
55    tracemalloc.stop()
56    return items
57
58track_allocations()

比較記憶體差異的完整腳本

 1import sys
 2import gc
 3import tracemalloc
 4from dataclasses import dataclass
 5
 6class StandardConfig:
 7    """Standard class with __dict__"""
 8    def __init__(self, key, value, metadata):
 9        self.key = key
10        self.value = value
11        self.metadata = metadata
12        self.hits = 0
13
14class SlottedConfig:
15    """Optimized with __slots__"""
16    __slots__ = ['key', 'value', 'metadata', 'hits']
17
18    def __init__(self, key, value, metadata):
19        self.key = key
20        self.value = value
21        self.metadata = metadata
22        self.hits = 0
23
24@dataclass
25class DataclassConfig:
26    """Using dataclass"""
27    key: str
28    value: str
29    metadata: dict
30    hits: int = 0
31
32@dataclass(slots=True)  # Python 3.10+
33class SlottedDataclass:
34    """Dataclass with __slots__"""
35    key: str
36    value: str
37    metadata: dict
38    hits: int = 0
39
40def benchmark_memory(cls, count=10000, label=""):
41    """Benchmark memory usage for a class"""
42    gc.collect()
43    tracemalloc.start()
44
45    objects = [
46        cls(f"key_{i}", f"value_{i}", {"index": i})
47        for i in range(count)
48    ]
49
50    current, peak = tracemalloc.get_traced_memory()
51    tracemalloc.stop()
52
53    per_object = current / count
54    print(f"{label or cls.__name__:25} | "
55          f"{current/1024:8.1f} KB | "
56          f"{per_object:6.1f} B/obj")
57
58    return objects  # Keep reference to prevent GC
59
60print(f"{'Class':25} | {'Total':>10} | {'Per Object':>10}")
61print("-" * 55)
62
63benchmark_memory(StandardConfig)
64benchmark_memory(SlottedConfig)
65benchmark_memory(DataclassConfig)
66benchmark_memory(SlottedDataclass)
67
68# Typical output:
69# Class                     |      Total |  Per Object
70# -------------------------------------------------------
71# StandardConfig            |   2578.5 KB |  263.6 B/obj
72# SlottedConfig             |    859.4 KB |   87.9 B/obj
73# DataclassConfig           |   2656.3 KB |  271.6 B/obj
74# SlottedDataclass          |    898.4 KB |   91.9 B/obj

完整程式碼

以下是整合所有優化技術的完整實作：

  1"""
  2Memory-optimized configuration cache system.
  3
  4This module demonstrates:
  5- Using __slots__ to reduce object memory footprint
  6- Using weakref for automatic cache cleanup
  7- Using tracemalloc for memory profiling
  8
  9Based on patterns from .claude/lib/config_loader.py
 10"""
 11
 12import weakref
 13import sys
 14import gc
 15import tracemalloc
 16from typing import Any, Callable, Generic, Optional, TypeVar
 17from pathlib import Path
 18from datetime import datetime
 19
 20T = TypeVar('T')
 21
 22class ConfigEntry:
 23    """
 24    Memory-optimized configuration entry.
 25
 26    Uses __slots__ to reduce memory footprint by ~3x compared
 27    to regular classes.
 28    """
 29    __slots__ = [
 30        'key', 'value', 'source', 'loaded_at',
 31        'access_count', '__weakref__'
 32    ]
 33
 34    def __init__(
 35        self,
 36        key: str,
 37        value: Any,
 38        source: Optional[str] = None
 39    ):
 40        self.key = key
 41        self.value = value
 42        self.source = source
 43        self.loaded_at = datetime.now()
 44        self.access_count = 0
 45
 46    def __repr__(self) -> str:
 47        return (
 48            f"ConfigEntry(key={self.key!r}, "
 49            f"value={self.value!r}, "
 50            f"accesses={self.access_count})"
 51        )
 52
 53    def touch(self) -> None:
 54        """Record an access to this entry"""
 55        self.access_count += 1
 56
 57class SmartConfigCache:
 58    """
 59    Smart configuration cache with automatic memory management.
 60
 61    Features:
 62    - Weak references for automatic cleanup
 63    - Memory usage tracking
 64    - Hit/miss statistics
 65    - Optional size limits
 66
 67    Example:
 68        cache = SmartConfigCache(max_size=1000)
 69
 70        # Get or create config
 71        config = cache.get_or_create(
 72            "database.host",
 73            lambda: ConfigEntry("database.host", "localhost", "env")
 74        )
 75
 76        # Check stats
 77        print(cache.stats())
 78    """
 79
 80    def __init__(self, max_size: Optional[int] = None):
 81        """
 82        Initialize the cache.
 83
 84        Args:
 85            max_size: Maximum number of entries. None for unlimited.
 86        """
 87        self._cache: weakref.WeakValueDictionary[str, ConfigEntry] = (
 88            weakref.WeakValueDictionary()
 89        )
 90        self._strong_refs: dict[str, ConfigEntry] = {}  # Keep important items
 91        self._max_size = max_size
 92        self._hits = 0
 93        self._misses = 0
 94        self._evictions = 0
 95
 96    def get(self, key: str) -> Optional[ConfigEntry]:
 97        """
 98        Get entry from cache.
 99
100        Args:
101            key: Configuration key
102
103        Returns:
104            ConfigEntry if found, None otherwise
105        """
106        # Check strong refs first
107        entry = self._strong_refs.get(key)
108        if entry is not None:
109            self._hits += 1
110            entry.touch()
111            return entry
112
113        # Then check weak refs
114        entry = self._cache.get(key)
115        if entry is not None:
116            self._hits += 1
117            entry.touch()
118            return entry
119
120        self._misses += 1
121        return None
122
123    def get_or_create(
124        self,
125        key: str,
126        factory: Callable[[], ConfigEntry],
127        keep_strong: bool = False
128    ) -> ConfigEntry:
129        """
130        Get existing entry or create new one.
131
132        Args:
133            key: Configuration key
134            factory: Function to create entry if not found
135            keep_strong: If True, keep a strong reference (won't auto-cleanup)
136
137        Returns:
138            Existing or newly created ConfigEntry
139        """
140        entry = self.get(key)
141        if entry is not None:
142            return entry
143
144        # Create new entry
145        entry = factory()
146        self._cache[key] = entry
147
148        if keep_strong:
149            self._enforce_size_limit()
150            self._strong_refs[key] = entry
151
152        return entry
153
154    def _enforce_size_limit(self) -> None:
155        """Evict old entries if cache is full"""
156        if self._max_size is None:
157            return
158
159        while len(self._strong_refs) >= self._max_size:
160            # Evict least accessed entry
161            if not self._strong_refs:
162                break
163
164            min_key = min(
165                self._strong_refs.keys(),
166                key=lambda k: self._strong_refs[k].access_count
167            )
168            del self._strong_refs[min_key]
169            self._evictions += 1
170
171    def pin(self, key: str) -> bool:
172        """
173        Pin an entry to prevent automatic cleanup.
174
175        Args:
176            key: Configuration key
177
178        Returns:
179            True if entry was pinned, False if not found
180        """
181        entry = self._cache.get(key)
182        if entry is None:
183            return False
184
185        self._enforce_size_limit()
186        self._strong_refs[key] = entry
187        return True
188
189    def unpin(self, key: str) -> bool:
190        """
191        Unpin an entry to allow automatic cleanup.
192
193        Args:
194            key: Configuration key
195
196        Returns:
197            True if entry was unpinned, False if not found
198        """
199        if key in self._strong_refs:
200            del self._strong_refs[key]
201            return True
202        return False
203
204    def clear(self) -> None:
205        """Clear all cached entries"""
206        self._cache.clear()
207        self._strong_refs.clear()
208
209    def stats(self) -> dict:
210        """
211        Get cache statistics.
212
213        Returns:
214            Dict with hits, misses, hit_rate, size, pinned, evictions
215        """
216        total = self._hits + self._misses
217        hit_rate = self._hits / total if total > 0 else 0.0
218
219        return {
220            "hits": self._hits,
221            "misses": self._misses,
222            "hit_rate": f"{hit_rate:.1%}",
223            "total_size": len(self._cache) + len(self._strong_refs),
224            "weak_refs": len(self._cache),
225            "pinned": len(self._strong_refs),
226            "evictions": self._evictions,
227        }
228
229    def memory_usage(self) -> dict:
230        """
231        Estimate memory usage of cached entries.
232
233        Returns:
234            Dict with entry_count, estimated_bytes, per_entry_bytes
235        """
236        all_entries = list(self._cache.values()) + list(self._strong_refs.values())
237
238        if not all_entries:
239            return {
240                "entry_count": 0,
241                "estimated_bytes": 0,
242                "per_entry_bytes": 0,
243            }
244
245        # Estimate based on first entry
246        sample = all_entries[0]
247        per_entry = sys.getsizeof(sample)
248
249        return {
250            "entry_count": len(all_entries),
251            "estimated_bytes": per_entry * len(all_entries),
252            "per_entry_bytes": per_entry,
253        }
254
255def demo_memory_optimization():
256    """Demonstrate memory optimization techniques"""
257
258    print("=" * 60)
259    print("Memory Optimization Demo")
260    print("=" * 60)
261
262    # Start memory tracking
263    tracemalloc.start()
264    gc.collect()
265    snapshot1 = tracemalloc.take_snapshot()
266
267    # Create cache and populate
268    cache = SmartConfigCache(max_size=100)
269
270    # Simulate loading many configurations
271    entries = []
272    for i in range(1000):
273        entry = cache.get_or_create(
274            f"config.item.{i}",
275            lambda i=i: ConfigEntry(
276                f"config.item.{i}",
277                f"value_{i}",
278                "demo"
279            ),
280            keep_strong=(i < 100)  # Pin first 100
281        )
282        entries.append(entry)
283
284    # Take snapshot after creation
285    gc.collect()
286    snapshot2 = tracemalloc.take_snapshot()
287
288    # Print stats
289    print("\nCache Statistics:")
290    for key, value in cache.stats().items():
291        print(f"  {key}: {value}")
292
293    print("\nMemory Usage:")
294    for key, value in cache.memory_usage().items():
295        print(f"  {key}: {value:,}")
296
297    # Show memory diff
298    diff = snapshot2.compare_to(snapshot1, 'lineno')
299    print("\nTop 5 Memory Allocations:")
300    for stat in diff[:5]:
301        print(f"  {stat}")
302
303    # Demo weak reference cleanup
304    print("\n" + "-" * 60)
305    print("Weak Reference Cleanup Demo")
306    print("-" * 60)
307
308    print(f"Before cleanup - Cache size: {cache.stats()['total_size']}")
309
310    # Delete external references to unpinned entries
311    del entries
312    gc.collect()
313
314    print(f"After cleanup  - Cache size: {cache.stats()['total_size']}")
315    print("(Only pinned entries remain)")
316
317    tracemalloc.stop()
318
319if __name__ == "__main__":
320    demo_memory_optimization()

使用範例

 1from memory_optimized_cache import SmartConfigCache, ConfigEntry
 2
 3# Initialize cache with size limit
 4cache = SmartConfigCache(max_size=1000)
 5
 6# Load configuration
 7def load_database_config():
 8    """Factory function to load database config"""
 9    return ConfigEntry(
10        key="database",
11        value={
12            "host": "localhost",
13            "port": 5432,
14            "name": "myapp"
15        },
16        source="config.yaml"
17    )
18
19# Get or create (with strong reference for important config)
20db_config = cache.get_or_create(
21    "database",
22    load_database_config,
23    keep_strong=True  # Keep in memory
24)
25
26print(f"Database host: {db_config.value['host']}")
27
28# Temporary config (will be auto-cleaned when not referenced)
29temp_config = cache.get_or_create(
30    "temp.setting",
31    lambda: ConfigEntry("temp.setting", "temporary", "runtime")
32)
33
34# Check statistics
35print(cache.stats())
36# {'hits': 0, 'misses': 2, 'hit_rate': '0.0%',
37#  'total_size': 2, 'weak_refs': 1, 'pinned': 1, 'evictions': 0}
38
39# Memory usage
40print(cache.memory_usage())
41# {'entry_count': 2, 'estimated_bytes': 112, 'per_entry_bytes': 56}

設計權衡

`slots` vs 標準類別

面向	標準類別	`__slots__`
記憶體佔用	較多（有 `__dict__`）	較少（節省 ~60-70%）
動態屬性	支援 `obj.new_attr = x`	不支援（除非加 `__dict__`）
繼承	簡單	子類別需要自己的 `__slots__`
弱引用	預設支援	需要加入 `__weakref__` slot
Pickle	直接支援	需要 `__getstate__`/`__setstate__`
多重繼承	正常運作	多個父類別不能都有非空 `__slots__`

強引用 vs 弱引用快取

面向	強引用快取	弱引用快取
記憶體管理	需要手動清理	自動清理
資料保證	資料一定存在	資料可能被回收
適用場景	關鍵配置	暫時性資料
實作複雜度	簡單	稍微複雜

何時使用哪種技術？

 1決策樹：
 2
 3物件數量多嗎？
 4├── 是 → 考慮 __slots__
 5│   └── 需要動態屬性嗎？
 6│       ├── 是 → __slots__ = [..., '__dict__']
 7│       └── 否 → __slots__ = [...]
 8└── 否 → 標準類別即可
 9
10快取可能無限增長嗎？
11├── 是 → 使用 WeakValueDictionary 或 LRU
12└── 否 → 普通字典即可
13
14資料可以被回收嗎？
15├── 是 → weakref
16└── 否 → 強引用

什麼時候該用這個技術？

適合使用

建立大量小物件：如資料點、事件、配置項目
記憶體使用是瓶頸：經過 profiling 確認
快取可能無限增長：如用戶 session、請求資料
長時間運行的服務：如 web server、daemon

不建議使用

物件數量很少：優化效果不明顯
需要動態新增屬性：__slots__ 會限制彈性
過早優化：先確認是否真的有問題
程式碼可讀性優先：標準類別更直觀

優化決策流程

 1# Step 1: Profile first!
 2# Don't optimize until you know where the problem is
 3
 4import tracemalloc
 5
 6tracemalloc.start()
 7# ... run your code ...
 8snapshot = tracemalloc.take_snapshot()
 9top_stats = snapshot.statistics('lineno')
10
11for stat in top_stats[:10]:
12    print(stat)
13
14# Step 2: If memory is the issue, identify the class
15# Look for classes with many instances
16
17import gc
18from collections import Counter
19
20counter = Counter(type(obj).__name__ for obj in gc.get_objects())
21print(counter.most_common(10))
22
23# Step 3: Only then apply __slots__ to hot classes

練習

基礎練習：比較有無 `slots` 的記憶體差異

撰寫一個腳本，比較以下三種類別建立 100,000 個實例的記憶體使用：

 1# Exercise: Complete this benchmark script
 2
 3import sys
 4import tracemalloc
 5from dataclasses import dataclass
 6
 7# 1. Standard class
 8class PointStandard:
 9    def __init__(self, x, y, z):
10        self.x = x
11        self.y = y
12        self.z = z
13
14# 2. Class with __slots__
15class PointSlots:
16    __slots__ = ['x', 'y', 'z']
17    def __init__(self, x, y, z):
18        self.x = x
19        self.y = y
20        self.z = z
21
22# 3. Named tuple
23from collections import namedtuple
24PointNamed = namedtuple('PointNamed', ['x', 'y', 'z'])
25
26# TODO: Write benchmark function
27def benchmark(cls, count=100000):
28    """Measure memory for creating `count` instances"""
29    pass  # Implement this
30
31# TODO: Compare results
32# Expected: PointSlots uses ~3x less memory than PointStandard

進階練習：實作 weakref 快取

建立一個 ImageCache 類別，具有以下功能：

 1# Exercise: Implement ImageCache
 2
 3class ImageCache:
 4    """
 5    Cache for image data with automatic cleanup.
 6
 7    Requirements:
 8    - Use WeakValueDictionary for auto-cleanup
 9    - Track hit/miss statistics
10    - Support maximum size limit
11    - Provide memory usage estimation
12
13    Example usage:
14        cache = ImageCache(max_size=100)
15
16        img = cache.get_or_load("photo.jpg", lambda: load_image("photo.jpg"))
17
18        print(cache.stats())
19        # {'hits': 0, 'misses': 1, 'size': 1}
20    """
21
22    def __init__(self, max_size=None):
23        # TODO: Initialize cache
24        pass
25
26    def get_or_load(self, key, loader):
27        # TODO: Implement get or load logic
28        pass
29
30    def stats(self):
31        # TODO: Return cache statistics
32        pass

挑戰題：用 tracemalloc 追蹤記憶體洩漏

給定以下有記憶體洩漏的程式碼，使用 tracemalloc 找出問題並修復：

 1# Exercise: Find and fix the memory leak
 2
 3class EventHandler:
 4    _handlers = []  # Class variable - potential leak!
 5
 6    def __init__(self, name):
 7        self.name = name
 8        self.callbacks = []
 9        EventHandler._handlers.append(self)  # Leak: strong reference
10
11    def register(self, callback):
12        self.callbacks.append(callback)
13
14    def fire(self, event):
15        for cb in self.callbacks:
16            cb(event)
17
18def process_events():
19    """This function creates handlers but never cleans them up"""
20    for i in range(1000):
21        handler = EventHandler(f"handler_{i}")
22        handler.register(lambda e: print(e))
23        handler.fire(f"event_{i}")
24        # handler goes out of scope but is still in _handlers!
25
26# TODO:
27# 1. Use tracemalloc to measure memory growth
28# 2. Identify the leak
29# 3. Fix EventHandler to use weak references
30# 4. Verify the fix with tracemalloc

延伸閱讀

上一章：效能分析實戰 返回：模組四：CPython 內部機制

3.2 記憶體管理與垃圾回收

Tue, 20 Jan 2026 00:00:00 +0000

Python 的記憶體管理結合了參考計數和分代垃圾回收。理解這些機制有助於寫出更高效的程式碼。

先備知識

3.1 PyObject 與物件模型

本章目標

學完本章後，你將能夠：

理解參考計數的限制
理解分代垃圾回收的原理
使用 __slots__ 優化記憶體
使用 tracemalloc 分析記憶體使用

【原理層】記憶體模型

Stack vs Heap

Python 的記憶體分為兩個主要區域：

 1┌─────────────────────────────────────┐
 2│              Stack                   │
 3│  ┌─────────────────────────────────┐│
 4│  │ 變數名稱 → 指向 Heap 的指標      ││
 5│  │ a ──────→ [指標]                ││
 6│  │ b ──────→ [指標]                ││
 7│  └─────────────────────────────────┘│
 8└─────────────────────────────────────┘
 9                 │
10                 ▼
11┌─────────────────────────────────────┐
12│              Heap                    │
13│  ┌─────────────────────────────────┐│
14│  │ PyObject: [1, 2, 3]             ││
15│  │ PyObject: "hello"               ││
16│  │ PyObject: 42                    ││
17│  └─────────────────────────────────┘│
18└─────────────────────────────────────┘

Stack：儲存變數名稱和指標（參考）
Heap：儲存實際的 Python 物件

Python 的記憶體分配器

CPython 使用分層的記憶體分配器：

 1┌─────────────────────────────────────┐
 2│     Python 物件分配器               │
 3│     (PyObject_Malloc)               │
 4├─────────────────────────────────────┤
 5│     Python 記憶體分配器             │
 6│     (PyMem_Malloc)                  │
 7├─────────────────────────────────────┤
 8│     C 標準函式庫                    │
 9│     (malloc)                        │
10├─────────────────────────────────────┤
11│     作業系統                        │
12└─────────────────────────────────────┘

對於小於 512 bytes 的物件，Python 使用自己的分配器來減少系統呼叫。

【設計層】循環參考問題

參考計數的限制

參考計數無法處理循環參考：

 1import gc
 2
 3class Node:
 4    def __init__(self, name):
 5        self.name = name
 6        self.ref = None
 7
 8# 建立循環參考
 9a = Node("A")
10b = Node("B")
11a.ref = b
12b.ref = a
13
14# 刪除外部參考
15del a
16del b
17
18# 此時 A 和 B 仍互相參考，參考計數都是 1
19# 但它們已經無法被存取了（垃圾）

1刪除前：
2外部 ─→ A ←──→ B ←─ 外部
3        refcnt=2  refcnt=2
4
5刪除後：
6        A ←──→ B
7        refcnt=1  refcnt=1
8        （無法被存取，但參考計數不為 0）

分代垃圾回收

為了解決循環參考，Python 使用分代垃圾回收：

 1import gc
 2
 3# 查看 GC 統計
 4print(gc.get_count())  # (700, 10, 0) - 各代的物件數
 5
 6# 三個世代（Python 3.12 以前）
 7# Generation 0: 新物件
 8# Generation 1: 存活過一次 GC 的物件
 9# Generation 2: 存活過多次 GC 的物件
10
11# Python 3.12+ 改為四個世代
12# Young generation (1 代)
13# Old generations (2 代)
14# Permanent generation (永久)

GC 觸發時機

 1import gc
 2
 3# 查看閾值
 4print(gc.get_threshold())  # (700, 10, 10)
 5
 6# 意義：
 7# - 當 Generation 0 有 700 個物件時，觸發 Gen 0 GC
 8# - 當 Gen 0 GC 執行 10 次後，觸發 Gen 1 GC
 9# - 當 Gen 1 GC 執行 10 次後，觸發 Gen 2 GC
10
11# 手動觸發 GC
12gc.collect()
13
14# 設定閾值
15gc.set_threshold(1000, 15, 15)

【實作層】記憶體優化

使用 slots

__slots__ 可以顯著減少物件的記憶體使用：

 1import sys
 2
 3class WithoutSlots:
 4    def __init__(self, x, y):
 5        self.x = x
 6        self.y = y
 7
 8class WithSlots:
 9    __slots__ = ['x', 'y']
10
11    def __init__(self, x, y):
12        self.x = x
13        self.y = y
14
15obj1 = WithoutSlots(1, 2)
16obj2 = WithSlots(1, 2)
17
18print(sys.getsizeof(obj1))  # 48
19print(sys.getsizeof(obj2))  # 48（但沒有 __dict__）
20
21# 實際差異在 __dict__
22print(sys.getsizeof(obj1.__dict__))  # 104
23# obj2 沒有 __dict__

為什麼 `slots` 省記憶體？

 1沒有 __slots__：
 2┌─────────────────────────┐
 3│ PyObject header (16 B)  │
 4│ __dict__ 指標 (8 B)      │
 5│ __weakref__ 指標 (8 B)   │
 6│ __dict__ → { 'x': 1,    │
 7│              'y': 2 }   │
 8│            （額外 100+ B）│
 9└─────────────────────────┘
10
11有 __slots__：
12┌─────────────────────────┐
13│ PyObject header (16 B)  │
14│ x (8 B)                 │
15│ y (8 B)                 │
16└─────────────────────────┘

slots 的限制

 1class Base:
 2    __slots__ = ['x']
 3
 4class Derived(Base):
 5    __slots__ = ['y']  # 不能與父類別重複
 6
 7    def __init__(self):
 8        self.x = 1
 9        self.y = 2
10        # self.z = 3  # 錯誤！沒有 __dict__
11
12# 如果需要動態屬性，加入 '__dict__'
13class Flexible:
14    __slots__ = ['x', '__dict__']

使用弱參考

弱參考不增加參考計數，適合用於快取：

 1import weakref
 2
 3class ExpensiveObject:
 4    def __init__(self, value):
 5        self.value = value
 6
 7# 建立物件和弱參考
 8obj = ExpensiveObject(42)
 9weak_ref = weakref.ref(obj)
10
11print(weak_ref())  # 
12print(weak_ref().value)  # 42
13
14# 刪除強參考
15del obj
16
17print(weak_ref())  # None（物件已被回收）

使用 WeakValueDictionary 實作快取

 1import weakref
 2
 3class Cache:
 4    def __init__(self):
 5        self._cache = weakref.WeakValueDictionary()
 6
 7    def get(self, key, factory):
 8        value = self._cache.get(key)
 9        if value is None:
10            value = factory()
11            self._cache[key] = value
12        return value
13
14cache = Cache()
15
16def create_expensive():
17    return ExpensiveObject(100)
18
19obj = cache.get('key1', create_expensive)
20# 當 obj 不再被使用時，快取會自動清理

【實作層】記憶體分析工具

使用 tracemalloc

 1import tracemalloc
 2
 3# 開始追蹤
 4tracemalloc.start()
 5
 6# 執行程式碼
 7data = [i ** 2 for i in range(10000)]
 8more_data = {str(i): i for i in range(10000)}
 9
10# 取得記憶體快照
11snapshot = tracemalloc.take_snapshot()
12
13# 顯示前 10 個記憶體使用最多的位置
14top_stats = snapshot.statistics('lineno')
15for stat in top_stats[:10]:
16    print(stat)
17
18# 比較兩個快照
19tracemalloc.start()
20snapshot1 = tracemalloc.take_snapshot()
21
22# 執行更多程式碼
23big_list = list(range(100000))
24
25snapshot2 = tracemalloc.take_snapshot()
26diff = snapshot2.compare_to(snapshot1, 'lineno')
27
28for stat in diff[:5]:
29    print(stat)

使用 gc 模組除錯

 1import gc
 2
 3# 啟用除錯
 4gc.set_debug(gc.DEBUG_LEAK)
 5
 6# 找出無法回收的物件
 7gc.collect()
 8print(gc.garbage)  # 無法回收的物件列表
 9
10# 取得所有被追蹤的物件
11all_objects = gc.get_objects()
12print(f"被追蹤的物件數量: {len(all_objects)}")
13
14# 找出特定類別的實例
15class MyClass:
16    pass
17
18instances = [obj for obj in gc.get_objects() if isinstance(obj, MyClass)]
19print(f"MyClass 實例數量: {len(instances)}")

檢測記憶體洩漏

 1import gc
 2import tracemalloc
 3
 4def find_memory_leak():
 5    tracemalloc.start()
 6
 7    # 記錄初始狀態
 8    gc.collect()
 9    snapshot1 = tracemalloc.take_snapshot()
10
11    # 執行可能洩漏的程式碼
12    for _ in range(1000):
13        suspicious_function()
14
15    # 記錄最終狀態
16    gc.collect()
17    snapshot2 = tracemalloc.take_snapshot()
18
19    # 比較
20    diff = snapshot2.compare_to(snapshot1, 'lineno')
21
22    print("記憶體增長最多的位置：")
23    for stat in diff[:10]:
24        print(stat)

【實戰】常見記憶體問題

問題 1：大量小物件

 1# 不好：建立大量小物件
 2class Point:
 3    def __init__(self, x, y):
 4        self.x = x
 5        self.y = y
 6
 7points = [Point(i, i) for i in range(1000000)]
 8
 9# 好：使用 __slots__
10class Point:
11    __slots__ = ['x', 'y']
12    def __init__(self, x, y):
13        self.x = x
14        self.y = y
15
16# 更好：使用 NumPy（如果是數值資料）
17import numpy as np
18points = np.zeros((1000000, 2))

問題 2：循環參考

 1# 不好：物件間的循環參考
 2class Parent:
 3    def __init__(self):
 4        self.children = []
 5
 6class Child:
 7    def __init__(self, parent):
 8        self.parent = parent
 9        parent.children.append(self)
10
11# 好：使用弱參考
12import weakref
13
14class Child:
15    def __init__(self, parent):
16        self.parent = weakref.ref(parent)
17        parent.children.append(self)

問題 3：全域變數累積

 1# 不好：全域快取無限增長
 2_cache = {}
 3
 4def process(key, value):
 5    if key not in _cache:
 6        _cache[key] = expensive_compute(value)
 7    return _cache[key]
 8
 9# 好：使用 LRU cache
10from functools import lru_cache
11
12@lru_cache(maxsize=1000)
13def process(key, value):
14    return expensive_compute(value)

思考題

為什麼 Python 需要同時使用參考計數和垃圾回收？只用其中一種不行嗎？
__slots__ 為什麼不能用於繼承自內建型別的類別？
在什麼情況下應該手動呼叫 gc.collect()？

實作練習

使用 tracemalloc 分析一個現有程式的記憶體使用
將一個使用大量物件的程式改用 __slots__ 優化
使用 WeakValueDictionary 實作一個自動清理的快取

延伸閱讀

上一章：PyObject 與物件模型 下一章：Bytecode 與虛擬機

3.3 Bytecode 與虛擬機

Tue, 20 Jan 2026 00:00:00 +0000

Python 先把原始碼編譯成 bytecode，再由虛擬機執行。理解這個過程有助於優化程式碼效能。

先備知識

3.2 記憶體管理與垃圾回收

本章目標

學完本章後，你將能夠：

理解 Python 的編譯流程
使用 dis 模組分析 bytecode
從 bytecode 角度理解效能差異
了解 Python 3.11+ 的效能優化

【原理層】Python 的執行流程

編譯與執行

 1原始碼 (.py)
 2    │
 3    ▼
 4┌─────────────┐
 5│   詞法分析   │ ← 將原始碼分解成 tokens
 6│   (Lexer)   │
 7└─────────────┘
 8    │
 9    ▼
10┌─────────────┐
11│   語法分析   │ ← 建立抽象語法樹 (AST)
12│   (Parser)  │
13└─────────────┘
14    │
15    ▼
16┌─────────────┐
17│   編譯器    │ ← 將 AST 編譯成 bytecode
18│  (Compiler) │
19└─────────────┘
20    │
21    ▼
22Bytecode (.pyc)
23    │
24    ▼
25┌─────────────┐
26│   虛擬機    │ ← 執行 bytecode
27│    (VM)     │
28└─────────────┘
29    │
30    ▼
31  執行結果

.pyc 檔案與 pycache

 1# 當你 import 一個模組時，Python 會：
 2# 1. 檢查 __pycache__ 中是否有對應的 .pyc 檔案
 3# 2. 如果沒有或過期，重新編譯
 4# 3. 將編譯結果存入 __pycache__
 5
 6# 檔案命名格式：
 7# module.cpython-312.pyc
 8# module.cpython-313.pyc
 9
10# 手動編譯
11import py_compile
12py_compile.compile('script.py')
13
14# 編譯整個目錄
15import compileall
16compileall.compile_dir('my_package/')

程式碼物件（Code Object）

編譯後的 bytecode 儲存在程式碼物件中：

 1def example(x, y):
 2    z = x + y
 3    return z * 2
 4
 5code = example.__code__
 6
 7print(code.co_name)       # example
 8print(code.co_varnames)   # ('x', 'y', 'z')
 9print(code.co_consts)     # (None, 2)
10print(code.co_code)       # b'|\x00|\x01\x17\x00}\x02|\x02d\x01\x14\x00S\x00'

【設計層】Stack-based 虛擬機

工作原理

Python 虛擬機是 stack-based（堆疊式）：

1執行 x + y：
2
31. LOAD_FAST 0 (x)    Stack: [x]
42. LOAD_FAST 1 (y)    Stack: [x, y]
53. BINARY_ADD         Stack: [x+y]

 1import dis
 2
 3def add(x, y):
 4    return x + y
 5
 6dis.dis(add)
 7# 輸出：
 8#   2           0 RESUME                   0
 9#
10#   3           2 LOAD_FAST                0 (x)
11#               4 LOAD_FAST                1 (y)
12#               6 BINARY_OP                0 (+)
13#              10 RETURN_VALUE

常見 Bytecode 指令

指令	說明
LOAD_FAST	載入區域變數
LOAD_GLOBAL	載入全域變數
LOAD_CONST	載入常數
STORE_FAST	儲存區域變數
BINARY_OP	二元運算
CALL	呼叫函式
RETURN_VALUE	返回值
JUMP_FORWARD	向前跳躍
POP_JUMP_IF_FALSE	條件跳躍

【實作層】使用 dis 模組

基本用法

1import dis
2
3# 反組譯函式
4def factorial(n):
5    if n <= 1:
6        return 1
7    return n * factorial(n - 1)
8
9dis.dis(factorial)

分析控制流程

 1import dis
 2
 3def loop_example():
 4    total = 0
 5    for i in range(10):
 6        total += i
 7    return total
 8
 9dis.dis(loop_example)
10# 可以看到 FOR_ITER、JUMP_BACKWARD 等指令

比較不同實現

 1import dis
 2
 3# 版本 1：使用迴圈
 4def sum_loop(n):
 5    total = 0
 6    for i in range(n):
 7        total += i
 8    return total
 9
10# 版本 2：使用內建函式
11def sum_builtin(n):
12    return sum(range(n))
13
14print("=== 迴圈版本 ===")
15dis.dis(sum_loop)
16
17print("\n=== 內建函式版本 ===")
18dis.dis(sum_builtin)
19
20# 內建函式版本的 bytecode 更少，而且 sum() 是 C 實現

【效能】從 Bytecode 理解效能

為什麼區域變數比全域變數快？

 1import dis
 2
 3global_var = 10
 4
 5def use_global():
 6    return global_var + 1
 7
 8def use_local():
 9    local_var = 10
10    return local_var + 1
11
12dis.dis(use_global)
13# LOAD_GLOBAL 0 (global_var)  ← 需要查找全域命名空間
14
15dis.dis(use_local)
16# LOAD_FAST 0 (local_var)     ← 直接用索引存取

1LOAD_GLOBAL: 需要在 globals() dict 中查找
2LOAD_FAST:   直接用索引存取陣列（O(1)）

為什麼 list comprehension 比 for 迴圈快？

 1import dis
 2
 3def for_loop():
 4    result = []
 5    for i in range(100):
 6        result.append(i * 2)
 7    return result
 8
 9def list_comp():
10    return [i * 2 for i in range(100)]
11
12dis.dis(for_loop)
13# 更多指令，包括 LOAD_METHOD (append)、CALL
14
15dis.dis(list_comp)
16# 使用特殊的 LIST_APPEND 指令，更高效

字串連接的效能

 1import dis
 2
 3def concat_plus():
 4    s = ""
 5    for i in range(10):
 6        s = s + str(i)
 7    return s
 8
 9def concat_join():
10    return "".join(str(i) for i in range(10))
11
12# plus 版本每次都建立新字串
13# join 版本一次性建立

【深入】Python 3.11+ 的優化

Specializing Adaptive Interpreter

Python 3.11 引入了自適應特化直譯器：

1# 針對常見模式進行優化
2# 例如：如果一個函式總是接收 int 參數
3
4def add(a, b):
5    return a + b
6
7# 前幾次呼叫：使用通用的 BINARY_OP
8# 多次呼叫後：特化為 BINARY_OP_ADD_INT

查看特化指令

1import dis
2
3def example():
4    x = 1
5    y = 2
6    return x + y
7
8# 使用 adaptive=True 查看特化指令
9dis.dis(example, adaptive=True)

內聯快取（Inline Caching）

1# Python 3.11+ 在 bytecode 中包含快取空間
2# 用於儲存運行時資訊
3
4def get_attr(obj):
5    return obj.value
6
7# 第一次呼叫：查找 'value' 屬性
8# 之後：使用快取的位置資訊

【實戰】效能調校

使用 bytecode 分析熱點

 1import dis
 2import timeit
 3
 4def version_a(data):
 5    total = 0
 6    for item in data:
 7        total = total + item
 8    return total
 9
10def version_b(data):
11    total = 0
12    for item in data:
13        total += item
14    return total
15
16# 比較 bytecode
17print("=== version_a ===")
18dis.dis(version_a)
19print("\n=== version_b ===")
20dis.dis(version_b)
21
22# 實際測量
23data = list(range(1000))
24print(timeit.timeit(lambda: version_a(data), number=10000))
25print(timeit.timeit(lambda: version_b(data), number=10000))
26# 結果相近，因為 total = total + item 和 total += item
27# 在 Python 中編譯成相同的 bytecode

避免不必要的屬性查找

 1import dis
 2
 3class MyClass:
 4    def __init__(self):
 5        self.value = 0
 6
 7    def slow_method(self):
 8        for i in range(100):
 9            self.value += i  # 每次都要查找 self.value
10
11    def fast_method(self):
12        value = self.value  # 快取到區域變數
13        for i in range(100):
14            value += i
15        self.value = value
16
17dis.dis(MyClass.slow_method)
18# 迴圈內有 LOAD_FAST (self) + LOAD_ATTR (value)
19
20dis.dis(MyClass.fast_method)
21# 迴圈內只有 LOAD_FAST (value)

使用 slots 加速屬性存取

 1import dis
 2
 3class WithoutSlots:
 4    def __init__(self, x):
 5        self.x = x
 6
 7class WithSlots:
 8    __slots__ = ['x']
 9    def __init__(self, x):
10        self.x = x
11
12def access_without_slots(obj):
13    return obj.x
14
15def access_with_slots(obj):
16    return obj.x
17
18# bytecode 相同，但運行時 __slots__ 更快
19# 因為不需要查找 __dict__

【參考】完整 Bytecode 列表

Python 3.12 的主要指令類別：

 1載入指令：
 2  LOAD_CONST, LOAD_FAST, LOAD_GLOBAL, LOAD_NAME, LOAD_ATTR
 3
 4儲存指令：
 5  STORE_FAST, STORE_GLOBAL, STORE_NAME, STORE_ATTR
 6
 7運算指令：
 8  BINARY_OP, UNARY_NEGATIVE, UNARY_NOT
 9
10跳躍指令：
11  JUMP_FORWARD, JUMP_BACKWARD, POP_JUMP_IF_TRUE, POP_JUMP_IF_FALSE
12
13函式相關：
14  CALL, RETURN_VALUE, PUSH_NULL
15
16迭代相關：
17  GET_ITER, FOR_ITER
18
19容器相關：
20  BUILD_LIST, BUILD_TUPLE, BUILD_MAP, LIST_APPEND

思考題

為什麼 Python 選擇 stack-based VM 而不是 register-based VM？
.pyc 檔案可以跨平台使用嗎？為什麼？
JIT 編譯器（如 PyPy）與 CPython 的直譯器有什麼根本差異？

實作練習

使用 dis 比較 map() 和 list comprehension 的 bytecode
寫一個簡單的 bytecode 分析工具，計算指令數量
研究 Python 3.11 和 3.12 的 bytecode 變化

延伸閱讀

上一章：記憶體管理與垃圾回收 下一章：GIL 與執行緒模型

3.4 GIL 與執行緒模型

Tue, 20 Jan 2026 00:00:00 +0000

GIL（Global Interpreter Lock）是 CPython 中最具爭議的設計之一。本章深入探討 GIL 的歷史、實現，以及 Python 3.13+ Free-threading 的技術細節。

先備知識

本章目標

學完本章後，你將能夠：

理解 GIL 存在的歷史原因
理解 GIL 的釋放時機
理解 Free-threading 的實現挑戰
做出正確的並行策略選擇

【原理層】為什麼需要 GIL？

歷史背景

GIL 是 1992 年 Python 初創時的設計決策：

1當時的考量：
21. 單核 CPU 是主流
32. 簡化記憶體管理（參考計數）
43. 簡化 C 擴展開發
54. 避免細粒度鎖的複雜性

參考計數與執行緒安全

GIL 主要保護參考計數操作：

 1// 沒有 GIL 時，這個操作不是原子的
 2Py_INCREF(obj);
 3// 展開後：
 4// 1. 讀取 ob_refcnt
 5// 2. 加 1
 6// 3. 寫回 ob_refcnt
 7
 8// 如果兩個執行緒同時執行，可能會：
 9// Thread 1: 讀取 refcnt = 1
10// Thread 2: 讀取 refcnt = 1
11// Thread 1: 寫入 refcnt = 2
12// Thread 2: 寫入 refcnt = 2  ← 錯誤！應該是 3

GIL 的實現

1// 簡化版的 GIL 結構
2typedef struct {
3    PyMutex mutex;           // 互斥鎖
4    PyThread_type_lock lock; // 執行緒鎖
5    int locked;              // 鎖定狀態
6} _gil_runtime_state;

【設計層】GIL 的釋放時機

自動釋放

GIL 在以下情況會自動釋放：

 1# 1. I/O 操作
 2f = open('file.txt', 'r')  # 釋放 GIL
 3content = f.read()          # 釋放 GIL
 4
 5# 2. sleep
 6import time
 7time.sleep(1)  # 釋放 GIL
 8
 9# 3. 某些 C 擴展操作
10import numpy as np
11result = np.dot(a, b)  # NumPy 可能釋放 GIL
12
13# 4. 定期釋放（每 N 個 bytecode 指令）
14# Python 3.2+ 預設約每 5ms 檢查一次

檢查間隔

1import sys
2
3# 查看切換間隔（秒）
4print(sys.getswitchinterval())  # 0.005（5ms）
5
6# 設定切換間隔
7sys.setswitchinterval(0.001)  # 1ms

C 擴展中手動釋放 GIL

 1// C 擴展可以明確釋放 GIL
 2static PyObject* compute_intensive(PyObject* self, PyObject* args) {
 3    // 釋放 GIL
 4    Py_BEGIN_ALLOW_THREADS
 5
 6    // 這裡的程式碼可以並行執行
 7    do_heavy_computation();
 8
 9    // 重新獲取 GIL
10    Py_END_ALLOW_THREADS
11
12    Py_RETURN_NONE;
13}

【實驗】測量 GIL 的影響

CPU 密集任務

 1import threading
 2import time
 3
 4def cpu_intensive(n):
 5    """純 Python CPU 密集計算"""
 6    total = 0
 7    for i in range(n):
 8        total += i * i
 9    return total
10
11def benchmark(func, args, num_threads):
12    threads = []
13    start = time.perf_counter()
14
15    for _ in range(num_threads):
16        t = threading.Thread(target=func, args=args)
17        threads.append(t)
18        t.start()
19
20    for t in threads:
21        t.join()
22
23    return time.perf_counter() - start
24
25n = 5_000_000
26
27# 單執行緒
28time_1 = benchmark(cpu_intensive, (n,), 1)
29print(f"1 執行緒: {time_1:.3f}s")
30
31# 多執行緒（受 GIL 限制）
32time_4 = benchmark(cpu_intensive, (n,), 4)
33print(f"4 執行緒: {time_4:.3f}s")
34
35# 結果：多執行緒可能更慢（執行緒切換開銷）

I/O 密集任務

 1import threading
 2import time
 3import urllib.request
 4
 5def io_intensive(url):
 6    """I/O 密集操作"""
 7    try:
 8        with urllib.request.urlopen(url, timeout=5) as f:
 9            return len(f.read())
10    except:
11        return 0
12
13urls = ["https://example.com"] * 10
14
15# 單執行緒
16start = time.perf_counter()
17for url in urls:
18    io_intensive(url)
19time_sequential = time.perf_counter() - start
20print(f"序列: {time_sequential:.3f}s")
21
22# 多執行緒
23start = time.perf_counter()
24threads = [threading.Thread(target=io_intensive, args=(url,)) for url in urls]
25for t in threads:
26    t.start()
27for t in threads:
28    t.join()
29time_parallel = time.perf_counter() - start
30print(f"並行: {time_parallel:.3f}s")
31
32# 結果：多執行緒明顯更快（I/O 時釋放 GIL）

【深入】Free-threading 技術細節

Biased Reference Counting

Python 3.13+ Free-threading 使用「偏向參考計數」解決多執行緒問題：

 1傳統參考計數：
 2┌─────────────────────────────────────┐
 3│  ob_refcnt = 2                      │
 4│  每次操作都需要原子操作或鎖         │
 5└─────────────────────────────────────┘
 6
 7偏向參考計數：
 8┌─────────────────────────────────────┐
 9│  local_refcnt[thread_id] = 1        │  ← 每個執行緒有自己的計數
10│  local_refcnt[thread_id] = 1        │
11│  shared_refcnt = 0                  │  ← 共享計數
12└─────────────────────────────────────┘
13
14優點：
15- 大多數操作只需更新區域計數（無鎖）
16- 只有跨執行緒參考才需要更新共享計數

延遲參考計數

 1# Free-threading 中的優化策略
 2
 3# 對於不朽物件（immortal objects）
 4# 如 None、True、False、小整數
 5# 完全跳過參考計數
 6
 7# 對於局部物件
 8# 使用區域計數，無需同步
 9
10# 只有跨執行緒共享的物件
11# 才需要使用原子操作

記憶體模型變化

 1傳統 CPython（有 GIL）：
 2┌──────────────────────────────────────────┐
 3│  Thread 1  │  Thread 2  │  Thread 3      │
 4│     ↓            ↓            ↓          │
 5│     └────────────┼────────────┘          │
 6│                  ↓                       │
 7│               [ GIL ]                    │
 8│                  ↓                       │
 9│        [ Python Interpreter ]            │
10│                  ↓                       │
11│          [ 共享記憶體 ]                  │
12└──────────────────────────────────────────┘
13
14Free-threaded CPython：
15┌──────────────────────────────────────────┐
16│  Thread 1  │  Thread 2  │  Thread 3      │
17│     ↓            ↓            ↓          │
18│  [Local]     [Local]     [Local]         │
19│  State       State       State           │
20│     ↓            ↓            ↓          │
21│     └────────────┼────────────┘          │
22│                  ↓                       │
23│     [ 原子操作 / 鎖 / 無鎖資料結構 ]     │
24│                  ↓                       │
25│          [ 共享記憶體 ]                  │
26└──────────────────────────────────────────┘

【實戰】Free-threading 程式設計

檢查執行環境

 1import sys
 2
 3def check_environment():
 4    """檢查 Free-threading 環境"""
 5    try:
 6        gil_enabled = sys._is_gil_enabled()
 7        print(f"GIL 啟用: {gil_enabled}")
 8        return not gil_enabled
 9    except AttributeError:
10        print("傳統 Python（有 GIL）")
11        return False
12
13is_free_threaded = check_environment()

執行緒安全的程式設計

 1import threading
 2
 3# 不安全：共享可變狀態
 4counter = 0
 5
 6def unsafe_increment():
 7    global counter
 8    for _ in range(100000):
 9        counter += 1  # 競爭條件！
10
11# 安全：使用鎖
12counter = 0
13lock = threading.Lock()
14
15def safe_increment():
16    global counter
17    for _ in range(100000):
18        with lock:
19            counter += 1
20
21# 更好：使用原子操作或不可變資料
22from collections import Counter
23from concurrent.futures import ThreadPoolExecutor
24
25def better_approach(data_chunk):
26    """每個執行緒處理自己的資料，最後合併"""
27    local_count = 0
28    for item in data_chunk:
29        local_count += process(item)
30    return local_count
31
32with ThreadPoolExecutor() as executor:
33    results = executor.map(better_approach, data_chunks)
34    total = sum(results)

適應性程式碼

 1import sys
 2
 3def compute(data):
 4    """根據環境選擇策略"""
 5    free_threaded = getattr(sys, '_is_gil_enabled', lambda: True)() == False
 6
 7    if free_threaded:
 8        # 可以安全使用多執行緒
 9        return parallel_compute_threading(data)
10    else:
11        # 使用多進程或保持單執行緒
12        return parallel_compute_multiprocess(data)

【選擇指南】並行策略

決策流程

 1你的任務是什麼類型？
 2│
 3├── I/O 密集（網路、檔案、資料庫）
 4│   └── 使用 threading 或 asyncio
 5│       （GIL 不影響）
 6│
 7└── CPU 密集（計算、處理）
 8    │
 9    ├── 使用 Free-threaded Python (3.13+)?
10    │   ├── 是 → 可以使用 threading
11    │   └── 否 → 選擇以下方案
12    │
13    ├── 可以用 C 擴展？
14    │   └── NumPy、Cython 等（會釋放 GIL）
15    │
16    └── 純 Python？
17        └── 使用 multiprocessing 或 ProcessPoolExecutor

效能比較總結

任務類型	threading (有 GIL)	threading (Free)	multiprocessing
I/O 密集	好	好	過重
CPU 密集	無效	好	好
記憶體共享	簡單	簡單	複雜
啟動成本	低	低	高

【未來】GIL 的發展

路線圖

1Python 3.13 (2024): 實驗性 Free-threading
2Python 3.14 (2025): 正式支援 Free-threading
3Python 3.15/3.16:   可能成為預設
4未來:               GIL 可能完全移除

生態系統遷移

1# 檢查套件是否支援 Free-threading
2# pip index versions package-name
3
4# 主要框架的支援狀態（2025年底）
5# NumPy 2.1+:       支援
6# pandas 2.2+:      支援
7# scikit-learn 1.6+: 支援
8# PyTorch 2.6+:     支援

思考題

如果沒有 GIL，CPython 需要做哪些改變來保證記憶體安全？
為什麼其他 Python 實現（如 Jython、IronPython）沒有 GIL？
Free-threading 的效能損失主要來自哪裡？如何最小化？

實作練習

寫一個程式，測量 GIL 切換間隔對效能的影響
比較 Free-threaded 和傳統 Python 在相同 CPU 密集任務上的效能
將一個使用 multiprocessing 的程式改寫為 Free-threading 版本

延伸閱讀

上一章：Bytecode 與虛擬機 下一模組：模組四：用 C 擴展 Python

模組四：CPython 內部機制

Tue, 20 Jan 2026 00:00:00 +0000

本模組深入 CPython 直譯器的內部，幫助你理解 Python 的運作原理。

為什麼學習 CPython 內部？

寫出更好的程式碼：理解底層機制有助於避免效能陷阱
除錯能力：深入理解有助於解決複雜問題
銜接擴展：為 C/Rust 擴展開發打基礎

章節列表

章節	主題	關鍵收穫
4.1	PyObject 與物件模型	理解「一切皆物件」
4.2	記憶體管理與垃圾回收	理解記憶體如何管理
4.3	Bytecode 與虛擬機	理解程式碼如何執行
4.4	GIL 與執行緒模型	深入理解 GIL
4.5	Free-Threading	Python 3.13+ 無 GIL 多執行緒

先備知識

入門系列並行處理

學習時間

每章節約 30-45 分鐘，全模組約 2.5-3.5 小時

上一模組：模組三：進階設計模式 下一模組：模組五：用 C 擴展 Python

4.5 Free-Threading - Python 的真正多執行緒時代

Tue, 20 Jan 2026 00:00:00 +0000

Python 3.13 開始提供實驗性的 Free-threading 支援，Python 3.14 正式將其升級為官方支援功能。這是 Python 歷史上最重要的並行處理改進之一。

什麼是 Free-Threading？

GIL 的歷史與限制

長久以來，CPython 使用 GIL（Global Interpreter Lock）來簡化記憶體管理和 C 擴展的開發。但這也意味著：

1傳統 Python（有 GIL）：
2┌─────────────────────────────────┐
3│  Thread 1  →  執行中             │
4│  Thread 2  →  等待 GIL...        │
5│  Thread 3  →  等待 GIL...        │
6│  Thread 4  →  等待 GIL...        │
7└─────────────────────────────────┘
8   同一時間只有一個執行緒能執行 Python 程式碼

1Free-threaded Python（無 GIL）：
2┌─────────────────────────────────┐
3│  Thread 1  →  執行中  (Core 1)   │
4│  Thread 2  →  執行中  (Core 2)   │
5│  Thread 3  →  執行中  (Core 3)   │
6│  Thread 4  →  執行中  (Core 4)   │
7└─────────────────────────────────┘
8   多個執行緒可以真正並行執行

發展歷程

版本	狀態	PEP
Python 3.13	實驗性支援	PEP 703
Python 3.14	正式支援	PEP 779
Python 3.15/3.16	可能成為預設	待定

安裝與啟用

各平台安裝方式

Windows / macOS

從 python.org 下載安裝程式，選擇「Customize installation」，勾選「Free threaded mode」。

Ubuntu / Debian

1# 使用 deadsnakes PPA
2sudo add-apt-repository ppa:deadsnakes/ppa
3sudo apt update
4sudo apt install python3.13-nogil
5# 或
6sudo apt install python3.14-nogil

安裝後可使用 python3.13t 或 python3.14t 執行。

從原始碼編譯

1./configure --disable-gil
2make -j$(nproc)
3sudo make install

確認安裝

1# 檢查版本資訊
2python3.14t -VV
3# 輸出應包含 "free-threading build"
4
5# 確認 GIL 狀態
6python3.14t -c "import sys; print('GIL enabled:', sys._is_gil_enabled())"
7# 應該輸出：GIL enabled: False

控制 GIL 狀態

1# 強制停用 GIL（即使有不相容模組）
2PYTHON_GIL=0 python3.14t script.py
3
4# 或使用命令列參數
5python3.14t -Xgil=0 script.py
6
7# 強制啟用 GIL（在 free-threaded 版本中）
8python3.14t -Xgil=1 script.py

效能實測數據

以下數據來自多個可信來源（Real Python、CodSpeed、Facebook Benchmarking）：

單執行緒 vs 多執行緒效能

場景	傳統 Python	Free-threaded	差異
單執行緒	1.44s	1.86s	慢 ~30% (3.13)
單執行緒	基準	慢 ~9%	(3.14 改善)
多執行緒 4 核	1.37s	0.39s	快 3.5x
Fibonacci 並行	1377ms	279ms	快 ~5x

關鍵數據

Python 3.13 單執行緒額外負擔：約 40%
Python 3.14 單執行緒額外負擔：約 5-10%（大幅改善）
多執行緒加速比：接近線性擴展（視任務而定）

重點：Free-threading 在單執行緒下有效能損失，但在多執行緒 CPU 密集任務中可獲得顯著加速。

適用場景判斷

適合使用 Free-threading

CPU 密集的並行計算：數學運算、資料處理
可分割的獨立任務：批次處理、平行搜尋
資料科學工作流程：大規模資料轉換
科學計算：模擬、數值分析

不適合使用 Free-threading

單執行緒應用：會有 5-10% 效能損失
I/O 密集任務：傳統 threading 已經足夠
大量使用尚未支援的 C 擴展：可能導致 GIL 被重新啟用
需要穩定性的生產環境：生態系統仍在成熟中

實際範例

範例 1：檢查是否在 Free-threaded 模式

 1import sys
 2
 3def is_free_threaded() -> bool:
 4    """檢查是否在 free-threaded 模式執行"""
 5    try:
 6        return not sys._is_gil_enabled()
 7    except AttributeError:
 8        # Python 3.12 或更早版本沒有這個函式
 9        return False
10
11def get_python_build_info() -> dict:
12    """取得 Python 建置資訊"""
13    return {
14        "version": sys.version,
15        "free_threaded": is_free_threaded(),
16        "gil_enabled": getattr(sys, '_is_gil_enabled', lambda: True)(),
17    }
18
19if __name__ == "__main__":
20    info = get_python_build_info()
21    print(f"Python 版本: {info['version']}")
22    print(f"Free-threaded: {info['free_threaded']}")
23    print(f"GIL 啟用: {info['gil_enabled']}")

範例 2：並行 CPU 計算

 1import threading
 2import time
 3import sys
 4
 5def cpu_intensive(n: int) -> int:
 6    """CPU 密集計算：計算平方和"""
 7    return sum(i * i for i in range(n))
 8
 9def sequential_compute(numbers: list[int]) -> list[int]:
10    """序列計算"""
11    return [cpu_intensive(n) for n in numbers]
12
13def parallel_compute(numbers: list[int]) -> list[int]:
14    """並行計算"""
15    results = [None] * len(numbers)
16
17    def worker(idx: int, n: int):
18        results[idx] = cpu_intensive(n)
19
20    threads = [
21        threading.Thread(target=worker, args=(i, n))
22        for i, n in enumerate(numbers)
23    ]
24
25    for t in threads:
26        t.start()
27    for t in threads:
28        t.join()
29
30    return results
31
32def benchmark():
33    """效能比較"""
34    numbers = [5_000_000] * 4
35
36    # 序列執行
37    start = time.perf_counter()
38    sequential_compute(numbers)
39    sequential_time = time.perf_counter() - start
40
41    # 並行執行
42    start = time.perf_counter()
43    parallel_compute(numbers)
44    parallel_time = time.perf_counter() - start
45
46    print(f"序列執行: {sequential_time:.3f}s")
47    print(f"並行執行: {parallel_time:.3f}s")
48    print(f"加速比: {sequential_time / parallel_time:.2f}x")
49
50    # 在傳統 Python 中，加速比接近 1（無改善）
51    # 在 Free-threaded Python 中，加速比接近 CPU 核心數
52
53if __name__ == "__main__":
54    try:
55        print(f"GIL 啟用: {sys._is_gil_enabled()}")
56    except AttributeError:
57        print("GIL 狀態: 無法檢測（舊版 Python）")
58
59    benchmark()

範例 3：使用 ThreadPoolExecutor

 1from concurrent.futures import ThreadPoolExecutor, as_completed
 2import time
 3import sys
 4
 5def process_chunk(chunk_id: int, size: int) -> dict:
 6    """處理一個資料區塊"""
 7    result = sum(i * i for i in range(size))
 8    return {"chunk_id": chunk_id, "result": result}
 9
10def parallel_process(num_chunks: int = 8, chunk_size: int = 2_000_000):
11    """並行處理多個資料區塊"""
12    start = time.perf_counter()
13
14    with ThreadPoolExecutor(max_workers=num_chunks) as executor:
15        futures = {
16            executor.submit(process_chunk, i, chunk_size): i
17            for i in range(num_chunks)
18        }
19
20        results = []
21        for future in as_completed(futures):
22            chunk_id = futures[future]
23            result = future.result()
24            results.append(result)
25            print(f"Chunk {chunk_id} 完成")
26
27    elapsed = time.perf_counter() - start
28    print(f"\n總耗時: {elapsed:.3f}s")
29    print(f"平均每個 chunk: {elapsed / num_chunks:.3f}s")
30
31    return results
32
33if __name__ == "__main__":
34    try:
35        print(f"Free-threaded 模式: {not sys._is_gil_enabled()}\n")
36    except AttributeError:
37        print("傳統 Python 模式\n")
38
39    parallel_process()

concurrent.interpreters 模組（Python 3.14 新增）

Python 3.14 引入了全新的 concurrent.interpreters 模組，提供了另一種並行方式。

什麼是多解釋器？

多解釋器（Multiple Interpreters）是在同一個進程中運行多個獨立的 Python 直譯器：

1┌─────────────────────────────────────────┐
2│              單一進程                     │
3│  ┌──────────┐  ┌──────────┐             │
4│  │ 解釋器 1  │  │ 解釋器 2  │             │
5│  │ (獨立)   │  │ (獨立)   │             │
6│  │ sys.path │  │ sys.path │  ← 完全隔離  │
7│  │ modules  │  │ modules  │             │
8│  └──────────┘  └──────────┘             │
9└─────────────────────────────────────────┘

基本用法

 1from concurrent.futures import InterpreterPoolExecutor
 2
 3def cpu_task(n: int) -> int:
 4    """在獨立解釋器中執行的任務"""
 5    return sum(i * i for i in range(n))
 6
 7if __name__ == "__main__":
 8    numbers = [1_000_000, 2_000_000, 3_000_000, 4_000_000]
 9
10    # 使用多解釋器池
11    with InterpreterPoolExecutor(max_workers=4) as executor:
12        results = list(executor.map(cpu_task, numbers))
13
14    print(f"結果: {results}")

多解釋器 vs 多進程 vs 多執行緒

特性	threading	multiprocessing	interpreters
隔離程度	共享記憶體	完全隔離	部分隔離
資源消耗	最低	最高	中等
啟動速度	最快	最慢	中等
通訊方式	直接存取	pickle/Queue	pickle
GIL 影響	受限（傳統）/ 無（Free-threaded）	無	無

何時使用多解釋器

需要隔離但不想付出多進程的代價
想要類似 CSP/Actor 模型的並行方式
需要在同一進程中運行不同配置的 Python 環境

已知問題與陷阱

來自 GitHub Issues 的真實案例

1. pathlib 的 race condition（#139001）

1# 在 3.14t 中可能有問題
2from pathlib import Path
3import threading
4
5path = Path("/some/path")
6
7def check_path():
8    # is_dir() 在多執行緒下可能有競爭條件
9    return path.is_dir()

2. click 套件的問題（#136248）

使用 click 套件時，在 free-threaded 模式下可能出現意外行為。

3. buffer interface 的資料競爭（#130977）

使用 memoryview 或其他 buffer interface 時需特別注意。

常見錯誤模式

 1# 錯誤：全域狀態未加鎖保護
 2cache = {}
 3
 4def get_cached(key):
 5    if key not in cache:
 6        cache[key] = expensive_compute(key)  # 競爭條件！
 7    return cache[key]
 8
 9# 正確：使用 Lock 保護
10import threading
11
12cache = {}
13cache_lock = threading.Lock()
14
15def get_cached_safe(key):
16    with cache_lock:
17        if key not in cache:
18            cache[key] = expensive_compute(key)
19        return cache[key]

 1# 錯誤：依賴內建型別的「隱式」執行緒安全
 2results = []
 3
 4def worker(n):
 5    result = compute(n)
 6    results.append(result)  # 在 free-threaded 中可能不安全
 7
 8# 正確：返回結果，由主執行緒收集
 9def worker_safe(n):
10    return compute(n)
11
12with ThreadPoolExecutor() as executor:
13    results = list(executor.map(worker_safe, items))

套件相容性現況（2025 年底）

已完全支援

套件	版本	備註
NumPy	2.1.0+	科學計算基礎
SciPy	1.15.0+	科學計算
pandas	2.2.3+	資料分析
PyTorch	2.6.0+	深度學習
scikit-learn	1.6.0+	機器學習
Pillow	11.0.0+	圖像處理
Matplotlib	3.9.0+	繪圖

部分支援或開發中

cryptography、h5py、polars
aiohttp、multidict、yarl
多個 aio-libs 套件

尚未支援

lxml、cupy 等特定套件
部分 C 擴展模組

追蹤最新狀態：py-free-threading.github.io/tracking

最佳實踐與建議

1. 漸進式採用

 1import sys
 2
 3def main():
 4    # 檢查執行環境
 5    free_threaded = getattr(sys, '_is_gil_enabled', lambda: True)() == False
 6
 7    if free_threaded:
 8        print("使用 Free-threaded 最佳化路徑")
 9        run_parallel_optimized()
10    else:
11        print("使用傳統多進程路徑")
12        run_multiprocess_fallback()

2. 明確使用同步原語

1import threading
2
3# 永遠明確使用 Lock，不要依賴「可能」的執行緒安全
4lock = threading.Lock()
5
6def thread_safe_operation():
7    with lock:
8        # 關鍵區段
9        pass

3. 測試策略

 1# 使用較短的執行緒切換間隔來暴露潛在的競爭條件
 2import sys
 3sys.setswitchinterval(0.0001)  # 測試時使用
 4
 5# 運行大量並行測試
 6import concurrent.futures
 7import random
 8
 9def stress_test(func, iterations=1000):
10    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
11        futures = [executor.submit(func) for _ in range(iterations)]
12        for f in concurrent.futures.as_completed(futures):
13            f.result()  # 會拋出任何異常

4. 檢查依賴套件相容性

 1def check_dependencies():
 2    """檢查關鍵依賴是否支援 free-threading"""
 3    import importlib.metadata
 4
 5    packages_to_check = ['numpy', 'pandas', 'scikit-learn']
 6    results = {}
 7
 8    for pkg in packages_to_check:
 9        try:
10            version = importlib.metadata.version(pkg)
11            results[pkg] = version
12        except importlib.metadata.PackageNotFoundError:
13            results[pkg] = "未安裝"
14
15    return results

未來展望

路線圖

Python 3.15：預期 Free-threading 將成為可選的預設選項
Python 3.16：可能成為真正的預設建置
長期：GIL 可能完全移除

社群呼籲

「Free-threaded 建置是這個語言的未來。現階段我們需要更多來自真實工作流程的回饋報告。」 — Quansight Labs

如果你正在使用 Free-threaded Python，歡迎：

回報問題到 Python Bug Tracker
參與 py-free-threading Discord 討論
測試你的套件並提交相容性報告

思考題

為什麼 Free-threading 在單執行緒下會有效能損失？這個損失從 40% 降到 9% 是如何達成的？
什麼情況下應該使用 InterpreterPoolExecutor 而不是 ThreadPoolExecutor？
如果你的程式依賴一個尚未支援 Free-threading 的套件，有什麼替代方案？

實作練習

寫一個程式，比較在傳統 Python 和 Free-threaded Python 下的多執行緒效能差異
使用 InterpreterPoolExecutor 實作一個簡單的任務佇列系統
為一個現有的單執行緒程式添加 Free-threading 支援，並處理執行緒安全問題

先備知識

入門系列並行處理 - threading、multiprocessing 基礎

上一章：GIL 與執行緒模型 下一模組：模組五：用 C 擴展 Python

案例研究

Wed, 21 Jan 2026 00:00:00 +0000

本節收錄基於 .claude/lib 實際程式碼的案例研究，展示如何應用 CPython 內部機制知識進行效能分析與優化。

案例列表

案例	素材	學習重點
效能分析實戰	markdown_link_checker.py	cProfile、line_profiler、效能瓶頸定位
記憶體優化	config_loader.py	slots、weakref、記憶體佔用分析

學習路徑

建議先完成本模組的理論章節，再閱讀案例研究：

理解 CPython 的物件模型
學習效能分析工具
通過案例實踐優化技巧

Cpython on Tarragon

案例：效能分析實戰

先備知識

問題背景

現有設計

效能問題

進階解決方案

分析目標

實作步驟

步驟 1：使用 cProfile 進行函式級分析

步驟 2：使用 pstats 分析結果

步驟 3：使用 line_profiler 進行行級分析

步驟 4：分析正則表達式效能

步驟 5：優化建議與驗證

完整程式碼

分析結果範例

設計權衡

什麼時候該做效能分析？

練習

基礎練習：用 cProfile 分析排序函式

進階練習：用 line_profiler 找出熱點程式碼

挑戰題：比較不同正則表達式寫法的效能差異

延伸閱讀

3.1 PyObject 與物件模型

先備知識

本章目標

【原理層】一切皆物件

什麼是「一切皆物件」？

PyObject 結構

變長物件：PyVarObject

【設計層】參考計數

工作原理

參考計數的增減時機

參考計數的優缺點

【實作層】觀察物件

使用 id() 觀察記憶體位址

小整數快取

字串駐留（String Interning）

使用 ctypes 觀察記憶體

觀察物件大小

【深入】PyTypeObject

型別物件的結構

在 Python 中觀察型別資訊

為什麼 is 比 == 快？

【實戰】效能影響

避免不必要的物件建立

使用物件池

思考題

實作練習

延伸閱讀

案例：記憶體優化

先備知識

問題背景

現有設計

記憶體問題

進階解決方案

優化目標

實作步驟

步驟 1：使用 __slots__ 減少物件大小

記憶體結構比較

大量物件的記憶體節省

步驟 2：使用 weakref 避免強引用

使用 callback 追蹤物件回收

步驟 3：使用 WeakValueDictionary

步驟 4：測量記憶體使用

比較記憶體差異的完整腳本

完整程式碼

使用範例

設計權衡

__slots__ vs 標準類別

強引用 vs 弱引用快取

何時使用哪種技術？

什麼時候該用這個技術？

適合使用

不建議使用

優化決策流程

練習

基礎練習：比較有無 __slots__ 的記憶體差異

進階練習：實作 weakref 快取

挑戰題：用 tracemalloc 追蹤記憶體洩漏

步驟 1：使用 `slots` 減少物件大小

`slots` vs 標準類別

基礎練習：比較有無 `slots` 的記憶體差異

為什麼 `slots` 省記憶體？