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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 1import re
 2from typing import List, Dict
 3
 4class MarkdownLinkChecker:
 5    """Markdown 連結檢查器"""
 6
 7    # Markdown 連結正則表達式
 8    # 匹配 [text](/python-advanced/05-c-extensions/case-studies/cython-markdown/target) 格式，排除圖片 ![alt](/python-advanced/05-c-extensions/case-studies/cython-markdown/src)
 9    INLINE_LINK_PATTERN = re.compile(
10        r'(?<!!)\[([^\]]+)\]\(([^)]+)\)'
11    )
12
13    # 引用式連結定義 [ref]: target
14    REFERENCE_DEF_PATTERN = re.compile(
15        r'^\s*\[([^\]]+)\]:\s*(.+)$',
16        re.MULTILINE
17    )
18
19    # 引用式連結使用 [text][ref]
20    REFERENCE_USE_PATTERN = re.compile(
21        r'\[([^\]]+)\]\[([^\]]+)\]'
22    )
23
24    def parse_markdown_links(self, content: str) -> List[Dict]:
25        """
26        解析 Markdown 內容中的所有連結
27
28        Args:
29            content: Markdown 內容
30
31        Returns:
32            list[dict]: 連結列表，每個包含 text, target, line
33        """
34        links = []
35        lines = content.split('\n')
36
37        # 首先收集引用式連結定義
38        reference_defs = {}
39        for match in self.REFERENCE_DEF_PATTERN.finditer(content):
40            ref_name = match.group(1).lower()
41            ref_target = match.group(2).strip()
42            reference_defs[ref_name] = ref_target
43
44        # 追蹤是否在程式碼區塊內
45        in_code_block = False
46
47        # 解析行內連結
48        for line_num, line in enumerate(lines, start=1):
49            # 檢查程式碼區塊開始/結束
50            if line.strip().startswith("```"):
51                in_code_block = not in_code_block
52                continue
53
54            # 跳過程式碼區塊內的連結
55            if in_code_block:
56                continue
57
58            # 行內連結 [text](/python-advanced/05-c-extensions/case-studies/cython-markdown/target)
59            for match in self.INLINE_LINK_PATTERN.finditer(line):
60                links.append({
61                    "text": match.group(1),
62                    "target": match.group(2),
63                    "line": line_num
64                })
65
66            # 引用式連結 [text][ref]
67            for match in self.REFERENCE_USE_PATTERN.finditer(line):
68                ref_name = match.group(2).lower()
69                if ref_name in reference_defs:
70                    links.append({
71                        "text": match.group(1),
72                        "target": reference_defs[ref_name],
73                        "line": line_num
74                    })
75
76        return links

 1# markdown_parser.pyx
 2"""
 3Cython accelerated Markdown link parser.
 4
 5This module provides fast parsing of Markdown links,
 6compatible with the original Python implementation.
 7"""
 8
 9import re
10from typing import List, Dict
11
12# Compile regex patterns at module level for reuse
13cdef object INLINE_LINK_PATTERN = re.compile(
14    r'(?<!!)\[([^\]]+)\]\(([^)]+)\)'
15)
16
17cdef object REFERENCE_DEF_PATTERN = re.compile(
18    r'^\s*\[([^\]]+)\]:\s*(.+)$',
19    re.MULTILINE
20)
21
22cdef object REFERENCE_USE_PATTERN = re.compile(
23    r'\[([^\]]+)\]\[([^\]]+)\]'
24)

 1# markdown_parser.pyx (continued)
 2
 3cdef class LinkInfo:
 4    """
 5    C-level struct to hold link information.
 6    Faster than Python dict for internal operations.
 7    """
 8    cdef public str text
 9    cdef public str target
10    cdef public int line
11
12    def __init__(self, str text, str target, int line):
13        self.text = text
14        self.target = target
15        self.line = line
16
17    def to_dict(self) -> dict:
18        """Convert to dictionary for API compatibility."""
19        return {
20            "text": self.text,
21            "target": self.target,
22            "line": self.line
23        }
24
25cdef bint is_code_fence(str line):
26    """
27    Check if line is a code fence marker.
28
29    cdef function: only callable from Cython, fastest.
30    """
31    cdef str stripped = line.strip()
32    return stripped.startswith("```") or stripped.startswith("~~~")

 1# markdown_parser.pyx (continued)
 2
 3cdef list _parse_inline_links(list lines, dict reference_defs):
 4    """
 5    Parse inline and reference links from lines.
 6
 7    Internal function with optimized loop.
 8    """
 9    cdef:
10        list links = []
11        int line_num
12        int total_lines = len(lines)
13        bint in_code_block = False
14        str line
15        str ref_name
16        object match
17
18    for line_num in range(total_lines):
19        line = lines[line_num]
20
21        # Check code fence
22        if is_code_fence(line):
23            in_code_block = not in_code_block
24            continue
25
26        if in_code_block:
27            continue
28
29        # Parse inline links [text](/python-advanced/05-c-extensions/case-studies/cython-markdown/target)
30        for match in INLINE_LINK_PATTERN.finditer(line):
31            links.append(LinkInfo(
32                match.group(1),
33                match.group(2),
34                line_num + 1  # 1-indexed
35            ))
36
37        # Parse reference links [text][ref]
38        for match in REFERENCE_USE_PATTERN.finditer(line):
39            ref_name = match.group(2).lower()
40            if ref_name in reference_defs:
41                links.append(LinkInfo(
42                    match.group(1),
43                    reference_defs[ref_name],
44                    line_num + 1
45                ))
46
47    return links
48
49cdef dict _collect_reference_defs(str content):
50    """
51    Collect reference link definitions from content.
52
53    Returns dict mapping ref_name -> target.
54    """
55    cdef:
56        dict reference_defs = {}
57        object match
58        str ref_name
59        str ref_target
60
61    for match in REFERENCE_DEF_PATTERN.finditer(content):
62        ref_name = match.group(1).lower()
63        ref_target = match.group(2).strip()
64        reference_defs[ref_name] = ref_target
65
66    return reference_defs

 1# markdown_parser.pyx (continued)
 2
 3cpdef list parse_markdown_links(str content):
 4    """
 5    Parse all links from Markdown content.
 6
 7    This is the main public API, compatible with the original
 8    Python implementation.
 9
10    Args:
11        content: Markdown content string
12
13    Returns:
14        List of dicts with 'text', 'target', 'line' keys
15    """
16    cdef:
17        list lines
18        dict reference_defs
19        list link_infos
20        list result
21        LinkInfo info
22
23    # Split content into lines
24    lines = content.split('\n')
25
26    # Collect reference definitions
27    reference_defs = _collect_reference_defs(content)
28
29    # Parse all links
30    link_infos = _parse_inline_links(lines, reference_defs)
31
32    # Convert to dict format for API compatibility
33    result = [info.to_dict() for info in link_infos]
34
35    return result
36
37def parse_markdown_links_py(content: str) -> List[Dict]:
38    """
39    Python-compatible wrapper with type hints.
40
41    Identical to parse_markdown_links but with explicit
42    Python type annotations for better IDE support.
43    """
44    return parse_markdown_links(content)

 1# setup.py
 2"""
 3Build script for Cython markdown parser.
 4
 5Usage:
 6    python setup.py build_ext --inplace
 7
 8Or for development with automatic rebuild:
 9    pip install -e .
10"""
11
12from setuptools import setup, Extension
13from Cython.Build import cythonize
14
15extensions = [
16    Extension(
17        "markdown_parser",
18        sources=["markdown_parser.pyx"],
19        # Optional: add compiler directives for optimization
20        # extra_compile_args=["-O3"],
21    )
22]
23
24setup(
25    name="markdown_parser",
26    version="0.1.0",
27    description="Cython accelerated Markdown link parser",
28    ext_modules=cythonize(
29        extensions,
30        compiler_directives={
31            "language_level": "3",      # Python 3 syntax
32            "boundscheck": False,       # Disable bounds checking
33            "wraparound": False,        # Disable negative indexing
34            "cdivision": True,          # Use C division semantics
35        },
36        annotate=True,  # Generate HTML annotation file
37    ),
38    zip_safe=False,
39)

  1# markdown_parser.pyx
  2"""
  3Cython accelerated Markdown link parser.
  4
  5This module provides fast parsing of Markdown links,
  6compatible with the original Python implementation.
  7
  8Build:
  9    python setup.py build_ext --inplace
 10
 11Usage:
 12    from markdown_parser import parse_markdown_links
 13    links = parse_markdown_links(markdown_content)
 14"""
 15
 16import re
 17from typing import List, Dict
 18
 19# ============================================================
 20# Compiled regex patterns (module level for reuse)
 21# ============================================================
 22
 23cdef object INLINE_LINK_PATTERN = re.compile(
 24    r'(?<!!)\[([^\]]+)\]\(([^)]+)\)'
 25)
 26
 27cdef object REFERENCE_DEF_PATTERN = re.compile(
 28    r'^\s*\[([^\]]+)\]:\s*(.+)$',
 29    re.MULTILINE
 30)
 31
 32cdef object REFERENCE_USE_PATTERN = re.compile(
 33    r'\[([^\]]+)\]\[([^\]]+)\]'
 34)
 35
 36# ============================================================
 37# C-level data structures
 38# ============================================================
 39
 40cdef class LinkInfo:
 41    """
 42    C-level struct to hold link information.
 43    Faster than Python dict for internal operations.
 44    """
 45    cdef public str text
 46    cdef public str target
 47    cdef public int line
 48
 49    def __init__(self, str text, str target, int line):
 50        self.text = text
 51        self.target = target
 52        self.line = line
 53
 54    def to_dict(self) -> dict:
 55        """Convert to dictionary for API compatibility."""
 56        return {
 57            "text": self.text,
 58            "target": self.target,
 59            "line": self.line
 60        }
 61
 62    def __repr__(self):
 63        return f"LinkInfo(text={self.text!r}, target={self.target!r}, line={self.line})"
 64
 65# ============================================================
 66# Internal helper functions (cdef = C-only, fastest)
 67# ============================================================
 68
 69cdef bint is_code_fence(str line):
 70    """
 71    Check if line is a code fence marker.
 72    """
 73    cdef str stripped = line.strip()
 74    return stripped.startswith("```") or stripped.startswith("~~~")
 75
 76cdef dict _collect_reference_defs(str content):
 77    """
 78    Collect reference link definitions from content.
 79    """
 80    cdef:
 81        dict reference_defs = {}
 82        object match
 83        str ref_name
 84        str ref_target
 85
 86    for match in REFERENCE_DEF_PATTERN.finditer(content):
 87        ref_name = match.group(1).lower()
 88        ref_target = match.group(2).strip()
 89        reference_defs[ref_name] = ref_target
 90
 91    return reference_defs
 92
 93cdef list _parse_inline_links(list lines, dict reference_defs):
 94    """
 95    Parse inline and reference links from lines.
 96    """
 97    cdef:
 98        list links = []
 99        int line_num
100        int total_lines = len(lines)
101        bint in_code_block = False
102        str line
103        str ref_name
104        object match
105
106    for line_num in range(total_lines):
107        line = lines[line_num]
108
109        # Check code fence
110        if is_code_fence(line):
111            in_code_block = not in_code_block
112            continue
113
114        if in_code_block:
115            continue
116
117        # Parse inline links [text](/python-advanced/05-c-extensions/case-studies/cython-markdown/target)
118        for match in INLINE_LINK_PATTERN.finditer(line):
119            links.append(LinkInfo(
120                match.group(1),
121                match.group(2),
122                line_num + 1
123            ))
124
125        # Parse reference links [text][ref]
126        for match in REFERENCE_USE_PATTERN.finditer(line):
127            ref_name = match.group(2).lower()
128            if ref_name in reference_defs:
129                links.append(LinkInfo(
130                    match.group(1),
131                    reference_defs[ref_name],
132                    line_num + 1
133                ))
134
135    return links
136
137# ============================================================
138# Public API (cpdef = callable from both Python and Cython)
139# ============================================================
140
141cpdef list parse_markdown_links(str content):
142    """
143    Parse all links from Markdown content.
144
145    Args:
146        content: Markdown content string
147
148    Returns:
149        List of dicts with 'text', 'target', 'line' keys
150
151    Example:
152        >>> content = "[Click here](https://example.com)"
153        >>> links = parse_markdown_links(content)
154        >>> links[0]['target']
155        'https://example.com'
156    """
157    cdef:
158        list lines
159        dict reference_defs
160        list link_infos
161        list result
162        LinkInfo info
163
164    lines = content.split('\n')
165    reference_defs = _collect_reference_defs(content)
166    link_infos = _parse_inline_links(lines, reference_defs)
167    result = [info.to_dict() for info in link_infos]
168
169    return result
170
171# Python-compatible wrapper with full type hints
172def parse_markdown_links_py(content: str) -> List[Dict]:
173    """
174    Python-compatible wrapper with type hints.
175
176    Identical to parse_markdown_links but with explicit
177    Python type annotations for better IDE support.
178    """
179    return parse_markdown_links(content)
180
181# ============================================================
182# Optional: Expose LinkInfo class for advanced usage
183# ============================================================
184
185def parse_markdown_links_fast(str content) -> list:
186    """
187    Parse links and return LinkInfo objects directly.
188
189    Faster than parse_markdown_links() as it skips
190    the dict conversion step.
191
192    Returns:
193        List of LinkInfo objects
194    """
195    cdef:
196        list lines
197        dict reference_defs
198
199    lines = content.split('\n')
200    reference_defs = _collect_reference_defs(content)
201    return _parse_inline_links(lines, reference_defs)

  1# benchmark.py
  2"""
  3Performance comparison between Python and Cython implementations.
  4
  5Usage:
  6    # First, build the Cython module
  7    python setup.py build_ext --inplace
  8
  9    # Then run benchmark
 10    python benchmark.py
 11"""
 12
 13import time
 14import statistics
 15from typing import Callable, List
 16
 17# Pure Python implementation (inline for comparison)
 18import re
 19
 20class PythonMarkdownParser:
 21    """Original pure Python implementation."""
 22
 23    INLINE_LINK_PATTERN = re.compile(r'(?<!!)\[([^\]]+)\]\(([^)]+)\)')
 24    REFERENCE_DEF_PATTERN = re.compile(r'^\s*\[([^\]]+)\]:\s*(.+)$', re.MULTILINE)
 25    REFERENCE_USE_PATTERN = re.compile(r'\[([^\]]+)\]\[([^\]]+)\]')
 26
 27    def parse_markdown_links(self, content: str) -> list:
 28        links = []
 29        lines = content.split('\n')
 30
 31        reference_defs = {}
 32        for match in self.REFERENCE_DEF_PATTERN.finditer(content):
 33            ref_name = match.group(1).lower()
 34            ref_target = match.group(2).strip()
 35            reference_defs[ref_name] = ref_target
 36
 37        in_code_block = False
 38
 39        for line_num, line in enumerate(lines, start=1):
 40            if line.strip().startswith("```"):
 41                in_code_block = not in_code_block
 42                continue
 43
 44            if in_code_block:
 45                continue
 46
 47            for match in self.INLINE_LINK_PATTERN.finditer(line):
 48                links.append({
 49                    "text": match.group(1),
 50                    "target": match.group(2),
 51                    "line": line_num
 52                })
 53
 54            for match in self.REFERENCE_USE_PATTERN.finditer(line):
 55                ref_name = match.group(2).lower()
 56                if ref_name in reference_defs:
 57                    links.append({
 58                        "text": match.group(1),
 59                        "target": reference_defs[ref_name],
 60                        "line": line_num
 61                    })
 62
 63        return links
 64
 65def generate_test_content(num_lines: int, links_per_100_lines: int = 10) -> str:
 66    """Generate test Markdown content with specified characteristics."""
 67    lines = []
 68    for i in range(num_lines):
 69        if i % (100 // links_per_100_lines) == 0:
 70            # Add an inline link
 71            lines.append(f"Check out [Link {i}](https://example.com/page{i}) for details.")
 72        elif i % 50 == 0:
 73            # Add a code block
 74            lines.append("```python")
 75            lines.append(f"# This is code, links here [should](/python-advanced/05-c-extensions/case-studies/cython-markdown/be/ignored)")
 76            lines.append("```")
 77        else:
 78            # Regular text
 79            lines.append(f"This is line {i} with some regular text content.")
 80
 81    return '\n'.join(lines)
 82
 83def benchmark(func: Callable, content: str, iterations: int = 100) -> dict:
 84    """Run benchmark and return statistics."""
 85    times = []
 86
 87    # Warmup
 88    for _ in range(5):
 89        func(content)
 90
 91    # Actual benchmark
 92    for _ in range(iterations):
 93        start = time.perf_counter()
 94        result = func(content)
 95        end = time.perf_counter()
 96        times.append(end - start)
 97
 98    return {
 99        "mean": statistics.mean(times) * 1000,  # Convert to ms
100        "stdev": statistics.stdev(times) * 1000,
101        "min": min(times) * 1000,
102        "max": max(times) * 1000,
103        "links_found": len(result),
104    }
105
106def main():
107    print("=" * 60)
108    print("Markdown Link Parser Benchmark")
109    print("=" * 60)
110
111    # Test different content sizes
112    sizes = [1000, 5000, 10000, 50000]
113
114    python_parser = PythonMarkdownParser()
115
116    # Try to import Cython version
117    try:
118        from markdown_parser import parse_markdown_links as cython_parse
119        has_cython = True
120    except ImportError:
121        print("\nWarning: Cython module not found.")
122        print("Run 'python setup.py build_ext --inplace' first.\n")
123        has_cython = False
124
125    for size in sizes:
126        print(f"\n--- Content size: {size} lines ---")
127        content = generate_test_content(size)
128
129        # Python benchmark
130        py_result = benchmark(python_parser.parse_markdown_links, content)
131        print(f"Python:  {py_result['mean']:.3f} ms (+/- {py_result['stdev']:.3f} ms)")
132        print(f"         Found {py_result['links_found']} links")
133
134        # Cython benchmark (if available)
135        if has_cython:
136            cy_result = benchmark(cython_parse, content)
137            speedup = py_result['mean'] / cy_result['mean']
138            print(f"Cython:  {cy_result['mean']:.3f} ms (+/- {cy_result['stdev']:.3f} ms)")
139            print(f"         Speedup: {speedup:.2f}x")
140
141    print("\n" + "=" * 60)
142
143if __name__ == "__main__":
144    main()

 1============================================================
 2Markdown Link Parser Benchmark
 3============================================================
 4
 5--- Content size: 1000 lines ---
 6Python:  0.523 ms (+/- 0.031 ms)
 7         Found 100 links
 8Cython:  0.198 ms (+/- 0.012 ms)
 9         Speedup: 2.64x
10
11--- Content size: 5000 lines ---
12Python:  2.617 ms (+/- 0.089 ms)
13         Found 500 links
14Cython:  0.892 ms (+/- 0.045 ms)
15         Speedup: 2.93x
16
17--- Content size: 10000 lines ---
18Python:  5.234 ms (+/- 0.156 ms)
19         Found 1000 links
20Cython:  1.712 ms (+/- 0.078 ms)
21         Speedup: 3.06x
22
23--- Content size: 50000 lines ---
24Python:  26.18 ms (+/- 0.823 ms)
25         Found 5000 links
26Cython:  7.89 ms (+/- 0.312 ms)
27         Speedup: 3.32x
28
29============================================================

 1# advanced_parser.pyx
 2"""
 3Advanced parser using PCRE2 C library for maximum performance.
 4
 5Requires: libpcre2-dev (Ubuntu) or pcre2 (macOS Homebrew)
 6"""
 7
 8cdef extern from "pcre2.h":
 9    # PCRE2 declarations...
10    pass
11
12# This is an advanced topic, see PCRE2 documentation for details

 1如果 Cython 不適合你的情境，考慮：
 2
 31. PyPy
 4   - 無需修改程式碼
 5   - JIT 編譯帶來 5-10x 加速
 6   - 但相容性問題較多
 7
 82. Numba
 9   - 針對數值計算優化
10   - 使用裝飾器即可加速
11   - 但僅支援部分 Python 語法
12
133. 演算法優化
14   - 先檢查是否有更好的演算法
15   - 減少不必要的記憶體分配
16   - 使用更高效的資料結構

 1# exercise_1.py
 2def count_words(text: str) -> dict:
 3    """Count word frequencies in text."""
 4    words = text.lower().split()
 5    counts = {}
 6    for word in words:
 7        word = word.strip('.,!?;:')
 8        if word:
 9            counts[word] = counts.get(word, 0) + 1
10    return counts

 1# exercise_2.py
 2import cProfile
 3import pstats
 4
 5def profile_parsers(content: str):
 6    """Profile both Python and Cython parsers."""
 7    from markdown_parser import parse_markdown_links as cython_parse
 8
 9    python_parser = PythonMarkdownParser()
10
11    # Profile Python version
12    print("=== Python Version ===")
13    cProfile.runctx(
14        'for _ in range(100): python_parser.parse_markdown_links(content)',
15        globals(), locals(),
16        'python_stats'
17    )
18    stats = pstats.Stats('python_stats')
19    stats.strip_dirs().sort_stats('cumulative').print_stats(10)
20
21    # Profile Cython version
22    print("\n=== Cython Version ===")
23    cProfile.runctx(
24        'for _ in range(100): cython_parse(content)',
25        globals(), locals(),
26        'cython_stats'
27    )
28    stats = pstats.Stats('cython_stats')
29    stats.strip_dirs().sort_stats('cumulative').print_stats(10)

 1import re
 2from typing import List, Dict
 3
 4class MarkdownLinkChecker:
 5    """Markdown 連結檢查器"""
 6
 7    # Markdown 連結正則表達式
 8    # 匹配 [text](/python-advanced/06-rust-extensions/case-studies/pyo3-parser/target) 格式，排除圖片 ![alt](/python-advanced/06-rust-extensions/case-studies/pyo3-parser/src)
 9    INLINE_LINK_PATTERN = re.compile(
10        r'(?<!!)\[([^\]]+)\]\(([^)]+)\)'
11    )
12
13    # 引用式連結定義 [ref]: target
14    REFERENCE_DEF_PATTERN = re.compile(
15        r'^\s*\[([^\]]+)\]:\s*(.+)$',
16        re.MULTILINE
17    )
18
19    # 引用式連結使用 [text][ref]
20    REFERENCE_USE_PATTERN = re.compile(
21        r'\[([^\]]+)\]\[([^\]]+)\]'
22    )
23
24    def parse_markdown_links(self, content: str) -> List[Dict]:
25        """
26        解析 Markdown 內容中的所有連結
27
28        Args:
29            content: Markdown 內容
30
31        Returns:
32            list[dict]: 連結列表，每個包含 text, target, line
33        """
34        links = []
35        lines = content.split('\n')
36
37        # 首先收集引用式連結定義
38        reference_defs = {}
39        for match in self.REFERENCE_DEF_PATTERN.finditer(content):
40            ref_name = match.group(1).lower()
41            ref_target = match.group(2).strip()
42            reference_defs[ref_name] = ref_target
43
44        # 追蹤是否在程式碼區塊內
45        in_code_block = False
46
47        # 解析行內連結
48        for line_num, line in enumerate(lines, start=1):
49            # 檢查程式碼區塊開始/結束
50            if line.strip().startswith("```"):
51                in_code_block = not in_code_block
52                continue
53
54            # 跳過程式碼區塊內的連結
55            if in_code_block:
56                continue
57
58            # 行內連結 [text](/python-advanced/06-rust-extensions/case-studies/pyo3-parser/target)
59            for match in self.INLINE_LINK_PATTERN.finditer(line):
60                links.append({
61                    "text": match.group(1),
62                    "target": match.group(2),
63                    "line": line_num
64                })
65
66            # 引用式連結 [text][ref]
67            for match in self.REFERENCE_USE_PATTERN.finditer(line):
68                ref_name = match.group(2).lower()
69                if ref_name in reference_defs:
70                    links.append({
71                        "text": match.group(1),
72                        "target": reference_defs[ref_name],
73                        "line": line_num
74                    })
75
76        return links