<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://xdh2580.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://xdh2580.github.io/" rel="alternate" type="text/html" /><updated>2026-04-06T17:32:23+00:00</updated><id>https://xdh2580.github.io/feed.xml</id><title type="html">Love Always Had A Way</title><subtitle>An amazing website.</subtitle><author><name>xdh2580</name></author><entry><title type="html">算法ALGO</title><link href="https://xdh2580.github.io/%E7%AE%97%E6%B3%95/%E7%AE%97%E6%B3%95ALGO/" rel="alternate" type="text/html" title="算法ALGO" /><published>2026-04-05T00:00:00+00:00</published><updated>2026-04-05T00:00:00+00:00</updated><id>https://xdh2580.github.io/%E7%AE%97%E6%B3%95/%E7%AE%97%E6%B3%95ALGO</id><content type="html" xml:base="https://xdh2580.github.io/%E7%AE%97%E6%B3%95/%E7%AE%97%E6%B3%95ALGO/"><![CDATA[<h1 id="算法-系统学习大纲以python示例">算法 系统学习大纲（以python示例）</h1>

<p><strong>葵花宝典：</strong><a href="https://www.hello-algo.com/" target="_blank">hello算法</a><br />
<strong>力扣刷题：</strong><a href="https://leetcode.cn/" target="_blank">力扣LeetCode</a></p>

<h2 id="一算法基础">一、算法基础</h2>
<ul>
  <li><strong>1.1 算法定义与特性</strong>
    <ul>
      <li>什么是算法</li>
      <li>算法的五个特性：有穷性、确定性、可行性、输入、输出</li>
      <li>算法与程序的区别</li>
    </ul>
  </li>
  <li><strong>1.2 算法复杂度分析</strong>
    <ul>
      <li>时间复杂度</li>
      <li>空间复杂度</li>
      <li>大O表示法</li>
      <li>最好、最坏、平均情况复杂度</li>
      <li>时间复杂度比较</li>
    </ul>
  </li>
  <li><strong>1.3 算法效率评估方法</strong>
    <ul>
      <li>理论分析</li>
      <li>实验测量</li>
      <li>渐近分析</li>
    </ul>
  </li>
  <li><strong>1.4 算法描述方法</strong>
    <ul>
      <li>自然语言</li>
      <li>流程图</li>
      <li>伪代码</li>
      <li>编程语言实现</li>
    </ul>
  </li>
</ul>

<h2 id="二基础数据结构">二、基础数据结构</h2>
<ul>
  <li><strong>2.1 数组</strong>
    <ul>
      <li>数组基本操作</li>
      <li>多维数组</li>
      <li>动态数组</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 数组基本操作
</span><span class="n">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>

<span class="c1"># 访问元素
</span><span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>  <span class="c1"># 输出: 1
</span>
<span class="c1"># 插入元素
</span><span class="n">arr</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>  <span class="c1"># 在索引2插入10
</span>
<span class="c1"># 删除元素
</span><span class="n">arr</span><span class="p">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>  <span class="c1"># 删除索引3的元素
</span>
<span class="c1"># 遍历数组
</span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)):</span>
    <span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
</code></pre></div>    </div>
  </li>
  <li><strong>2.2 链表</strong>
    <ul>
      <li>单向链表</li>
      <li>双向链表</li>
      <li>循环链表</li>
      <li>链表基本操作</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 单链表节点定义
</span><span class="k">class</span> <span class="nc">ListNode</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">val</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">next</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">val</span> <span class="o">=</span> <span class="n">val</span>
        <span class="bp">self</span><span class="p">.</span><span class="nb">next</span> <span class="o">=</span> <span class="nb">next</span>

<span class="c1"># 链表遍历
</span><span class="k">def</span> <span class="nf">traverse_list</span><span class="p">(</span><span class="n">head</span><span class="p">):</span>
    <span class="n">current</span> <span class="o">=</span> <span class="n">head</span>
    <span class="k">while</span> <span class="n">current</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="n">current</span><span class="p">.</span><span class="n">val</span><span class="p">)</span>
        <span class="n">current</span> <span class="o">=</span> <span class="n">current</span><span class="p">.</span><span class="nb">next</span>
</code></pre></div>    </div>
  </li>
  <li><strong>2.3 栈</strong>
    <ul>
      <li>栈的定义与特性</li>
      <li>栈的实现</li>
      <li>栈的应用</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 栈的实现
</span><span class="k">class</span> <span class="nc">Stack</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">items</span> <span class="o">=</span> <span class="p">[]</span>
        
    <span class="k">def</span> <span class="nf">push</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
        
    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">.</span><span class="n">is_empty</span><span class="p">():</span>
            <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">.</span><span class="n">pop</span><span class="p">()</span>
        
    <span class="k">def</span> <span class="nf">peek</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">.</span><span class="n">is_empty</span><span class="p">():</span>
            <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
        
    <span class="k">def</span> <span class="nf">is_empty</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span>
        
    <span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
  <li><strong>2.4 队列</strong>
    <ul>
      <li>队列的定义与特性</li>
      <li>普通队列</li>
      <li>双端队列</li>
      <li>优先队列</li>
      <li>循环队列</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 队列实现
</span><span class="k">class</span> <span class="nc">Queue</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">items</span> <span class="o">=</span> <span class="p">[]</span>
        
    <span class="k">def</span> <span class="nf">enqueue</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">item</span><span class="p">)</span>
        
    <span class="k">def</span> <span class="nf">dequeue</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">.</span><span class="n">is_empty</span><span class="p">():</span>
            <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">.</span><span class="n">pop</span><span class="p">()</span>
        
    <span class="k">def</span> <span class="nf">is_empty</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span>
        
    <span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">items</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
  <li><strong>2.5 哈希表</strong>
    <ul>
      <li>哈希函数</li>
      <li>冲突解决</li>
      <li>装载因子</li>
      <li>哈希表实现</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 哈希表简单实现
</span><span class="k">class</span> <span class="nc">HashTable</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">size</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">size</span> <span class="o">=</span> <span class="n">size</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">table</span> <span class="o">=</span> <span class="p">[[]</span> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">size</span><span class="p">)]</span>
        
    <span class="k">def</span> <span class="nf">_hash</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">hash</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="o">%</span> <span class="bp">self</span><span class="p">.</span><span class="n">size</span>
        
    <span class="k">def</span> <span class="nf">put</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="n">hash_key</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">_hash</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">table</span><span class="p">[</span><span class="n">hash_key</span><span class="p">]):</span>
            <span class="k">if</span> <span class="n">k</span> <span class="o">==</span> <span class="n">key</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">table</span><span class="p">[</span><span class="n">hash_key</span><span class="p">][</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
                <span class="k">return</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">table</span><span class="p">[</span><span class="n">hash_key</span><span class="p">].</span><span class="n">append</span><span class="p">((</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">))</span>
        
    <span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">hash_key</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">_hash</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">.</span><span class="n">table</span><span class="p">[</span><span class="n">hash_key</span><span class="p">]:</span>
            <span class="k">if</span> <span class="n">k</span> <span class="o">==</span> <span class="n">key</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">v</span>
        <span class="k">return</span> <span class="bp">None</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="三排序算法">三、排序算法</h2>
<ul>
  <li><strong>3.1 排序算法分类</strong>
    <ul>
      <li>比较排序 vs 非比较排序</li>
      <li>内部排序 vs 外部排序</li>
      <li>稳定排序 vs 不稳定排序</li>
    </ul>
  </li>
  <li><strong>3.2 简单排序</strong>
    <ul>
      <li>冒泡排序</li>
      <li>选择排序</li>
      <li>插入排序</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 冒泡排序
</span><span class="k">def</span> <span class="nf">bubble_sort</span><span class="p">(</span><span class="n">arr</span><span class="p">):</span>
    <span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="o">+</span><span class="mi">1</span><span class="p">]:</span>
                <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">]</span>
    <span class="k">return</span> <span class="n">arr</span>
</code></pre></div>    </div>
  </li>
  <li><strong>3.3 高级排序</strong>
    <ul>
      <li>快速排序</li>
      <li>归并排序</li>
      <li>堆排序</li>
      <li>希尔排序</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 快速排序
</span><span class="k">def</span> <span class="nf">quick_sort</span><span class="p">(</span><span class="n">arr</span><span class="p">):</span>
    <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">arr</span>
    <span class="n">pivot</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="o">//</span><span class="mi">2</span><span class="p">]</span>
    <span class="n">left</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">arr</span> <span class="k">if</span> <span class="n">x</span> <span class="o">&lt;</span> <span class="n">pivot</span><span class="p">]</span>
    <span class="n">middle</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">arr</span> <span class="k">if</span> <span class="n">x</span> <span class="o">==</span> <span class="n">pivot</span><span class="p">]</span>
    <span class="n">right</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">arr</span> <span class="k">if</span> <span class="n">x</span> <span class="o">&gt;</span> <span class="n">pivot</span><span class="p">]</span>
    <span class="k">return</span> <span class="n">quick_sort</span><span class="p">(</span><span class="n">left</span><span class="p">)</span> <span class="o">+</span> <span class="n">middle</span> <span class="o">+</span> <span class="n">quick_sort</span><span class="p">(</span><span class="n">right</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
  <li><strong>3.4 线性排序</strong>
    <ul>
      <li>计数排序</li>
      <li>桶排序</li>
      <li>基数排序</li>
    </ul>
  </li>
  <li><strong>3.5 排序算法比较</strong>
    <ul>
      <li>时间复杂度对比</li>
      <li>空间复杂度对比</li>
      <li>稳定性对比</li>
      <li>适用场景</li>
    </ul>
  </li>
</ul>

<h2 id="四搜索算法">四、搜索算法</h2>
<ul>
  <li><strong>4.1 线性搜索</strong>
    <ul>
      <li>顺序查找</li>
      <li>哨兵查找</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 线性搜索
</span><span class="k">def</span> <span class="nf">linear_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">target</span><span class="p">):</span>
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)):</span>
        <span class="k">if</span> <span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">==</span> <span class="n">target</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">i</span>
    <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</code></pre></div>    </div>
  </li>
  <li><strong>4.2 二分搜索</strong>
    <ul>
      <li>二分查找原理</li>
      <li>二分查找实现</li>
      <li>二分查找变体</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 二分搜索
</span><span class="k">def</span> <span class="nf">binary_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">target</span><span class="p">):</span>
    <span class="n">left</span><span class="p">,</span> <span class="n">right</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span>
    <span class="k">while</span> <span class="n">left</span> <span class="o">&lt;=</span> <span class="n">right</span><span class="p">:</span>
        <span class="n">mid</span> <span class="o">=</span> <span class="n">left</span> <span class="o">+</span> <span class="p">(</span><span class="n">right</span> <span class="o">-</span> <span class="n">left</span><span class="p">)</span> <span class="o">//</span> <span class="mi">2</span>
        <span class="k">if</span> <span class="n">arr</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span> <span class="o">==</span> <span class="n">target</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">mid</span>
        <span class="k">elif</span> <span class="n">arr</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">target</span><span class="p">:</span>
            <span class="n">left</span> <span class="o">=</span> <span class="n">mid</span> <span class="o">+</span> <span class="mi">1</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">right</span> <span class="o">=</span> <span class="n">mid</span> <span class="o">-</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</code></pre></div>    </div>
  </li>
  <li><strong>4.3 哈希搜索</strong>
    <ul>
      <li>哈希查找</li>
      <li>布隆过滤器</li>
    </ul>
  </li>
  <li><strong>4.4 树形搜索</strong>
    <ul>
      <li>二叉搜索树</li>
      <li>B树/B+树</li>
    </ul>
  </li>
  <li><strong>4.5 字符串搜索</strong>
    <ul>
      <li>KMP算法</li>
      <li>Boyer-Moore算法</li>
      <li>Rabin-Karp算法</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># KMP算法
</span><span class="k">def</span> <span class="nf">kmp_search</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">pattern</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">build_lps</span><span class="p">(</span><span class="n">pattern</span><span class="p">):</span>
        <span class="n">lps</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="nb">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span>
        <span class="n">length</span> <span class="o">=</span> <span class="mi">0</span>
        <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span>
        <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">pattern</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">==</span> <span class="n">pattern</span><span class="p">[</span><span class="n">length</span><span class="p">]:</span>
                <span class="n">length</span> <span class="o">+=</span> <span class="mi">1</span>
                <span class="n">lps</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">length</span>
                <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="k">if</span> <span class="n">length</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
                    <span class="n">length</span> <span class="o">=</span> <span class="n">lps</span><span class="p">[</span><span class="n">length</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
                <span class="k">else</span><span class="p">:</span>
                    <span class="n">lps</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
                    <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
        <span class="k">return</span> <span class="n">lps</span>
        
    <span class="n">lps</span> <span class="o">=</span> <span class="n">build_lps</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span>
    <span class="n">i</span> <span class="o">=</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
    <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">pattern</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">==</span> <span class="n">text</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
            <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
            <span class="n">j</span> <span class="o">+=</span> <span class="mi">1</span>
        <span class="k">if</span> <span class="n">j</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">i</span> <span class="o">-</span> <span class="n">j</span>
        <span class="k">elif</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="ow">and</span> <span class="n">pattern</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">!=</span> <span class="n">text</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
            <span class="k">if</span> <span class="n">j</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
                <span class="n">j</span> <span class="o">=</span> <span class="n">lps</span><span class="p">[</span><span class="n">j</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="五递归与分治">五、递归与分治</h2>
<ul>
  <li><strong>5.1 递归基础</strong>
    <ul>
      <li>递归定义</li>
      <li>递归三要素</li>
      <li>递归调用栈</li>
    </ul>
  </li>
  <li><strong>5.2 递归算法设计</strong>
    <ul>
      <li>递归式求解</li>
      <li>递归树</li>
      <li>主定理</li>
    </ul>
  </li>
  <li><strong>5.3 分治算法</strong>
    <ul>
      <li>分治策略</li>
      <li>分治算法设计</li>
      <li>分治算法分析</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 归并排序（分治算法）
</span><span class="k">def</span> <span class="nf">merge_sort</span><span class="p">(</span><span class="n">arr</span><span class="p">):</span>
    <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">arr</span>
        
    <span class="n">mid</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span> <span class="o">//</span> <span class="mi">2</span>
    <span class="n">left</span> <span class="o">=</span> <span class="n">merge_sort</span><span class="p">(</span><span class="n">arr</span><span class="p">[:</span><span class="n">mid</span><span class="p">])</span>
    <span class="n">right</span> <span class="o">=</span> <span class="n">merge_sort</span><span class="p">(</span><span class="n">arr</span><span class="p">[</span><span class="n">mid</span><span class="p">:])</span>
        
    <span class="k">return</span> <span class="n">merge</span><span class="p">(</span><span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">merge</span><span class="p">(</span><span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">):</span>
    <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="n">i</span> <span class="o">=</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
        
    <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">left</span><span class="p">)</span> <span class="ow">and</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">right</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">left</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">right</span><span class="p">[</span><span class="n">j</span><span class="p">]:</span>
            <span class="n">result</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">left</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
            <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">result</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">right</span><span class="p">[</span><span class="n">j</span><span class="p">])</span>
            <span class="n">j</span> <span class="o">+=</span> <span class="mi">1</span>
        
    <span class="n">result</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">left</span><span class="p">[</span><span class="n">i</span><span class="p">:])</span>
    <span class="n">result</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">right</span><span class="p">[</span><span class="n">j</span><span class="p">:])</span>
    <span class="k">return</span> <span class="n">result</span>
</code></pre></div>    </div>
  </li>
  <li><strong>5.4 递归与迭代转换</strong>
    <ul>
      <li>尾递归优化</li>
      <li>递归转迭代</li>
    </ul>
  </li>
  <li><strong>5.5 分治算法应用</strong>
    <ul>
      <li>大整数乘法</li>
      <li>快速傅里叶变换</li>
      <li>最近点对问题</li>
    </ul>
  </li>
</ul>

<h2 id="六动态规划">六、动态规划</h2>
<ul>
  <li><strong>6.1 动态规划基础</strong>
    <ul>
      <li>最优子结构</li>
      <li>重叠子问题</li>
      <li>状态转移方程</li>
    </ul>
  </li>
  <li><strong>6.2 动态规划步骤</strong>
    <ul>
      <li>定义状态</li>
      <li>确定状态转移</li>
      <li>确定初始条件</li>
      <li>计算顺序</li>
    </ul>
  </li>
  <li><strong>6.3 经典动态规划问题</strong>
    <ul>
      <li>斐波那契数列</li>
      <li>最长公共子序列</li>
      <li>最长递增子序列</li>
      <li>0-1背包问题</li>
      <li>完全背包问题</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 斐波那契数列（动态规划）
</span><span class="k">def</span> <span class="nf">fibonacci_dp</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">n</span>
        
    <span class="n">dp</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
    <span class="n">dp</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
        
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
        <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>
        
    <span class="k">return</span> <span class="n">dp</span><span class="p">[</span><span class="n">n</span><span class="p">]</span>

<span class="c1"># 0-1背包问题
</span><span class="k">def</span> <span class="nf">knapsack_01</span><span class="p">(</span><span class="n">weights</span><span class="p">,</span> <span class="n">values</span><span class="p">,</span> <span class="n">capacity</span><span class="p">):</span>
    <span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">weights</span><span class="p">)</span>
    <span class="n">dp</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="n">capacity</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)]</span>
        
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">w</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">capacity</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">weights</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="n">w</span><span class="p">:</span>
                <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">w</span><span class="p">]</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">w</span><span class="p">],</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">w</span><span class="o">-</span><span class="n">weights</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]]</span> <span class="o">+</span> <span class="n">values</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">w</span><span class="p">]</span> <span class="o">=</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">w</span><span class="p">]</span>
        
    <span class="k">return</span> <span class="n">dp</span><span class="p">[</span><span class="n">n</span><span class="p">][</span><span class="n">capacity</span><span class="p">]</span>
</code></pre></div>    </div>
  </li>
  <li><strong>6.4 动态规划优化</strong>
    <ul>
      <li>空间优化</li>
      <li>状态压缩</li>
      <li>记忆化搜索</li>
    </ul>
  </li>
  <li><strong>6.5 动态规划应用</strong>
    <ul>
      <li>编辑距离</li>
      <li>矩阵链乘法</li>
      <li>最优二叉搜索树</li>
      <li>旅行商问题</li>
    </ul>
  </li>
</ul>

<h2 id="七贪心算法">七、贪心算法</h2>
<ul>
  <li><strong>7.1 贪心算法基础</strong>
    <ul>
      <li>贪心选择性质</li>
      <li>最优子结构</li>
      <li>贪心算法与动态规划区别</li>
    </ul>
  </li>
  <li><strong>7.2 贪心算法设计</strong>
    <ul>
      <li>贪心策略选择</li>
      <li>算法正确性证明</li>
    </ul>
  </li>
  <li><strong>7.3 经典贪心算法问题</strong>
    <ul>
      <li>活动选择问题</li>
      <li>霍夫曼编码</li>
      <li>最小生成树</li>
      <li>单源最短路径</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 活动选择问题
</span><span class="k">def</span> <span class="nf">activity_selection</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">finish</span><span class="p">):</span>
    <span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
    <span class="n">activities</span> <span class="o">=</span> <span class="p">[]</span>
        
    <span class="c1"># 按结束时间排序
</span>    <span class="n">sorted_activities</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">finish</span><span class="p">,</span> <span class="n">start</span><span class="p">))</span>
    <span class="n">finish_sorted</span><span class="p">,</span> <span class="n">start_sorted</span> <span class="o">=</span> <span class="nb">zip</span><span class="p">(</span><span class="o">*</span><span class="n">sorted_activities</span><span class="p">)</span>
        
    <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
    <span class="n">activities</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
        
    <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">start_sorted</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">finish_sorted</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
            <span class="n">activities</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
            <span class="n">i</span> <span class="o">=</span> <span class="n">j</span>
        
    <span class="k">return</span> <span class="n">activities</span>
</code></pre></div>    </div>
  </li>
  <li><strong>7.4 贪心算法应用</strong>
    <ul>
      <li>找零钱问题</li>
      <li>区间调度问题</li>
      <li>任务调度问题</li>
      <li>集合覆盖问题</li>
    </ul>
  </li>
</ul>

<h2 id="八回溯算法">八、回溯算法</h2>
<ul>
  <li><strong>8.1 回溯算法基础</strong>
    <ul>
      <li>回溯法定义</li>
      <li>解空间树</li>
      <li>剪枝函数</li>
    </ul>
  </li>
  <li><strong>8.2 回溯算法框架</strong>
    <ul>
      <li>递归回溯</li>
      <li>迭代回溯</li>
    </ul>
  </li>
  <li><strong>8.3 经典回溯问题</strong>
    <ul>
      <li>N皇后问题</li>
      <li>子集和问题</li>
      <li>全排列</li>
      <li>组合问题</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># N皇后问题
</span><span class="k">def</span> <span class="nf">solve_n_queens</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">is_safe</span><span class="p">(</span><span class="n">board</span><span class="p">,</span> <span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">):</span>
        <span class="c1"># 检查列
</span>        <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">row</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">board</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">col</span><span class="p">]</span> <span class="o">==</span> <span class="s">'Q'</span><span class="p">:</span>
                <span class="k">return</span> <span class="bp">False</span>
            
        <span class="c1"># 检查左上对角线
</span>        <span class="n">i</span><span class="p">,</span> <span class="n">j</span> <span class="o">=</span> <span class="n">row</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="o">-</span><span class="mi">1</span>
        <span class="k">while</span> <span class="n">i</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">j</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">board</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="o">==</span> <span class="s">'Q'</span><span class="p">:</span>
                <span class="k">return</span> <span class="bp">False</span>
            <span class="n">i</span> <span class="o">-=</span> <span class="mi">1</span>
            <span class="n">j</span> <span class="o">-=</span> <span class="mi">1</span>
            
        <span class="c1"># 检查右上对角线
</span>        <span class="n">i</span><span class="p">,</span> <span class="n">j</span> <span class="o">=</span> <span class="n">row</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="o">+</span><span class="mi">1</span>
        <span class="k">while</span> <span class="n">i</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">board</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="o">==</span> <span class="s">'Q'</span><span class="p">:</span>
                <span class="k">return</span> <span class="bp">False</span>
            <span class="n">i</span> <span class="o">-=</span> <span class="mi">1</span>
            <span class="n">j</span> <span class="o">+=</span> <span class="mi">1</span>
            
        <span class="k">return</span> <span class="bp">True</span>
        
    <span class="k">def</span> <span class="nf">backtrack</span><span class="p">(</span><span class="n">row</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">row</span> <span class="o">==</span> <span class="n">n</span><span class="p">:</span>
            <span class="n">result</span><span class="p">.</span><span class="n">append</span><span class="p">([</span><span class="s">''</span><span class="p">.</span><span class="n">join</span><span class="p">(</span><span class="n">row</span><span class="p">)</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">board</span><span class="p">])</span>
            <span class="k">return</span>
            
        <span class="k">for</span> <span class="n">col</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">is_safe</span><span class="p">(</span><span class="n">board</span><span class="p">,</span> <span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">):</span>
                <span class="n">board</span><span class="p">[</span><span class="n">row</span><span class="p">][</span><span class="n">col</span><span class="p">]</span> <span class="o">=</span> <span class="s">'Q'</span>
                <span class="n">backtrack</span><span class="p">(</span><span class="n">row</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
                <span class="n">board</span><span class="p">[</span><span class="n">row</span><span class="p">][</span><span class="n">col</span><span class="p">]</span> <span class="o">=</span> <span class="s">'.'</span>
        
    <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="n">board</span> <span class="o">=</span> <span class="p">[[</span><span class="s">'.'</span> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">)]</span> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">)]</span>
    <span class="n">backtrack</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">result</span>
</code></pre></div>    </div>
  </li>
  <li><strong>8.4 回溯算法优化</strong>
    <ul>
      <li>可行性剪枝</li>
      <li>最优性剪枝</li>
      <li>记忆化</li>
    </ul>
  </li>
  <li><strong>8.5 回溯算法应用</strong>
    <ul>
      <li>数独求解</li>
      <li>图的着色问题</li>
      <li>哈密顿回路</li>
      <li>0-1背包问题</li>
    </ul>
  </li>
</ul>

<h2 id="九图算法">九、图算法</h2>
<ul>
  <li><strong>9.1 图的基本概念</strong>
    <ul>
      <li>图的定义</li>
      <li>图的表示</li>
      <li>图的基本术语</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 图的邻接表表示
</span><span class="k">class</span> <span class="nc">Graph</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">vertices</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">vertices</span> <span class="o">=</span> <span class="n">vertices</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">adj_list</span> <span class="o">=</span> <span class="p">{</span><span class="n">v</span><span class="p">:</span> <span class="p">[]</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">vertices</span><span class="p">)}</span>
        
    <span class="k">def</span> <span class="nf">add_edge</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">adj_list</span><span class="p">[</span><span class="n">u</span><span class="p">].</span><span class="n">append</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">adj_list</span><span class="p">[</span><span class="n">v</span><span class="p">].</span><span class="n">append</span><span class="p">(</span><span class="n">u</span><span class="p">)</span>  <span class="c1"># 无向图
</span></code></pre></div>    </div>
  </li>
  <li><strong>9.2 图的遍历</strong>
    <ul>
      <li>深度优先搜索</li>
      <li>广度优先搜索</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 深度优先搜索
</span><span class="k">def</span> <span class="nf">dfs</span><span class="p">(</span><span class="n">graph</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">visited</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">visited</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="n">visited</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
    <span class="n">visited</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
    <span class="k">print</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s">' '</span><span class="p">)</span>
        
    <span class="k">for</span> <span class="n">neighbor</span> <span class="ow">in</span> <span class="n">graph</span><span class="p">.</span><span class="n">adj_list</span><span class="p">[</span><span class="n">start</span><span class="p">]:</span>
        <span class="k">if</span> <span class="n">neighbor</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">visited</span><span class="p">:</span>
            <span class="n">dfs</span><span class="p">(</span><span class="n">graph</span><span class="p">,</span> <span class="n">neighbor</span><span class="p">,</span> <span class="n">visited</span><span class="p">)</span>
        
    <span class="k">return</span> <span class="n">visited</span>
</code></pre></div>    </div>
  </li>
  <li><strong>9.3 最短路径算法</strong>
    <ul>
      <li>Dijkstra算法</li>
      <li>Bellman-Ford算法</li>
      <li>Floyd-Warshall算法</li>
    </ul>
  </li>
  <li><strong>9.4 最小生成树</strong>
    <ul>
      <li>Kruskal算法</li>
      <li>Prim算法</li>
    </ul>
  </li>
  <li><strong>9.5 拓扑排序</strong>
    <ul>
      <li>拓扑排序算法</li>
      <li>应用场景</li>
    </ul>
  </li>
  <li><strong>9.6 强连通分量</strong>
    <ul>
      <li>Kosaraju算法</li>
      <li>Tarjan算法</li>
    </ul>
  </li>
  <li><strong>9.7 网络流算法</strong>
    <ul>
      <li>最大流</li>
      <li>最小割</li>
      <li>Ford-Fulkerson算法</li>
      <li>Edmonds-Karp算法</li>
    </ul>
  </li>
</ul>

<h2 id="十高级数据结构">十、高级数据结构</h2>
<ul>
  <li><strong>10.1 树</strong>
    <ul>
      <li>二叉树</li>
      <li>二叉搜索树</li>
      <li>平衡二叉树</li>
      <li>B树/B+树</li>
      <li>线段树</li>
      <li>树状数组</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 二叉搜索树
</span><span class="k">class</span> <span class="nc">TreeNode</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">val</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">left</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">right</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">val</span> <span class="o">=</span> <span class="n">val</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">left</span> <span class="o">=</span> <span class="n">left</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">right</span> <span class="o">=</span> <span class="n">right</span>

<span class="k">class</span> <span class="nc">BST</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">root</span> <span class="o">=</span> <span class="bp">None</span>
        
    <span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">val</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">.</span><span class="n">root</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">.</span><span class="n">root</span> <span class="o">=</span> <span class="n">TreeNode</span><span class="p">(</span><span class="n">val</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">.</span><span class="n">_insert</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">root</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
        
    <span class="k">def</span> <span class="nf">_insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">node</span><span class="p">,</span> <span class="n">val</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">val</span> <span class="o">&lt;</span> <span class="n">node</span><span class="p">.</span><span class="n">val</span><span class="p">:</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">node</span><span class="p">.</span><span class="n">left</span><span class="p">:</span>
                <span class="n">node</span><span class="p">.</span><span class="n">left</span> <span class="o">=</span> <span class="n">TreeNode</span><span class="p">(</span><span class="n">val</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">_insert</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">left</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">node</span><span class="p">.</span><span class="n">right</span><span class="p">:</span>
                <span class="n">node</span><span class="p">.</span><span class="n">right</span> <span class="o">=</span> <span class="n">TreeNode</span><span class="p">(</span><span class="n">val</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">_insert</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">right</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
  <li><strong>10.2 堆</strong>
    <ul>
      <li>二叉堆</li>
      <li>优先队列</li>
      <li>左偏树</li>
    </ul>
  </li>
  <li><strong>10.3 并查集</strong>
    <ul>
      <li>并查集操作</li>
      <li>路径压缩</li>
      <li>按秩合并</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 并查集
</span><span class="k">class</span> <span class="nc">UnionFind</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">parent</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">))</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">rank</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="n">n</span>
        
    <span class="k">def</span> <span class="nf">find</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="k">if</span> <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">x</span><span class="p">]</span> <span class="o">!=</span> <span class="n">x</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">x</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">find</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">x</span><span class="p">])</span>
        <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">x</span><span class="p">]</span>
        
    <span class="k">def</span> <span class="nf">union</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
        <span class="n">root_x</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">find</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="n">root_y</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">find</span><span class="p">(</span><span class="n">y</span><span class="p">)</span>
            
        <span class="k">if</span> <span class="n">root_x</span> <span class="o">!=</span> <span class="n">root_y</span><span class="p">:</span>
            <span class="k">if</span> <span class="bp">self</span><span class="p">.</span><span class="n">rank</span><span class="p">[</span><span class="n">root_x</span><span class="p">]</span> <span class="o">&lt;</span> <span class="bp">self</span><span class="p">.</span><span class="n">rank</span><span class="p">[</span><span class="n">root_y</span><span class="p">]:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">root_x</span><span class="p">]</span> <span class="o">=</span> <span class="n">root_y</span>
            <span class="k">elif</span> <span class="bp">self</span><span class="p">.</span><span class="n">rank</span><span class="p">[</span><span class="n">root_x</span><span class="p">]</span> <span class="o">&gt;</span> <span class="bp">self</span><span class="p">.</span><span class="n">rank</span><span class="p">[</span><span class="n">root_y</span><span class="p">]:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">root_y</span><span class="p">]</span> <span class="o">=</span> <span class="n">root_x</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">parent</span><span class="p">[</span><span class="n">root_y</span><span class="p">]</span> <span class="o">=</span> <span class="n">root_x</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">rank</span><span class="p">[</span><span class="n">root_x</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
            <span class="k">return</span> <span class="bp">True</span>
        <span class="k">return</span> <span class="bp">False</span>
</code></pre></div>    </div>
  </li>
  <li><strong>10.4 Trie树</strong>
    <ul>
      <li>Trie树实现</li>
      <li>应用场景</li>
    </ul>
  </li>
  <li><strong>10.5 跳表</strong>
    <ul>
      <li>跳表原理</li>
      <li>跳表操作</li>
    </ul>
  </li>
  <li><strong>10.6 布隆过滤器</strong>
    <ul>
      <li>布隆过滤器原理</li>
      <li>应用场景</li>
    </ul>
  </li>
</ul>

<h2 id="十一字符串算法">十一、字符串算法</h2>
<ul>
  <li><strong>11.1 字符串匹配</strong>
    <ul>
      <li>朴素算法</li>
      <li>KMP算法</li>
      <li>Rabin-Karp算法</li>
    </ul>
  </li>
  <li><strong>11.2 字符串处理</strong>
    <ul>
      <li>字符串反转</li>
      <li>字符串分割</li>
      <li>字符串替换</li>
    </ul>
  </li>
  <li><strong>11.3 正则表达式</strong>
    <ul>
      <li>正则语法</li>
      <li>正则引擎</li>
    </ul>
  </li>
  <li><strong>11.4 字典树</strong>
    <ul>
      <li>Trie树</li>
      <li>后缀树</li>
      <li>后缀数组</li>
    </ul>
  </li>
  <li><strong>11.5 字符串压缩</strong>
    <ul>
      <li>哈夫曼编码</li>
      <li>LZW算法</li>
    </ul>
  </li>
</ul>

<h2 id="十二数论算法">十二、数论算法</h2>
<ul>
  <li><strong>12.1 基本数论</strong>
    <ul>
      <li>质数判定</li>
      <li>最大公约数</li>
      <li>最小公倍数</li>
    </ul>
  </li>
  <li><strong>12.2 模运算</strong>
    <ul>
      <li>模运算性质</li>
      <li>模逆元</li>
      <li>中国剩余定理</li>
    </ul>
  </li>
  <li><strong>12.3 素数算法</strong>
    <ul>
      <li>埃拉托斯特尼筛法</li>
      <li>欧拉筛法</li>
      <li>米勒-拉宾素性测试</li>
    </ul>

    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 埃拉托斯特尼筛法
</span><span class="k">def</span> <span class="nf">sieve_of_eratosthenes</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="n">is_prime</span> <span class="o">=</span> <span class="p">[</span><span class="bp">True</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">is_prime</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="n">is_prime</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="bp">False</span>
        
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="nb">int</span><span class="p">(</span><span class="n">n</span><span class="o">**</span><span class="mf">0.5</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">is_prime</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
            <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">i</span><span class="o">*</span><span class="n">i</span><span class="p">,</span> <span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span>
                <span class="n">is_prime</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="bp">False</span>
        
    <span class="n">primes</span> <span class="o">=</span> <span class="p">[</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="k">if</span> <span class="n">is_prime</span><span class="p">[</span><span class="n">i</span><span class="p">]]</span>
    <span class="k">return</span> <span class="n">primes</span>
</code></pre></div>    </div>
  </li>
  <li><strong>12.4 快速幂</strong>
    <ul>
      <li>快速幂算法</li>
      <li>矩阵快速幂</li>
    </ul>
  </li>
  <li><strong>12.5 组合数学</strong>
    <ul>
      <li>排列组合</li>
      <li>二项式系数</li>
      <li>卡特兰数</li>
    </ul>
  </li>
</ul>

<h2 id="十三计算几何">十三、计算几何</h2>
<ul>
  <li><strong>13.1 基本几何对象</strong>
    <ul>
      <li>点</li>
      <li>向量</li>
      <li>直线</li>
      <li>多边形</li>
    </ul>
  </li>
  <li><strong>13.2 几何运算</strong>
    <ul>
      <li>点积</li>
      <li>叉积</li>
      <li>距离计算</li>
    </ul>
  </li>
  <li><strong>13.3 几何算法</strong>
    <ul>
      <li>凸包算法</li>
      <li>线段相交判断</li>
      <li>多边形包含判断</li>
    </ul>
  </li>
  <li><strong>13.4 扫描线算法</strong>
    <ul>
      <li>扫描线原理</li>
      <li>应用场景</li>
    </ul>
  </li>
</ul>

<h2 id="十四近似算法">十四、近似算法</h2>
<ul>
  <li><strong>14.1 近似算法基础</strong>
    <ul>
      <li>近似比</li>
      <li>近似方案</li>
    </ul>
  </li>
  <li><strong>14.2 经典近似问题</strong>
    <ul>
      <li>旅行商问题</li>
      <li>顶点覆盖</li>
      <li>集合覆盖</li>
    </ul>
  </li>
  <li><strong>14.3 随机化算法</strong>
    <ul>
      <li>随机化快速排序</li>
      <li>随机化选择算法</li>
    </ul>
  </li>
  <li><strong>14.4 启发式算法</strong>
    <ul>
      <li>遗传算法</li>
      <li>模拟退火</li>
      <li>蚁群算法</li>
    </ul>
  </li>
</ul>

<h2 id="十五算法设计范式">十五、算法设计范式</h2>
<ul>
  <li><strong>15.1 穷举法</strong>
    <ul>
      <li>朴素穷举</li>
      <li>分支限界</li>
    </ul>
  </li>
  <li><strong>15.2 递推法</strong>
    <ul>
      <li>递推关系</li>
      <li>递推求解</li>
    </ul>
  </li>
  <li><strong>15.3 迭代法</strong>
    <ul>
      <li>迭代改进</li>
      <li>不动点迭代</li>
    </ul>
  </li>
  <li><strong>15.4 随机化方法</strong>
    <ul>
      <li>蒙特卡洛方法</li>
      <li>拉斯维加斯方法</li>
    </ul>
  </li>
  <li><strong>15.5 并行算法</strong>
    <ul>
      <li>并行计算模型</li>
      <li>并行算法设计</li>
    </ul>
  </li>
</ul>

<h2 id="十六算法优化">十六、算法优化</h2>
<ul>
  <li><strong>16.1 时间优化</strong>
    <ul>
      <li>减少循环</li>
      <li>提前终止</li>
      <li>记忆化</li>
    </ul>
  </li>
  <li><strong>16.2 空间优化</strong>
    <ul>
      <li>原地操作</li>
      <li>滚动数组</li>
      <li>压缩存储</li>
    </ul>
  </li>
  <li><strong>16.3 代码优化</strong>
    <ul>
      <li>避免重复计算</li>
      <li>使用内置函数</li>
      <li>选择合适数据结构</li>
    </ul>
  </li>
  <li><strong>16.4 算法选择策略</strong>
    <ul>
      <li>问题特征分析</li>
      <li>算法适用性评估</li>
      <li>性能权衡</li>
    </ul>
  </li>
</ul>

<h2 id="十七算法竞赛">十七、算法竞赛</h2>
<ul>
  <li><strong>17.1 竞赛平台</strong>
    <ul>
      <li>LeetCode</li>
      <li>Codeforces</li>
      <li>AtCoder</li>
      <li>HackerRank</li>
    </ul>
  </li>
  <li><strong>17.2 竞赛技巧</strong>
    <ul>
      <li>问题分析</li>
      <li>解题策略</li>
      <li>调试技巧</li>
    </ul>
  </li>
  <li><strong>17.3 常用模板</strong>
    <ul>
      <li>输入输出模板</li>
      <li>常用算法模板</li>
      <li>数据结构模板</li>
    </ul>
  </li>
  <li><strong>17.4 比赛策略</strong>
    <ul>
      <li>时间管理</li>
      <li>题目选择</li>
      <li>团队协作</li>
    </ul>
  </li>
</ul>

<h2 id="十八学习资源">十八、学习资源</h2>
<ul>
  <li><strong>18.1 经典书籍</strong>
    <ul>
      <li>《算法导论》</li>
      <li>《算法》</li>
      <li>《编程珠玑》</li>
    </ul>
  </li>
  <li><strong>18.2 在线课程</strong>
    <ul>
      <li>中国大学MOOC</li>
      <li>Coursera</li>
      <li>极客时间</li>
    </ul>
  </li>
  <li><strong>18.3 刷题平台</strong>
    <ul>
      <li>LeetCode</li>
      <li>牛客网</li>
      <li>洛谷</li>
    </ul>
  </li>
  <li><strong>18.4 实践项目</strong>
    <ul>
      <li>实现经典算法</li>
      <li>参与开源项目</li>
      <li>算法可视化</li>
    </ul>
  </li>
  <li><strong>18.5 社区资源</strong>
    <ul>
      <li>算法论坛</li>
      <li>技术博客</li>
      <li>GitHub仓库</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="算法" /><category term="算法" /><summary type="html"><![CDATA[算法 系统学习大纲（以python示例）]]></summary></entry><entry><title type="html">进阶-python函数相关</title><link href="https://xdh2580.github.io/python/python%E5%87%BD%E6%95%B0/" rel="alternate" type="text/html" title="进阶-python函数相关" /><published>2026-04-05T00:00:00+00:00</published><updated>2026-04-05T00:00:00+00:00</updated><id>https://xdh2580.github.io/python/python%E5%87%BD%E6%95%B0</id><content type="html" xml:base="https://xdh2580.github.io/python/python%E5%87%BD%E6%95%B0/"><![CDATA[<h1 id="python-函数全面详解">Python 函数全面详解</h1>

<h2 id="一函数基础概念">一、函数基础概念</h2>

<h3 id="1-什么是函数">1. 什么是函数？</h3>
<p>函数是<strong>可重用的代码块</strong>，用于执行特定任务。它具有以下特点：</p>
<ul>
  <li>接收输入（参数）</li>
  <li>执行操作</li>
  <li>返回输出（返回值）</li>
  <li>提高代码的<strong>模块性</strong>和<strong>可重用性</strong></li>
</ul>

<h3 id="2-函数定义与调用">2. 函数定义与调用</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 定义函数
</span><span class="k">def</span> <span class="nf">greet</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
    <span class="s">"""打印问候语（文档字符串）"""</span>
    <span class="k">return</span> <span class="sa">f</span><span class="s">"Hello, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">!"</span>

<span class="c1"># 调用函数
</span><span class="n">result</span> <span class="o">=</span> <span class="n">greet</span><span class="p">(</span><span class="s">"Alice"</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>  <span class="c1"># Hello, Alice!
</span>
<span class="c1"># 无参数函数
</span><span class="k">def</span> <span class="nf">say_hello</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"Hello World!"</span><span class="p">)</span>

<span class="c1"># 无返回值函数（返回None）
</span><span class="k">def</span> <span class="nf">do_nothing</span><span class="p">():</span>
    <span class="k">pass</span>
</code></pre></div></div>

<h2 id="二函数参数详解">二、函数参数详解</h2>

<h3 id="1-参数类型对比">1. 参数类型对比</h3>

<table>
  <thead>
    <tr>
      <th>参数类型</th>
      <th>语法</th>
      <th>描述</th>
      <th>示例</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>位置参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(a, b)</code></td>
      <td>按位置传递</td>
      <td><code class="language-plaintext highlighter-rouge">func(1, 2)</code></td>
    </tr>
    <tr>
      <td>关键字参数</td>
      <td><code class="language-plaintext highlighter-rouge">func(a=1, b=2)</code></td>
      <td>按参数名传递</td>
      <td><code class="language-plaintext highlighter-rouge">func(b=2, a=1)</code></td>
    </tr>
    <tr>
      <td>默认参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(a, b=5)</code></td>
      <td>提供默认值</td>
      <td><code class="language-plaintext highlighter-rouge">func(1)</code> → <code class="language-plaintext highlighter-rouge">a=1, b=5</code></td>
    </tr>
    <tr>
      <td>可变位置参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(*args)</code></td>
      <td>接收任意数量位置参数</td>
      <td><code class="language-plaintext highlighter-rouge">func(1,2,3)</code> → <code class="language-plaintext highlighter-rouge">args=(1,2,3)</code></td>
    </tr>
    <tr>
      <td>可变关键字参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(**kwargs)</code></td>
      <td>接收任意数量关键字参数</td>
      <td><code class="language-plaintext highlighter-rouge">func(a=1,b=2)</code> → <code class="language-plaintext highlighter-rouge">kwargs={'a':1,'b':2}</code></td>
    </tr>
    <tr>
      <td>仅限关键字参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(*, a, b)</code> 或 <code class="language-plaintext highlighter-rouge">def func(*args, a, b)</code></td>
      <td>必须用关键字传递</td>
      <td><code class="language-plaintext highlighter-rouge">func(a=1, b=2)</code></td>
    </tr>
    <tr>
      <td>仅限位置参数</td>
      <td><code class="language-plaintext highlighter-rouge">def func(a, b, /)</code></td>
      <td>必须用位置传递</td>
      <td><code class="language-plaintext highlighter-rouge">func(1, 2)</code></td>
    </tr>
  </tbody>
</table>

<h3 id="2-完整参数语法">2. 完整参数语法</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">complex_func</span><span class="p">(</span><span class="n">pos1</span><span class="p">,</span> <span class="n">pos2</span><span class="p">,</span> <span class="o">/</span><span class="p">,</span> <span class="n">pos_or_kw</span><span class="p">,</span> <span class="o">*</span><span class="p">,</span> <span class="n">kw1</span><span class="p">,</span> <span class="n">kw2</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>
    <span class="s">"""
    参数说明：
    - pos1, pos2: 仅限位置参数
    - pos_or_kw: 位置或关键字参数
    - kw1, kw2: 仅限关键字参数（kw2有默认值）
    """</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"pos1=</span><span class="si">{</span><span class="n">pos1</span><span class="si">}</span><span class="s">, pos2=</span><span class="si">{</span><span class="n">pos2</span><span class="si">}</span><span class="s">, pos_or_kw=</span><span class="si">{</span><span class="n">pos_or_kw</span><span class="si">}</span><span class="s">, kw1=</span><span class="si">{</span><span class="n">kw1</span><span class="si">}</span><span class="s">, kw2=</span><span class="si">{</span><span class="n">kw2</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="c1"># 调用示例
</span><span class="n">complex_func</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">kw1</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span>  <span class="c1"># 正确
</span><span class="n">complex_func</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">pos_or_kw</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">kw1</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span>  <span class="c1"># 正确
# complex_func(1, 2, 3, 4)  # 错误：kw1必须用关键字
</span></code></pre></div></div>

<h3 id="3-可变参数示例">3. 可变参数示例</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># *args 接收任意数量的位置参数
</span><span class="k">def</span> <span class="nf">sum_all</span><span class="p">(</span><span class="o">*</span><span class="n">numbers</span><span class="p">):</span>
    <span class="s">"""计算所有数字的和"""</span>
    <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">sum_all</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>  <span class="c1"># 15
</span><span class="k">print</span><span class="p">(</span><span class="n">sum_all</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">))</span>         <span class="c1"># 30
</span>
<span class="c1"># **kwargs 接收任意数量的关键字参数
</span><span class="k">def</span> <span class="nf">print_info</span><span class="p">(</span><span class="o">**</span><span class="n">info</span><span class="p">):</span>
    <span class="s">"""打印所有关键字参数"""</span>
    <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">info</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s">: </span><span class="si">{</span><span class="n">value</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="n">print_info</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"Alice"</span><span class="p">,</span> <span class="n">age</span><span class="o">=</span><span class="mi">25</span><span class="p">,</span> <span class="n">city</span><span class="o">=</span><span class="s">"Beijing"</span><span class="p">)</span>

<span class="c1"># 混合使用
</span><span class="k">def</span> <span class="nf">mixed_func</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="n">option</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
    <span class="s">"""混合所有参数类型"""</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"a=</span><span class="si">{</span><span class="n">a</span><span class="si">}</span><span class="s">, b=</span><span class="si">{</span><span class="n">b</span><span class="si">}</span><span class="s">, args=</span><span class="si">{</span><span class="n">args</span><span class="si">}</span><span class="s">, option=</span><span class="si">{</span><span class="n">option</span><span class="si">}</span><span class="s">, kwargs=</span><span class="si">{</span><span class="n">kwargs</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
</code></pre></div></div>

<h2 id="三函数返回值">三、函数返回值</h2>

<h3 id="1-返回多个值">1. 返回多个值</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">get_stats</span><span class="p">(</span><span class="n">numbers</span><span class="p">):</span>
    <span class="s">"""返回统计信息：最小值、最大值、平均值"""</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">numbers</span><span class="p">:</span>
        <span class="k">return</span> <span class="bp">None</span>
    
    <span class="n">minimum</span> <span class="o">=</span> <span class="nb">min</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span>
    <span class="n">maximum</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span>
    <span class="n">average</span> <span class="o">=</span> <span class="nb">sum</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span> <span class="o">/</span> <span class="nb">len</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span>
    
    <span class="c1"># 返回元组（多个值）
</span>    <span class="k">return</span> <span class="n">minimum</span><span class="p">,</span> <span class="n">maximum</span><span class="p">,</span> <span class="n">average</span>

<span class="c1"># 接收多个返回值
</span><span class="n">min_val</span><span class="p">,</span> <span class="n">max_val</span><span class="p">,</span> <span class="n">avg_val</span> <span class="o">=</span> <span class="n">get_stats</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>

<span class="c1"># 返回字典
</span><span class="k">def</span> <span class="nf">get_person</span><span class="p">():</span>
    <span class="s">"""返回字典包含多个值"""</span>
    <span class="k">return</span> <span class="p">{</span>
        <span class="s">"name"</span><span class="p">:</span> <span class="s">"Alice"</span><span class="p">,</span>
        <span class="s">"age"</span><span class="p">:</span> <span class="mi">25</span><span class="p">,</span>
        <span class="s">"city"</span><span class="p">:</span> <span class="s">"Beijing"</span>
    <span class="p">}</span>
</code></pre></div></div>

<h3 id="2-返回函数">2. 返回函数</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 函数作为返回值
</span><span class="k">def</span> <span class="nf">make_multiplier</span><span class="p">(</span><span class="n">factor</span><span class="p">):</span>
    <span class="s">"""创建乘法函数"""</span>
    <span class="k">def</span> <span class="nf">multiplier</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="n">factor</span>
    <span class="k">return</span> <span class="n">multiplier</span>

<span class="c1"># 使用
</span><span class="n">double</span> <span class="o">=</span> <span class="n">make_multiplier</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="n">triple</span> <span class="o">=</span> <span class="n">make_multiplier</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">double</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>  <span class="c1"># 10
</span><span class="k">print</span><span class="p">(</span><span class="n">triple</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>  <span class="c1"># 15
</span></code></pre></div></div>

<h2 id="四变量作用域">四、变量作用域</h2>

<h3 id="1-作用域层次">1. 作用域层次</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 全局变量
</span><span class="n">global_var</span> <span class="o">=</span> <span class="s">"I'm global"</span>

<span class="k">def</span> <span class="nf">outer_function</span><span class="p">():</span>
    <span class="c1"># 闭包作用域变量
</span>    <span class="n">outer_var</span> <span class="o">=</span> <span class="s">"I'm in outer function"</span>
    
    <span class="k">def</span> <span class="nf">inner_function</span><span class="p">():</span>
        <span class="c1"># 局部变量
</span>        <span class="n">local_var</span> <span class="o">=</span> <span class="s">"I'm local"</span>
        
        <span class="c1"># 访问所有作用域
</span>        <span class="k">print</span><span class="p">(</span><span class="n">local_var</span><span class="p">)</span>      <span class="c1"># 局部
</span>        <span class="k">print</span><span class="p">(</span><span class="n">outer_var</span><span class="p">)</span>      <span class="c1"># 闭包
</span>        <span class="k">print</span><span class="p">(</span><span class="n">global_var</span><span class="p">)</span>     <span class="c1"># 全局
</span>        <span class="k">print</span><span class="p">(</span><span class="n">__name__</span><span class="p">)</span>       <span class="c1"># 内置
</span>    
    <span class="n">inner_function</span><span class="p">()</span>

<span class="c1"># 全局作用域
</span><span class="k">print</span><span class="p">(</span><span class="n">global_var</span><span class="p">)</span>
<span class="c1"># print(outer_var)  # 错误：不可访问
</span></code></pre></div></div>

<h3 id="2-global-和-nonlocal">2. global 和 nonlocal</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># global 关键字
</span><span class="n">counter</span> <span class="o">=</span> <span class="mi">0</span>

<span class="k">def</span> <span class="nf">increment</span><span class="p">():</span>
    <span class="k">global</span> <span class="n">counter</span>  <span class="c1"># 声明使用全局变量
</span>    <span class="n">counter</span> <span class="o">+=</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="n">counter</span>

<span class="c1"># nonlocal 关键字
</span><span class="k">def</span> <span class="nf">outer</span><span class="p">():</span>
    <span class="n">x</span> <span class="o">=</span> <span class="mi">10</span>
    
    <span class="k">def</span> <span class="nf">inner</span><span class="p">():</span>
        <span class="k">nonlocal</span> <span class="n">x</span>  <span class="c1"># 声明使用外层函数的变量
</span>        <span class="n">x</span> <span class="o">+=</span> <span class="mi">5</span>
        <span class="k">return</span> <span class="n">x</span>
    
    <span class="k">return</span> <span class="n">inner</span><span class="p">()</span>
</code></pre></div></div>

<h2 id="五函数作为对象">五、函数作为对象</h2>

<h3 id="1-函数是一等公民">1. 函数是一等公民</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 1. 函数可以赋值给变量
</span><span class="k">def</span> <span class="nf">say_hello</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
    <span class="k">return</span> <span class="sa">f</span><span class="s">"Hello, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">!"</span>

<span class="n">greeting</span> <span class="o">=</span> <span class="n">say_hello</span>  <span class="c1"># 函数赋值
</span><span class="k">print</span><span class="p">(</span><span class="n">greeting</span><span class="p">(</span><span class="s">"Bob"</span><span class="p">))</span>  <span class="c1"># 通过变量调用
</span>
<span class="c1"># 2. 函数可以作为参数传递
</span><span class="k">def</span> <span class="nf">apply_operation</span><span class="p">(</span><span class="n">func</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
    <span class="s">"""将函数应用于值"""</span>
    <span class="k">return</span> <span class="n">func</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">square</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span>

<span class="n">result</span> <span class="o">=</span> <span class="n">apply_operation</span><span class="p">(</span><span class="n">square</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>  <span class="c1"># 25
</span>
<span class="c1"># 3. 函数可以作为返回值
</span><span class="k">def</span> <span class="nf">get_operation</span><span class="p">(</span><span class="n">op_type</span><span class="p">):</span>
    <span class="s">"""根据操作类型返回函数"""</span>
    <span class="k">if</span> <span class="n">op_type</span> <span class="o">==</span> <span class="s">"add"</span><span class="p">:</span>
        <span class="k">return</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
    <span class="k">elif</span> <span class="n">op_type</span> <span class="o">==</span> <span class="s">"multiply"</span><span class="p">:</span>
        <span class="k">return</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="n">y</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">return</span> <span class="bp">None</span>
</code></pre></div></div>

<h3 id="2-函数属性">2. 函数属性</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">example_func</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>
    <span class="s">"""示例函数，用于演示属性"""</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>

<span class="c1"># 查看函数属性
</span><span class="k">print</span><span class="p">(</span><span class="n">example_func</span><span class="p">.</span><span class="n">__name__</span><span class="p">)</span>      <span class="c1"># 函数名: 'example_func'
</span><span class="k">print</span><span class="p">(</span><span class="n">example_func</span><span class="p">.</span><span class="n">__doc__</span><span class="p">)</span>       <span class="c1"># 文档字符串
</span><span class="k">print</span><span class="p">(</span><span class="n">example_func</span><span class="p">.</span><span class="n">__module__</span><span class="p">)</span>    <span class="c1"># 模块名
</span><span class="k">print</span><span class="p">(</span><span class="n">example_func</span><span class="p">.</span><span class="n">__defaults__</span><span class="p">)</span>  <span class="c1"># 默认参数值: (10,)
</span><span class="k">print</span><span class="p">(</span><span class="n">example_func</span><span class="p">.</span><span class="n">__code__</span><span class="p">)</span>      <span class="c1"># 字节码对象
</span>
<span class="c1"># 自定义函数属性
</span><span class="n">example_func</span><span class="p">.</span><span class="n">author</span> <span class="o">=</span> <span class="s">"Alice"</span>
<span class="n">example_func</span><span class="p">.</span><span class="n">version</span> <span class="o">=</span> <span class="s">"1.0"</span>
</code></pre></div></div>

<h2 id="六lambda表达式">六、Lambda表达式</h2>

<h3 id="1-lambda-基础">1. Lambda 基础</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Lambda 语法: lambda arguments: expression
</span><span class="n">square</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span>
<span class="n">add</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>

<span class="c1"># 立即调用
</span><span class="n">result</span> <span class="o">=</span> <span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)(</span><span class="mi">5</span><span class="p">)</span>  <span class="c1"># 6
</span>
<span class="c1"># 在列表推导式中使用
</span><span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="n">squares</span> <span class="o">=</span> <span class="p">[(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">)(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">numbers</span><span class="p">]</span>
</code></pre></div></div>

<h3 id="2-lambda-与高阶函数">2. Lambda 与高阶函数</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 与 map 一起使用
</span><span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="n">squared</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">,</span> <span class="n">numbers</span><span class="p">))</span>  <span class="c1"># [1, 4, 9, 16, 25]
</span>
<span class="c1"># 与 filter 一起使用
</span><span class="n">evens</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">filter</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">,</span> <span class="n">numbers</span><span class="p">))</span>  <span class="c1"># [2, 4]
</span>
<span class="c1"># 与 sorted 一起使用
</span><span class="n">pairs</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">5</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">8</span><span class="p">)]</span>
<span class="n">sorted_pairs</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">pairs</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>  <span class="c1"># 按第二个元素排序
</span></code></pre></div></div>

<h2 id="七装饰器">七、装饰器</h2>

<h3 id="1-装饰器基础">1. 装饰器基础</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 简单装饰器
</span><span class="k">def</span> <span class="nf">my_decorator</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
    <span class="s">"""装饰器：在函数调用前后添加打印"""</span>
    <span class="k">def</span> <span class="nf">wrapper</span><span class="p">():</span>
        <span class="k">print</span><span class="p">(</span><span class="s">"Before function call"</span><span class="p">)</span>
        <span class="n">func</span><span class="p">()</span>
        <span class="k">print</span><span class="p">(</span><span class="s">"After function call"</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">wrapper</span>

<span class="c1"># 使用装饰器
</span><span class="o">@</span><span class="n">my_decorator</span>
<span class="k">def</span> <span class="nf">say_hello</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"Hello!"</span><span class="p">)</span>

<span class="n">say_hello</span><span class="p">()</span>
<span class="c1"># 输出:
# Before function call
# Hello!
# After function call
</span></code></pre></div></div>

<h3 id="2-带参数的装饰器">2. 带参数的装饰器</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 带参数的装饰器
</span><span class="k">def</span> <span class="nf">repeat</span><span class="p">(</span><span class="n">num_times</span><span class="p">):</span>
    <span class="s">"""重复执行函数指定次数"""</span>
    <span class="k">def</span> <span class="nf">decorator</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
            <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">num_times</span><span class="p">):</span>
                <span class="n">result</span> <span class="o">=</span> <span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
            <span class="k">return</span> <span class="n">result</span>
        <span class="k">return</span> <span class="n">wrapper</span>
    <span class="k">return</span> <span class="n">decorator</span>

<span class="o">@</span><span class="n">repeat</span><span class="p">(</span><span class="n">num_times</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">greet</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Hello, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">!"</span><span class="p">)</span>

<span class="n">greet</span><span class="p">(</span><span class="s">"Alice"</span><span class="p">)</span>
<span class="c1"># 输出三次: Hello, Alice!
</span></code></pre></div></div>

<h3 id="3-类装饰器">3. 类装饰器</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 类装饰器
</span><span class="k">class</span> <span class="nc">Timer</span><span class="p">:</span>
    <span class="s">"""计时装饰器"""</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>
    
    <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
        <span class="kn">import</span> <span class="nn">time</span>
        <span class="n">start</span> <span class="o">=</span> <span class="n">time</span><span class="p">.</span><span class="n">time</span><span class="p">()</span>
        <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="n">end</span> <span class="o">=</span> <span class="n">time</span><span class="p">.</span><span class="n">time</span><span class="p">()</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="bp">self</span><span class="p">.</span><span class="n">func</span><span class="p">.</span><span class="n">__name__</span><span class="si">}</span><span class="s"> took </span><span class="si">{</span><span class="n">end</span><span class="o">-</span><span class="n">start</span><span class="si">:</span><span class="p">.</span><span class="mi">4</span><span class="n">f</span><span class="si">}</span><span class="s"> seconds"</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">result</span>

<span class="o">@</span><span class="n">Timer</span>
<span class="k">def</span> <span class="nf">slow_function</span><span class="p">():</span>
    <span class="kn">import</span> <span class="nn">time</span>
    <span class="n">time</span><span class="p">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
    <span class="k">return</span> <span class="s">"Done"</span>

<span class="n">slow_function</span><span class="p">()</span>  <span class="c1"># 输出执行时间
</span></code></pre></div></div>

<h2 id="八生成器和迭代器">八、生成器和迭代器</h2>

<h3 id="1-生成器函数">1. 生成器函数</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 使用 yield 创建生成器
</span><span class="k">def</span> <span class="nf">count_up_to</span><span class="p">(</span><span class="n">max_num</span><span class="p">):</span>
    <span class="s">"""生成从1到max_num的数字"""</span>
    <span class="n">count</span> <span class="o">=</span> <span class="mi">1</span>
    <span class="k">while</span> <span class="n">count</span> <span class="o">&lt;=</span> <span class="n">max_num</span><span class="p">:</span>
        <span class="k">yield</span> <span class="n">count</span>
        <span class="n">count</span> <span class="o">+=</span> <span class="mi">1</span>

<span class="c1"># 使用生成器
</span><span class="n">counter</span> <span class="o">=</span> <span class="n">count_up_to</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="n">counter</span><span class="p">:</span>
    <span class="k">print</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>  <span class="c1"># 1, 2, 3, 4, 5
</span>
<span class="c1"># 生成器表达式
</span><span class="n">squares</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>
<span class="k">for</span> <span class="n">square</span> <span class="ow">in</span> <span class="n">squares</span><span class="p">:</span>
    <span class="k">print</span><span class="p">(</span><span class="n">square</span><span class="p">)</span>  <span class="c1"># 0, 1, 4, 9, 16
</span></code></pre></div></div>

<h3 id="2-协程">2. 协程</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 使用 yield 接收值的生成器
</span><span class="k">def</span> <span class="nf">coroutine</span><span class="p">():</span>
    <span class="s">"""协程示例"""</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"Starting coroutine"</span><span class="p">)</span>
    <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
        <span class="n">value</span> <span class="o">=</span> <span class="k">yield</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Received: </span><span class="si">{</span><span class="n">value</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="c1"># 使用协程
</span><span class="n">co</span> <span class="o">=</span> <span class="n">coroutine</span><span class="p">()</span>
<span class="nb">next</span><span class="p">(</span><span class="n">co</span><span class="p">)</span>  <span class="c1"># 启动协程
</span><span class="n">co</span><span class="p">.</span><span class="n">send</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>  <span class="c1"># Received: 10
</span><span class="n">co</span><span class="p">.</span><span class="n">send</span><span class="p">(</span><span class="mi">20</span><span class="p">)</span>  <span class="c1"># Received: 20
</span></code></pre></div></div>

<h2 id="九递归函数">九、递归函数</h2>

<h3 id="1-递归基础">1. 递归基础</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 阶乘函数
</span><span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="s">"""计算阶乘（递归实现）"""</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="n">n</span> <span class="o">*</span> <span class="n">factorial</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">factorial</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>  <span class="c1"># 120
</span>
<span class="c1"># 斐波那契数列
</span><span class="k">def</span> <span class="nf">fibonacci</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="s">"""计算斐波那契数列（递归实现）"""</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">n</span>
    <span class="k">return</span> <span class="n">fibonacci</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">fibonacci</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">2</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">fibonacci</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>  <span class="c1"># 55
</span></code></pre></div></div>

<h3 id="2-尾递归优化">2. 尾递归优化</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 尾递归优化版本
</span><span class="k">def</span> <span class="nf">factorial_tail</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">accumulator</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
    <span class="s">"""尾递归阶乘函数"""</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">1</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">accumulator</span>
    <span class="k">return</span> <span class="n">factorial_tail</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">n</span> <span class="o">*</span> <span class="n">accumulator</span><span class="p">)</span>

<span class="c1"># 使用递归深度限制
</span><span class="kn">import</span> <span class="nn">sys</span>
<span class="n">sys</span><span class="p">.</span><span class="n">setrecursionlimit</span><span class="p">(</span><span class="mi">10000</span><span class="p">)</span>  <span class="c1"># 设置递归深度限制
</span></code></pre></div></div>

<h2 id="十函数注解">十、函数注解</h2>

<h3 id="1-类型注解">1. 类型注解</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 函数注解
</span><span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="n">x</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">int</span><span class="p">:</span>
    <span class="s">"""返回两个整数的和"""</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>

<span class="c1"># 带有复杂类型注解
</span><span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">List</span><span class="p">,</span> <span class="n">Dict</span><span class="p">,</span> <span class="n">Optional</span><span class="p">,</span> <span class="n">Union</span>

<span class="k">def</span> <span class="nf">process_data</span><span class="p">(</span>
    <span class="n">items</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span>
    <span class="n">config</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Union</span><span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="nb">str</span><span class="p">]]]</span> <span class="o">=</span> <span class="bp">None</span>
<span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">]]:</span>
    <span class="s">"""处理数据函数"""</span>
    <span class="k">if</span> <span class="n">config</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="n">config</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="k">return</span> <span class="p">{</span><span class="n">item</span><span class="p">:</span> <span class="p">[</span><span class="n">item</span><span class="p">]</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">items</span><span class="p">}</span>

<span class="c1"># 变量类型注解
</span><span class="n">name</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="s">"Alice"</span>
<span class="n">age</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="mi">25</span>
<span class="n">scores</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="nb">int</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="mi">85</span><span class="p">,</span> <span class="mi">90</span><span class="p">,</span> <span class="mi">78</span><span class="p">]</span>
</code></pre></div></div>

<h3 id="2-类型检查">2. 类型检查</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 使用 mypy 进行类型检查
# 在命令行运行: mypy your_script.py
</span>
<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">TypeVar</span><span class="p">,</span> <span class="n">Callable</span>

<span class="n">T</span> <span class="o">=</span> <span class="n">TypeVar</span><span class="p">(</span><span class="s">'T'</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">apply_to_all</span><span class="p">(</span><span class="n">func</span><span class="p">:</span> <span class="n">Callable</span><span class="p">[[</span><span class="n">T</span><span class="p">],</span> <span class="n">T</span><span class="p">],</span> <span class="n">items</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">T</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="n">T</span><span class="p">]:</span>
    <span class="s">"""将函数应用于列表所有元素"""</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">func</span><span class="p">(</span><span class="n">item</span><span class="p">)</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">items</span><span class="p">]</span>
</code></pre></div></div>

<h2 id="十一内置高阶函数">十一、内置高阶函数</h2>

<table>
  <thead>
    <tr>
      <th>函数</th>
      <th>描述</th>
      <th>示例</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">map(func, iterable)</code></td>
      <td>对可迭代对象的每个元素应用函数</td>
      <td><code class="language-plaintext highlighter-rouge">map(str.upper, ['a','b'])</code> → <code class="language-plaintext highlighter-rouge">['A','B']</code></td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">filter(func, iterable)</code></td>
      <td>筛选满足条件的元素</td>
      <td><code class="language-plaintext highlighter-rouge">filter(lambda x: x&gt;0, [-1,0,1])</code> → <code class="language-plaintext highlighter-rouge">[1]</code></td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">reduce(func, iterable)</code></td>
      <td>累积计算</td>
      <td><code class="language-plaintext highlighter-rouge">reduce(lambda x,y: x+y, [1,2,3])</code> → <code class="language-plaintext highlighter-rouge">6</code></td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">sorted(iterable, key=func)</code></td>
      <td>排序</td>
      <td><code class="language-plaintext highlighter-rouge">sorted(['abc','a','ab'], key=len)</code> → <code class="language-plaintext highlighter-rouge">['a','ab','abc']</code></td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">min(iterable, key=func)</code></td>
      <td>最小值</td>
      <td><code class="language-plaintext highlighter-rouge">min(['abc','a','ab'], key=len)</code> → <code class="language-plaintext highlighter-rouge">'a'</code></td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">max(iterable, key=func)</code></td>
      <td>最大值</td>
      <td><code class="language-plaintext highlighter-rouge">max(['abc','a','ab'], key=len)</code> → <code class="language-plaintext highlighter-rouge">'abc'</code></td>
    </tr>
  </tbody>
</table>

<h2 id="十二偏函数">十二、偏函数</h2>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">partial</span>

<span class="c1"># 创建偏函数
</span><span class="k">def</span> <span class="nf">power</span><span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="n">exponent</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">base</span> <span class="o">**</span> <span class="n">exponent</span>

<span class="c1"># 平方函数
</span><span class="n">square</span> <span class="o">=</span> <span class="n">partial</span><span class="p">(</span><span class="n">power</span><span class="p">,</span> <span class="n">exponent</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="n">cube</span> <span class="o">=</span> <span class="n">partial</span><span class="p">(</span><span class="n">power</span><span class="p">,</span> <span class="n">exponent</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">square</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>  <span class="c1"># 25
</span><span class="k">print</span><span class="p">(</span><span class="n">cube</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>    <span class="c1"># 27
</span>
<span class="c1"># 固定部分参数
</span><span class="k">def</span> <span class="nf">greet</span><span class="p">(</span><span class="n">greeting</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
    <span class="k">return</span> <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">greeting</span><span class="si">}</span><span class="s">, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">!"</span>

<span class="n">say_hello</span> <span class="o">=</span> <span class="n">partial</span><span class="p">(</span><span class="n">greet</span><span class="p">,</span> <span class="s">"Hello"</span><span class="p">)</span>
<span class="n">say_hi</span> <span class="o">=</span> <span class="n">partial</span><span class="p">(</span><span class="n">greet</span><span class="p">,</span> <span class="s">"Hi"</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="n">say_hello</span><span class="p">(</span><span class="s">"Alice"</span><span class="p">))</span>  <span class="c1"># Hello, Alice!
</span><span class="k">print</span><span class="p">(</span><span class="n">say_hi</span><span class="p">(</span><span class="s">"Bob"</span><span class="p">))</span>       <span class="c1"># Hi, Bob!
</span></code></pre></div></div>

<h2 id="十三函数式编程">十三、函数式编程</h2>

<h3 id="1-不可变性">1. 不可变性</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 使用不可变数据结构
</span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="nb">reduce</span>
<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">List</span>

<span class="c1"># 纯函数示例
</span><span class="k">def</span> <span class="nf">pure_multiply</span><span class="p">(</span><span class="n">numbers</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="nb">int</span><span class="p">],</span> <span class="n">factor</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="nb">int</span><span class="p">]:</span>
    <span class="s">"""纯函数：不修改输入，返回新列表"""</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">n</span> <span class="o">*</span> <span class="n">factor</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">numbers</span><span class="p">]</span>

<span class="c1"># 函数组合
</span><span class="k">def</span> <span class="nf">compose</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">g</span><span class="p">):</span>
    <span class="s">"""函数组合：(f ∘ g)(x) = f(g(x))"""</span>
    <span class="k">return</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">f</span><span class="p">(</span><span class="n">g</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>

<span class="c1"># 使用
</span><span class="n">add_one</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">square</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span>
<span class="n">add_one_then_square</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">square</span><span class="p">,</span> <span class="n">add_one</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">add_one_then_square</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>  <span class="c1"># 36
</span></code></pre></div></div>

<h2 id="十四异步函数">十四、异步函数</h2>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">asyncio</span>

<span class="c1"># 异步函数
</span><span class="k">async</span> <span class="k">def</span> <span class="nf">fetch_data</span><span class="p">():</span>
    <span class="s">"""模拟异步获取数据"""</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"开始获取数据..."</span><span class="p">)</span>
    <span class="k">await</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>  <span class="c1"># 模拟IO操作
</span>    <span class="k">print</span><span class="p">(</span><span class="s">"数据获取完成"</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">{</span><span class="s">"data"</span><span class="p">:</span> <span class="s">"some data"</span><span class="p">}</span>

<span class="k">async</span> <span class="k">def</span> <span class="nf">process_data</span><span class="p">():</span>
    <span class="s">"""异步处理数据"""</span>
    <span class="n">data</span> <span class="o">=</span> <span class="k">await</span> <span class="n">fetch_data</span><span class="p">()</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"处理数据: </span><span class="si">{</span><span class="n">data</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">data</span>

<span class="c1"># 运行异步函数
</span><span class="k">async</span> <span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
    <span class="n">result</span> <span class="o">=</span> <span class="k">await</span> <span class="n">process_data</span><span class="p">()</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"结果: </span><span class="si">{</span><span class="n">result</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="c1"># Python 3.7+
</span><span class="n">asyncio</span><span class="p">.</span><span class="n">run</span><span class="p">(</span><span class="n">main</span><span class="p">())</span>
</code></pre></div></div>

<h2 id="十五最佳实践">十五、最佳实践</h2>

<h3 id="1-设计原则">1. 设计原则</h3>
<ol>
  <li><strong>单一职责</strong>：每个函数只做一件事</li>
  <li><strong>短小精悍</strong>：函数应该简短（通常不超过20行）</li>
  <li><strong>明确命名</strong>：函数名应清晰表达其功能</li>
  <li><strong>减少副作用</strong>：尽量使用纯函数</li>
  <li><strong>合理抽象</strong>：适当抽象重复代码</li>
</ol>

<h3 id="2-性能优化">2. 性能优化</h3>
<ol>
  <li>避免不必要的递归</li>
  <li>使用生成器处理大数据流</li>
  <li>缓存重复计算结果</li>
  <li>使用局部变量加速访问</li>
  <li>考虑使用内置函数</li>
</ol>

<h3 id="3-可读性建议">3. 可读性建议</h3>
<ol>
  <li>编写清晰的文档字符串</li>
  <li>使用类型注解</li>
  <li>保持参数数量合理（一般不超过5个）</li>
  <li>避免深层嵌套</li>
  <li>适当使用装饰器</li>
</ol>

<h2 id="十六常见模式">十六、常见模式</h2>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 1. 单例模式
</span><span class="k">def</span> <span class="nf">singleton</span><span class="p">(</span><span class="n">cls</span><span class="p">):</span>
    <span class="s">"""单例装饰器"""</span>
    <span class="n">instances</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">cls</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">instances</span><span class="p">:</span>
            <span class="n">instances</span><span class="p">[</span><span class="n">cls</span><span class="p">]</span> <span class="o">=</span> <span class="n">cls</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">instances</span><span class="p">[</span><span class="n">cls</span><span class="p">]</span>
    <span class="k">return</span> <span class="n">wrapper</span>

<span class="c1"># 2. 策略模式
</span><span class="k">class</span> <span class="nc">Strategy</span><span class="p">:</span>
    <span class="s">"""策略模式示例"""</span>
    <span class="k">def</span> <span class="nf">execute</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
        <span class="k">pass</span>

<span class="k">class</span> <span class="nc">AddStrategy</span><span class="p">(</span><span class="n">Strategy</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">execute</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>

<span class="k">class</span> <span class="nc">MultiplyStrategy</span><span class="p">(</span><span class="n">Strategy</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">execute</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">a</span> <span class="o">*</span> <span class="n">b</span>

<span class="c1"># 3. 回调模式
</span><span class="k">def</span> <span class="nf">fetch_data</span><span class="p">(</span><span class="n">callback</span><span class="p">):</span>
    <span class="s">"""获取数据后调用回调函数"""</span>
    <span class="n">data</span> <span class="o">=</span> <span class="p">{</span><span class="s">"result"</span><span class="p">:</span> <span class="s">"success"</span><span class="p">}</span>
    <span class="n">callback</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">handle_data</span><span class="p">(</span><span class="n">data</span><span class="p">):</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"处理数据: </span><span class="si">{</span><span class="n">data</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="n">fetch_data</span><span class="p">(</span><span class="n">handle_data</span><span class="p">)</span>
</code></pre></div></div>]]></content><author><name>xdh2580</name></author><category term="python" /><category term="python" /><summary type="html"><![CDATA[Python 函数全面详解]]></summary></entry><entry><title type="html">计算机网络</title><link href="https://xdh2580.github.io/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/" rel="alternate" type="text/html" title="计算机网络" /><published>2026-04-02T00:00:00+00:00</published><updated>2026-04-02T00:00:00+00:00</updated><id>https://xdh2580.github.io/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C</id><content type="html" xml:base="https://xdh2580.github.io/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/"><![CDATA[<h1 id="计算机网络-系统学习大纲">计算机网络 系统学习大纲</h1>

<h2 id="一计算机网络概述">一、计算机网络概述</h2>
<ul>
  <li><strong>1.1 计算机网络的定义与功能</strong>
    <ul>
      <li>定义：将地理位置不同的、具有独立功能的多台计算机及其外部设备，通过通信线路连接起来</li>
      <li>功能：数据通信、资源共享、分布式处理、提高可靠性、负载均衡</li>
    </ul>
  </li>
  <li><strong>1.2 计算机网络的演进</strong>
    <ul>
      <li>批处理系统</li>
      <li>分时系统</li>
      <li>计算机-计算机通信</li>
      <li>计算机网络标准化</li>
    </ul>
  </li>
  <li><strong>1.3 网络分类</strong>
    <ul>
      <li>按覆盖范围：个人区域网、局域网、城域网、广域网、互联网</li>
      <li>按拓扑结构：总线型、星型、环型、树型、网状</li>
      <li>按传输技术：广播式网络、点对点网络</li>
    </ul>
  </li>
  <li><strong>1.4 网络标准化组织</strong>
    <ul>
      <li>ISO：国际标准化组织</li>
      <li>IEEE：电气和电子工程师协会</li>
      <li>IETF：互联网工程任务组</li>
      <li>ITU：国际电信联盟</li>
    </ul>
  </li>
  <li><strong>1.5 网络性能指标</strong>
    <ul>
      <li>带宽</li>
      <li>时延</li>
      <li>时延带宽积</li>
      <li>往返时间</li>
      <li>吞吐量</li>
      <li>利用率</li>
    </ul>
  </li>
</ul>

<h2 id="二网络体系结构与参考模型">二、网络体系结构与参考模型</h2>
<ul>
  <li><strong>2.1 协议与分层</strong>
    <ul>
      <li>协议三要素：语法、语义、时序</li>
      <li>分层的优点与缺点</li>
    </ul>
  </li>
  <li><strong>2.2 OSI参考模型</strong>
    <ul>
      <li>物理层</li>
      <li>数据链路层</li>
      <li>网络层</li>
      <li>传输层</li>
      <li>会话层</li>
      <li>表示层</li>
      <li>应用层</li>
    </ul>
  </li>
  <li><strong>2.3 TCP/IP参考模型</strong>
    <ul>
      <li>网络接口层</li>
      <li>网络层</li>
      <li>传输层</li>
      <li>应用层</li>
    </ul>
  </li>
  <li><strong>2.4 五层参考模型</strong>
    <ul>
      <li>物理层</li>
      <li>数据链路层</li>
      <li>网络层</li>
      <li>传输层</li>
      <li>应用层</li>
    </ul>
  </li>
  <li><strong>2.5 各层功能与协议对应关系</strong></li>
</ul>

<h2 id="三物理层">三、物理层</h2>
<ul>
  <li><strong>3.1 数据通信基础</strong>
    <ul>
      <li>数据通信系统模型</li>
      <li>模拟信号与数字信号</li>
      <li>信道容量</li>
    </ul>
  </li>
  <li><strong>3.2 传输介质</strong>
    <ul>
      <li>导向传输介质：双绞线、同轴电缆、光纤</li>
      <li>非导向传输介质：无线电波、微波、红外线</li>
    </ul>
  </li>
  <li><strong>3.3 信道复用技术</strong>
    <ul>
      <li>频分复用</li>
      <li>时分复用</li>
      <li>波分复用</li>
      <li>码分复用</li>
    </ul>
  </li>
  <li><strong>3.4 宽带接入技术</strong>
    <ul>
      <li>数字用户线</li>
      <li>光纤同轴混合网</li>
      <li>FTTx</li>
    </ul>
  </li>
  <li><strong>3.5 物理层设备</strong>
    <ul>
      <li>中继器</li>
      <li>集线器</li>
    </ul>
  </li>
</ul>

<h2 id="四数据链路层">四、数据链路层</h2>
<ul>
  <li><strong>4.1 数据链路层功能</strong>
    <ul>
      <li>封装成帧</li>
      <li>透明传输</li>
      <li>差错控制</li>
      <li>流量控制</li>
    </ul>
  </li>
  <li><strong>4.2 成帧方法</strong>
    <ul>
      <li>字符计数法</li>
      <li>字符填充法</li>
      <li>零比特填充法</li>
      <li>违规编码法</li>
    </ul>
  </li>
  <li><strong>4.3 差错控制</strong>
    <ul>
      <li>差错类型</li>
      <li>奇偶校验</li>
      <li>循环冗余校验</li>
      <li>校验和</li>
    </ul>
  </li>
  <li><strong>4.4 流量控制</strong>
    <ul>
      <li>停止-等待协议</li>
      <li>滑动窗口协议</li>
    </ul>
  </li>
  <li><strong>4.5 可靠传输机制</strong>
    <ul>
      <li>自动重传请求</li>
      <li>后退N帧协议</li>
      <li>选择重传协议</li>
    </ul>
  </li>
  <li><strong>4.6 介质访问控制</strong>
    <ul>
      <li>信道划分介质访问控制</li>
      <li>随机访问介质访问控制</li>
      <li>轮询访问介质访问控制</li>
    </ul>
  </li>
  <li><strong>4.7 局域网</strong>
    <ul>
      <li>局域网体系结构</li>
      <li>以太网</li>
      <li>令牌环网</li>
      <li>VLAN</li>
    </ul>
  </li>
  <li><strong>4.8 广域网</strong>
    <ul>
      <li>PPP协议</li>
      <li>HDLC协议</li>
    </ul>
  </li>
  <li><strong>4.9 数据链路层设备</strong>
    <ul>
      <li>网桥</li>
      <li>交换机</li>
      <li>生成树协议</li>
    </ul>
  </li>
</ul>

<h2 id="五网络层">五、网络层</h2>
<ul>
  <li><strong>5.1 网络层功能</strong>
    <ul>
      <li>路由选择</li>
      <li>分组转发</li>
      <li>异构网络互连</li>
    </ul>
  </li>
  <li><strong>5.2 IP协议</strong>
    <ul>
      <li>IPv4地址</li>
      <li>IPv4数据报格式</li>
      <li>IP地址分类</li>
      <li>子网划分</li>
      <li>无类别域间路由</li>
      <li>NAT</li>
    </ul>
  </li>
  <li><strong>5.3 ARP协议</strong>
    <ul>
      <li>ARP工作原理</li>
      <li>RARP</li>
    </ul>
  </li>
  <li><strong>5.4 ICMP协议</strong>
    <ul>
      <li>ICMP报文类型</li>
      <li>Ping命令</li>
      <li>Traceroute命令</li>
    </ul>
  </li>
  <li><strong>5.5 路由算法</strong>
    <ul>
      <li>静态路由</li>
      <li>动态路由</li>
      <li>距离向量路由算法</li>
      <li>链路状态路由算法</li>
    </ul>
  </li>
  <li><strong>5.6 路由协议</strong>
    <ul>
      <li>RIP</li>
      <li>OSPF</li>
      <li>BGP</li>
    </ul>
  </li>
  <li><strong>5.7 IP组播</strong>
    <ul>
      <li>组播地址</li>
      <li>IGMP</li>
      <li>组播路由协议</li>
    </ul>
  </li>
  <li><strong>5.8 移动IP</strong>
    <ul>
      <li>移动IP工作原理</li>
    </ul>
  </li>
  <li><strong>5.9 网络层设备</strong>
    <ul>
      <li>路由器</li>
    </ul>
  </li>
  <li><strong>5.10 IPv6</strong>
    <ul>
      <li>IPv6地址</li>
      <li>IPv6数据报格式</li>
      <li>IPv4到IPv6过渡</li>
    </ul>
  </li>
</ul>

<h2 id="六传输层">六、传输层</h2>
<ul>
  <li><strong>6.1 传输层功能</strong>
    <ul>
      <li>进程间通信</li>
      <li>复用与分用</li>
      <li>可靠传输</li>
    </ul>
  </li>
  <li><strong>6.2 端口与套接字</strong>
    <ul>
      <li>端口概念</li>
      <li>套接字概念</li>
    </ul>
  </li>
  <li><strong>6.3 无连接传输：UDP</strong>
    <ul>
      <li>UDP数据报格式</li>
      <li>UDP特点</li>
      <li>UDP应用</li>
    </ul>
  </li>
  <li><strong>6.4 面向连接传输：TCP</strong>
    <ul>
      <li>TCP数据报格式</li>
      <li>TCP连接管理</li>
      <li>TCP可靠传输</li>
      <li>TCP流量控制</li>
      <li>TCP拥塞控制</li>
    </ul>
  </li>
  <li><strong>6.5 TCP与UDP比较</strong>
    <ul>
      <li>应用场景</li>
      <li>性能差异</li>
    </ul>
  </li>
  <li><strong>6.6 传输层协议实现</strong></li>
</ul>

<h2 id="七应用层">七、应用层</h2>
<ul>
  <li><strong>7.1 应用层协议原理</strong>
    <ul>
      <li>网络应用模型</li>
      <li>客户-服务器模型</li>
      <li>P2P模型</li>
    </ul>
  </li>
  <li><strong>7.2 DNS</strong>
    <ul>
      <li>域名结构</li>
      <li>域名服务器</li>
      <li>域名解析过程</li>
    </ul>
  </li>
  <li><strong>7.3 HTTP</strong>
    <ul>
      <li>HTTP协议版本</li>
      <li>HTTP请求与响应</li>
      <li>Cookie</li>
      <li>持久连接</li>
    </ul>
  </li>
  <li><strong>7.4 电子邮件</strong>
    <ul>
      <li>SMTP</li>
      <li>POP3</li>
      <li>IMAP</li>
      <li>MIME</li>
    </ul>
  </li>
  <li><strong>7.5 文件传输</strong>
    <ul>
      <li>FTP</li>
      <li>TFTP</li>
    </ul>
  </li>
  <li><strong>7.6 远程登录</strong>
    <ul>
      <li>TELNET</li>
      <li>SSH</li>
    </ul>
  </li>
  <li><strong>7.7 动态主机配置</strong>
    <ul>
      <li>DHCP</li>
    </ul>
  </li>
  <li><strong>7.8 Web应用</strong>
    <ul>
      <li>Web缓存</li>
      <li>内容分发网络</li>
    </ul>
  </li>
  <li><strong>7.9 流媒体</strong>
    <ul>
      <li>流媒体传输协议</li>
      <li>实时传输协议</li>
    </ul>
  </li>
  <li><strong>7.10 P2P应用</strong></li>
</ul>

<h2 id="八网络安全">八、网络安全</h2>
<ul>
  <li><strong>8.1 网络安全概述</strong>
    <ul>
      <li>网络安全威胁</li>
      <li>网络安全服务</li>
    </ul>
  </li>
  <li><strong>8.2 密码学基础</strong>
    <ul>
      <li>对称密钥密码</li>
      <li>公钥密码</li>
      <li>数字签名</li>
      <li>消息认证</li>
    </ul>
  </li>
  <li><strong>8.3 身份认证</strong>
    <ul>
      <li>密码认证</li>
      <li>生物特征认证</li>
      <li>双因素认证</li>
    </ul>
  </li>
  <li><strong>8.4 网络安全协议</strong>
    <ul>
      <li>SSL/TLS</li>
      <li>IPSec</li>
      <li>VPN</li>
    </ul>
  </li>
  <li><strong>8.5 防火墙</strong>
    <ul>
      <li>防火墙类型</li>
      <li>防火墙配置</li>
    </ul>
  </li>
  <li><strong>8.6 入侵检测系统</strong>
    <ul>
      <li>入侵检测方法</li>
      <li>入侵防御系统</li>
    </ul>
  </li>
  <li><strong>8.7 无线网络安全</strong>
    <ul>
      <li>WEP</li>
      <li>WPA</li>
      <li>WPA2</li>
    </ul>
  </li>
  <li><strong>8.8 Web安全</strong>
    <ul>
      <li>XSS</li>
      <li>CSRF</li>
      <li>SQL注入</li>
    </ul>
  </li>
</ul>

<h2 id="九网络编程">九、网络编程</h2>
<ul>
  <li><strong>9.1 套接字编程基础</strong>
    <ul>
      <li>套接字类型</li>
      <li>套接字地址</li>
    </ul>
  </li>
  <li><strong>9.2 基于TCP的套接字编程</strong>
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># TCP服务器示例
</span><span class="kn">import</span> <span class="nn">socket</span>

<span class="k">def</span> <span class="nf">tcp_server</span><span class="p">():</span>
    <span class="n">server_socket</span> <span class="o">=</span> <span class="n">socket</span><span class="p">.</span><span class="n">socket</span><span class="p">(</span><span class="n">socket</span><span class="p">.</span><span class="n">AF_INET</span><span class="p">,</span> <span class="n">socket</span><span class="p">.</span><span class="n">SOCK_STREAM</span><span class="p">)</span>
    <span class="n">server_socket</span><span class="p">.</span><span class="n">bind</span><span class="p">((</span><span class="s">'localhost'</span><span class="p">,</span> <span class="mi">8888</span><span class="p">))</span>
    <span class="n">server_socket</span><span class="p">.</span><span class="n">listen</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
        
    <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
        <span class="n">client_socket</span><span class="p">,</span> <span class="n">addr</span> <span class="o">=</span> <span class="n">server_socket</span><span class="p">.</span><span class="n">accept</span><span class="p">()</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"连接来自: </span><span class="si">{</span><span class="n">addr</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
            
        <span class="n">data</span> <span class="o">=</span> <span class="n">client_socket</span><span class="p">.</span><span class="n">recv</span><span class="p">(</span><span class="mi">1024</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">data</span><span class="p">:</span>
            <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"收到数据: </span><span class="si">{</span><span class="n">data</span><span class="p">.</span><span class="n">decode</span><span class="p">()</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
            <span class="n">client_socket</span><span class="p">.</span><span class="n">send</span><span class="p">(</span><span class="sa">b</span><span class="s">"Hello from server"</span><span class="p">)</span>
            
        <span class="n">client_socket</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">"__main__"</span><span class="p">:</span>
    <span class="n">tcp_server</span><span class="p">()</span>
</code></pre></div>    </div>
  </li>
  <li><strong>9.3 基于UDP的套接字编程</strong>
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># UDP服务器示例
</span><span class="kn">import</span> <span class="nn">socket</span>

<span class="k">def</span> <span class="nf">udp_server</span><span class="p">():</span>
    <span class="n">server_socket</span> <span class="o">=</span> <span class="n">socket</span><span class="p">.</span><span class="n">socket</span><span class="p">(</span><span class="n">socket</span><span class="p">.</span><span class="n">AF_INET</span><span class="p">,</span> <span class="n">socket</span><span class="p">.</span><span class="n">SOCK_DGRAM</span><span class="p">)</span>
    <span class="n">server_socket</span><span class="p">.</span><span class="n">bind</span><span class="p">((</span><span class="s">'localhost'</span><span class="p">,</span> <span class="mi">8888</span><span class="p">))</span>
        
    <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
        <span class="n">data</span><span class="p">,</span> <span class="n">addr</span> <span class="o">=</span> <span class="n">server_socket</span><span class="p">.</span><span class="n">recvfrom</span><span class="p">(</span><span class="mi">1024</span><span class="p">)</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"收到来自 </span><span class="si">{</span><span class="n">addr</span><span class="si">}</span><span class="s"> 的数据: </span><span class="si">{</span><span class="n">data</span><span class="p">.</span><span class="n">decode</span><span class="p">()</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
        <span class="n">server_socket</span><span class="p">.</span><span class="n">sendto</span><span class="p">(</span><span class="sa">b</span><span class="s">"Hello from server"</span><span class="p">,</span> <span class="n">addr</span><span class="p">)</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">"__main__"</span><span class="p">:</span>
    <span class="n">udp_server</span><span class="p">()</span>
</code></pre></div>    </div>
  </li>
  <li><strong>9.4 多线程网络编程</strong></li>
  <li><strong>9.5 异步网络编程</strong></li>
  <li><strong>9.6 HTTP客户端编程</strong></li>
  <li><strong>9.7 HTTP服务器编程</strong></li>
</ul>

<h2 id="十网络管理">十、网络管理</h2>
<ul>
  <li><strong>10.1 网络管理概述</strong>
    <ul>
      <li>网络管理功能</li>
      <li>网络管理模型</li>
    </ul>
  </li>
  <li><strong>10.2 SNMP</strong>
    <ul>
      <li>SNMP体系结构</li>
      <li>管理信息结构</li>
      <li>管理信息库</li>
      <li>SNMP协议</li>
    </ul>
  </li>
  <li><strong>10.3 网络监控</strong>
    <ul>
      <li>网络性能监控</li>
      <li>网络流量分析</li>
    </ul>
  </li>
  <li><strong>10.4 网络故障排除</strong>
    <ul>
      <li>故障排除方法</li>
      <li>常用网络命令</li>
    </ul>
  </li>
  <li><strong>10.5 网络配置管理</strong></li>
</ul>

<h2 id="十一无线与移动网络">十一、无线与移动网络</h2>
<ul>
  <li><strong>11.1 无线网络概述</strong>
    <ul>
      <li>无线网络特点</li>
      <li>无线网络分类</li>
    </ul>
  </li>
  <li><strong>11.2 无线局域网</strong>
    <ul>
      <li>802.11标准</li>
      <li>Wi-Fi</li>
      <li>无线接入点</li>
    </ul>
  </li>
  <li><strong>11.3 无线个域网</strong>
    <ul>
      <li>蓝牙</li>
      <li>ZigBee</li>
    </ul>
  </li>
  <li><strong>11.4 无线城域网</strong>
    <ul>
      <li>802.16标准</li>
    </ul>
  </li>
  <li><strong>11.5 移动通信网络</strong>
    <ul>
      <li>蜂窝网络</li>
      <li>2G/3G/4G/5G</li>
    </ul>
  </li>
  <li><strong>11.6 移动IP</strong>
    <ul>
      <li>移动IP原理</li>
      <li>移动IP实现</li>
    </ul>
  </li>
  <li><strong>11.7 移动自组织网络</strong></li>
</ul>

<h2 id="十二下一代互联网">十二、下一代互联网</h2>
<ul>
  <li><strong>12.1 IPv6</strong>
    <ul>
      <li>IPv6地址格式</li>
      <li>IPv6数据报格式</li>
      <li>IPv6过渡技术</li>
    </ul>
  </li>
  <li><strong>12.2 软件定义网络</strong>
    <ul>
      <li>SDN架构</li>
      <li>OpenFlow</li>
    </ul>
  </li>
  <li><strong>12.3 网络功能虚拟化</strong>
    <ul>
      <li>NFV架构</li>
      <li>虚拟网络功能</li>
    </ul>
  </li>
  <li><strong>12.4 云计算网络</strong>
    <ul>
      <li>云计算网络架构</li>
      <li>虚拟网络</li>
    </ul>
  </li>
  <li><strong>12.5 物联网网络</strong>
    <ul>
      <li>物联网网络架构</li>
      <li>物联网协议</li>
    </ul>
  </li>
  <li><strong>12.6 5G网络</strong>
    <ul>
      <li>5G网络架构</li>
      <li>5G关键技术</li>
    </ul>
  </li>
</ul>

<h2 id="十三网络模拟与测试">十三、网络模拟与测试</h2>
<ul>
  <li><strong>13.1 网络模拟工具</strong>
    <ul>
      <li>NS-2/NS-3</li>
      <li>OMNeT++</li>
    </ul>
  </li>
  <li><strong>13.2 网络测试工具</strong>
    <ul>
      <li>网络测试仪</li>
      <li>流量生成器</li>
    </ul>
  </li>
  <li><strong>13.3 网络性能测试</strong>
    <ul>
      <li>吞吐量测试</li>
      <li>时延测试</li>
      <li>丢包率测试</li>
    </ul>
  </li>
  <li><strong>13.4 网络协议分析</strong>
    <ul>
      <li>协议分析工具</li>
      <li>数据包捕获</li>
    </ul>
  </li>
</ul>

<h2 id="十四实践项目">十四、实践项目</h2>
<ul>
  <li><strong>14.1 网络抓包分析</strong>
    <ul>
      <li>使用Wireshark</li>
      <li>协议分析</li>
    </ul>
  </li>
  <li><strong>14.2 网络扫描</strong>
    <ul>
      <li>端口扫描</li>
      <li>漏洞扫描</li>
    </ul>
  </li>
  <li><strong>14.3 网络配置</strong>
    <ul>
      <li>路由器配置</li>
      <li>交换机配置</li>
    </ul>
  </li>
  <li><strong>14.4 网络服务器搭建</strong>
    <ul>
      <li>Web服务器</li>
      <li>DNS服务器</li>
      <li>DHCP服务器</li>
    </ul>
  </li>
  <li><strong>14.5 网络应用开发</strong>
    <ul>
      <li>聊天程序</li>
      <li>文件传输程序</li>
      <li>Web爬虫</li>
    </ul>
  </li>
</ul>

<h2 id="十五学习资源">十五、学习资源</h2>
<ul>
  <li><strong>15.1 经典教材</strong>
    <ul>
      <li>《计算机网络：自顶向下方法》</li>
      <li>《TCP/IP详解》</li>
      <li>《计算机网络》</li>
    </ul>
  </li>
  <li><strong>15.2 在线课程</strong>
    <ul>
      <li>中国大学MOOC</li>
      <li>Coursera</li>
      <li>edX</li>
    </ul>
  </li>
  <li><strong>15.3 实验平台</strong>
    <ul>
      <li>Cisco Packet Tracer</li>
      <li>GNS3</li>
      <li>Mininet</li>
    </ul>
  </li>
  <li><strong>15.4 认证考试</strong>
    <ul>
      <li>CCNA</li>
      <li>CCNP</li>
      <li>网络工程师</li>
    </ul>
  </li>
  <li><strong>15.5 社区资源</strong>
    <ul>
      <li>Stack Overflow</li>
      <li>GitHub</li>
      <li>技术博客</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="计算机网络" /><category term="计算机网络" /><category term="TCP/IP" /><category term="HTTP" /><summary type="html"><![CDATA[计算机网络 系统学习大纲]]></summary></entry><entry><title type="html">PO模式（Page Object Model）</title><link href="https://xdh2580.github.io/pom/pytest/POModel/" rel="alternate" type="text/html" title="PO模式（Page Object Model）" /><published>2026-04-02T00:00:00+00:00</published><updated>2026-04-02T00:00:00+00:00</updated><id>https://xdh2580.github.io/pom/pytest/POModel</id><content type="html" xml:base="https://xdh2580.github.io/pom/pytest/POModel/"><![CDATA[<h1 id="po模式page-object-model">PO模式（Page Object Model）</h1>

<p><strong>PO模式，即页面对象模型，是UI自动化测试中一种主流的、用于增强代码可维护性、可读性和复用性的设计模式。</strong>​ 其核心思想是将<strong>测试逻辑</strong>与<strong>页面细节</strong>（如元素定位、页面结构）分离。</p>
<details>
  <summary>concept</summary>

  <p><img src="/assets/images/POMexample.png" alt="POMexample" /></p>

</details>

<h2 id="核心思想">核心思想</h2>
<ol>
  <li>页面抽象为对象：将每个被测试的Web页面或移动端页面（或页面的一个重要组件）抽象为一个独立的类（Class），这个类就是 PageObject。</li>
  <li>操作为方法：将对页面元素的所有操作（如点击、输入、获取文本）封装为这个类的方法。</li>
  <li>元素定位与业务逻辑分离：页面上所有的UI元素定位器（如XPath, CSS Selector, ID）都作为这个类的属性。测试用例脚本中不直接出现任何元素定位信息，只调用PageObject提供的方法。</li>
</ol>

<h2 id="标准分层结构">标准分层结构</h2>
<p>一个典型的PO模式项目结构通常包含以下三层：</p>

<ol>
  <li><strong>PageObject层</strong> (基础层)： 
 职责：封装单一页面的所有元素信息和基本操作。<br />
 内容：类的属性是元素定位器，类的方法是针对这些元素的基本操作（如 inputUsername, clickSubmit）。<br />
 示例：LoginPage, HomePage, ProductDetailPage。</li>
  <li><strong>PageModule / Business Flow层</strong> (业务流层，可选但推荐)：<br />
 职责：将多个PageObject的方法组合起来，形成可复用的、完整的业务操作流程。<br />
 内容：一个类的方法中会调用多个不同PageObject的方法。<br />
 示例：LoginFlow.login(username, password)内部会调用 LoginPage.inputUsername()和 LoginPage.clickSubmit()。OrderFlow.createOrder()可能会串联浏览商品、加入购物车、结算等多个页面的操作。</li>
  <li><strong>TestCase层</strong> (测试层)：<br />
 职责：编写具体的测试用例，包含测试数据、断言和测试步骤。<br />
 内容：测试用例脚本。这里只调用PageModule的业务方法或PageObject的页面方法，并进行结果断言。完全看不到任何元素定位信息。<br />
 示例：test_login_success, test_add_item_to_cart。</li>
</ol>

<h2 id="代码示例以web登录为例">代码示例（以Web登录为例）</h2>
<ol>
  <li>PageObject - LoginPage.py
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kn">from</span> <span class="nn">selenium.webdriver.common.by</span> <span class="kn">import</span> <span class="n">By</span>
 <span class="kn">from</span> <span class="nn">selenium.webdriver.support.ui</span> <span class="kn">import</span> <span class="n">WebDriverWait</span>
 <span class="kn">from</span> <span class="nn">selenium.webdriver.support</span> <span class="kn">import</span> <span class="n">expected_conditions</span> <span class="k">as</span> <span class="n">EC</span>

 <span class="k">class</span> <span class="nc">LoginPage</span><span class="p">:</span>
     <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">driver</span><span class="p">):</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">driver</span> <span class="o">=</span> <span class="n">driver</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">wait</span> <span class="o">=</span> <span class="n">WebDriverWait</span><span class="p">(</span><span class="n">driver</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
         <span class="c1"># 元素定位器（页面细节集中在此）
</span>         <span class="bp">self</span><span class="p">.</span><span class="n">username_input</span> <span class="o">=</span> <span class="p">(</span><span class="n">By</span><span class="p">.</span><span class="n">ID</span><span class="p">,</span> <span class="s">"username"</span><span class="p">)</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">password_input</span> <span class="o">=</span> <span class="p">(</span><span class="n">By</span><span class="p">.</span><span class="n">ID</span><span class="p">,</span> <span class="s">"password"</span><span class="p">)</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">submit_button</span> <span class="o">=</span> <span class="p">(</span><span class="n">By</span><span class="p">.</span><span class="n">XPATH</span><span class="p">,</span> <span class="s">"//button[@type='submit']"</span><span class="p">)</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">error_message</span> <span class="o">=</span> <span class="p">(</span><span class="n">By</span><span class="p">.</span><span class="n">CLASS_NAME</span><span class="p">,</span> <span class="s">"alert-error"</span><span class="p">)</span>

     <span class="k">def</span> <span class="nf">enter_username</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">username</span><span class="p">):</span>
         <span class="c1"># 封装操作细节
</span>         <span class="n">element</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">wait</span><span class="p">.</span><span class="n">until</span><span class="p">(</span><span class="n">EC</span><span class="p">.</span><span class="n">presence_of_element_located</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">username_input</span><span class="p">))</span>
         <span class="n">element</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>
         <span class="n">element</span><span class="p">.</span><span class="n">send_keys</span><span class="p">(</span><span class="n">username</span><span class="p">)</span>
         <span class="k">return</span> <span class="bp">self</span>  <span class="c1"># 支持链式调用
</span>
     <span class="k">def</span> <span class="nf">enter_password</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">password</span><span class="p">):</span>
         <span class="n">element</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">wait</span><span class="p">.</span><span class="n">until</span><span class="p">(</span><span class="n">EC</span><span class="p">.</span><span class="n">presence_of_element_located</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">password_input</span><span class="p">))</span>
         <span class="n">element</span><span class="p">.</span><span class="n">send_keys</span><span class="p">(</span><span class="n">password</span><span class="p">)</span>
         <span class="k">return</span> <span class="bp">self</span>

     <span class="k">def</span> <span class="nf">click_submit</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
         <span class="bp">self</span><span class="p">.</span><span class="n">wait</span><span class="p">.</span><span class="n">until</span><span class="p">(</span><span class="n">EC</span><span class="p">.</span><span class="n">element_to_be_clickable</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">submit_button</span><span class="p">)).</span><span class="n">click</span><span class="p">()</span>
         <span class="c1"># 通常返回下一个页面的PO对象，例如 return HomePage(self.driver)
</span>
     <span class="k">def</span> <span class="nf">get_error_text</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
         <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">wait</span><span class="p">.</span><span class="n">until</span><span class="p">(</span><span class="n">EC</span><span class="p">.</span><span class="n">visibility_of_element_located</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">error_message</span><span class="p">)).</span><span class="n">text</span>
</code></pre></div>    </div>
  </li>
  <li>PageModule - LoginFlow.py
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="k">class</span> <span class="nc">LoginFlow</span><span class="p">:</span>
     <span class="o">@</span><span class="nb">staticmethod</span>
     <span class="k">def</span> <span class="nf">login_with_credentials</span><span class="p">(</span><span class="n">driver</span><span class="p">,</span> <span class="n">username</span><span class="p">,</span> <span class="n">password</span><span class="p">):</span>
         <span class="n">login_page</span> <span class="o">=</span> <span class="n">LoginPage</span><span class="p">(</span><span class="n">driver</span><span class="p">)</span>
         <span class="c1"># 组合基本操作形成业务流
</span>         <span class="n">login_page</span><span class="p">.</span><span class="n">enter_username</span><span class="p">(</span><span class="n">username</span><span class="p">).</span><span class="n">enter_password</span><span class="p">(</span><span class="n">password</span><span class="p">).</span><span class="n">click_submit</span><span class="p">()</span>
         <span class="c1"># 返回登录后的页面对象，如首页
</span>         <span class="kn">from</span> <span class="nn">pages.home_page</span> <span class="kn">import</span> <span class="n">HomePage</span>
         <span class="k">return</span> <span class="n">HomePage</span><span class="p">(</span><span class="n">driver</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
  <li>TestCase - test_login.py
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kn">import</span> <span class="nn">pytest</span>
 <span class="kn">from</span> <span class="nn">flows.login_flow</span> <span class="kn">import</span> <span class="n">LoginFlow</span>
 <span class="kn">from</span> <span class="nn">pages.home_page</span> <span class="kn">import</span> <span class="n">HomePage</span>

 <span class="k">class</span> <span class="nc">TestLogin</span><span class="p">:</span>
     <span class="k">def</span> <span class="nf">test_login_success</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">browser</span><span class="p">):</span> <span class="c1"># browser是pytest fixture，提供driver
</span>         <span class="c1"># 测试脚本清晰，只有业务调用和断言
</span>         <span class="n">home_page</span> <span class="o">=</span> <span class="n">LoginFlow</span><span class="p">.</span><span class="n">login_with_credentials</span><span class="p">(</span><span class="n">browser</span><span class="p">,</span> <span class="s">"validUser"</span><span class="p">,</span> <span class="s">"validPass"</span><span class="p">)</span>
         <span class="k">assert</span> <span class="n">home_page</span><span class="p">.</span><span class="n">is_user_logged_in</span><span class="p">(</span><span class="s">"validUser"</span><span class="p">)</span> <span class="o">==</span> <span class="bp">True</span>

     <span class="k">def</span> <span class="nf">test_login_failure</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">browser</span><span class="p">):</span>
         <span class="n">login_page</span> <span class="o">=</span> <span class="n">LoginPage</span><span class="p">(</span><span class="n">browser</span><span class="p">)</span>
         <span class="n">login_page</span><span class="p">.</span><span class="n">enter_username</span><span class="p">(</span><span class="s">"invalidUser"</span><span class="p">).</span><span class="n">enter_password</span><span class="p">(</span><span class="s">"wrongPass"</span><span class="p">).</span><span class="n">click_submit</span><span class="p">()</span>
         <span class="n">error_text</span> <span class="o">=</span> <span class="n">login_page</span><span class="p">.</span><span class="n">get_error_text</span><span class="p">()</span>
         <span class="k">assert</span> <span class="s">"Invalid credentials"</span> <span class="ow">in</span> <span class="n">error_text</span>
</code></pre></div>    </div>
  </li>
</ol>

<h2 id="po模式的设计原则六大原则">PO模式的设计原则（六大原则）</h2>
<ol>
  <li>单一职责原则：一个PageObject只代表一个页面（或一个功能完整的组件）的逻辑。</li>
  <li>方法代表服务：PageObject的方法应体现用户在页面上的“目标”或“服务”，而不是实现细节（如“点击某个按钮”是细节，“提交登录”是目标）。</li>
  <li>避免在PO内断言：断言是测试逻辑，应放在TestCase层。PO方法可以返回结果（如是否成功、获取文本）供TestCase断言。</li>
  <li>返回其他PO：一个页面的操作导致页面跳转时，该方法应返回下一个页面的PageObject实例。这使测试用例的链式调用非常流畅。</li>
  <li>不需要封装所有元素：只为测试涉及的元素创建定位器和方法。</li>
  <li>相同动作，不同结果：同一个操作可能导致不同结果（如登录成功/失败），应在PO中通过不同方法或返回值来处理。</li>
</ol>

<h2 id="po模式的优势">PO模式的优势</h2>
<ul>
  <li>高可维护性：当页面UI发生变更时，通常只需修改对应的PageObject中的元素定位器，所有用到该元素的测试用例会自动生效，无需四处修改。</li>
  <li>高可读性：测试用例由一系列业务方法组成（如 login(), addToCart(), checkout()），读起来像用户故事，易于理解和评审。</li>
  <li>高复用性：封装的页面方法和业务流可以在多个测试用例中被重复使用，减少代码冗余。</li>
  <li>低耦合：测试逻辑与UI细节、驱动（Selenium, Appium）解耦。更换测试框架或驱动时，影响范围小。</li>
</ul>

<h2 id="总结">总结</h2>
<p>PO模式通过抽象、封装和分层，将脆弱易变的UI元素定位与稳定的业务测试逻辑分离，是应对UI自动化“脆弱性”和“维护成本高”挑战的最有效实践，已成为现代UI自动化测试框架的事实标准。在实现时，通常结合PageFactory（用于懒加载元素）等工具，并遵循上述设计原则，以构建健壮、可持续的自动化测试工程。</p>]]></content><author><name>xdh2580</name></author><category term="POM" /><category term="pytest" /><category term="POM" /><category term="pytest" /><summary type="html"><![CDATA[PO模式（Page Object Model）]]></summary></entry><entry><title type="html">进阶-pytest配置文件</title><link href="https://xdh2580.github.io/pytest/pytest-config-file/" rel="alternate" type="text/html" title="进阶-pytest配置文件" /><published>2026-04-02T00:00:00+00:00</published><updated>2026-04-02T00:00:00+00:00</updated><id>https://xdh2580.github.io/pytest/pytest-config-file</id><content type="html" xml:base="https://xdh2580.github.io/pytest/pytest-config-file/"><![CDATA[<h1 id="pytest配置文件全面解析">pytest配置文件全面解析</h1>

<p><strong>pytest 配置文件是 pytest 测试框架的核心配置机制，它让您能精细控制测试行为。如下是从基础到高级的全面解析。</strong></p>

<h2 id="一配置文件类型和优先级">一、配置文件类型和优先级</h2>
<p>pytest 支持多种配置文件格式，按查找顺序和优先级如下：</p>
<ul>
  <li>
    <p><strong>1.1 配置文件查找顺序</strong></p>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  1. pytest.ini
  2. pyproject.toml
  3. tox.ini
  4. setup.cfg
</code></pre></div>    </div>
    <p>查找路径：从当前目录向上查找，直到找到第一个配置文件。</p>
  </li>
  <li>
    <p><strong>1.2 推荐使用优先级</strong></p>

    <div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># 现代项目（推荐）</span>
  pyproject.toml ✅

  <span class="c"># 传统项目</span>
  pytest.ini ✅

  <span class="c"># 兼容性项目</span>
  tox.ini ⚠️

  <span class="c"># 已弃用</span>
  setup.cfg ❌
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="二配置文件详解">二、配置文件详解</h2>
<ul>
  <li>
    <p><strong>2.1 pytest.ini（最传统）</strong></p>

    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[pytest]</span>
  <span class="c"># 1. 测试发现配置
</span>  <span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests integration_tests</span>
  <span class="py">python_files</span> <span class="p">=</span> <span class="s">test_*.py *_test.py check_*.py</span>
  <span class="py">python_classes</span> <span class="p">=</span> <span class="s">Test* Check*</span>
  <span class="py">python_functions</span> <span class="p">=</span> <span class="s">test_* check_*</span>

  <span class="c"># 2. 命令行选项
</span>  <span class="py">addopts</span> <span class="p">=</span> 
      <span class="s">-v                     # 详细输出</span>
      <span class="py">--tb</span><span class="p">=</span><span class="s">short             # 简短错误回溯</span>
      <span class="err">--strict-markers</span>       <span class="c"># 严格标记
</span>      <span class="err">--disable-warnings</span>     <span class="c"># 禁用警告
</span>      <span class="py">--maxfail</span><span class="p">=</span><span class="s">2            # 失败2个测试后停止</span>
      <span class="err">-x</span>                     <span class="c"># 第一个失败后停止
</span>      <span class="err">--cov</span>                  <span class="c"># 覆盖率报告
</span>      <span class="py">--cov-report</span><span class="p">=</span><span class="s">html      # HTML覆盖率报告</span>
      <span class="err">-p</span> <span class="err">no:warnings</span>         <span class="c"># 插件配置
</span>
  <span class="c"># 3. 标记（markers）注册
</span>  <span class="py">markers</span> <span class="p">=</span>
      <span class="err">slow:</span> <span class="err">标记为慢速测试</span>
      <span class="err">fast:</span> <span class="err">快速测试</span>
      <span class="err">smoke:</span> <span class="err">冒烟测试</span>
      <span class="err">integration:</span> <span class="err">集成测试</span>
      <span class="err">unit:</span> <span class="err">单元测试</span>
      <span class="err">serial:</span> <span class="err">必须串行执行</span>
      <span class="err">windows:</span> <span class="err">仅Windows平台</span>
      <span class="err">linux:</span> <span class="err">仅Linux平台</span>
      <span class="err">database:</span> <span class="err">需要数据库</span>
      <span class="err">api:</span> <span class="err">API测试</span>
      <span class="err">param(id1,</span> <span class="err">id2):</span> <span class="err">带参数的标记</span>

  <span class="c"># 4. 过滤器配置
</span>  <span class="py">filterwarnings</span> <span class="p">=</span>
      <span class="err">error</span>                     <span class="c"># 将警告转为错误
</span>      <span class="err">ignore::UserWarning</span>       <span class="c"># 忽略特定警告
</span>      <span class="err">ignore:.*U.*mode.*:DeprecationWarning</span>
      <span class="err">always::ResourceWarning</span>

  <span class="c"># 5. 日志配置
</span>  <span class="py">log_cli</span> <span class="p">=</span> <span class="s">true</span>
  <span class="py">log_cli_level</span> <span class="p">=</span> <span class="s">INFO</span>
  <span class="py">log_cli_format</span> <span class="p">=</span> <span class="s">%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)</span>
  <span class="py">log_cli_date_format</span> <span class="p">=</span> <span class="s">%Y-%m-%d %H:%M:%S</span>
  <span class="py">log_file</span> <span class="p">=</span> <span class="s">logs/pytest.log</span>
  <span class="py">log_file_level</span> <span class="p">=</span> <span class="s">DEBUG</span>
  <span class="py">log_file_format</span> <span class="p">=</span> <span class="s">%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)</span>
  <span class="py">log_file_date_format</span> <span class="p">=</span> <span class="s">%Y-%m-%d %H:%M:%S</span>

  <span class="c"># 6. 测试结果输出
</span>  <span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">Pytest Test Suite</span>
  <span class="py">junit_logging</span> <span class="p">=</span> <span class="s">all</span>
  <span class="py">junit_duration_report</span> <span class="p">=</span> <span class="s">call</span>
  <span class="py">junit_family</span> <span class="p">=</span> <span class="s">xunit2</span>

  <span class="c"># 7. 插件配置
</span>  <span class="py">required_plugins</span> <span class="p">=</span> <span class="s">pytest-cov pytest-html pytest-xdist</span>
  <span class="py">asyncio_mode</span> <span class="p">=</span> <span class="s">auto</span>

  <span class="c"># 8. 缓存配置
</span>  <span class="py">cache_dir</span> <span class="p">=</span> <span class="s">.pytest_cache</span>

  <span class="c"># 9. 自定义配置
</span>  <span class="py">my_custom_setting</span> <span class="p">=</span> <span class="s">value</span>
  <span class="py">timeout</span> <span class="p">=</span> <span class="s">30.0</span>
</code></pre></div>    </div>
  </li>
  <li>
    <p><strong>2.2 pyproject.toml（现代标准）</strong></p>

    <div class="language-toml highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># pyproject.toml</span>
  <span class="nn">[tool.pytest.ini_options]</span>
  <span class="c"># 1. 测试发现</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="p">[</span><span class="s">"tests"</span><span class="p">,</span> <span class="s">"integration_tests"</span><span class="p">]</span>
  <span class="py">python_files</span> <span class="p">=</span> <span class="p">[</span><span class="s">"test_*.py"</span><span class="p">,</span> <span class="s">"*_test.py"</span><span class="p">,</span> <span class="s">"check_*.py"</span><span class="p">]</span>
  <span class="py">python_classes</span> <span class="p">=</span> <span class="p">[</span><span class="s">"Test*"</span><span class="p">,</span> <span class="s">"Check*"</span><span class="p">]</span>
  <span class="py">python_functions</span> <span class="p">=</span> <span class="p">[</span><span class="s">"test_*"</span><span class="p">,</span> <span class="s">"check_*"</span><span class="p">]</span>

  <span class="c"># 2. 命令行选项</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"-v"</span><span class="p">,</span>
      <span class="py">"--tb</span><span class="p">=</span><span class="err">short</span><span class="s">",</span><span class="err">
</span>      <span class="s">"--strict-markers"</span><span class="p">,</span>
      <span class="s">"--disable-warnings"</span><span class="p">,</span>
      <span class="py">"--maxfail</span><span class="p">=</span><span class="mi">2</span><span class="s">",</span><span class="err">
</span>      <span class="s">"-x"</span><span class="p">,</span>
      <span class="s">"--cov"</span><span class="p">,</span>
      <span class="py">"--cov-report</span><span class="p">=</span><span class="err">html</span><span class="s">",</span><span class="err">
</span>      <span class="s">"-p"</span><span class="p">,</span> <span class="s">"no:warnings"</span>
  <span class="p">]</span>

  <span class="c"># 3. 标记注册</span>
  <span class="py">markers</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"slow: marks tests as slow (deselect with '-m </span><span class="se">\"</span><span class="s">not slow</span><span class="se">\"</span><span class="s">')"</span><span class="p">,</span>
      <span class="s">"fast: marks tests as fast"</span><span class="p">,</span>
      <span class="s">"smoke: smoke tests"</span><span class="p">,</span>
      <span class="s">"integration: integration tests"</span><span class="p">,</span>
      <span class="s">"unit: unit tests"</span><span class="p">,</span>
      <span class="s">"serial: tests that must be run serially"</span><span class="p">,</span>
      <span class="s">"windows: windows only tests"</span><span class="p">,</span>
      <span class="s">"linux: linux only tests"</span><span class="p">,</span>
      <span class="s">"database: tests that require database access"</span><span class="p">,</span>
      <span class="s">"api: API tests"</span>
  <span class="p">]</span>

  <span class="c"># 4. 过滤器</span>
  <span class="py">filterwarnings</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"error"</span><span class="p">,</span>
      <span class="s">"ignore::UserWarning"</span><span class="p">,</span>
      <span class="s">"ignore:.*U.*mode.*:DeprecationWarning"</span><span class="p">,</span>
      <span class="s">"always::ResourceWarning"</span>
  <span class="p">]</span>

  <span class="c"># 5. 日志配置</span>
  <span class="py">log_cli</span> <span class="p">=</span> <span class="kc">true</span>
  <span class="py">log_cli_level</span> <span class="p">=</span> <span class="s">"INFO"</span>
  <span class="py">log_cli_format</span> <span class="p">=</span> <span class="s">"%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"</span>
  <span class="py">log_cli_date_format</span> <span class="p">=</span> <span class="s">"%Y-%m-%d %H:%M:%S"</span>
  <span class="py">log_file</span> <span class="p">=</span> <span class="s">"logs/pytest.log"</span>
  <span class="py">log_file_level</span> <span class="p">=</span> <span class="s">"DEBUG"</span>

  <span class="c"># 6. JUnit报告</span>
  <span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">"Pytest Test Suite"</span>
  <span class="py">junit_logging</span> <span class="p">=</span> <span class="s">"all"</span>
  <span class="py">junit_duration_report</span> <span class="p">=</span> <span class="s">"call"</span>
  <span class="py">junit_family</span> <span class="p">=</span> <span class="s">"xunit2"</span>

  <span class="c"># 7. 插件配置</span>
  <span class="py">asyncio_mode</span> <span class="p">=</span> <span class="s">"auto"</span>
  <span class="py">timeout</span> <span class="p">=</span> <span class="mf">30.0</span>

  <span class="c"># 8. 自定义配置</span>
  <span class="py">my_custom_setting</span> <span class="p">=</span> <span class="s">"value"</span>

  <span class="c"># 9. 覆盖率配置（pytest-cov）</span>
  <span class="nn">[tool.coverage.run]</span>
  <span class="py">source</span> <span class="p">=</span> <span class="nn">["src"]</span>
  <span class="py">omit</span> <span class="p">=</span> <span class="p">[</span><span class="s">"*/tests/*"</span><span class="p">,</span> <span class="s">"*/migrations/*"</span><span class="p">]</span>

  <span class="nn">[tool.coverage.report]</span>
  <span class="py">exclude_lines</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"pragma: no cover"</span><span class="p">,</span>
      <span class="s">"def __repr__"</span><span class="p">,</span>
      <span class="s">"if self.debug:"</span><span class="p">,</span>
      <span class="s">"if 0:"</span><span class="p">,</span>
      <span class="s">"if __name__ == .__main__.:"</span>
  <span class="p">]</span>

  <span class="nn">[tool.coverage.html]</span>
  <span class="py">directory</span> <span class="p">=</span> <span class="s">"htmlcov"</span>
  <span class="py">title</span> <span class="p">=</span> <span class="s">"Test Coverage Report"</span>

  <span class="c"># 10. 插件特定配置</span>
  <span class="nn">[tool.pytest-xdist]</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="s">"-n auto"</span>  <span class="c"># 自动检测CPU核心数</span>
</code></pre></div>    </div>
  </li>
  <li>
    <p><strong>2.3 tox.ini（兼容tox）</strong></p>

    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[tox]</span>
  <span class="py">envlist</span> <span class="p">=</span> <span class="s">py38, py39, py310</span>
  <span class="py">skipsdist</span> <span class="p">=</span> <span class="s">true</span>

  <span class="nn">[testenv]</span>
  <span class="py">deps</span> <span class="p">=</span>
      <span class="err">pytest</span>
      <span class="err">pytest-cov</span>
  <span class="py">commands</span> <span class="p">=</span> <span class="s">pytest {posargs}</span>

  <span class="nn">[pytest]</span>
  <span class="c"># 所有pytest配置可以放在这里
</span>  <span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests</span>
  <span class="py">python_files</span> <span class="p">=</span> <span class="s">test_*.py</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="s">-v</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="三核心配置项详解">三、核心配置项详解</h2>
<h3 id="31-测试发现配置">3.1 测试发现配置</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># 测试目录（多个用空格分隔）
</span><span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests integration_tests e2e</span>

<span class="c"># 测试文件模式
</span><span class="py">python_files</span> <span class="p">=</span> 
    <span class="s">test_*.py      # 前缀模式</span>
    <span class="err">*_test.py</span>      <span class="c"># 后缀模式
</span>    <span class="err">check_*.py</span>     <span class="c"># 自定义模式
</span>    <span class="err">spec_*.py</span>      <span class="c"># BDD风格
</span>    <span class="err">*test.py</span>       <span class="c"># 包含test
</span>
<span class="c"># 测试类模式
</span><span class="py">python_classes</span> <span class="p">=</span> 
    <span class="s">Test*          # 以Test开头</span>
    <span class="err">*Test</span>          <span class="c"># 以Test结尾
</span>    <span class="err">Check*</span>         <span class="c"># 自定义
</span>    <span class="err">Spec*</span>          <span class="c"># BDD风格
</span>
<span class="c"># 测试函数/方法模式
</span><span class="py">python_functions</span> <span class="p">=</span> 
    <span class="s">test_*         # 前缀模式</span>
    <span class="err">*test</span>          <span class="c"># 后缀模式
</span>    <span class="err">check_*</span>        <span class="c"># 自定义
</span>    <span class="err">should_*</span>       <span class="c"># BDD风格
</span>    <span class="err">it_*</span>           <span class="c"># BDD风格
</span></code></pre></div></div>

<h3 id="32-标记系统markers">3.2 标记系统（Markers）</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="py">markers</span> <span class="p">=</span>
    <span class="c"># 基本分类
</span>    <span class="err">unit:</span> <span class="err">单元测试</span>
    <span class="err">integration:</span> <span class="err">集成测试</span>
    <span class="err">e2e:</span> <span class="err">端到端测试</span>
    <span class="err">smoke:</span> <span class="err">冒烟测试</span>
    
    <span class="c"># 性能相关
</span>    <span class="err">slow:</span> <span class="err">运行缓慢的测试</span> <span class="err">(&gt;1秒)</span>
    <span class="err">fast:</span> <span class="err">快速测试</span> <span class="err">(&lt;0.1秒)</span>
    
    <span class="c"># 环境相关
</span>    <span class="err">windows:</span> <span class="err">仅Windows平台</span>
    <span class="err">linux:</span> <span class="err">仅Linux平台</span>
    <span class="err">macos:</span> <span class="err">仅macOS平台</span>
    <span class="err">docker:</span> <span class="err">需要Docker</span>
    <span class="err">database:</span> <span class="err">需要数据库</span>
    <span class="err">network:</span> <span class="err">需要网络</span>
    
    <span class="c"># 功能相关
</span>    <span class="err">api:</span> <span class="err">API测试</span>
    <span class="err">ui:</span> <span class="err">用户界面测试</span>
    <span class="err">security:</span> <span class="err">安全测试</span>
    <span class="err">performance:</span> <span class="err">性能测试</span>
    
    <span class="c"># 执行控制
</span>    <span class="err">serial:</span> <span class="err">必须串行执行</span>
    <span class="err">parallel:</span> <span class="err">可以并行执行</span>
    <span class="err">flaky:</span> <span class="err">不稳定测试</span>
    
    <span class="c"># 自定义参数
</span>    <span class="err">param(name:</span> <span class="err">参数名,</span> <span class="err">value:</span> <span class="err">参数值):</span> <span class="err">带参数的标记</span>
</code></pre></div></div>

<p>使用示例：</p>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">pytest</span>

<span class="o">@</span><span class="n">pytest</span><span class="p">.</span><span class="n">mark</span><span class="p">.</span><span class="n">slow</span>
<span class="o">@</span><span class="n">pytest</span><span class="p">.</span><span class="n">mark</span><span class="p">.</span><span class="n">database</span>
<span class="o">@</span><span class="n">pytest</span><span class="p">.</span><span class="n">mark</span><span class="p">.</span><span class="n">flaky</span><span class="p">(</span><span class="n">reruns</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">test_complex_operation</span><span class="p">():</span>
    <span class="k">pass</span>

<span class="o">@</span><span class="n">pytest</span><span class="p">.</span><span class="n">mark</span><span class="p">.</span><span class="n">param</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"user_type"</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="s">"admin"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">test_admin_access</span><span class="p">():</span>
    <span class="k">pass</span>
</code></pre></div></div>

<h3 id="33-警告过滤">3.3 警告过滤</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="py">filterwarnings</span> <span class="p">=</span>
    <span class="c"># 1. 错误级别
</span>    <span class="err">error</span>                      <span class="c"># 所有警告转为错误
</span>    <span class="err">error::DeprecationWarning</span>  <span class="c"># 特定警告转为错误
</span>    
    <span class="c"># 2. 忽略警告
</span>    <span class="err">ignore</span>                     <span class="c"># 忽略所有警告
</span>    <span class="err">ignore::UserWarning</span>        <span class="c"># 忽略特定类型
</span>    <span class="err">ignore:.*deprecated.*</span>      <span class="c"># 忽略匹配消息
</span>    <span class="err">ignore:DeprecationWarning:.*:django.*</span>  <span class="c"># 忽略特定模块
</span>    
    <span class="c"># 3. 特定动作
</span>    <span class="err">always::UserWarning</span>        <span class="c"># 总是显示
</span>    <span class="err">once::FutureWarning</span>        <span class="c"># 只显示一次
</span>    <span class="err">module::ImportWarning</span>      <span class="c"># 每个模块显示一次
</span>    
    <span class="c"># 4. 复杂模式
</span>    <span class="err">ignore:.*U.*mode.*:DeprecationWarning</span>
    <span class="err">error:.*deprecated.*:DeprecationWarning</span>
</code></pre></div></div>

<h3 id="34-日志配置">3.4 日志配置</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># 控制台日志
</span><span class="py">log_cli</span> <span class="p">=</span> <span class="s">true                          # 启用控制台日志</span>
<span class="py">log_cli_level</span> <span class="p">=</span> <span class="s">INFO                    # 日志级别</span>
<span class="py">log_cli_format</span> <span class="p">=</span> <span class="s">%(asctime)s [%(levelname)8s] %(message)s</span>
<span class="py">log_cli_date_format</span> <span class="p">=</span> <span class="s">%Y-%m-%d %H:%M:%S</span>

<span class="c"># 文件日志
</span><span class="py">log_file</span> <span class="p">=</span> <span class="s">logs/pytest.log              # 日志文件路径</span>
<span class="py">log_file_level</span> <span class="p">=</span> <span class="s">DEBUG                  # 文件日志级别</span>
<span class="py">log_file_format</span> <span class="p">=</span> <span class="s">%(asctime)s [%(levelname)8s] %(name)s: %(message)s</span>
<span class="py">log_file_date_format</span> <span class="p">=</span> <span class="s">%Y-%m-%d %H:%M:%S</span>

<span class="c"># 自动日志捕获
</span><span class="py">log_auto_indent</span> <span class="p">=</span> <span class="s">true                  # 自动缩进</span>
<span class="py">log_format</span> <span class="p">=</span> <span class="s">%(levelname)8s %(name)s:%(lineno)d %(message)s</span>
<span class="py">log_date_format</span> <span class="p">=</span> <span class="s">%Y-%m-%d %H:%M:%S</span>
</code></pre></div></div>

<h3 id="35-junit-xml报告">3.5 JUnit XML报告</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># 生成JUnit XML报告
</span><span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">My Test Suite</span>
<span class="py">junit_logging</span> <span class="p">=</span> <span class="s">all</span>
<span class="py">junit_duration_report</span> <span class="p">=</span> <span class="s">call</span>
<span class="py">junit_family</span> <span class="p">=</span> <span class="s">xunit2</span>

<span class="c"># 高级配置
</span><span class="py">junit_log_passing_tests</span> <span class="p">=</span> <span class="s">true</span>
<span class="py">junit_duration_report</span> <span class="p">=</span> <span class="s">total</span>
<span class="py">junit_suite_name_remove_path</span> <span class="p">=</span> <span class="s">true</span>
</code></pre></div></div>

<h2 id="四高级配置技巧">四、高级配置技巧</h2>
<h3 id="41-环境特定配置">4.1 环境特定配置</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># 基础配置
</span><span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests</span>
<span class="py">python_files</span> <span class="p">=</span> <span class="s">test_*.py</span>
<span class="py">addopts</span> <span class="p">=</span> <span class="s">-v</span>

<span class="c"># 通过环境变量覆盖
# 开发环境
</span><span class="py">addopts_dev</span> <span class="p">=</span> <span class="s">--tb=short -x --lf</span>
<span class="c"># CI环境
</span><span class="py">addopts_ci</span> <span class="p">=</span> <span class="s">--junitxml=report.xml --cov --cov-report=xml</span>
<span class="c"># 生产环境
</span><span class="py">addopts_prod</span> <span class="p">=</span> <span class="s">--tb=no -q</span>

<span class="c"># 使用环境变量选择
</span><span class="err">import</span> <span class="err">os</span>
<span class="py">env</span> <span class="p">=</span> <span class="s">os.getenv("PYTEST_ENV", "dev")</span>
<span class="err">if</span> <span class="py">env</span> <span class="p">=</span><span class="s">= "ci":</span>
    <span class="py">addopts</span> <span class="p">=</span> <span class="s">{addopts_ci}</span>
<span class="err">elif</span> <span class="py">env</span> <span class="p">=</span><span class="s">= "prod":</span>
    <span class="py">addopts</span> <span class="p">=</span> <span class="s">{addopts_prod}</span>
<span class="err">else:</span>
    <span class="py">addopts</span> <span class="p">=</span> <span class="s">{addopts_dev}</span>
</code></pre></div></div>

<h3 id="42-动态配置">4.2 动态配置</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># 通过conftest.py动态配置
</span><span class="err">import</span> <span class="err">sys</span>
<span class="err">import</span> <span class="err">os</span>

<span class="c"># 根据Python版本配置
</span><span class="err">if</span> <span class="err">sys.version_info</span> <span class="err">&gt;=</span> <span class="err">(3,</span> <span class="err">10):</span>
    <span class="py">addopts</span> <span class="p">=</span> <span class="s">--tb=short -v</span>
<span class="err">else:</span>
    <span class="py">addopts</span> <span class="p">=</span> <span class="s">-v</span>

<span class="c"># 根据操作系统配置
</span><span class="err">if</span> <span class="py">sys.platform</span> <span class="p">=</span><span class="s">= "win32":</span>
    <span class="py">markers</span> <span class="p">=</span> <span class="s">windows: windows only</span>
<span class="err">elif</span> <span class="py">sys.platform</span> <span class="p">=</span><span class="s">= "linux":</span>
    <span class="py">markers</span> <span class="p">=</span> <span class="s">linux: linux only</span>
<span class="err">elif</span> <span class="py">sys.platform</span> <span class="p">=</span><span class="s">= "darwin":</span>
    <span class="py">markers</span> <span class="p">=</span> <span class="s">macos: macos only</span>

<span class="c"># 根据环境变量配置
</span><span class="err">if</span> <span class="err">os.getenv("CI"):</span>
    <span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">CI Test Run</span>
    <span class="err">addopts</span> <span class="err">+=</span> <span class="py">--junitxml</span><span class="p">=</span><span class="s">junit.xml</span>
</code></pre></div></div>

<h3 id="43-插件集成配置">4.3 插件集成配置</h3>
<div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nn">[pytest]</span>
<span class="c"># pytest-cov 覆盖率
</span><span class="py">addopts</span> <span class="p">=</span> <span class="s">--cov=src --cov-report=term-missing --cov-report=html</span>

<span class="c"># pytest-xdist 并行测试
</span><span class="py">addopts</span> <span class="p">=</span> <span class="s">-n auto</span>
<span class="py">xfail_strict</span> <span class="p">=</span> <span class="s">true</span>

<span class="c"># pytest-asyncio
</span><span class="py">asyncio_mode</span> <span class="p">=</span> <span class="s">auto</span>

<span class="c"># pytest-bdd
</span><span class="py">bdd_features_base_dir</span> <span class="p">=</span> <span class="s">features/</span>
<span class="py">bdd_strict_gherkin</span> <span class="p">=</span> <span class="s">false</span>

<span class="c"># pytest-django
</span><span class="py">DJANGO_SETTINGS_MODULE</span> <span class="p">=</span> <span class="s">myproject.settings</span>
</code></pre></div></div>

<h2 id="五配置文件组织结构">五、配置文件组织结构</h2>
<ul>
  <li><strong>5.1 多环境配置示例</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  project/
  ├── pyproject.toml           # 基础配置
  ├── pytest.ini              # 本地开发
  ├── pytest-ci.ini           # CI环境
  ├── conftest.py             # 共享fixtures
  ├── src/                    # 源代码
  │   └── myapp/
  └── tests/                  # 测试代码
      ├── unit/               # 单元测试
      │   ├── conftest.py     # 单元测试fixtures
      │   └── test_*.py
      ├── integration/        # 集成测试
      │   ├── conftest.py     # 集成测试fixtures
      │   └── test_*.py
      └── e2e/                # 端到端测试
          ├── conftest.py     # E2E测试fixtures
          └── test_*.py
</code></pre></div>    </div>
  </li>
  <li><strong>5.2 分层配置示例</strong><br />
  目录 pyproject.toml：
    <div class="language-toml highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[tool.pytest.ini_options]</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="nn">["tests"]</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="s">"-v"</span>
  <span class="py">markers</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"unit: unit tests"</span><span class="p">,</span>
      <span class="s">"integration: integration tests"</span><span class="p">,</span>
      <span class="s">"e2e: end-to-end tests"</span>
  <span class="p">]</span>
</code></pre></div>    </div>

    <p>tests/unit/conftest.py：</p>
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 单元测试特定配置
</span>  <span class="kn">import</span> <span class="nn">pytest</span>

  <span class="k">def</span> <span class="nf">pytest_collection_modifyitems</span><span class="p">(</span><span class="n">config</span><span class="p">,</span> <span class="n">items</span><span class="p">):</span>
      <span class="s">"""为单元测试自动添加标记"""</span>
      <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">items</span><span class="p">:</span>
          <span class="k">if</span> <span class="s">"unit"</span> <span class="ow">in</span> <span class="nb">str</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">fspath</span><span class="p">):</span>
              <span class="n">item</span><span class="p">.</span><span class="n">add_marker</span><span class="p">(</span><span class="n">pytest</span><span class="p">.</span><span class="n">mark</span><span class="p">.</span><span class="n">unit</span><span class="p">)</span>
</code></pre></div>    </div>

    <p>tests/integration/pytest.ini：</p>
    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[pytest]</span>
  <span class="c"># 集成测试特定配置
</span>  <span class="py">addopts</span> <span class="p">=</span> <span class="s">--tb=short -m integration</span>
  <span class="py">timeout</span> <span class="p">=</span> <span class="s">60</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="六配置验证和调试">六、配置验证和调试</h2>
<ul>
  <li><strong>6.1 验证配置文件</strong>
    <div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># 查看有效配置</span>
  pytest <span class="nt">--help</span>

  <span class="c"># 查看已注册的标记</span>
  pytest <span class="nt">--markers</span>

  <span class="c"># 查看收集的测试</span>
  pytest <span class="nt">--collect-only</span>

  <span class="c"># 查看配置详情</span>
  pytest <span class="nt">--version</span>
  pytest <span class="nt">--config</span>
</code></pre></div>    </div>
  </li>
  <li><strong>6.2 调试配置文件</strong>
    <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># conftest.py
</span>  <span class="k">def</span> <span class="nf">pytest_configure</span><span class="p">(</span><span class="n">config</span><span class="p">):</span>
      <span class="s">"""调试配置"""</span>
      <span class="k">print</span><span class="p">(</span><span class="s">"=== pytest_configure ==="</span><span class="p">)</span>
      <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Rootdir: </span><span class="si">{</span><span class="n">config</span><span class="p">.</span><span class="n">rootdir</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
      <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Inifile: </span><span class="si">{</span><span class="n">config</span><span class="p">.</span><span class="n">inifile</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
      <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Addopts: </span><span class="si">{</span><span class="n">config</span><span class="p">.</span><span class="n">option</span><span class="p">.</span><span class="n">addopts</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
      <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Testpaths: </span><span class="si">{</span><span class="n">config</span><span class="p">.</span><span class="n">getini</span><span class="p">(</span><span class="s">'testpaths'</span><span class="p">)</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
      <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Markers: </span><span class="si">{</span><span class="n">config</span><span class="p">.</span><span class="n">getini</span><span class="p">(</span><span class="s">'markers'</span><span class="p">)</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="七最佳实践建议">七、最佳实践建议</h2>
<ul>
  <li><strong>7.1 配置选择</strong>
    <div class="language-yaml highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="s">项目类型            推荐配置          说明</span>
  <span class="s">--------------     -------------    ----------------</span>
  <span class="s">现代Python项目     pyproject.toml     PEP 621标准，统一管理</span>
  <span class="s">Django项目         pytest.ini        传统，社区习惯</span>
  <span class="s">混合项目           pytest.ini        兼容性好</span>
  <span class="s">库/包              pyproject.toml    与构建工具集成</span>
</code></pre></div>    </div>
  </li>
  <li><strong>7.2 配置文件组织</strong>
    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># 1. 基础配置（必须）
</span>  <span class="nn">[pytest]</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="s">-v --tb=short</span>
  <span class="py">markers</span> <span class="p">=</span> <span class="s">基本标记</span>

  <span class="c"># 2. 环境特定（按需）
</span>  <span class="py">filterwarnings</span> <span class="p">=</span> <span class="s">警告过滤</span>
  <span class="py">log_cli</span> <span class="p">=</span> <span class="s">日志配置</span>
  <span class="err">junit_*</span> <span class="err">=</span> <span class="err">报告配置</span>

  <span class="c"># 3. 插件集成（按需）
</span>  <span class="py">asyncio_mode</span> <span class="p">=</span> <span class="s">asyncio配置</span>
  <span class="err">cov_*</span> <span class="err">=</span> <span class="err">覆盖率配置</span>
</code></pre></div>    </div>
  </li>
  <li><strong>7.3 版本控制</strong>
    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># .gitignore
</span>  <span class="err">.pytest_cache/</span>
  <span class="err">.coverage</span>
  <span class="err">htmlcov/</span>
  <span class="err">*.xml</span>
  <span class="err">*.html</span>
  <span class="err">logs/*.log</span>
  <span class="err">!logs/.gitkeep</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="八实用配置片段">八、实用配置片段</h2>
<ul>
  <li><strong>8.1 开发环境配置</strong>
    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[pytest]</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests</span>
  <span class="py">python_files</span> <span class="p">=</span> <span class="s">test_*.py</span>
  <span class="py">addopts</span> <span class="p">=</span> 
      <span class="s">-v</span>
      <span class="py">--tb</span><span class="p">=</span><span class="s">short</span>
      <span class="err">-x</span>
      <span class="err">--lf</span>
      <span class="py">--capture</span><span class="p">=</span><span class="s">no</span>
  <span class="py">markers</span> <span class="p">=</span>
      <span class="err">unit:</span> <span class="err">单元测试</span>
      <span class="err">integration:</span> <span class="err">集成测试</span>
      <span class="err">slow:</span> <span class="err">慢速测试</span>
  <span class="py">filterwarnings</span> <span class="p">=</span>
      <span class="err">ignore::DeprecationWarning</span>
      <span class="err">ignore::FutureWarning</span>
</code></pre></div>    </div>
  </li>
  <li><strong>8.2 CI环境配置</strong>
    <div class="language-ini highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nn">[pytest]</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="s">tests</span>
  <span class="py">addopts</span> <span class="p">=</span> 
      <span class="s">-v</span>
      <span class="py">--tb</span><span class="p">=</span><span class="s">line</span>
      <span class="err">--strict-markers</span>
      <span class="py">--junitxml</span><span class="p">=</span><span class="s">junit.xml</span>
      <span class="py">--cov</span><span class="p">=</span><span class="s">src</span>
      <span class="py">--cov-report</span><span class="p">=</span><span class="s">xml</span>
      <span class="py">--cov-report</span><span class="p">=</span><span class="s">term-missing</span>
  <span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">CI Test Suite</span>
</code></pre></div>    </div>
  </li>
  <li><strong>8.3 完整企业级示例</strong>
    <div class="language-toml highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c"># pyproject.toml</span>
  <span class="nn">[build-system]</span>
  <span class="py">requires</span> <span class="p">=</span> <span class="nn">["setuptools&gt;=61.0"]</span>
  <span class="py">build-backend</span> <span class="p">=</span> <span class="s">"setuptools.build_meta"</span>

  <span class="nn">[project]</span>
  <span class="py">name</span> <span class="p">=</span> <span class="s">"myproject"</span>
  <span class="py">version</span> <span class="p">=</span> <span class="s">"1.0.0"</span>
  <span class="py">dependencies</span> <span class="p">=</span> <span class="p">[]</span>

  <span class="nn">[tool.pytest.ini_options]</span>
  <span class="py">testpaths</span> <span class="p">=</span> <span class="nn">["tests"]</span>
  <span class="py">python_files</span> <span class="p">=</span> <span class="p">[</span><span class="s">"test_*.py"</span><span class="p">,</span> <span class="s">"*_test.py"</span><span class="p">]</span>
  <span class="py">python_classes</span> <span class="p">=</span> <span class="nn">["Test*"]</span>
  <span class="py">python_functions</span> <span class="p">=</span> <span class="p">[</span><span class="s">"test_*"</span><span class="p">,</span> <span class="s">"should_*"</span><span class="p">]</span>
  <span class="py">addopts</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"-v"</span><span class="p">,</span>
      <span class="s">"--strict-markers"</span><span class="p">,</span>
      <span class="py">"--tb</span><span class="p">=</span><span class="err">short</span><span class="s">",</span><span class="err">
</span>      <span class="py">"--durations</span><span class="p">=</span><span class="mi">10</span><span class="s">",</span><span class="err">
</span>      <span class="s">"--disable-warnings"</span><span class="p">,</span>
      <span class="s">"-p"</span><span class="p">,</span> <span class="s">"no:warnings"</span>
  <span class="p">]</span>

  <span class="py">markers</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"unit: Unit tests (&lt; 0.1s)"</span><span class="p">,</span>
      <span class="s">"integration: Integration tests (0.1-1s)"</span><span class="p">,</span>
      <span class="s">"e2e: End-to-end tests (&gt; 1s)"</span><span class="p">,</span>
      <span class="s">"slow: Slow tests (&gt; 5s, run separately)"</span><span class="p">,</span>
      <span class="py">"flaky(reruns</span><span class="p">=</span><span class="mi">3</span><span class="err">):</span> <span class="err">Flaky</span> <span class="err">tests</span> <span class="err">that</span> <span class="err">can</span> <span class="err">be</span> <span class="err">retried</span><span class="s">",</span><span class="err">
</span>      <span class="s">"windows: Windows-specific tests"</span><span class="p">,</span>
      <span class="s">"linux: Linux-specific tests"</span><span class="p">,</span>
      <span class="s">"macos: macOS-specific tests"</span><span class="p">,</span>
      <span class="s">"docker: Requires Docker"</span><span class="p">,</span>
      <span class="s">"database: Requires database"</span><span class="p">,</span>
      <span class="s">"api: API tests"</span><span class="p">,</span>
      <span class="s">"security: Security tests"</span>
  <span class="p">]</span>

  <span class="py">filterwarnings</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"error"</span><span class="p">,</span>
      <span class="s">"ignore::DeprecationWarning"</span><span class="p">,</span>
      <span class="s">"ignore::PendingDeprecationWarning"</span><span class="p">,</span>
      <span class="s">"ignore::FutureWarning:.*:"</span><span class="p">,</span>
      <span class="s">"ignore:.*U.*mode.*:DeprecationWarning"</span>
  <span class="p">]</span>

  <span class="py">log_cli</span> <span class="p">=</span> <span class="kc">true</span>
  <span class="py">log_cli_level</span> <span class="p">=</span> <span class="s">"INFO"</span>
  <span class="py">log_cli_format</span> <span class="p">=</span> <span class="s">"%(asctime)s [%(levelname)-8s] %(name)-20s: %(message)s"</span>
  <span class="py">log_cli_date_format</span> <span class="p">=</span> <span class="s">"%H:%M:%S"</span>

  <span class="py">junit_suite_name</span> <span class="p">=</span> <span class="s">"MyProject Test Suite"</span>
  <span class="py">junit_family</span> <span class="p">=</span> <span class="s">"xunit2"</span>
  <span class="py">junit_logging</span> <span class="p">=</span> <span class="s">"system-out"</span>

  <span class="nn">[tool.coverage.run]</span>
  <span class="py">source</span> <span class="p">=</span> <span class="nn">["src"]</span>
  <span class="py">omit</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"*/tests/*"</span><span class="p">,</span>
      <span class="s">"*/migrations/*"</span><span class="p">,</span>
      <span class="s">"*/__pycache__/*"</span><span class="p">,</span>
      <span class="s">"setup.py"</span>
  <span class="p">]</span>

  <span class="nn">[tool.coverage.report]</span>
  <span class="py">exclude_lines</span> <span class="p">=</span> <span class="p">[</span>
      <span class="s">"pragma: no cover"</span><span class="p">,</span>
      <span class="s">"def __repr__"</span><span class="p">,</span>
      <span class="s">"if self.debug:"</span><span class="p">,</span>
      <span class="s">"if 0:"</span><span class="p">,</span>
      <span class="s">"if __name__ == .__main__.:"</span><span class="p">,</span>
      <span class="s">"raise AssertionError"</span><span class="p">,</span>
      <span class="s">"raise NotImplementedError"</span>
  <span class="p">]</span>

  <span class="nn">[tool.coverage.html]</span>
  <span class="py">directory</span> <span class="p">=</span> <span class="s">"coverage_html"</span>
  <span class="py">title</span> <span class="p">=</span> <span class="s">"Coverage Report"</span>
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="九总结">九、总结</h2>

<p><strong>pytest 配置文件是测试框架的控制中心，合理配置可以：</strong></p>
<ul>
  <li>统一测试规范：确保团队使用相同的测试发现和运行规则</li>
  <li>提高测试效率：通过合理配置减少等待时间，优化输出</li>
  <li>增强测试可维护性：清晰的标记系统和配置结构</li>
  <li>集成CI/CD：生成标准化的测试报告</li>
  <li>管理测试环境：不同环境使用不同配置</li>
</ul>

<p><strong>核心建议：</strong></p>
<ul>
  <li>新项目使用 pyproject.toml</li>
  <li>明确配置测试发现规则</li>
  <li>使用标记系统组织测试</li>
  <li>合理配置日志和报告</li>
  <li>为不同环境准备不同配置</li>
  <li>文档化配置项，特别是自定义标记*</li>
</ul>]]></content><author><name>xdh2580</name></author><category term="pytest" /><category term="pytest" /><summary type="html"><![CDATA[pytest配置文件全面解析]]></summary></entry><entry><title type="html">pytest相关</title><link href="https://xdh2580.github.io/pytest/pytest/" rel="alternate" type="text/html" title="pytest相关" /><published>2026-04-01T00:00:00+00:00</published><updated>2026-04-01T00:00:00+00:00</updated><id>https://xdh2580.github.io/pytest/pytest</id><content type="html" xml:base="https://xdh2580.github.io/pytest/pytest/"><![CDATA[<h1 id="pytest-测试框架-系统学习大纲">Pytest 测试框架 系统学习大纲</h1>

<h2 id="一pytest-概述">一、Pytest 概述</h2>
<ul>
  <li><strong>1.1 Pytest 简介</strong>
    <ul>
      <li>什么是 Pytest</li>
      <li>Pytest 的特点和优势</li>
      <li>与其他测试框架对比（unittest, nose）</li>
    </ul>
    <details>
      <summary>详情关于pytest和unittest对比</summary>

      <table>
        <thead>
          <tr>
            <th style="text-align: left">对比维度</th>
            <th style="text-align: left">pytest</th>
            <th style="text-align: left">unittest</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td style="text-align: left"><strong>设计哲学</strong></td>
            <td style="text-align: left">更灵活、简洁，遵循“约定优于配置”原则。</td>
            <td style="text-align: left">基于 Java 的 JUnit 框架，采用经典的 xUnit 风格，结构严谨。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>编写风格</strong></td>
            <td style="text-align: left">使用普通的 Python 函数和 <code class="language-plaintext highlighter-rouge">assert</code> 语句，代码更简洁。</td>
            <td style="text-align: left">必须继承 <code class="language-plaintext highlighter-rouge">unittest.TestCase</code> 类，并使用 <code class="language-plaintext highlighter-rouge">self.assertXxx()</code> 系列方法。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>断言方式</strong></td>
            <td style="text-align: left">直接使用 Python 原生的 <code class="language-plaintext highlighter-rouge">assert</code> 语句，失败时信息更清晰易读。</td>
            <td style="text-align: left">使用 <code class="language-plaintext highlighter-rouge">self.assertXxx()</code> 方法（如 <code class="language-plaintext highlighter-rouge">assertEqual</code>, <code class="language-plaintext highlighter-rouge">assertTrue</code>）。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>夹具管理</strong></td>
            <td style="text-align: left">通过 <code class="language-plaintext highlighter-rouge">@pytest.fixture</code> 装饰器提供强大、灵活的夹具系统，支持作用域和自动使用。</td>
            <td style="text-align: left">通过 <code class="language-plaintext highlighter-rouge">setUp</code>/<code class="language-plaintext highlighter-rouge">tearDown</code>（方法级）和 <code class="language-plaintext highlighter-rouge">setUpClass</code>/<code class="language-plaintext highlighter-rouge">tearDownClass</code>（类级）管理。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>测试发现</strong></td>
            <td style="text-align: left">自动发现以 <code class="language-plaintext highlighter-rouge">test_</code> 开头的函数和以 <code class="language-plaintext highlighter-rouge">Test</code> 开头的类中的 <code class="language-plaintext highlighter-rouge">test_</code> 方法。</td>
            <td style="text-align: left">自动发现继承 <code class="language-plaintext highlighter-rouge">unittest.TestCase</code> 的类中的 <code class="language-plaintext highlighter-rouge">test_</code> 开头的方法。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>插件生态</strong></td>
            <td style="text-align: left">拥有极其丰富和强大的插件生态系统（如并发执行、HTML报告、覆盖率集成等）。</td>
            <td style="text-align: left">生态相对简单，功能扩展主要依赖原生模块或少量第三方库。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>执行控制</strong></td>
            <td style="text-align: left">命令行功能强大，支持通过 <code class="language-plaintext highlighter-rouge">-k</code> 筛选用例、<code class="language-plaintext highlighter-rouge">-m</code> 标记用例、<code class="language-plaintext highlighter-rouge">--lf</code> 只运行上次失败的用例等。</td>
            <td style="text-align: left">命令行功能相对基础。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>报告输出</strong></td>
            <td style="text-align: left">默认输出简洁，失败时提供非常详细的上下文差异分析。</td>
            <td style="text-align: left">输出为标准 xUnit 风格报告。</td>
          </tr>
          <tr>
            <td style="text-align: left"><strong>与unittest兼容</strong></td>
            <td style="text-align: left"><strong>可以无缝运行</strong> unittest 测试用例，无需修改代码。</td>
            <td style="text-align: left">无法直接运行 pytest 风格的测试函数。</td>
          </tr>
        </tbody>
      </table>

    </details>
  </li>
  <li><strong>1.2 安装与配置</strong>
    <ul>
      <li>
        <p>pip 安装</p>
      </li>
      <li>虚拟环境配置</li>
      <li>验证安装</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip install pytest
pytest --version
</code></pre></div>    </div>
  </li>
  <li><strong>1.3 第一个测试用例</strong>
    <ul>
      <li>简单测试函数</li>
      <li>运行测试</li>
      <li>测试结果解读</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># test_sample.py
def func(x):
    return x + 1

def test_answer():
    assert func(3) == 5
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="二测试发现与执行">二、测试发现与执行</h2>
<ul>
  <li><strong>2.1 测试发现规则</strong>
    <ul>
      <li>文件命名规则：test_*.py 或 *_test.py</li>
      <li>函数命名规则：test_*</li>
      <li>类命名规则：Test*</li>
      <li>方法命名规则：test_*</li>
    </ul>
  </li>
  <li><strong>2.2 执行测试的方式</strong>
    <ul>
      <li>运行所有测试</li>
      <li>运行指定模块</li>
      <li>运行指定目录</li>
      <li>运行指定测试函数</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># 运行所有测试
pytest

# 运行指定文件
pytest test_module.py

# 运行指定测试函数
pytest test_module.py::test_function

# 运行指定类
pytest test_module.py::TestClass

# 运行指定类中的方法
pytest test_module.py::TestClass::test_method
</code></pre></div>    </div>
  </li>
  <li><strong>2.3 常用命令行选项</strong>
    <ul>
      <li>-v: 详细输出</li>
      <li>-q: 简洁输出</li>
      <li>-s: 显示 print 输出</li>
      <li>-k: 关键字过滤</li>
      <li>-m: 标记过滤</li>
      <li>-x: 遇到失败立即停止</li>
      <li>–maxfail=n: 指定最大失败数</li>
      <li>–collect-only: 收集但不执行</li>
      <li>–tb=style: 设置回溯显示样式</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pytest -v -s
pytest -k "login"
pytest -m "slow"
pytest --maxfail=2
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="三测试用例编写规范">三、测试用例编写规范</h2>
<ul>
  <li><strong>3.1 测试函数结构</strong>
    <ul>
      <li>Arrange-Act-Assert 模式</li>
      <li>函数签名</li>
      <li>返回值</li>
    </ul>
  </li>
  <li><strong>3.2 断言使用</strong>
    <ul>
      <li>assert 语句</li>
      <li>内置断言</li>
      <li>断言重写机制</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_addition():
    # Arrange
    a, b = 1, 2
        
    # Act
    result = a + b
        
    # Assert
    assert result == 3
        
def test_list_operations():
    items = [1, 2, 3]
    assert len(items) == 3
    assert 2 in items
    assert items[0] == 1
</code></pre></div>    </div>
  </li>
  <li><strong>3.3 测试异常</strong>
    <ul>
      <li>pytest.raises</li>
      <li>异常匹配</li>
      <li>异常消息验证</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        1 / 0

def test_divide_by_zero_with_message():
    with pytest.raises(ZeroDivisionError, match="division by zero"):
        1 / 0
</code></pre></div>    </div>
  </li>
  <li><strong>3.4 测试类组织</strong>
    <ul>
      <li>测试类结构</li>
      <li>类级别设置</li>
      <li>实例方法</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class TestCalculator:
    def test_addition(self):
        assert 1 + 1 == 2
        
    def test_subtraction(self):
        assert 5 - 3 == 2
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="四固件fixture">四、固件（Fixture）</h2>
<ul>
  <li><strong>4.1 什么是 Fixture</strong>
    <ul>
      <li>定义和用途</li>
      <li>生命周期</li>
      <li>作用域</li>
    </ul>
  </li>
  <li><strong>4.2 基本用法</strong>
    <ul>
      <li>@pytest.fixture 装饰器</li>
      <li>Fixture 参数</li>
      <li>使用 Fixture</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest

@pytest.fixture
def sample_data():
    return {"name": "Alice", "age": 30}

def test_user_data(sample_data):
    assert sample_data["name"] == "Alice"
    assert sample_data["age"] == 30
</code></pre></div>    </div>
  </li>
  <li><strong>4.3 Fixture 作用域</strong>
    <ul>
      <li>function: 函数级别</li>
      <li>class: 类级别</li>
      <li>module: 模块级别</li>
      <li>session: 会话级别</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture(scope="session")
def db_connection():
    # 建立数据库连接
    conn = create_connection()
    yield conn
    # 清理
    conn.close()

@pytest.fixture(scope="module")
def setup_data():
    return {"key": "value"}
</code></pre></div>    </div>
  </li>
  <li><strong>4.4 Fixture 自动使用</strong>
    <ul>
      <li>autouse=True</li>
      <li>全局 Fixture</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture(autouse=True)
def setup_each_test():
    print("\n=== 开始测试 ===")
    yield
    print("\n=== 结束测试 ===")
</code></pre></div>    </div>
  </li>
  <li><strong>4.5 Fixture 之间的依赖</strong>
    <ul>
      <li>Fixture 调用其他 Fixture</li>
      <li>依赖关系</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture
def user():
    return {"name": "Alice"}

@pytest.fixture
def user_with_age(user):
    user["age"] = 30
    return user

def test_user_info(user_with_age):
    assert user_with_age["name"] == "Alice"
    assert user_with_age["age"] == 30
</code></pre></div>    </div>
  </li>
  <li><strong>4.6 内置 Fixture</strong>
    <ul>
      <li>tmp_path: 临时目录</li>
      <li>capsys: 捕获输出</li>
      <li>monkeypatch: 猴子补丁</li>
      <li>mocker: pytest-mock</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_tmp_path(tmp_path):
    file_path = tmp_path / "test.txt"
    file_path.write_text("Hello")
    assert file_path.read_text() == "Hello"

def test_output(capsys):
    print("Hello World")
    captured = capsys.readouterr()
    assert captured.out == "Hello World\n"
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="五参数化测试">五、参数化测试</h2>
<ul>
  <li><strong>5.1 @pytest.mark.parametrize</strong>
    <ul>
      <li>基本语法</li>
      <li>多参数</li>
      <li>参数组合</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest

@pytest.mark.parametrize("input,expected", [
    (1, 2),
    (2, 3),
    (3, 4)
])
def test_increment(input, expected):
    assert input + 1 == expected
</code></pre></div>    </div>
  </li>
  <li><strong>5.2 参数化 Fixture</strong>
    <ul>
      <li>indirect 参数</li>
      <li>动态参数</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture
def data(request):
    return request.param * 2

@pytest.mark.parametrize("data", [1, 2, 3], indirect=True)
def test_data(data):
    assert data % 2 == 0
</code></pre></div>    </div>
  </li>
  <li><strong>5.3 参数化策略</strong>
    <ul>
      <li>笛卡尔积</li>
      <li>自定义参数生成</li>
      <li>从文件读取参数</li>
    </ul>
  </li>
</ul>

<h2 id="六标记mark">六、标记（Mark）</h2>
<ul>
  <li><strong>6.1 内置标记</strong>
    <ul>
      <li>@pytest.mark.skip: 跳过测试</li>
      <li>@pytest.mark.skipif: 条件跳过</li>
      <li>@pytest.mark.xfail: 预期失败</li>
      <li>@pytest.mark.parametrize: 参数化</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest
import sys

@pytest.mark.skip(reason="功能未实现")
def test_unimplemented():
    assert False

@pytest.mark.skipif(sys.version_info &lt; (3, 8), reason="需要 Python 3.8+")
def test_python38_feature():
    assert True

@pytest.mark.xfail
def test_experimental():
    assert False
</code></pre></div>    </div>
  </li>
  <li><strong>6.2 自定义标记</strong>
    <ul>
      <li>注册标记</li>
      <li>标记分类</li>
      <li>按标记过滤</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># pytest.ini
[pytest]
markers =
    slow: 标记慢速测试
    integration: 集成测试
    smoke: 冒烟测试

# 测试文件
@pytest.mark.slow
def test_slow_operation():
    import time
    time.sleep(2)
    assert True
</code></pre></div>    </div>
  </li>
  <li><strong>6.3 标记与 Fixture 结合</strong>
    <ul>
      <li>根据标记使用不同 Fixture</li>
      <li>动态 Fixture</li>
    </ul>
  </li>
</ul>

<h2 id="七测试报告与日志">七、测试报告与日志</h2>
<ul>
  <li><strong>7.1 测试结果输出</strong>
    <ul>
      <li>控制台输出</li>
      <li>详细模式</li>
      <li>安静模式</li>
    </ul>
  </li>
  <li><strong>7.2 报告生成</strong>
    <ul>
      <li>生成 JUnit XML</li>
      <li>生成 HTML 报告</li>
      <li>生成 Allure 报告</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># 生成 JUnit XML
pytest --junit-xml=report.xml

# 生成 HTML 报告
pytest --html=report.html

# 使用 pytest-html
pytest --html=report.html --self-contained-html
</code></pre></div>    </div>
  </li>
  <li><strong>7.3 日志记录</strong>
    <ul>
      <li>caplog Fixture</li>
      <li>配置日志级别</li>
      <li>捕获日志消息</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import logging

def test_logging(caplog):
    caplog.set_level(logging.INFO)
    logging.info("测试日志")
    assert "测试日志" in caplog.text
</code></pre></div>    </div>
  </li>
  <li><strong>7.4 测试覆盖率</strong>
    <ul>
      <li>pytest-cov 插件</li>
      <li>覆盖率报告</li>
      <li>覆盖率配置</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
# 运行测试并计算覆盖率
pytest --cov=myproject tests/

# 生成 HTML 覆盖率报告
pytest --cov=myproject --cov-report=html tests/
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="八mock-和-monkeypatch">八、Mock 和 Monkeypatch</h2>
<ul>
  <li><strong>8.1 什么是 Mock</strong>
    <ul>
      <li>模拟对象</li>
      <li>测试替身</li>
      <li>使用场景</li>
    </ul>
  </li>
  <li><strong>8.2 unittest.mock</strong>
    <ul>
      <li>Mock 对象</li>
      <li>MagicMock</li>
      <li>patch 装饰器</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>from unittest.mock import Mock, patch

def test_mock():
    mock_obj = Mock()
    mock_obj.method.return_value = 42
    assert mock_obj.method() == 42
    mock_obj.method.assert_called_once()

@patch("module.function")
def test_patch(mock_function):
    mock_function.return_value = "mocked"
    result = module.function()
    assert result == "mocked"
</code></pre></div>    </div>
  </li>
  <li><strong>8.3 pytest-mock 插件</strong>
    <ul>
      <li>mocker Fixture</li>
      <li>简化 Mock</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_with_mocker(mocker):
    mock_func = mocker.patch("module.function")
    mock_func.return_value = "mocked"
    result = module.function()
    assert result == "mocked"
    mock_func.assert_called_once()
</code></pre></div>    </div>
  </li>
  <li><strong>8.4 monkeypatch</strong>
    <ul>
      <li>临时修改</li>
      <li>环境变量</li>
      <li>属性修改</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import os

def test_env_var(monkeypatch):
    monkeypatch.setenv("API_KEY", "test_key")
    assert os.getenv("API_KEY") == "test_key"

def test_attribute(monkeypatch):
    class MyClass:
        value = 1
        
    obj = MyClass()
    monkeypatch.setattr(obj, "value", 2)
    assert obj.value == 2
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="九测试数据管理">九、测试数据管理</h2>
<ul>
  <li><strong>9.1 测试数据文件</strong>
    <ul>
      <li>JSON 文件</li>
      <li>YAML 文件</li>
      <li>CSV 文件</li>
    </ul>
  </li>
  <li><strong>9.2 Fixture 工厂</strong>
    <ul>
      <li>动态生成测试数据</li>
      <li>数据清理</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture
def user_factory():
    users = []
        
    def _create_user(name, age):
        user = {"name": name, "age": age}
        users.append(user)
        return user
        
    yield _create_user
        
    # 清理
    for user in users:
        # 清理逻辑
        pass
</code></pre></div>    </div>
  </li>
  <li><strong>9.3 测试数据库</strong>
    <ul>
      <li>测试数据库设置</li>
      <li>数据迁移</li>
      <li>事务回滚</li>
    </ul>
  </li>
  <li><strong>9.4 临时文件</strong>
    <ul>
      <li>tmp_path Fixture</li>
      <li>临时目录</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_temp_file(tmp_path):
    d = tmp_path / "sub"
    d.mkdir()
    p = d / "test.txt"
    p.write_text("Hello")
    assert p.read_text() == "Hello"
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十插件系统">十、插件系统</h2>
<ul>
  <li><strong>10.1 常用插件</strong>
    <ul>
      <li>pytest-html: HTML 报告</li>
      <li>pytest-cov: 测试覆盖率</li>
      <li>pytest-xdist: 并行测试</li>
      <li>pytest-ordering: 测试顺序</li>
      <li>pytest-timeout: 超时控制</li>
      <li>pytest-asyncio: 异步测试</li>
      <li>pytest-rerunfailures: 失败重试</li>
    </ul>
  </li>
  <li><strong>10.2 插件安装与配置</strong>
    <ul>
      <li>
        <p>安装插件</p>
      </li>
      <li>插件配置</li>
      <li>插件选项</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip install pytest-html pytest-cov pytest-xdist
pytest --html=report.html --cov=myproject -n 4
</code></pre></div>    </div>
  </li>
  <li><strong>10.3 自定义插件</strong>
    <ul>
      <li>钩子函数</li>
      <li>命令行选项</li>
      <li>自定义 Fixture</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># conftest.py
def pytest_addoption(parser):
    parser.addoption("--env", action="store", default="test")

@pytest.fixture
def environment(request):
    return request.config.getoption("--env")
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十一并发与并行测试">十一、并发与并行测试</h2>
<ul>
  <li><strong>11.1 pytest-xdist 插件</strong>
    <ul>
      <li>并行执行</li>
      <li>分布式测试</li>
      <li>CPU 核心数</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># 并行运行测试
pytest -n auto
pytest -n 4
</code></pre></div>    </div>
  </li>
  <li><strong>11.2 并发问题</strong>
    <ul>
      <li>资源竞争</li>
      <li>测试隔离</li>
      <li>数据一致性</li>
    </ul>
  </li>
  <li><strong>11.3 优化策略</strong>
    <ul>
      <li>测试分组</li>
      <li>资源管理</li>
      <li>测试顺序</li>
    </ul>
  </li>
</ul>

<h2 id="十二异步测试">十二、异步测试</h2>
<ul>
  <li><strong>12.1 pytest-asyncio</strong>
    <ul>
      <li>异步测试支持</li>
      <li>async/await</li>
      <li>事件循环</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest
import asyncio

@pytest.mark.asyncio
async def test_async():
    result = await async_function()
    assert result == "expected"
</code></pre></div>    </div>
  </li>
  <li><strong>12.2 异步 Fixture</strong>
    <ul>
      <li>异步设置</li>
      <li>异步清理</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.fixture
async def async_fixture():
    data = await fetch_data()
    yield data
    await cleanup()
</code></pre></div>    </div>
  </li>
  <li><strong>12.3 超时控制</strong>
    <ul>
      <li>测试超时</li>
      <li>异步超时</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@pytest.mark.asyncio
@pytest.mark.timeout(5)
async def test_timeout():
    await asyncio.sleep(10)  # 会超时
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十三测试配置">十三、测试配置</h2>
<ul>
  <li><strong>13.1 配置文件</strong>
    <ul>
      <li>pytest.ini</li>
      <li>setup.cfg</li>
      <li>pyproject.toml</li>
      <li>tox.ini</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># pytest.ini
[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
markers =
    slow: 慢速测试
    integration: 集成测试
addopts = -v -s
</code></pre></div>    </div>

    <p><a href="/pytest/pytest-config-file/">更多关于pytest配置文件</a></p>
  </li>
  <li><strong>13.2 命令行配置</strong>
    <ul>
      <li>默认选项</li>
      <li>配置文件优先级</li>
      <li><strong>13.3 环境配置</strong></li>
      <li>环境变量</li>
      <li>配置文件</li>
      <li>动态配置</li>
    </ul>
  </li>
</ul>

<h2 id="十四测试组织结构">十四、测试组织结构</h2>
<ul>
  <li><strong>14.1 测试目录结构</strong>
    <ul>
      <li>扁平结构</li>
      <li>分层结构</li>
      <li>包结构</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>project/
├── src/
│   └── mypackage/
├── tests/
│   ├── unit/
│   ├── integration/
│   └── conftest.py
├── pytest.ini
└── pyproject.toml
</code></pre></div>    </div>
  </li>
  <li><strong>14.2 conftest.py</strong>
    <ul>
      <li>作用域</li>
      <li>共享 Fixture</li>
      <li>插件配置</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># tests/conftest.py
import pytest

@pytest.fixture
def shared_data():
    return {"key": "value"}

# tests/unit/conftest.py
@pytest.fixture
def unit_data():
    return {"unit": "test"}
</code></pre></div>    </div>
  </li>
  <li><strong>14.3 导入路径</strong>
    <ul>
      <li>sys.path</li>
      <li>PYTHONPATH</li>
      <li>相对导入</li>
    </ul>
  </li>
  <li><strong>14.4 测试分类</strong>
    <ul>
      <li>单元测试</li>
      <li>集成测试</li>
      <li>端到端测试</li>
      <li>冒烟测试</li>
    </ul>
  </li>
</ul>

<h2 id="十五高级特性">十五、高级特性</h2>
<ul>
  <li><strong>15.1 钩子函数</strong>
    <ul>
      <li>pytest_addoption</li>
      <li>pytest_configure</li>
      <li>pytest_collection_modifyitems</li>
      <li>pytest_runtest_setup</li>
      <li>pytest_runtest_teardown</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># conftest.py
def pytest_collection_modifyitems(config, items):
    # 修改测试项顺序
    items.reverse()
        
def pytest_configure(config):
    # 配置阶段
    config
    .addinivalue_line("markers", "slow: 慢速测试")
</code></pre></div>    </div>
  </li>
  <li><strong>15.2 自定义断言</strong>
    <ul>
      <li>断言重写</li>
      <li>自定义断言消息</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_custom_assertion():
    a = [1, 2, 3]
    b = [1, 2, 3]
    # 自定义断言消息
    assert a == b, f"列表不相等: {a} != {b}"
</code></pre></div>    </div>
  </li>
  <li><strong>15.3 测试依赖</strong>
    <ul>
      <li>pytest-dependency</li>
      <li>测试执行顺序</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import pytest

@pytest.mark.dependency()
def test_first():
    assert True

@pytest.mark.dependency(depends=["test_first"])
def test_second():
    assert True
</code></pre></div>    </div>
  </li>
  <li><strong>15.4 跳过条件</strong>
    <ul>
      <li>运行时跳过</li>
      <li>平台判断</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import sys
import pytest

@pytest.mark.skipif(sys.platform != "linux", reason="仅在 Linux 上运行")
def test_linux_only():
    assert True
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十六最佳实践">十六、最佳实践</h2>
<ul>
  <li><strong>16.1 测试设计原则</strong>
    <ul>
      <li>单一职责</li>
      <li>独立性</li>
      <li>可重复性</li>
      <li>快速执行</li>
    </ul>
  </li>
  <li><strong>16.2 测试命名规范</strong>
    <ul>
      <li>描述性名称</li>
      <li>统一格式</li>
      <li>英文命名</li>
    </ul>
  </li>
  <li><strong>16.3 测试维护</strong>
    <ul>
      <li>避免重复</li>
      <li>及时清理</li>
      <li>持续重构</li>
    </ul>
  </li>
  <li><strong>16.4 测试性能</strong>
    <ul>
      <li>避免 I/O</li>
      <li>使用 Mock</li>
      <li>并行执行</li>
    </ul>
  </li>
  <li><strong>16.5 测试稳定性</strong>
    <ul>
      <li>避免随机性</li>
      <li>处理竞态条件</li>
      <li>资源清理</li>
    </ul>
  </li>
</ul>

<h2 id="十七常见问题与调试">十七、常见问题与调试</h2>
<ul>
  <li><strong>17.1 测试失败分析</strong>
    <ul>
      <li>回溯信息</li>
      <li>断言消息</li>
      <li>调试输出</li>
    </ul>
  </li>
  <li><strong>17.2 常见错误</strong>
    <ul>
      <li>Fixture 作用域错误</li>
      <li>导入错误</li>
      <li>依赖缺失</li>
    </ul>
  </li>
  <li><strong>17.3 调试技巧</strong>
    <ul>
      <li>pdb 调试</li>
      <li>print 输出</li>
      <li>日志记录</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def test_debug():
    import pdb; pdb.set_trace()
    # 或者使用断点
    breakpoint()
</code></pre></div>    </div>
  </li>
  <li><strong>17.4 测试隔离</strong>
    <ul>
      <li>环境隔离</li>
      <li>数据隔离</li>
      <li>进程隔离</li>
    </ul>
  </li>
</ul>

<h2 id="十八cicd-集成">十八、CI/CD 集成</h2>
<ul>
  <li><strong>18.1 持续集成配置</strong>
    <ul>
      <li>GitHub Actions</li>
      <li>GitLab CI</li>
      <li>Jenkins</li>
      <li>Travis CI</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># .github/workflows/test.yml
name: Tests
on: [push, pull_request]
jobs:
test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Run tests
        run: |
        pip install -r requirements.txt
        pytest --cov=myproject --cov-report=xml
</code></pre></div>    </div>
  </li>
  <li><strong>18.2 测试报告集成</strong>
    <ul>
      <li>测试结果通知</li>
      <li>覆盖率报告</li>
      <li>测试趋势</li>
    </ul>
  </li>
  <li><strong>18.3 质量门禁</strong>
    <ul>
      <li>测试通过率</li>
      <li>覆盖率阈值</li>
      <li>测试时长</li>
    </ul>

    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pytest --cov=myproject --cov-fail-under=80
pytest --junitxml=report.xml
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十九学习资源">十九、学习资源</h2>
<ul>
  <li><strong>19.1 官方文档</strong>
    <ul>
      <li>Pytest 官方文档</li>
      <li>GitHub 仓库</li>
      <li>官方示例</li>
    </ul>
  </li>
  <li><strong>19.2 书籍推荐</strong>
    <ul>
      <li>《Python Testing with pytest》</li>
      <li>《Pytest Quick Start Guide》</li>
    </ul>
  </li>
  <li><strong>19.3 在线教程</strong>
    <ul>
      <li>官方教程</li>
      <li>视频课程</li>
      <li>博客文章</li>
    </ul>
  </li>
  <li><strong>19.4 社区资源</strong>
    <ul>
      <li>Stack Overflow</li>
      <li>GitHub Issues</li>
      <li>中文社区</li>
    </ul>
  </li>
  <li><strong>19.5 进阶学习</strong>
    <ul>
      <li>插件开发</li>
      <li>源码阅读</li>
      <li>贡献代码</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="pytest" /><category term="pytest" /><summary type="html"><![CDATA[Pytest 测试框架 系统学习大纲]]></summary></entry><entry><title type="html">HTTP相关</title><link href="https://xdh2580.github.io/http/HTTP/" rel="alternate" type="text/html" title="HTTP相关" /><published>2026-03-25T00:00:00+00:00</published><updated>2026-03-25T00:00:00+00:00</updated><id>https://xdh2580.github.io/http/HTTP</id><content type="html" xml:base="https://xdh2580.github.io/http/HTTP/"><![CDATA[<h1 id="http-协议-系统学习大纲">HTTP 协议 系统学习大纲</h1>

<h2 id="一-http-协议概述">一、 HTTP 协议概述</h2>
<ul>
  <li><strong>1.1 HTTP 是什么？</strong>
    <ul>
      <li>定义：超文本传输协议</li>
      <li>作用：客户端和服务器之间的通信协议</li>
      <li>位置：应用层协议，基于 TCP/IP</li>
    </ul>
  </li>
  <li><strong>1.2 HTTP 的历史与发展</strong>
    <ul>
      <li>HTTP/0.9：初始版本，只有 GET 方法</li>
      <li>HTTP/1.0：支持多种方法、状态码、头部</li>
      <li>HTTP/1.1：持久连接、管道化、分块传输</li>
      <li>HTTP/2：二进制协议、头部压缩、多路复用、服务器推送</li>
      <li>HTTP/3：基于 QUIC 协议，解决队头阻塞</li>
    </ul>
  </li>
  <li><strong>1.3 HTTP 的核心特性</strong>
    <ul>
      <li>无状态：每次请求独立</li>
      <li>可扩展：通过头部字段扩展功能</li>
      <li>客户端-服务器架构</li>
      <li>支持缓存</li>
      <li>支持中间人（代理、网关）</li>
    </ul>
  </li>
</ul>

<h2 id="二-http-消息结构">二、 HTTP 消息结构</h2>
<ul>
  <li><strong>2.1 HTTP 请求消息</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html
Accept-Language: en-US
</code></pre></div>    </div>
  </li>
  <li><strong>2.2 HTTP 响应消息</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>HTTP/1.1 200 OK
Date: Mon, 23 May 2022 22:38:34 GMT
Content-Type: text/html; charset=UTF-8
Content-Length: 138
Last-Modified: Wed, 08 Jan 2022 23:11:55 GMT
Server: Apache/1.3.3.7 (Unix) (Red-Hat/Linux)

&lt;html&gt;
&lt;body&gt;
&lt;h1&gt;Hello, World!&lt;/h1&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre></div>    </div>
  </li>
  <li><strong>2.3 消息组成部分</strong>
    <ul>
      <li>起始行（请求行/状态行）</li>
      <li>消息头部</li>
      <li>空行</li>
      <li>消息体</li>
    </ul>
  </li>
</ul>

<h2 id="三-http-方法">三、 HTTP 方法</h2>
<ul>
  <li><strong>3.1 安全方法</strong>
    <ul>
      <li>GET：获取资源</li>
      <li>HEAD：获取响应头</li>
      <li>OPTIONS：查询服务器支持的方法</li>
      <li>TRACE：追踪路径</li>
    </ul>
  </li>
  <li><strong>3.2 非安全方法</strong>
    <ul>
      <li>POST：提交数据</li>
      <li>PUT：替换资源</li>
      <li>DELETE：删除资源</li>
      <li>PATCH：局部更新资源</li>
    </ul>
  </li>
  <li><strong>3.3 方法特性</strong>
    <ul>
      <li>幂等性</li>
      <li>安全性</li>
      <li>可缓存性</li>
    </ul>
  </li>
  <li><strong>3.4 RESTful API 中的方法使用</strong></li>
</ul>

<h2 id="四-http-状态码">四、 HTTP 状态码</h2>
<ul>
  <li><strong>4.1 1xx 信息响应</strong>
    <ul>
      <li>100 Continue</li>
      <li>101 Switching Protocols</li>
    </ul>
  </li>
  <li><strong>4.2 2xx 成功响应</strong>
    <ul>
      <li>200 OK</li>
      <li>201 Created</li>
      <li>204 No Content</li>
      <li>206 Partial Content</li>
    </ul>
  </li>
  <li><strong>4.3 3xx 重定向</strong>
    <ul>
      <li>301 Moved Permanently</li>
      <li>302 Found</li>
      <li>304 Not Modified</li>
      <li>307 Temporary Redirect</li>
      <li>308 Permanent Redirect</li>
    </ul>
  </li>
  <li><strong>4.4 4xx 客户端错误</strong>
    <ul>
      <li>400 Bad Request</li>
      <li>401 Unauthorized</li>
      <li>403 Forbidden</li>
      <li>404 Not Found</li>
      <li>405 Method Not Allowed</li>
      <li>408 Request Timeout</li>
      <li>429 Too Many Requests</li>
    </ul>
  </li>
  <li><strong>4.5 5xx 服务器错误</strong>
    <ul>
      <li>500 Internal Server Error</li>
      <li>502 Bad Gateway</li>
      <li>503 Service Unavailable</li>
      <li>504 Gateway Timeout</li>
    </ul>
  </li>
</ul>

<h2 id="五-http-头部">五、 HTTP 头部</h2>
<ul>
  <li><strong>5.1 通用头部</strong>
    <ul>
      <li>Cache-Control</li>
      <li>Connection</li>
      <li>Date</li>
      <li>Transfer-Encoding</li>
    </ul>
  </li>
  <li><strong>5.2 请求头部</strong>
    <ul>
      <li>Accept</li>
      <li>Authorization</li>
      <li>Cookie</li>
      <li>Host</li>
      <li>Referer</li>
      <li>User-Agent</li>
    </ul>
  </li>
  <li><strong>5.3 响应头部</strong>
    <ul>
      <li>ETag</li>
      <li>Location</li>
      <li>Server</li>
      <li>Set-Cookie</li>
    </ul>
  </li>
  <li><strong>5.4 实体头部</strong>
    <ul>
      <li>Content-Type</li>
      <li>Content-Length</li>
      <li>Content-Encoding</li>
      <li>Last-Modified</li>
    </ul>
  </li>
  <li><strong>5.5 安全相关头部</strong>
    <ul>
      <li>Content-Security-Policy</li>
      <li>Strict-Transport-Security</li>
      <li>X-Content-Type-Options</li>
      <li>X-Frame-Options</li>
    </ul>
  </li>
</ul>

<h2 id="六-连接管理">六、 连接管理</h2>
<ul>
  <li><strong>6.1 HTTP/1.0 连接</strong>
    <ul>
      <li>短连接：每次请求建立新连接</li>
    </ul>
  </li>
  <li><strong>6.2 HTTP/1.1 连接</strong>
    <ul>
      <li>持久连接：Keep-Alive</li>
      <li>管道化</li>
    </ul>
  </li>
  <li><strong>6.3 HTTP/2 连接</strong>
    <ul>
      <li>二进制分帧</li>
      <li>多路复用</li>
      <li>服务器推送</li>
      <li>头部压缩</li>
    </ul>
  </li>
  <li><strong>6.4 HTTP/3 连接</strong>
    <ul>
      <li>基于 QUIC</li>
      <li>解决队头阻塞</li>
      <li>快速握手</li>
    </ul>
  </li>
  <li><strong>6.5 连接优化</strong>
    <ul>
      <li>域名分片</li>
      <li>长轮询</li>
      <li>WebSocket</li>
    </ul>
  </li>
</ul>

<h2 id="七-缓存机制">七、 缓存机制</h2>
<ul>
  <li><strong>7.1 缓存类型</strong>
    <ul>
      <li>私有缓存</li>
      <li>共享缓存</li>
    </ul>
  </li>
  <li><strong>7.2 缓存控制头部</strong>
    <ul>
      <li>Cache-Control</li>
      <li>Expires</li>
      <li>Pragma</li>
    </ul>
  </li>
  <li><strong>7.3 验证机制</strong>
    <ul>
      <li>Last-Modified / If-Modified-Since</li>
      <li>ETag / If-None-Match</li>
    </ul>
  </li>
  <li><strong>7.4 缓存策略</strong>
    <ul>
      <li>强缓存</li>
      <li>协商缓存</li>
      <li>缓存优先级</li>
    </ul>
  </li>
  <li><strong>7.5 清除缓存</strong>
    <ul>
      <li>版本化 URL</li>
      <li>强制刷新</li>
    </ul>
  </li>
</ul>

<h2 id="八-认证与安全">八、 认证与安全</h2>
<ul>
  <li><strong>8.1 基本认证</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Authorization: Basic dXNlcjpwYXNz
</code></pre></div>    </div>
  </li>
  <li><strong>8.2 摘要认证</strong></li>
  <li><strong>8.3 Bearer Token 认证</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
</code></pre></div>    </div>
  </li>
  <li><strong>8.4 OAuth 2.0</strong>
    <ul>
      <li>授权码模式</li>
      <li>客户端凭证模式</li>
      <li>密码模式</li>
      <li>简化模式</li>
    </ul>
  </li>
  <li><strong>8.5 HTTPS</strong>
    <ul>
      <li>SSL/TLS</li>
      <li>证书验证</li>
      <li>混合内容</li>
    </ul>
  </li>
  <li><strong>8.6 跨域资源共享</strong>
    <ul>
      <li>CORS 头部</li>
      <li>预检请求</li>
      <li>简单请求</li>
      <li>复杂请求</li>
    </ul>
  </li>
</ul>

<h2 id="九-cookie-与会话">九、 Cookie 与会话</h2>
<ul>
  <li><strong>9.1 Cookie 基础</strong>
    <ul>
      <li>Set-Cookie</li>
      <li>Cookie</li>
    </ul>
  </li>
  <li><strong>9.2 Cookie 属性</strong>
    <ul>
      <li>Domain</li>
      <li>Path</li>
      <li>Expires/Max-Age</li>
      <li>HttpOnly</li>
      <li>Secure</li>
      <li>SameSite</li>
    </ul>
  </li>
  <li><strong>9.3 会话管理</strong>
    <ul>
      <li>基于 Cookie 的会话</li>
      <li>基于 Token 的会话</li>
      <li>会话劫持防护</li>
    </ul>
  </li>
  <li><strong>9.4 会话存储</strong>
    <ul>
      <li>内存存储</li>
      <li>数据库存储</li>
      <li>Redis 存储</li>
    </ul>
  </li>
</ul>

<h2 id="十-数据格式与编码">十、 数据格式与编码</h2>
<ul>
  <li><strong>10.1 内容协商</strong>
    <ul>
      <li>Accept</li>
      <li>Accept-Encoding</li>
      <li>Accept-Language</li>
    </ul>
  </li>
  <li><strong>10.2 媒体类型</strong>
    <ul>
      <li>text/html</li>
      <li>application/json</li>
      <li>application/xml</li>
      <li>multipart/form-data</li>
    </ul>
  </li>
  <li><strong>10.3 传输编码</strong>
    <ul>
      <li>chunked</li>
      <li>gzip</li>
      <li>deflate</li>
      <li>br</li>
    </ul>
  </li>
  <li><strong>10.4 字符编码</strong>
    <ul>
      <li>charset=utf-8</li>
      <li>Content-Type 指定</li>
    </ul>
  </li>
</ul>

<h2 id="十一-状态管理">十一、 状态管理</h2>
<ul>
  <li><strong>11.1 无状态协议</strong>
    <ul>
      <li>状态的含义</li>
      <li>无状态的优点</li>
    </ul>
  </li>
  <li><strong>11.2 状态保持</strong>
    <ul>
      <li>Cookie</li>
      <li>URL 重写</li>
      <li>隐藏表单字段</li>
    </ul>
  </li>
  <li><strong>11.3 REST 的无状态约束</strong></li>
</ul>

<h2 id="十二-性能优化">十二、 性能优化</h2>
<ul>
  <li><strong>12.1 请求优化</strong>
    <ul>
      <li>减少请求数量</li>
      <li>使用雪碧图</li>
      <li>代码合并</li>
    </ul>
  </li>
  <li><strong>12.2 传输优化</strong>
    <ul>
      <li>启用压缩</li>
      <li>使用 CDN</li>
      <li>启用 HTTP/2</li>
    </ul>
  </li>
  <li><strong>12.3 缓存优化</strong>
    <ul>
      <li>合理设置缓存头</li>
      <li>使用 Service Worker</li>
    </ul>
  </li>
  <li><strong>12.4 资源优化</strong>
    <ul>
      <li>延迟加载</li>
      <li>预加载</li>
      <li>预连接</li>
    </ul>
  </li>
</ul>

<h2 id="十三-安全实践">十三、 安全实践</h2>
<ul>
  <li><strong>13.1 常见攻击</strong>
    <ul>
      <li>CSRF</li>
      <li>XSS</li>
      <li>点击劫持</li>
      <li>中间人攻击</li>
    </ul>
  </li>
  <li><strong>13.2 防御措施</strong>
    <ul>
      <li>CSRF Token</li>
      <li>Content Security Policy</li>
      <li>X-Frame-Options</li>
      <li>HTTP Strict Transport Security</li>
    </ul>
  </li>
  <li><strong>13.3 安全头部配置</strong>
    <ul>
      <li>完整的安全头部示例</li>
      <li>头部检测工具</li>
    </ul>
  </li>
</ul>

<h2 id="十四-工具与调试">十四、 工具与调试</h2>
<ul>
  <li><strong>14.1 命令行工具</strong>
    <ul>
      <li>curl</li>
      <li>telnet</li>
      <li>openssl</li>
    </ul>
  </li>
  <li><strong>14.2 图形化工具</strong>
    <ul>
      <li>Postman</li>
      <li>Insomnia</li>
      <li>HTTPie</li>
    </ul>
  </li>
  <li><strong>14.3 浏览器开发者工具</strong>
    <ul>
      <li>Network 面板</li>
      <li>查看请求/响应</li>
      <li>性能分析</li>
    </ul>
  </li>
  <li><strong>14.4 代理工具</strong>
    <ul>
      <li>Fiddler</li>
      <li>Charles</li>
      <li>Wireshark</li>
    </ul>
  </li>
  <li><strong>14.5 在线工具</strong>
    <ul>
      <li>Webhook 测试</li>
      <li>HTTP 状态码检查</li>
      <li>头部分析</li>
    </ul>
  </li>
</ul>

<h2 id="十五-协议扩展">十五、 协议扩展</h2>
<ul>
  <li><strong>15.1 WebDAV</strong>
    <ul>
      <li>方法扩展</li>
      <li>集合操作</li>
    </ul>
  </li>
  <li><strong>15.2 WebSocket</strong>
    <ul>
      <li>握手过程</li>
      <li>双向通信</li>
    </ul>
  </li>
  <li><strong>15.3 Server-Sent Events</strong>
    <ul>
      <li>服务器推送</li>
      <li>长连接</li>
    </ul>
  </li>
  <li><strong>15.4 HTTP/2 Push</strong>
    <ul>
      <li>服务器主动推送</li>
      <li>推送限制</li>
    </ul>
  </li>
</ul>

<h2 id="十六-restful-api-设计">十六、 RESTful API 设计</h2>
<ul>
  <li><strong>16.1 REST 原则</strong>
    <ul>
      <li>统一接口</li>
      <li>无状态</li>
      <li>可缓存</li>
      <li>客户端-服务器</li>
      <li>分层系统</li>
      <li>按需代码</li>
    </ul>
  </li>
  <li><strong>16.2 资源设计</strong>
    <ul>
      <li>资源标识</li>
      <li>资源操作</li>
      <li>版本管理</li>
    </ul>
  </li>
  <li><strong>16.3 错误处理</strong>
    <ul>
      <li>统一错误格式</li>
      <li>适当的 HTTP 状态码</li>
    </ul>
  </li>
  <li><strong>16.4 分页与过滤</strong>
    <ul>
      <li>分页参数</li>
      <li>过滤条件</li>
      <li>排序参数</li>
    </ul>
  </li>
  <li><strong>16.5 API 文档</strong>
    <ul>
      <li>OpenAPI/Swagger</li>
      <li>API Blueprint</li>
      <li>RAML</li>
    </ul>
  </li>
</ul>

<h2 id="十七-实战应用">十七、 实战应用</h2>
<ul>
  <li><strong>17.1 文件上传</strong>
    <ul>
      <li>multipart/form-data</li>
      <li>分块上传</li>
      <li>断点续传</li>
    </ul>
  </li>
  <li><strong>17.2 文件下载</strong>
    <ul>
      <li>Content-Disposition</li>
      <li>大文件下载</li>
      <li>流式下载</li>
    </ul>
  </li>
  <li><strong>17.3 实时通信</strong>
    <ul>
      <li>WebSocket</li>
      <li>Server-Sent Events</li>
      <li>长轮询</li>
    </ul>
  </li>
  <li><strong>17.4 反向代理</strong>
    <ul>
      <li>Nginx 配置</li>
      <li>负载均衡</li>
      <li>缓存代理</li>
    </ul>
  </li>
  <li><strong>17.5 API 网关</strong>
    <ul>
      <li>认证授权</li>
      <li>限流熔断</li>
      <li>监控日志</li>
    </ul>
  </li>
</ul>

<h2 id="十八-学习资源">十八、 学习资源</h2>
<ul>
  <li><strong>18.1 官方文档</strong>
    <ul>
      <li>RFC 文档</li>
      <li>MDN Web Docs</li>
    </ul>
  </li>
  <li><strong>18.2 在线课程</strong>
    <ul>
      <li>计算机网络相关课程</li>
      <li>Web 开发课程</li>
    </ul>
  </li>
  <li><strong>18.3 书籍推荐</strong>
    <ul>
      <li>《HTTP 权威指南》</li>
      <li>《图解 HTTP》</li>
    </ul>
  </li>
  <li><strong>18.4 实践项目</strong>
    <ul>
      <li>实现简单的 HTTP 服务器</li>
      <li>开发 RESTful API</li>
      <li>性能测试与优化</li>
    </ul>
  </li>
  <li><strong>18.5 社区资源</strong>
    <ul>
      <li>Stack Overflow</li>
      <li>GitHub 开源项目</li>
      <li>技术博客</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="HTTP" /><category term="HTTP" /><summary type="html"><![CDATA[HTTP 协议 系统学习大纲]]></summary></entry><entry><title type="html">Python相关</title><link href="https://xdh2580.github.io/python/Python/" rel="alternate" type="text/html" title="Python相关" /><published>2026-03-24T00:00:00+00:00</published><updated>2026-03-24T00:00:00+00:00</updated><id>https://xdh2580.github.io/python/Python</id><content type="html" xml:base="https://xdh2580.github.io/python/Python/"><![CDATA[<h1 id="python-编程语言-系统学习大纲">Python 编程语言 系统学习大纲</h1>

<h2 id="一-python-语言概述">一、 Python 语言概述</h2>
<ul>
  <li><strong>1.1 Python 简介</strong>
    <ul>
      <li>历史与发展：Guido van Rossum 创建，Python 2 和 Python 3</li>
      <li>设计哲学：简洁、易读、明确</li>
      <li>特点：解释型、动态类型、面向对象、跨平台</li>
      <li>应用领域：Web开发、数据分析、人工智能、自动化运维、科学计算</li>
    </ul>
  </li>
  <li><strong>1.2 Python 版本与生态系统</strong>
    <ul>
      <li>Python 2 与 Python 3 的主要区别</li>
      <li>CPython、Jython、IronPython、PyPy 解释器</li>
      <li>Python 包索引 (PyPI) 和 pip 包管理器</li>
    </ul>
  </li>
  <li><strong>1.3 开发环境搭建</strong>
    <ul>
      <li>安装 Python 解释器</li>
      <li>配置环境变量</li>
      <li>使用 IDLE</li>
      <li>安装和使用 pip</li>
      <li>虚拟环境：venv、virtualenv、conda</li>
      <li>开发工具：PyCharm、VS Code、Jupyter Notebook</li>
    </ul>
  </li>
</ul>

<h2 id="二-基础语法">二、 基础语法</h2>
<ul>
  <li><strong>2.1 第一个 Python 程序</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>print("Hello, World!")
</code></pre></div>    </div>
  </li>
  <li><strong>2.2 变量与数据类型</strong>
    <ul>
      <li>变量的定义与命名规则</li>
      <li>基本数据类型：
        <ul>
          <li>数字类型：int、float、complex</li>
          <li>布尔类型：bool</li>
          <li>字符串类型：str</li>
        </ul>
      </li>
      <li>类型检查与转换</li>
    </ul>
  </li>
  <li><strong>2.3 运算符</strong>
    <ul>
      <li>算术运算符：<code class="language-plaintext highlighter-rouge">+</code>、<code class="language-plaintext highlighter-rouge">-</code>、<code class="language-plaintext highlighter-rouge">*</code>、<code class="language-plaintext highlighter-rouge">/</code>、<code class="language-plaintext highlighter-rouge">//</code>、<code class="language-plaintext highlighter-rouge">%</code>、<code class="language-plaintext highlighter-rouge">**</code></li>
      <li>比较运算符：<code class="language-plaintext highlighter-rouge">==</code>、<code class="language-plaintext highlighter-rouge">!=</code>、<code class="language-plaintext highlighter-rouge">&gt;</code>、<code class="language-plaintext highlighter-rouge">&lt;</code>、<code class="language-plaintext highlighter-rouge">&gt;=</code>、<code class="language-plaintext highlighter-rouge">&lt;=</code></li>
      <li>赋值运算符：<code class="language-plaintext highlighter-rouge">=</code>、<code class="language-plaintext highlighter-rouge">+=</code>、<code class="language-plaintext highlighter-rouge">-=</code> 等</li>
      <li>逻辑运算符：<code class="language-plaintext highlighter-rouge">and</code>、<code class="language-plaintext highlighter-rouge">or</code>、<code class="language-plaintext highlighter-rouge">not</code></li>
      <li>位运算符：<code class="language-plaintext highlighter-rouge">&amp;</code>、<code class="language-plaintext highlighter-rouge">|</code>、<code class="language-plaintext highlighter-rouge">^</code>、<code class="language-plaintext highlighter-rouge">~</code>、<code class="language-plaintext highlighter-rouge">&lt;&lt;</code>、<code class="language-plaintext highlighter-rouge">&gt;&gt;</code></li>
      <li>成员运算符：<code class="language-plaintext highlighter-rouge">in</code>、<code class="language-plaintext highlighter-rouge">not in</code></li>
      <li>身份运算符：<code class="language-plaintext highlighter-rouge">is</code>、<code class="language-plaintext highlighter-rouge">is not</code></li>
    </ul>
  </li>
  <li><strong>2.4 输入与输出</strong>
    <ul>
      <li>输入函数：<code class="language-plaintext highlighter-rouge">input()</code></li>
      <li>输出函数：<code class="language-plaintext highlighter-rouge">print()</code></li>
      <li>格式化输出：<code class="language-plaintext highlighter-rouge">%</code> 格式化、<code class="language-plaintext highlighter-rouge">str.format()</code>、f-string
        <details>
          <summary>详情关于格式化输出</summary>

          <p><strong>一、格式化方法概览</strong></p>

          <table>
            <thead>
              <tr>
                <th>方法</th>
                <th>Python版本</th>
                <th>特点</th>
                <th>示例</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>%-格式化</td>
                <td>所有版本</td>
                <td>类似C语言printf，简单但功能有限</td>
                <td><code class="language-plaintext highlighter-rouge">"Name: %s, Age: %d" % ("Alice", 25)</code></td>
              </tr>
              <tr>
                <td>str.format()</td>
                <td>2.6+</td>
                <td>功能强大，支持位置、关键字、索引</td>
                <td><code class="language-plaintext highlighter-rouge">"Name: {}, Age: {}".format("Alice", 25)</code></td>
              </tr>
              <tr>
                <td>f-string</td>
                <td>3.6+</td>
                <td>语法简洁，性能好，推荐使用</td>
                <td><code class="language-plaintext highlighter-rouge">f"Name: {name}, Age: {age}"</code></td>
              </tr>
              <tr>
                <td>Template字符串</td>
                <td>所有版本</td>
                <td>安全，适合用户输入</td>
                <td><code class="language-plaintext highlighter-rouge">Template('Hello $name').substitute(name='Alice')</code></td>
              </tr>
            </tbody>
          </table>

          <p><strong>二、%-格式化（旧式格式化）</strong></p>
          <ul>
            <li>
              <p>基本格式说明符</p>

              <table>
                <thead>
                  <tr>
                    <th>格式符</th>
                    <th>说明</th>
                    <th>示例</th>
                    <th>输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>%s</td>
                    <td>字符串</td>
                    <td><code class="language-plaintext highlighter-rouge">"%s" % "hello"</code></td>
                    <td>hello</td>
                  </tr>
                  <tr>
                    <td>%d</td>
                    <td>十进制整数</td>
                    <td><code class="language-plaintext highlighter-rouge">"%d" % 42</code></td>
                    <td>42</td>
                  </tr>
                  <tr>
                    <td>%f</td>
                    <td>浮点数</td>
                    <td><code class="language-plaintext highlighter-rouge">"%.2f" % 3.14159</code></td>
                    <td>3.14</td>
                  </tr>
                  <tr>
                    <td>%e</td>
                    <td>科学计数法</td>
                    <td><code class="language-plaintext highlighter-rouge">"%.2e" % 1234.5678</code></td>
                    <td>1.23e+03</td>
                  </tr>
                  <tr>
                    <td>%x</td>
                    <td>十六进制整数</td>
                    <td><code class="language-plaintext highlighter-rouge">"%x" % 255</code></td>
                    <td>ff</td>
                  </tr>
                  <tr>
                    <td>%o</td>
                    <td>八进制整数</td>
                    <td><code class="language-plaintext highlighter-rouge">"%o" % 64</code></td>
                    <td>100</td>
                  </tr>
                  <tr>
                    <td>%%</td>
                    <td>百分号</td>
                    <td><code class="language-plaintext highlighter-rouge">"%.1f%%" % 99.5</code></td>
                    <td>99.5%</td>
                  </tr>
                </tbody>
              </table>
            </li>
            <li>
              <p>格式化控制参数</p>

              <table>
                <thead>
                  <tr>
                    <th>参数</th>
                    <th>含义</th>
                    <th>示例</th>
                    <th>输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>宽度</td>
                    <td>最小字段宽度</td>
                    <td><code class="language-plaintext highlighter-rouge">"%10s" % "hello"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">（前面五个空格）hello</code></td>
                  </tr>
                  <tr>
                    <td>精度</td>
                    <td>小数位数/最大字符数</td>
                    <td><code class="language-plaintext highlighter-rouge">"%.3f" % 3.14159</code></td>
                    <td>3.142</td>
                  </tr>
                  <tr>
                    <td>对齐</td>
                    <td>-左对齐，默认右对齐</td>
                    <td><code class="language-plaintext highlighter-rouge">"%-10s" % "hello"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">hello（后面五个空格）</code></td>
                  </tr>
                  <tr>
                    <td>填充</td>
                    <td>指定填充字符</td>
                    <td><code class="language-plaintext highlighter-rouge">"%010d" % 42</code></td>
                    <td>0000000042</td>
                  </tr>
                  <tr>
                    <td>符号</td>
                    <td>+强制显示符号</td>
                    <td><code class="language-plaintext highlighter-rouge">"%+d" % 42</code></td>
                    <td>+42</td>
                  </tr>
                  <tr>
                    <td>空格</td>
                    <td>正数前加空格</td>
                    <td><code class="language-plaintext highlighter-rouge">"% d" % 42</code></td>
                    <td>` 42`</td>
                  </tr>
                </tbody>
              </table>
            </li>
          </ul>

          <p><strong>三、str.format()方法</strong></p>

          <ul>
            <li>
              <p>基本语法对照表</p>

              <table>
                <thead>
                  <tr>
                    <th>类型</th>
                    <th>语法</th>
                    <th>示例</th>
                    <th>输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>位置参数</td>
                    <td><code class="language-plaintext highlighter-rouge">{}</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}, {}".format("A", "B")</code></td>
                    <td>A, B</td>
                  </tr>
                  <tr>
                    <td>索引参数</td>
                    <td><code class="language-plaintext highlighter-rouge">{0}</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{1}, {0}".format("A", "B")</code></td>
                    <td>B, A</td>
                  </tr>
                  <tr>
                    <td>关键字参数</td>
                    <td><code class="language-plaintext highlighter-rouge">{key}</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{name}, {age}".format(name="Alice", age=25)</code></td>
                    <td>Alice, 25</td>
                  </tr>
                  <tr>
                    <td>属性访问</td>
                    <td><code class="language-plaintext highlighter-rouge">{obj.attr}</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{0.name}".format(person)</code></td>
                    <td>Alice</td>
                  </tr>
                  <tr>
                    <td>下标访问</td>
                    <td><code class="language-plaintext highlighter-rouge">{list[0]}</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{0[0]}".format(lst)</code></td>
                    <td>1</td>
                  </tr>
                </tbody>
              </table>
            </li>
            <li>
              <p>格式控制语法</p>

              <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  # 完整格式: {[索引/键]:[[填充]对齐][符号][#][0][宽度][,][.精度][类型]}
</code></pre></div>              </div>

              <table>
                <thead>
                  <tr>
                    <th>控制项</th>
                    <th>语法</th>
                    <th>描述</th>
                    <th>示例</th>
                    <th>输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>对齐</td>
                    <td><code class="language-plaintext highlighter-rouge">&lt;</code>, <code class="language-plaintext highlighter-rouge">&gt;</code>, <code class="language-plaintext highlighter-rouge">^</code>, <code class="language-plaintext highlighter-rouge">=</code></td>
                    <td>左、右、居中、符号后填充</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:&gt;10}".format("test")</code></td>
                    <td><code class="language-plaintext highlighter-rouge">（前面6个空格）test</code></td>
                  </tr>
                  <tr>
                    <td>填充</td>
                    <td>任何字符</td>
                    <td>填充字符</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:*^10}".format("test")</code></td>
                    <td><code class="language-plaintext highlighter-rouge">***test***</code></td>
                  </tr>
                  <tr>
                    <td>符号</td>
                    <td><code class="language-plaintext highlighter-rouge">+</code>, <code class="language-plaintext highlighter-rouge">-</code>, 空格</td>
                    <td>显示符号</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:+}".format(42)</code></td>
                    <td>+42</td>
                  </tr>
                  <tr>
                    <td>宽度</td>
                    <td>数字</td>
                    <td>最小宽度</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:5}".format(42)</code></td>
                    <td><code class="language-plaintext highlighter-rouge">（前面三个空格）42</code></td>
                  </tr>
                  <tr>
                    <td>精度</td>
                    <td><code class="language-plaintext highlighter-rouge">.数字</code></td>
                    <td>小数位数/字符数</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.2f}".format(3.14159)</code></td>
                    <td>3.14</td>
                  </tr>
                  <tr>
                    <td>类型</td>
                    <td>s,d,f等</td>
                    <td>数据类型</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:d}".format(42)</code></td>
                    <td>42</td>
                  </tr>
                </tbody>
              </table>
            </li>
            <li>
              <p>类型说明符对照表</p>

              <table>
                <thead>
                  <tr>
                    <th>类型符</th>
                    <th>含义</th>
                    <th>示例</th>
                    <th>输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>s</td>
                    <td>字符串（默认）</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:s}".format("test")</code></td>
                    <td>test</td>
                  </tr>
                  <tr>
                    <td>d</td>
                    <td>十进制整数</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:d}".format(42)</code></td>
                    <td>42</td>
                  </tr>
                  <tr>
                    <td>b</td>
                    <td>二进制</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:b}".format(10)</code></td>
                    <td>1010</td>
                  </tr>
                  <tr>
                    <td>o</td>
                    <td>八进制</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:o}".format(10)</code></td>
                    <td>12</td>
                  </tr>
                  <tr>
                    <td>x</td>
                    <td>十六进制小写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:x}".format(255)</code></td>
                    <td>ff</td>
                  </tr>
                  <tr>
                    <td>X</td>
                    <td>十六进制大写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:X}".format(255)</code></td>
                    <td>FF</td>
                  </tr>
                  <tr>
                    <td>e</td>
                    <td>科学计数法小写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.2e}".format(1000)</code></td>
                    <td>1.00e+03</td>
                  </tr>
                  <tr>
                    <td>E</td>
                    <td>科学计数法大写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.2E}".format(1000)</code></td>
                    <td>1.00E+03</td>
                  </tr>
                  <tr>
                    <td>f</td>
                    <td>定点小数</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.2f}".format(3.14159)</code></td>
                    <td>3.14</td>
                  </tr>
                  <tr>
                    <td>F</td>
                    <td>定点小数大写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.2F}".format(float('inf'))</code></td>
                    <td>INF</td>
                  </tr>
                  <tr>
                    <td>g</td>
                    <td>通用格式</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:g}".format(1000)</code></td>
                    <td>1000</td>
                  </tr>
                  <tr>
                    <td>G</td>
                    <td>通用格式大写</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:G}".format(1000)</code></td>
                    <td>1000</td>
                  </tr>
                  <tr>
                    <td>%</td>
                    <td>百分比</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:.1%}".format(0.85)</code></td>
                    <td>85.0%</td>
                  </tr>
                  <tr>
                    <td>c</td>
                    <td>字符</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:c}".format(65)</code></td>
                    <td>A</td>
                  </tr>
                </tbody>
              </table>
            </li>
          </ul>

          <p><strong>四、f-string（格式化字符串字面值）</strong></p>

          <ul>
            <li>
              <p>基本用法对比</p>

              <table>
                <thead>
                  <tr>
                    <th>功能</th>
                    <th>f-string语法</th>
                    <th>等效的format()</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>变量</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{name}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format(name)</code></td>
                  </tr>
                  <tr>
                    <td>表达式</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{a + b}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format(a + b)</code></td>
                  </tr>
                  <tr>
                    <td>函数调用</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{name.upper()}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format(name.upper())</code></td>
                  </tr>
                  <tr>
                    <td>条件表达式</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{'偶数' if n%2==0 else '奇数'}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format('偶数' if n%2==0 else '奇数')</code></td>
                  </tr>
                  <tr>
                    <td>字典键</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{d['key']}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format(d['key'])</code></td>
                  </tr>
                  <tr>
                    <td>列表索引</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{lst[0]}"</code></td>
                    <td><code class="language-plaintext highlighter-rouge">"{}".format(lst[0])</code></td>
                  </tr>
                </tbody>
              </table>
            </li>
            <li>
              <p>格式控制示例</p>

              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 对齐和宽度
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="s">'hello'</span><span class="si">:</span><span class="o">&lt;</span><span class="mi">10</span><span class="si">}</span><span class="s">"</span>   <span class="c1"># 左对齐，宽度10
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="s">'hello'</span><span class="si">:</span><span class="o">&gt;</span><span class="mi">10</span><span class="si">}</span><span class="s">"</span>   <span class="c1"># 右对齐，宽度10
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="s">'hello'</span><span class="si">:</span><span class="o">^</span><span class="mi">10</span><span class="si">}</span><span class="s">"</span>   <span class="c1"># 居中对齐，宽度10
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="s">'hello'</span><span class="si">:</span><span class="o">*^</span><span class="mi">10</span><span class="si">}</span><span class="s">"</span>  <span class="c1"># 居中，宽度10，用*填充
</span>
  <span class="c1"># 数字格式化
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="mf">3.14159</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">"</span>   <span class="c1"># 保留2位小数
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="mi">1000</span><span class="si">:</span><span class="p">,.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">"</span>     <span class="c1"># 千位分隔符
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="mf">0.85</span><span class="si">:</span><span class="p">.</span><span class="mi">1</span><span class="o">%</span><span class="si">}</span><span class="s">"</span>      <span class="c1"># 百分比
</span>  <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="mi">255</span><span class="si">:</span><span class="c1">#x</span><span class="si">}</span><span class="s">"</span>        <span class="c1"># 带前缀的十六进制
</span></code></pre></div>              </div>
            </li>
            <li>
              <p>等号扩展（Python 3.8+）</p>

              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 调试输出变量名和值
</span>  <span class="n">x</span> <span class="o">=</span> <span class="mi">10</span>
  <span class="n">y</span> <span class="o">=</span> <span class="mi">20</span>
  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">x</span><span class="o">=</span><span class="si">}</span><span class="s">, </span><span class="si">{</span><span class="n">y</span><span class="o">=</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>  <span class="c1"># 输出: x=10, y=20
</span>  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="o">=</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>    <span class="c1"># 输出: x + y=30
</span></code></pre></div>              </div>
            </li>
          </ul>

          <p><strong>五、数字格式化特例</strong></p>

          <ul>
            <li>
              <p>千位分隔符对比</p>

              <table>
                <thead>
                  <tr>
                    <th>方法</th>
                    <th>语法</th>
                    <th>示例输出</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>%-格式化</td>
                    <td><code class="language-plaintext highlighter-rouge">"%,d"</code></td>
                    <td>不支持</td>
                  </tr>
                  <tr>
                    <td>format()</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:,}"</code></td>
                    <td>1,000,000</td>
                  </tr>
                  <tr>
                    <td>f-string</td>
                    <td><code class="language-plaintext highlighter-rouge">f"{value:,}"</code></td>
                    <td>1,000,000</td>
                  </tr>
                </tbody>
              </table>
            </li>
            <li>
              <p>不同进制输出</p>

              <table>
                <thead>
                  <tr>
                    <th>进制</th>
                    <th>format()</th>
                    <th>f-string</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td>二进制</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:b}".format(10)</code></td>
                    <td><code class="language-plaintext highlighter-rouge">f"{10:b}"</code></td>
                  </tr>
                  <tr>
                    <td>八进制</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:o}".format(10)</code></td>
                    <td><code class="language-plaintext highlighter-rouge">f"{10:o}"</code></td>
                  </tr>
                  <tr>
                    <td>十六进制</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:x}".format(255)</code></td>
                    <td><code class="language-plaintext highlighter-rouge">f"{255:x}"</code></td>
                  </tr>
                  <tr>
                    <td>带前缀</td>
                    <td><code class="language-plaintext highlighter-rouge">"{:#x}".format(255)</code></td>
                    <td><code class="language-plaintext highlighter-rouge">f"{255:#x}"</code></td>
                  </tr>
                </tbody>
              </table>
            </li>
          </ul>

          <p><strong>六、格式化选项对比表</strong></p>

          <table>
            <thead>
              <tr>
                <th>功能需求</th>
                <th>%-格式化</th>
                <th>str.format()</th>
                <th>f-string</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>简单替换</td>
                <td>✓ 简单</td>
                <td>✓ 较复杂</td>
                <td>✓ 最简单</td>
              </tr>
              <tr>
                <td>位置参数</td>
                <td>✓ 支持</td>
                <td>✓ 灵活</td>
                <td>✓ 支持</td>
              </tr>
              <tr>
                <td>关键字参数</td>
                <td>✗ 不支持</td>
                <td>✓ 支持</td>
                <td>✓ 支持</td>
              </tr>
              <tr>
                <td>表达式计算</td>
                <td>✗ 不支持</td>
                <td>✗ 不支持</td>
                <td>✓ 支持</td>
              </tr>
              <tr>
                <td>性能</td>
                <td>一般</td>
                <td>较慢</td>
                <td>最快</td>
              </tr>
              <tr>
                <td>可读性</td>
                <td>较差</td>
                <td>一般</td>
                <td>最好</td>
              </tr>
              <tr>
                <td>类型安全</td>
                <td>较差</td>
                <td>较好</td>
                <td>最好</td>
              </tr>
              <tr>
                <td>调试支持</td>
                <td>✗ 不支持</td>
                <td>✗ 不支持</td>
                <td>✓ Python 3.8+</td>
              </tr>
            </tbody>
          </table>

          <p><strong>七、高级格式化技巧</strong></p>

          <ul>
            <li>
              <p>日期时间格式化</p>

              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">datetime</span>
  <span class="n">now</span> <span class="o">=</span> <span class="n">datetime</span><span class="p">.</span><span class="n">now</span><span class="p">()</span>

  <span class="c1"># 各种方法的日期格式化
</span>  <span class="k">print</span><span class="p">(</span><span class="s">"%Y-%m-%d %H:%M:%S"</span> <span class="o">%</span> <span class="p">(</span><span class="n">now</span><span class="p">.</span><span class="n">year</span><span class="p">,</span> <span class="n">now</span><span class="p">.</span><span class="n">month</span><span class="p">,</span> <span class="n">now</span><span class="p">.</span><span class="n">day</span><span class="p">,</span> <span class="n">now</span><span class="p">.</span><span class="n">hour</span><span class="p">,</span> <span class="n">now</span><span class="p">.</span><span class="n">minute</span><span class="p">,</span> <span class="n">now</span><span class="p">.</span><span class="n">second</span><span class="p">))</span>
  <span class="k">print</span><span class="p">(</span><span class="s">"{:%Y-%m-%d %H:%M:%S}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">now</span><span class="p">))</span>
  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">now</span><span class="si">:</span><span class="o">%</span><span class="n">Y</span><span class="o">-%</span><span class="n">m</span><span class="o">-%</span><span class="n">d</span> <span class="o">%</span><span class="n">H</span><span class="si">:</span><span class="o">%</span><span class="n">M</span><span class="si">:</span><span class="o">%</span><span class="n">S</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

  <span class="c1"># 常用日期格式符
</span>  <span class="c1"># %Y: 四位数年份 %y: 两位数年份
</span>  <span class="c1"># %m: 月份(01-12) %B: 月份全名
</span>  <span class="c1"># %d: 日(01-31) %A: 星期全名
</span></code></pre></div>              </div>
            </li>
            <li>
              <p>嵌套格式化</p>

              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># format() 嵌套
</span>  <span class="n">width</span> <span class="o">=</span> <span class="mi">10</span>
  <span class="n">precision</span> <span class="o">=</span> <span class="mi">2</span>
  <span class="n">value</span> <span class="o">=</span> <span class="mf">12.3456</span>
  <span class="k">print</span><span class="p">(</span><span class="s">"{:{width}.{precision}f}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">width</span><span class="o">=</span><span class="n">width</span><span class="p">,</span> <span class="n">precision</span><span class="o">=</span><span class="n">precision</span><span class="p">))</span>

  <span class="c1"># f-string 嵌套
</span>  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">value</span><span class="si">:{</span><span class="n">width</span><span class="si">}</span><span class="p">.</span><span class="si">{</span><span class="n">precision</span><span class="si">}</span><span class="n">f</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
</code></pre></div>              </div>
            </li>
            <li>
              <p>自定义格式化</p>

              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">class</span> <span class="nc">Person</span><span class="p">:</span>
      <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">age</span><span class="p">):</span>
          <span class="bp">self</span><span class="p">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
          <span class="bp">self</span><span class="p">.</span><span class="n">age</span> <span class="o">=</span> <span class="n">age</span>
                
      <span class="k">def</span> <span class="nf">__format__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">format_spec</span><span class="p">):</span>
          <span class="k">if</span> <span class="n">format_spec</span> <span class="o">==</span> <span class="s">"long"</span><span class="p">:</span>
              <span class="k">return</span> <span class="sa">f</span><span class="s">"Person(name=</span><span class="si">{</span><span class="bp">self</span><span class="p">.</span><span class="n">name</span><span class="si">}</span><span class="s">, age=</span><span class="si">{</span><span class="bp">self</span><span class="p">.</span><span class="n">age</span><span class="si">}</span><span class="s">)"</span>
          <span class="k">elif</span> <span class="n">format_spec</span> <span class="o">==</span> <span class="s">"short"</span><span class="p">:</span>
              <span class="k">return</span> <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="bp">self</span><span class="p">.</span><span class="n">name</span><span class="si">}</span><span class="s">(</span><span class="si">{</span><span class="bp">self</span><span class="p">.</span><span class="n">age</span><span class="si">}</span><span class="s">)"</span>
          <span class="k">else</span><span class="p">:</span>
              <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

  <span class="n">p</span> <span class="o">=</span> <span class="n">Person</span><span class="p">(</span><span class="s">"Alice"</span><span class="p">,</span> <span class="mi">25</span><span class="p">)</span>
  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">p</span><span class="si">:</span><span class="nb">long</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>   <span class="c1"># Person(name=Alice, age=25)
</span>  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">p</span><span class="si">:</span><span class="n">short</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>  <span class="c1"># Alice(25)
</span></code></pre></div>              </div>
            </li>
          </ul>

          <p><strong>八、最佳实践建议</strong></p>

          <table>
            <thead>
              <tr>
                <th>场景</th>
                <th>推荐方法</th>
                <th>理由</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>Python 3.6+ 新项目</td>
                <td>f-string</td>
                <td>语法简洁，性能好，可读性强</td>
              </tr>
              <tr>
                <td>需要兼容旧版本</td>
                <td>str.format()</td>
                <td>功能强大，兼容性好</td>
              </tr>
              <tr>
                <td>简单临时输出</td>
                <td>print() 直接打印</td>
                <td>快速调试</td>
              </tr>
              <tr>
                <td>用户输入模板</td>
                <td>string.Template</td>
                <td>安全性高，防止注入</td>
              </tr>
              <tr>
                <td>C语言背景开发者</td>
                <td>%-格式化</td>
                <td>熟悉度高，但建议迁移</td>
              </tr>
            </tbody>
          </table>

          <ul>
            <li>代码示例汇总
              <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 各种方法的完整示例
</span>  <span class="n">name</span> <span class="o">=</span> <span class="s">"Alice"</span>
  <span class="n">age</span> <span class="o">=</span> <span class="mi">25</span>
  <span class="n">height</span> <span class="o">=</span> <span class="mf">1.68</span>
  <span class="n">salary</span> <span class="o">=</span> <span class="mf">50000.50</span>

  <span class="c1"># 1. %-格式化
</span>  <span class="k">print</span><span class="p">(</span><span class="s">"Name: %s, Age: %d, Height: %.2f"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">age</span><span class="p">,</span> <span class="n">height</span><span class="p">))</span>

  <span class="c1"># 2. str.format()
</span>  <span class="k">print</span><span class="p">(</span><span class="s">"Name: {0}, Age: {1}, Salary: {2:,.2f}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">age</span><span class="p">,</span> <span class="n">salary</span><span class="p">))</span>
  <span class="k">print</span><span class="p">(</span><span class="s">"Name: {name}, Age: {age}, Salary: {salary:,.2f}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span>
      <span class="n">name</span><span class="o">=</span><span class="n">name</span><span class="p">,</span> <span class="n">age</span><span class="o">=</span><span class="n">age</span><span class="p">,</span> <span class="n">salary</span><span class="o">=</span><span class="n">salary</span><span class="p">))</span>

  <span class="c1"># 3. f-string (推荐)
</span>  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Name: </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">, Age: </span><span class="si">{</span><span class="n">age</span><span class="si">}</span><span class="s">, Salary: </span><span class="si">{</span><span class="n">salary</span><span class="si">:</span><span class="p">,.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
  <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"Name: </span><span class="si">{</span><span class="n">name</span><span class="si">:</span><span class="o">&lt;</span><span class="mi">10</span><span class="si">}</span><span class="s"> Age: </span><span class="si">{</span><span class="n">age</span><span class="si">:</span><span class="o">&gt;</span><span class="mi">3</span><span class="si">}</span><span class="s"> Height: </span><span class="si">{</span><span class="n">height</span><span class="si">:</span><span class="mf">6.2</span><span class="n">f</span><span class="si">}</span><span class="s">m"</span><span class="p">)</span>

  <span class="c1"># 4. 多行f-string
</span>  <span class="n">message</span> <span class="o">=</span> <span class="p">(</span>
      <span class="sa">f</span><span class="s">"个人信息：</span><span class="se">\n</span><span class="s">"</span>
      <span class="sa">f</span><span class="s">"  姓名：</span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="se">\n</span><span class="s">"</span>
      <span class="sa">f</span><span class="s">"  年龄：</span><span class="si">{</span><span class="n">age</span><span class="si">}</span><span class="se">\n</span><span class="s">"</span>
      <span class="sa">f</span><span class="s">"  身高：</span><span class="si">{</span><span class="n">height</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">m"</span>
  <span class="p">)</span>
</code></pre></div>              </div>
            </li>
          </ul>

          <p><strong>总结建议</strong></p>
          <ol>
            <li><strong>优先使用f-string</strong>（Python 3.6+），语法最简洁，性能最好</li>
            <li>需要兼容旧版本时使用<strong>str.format()</strong></li>
            <li>避免在新代码中使用<strong>%-格式化</strong>，除非维护旧代码</li>
            <li>处理用户提供的模板时考虑<strong>string.Template</strong>以保证安全</li>
            <li>复杂的格式化需求可结合多种方法使用</li>
          </ol>

        </details>
      </li>
      <li>文件输入输出基础</li>
    </ul>
  </li>
</ul>

<h2 id="三-流程控制">三、 流程控制</h2>
<ul>
  <li><strong>3.1 条件语句</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>if condition1:
    # 代码块1
elif condition2:
    # 代码块2
else:
    # 代码块3
</code></pre></div>    </div>
  </li>
  <li><strong>3.2 循环语句</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">while</code> 循环
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>while condition:
# 循环体
</code></pre></div>        </div>
      </li>
      <li><code class="language-plaintext highlighter-rouge">for</code> 循环
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>for item in iterable:
# 循环体
</code></pre></div>        </div>
      </li>
      <li><code class="language-plaintext highlighter-rouge">range()</code> 函数</li>
      <li>循环控制语句：<code class="language-plaintext highlighter-rouge">break</code>、<code class="language-plaintext highlighter-rouge">continue</code>、<code class="language-plaintext highlighter-rouge">pass</code></li>
      <li>循环的 <code class="language-plaintext highlighter-rouge">else</code> 子句</li>
    </ul>
  </li>
  <li><strong>3.3 异常处理</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">try</code>、<code class="language-plaintext highlighter-rouge">except</code>、<code class="language-plaintext highlighter-rouge">else</code>、<code class="language-plaintext highlighter-rouge">finally</code>
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>try:
# 可能引发异常的代码
except SomeException as e:
# 异常处理
else:
# 无异常时执行
finally:
# 无论是否异常都执行
</code></pre></div>        </div>
      </li>
      <li>常见内置异常类型</li>
      <li>抛出异常：<code class="language-plaintext highlighter-rouge">raise</code></li>
      <li>自定义异常</li>
    </ul>
  </li>
</ul>

<h2 id="四-数据结构">四、 数据结构</h2>
<ul>
  <li><strong>4.1 列表 (List)</strong>
    <ul>
      <li>创建：<code class="language-plaintext highlighter-rouge">[]</code> 或 <code class="language-plaintext highlighter-rouge">list()</code></li>
      <li>访问：索引、切片</li>
      <li>常用方法：<code class="language-plaintext highlighter-rouge">append()</code>、<code class="language-plaintext highlighter-rouge">extend()</code>、<code class="language-plaintext highlighter-rouge">insert()</code>、<code class="language-plaintext highlighter-rouge">remove()</code>、<code class="language-plaintext highlighter-rouge">pop()</code>、<code class="language-plaintext highlighter-rouge">sort()</code>、<code class="language-plaintext highlighter-rouge">reverse()</code></li>
      <li>列表推导式
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[x**2 for x in range(10) if x % 2 == 0]
</code></pre></div>        </div>
      </li>
    </ul>
    <details>
      <summary>详情关于列表</summary>

      <p>一、列表创建与基本操作</p>

      <table>
        <thead>
          <tr>
            <th>类别</th>
            <th>方法/操作</th>
            <th>描述</th>
            <th>示例</th>
            <th>结果</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>创建列表</td>
            <td><code class="language-plaintext highlighter-rouge">[]</code></td>
            <td>创建空列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst = []</code></td>
            <td><code class="language-plaintext highlighter-rouge">[]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">list()</code></td>
            <td>从可迭代对象创建</td>
            <td><code class="language-plaintext highlighter-rouge">list('abc')</code></td>
            <td><code class="language-plaintext highlighter-rouge">['a','b','c']</code></td>
          </tr>
          <tr>
            <td> </td>
            <td>列表推导式</td>
            <td>快速生成列表</td>
            <td><code class="language-plaintext highlighter-rouge">[x**2 for x in range(5)]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[0,1,4,9,16]</code></td>
          </tr>
          <tr>
            <td>索引访问</td>
            <td><code class="language-plaintext highlighter-rouge">lst[index]</code></td>
            <td>访问指定位置元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst[0]</code></td>
            <td>第一个元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">lst[-1]</code></td>
            <td>访问倒数第一个元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst[-1]</code></td>
            <td>最后一个元素</td>
          </tr>
          <tr>
            <td>切片操作</td>
            <td><code class="language-plaintext highlighter-rouge">lst[start:end]</code></td>
            <td>获取子列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst[1:4]</code></td>
            <td>索引1-3的元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">lst[start:end:step]</code></td>
            <td>带步长的切片</td>
            <td><code class="language-plaintext highlighter-rouge">lst[::2]</code></td>
            <td>每隔一个元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">lst[::-1]</code></td>
            <td>反转列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst[::-1]</code></td>
            <td>反向列表</td>
          </tr>
          <tr>
            <td>修改元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst[index] = value</code></td>
            <td>修改指定位置元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst[0] = 10</code></td>
            <td>修改第一个元素</td>
          </tr>
          <tr>
            <td> </td>
            <td>切片赋值</td>
            <td>修改子列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst[1:3] = [20,30]</code></td>
            <td>替换1-2位置元素</td>
          </tr>
        </tbody>
      </table>

      <p>二、列表常用方法</p>

      <table>
        <thead>
          <tr>
            <th>类别</th>
            <th>方法</th>
            <th>描述</th>
            <th>示例</th>
            <th>结果</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>添加元素</td>
            <td><code class="language-plaintext highlighter-rouge">append(x)</code></td>
            <td>末尾添加元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst.append(4)</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,2,3,4]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">insert(i, x)</code></td>
            <td>指定位置插入</td>
            <td><code class="language-plaintext highlighter-rouge">lst.insert(1, 10)</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,10,2,3]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">extend(iterable)</code></td>
            <td>合并列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst.extend([4,5])</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,2,3,4,5]</code></td>
          </tr>
          <tr>
            <td>删除元素</td>
            <td><code class="language-plaintext highlighter-rouge">remove(x)</code></td>
            <td>删除第一个匹配元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst.remove(2)</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,3]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">pop([i])</code></td>
            <td>删除并返回指定位置元素</td>
            <td><code class="language-plaintext highlighter-rouge">lst.pop(1)</code></td>
            <td>返回<code class="language-plaintext highlighter-rouge">2</code>，列表变<code class="language-plaintext highlighter-rouge">[1,3]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">clear()</code></td>
            <td>清空列表</td>
            <td><code class="language-plaintext highlighter-rouge">lst.clear()</code></td>
            <td><code class="language-plaintext highlighter-rouge">[]</code></td>
          </tr>
          <tr>
            <td>查找元素</td>
            <td><code class="language-plaintext highlighter-rouge">index(x)</code></td>
            <td>返回元素索引</td>
            <td><code class="language-plaintext highlighter-rouge">lst.index(2)</code></td>
            <td><code class="language-plaintext highlighter-rouge">1</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">count(x)</code></td>
            <td>统计元素出现次数</td>
            <td><code class="language-plaintext highlighter-rouge">lst.count(2)</code></td>
            <td><code class="language-plaintext highlighter-rouge">1</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">in</code> 操作符</td>
            <td>检查元素是否存在</td>
            <td><code class="language-plaintext highlighter-rouge">2 in lst</code></td>
            <td><code class="language-plaintext highlighter-rouge">True</code></td>
          </tr>
          <tr>
            <td>排序操作</td>
            <td><code class="language-plaintext highlighter-rouge">sort()</code></td>
            <td>原地排序</td>
            <td><code class="language-plaintext highlighter-rouge">lst.sort()</code></td>
            <td>升序排列</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">reverse()</code></td>
            <td>原地反转</td>
            <td><code class="language-plaintext highlighter-rouge">lst.reverse()</code></td>
            <td>反转列表</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">sorted()</code></td>
            <td>返回排序后的新列表</td>
            <td><code class="language-plaintext highlighter-rouge">sorted(lst)</code></td>
            <td>新排序列表</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">reversed()</code></td>
            <td>返回反转迭代器</td>
            <td><code class="language-plaintext highlighter-rouge">list(reversed(lst))</code></td>
            <td>新反转列表</td>
          </tr>
          <tr>
            <td>列表运算</td>
            <td><code class="language-plaintext highlighter-rouge">+</code></td>
            <td>列表连接</td>
            <td><code class="language-plaintext highlighter-rouge">[1,2] + [3,4]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,2,3,4]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">*</code></td>
            <td>列表重复</td>
            <td><code class="language-plaintext highlighter-rouge">[1,2] * 2</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1,2,1,2]</code></td>
          </tr>
          <tr>
            <td>列表复制</td>
            <td><code class="language-plaintext highlighter-rouge">copy()</code></td>
            <td>浅拷贝</td>
            <td><code class="language-plaintext highlighter-rouge">lst.copy()</code></td>
            <td>新列表对象</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">list()</code></td>
            <td>浅拷贝</td>
            <td><code class="language-plaintext highlighter-rouge">list(lst)</code></td>
            <td>新列表对象</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">[:]</code></td>
            <td>浅拷贝</td>
            <td><code class="language-plaintext highlighter-rouge">lst[:]</code></td>
            <td>新列表对象</td>
          </tr>
          <tr>
            <td>列表信息</td>
            <td><code class="language-plaintext highlighter-rouge">len()</code></td>
            <td>列表长度</td>
            <td><code class="language-plaintext highlighter-rouge">len(lst)</code></td>
            <td>元素个数</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">max()</code></td>
            <td>最大值</td>
            <td><code class="language-plaintext highlighter-rouge">max(lst)</code></td>
            <td>最大元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">min()</code></td>
            <td>最小值</td>
            <td><code class="language-plaintext highlighter-rouge">min(lst)</code></td>
            <td>最小元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">sum()</code></td>
            <td>元素求和</td>
            <td><code class="language-plaintext highlighter-rouge">sum(lst)</code></td>
            <td>所有元素和</td>
          </tr>
        </tbody>
      </table>

      <p>三、列表推导式与高级操作</p>

      <table>
        <thead>
          <tr>
            <th>类别</th>
            <th>语法</th>
            <th>描述</th>
            <th>示例</th>
            <th>结果</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>基本推导式</td>
            <td><code class="language-plaintext highlighter-rouge">[expr for x in iterable]</code></td>
            <td>对每个元素应用表达式</td>
            <td><code class="language-plaintext highlighter-rouge">[x*2 for x in [1,2,3]]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[2,4,6]</code></td>
          </tr>
          <tr>
            <td>带条件</td>
            <td><code class="language-plaintext highlighter-rouge">[expr for x in iterable if cond]</code></td>
            <td>筛选满足条件的元素</td>
            <td><code class="language-plaintext highlighter-rouge">[x for x in range(5) if x%2==0]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[0,2,4]</code></td>
          </tr>
          <tr>
            <td>嵌套循环</td>
            <td><code class="language-plaintext highlighter-rouge">[expr for x in A for y in B]</code></td>
            <td>嵌套循环</td>
            <td><code class="language-plaintext highlighter-rouge">[(x,y) for x in [1,2] for y in [3,4]]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[(1,3),(1,4),(2,3),(2,4)]</code></td>
          </tr>
          <tr>
            <td>条件表达式</td>
            <td><code class="language-plaintext highlighter-rouge">[expr1 if cond else expr2 for x in iterable]</code></td>
            <td>根据条件选择不同表达式</td>
            <td><code class="language-plaintext highlighter-rouge">[x if x&gt;0 else 0 for x in [-1,0,1]]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[0,0,1]</code></td>
          </tr>
          <tr>
            <td>嵌套列表推导式</td>
            <td><code class="language-plaintext highlighter-rouge">[[expr for y in iterable2] for x in iterable1]</code></td>
            <td>创建嵌套列表</td>
            <td><code class="language-plaintext highlighter-rouge">[[0 for _ in range(3)] for _ in range(2)]</code></td>
            <td><code class="language-plaintext highlighter-rouge">[[0,0,0],[0,0,0]]</code></td>
          </tr>
        </tbody>
      </table>

      <p>四、列表与迭代器</p>

      <table>
        <thead>
          <tr>
            <th>类别</th>
            <th>方法/函数</th>
            <th>描述</th>
            <th>示例</th>
            <th>结果</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>迭代</td>
            <td><code class="language-plaintext highlighter-rouge">for</code>循环</td>
            <td>遍历列表</td>
            <td><code class="language-plaintext highlighter-rouge">for x in lst: print(x)</code></td>
            <td>依次输出每个元素</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">enumerate()</code></td>
            <td>同时获取索引和值</td>
            <td><code class="language-plaintext highlighter-rouge">list(enumerate(['a','b']))</code></td>
            <td><code class="language-plaintext highlighter-rouge">[(0,'a'),(1,'b')]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">zip()</code></td>
            <td>并行迭代多个列表</td>
            <td><code class="language-plaintext highlighter-rouge">list(zip([1,2],['a','b']))</code></td>
            <td><code class="language-plaintext highlighter-rouge">[(1,'a'),(2,'b')]</code></td>
          </tr>
          <tr>
            <td>迭代器</td>
            <td><code class="language-plaintext highlighter-rouge">iter()</code></td>
            <td>获取迭代器</td>
            <td><code class="language-plaintext highlighter-rouge">it = iter(lst)</code></td>
            <td>列表迭代器</td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">next()</code></td>
            <td>获取下一个元素</td>
            <td><code class="language-plaintext highlighter-rouge">next(it)</code></td>
            <td>第一个元素</td>
          </tr>
          <tr>
            <td>函数式编程</td>
            <td><code class="language-plaintext highlighter-rouge">map()</code></td>
            <td>对每个元素应用函数</td>
            <td><code class="language-plaintext highlighter-rouge">list(map(str, [1,2,3]))</code></td>
            <td><code class="language-plaintext highlighter-rouge">['1','2','3']</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">filter()</code></td>
            <td>筛选满足条件的元素</td>
            <td><code class="language-plaintext highlighter-rouge">list(filter(lambda x:x&gt;0, [-1,0,1]))</code></td>
            <td><code class="language-plaintext highlighter-rouge">[1]</code></td>
          </tr>
          <tr>
            <td> </td>
            <td><code class="language-plaintext highlighter-rouge">reduce()</code></td>
            <td>累积计算</td>
            <td><code class="language-plaintext highlighter-rouge">from functools import reduce; reduce(lambda x,y:x+y, [1,2,3])</code></td>
            <td><code class="language-plaintext highlighter-rouge">6</code></td>
          </tr>
        </tbody>
      </table>

      <p>五、列表性能与最佳实践</p>

      <table>
        <thead>
          <tr>
            <th>建议</th>
            <th>原因</th>
            <th>好例子</th>
            <th>坏例子</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>使用<code class="language-plaintext highlighter-rouge">append()</code>添加元素</td>
            <td>O(1)时间复杂度</td>
            <td><code class="language-plaintext highlighter-rouge">lst.append(x)</code></td>
            <td><code class="language-plaintext highlighter-rouge">lst = lst + [x]</code></td>
          </tr>
          <tr>
            <td>使用列表推导式</td>
            <td>简洁高效</td>
            <td><code class="language-plaintext highlighter-rouge">[x**2 for x in range(10)]</code></td>
            <td>手动循环创建列表</td>
          </tr>
          <tr>
            <td>使用<code class="language-plaintext highlighter-rouge">in</code>检查成员</td>
            <td>清晰可读</td>
            <td><code class="language-plaintext highlighter-rouge">if x in lst:</code></td>
            <td>手动遍历检查</td>
          </tr>
          <tr>
            <td>避免在循环中修改列表</td>
            <td>可能导致意外结果</td>
            <td>创建新列表</td>
            <td>在循环中删除元素</td>
          </tr>
          <tr>
            <td>使用切片复制列表</td>
            <td>避免修改原列表</td>
            <td><code class="language-plaintext highlighter-rouge">new = lst[:]</code></td>
            <td><code class="language-plaintext highlighter-rouge">new = lst</code>（同一对象）</td>
          </tr>
          <tr>
            <td>排序时使用<code class="language-plaintext highlighter-rouge">key</code>参数</td>
            <td>灵活指定排序规则</td>
            <td><code class="language-plaintext highlighter-rouge">lst.sort(key=lambda x:x[1])</code></td>
            <td>手动实现排序逻辑</td>
          </tr>
          <tr>
            <td>使用<code class="language-plaintext highlighter-rouge">collections.deque</code>处理队列</td>
            <td>高效的两端操作</td>
            <td><code class="language-plaintext highlighter-rouge">from collections import deque</code></td>
            <td>用列表实现队列（pop(0)效率低）</td>
          </tr>
        </tbody>
      </table>

      <p>六、常见问题与解决方案</p>

      <table>
        <thead>
          <tr>
            <th>问题</th>
            <th>解决方案</th>
            <th>代码示例</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>列表去重</td>
            <td>使用<code class="language-plaintext highlighter-rouge">set</code>或字典</td>
            <td><code class="language-plaintext highlighter-rouge">list(set(lst))</code> 或 <code class="language-plaintext highlighter-rouge">list(dict.fromkeys(lst))</code></td>
          </tr>
          <tr>
            <td>展平嵌套列表</td>
            <td>使用列表推导式</td>
            <td><code class="language-plaintext highlighter-rouge">[item for sublist in lst for item in sublist]</code></td>
          </tr>
          <tr>
            <td>查找最大/最小元素索引</td>
            <td>使用<code class="language-plaintext highlighter-rouge">max</code>/<code class="language-plaintext highlighter-rouge">min</code>的<code class="language-plaintext highlighter-rouge">key</code>参数</td>
            <td><code class="language-plaintext highlighter-rouge">max_index = max(range(len(lst)), key=lst.__getitem__)</code></td>
          </tr>
          <tr>
            <td>按多个条件排序</td>
            <td>使用<code class="language-plaintext highlighter-rouge">sort</code>的<code class="language-plaintext highlighter-rouge">key</code>参数返回元组</td>
            <td><code class="language-plaintext highlighter-rouge">lst.sort(key=lambda x: (x[0], x[1]))</code></td>
          </tr>
          <tr>
            <td>分组操作</td>
            <td>使用<code class="language-plaintext highlighter-rouge">itertools.groupby</code></td>
            <td><code class="language-plaintext highlighter-rouge">from itertools import groupby; {k:list(v) for k,v in groupby(lst, key=func)}</code></td>
          </tr>
          <tr>
            <td>列表分块</td>
            <td>使用切片</td>
            <td><code class="language-plaintext highlighter-rouge">[lst[i:i+n] for i in range(0, len(lst), n)]</code></td>
          </tr>
          <tr>
            <td>合并多个列表</td>
            <td>使用<code class="language-plaintext highlighter-rouge">itertools.chain</code></td>
            <td><code class="language-plaintext highlighter-rouge">from itertools import chain; list(chain(list1, list2, list3))</code></td>
          </tr>
          <tr>
            <td>计算列表差异</td>
            <td>使用集合运算</td>
            <td><code class="language-plaintext highlighter-rouge">list(set(lst1) - set(lst2))</code></td>
          </tr>
        </tbody>
      </table>

      <p>七、性能注意事项</p>

      <table>
        <thead>
          <tr>
            <th>操作</th>
            <th>时间复杂度</th>
            <th>说明</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>索引访问 <code class="language-plaintext highlighter-rouge">lst[i]</code></td>
            <td>O(1)</td>
            <td>随机访问，常数时间</td>
          </tr>
          <tr>
            <td>追加元素 <code class="language-plaintext highlighter-rouge">append()</code></td>
            <td>O(1)</td>
            <td>平均情况，可能需要扩容</td>
          </tr>
          <tr>
            <td>插入元素 <code class="language-plaintext highlighter-rouge">insert()</code></td>
            <td>O(n)</td>
            <td>需要移动后续元素</td>
          </tr>
          <tr>
            <td>删除元素 <code class="language-plaintext highlighter-rouge">remove()</code>/<code class="language-plaintext highlighter-rouge">pop(i)</code></td>
            <td>O(n)</td>
            <td>需要移动元素</td>
          </tr>
          <tr>
            <td>成员检查 <code class="language-plaintext highlighter-rouge">x in lst</code></td>
            <td>O(n)</td>
            <td>需要遍历列表</td>
          </tr>
          <tr>
            <td>切片 <code class="language-plaintext highlighter-rouge">lst[i:j]</code></td>
            <td>O(k)</td>
            <td>k是切片长度</td>
          </tr>
          <tr>
            <td>排序 <code class="language-plaintext highlighter-rouge">sort()</code></td>
            <td>O(n log n)</td>
            <td>Timsort算法</td>
          </tr>
          <tr>
            <td>列表连接 <code class="language-plaintext highlighter-rouge">lst1 + lst2</code></td>
            <td>O(m+n)</td>
            <td>创建新列表，复制所有元素</td>
          </tr>
        </tbody>
      </table>

      <p>八、实用代码片段</p>
      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 1. 列表去重并保持顺序
</span><span class="k">def</span> <span class="nf">unique_preserve_order</span><span class="p">(</span><span class="n">lst</span><span class="p">):</span>
    <span class="n">seen</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">lst</span> <span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="n">x</span> <span class="ow">in</span> <span class="n">seen</span> <span class="ow">or</span> <span class="n">seen</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">x</span><span class="p">))]</span>

<span class="c1"># 2. 展平嵌套列表
</span><span class="k">def</span> <span class="nf">flatten</span><span class="p">(</span><span class="n">lst</span><span class="p">):</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">item</span> <span class="k">for</span> <span class="n">sublist</span> <span class="ow">in</span> <span class="n">lst</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="p">(</span><span class="n">sublist</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">sublist</span><span class="p">,</span> <span class="nb">list</span><span class="p">)</span> <span class="k">else</span> <span class="p">[</span><span class="n">sublist</span><span class="p">])]</span>

<span class="c1"># 3. 列表分块
</span><span class="k">def</span> <span class="nf">chunk_list</span><span class="p">(</span><span class="n">lst</span><span class="p">,</span> <span class="n">chunk_size</span><span class="p">):</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">lst</span><span class="p">[</span><span class="n">i</span><span class="p">:</span><span class="n">i</span><span class="o">+</span><span class="n">chunk_size</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">lst</span><span class="p">),</span> <span class="n">chunk_size</span><span class="p">)]</span>

<span class="c1"># 4. 查找出现次数最多的元素
</span><span class="k">def</span> <span class="nf">most_common</span><span class="p">(</span><span class="n">lst</span><span class="p">):</span>
    <span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">Counter</span>
    <span class="k">return</span> <span class="n">Counter</span><span class="p">(</span><span class="n">lst</span><span class="p">).</span><span class="n">most_common</span><span class="p">(</span><span class="mi">1</span><span class="p">)[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>

<span class="c1"># 5. 列表元素频率统计
</span><span class="k">def</span> <span class="nf">frequency_count</span><span class="p">(</span><span class="n">lst</span><span class="p">):</span>
    <span class="n">freq</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">lst</span><span class="p">:</span>
        <span class="n">freq</span><span class="p">[</span><span class="n">item</span><span class="p">]</span> <span class="o">=</span> <span class="n">freq</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="n">freq</span>

<span class="c1"># 6. 合并多个列表
</span><span class="k">def</span> <span class="nf">merge_lists</span><span class="p">(</span><span class="o">*</span><span class="n">lists</span><span class="p">):</span>
    <span class="kn">from</span> <span class="nn">itertools</span> <span class="kn">import</span> <span class="n">chain</span>
    <span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="n">chain</span><span class="p">(</span><span class="o">*</span><span class="n">lists</span><span class="p">))</span>

<span class="c1"># 7. 列表元素分组
</span><span class="k">def</span> <span class="nf">group_by_key</span><span class="p">(</span><span class="n">lst</span><span class="p">,</span> <span class="n">key_func</span><span class="p">):</span>
    <span class="n">grouped</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">lst</span><span class="p">:</span>
        <span class="n">key</span> <span class="o">=</span> <span class="n">key_func</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
        <span class="n">grouped</span><span class="p">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">[]).</span><span class="n">append</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">grouped</span>
</code></pre></div>      </div>
      <p>九、最佳实践总结</p>

      <ol>
        <li><strong>选择合适的数据结构</strong>：列表适合有序、可重复的集合，需要快速随机访问</li>
        <li><strong>注意性能特征</strong>：了解常见操作的时间复杂度，避免在大列表上频繁使用O(n)操作</li>
        <li><strong>使用列表推导式</strong>：简洁高效，Pythonic风格</li>
        <li><strong>避免在循环中修改列表</strong>：如需修改，考虑创建新列表或使用倒序遍历</li>
        <li><strong>合理使用切片</strong>：复制、反转、获取子列表的利器</li>
        <li><strong>善用内置函数和方法</strong>：Python提供了丰富的列表操作方法</li>
        <li><strong>考虑使用其他数据结构</strong>：
          <ul>
            <li>频繁插入/删除：考虑<code class="language-plaintext highlighter-rouge">collections.deque</code></li>
            <li>快速成员检查：考虑<code class="language-plaintext highlighter-rouge">set</code></li>
            <li>键值对：考虑<code class="language-plaintext highlighter-rouge">dict</code></li>
          </ul>
        </li>
      </ol>

      <p><strong>Python列表是动态数组，支持任意类型的元素，是Python中最灵活、最常用的数据结构之一。掌握列表的操作和特性，是编写高效Python代码的基础。</strong></p>

    </details>
  </li>
  <li><strong>4.2 元组 (Tuple)</strong>
    <ul>
      <li>创建：<code class="language-plaintext highlighter-rouge">()</code> 或 <code class="language-plaintext highlighter-rouge">tuple()</code></li>
      <li>不可变性</li>
      <li>元组拆包</li>
    </ul>
    <details>
      <summary>详情关于元组</summary>
      <p>一、元组基础</p>

      <ul>
        <li>什么是元组？
          <ul>
            <li><strong>不可变</strong>的有序序列</li>
            <li>一旦创建，<strong>不能修改、添加或删除元素</strong></li>
            <li>用圆括号 <code class="language-plaintext highlighter-rouge">()</code> 表示</li>
            <li>支持任意类型的元素</li>
          </ul>
        </li>
        <li>元组的特点
  | 特性 | 说明 |
  |——|——|
  | 不可变性 | 创建后不能修改元素（但可包含可变元素） |
  | 有序性 | 元素有固定顺序，可通过索引访问 |
  | 可哈希性 | 不可变元组可用作字典键 |
  | 内存效率 | 比列表占用更少内存 |
  | 性能优势 | 某些操作比列表更快 |</li>
      </ul>

      <p>二、元组创建</p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 创建空元组
</span><span class="n">t1</span> <span class="o">=</span> <span class="p">()</span>
<span class="n">t2</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">()</span>

<span class="c1"># 单元素元组（必须加逗号）
</span><span class="n">t3</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,)</span>
<span class="n">t4</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span>  <span class="c1"># 括号可选，但推荐加括号
</span>
<span class="c1"># 多元素元组
</span><span class="n">t5</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="n">t6</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span>  <span class="c1"># 括号可选
</span>
<span class="c1"># 从可迭代对象创建
</span><span class="n">t7</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>  <span class="c1"># 从列表
</span><span class="n">t8</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="s">"abc"</span><span class="p">)</span>      <span class="c1"># 从字符串 → ('a', 'b', 'c')
</span></code></pre></div>      </div>

      <p>三、元组基本操作</p>

      <ul>
        <li>访问元素
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">50</span><span class="p">)</span>

  <span class="c1"># 索引访问
</span>  <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>    <span class="c1"># 10
</span>  <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>   <span class="c1"># 50 (倒数第一个)
</span>
  <span class="c1"># 切片操作
</span>  <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">4</span><span class="p">])</span>   <span class="c1"># (20, 30, 40)
</span>  <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">[::</span><span class="mi">2</span><span class="p">])</span>   <span class="c1"># (10, 30, 50) 步长为2
</span>  <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">[::</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>  <span class="c1"># (50, 40, 30, 20, 10) 反转
</span></code></pre></div>          </div>
        </li>
        <li>元组操作
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 连接
</span>  <span class="n">t1</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
  <span class="n">t2</span> <span class="o">=</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
  <span class="n">t3</span> <span class="o">=</span> <span class="n">t1</span> <span class="o">+</span> <span class="n">t2</span>  <span class="c1"># (1, 2, 3, 4)
</span>
  <span class="c1"># 重复
</span>  <span class="n">t4</span> <span class="o">=</span> <span class="n">t1</span> <span class="o">*</span> <span class="mi">3</span>  <span class="c1"># (1, 2, 1, 2, 1, 2)
</span>
  <span class="c1"># 成员检查
</span>  <span class="k">print</span><span class="p">(</span><span class="mi">2</span> <span class="ow">in</span> <span class="n">t1</span><span class="p">)</span>  <span class="c1"># True
</span>  <span class="k">print</span><span class="p">(</span><span class="mi">5</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">t1</span><span class="p">)</span>  <span class="c1"># True
</span>
  <span class="c1"># 长度
</span>  <span class="k">print</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t1</span><span class="p">))</span>  <span class="c1"># 2
</span></code></pre></div>          </div>
        </li>
      </ul>

      <p>四、元组方法（只有2个）</p>

      <table>
        <thead>
          <tr>
            <th>方法</th>
            <th>描述</th>
            <th>示例</th>
            <th>结果</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">count(x)</code></td>
            <td>统计元素x出现次数</td>
            <td><code class="language-plaintext highlighter-rouge">(1,2,2,3).count(2)</code></td>
            <td><code class="language-plaintext highlighter-rouge">2</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">index(x)</code></td>
            <td>返回元素x首次出现的索引</td>
            <td><code class="language-plaintext highlighter-rouge">(1,2,3,2).index(2)</code></td>
            <td><code class="language-plaintext highlighter-rouge">1</code></td>
          </tr>
        </tbody>
      </table>

      <p>五、元组解包</p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 基本解包
</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span><span class="p">)</span>  <span class="c1"># 1 2 3
</span>
<span class="c1"># 星号解包
</span><span class="n">a</span><span class="p">,</span> <span class="o">*</span><span class="n">b</span><span class="p">,</span> <span class="n">c</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span>  <span class="c1"># 1 [2, 3, 4] 5
</span>
<span class="c1"># 交换变量
</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">y</span><span class="p">,</span> <span class="n">x</span>
<span class="k">print</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>  <span class="c1"># 2 1
</span>
<span class="c1"># 函数返回多个值
</span><span class="k">def</span> <span class="nf">get_stats</span><span class="p">(</span><span class="n">numbers</span><span class="p">):</span>
    <span class="k">return</span> <span class="nb">min</span><span class="p">(</span><span class="n">numbers</span><span class="p">),</span> <span class="nb">max</span><span class="p">(</span><span class="n">numbers</span><span class="p">),</span> <span class="nb">sum</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span>

<span class="n">minimum</span><span class="p">,</span> <span class="n">maximum</span><span class="p">,</span> <span class="n">average</span> <span class="o">=</span> <span class="n">get_stats</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>
</code></pre></div>      </div>

      <p>六、命名元组</p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">namedtuple</span>

<span class="c1"># 定义命名元组类型
</span><span class="n">Point</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s">'Point'</span><span class="p">,</span> <span class="p">[</span><span class="s">'x'</span><span class="p">,</span> <span class="s">'y'</span><span class="p">])</span>
<span class="n">Color</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s">'Color'</span><span class="p">,</span> <span class="s">'red green blue'</span><span class="p">)</span>  <span class="c1"># 也可以传字符串
</span>
<span class="c1"># 创建实例
</span><span class="n">p1</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">)</span>
<span class="n">p2</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">15</span><span class="p">)</span>

<span class="c1"># 访问字段
</span><span class="k">print</span><span class="p">(</span><span class="n">p1</span><span class="p">.</span><span class="n">x</span><span class="p">,</span> <span class="n">p1</span><span class="p">.</span><span class="n">y</span><span class="p">)</span>  <span class="c1"># 10 20
</span><span class="k">print</span><span class="p">(</span><span class="n">p1</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">p1</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>  <span class="c1"># 10 20 (也可以用索引)
</span>
<span class="c1"># 命名元组方法
</span><span class="k">print</span><span class="p">(</span><span class="n">Point</span><span class="p">.</span><span class="n">_fields</span><span class="p">)</span>  <span class="c1"># ('x', 'y')
</span><span class="k">print</span><span class="p">(</span><span class="n">p1</span><span class="p">.</span><span class="n">_asdict</span><span class="p">())</span>   <span class="c1"># {'x': 10, 'y': 20}
</span><span class="k">print</span><span class="p">(</span><span class="n">p1</span><span class="p">.</span><span class="n">_replace</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">100</span><span class="p">))</span>  <span class="c1"># Point(x=100, y=20)
</span></code></pre></div>      </div>

      <p>七、元组 vs 列表</p>

      <table>
        <thead>
          <tr>
            <th>对比项</th>
            <th>元组</th>
            <th>列表</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>可变性</td>
            <td>❌ 不可变</td>
            <td>✅ 可变</td>
          </tr>
          <tr>
            <td>语法</td>
            <td>圆括号 <code class="language-plaintext highlighter-rouge">()</code></td>
            <td>方括号 <code class="language-plaintext highlighter-rouge">[]</code></td>
          </tr>
          <tr>
            <td>性能</td>
            <td>创建和访问更快</td>
            <td>修改操作更多</td>
          </tr>
          <tr>
            <td>内存占用</td>
            <td>较少</td>
            <td>较多</td>
          </tr>
          <tr>
            <td>使用场景</td>
            <td>数据记录、字典键</td>
            <td>动态集合</td>
          </tr>
          <tr>
            <td>方法数量</td>
            <td>2个</td>
            <td>11+个</td>
          </tr>
          <tr>
            <td>哈希性</td>
            <td>✅ 可哈希</td>
            <td>❌ 不可哈希</td>
          </tr>
        </tbody>
      </table>

      <p>八、实用技巧</p>

      <ol>
        <li>元组作为字典键
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="c1"># 元组可哈希，可作为字典键
</span> <span class="n">points</span> <span class="o">=</span> <span class="p">{</span>
     <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">):</span> <span class="s">"原点"</span><span class="p">,</span>
     <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">):</span> <span class="s">"X轴上"</span><span class="p">,</span>
     <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">):</span> <span class="s">"Y轴上"</span>
 <span class="p">}</span>
 <span class="k">print</span><span class="p">(</span><span class="n">points</span><span class="p">[(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">)])</span>  <span class="c1"># "X轴上"
</span></code></pre></div>          </div>
        </li>
        <li>元组包含可变对象
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="c1"># 元组不可变，但元素可以是可变对象
</span> <span class="n">t</span> <span class="o">=</span> <span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
 <span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="n">append</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>  <span class="c1"># 可以修改元组中的列表
</span> <span class="k">print</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>  <span class="c1"># ([1, 2, 3], [3, 4])
</span> <span class="c1"># t[0] = [5, 6]  # 错误！不能替换整个元素
</span></code></pre></div>          </div>
        </li>
        <li>元组推导式
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="c1"># 元组推导式返回的是生成器
</span> <span class="n">gen</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>
 <span class="n">t</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">gen</span><span class="p">)</span>  <span class="c1"># 转为元组: (0, 1, 4, 9, 16)
</span></code></pre></div>          </div>
        </li>
      </ol>

      <p>九、最佳实践</p>

      <ul>
        <li><strong>何时使用元组</strong>：
          <ul>
            <li>数据不应该被修改时</li>
            <li>用作字典键</li>
            <li>函数返回多个值</li>
            <li>保证数据安全</li>
          </ul>
        </li>
        <li><strong>何时使用列表</strong>：
          <ul>
            <li>需要频繁修改数据</li>
            <li>需要排序、添加、删除等操作</li>
            <li>数据集合大小会变化</li>
          </ul>
        </li>
        <li><strong>性能考虑</strong>：
          <ul>
            <li>元组创建和访问更快</li>
            <li>元组内存占用更小</li>
            <li>大量只读数据时用元组</li>
          </ul>
        </li>
        <li><strong>可读性</strong>：
          <ul>
            <li>命名元组提高代码可读性</li>
            <li>元组解包使代码更简洁</li>
            <li>使用合适的命名表示数据含义</li>
          </ul>
        </li>
      </ul>

      <p>十、常见误区</p>

      <ol>
        <li><strong>单元素元组必须加逗号</strong>：<code class="language-plaintext highlighter-rouge">(1,)</code> 不是 <code class="language-plaintext highlighter-rouge">(1)</code></li>
        <li><strong>元组不可变</strong>：但可以包含可变对象</li>
        <li><strong>元组方法少</strong>：只有 <code class="language-plaintext highlighter-rouge">count()</code> 和 <code class="language-plaintext highlighter-rouge">index()</code></li>
        <li><strong>元组推导式</strong>：实际返回生成器，需用 <code class="language-plaintext highlighter-rouge">tuple()</code> 转换</li>
      </ol>

    </details>
  </li>
  <li><strong>4.3 集合 (Set)</strong>
    <ul>
      <li>创建：<code class="language-plaintext highlighter-rouge">{}</code> 或 <code class="language-plaintext highlighter-rouge">set()</code></li>
      <li>无序、不重复</li>
      <li>集合运算：并集、交集、差集、对称差集</li>
      <li>集合推导式</li>
    </ul>
    <details>
      <summary>详情关于集合</summary>

      <p><strong>一、集合基础</strong></p>

      <ul>
        <li>什么是集合？
          <ul>
            <li><strong>无序</strong>的唯一元素集合</li>
            <li>用花括号 <code class="language-plaintext highlighter-rouge">{}</code> 表示，但空集合用 <code class="language-plaintext highlighter-rouge">set()</code></li>
            <li>元素必须是<strong>可哈希的</strong>（不可变类型）</li>
            <li>支持数学集合运算</li>
          </ul>
        </li>
        <li>
          <p>集合的特点</p>

          <table>
            <thead>
              <tr>
                <th>特性</th>
                <th>说明</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>无序性</td>
                <td>元素没有固定顺序</td>
              </tr>
              <tr>
                <td>唯一性</td>
                <td>自动去重，每个元素只出现一次</td>
              </tr>
              <tr>
                <td>可哈希性</td>
                <td>元素必须是不可变类型</td>
              </tr>
              <tr>
                <td>高效查找</td>
                <td>成员检查为 O(1) 时间复杂度</td>
              </tr>
              <tr>
                <td>可变性</td>
                <td>集合本身可变，但元素必须不可变</td>
              </tr>
            </tbody>
          </table>
        </li>
      </ul>

      <p><strong>二、集合创建</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 创建空集合（不能用 {}，那是空字典）
</span><span class="n">empty_set</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>

<span class="c1"># 从列表创建
</span><span class="n">set1</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">}</span>  <span class="c1"># 自动去重：{1, 2, 3}
</span><span class="n">set2</span> <span class="o">=</span> <span class="nb">set</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>  <span class="c1"># 从列表：{1, 2, 3, 4}
</span>
<span class="c1"># 从字符串创建（获取唯一字符）
</span><span class="n">char_set</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="s">"hello"</span><span class="p">)</span>  <span class="c1"># {'h', 'e', 'l', 'o'}
</span>
<span class="c1"># 集合推导式
</span><span class="n">square_set</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">)}</span>  <span class="c1"># {0, 1, 4, 9, 16}
</span></code></pre></div>      </div>

      <p><strong>三、集合基本操作</strong></p>

      <ul>
        <li>增删元素
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="n">s</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">}</span>

  <span class="c1"># 添加元素
</span>  <span class="n">s</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>          <span class="c1"># {1, 2, 3, 4}
</span>  <span class="n">s</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>          <span class="c1"># 已存在，不变
</span>
  <span class="c1"># 添加多个元素
</span>  <span class="n">s</span><span class="p">.</span><span class="n">update</span><span class="p">([</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">])</span>  <span class="c1"># {1, 2, 3, 4, 5, 6, 7}
</span>  <span class="n">s</span><span class="p">.</span><span class="n">update</span><span class="p">({</span><span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">})</span>     <span class="c1"># 也可以从其他集合添加
</span>
  <span class="c1"># 删除元素
</span>  <span class="n">s</span><span class="p">.</span><span class="n">remove</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>       <span class="c1"># 移除3，如果不存在则报错
</span>  <span class="n">s</span><span class="p">.</span><span class="n">discard</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>     <span class="c1"># 移除10，不存在也不报错
</span>  <span class="n">s</span><span class="p">.</span><span class="n">pop</span><span class="p">()</span>           <span class="c1"># 随机移除一个元素并返回
</span>  <span class="n">s</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>         <span class="c1"># 清空集合
</span></code></pre></div>          </div>
        </li>
        <li>查询操作
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="n">s</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">}</span>

  <span class="c1"># 成员检查
</span>  <span class="k">print</span><span class="p">(</span><span class="mi">3</span> <span class="ow">in</span> <span class="n">s</span><span class="p">)</span>     <span class="c1"># True
</span>  <span class="k">print</span><span class="p">(</span><span class="mi">6</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">s</span><span class="p">)</span> <span class="c1"># True
</span>
  <span class="c1"># 长度
</span>  <span class="k">print</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">))</span>     <span class="c1"># 5
</span>
  <span class="c1"># 遍历
</span>  <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
      <span class="k">print</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>   <span class="c1"># 顺序不确定
</span></code></pre></div>          </div>
        </li>
      </ul>

      <p><strong>四、集合运算</strong></p>

      <table>
        <thead>
          <tr>
            <th>运算</th>
            <th>方法</th>
            <th>运算符</th>
            <th>描述</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>并集</td>
            <td><code class="language-plaintext highlighter-rouge">union()</code></td>
            <td><code class="language-plaintext highlighter-rouge">|</code></td>
            <td>所有元素</td>
          </tr>
          <tr>
            <td>交集</td>
            <td><code class="language-plaintext highlighter-rouge">intersection()</code></td>
            <td><code class="language-plaintext highlighter-rouge">&amp;</code></td>
            <td>共同元素</td>
          </tr>
          <tr>
            <td>差集</td>
            <td><code class="language-plaintext highlighter-rouge">difference()</code></td>
            <td><code class="language-plaintext highlighter-rouge">-</code></td>
            <td>在A不在B的元素</td>
          </tr>
          <tr>
            <td>对称差集</td>
            <td><code class="language-plaintext highlighter-rouge">symmetric_difference()</code></td>
            <td><code class="language-plaintext highlighter-rouge">^</code></td>
            <td>只在一个集合中的元素</td>
          </tr>
          <tr>
            <td>子集检查</td>
            <td><code class="language-plaintext highlighter-rouge">issubset()</code></td>
            <td><code class="language-plaintext highlighter-rouge">&lt;=</code></td>
            <td>是否为子集</td>
          </tr>
          <tr>
            <td>真子集检查</td>
            <td><code class="language-plaintext highlighter-rouge">&lt;</code></td>
            <td> </td>
            <td>是否为真子集</td>
          </tr>
          <tr>
            <td>超集检查</td>
            <td><code class="language-plaintext highlighter-rouge">issuperset()</code></td>
            <td><code class="language-plaintext highlighter-rouge">&gt;=</code></td>
            <td>是否为超集</td>
          </tr>
          <tr>
            <td>真超集检查</td>
            <td><code class="language-plaintext highlighter-rouge">&gt;</code></td>
            <td> </td>
            <td>是否为真超集</td>
          </tr>
          <tr>
            <td>无交集检查</td>
            <td><code class="language-plaintext highlighter-rouge">isdisjoint()</code></td>
            <td> </td>
            <td>是否没有共同元素</td>
          </tr>
        </tbody>
      </table>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">A</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">}</span>
<span class="n">B</span> <span class="o">=</span> <span class="p">{</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">}</span>

<span class="c1"># 并集
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span> <span class="o">|</span> <span class="n">B</span><span class="p">)</span>           <span class="c1"># {1, 2, 3, 4, 5, 6}
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">union</span><span class="p">(</span><span class="n">B</span><span class="p">))</span>      <span class="c1"># 同上
</span>
<span class="c1"># 交集
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span> <span class="o">&amp;</span> <span class="n">B</span><span class="p">)</span>           <span class="c1"># {3, 4}
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">intersection</span><span class="p">(</span><span class="n">B</span><span class="p">))</span>  <span class="c1"># 同上
</span>
<span class="c1"># 差集
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span> <span class="o">-</span> <span class="n">B</span><span class="p">)</span>           <span class="c1"># {1, 2} (在A中但不在B中)
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">difference</span><span class="p">(</span><span class="n">B</span><span class="p">))</span> <span class="c1"># 同上
</span>
<span class="c1"># 对称差集
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span> <span class="o">^</span> <span class="n">B</span><span class="p">)</span>           <span class="c1"># {1, 2, 5, 6} (只在其中一个集合中)
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">symmetric_difference</span><span class="p">(</span><span class="n">B</span><span class="p">))</span>  <span class="c1"># 同上
</span>
<span class="c1"># 子集/超集检查
</span><span class="n">C</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">}</span>
<span class="k">print</span><span class="p">(</span><span class="n">C</span> <span class="o">&lt;=</span> <span class="n">A</span><span class="p">)</span>          <span class="c1"># True (C是A的子集)
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span> <span class="o">&gt;=</span> <span class="n">C</span><span class="p">)</span>          <span class="c1"># True (A是C的超集)
</span><span class="k">print</span><span class="p">(</span><span class="n">C</span> <span class="o">&lt;</span> <span class="n">A</span><span class="p">)</span>           <span class="c1"># True (C是A的真子集)
</span><span class="k">print</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">isdisjoint</span><span class="p">({</span><span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">}))</span>  <span class="c1"># True (没有共同元素)
</span></code></pre></div>      </div>

      <p><strong>五、不可变集合（frozenset）</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 创建不可变集合
</span><span class="n">fs</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>  <span class="c1"># frozenset({1, 2, 3})
</span>
<span class="c1"># 不可变集合操作
</span><span class="n">fs2</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
<span class="k">print</span><span class="p">(</span><span class="n">fs</span> <span class="o">&amp;</span> <span class="n">fs2</span><span class="p">)</span>    <span class="c1"># frozenset({2, 3}) 可进行集合运算
# fs.add(4)        # 错误！不可变集合不能修改
</span>
<span class="c1"># 作为字典键
</span><span class="n">dict_with_frozenset</span> <span class="o">=</span> <span class="p">{</span>
    <span class="nb">frozenset</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]):</span> <span class="s">"set1"</span><span class="p">,</span>
    <span class="nb">frozenset</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]):</span> <span class="s">"set2"</span>
<span class="p">}</span>
</code></pre></div>      </div>

      <p><strong>六、集合常用方法</strong></p>

      <table>
        <thead>
          <tr>
            <th>方法</th>
            <th>描述</th>
            <th>示例</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">copy()</code></td>
            <td>返回浅拷贝</td>
            <td><code class="language-plaintext highlighter-rouge">s2 = s1.copy()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">update()</code></td>
            <td>添加多个元素</td>
            <td><code class="language-plaintext highlighter-rouge">s.update([1,2,3])</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">intersection_update()</code></td>
            <td>原地交集</td>
            <td><code class="language-plaintext highlighter-rouge">s.intersection_update(t)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">difference_update()</code></td>
            <td>原地差集</td>
            <td><code class="language-plaintext highlighter-rouge">s.difference_update(t)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">symmetric_difference_update()</code></td>
            <td>原地对称差集</td>
            <td><code class="language-plaintext highlighter-rouge">s.symmetric_difference_update(t)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">pop()</code></td>
            <td>随机移除并返回一个元素</td>
            <td><code class="language-plaintext highlighter-rouge">elem = s.pop()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">remove()</code></td>
            <td>移除指定元素（不存在则报错）</td>
            <td><code class="language-plaintext highlighter-rouge">s.remove(1)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">discard()</code></td>
            <td>移除指定元素（不存在不报错）</td>
            <td><code class="language-plaintext highlighter-rouge">s.discard(1)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">clear()</code></td>
            <td>清空集合</td>
            <td><code class="language-plaintext highlighter-rouge">s.clear()</code></td>
          </tr>
        </tbody>
      </table>

      <p><strong>七、集合推导式</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 基本集合推导式
</span><span class="n">numbers</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">}</span>  <span class="c1"># {0, 2, 4, 6, 8}
</span>
<span class="c1"># 从字典创建（获取键的集合）
</span><span class="n">data</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
<span class="n">keys_set</span> <span class="o">=</span> <span class="p">{</span><span class="n">key</span> <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">data</span><span class="p">}</span>  <span class="c1"># {'a', 'b', 'c'}
</span>
<span class="c1"># 复杂推导式
</span><span class="n">pairs</span> <span class="o">=</span> <span class="p">{(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="k">for</span> <span class="n">y</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)}</span>  <span class="c1"># 9个坐标对
</span></code></pre></div>      </div>

      <p><strong>八、集合与列表/元组转换</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 列表去重（保持顺序）
</span><span class="n">lst</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="n">unique_ordered</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">dict</span><span class="p">.</span><span class="n">fromkeys</span><span class="p">(</span><span class="n">lst</span><span class="p">))</span>  <span class="c1"># [3, 1, 2, 4]
</span>
<span class="c1"># 列表去重（不关心顺序）
</span><span class="n">unique_set</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">lst</span><span class="p">))</span>  <span class="c1"># 顺序可能变化
</span>
<span class="c1"># 检查列表是否有重复
</span><span class="n">has_duplicates</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">lst</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">lst</span><span class="p">))</span>

<span class="c1"># 获取两个列表的共同元素
</span><span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="n">list2</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span>
<span class="n">common</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">set</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span>  <span class="c1"># {3, 4}
</span></code></pre></div>      </div>

      <p><strong>九、集合使用场景</strong></p>

      <ul>
        <li>数据去重
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 去除重复项
</span>  <span class="n">emails</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a@test.com"</span><span class="p">,</span> <span class="s">"b@test.com"</span><span class="p">,</span> <span class="s">"a@test.com"</span><span class="p">,</span> <span class="s">"c@test.com"</span><span class="p">]</span>
  <span class="n">unique_emails</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">emails</span><span class="p">)</span>  <span class="c1"># 去重
</span></code></pre></div>          </div>
        </li>
        <li>成员快速检查
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 高效检查元素是否存在
</span>  <span class="n">valid_users</span> <span class="o">=</span> <span class="p">{</span><span class="s">"alice"</span><span class="p">,</span> <span class="s">"bob"</span><span class="p">,</span> <span class="s">"charlie"</span><span class="p">}</span>
  <span class="n">username</span> <span class="o">=</span> <span class="s">"alice"</span>
  <span class="k">if</span> <span class="n">username</span> <span class="ow">in</span> <span class="n">valid_users</span><span class="p">:</span>  <span class="c1"># O(1)时间复杂度
</span>      <span class="k">print</span><span class="p">(</span><span class="s">"用户存在"</span><span class="p">)</span>
</code></pre></div>          </div>
        </li>
        <li>数据对比
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 比较两个数据集
</span>  <span class="n">old_data</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">}</span>
  <span class="n">new_data</span> <span class="o">=</span> <span class="p">{</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">}</span>

  <span class="n">added</span> <span class="o">=</span> <span class="n">new_data</span> <span class="o">-</span> <span class="n">old_data</span>    <span class="c1"># {6, 7} 新增的
</span>  <span class="n">removed</span> <span class="o">=</span> <span class="n">old_data</span> <span class="o">-</span> <span class="n">new_data</span>  <span class="c1"># {1, 2} 删除的
</span>  <span class="n">common</span> <span class="o">=</span> <span class="n">old_data</span> <span class="o">&amp;</span> <span class="n">new_data</span>   <span class="c1"># {3, 4, 5} 共同的
</span></code></pre></div>          </div>
        </li>
      </ul>

      <p><strong>十、性能比较</strong></p>

      <table>
        <thead>
          <tr>
            <th>操作</th>
            <th>列表/元组</th>
            <th>集合</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>成员检查 (x in s)</td>
            <td>O(n)</td>
            <td>O(1)</td>
          </tr>
          <tr>
            <td>添加元素</td>
            <td>O(1) (列表末尾)</td>
            <td>O(1)</td>
          </tr>
          <tr>
            <td>删除元素</td>
            <td>O(n)</td>
            <td>O(1)</td>
          </tr>
          <tr>
            <td>遍历</td>
            <td>O(n)</td>
            <td>O(n)</td>
          </tr>
          <tr>
            <td>交集/并集</td>
            <td>O(n²)</td>
            <td>O(min(len(a), len(b)))</td>
          </tr>
        </tbody>
      </table>

      <p><strong>十一、注意事项</strong></p>

      <ol>
        <li><strong>元素必须可哈希</strong>：不能包含列表、字典等可变对象</li>
        <li><strong>集合推导式返回集合</strong>：<code class="language-plaintext highlighter-rouge">{x for x in ...}</code></li>
        <li><strong>集合运算返回新集合</strong>：原始集合不变</li>
        <li><strong>frozenset可用作字典键</strong>：普通集合不可以</li>
        <li><strong>集合顺序不确定</strong>：Python 3.7+ 中字典有序，但集合仍无序</li>
      </ol>

      <p><strong>十二、实用代码片段</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 1. 统计不同单词数量
</span><span class="n">text</span> <span class="o">=</span> <span class="s">"hello world hello python world python programming"</span>
<span class="n">words</span> <span class="o">=</span> <span class="n">text</span><span class="p">.</span><span class="n">split</span><span class="p">()</span>
<span class="n">unique_words</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">words</span><span class="p">))</span>  <span class="c1"># 5
</span>
<span class="c1"># 2. 查找两个列表的不同元素
</span><span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="n">list2</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">]</span>
<span class="n">only_in_list1</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span> <span class="o">-</span> <span class="nb">set</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span>  <span class="c1"># {1, 2, 3}
</span><span class="n">only_in_list2</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span> <span class="o">-</span> <span class="nb">set</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span>  <span class="c1"># {6, 7, 8}
</span>
<span class="c1"># 3. 检查多个列表是否有共同元素
</span><span class="n">lists</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">]]</span>
<span class="n">common_elements</span> <span class="o">=</span> <span class="nb">set</span><span class="p">.</span><span class="n">intersection</span><span class="p">(</span><span class="o">*</span><span class="nb">map</span><span class="p">(</span><span class="nb">set</span><span class="p">,</span> <span class="n">lists</span><span class="p">))</span>  <span class="c1"># 空集
</span>
<span class="c1"># 4. 获取列表中出现频率最高的元素
</span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">Counter</span>
<span class="n">lst</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="n">most_common</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">lst</span><span class="p">).</span><span class="n">most_common</span><span class="p">(</span><span class="mi">1</span><span class="p">)[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>  <span class="c1"># 3
</span></code></pre></div>      </div>

      <p><strong>十三、最佳实践</strong></p>

      <ul>
        <li><strong>使用场景选择</strong>：
          <ul>
            <li>需要快速成员检查 → 集合</li>
            <li>需要去重 → 集合</li>
            <li>需要集合运算 → 集合</li>
            <li>需要顺序或重复元素 → 列表</li>
          </ul>
        </li>
        <li><strong>性能优化</strong>：
          <ul>
            <li>大量成员检查时，先将列表转为集合</li>
            <li>多次集合运算时，使用集合方法</li>
            <li>大型集合考虑内存占用</li>
          </ul>
        </li>
        <li><strong>代码可读性</strong>：
          <ul>
            <li>使用集合运算符号（| &amp; - ^）更简洁</li>
            <li>命名有意义，如 <code class="language-plaintext highlighter-rouge">valid_users</code> 而不是 <code class="language-plaintext highlighter-rouge">s</code></li>
            <li>适当添加注释说明集合操作逻辑</li>
          </ul>
        </li>
      </ul>

    </details>
  </li>
  <li><strong>4.4 字典 (Dictionary)</strong>
    <ul>
      <li>创建：<code class="language-plaintext highlighter-rouge">{}</code> 或 <code class="language-plaintext highlighter-rouge">dict()</code></li>
      <li>键值对映射</li>
      <li>访问：<code class="language-plaintext highlighter-rouge">dict[key]</code>、<code class="language-plaintext highlighter-rouge">dict.get()</code></li>
      <li>常用方法：<code class="language-plaintext highlighter-rouge">keys()</code>、<code class="language-plaintext highlighter-rouge">values()</code>、<code class="language-plaintext highlighter-rouge">items()</code>、<code class="language-plaintext highlighter-rouge">update()</code>、<code class="language-plaintext highlighter-rouge">pop()</code></li>
      <li>字典推导式
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>{x: x**2 for x in range(5)}
</code></pre></div>        </div>
      </li>
    </ul>
    <details>
      <summary>详情关于字典</summary>

      <p><strong>一、字典基础</strong></p>

      <ul>
        <li>什么是字典？
          <ul>
            <li>键值对（key-value）的<strong>无序</strong>集合（Python 3.7+ 变为有序）</li>
            <li>键必须是<strong>不可变类型</strong>（字符串、数字、元组）</li>
            <li>值可以是任意类型</li>
            <li>用花括号 <code class="language-plaintext highlighter-rouge">{}</code> 表示，键值对用冒号 <code class="language-plaintext highlighter-rouge">:</code> 分隔</li>
          </ul>
        </li>
        <li>
          <p>字典的特点</p>

          <table>
            <thead>
              <tr>
                <th>特性</th>
                <th>说明</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>键的唯一性</td>
                <td>键不能重复，后出现的覆盖前面的</td>
              </tr>
              <tr>
                <td>可哈希键</td>
                <td>键必须是不可变类型</td>
              </tr>
              <tr>
                <td>无序性</td>
                <td>Python 3.6 前无序，3.7+ 保持插入顺序</td>
              </tr>
              <tr>
                <td>动态性</td>
                <td>可动态添加、删除键值对</td>
              </tr>
              <tr>
                <td>高效查找</td>
                <td>基于哈希表，查找速度为 O(1)</td>
              </tr>
            </tbody>
          </table>
        </li>
      </ul>

      <p><strong>二、字典创建</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 创建空字典
</span><span class="n">d1</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">d2</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">()</span>

<span class="c1"># 直接创建
</span><span class="n">d3</span> <span class="o">=</span> <span class="p">{</span><span class="s">'name'</span><span class="p">:</span> <span class="s">'Alice'</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span> <span class="mi">25</span><span class="p">,</span> <span class="s">'city'</span><span class="p">:</span> <span class="s">'Beijing'</span><span class="p">}</span>

<span class="c1"># 使用dict()构造函数
</span><span class="n">d4</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'Bob'</span><span class="p">,</span> <span class="n">age</span><span class="o">=</span><span class="mi">30</span><span class="p">)</span>  <span class="c1"># 关键字参数
</span><span class="n">d5</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">([(</span><span class="s">'name'</span><span class="p">,</span> <span class="s">'Charlie'</span><span class="p">),</span> <span class="p">(</span><span class="s">'age'</span><span class="p">,</span> <span class="mi">35</span><span class="p">)])</span>  <span class="c1"># 可迭代对象
</span><span class="n">d6</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">zip</span><span class="p">([</span><span class="s">'name'</span><span class="p">,</span> <span class="s">'age'</span><span class="p">],</span> <span class="p">[</span><span class="s">'David'</span><span class="p">,</span> <span class="mi">40</span><span class="p">]))</span>  <span class="c1"># zip函数
</span>
<span class="c1"># 字典推导式
</span><span class="n">d7</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">)}</span>  <span class="c1"># {0:0, 1:1, 2:4, 3:9, 4:16}
</span></code></pre></div>      </div>

      <p><strong>三、字典基本操作</strong></p>

      <ul>
        <li>访问元素
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="n">person</span> <span class="o">=</span> <span class="p">{</span><span class="s">'name'</span><span class="p">:</span> <span class="s">'Alice'</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span> <span class="mi">25</span><span class="p">,</span> <span class="s">'city'</span><span class="p">:</span> <span class="s">'Beijing'</span><span class="p">}</span>

  <span class="c1"># 通过键访问
</span>  <span class="k">print</span><span class="p">(</span><span class="n">person</span><span class="p">[</span><span class="s">'name'</span><span class="p">])</span>  <span class="c1"># 'Alice'
</span>
  <span class="c1"># 通过get()方法访问（推荐）
</span>  <span class="k">print</span><span class="p">(</span><span class="n">person</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">'age'</span><span class="p">))</span>      <span class="c1"># 25
</span>  <span class="k">print</span><span class="p">(</span><span class="n">person</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">'email'</span><span class="p">))</span>    <span class="c1"># None
</span>  <span class="k">print</span><span class="p">(</span><span class="n">person</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">'email'</span><span class="p">,</span> <span class="s">'未设置'</span><span class="p">))</span>  <span class="c1"># '未设置'（默认值）
</span>
  <span class="c1"># 检查键是否存在
</span>  <span class="k">if</span> <span class="s">'name'</span> <span class="ow">in</span> <span class="n">person</span><span class="p">:</span>
      <span class="k">print</span><span class="p">(</span><span class="s">"键存在"</span><span class="p">)</span>

  <span class="c1"># 获取所有键、值、键值对
</span>  <span class="n">keys</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">keys</span><span class="p">()</span>     <span class="c1"># dict_keys(['name', 'age', 'city'])
</span>  <span class="n">values</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">values</span><span class="p">()</span> <span class="c1"># dict_values(['Alice', 25, 'Beijing'])
</span>  <span class="n">items</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">items</span><span class="p">()</span>   <span class="c1"># dict_items([('name','Alice'), ('age',25), ...])
</span></code></pre></div>          </div>
        </li>
        <li>修改元素
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 添加/修改键值对
</span>  <span class="n">person</span><span class="p">[</span><span class="s">'email'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'alice@example.com'</span>  <span class="c1"># 添加
</span>  <span class="n">person</span><span class="p">[</span><span class="s">'age'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">26</span>                     <span class="c1"># 修改
</span>
  <span class="c1"># 使用update()更新多个键值对
</span>  <span class="n">person</span><span class="p">.</span><span class="n">update</span><span class="p">({</span><span class="s">'city'</span><span class="p">:</span> <span class="s">'Shanghai'</span><span class="p">,</span> <span class="s">'gender'</span><span class="p">:</span> <span class="s">'female'</span><span class="p">})</span>

  <span class="c1"># 设置默认值
</span>  <span class="n">person</span><span class="p">.</span><span class="n">setdefault</span><span class="p">(</span><span class="s">'country'</span><span class="p">,</span> <span class="s">'China'</span><span class="p">)</span>  <span class="c1"># 如果不存在则设置
</span></code></pre></div>          </div>
        </li>
        <li>删除元素
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="c1"># 删除指定键
</span>  <span class="k">del</span> <span class="n">person</span><span class="p">[</span><span class="s">'city'</span><span class="p">]</span>

  <span class="c1"># pop()删除并返回值
</span>  <span class="n">age</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">pop</span><span class="p">(</span><span class="s">'age'</span><span class="p">)</span>  <span class="c1"># 返回25，从字典删除
</span>  <span class="n">email</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">pop</span><span class="p">(</span><span class="s">'email'</span><span class="p">,</span> <span class="s">'默认值'</span><span class="p">)</span>  <span class="c1"># 提供默认值
</span>
  <span class="c1"># popitem()删除最后一个键值对（Python 3.7+）
</span>  <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">person</span><span class="p">.</span><span class="n">popitem</span><span class="p">()</span>  <span class="c1"># 返回最后一个键值对
</span>
  <span class="c1"># 清空字典
</span>  <span class="n">person</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>  <span class="c1"># 清空所有键值对
</span></code></pre></div>          </div>
        </li>
      </ul>

      <p><strong>四、字典常用方法</strong></p>

      <table>
        <thead>
          <tr>
            <th>方法</th>
            <th>描述</th>
            <th>示例</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">get(key[, default])</code></td>
            <td>安全获取值</td>
            <td><code class="language-plaintext highlighter-rouge">d.get('key', 0)</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">setdefault(key[, default])</code></td>
            <td>键不存在时设置默认值</td>
            <td><code class="language-plaintext highlighter-rouge">d.setdefault('key', [])</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">update([other])</code></td>
            <td>更新多个键值对</td>
            <td><code class="language-plaintext highlighter-rouge">d.update({'a':1})</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">pop(key[, default])</code></td>
            <td>删除并返回值</td>
            <td><code class="language-plaintext highlighter-rouge">d.pop('key')</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">popitem()</code></td>
            <td>删除最后一个键值对</td>
            <td><code class="language-plaintext highlighter-rouge">d.popitem()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">clear()</code></td>
            <td>清空字典</td>
            <td><code class="language-plaintext highlighter-rouge">d.clear()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">copy()</code></td>
            <td>浅拷贝</td>
            <td><code class="language-plaintext highlighter-rouge">d2 = d.copy()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">keys()</code></td>
            <td>返回所有键</td>
            <td><code class="language-plaintext highlighter-rouge">d.keys()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">values()</code></td>
            <td>返回所有值</td>
            <td><code class="language-plaintext highlighter-rouge">d.values()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">items()</code></td>
            <td>返回所有键值对</td>
            <td><code class="language-plaintext highlighter-rouge">d.items()</code></td>
          </tr>
          <tr>
            <td><code class="language-plaintext highlighter-rouge">fromkeys(seq[, value])</code></td>
            <td>从序列创建字典</td>
            <td><code class="language-plaintext highlighter-rouge">dict.fromkeys(['a','b'], 0)</code></td>
          </tr>
        </tbody>
      </table>

      <p><strong>五、字典遍历</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">person</span> <span class="o">=</span> <span class="p">{</span><span class="s">'name'</span><span class="p">:</span> <span class="s">'Alice'</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span> <span class="mi">25</span><span class="p">,</span> <span class="s">'city'</span><span class="p">:</span> <span class="s">'Beijing'</span><span class="p">}</span>

<span class="c1"># 遍历键
</span><span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">person</span><span class="p">:</span>
    <span class="k">print</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">person</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>

<span class="c1"># 遍历键值对
</span><span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">person</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s">: </span><span class="si">{</span><span class="n">value</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>

<span class="c1"># 只遍历值
</span><span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">person</span><span class="p">.</span><span class="n">values</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>

<span class="c1"># 使用enumerate()获取索引
</span><span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">person</span><span class="p">.</span><span class="n">items</span><span class="p">()):</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">i</span><span class="si">}</span><span class="s">. </span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s">=</span><span class="si">{</span><span class="n">value</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
</code></pre></div>      </div>

      <p><strong>六、字典推导式</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 基本字典推导式
</span><span class="n">squares</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">)}</span>  <span class="c1"># {0:0, 1:1, 2:4, 3:9, 4:16}
</span>
<span class="c1"># 带条件的字典推导式
</span><span class="n">even_squares</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">}</span>

<span class="c1"># 键值交换
</span><span class="n">original</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
<span class="n">reversed_dict</span> <span class="o">=</span> <span class="p">{</span><span class="n">value</span><span class="p">:</span> <span class="n">key</span> <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">original</span><span class="p">.</span><span class="n">items</span><span class="p">()}</span>

<span class="c1"># 合并两个列表为字典
</span><span class="n">keys</span> <span class="o">=</span> <span class="p">[</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">]</span>
<span class="n">values</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="n">merged</span> <span class="o">=</span> <span class="p">{</span><span class="n">k</span><span class="p">:</span> <span class="n">v</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">values</span><span class="p">)}</span>  <span class="c1"># {'a':1, 'b':2, 'c':3}
</span></code></pre></div>      </div>

      <p><strong>七、嵌套字典</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 创建嵌套字典
</span><span class="n">students</span> <span class="o">=</span> <span class="p">{</span>
    <span class="s">'Alice'</span><span class="p">:</span> <span class="p">{</span>
        <span class="s">'age'</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span>
        <span class="s">'grade'</span><span class="p">:</span> <span class="s">'A'</span><span class="p">,</span>
        <span class="s">'courses'</span><span class="p">:</span> <span class="p">[</span><span class="s">'Math'</span><span class="p">,</span> <span class="s">'Physics'</span><span class="p">]</span>
    <span class="p">},</span>
    <span class="s">'Bob'</span><span class="p">:</span> <span class="p">{</span>
        <span class="s">'age'</span><span class="p">:</span> <span class="mi">21</span><span class="p">,</span>
        <span class="s">'grade'</span><span class="p">:</span> <span class="s">'B'</span><span class="p">,</span>
        <span class="s">'courses'</span><span class="p">:</span> <span class="p">[</span><span class="s">'Chemistry'</span><span class="p">,</span> <span class="s">'Biology'</span><span class="p">]</span>
    <span class="p">}</span>
<span class="p">}</span>

<span class="c1"># 访问嵌套字典
</span><span class="k">print</span><span class="p">(</span><span class="n">students</span><span class="p">[</span><span class="s">'Alice'</span><span class="p">][</span><span class="s">'age'</span><span class="p">])</span>  <span class="c1"># 20
</span><span class="k">print</span><span class="p">(</span><span class="n">students</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">'Bob'</span><span class="p">,</span> <span class="p">{}).</span><span class="n">get</span><span class="p">(</span><span class="s">'grade'</span><span class="p">,</span> <span class="s">'未知'</span><span class="p">))</span>  <span class="c1"># 'B'
</span>
<span class="c1"># 修改嵌套字典
</span><span class="n">students</span><span class="p">[</span><span class="s">'Alice'</span><span class="p">][</span><span class="s">'grade'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'A+'</span>
<span class="n">students</span><span class="p">[</span><span class="s">'Alice'</span><span class="p">][</span><span class="s">'courses'</span><span class="p">].</span><span class="n">append</span><span class="p">(</span><span class="s">'English'</span><span class="p">)</span>

<span class="c1"># 遍历嵌套字典
</span><span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">info</span> <span class="ow">in</span> <span class="n">students</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"姓名: </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">info</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">"  </span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s">: </span><span class="si">{</span><span class="n">value</span><span class="si">}</span><span class="s">"</span><span class="p">)</span>
</code></pre></div>      </div>

      <p><strong>八、特殊字典类型</strong></p>

      <ul>
        <li>默认字典（defaultdict）
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">defaultdict</span>

  <span class="c1"># 自动为不存在的键创建默认值
</span>  <span class="n">word_count</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">int</span><span class="p">)</span>  <span class="c1"># 默认值为0
</span>  <span class="k">for</span> <span class="n">word</span> <span class="ow">in</span> <span class="p">[</span><span class="s">"apple"</span><span class="p">,</span> <span class="s">"banana"</span><span class="p">,</span> <span class="s">"apple"</span><span class="p">,</span> <span class="s">"cherry"</span><span class="p">]:</span>
      <span class="n">word_count</span><span class="p">[</span><span class="n">word</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
  <span class="c1"># 结果: {'apple': 2, 'banana': 1, 'cherry': 1}
</span>
  <span class="c1"># 默认值为列表
</span>  <span class="n">group_by_letter</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>
  <span class="n">words</span> <span class="o">=</span> <span class="p">[</span><span class="s">"apple"</span><span class="p">,</span> <span class="s">"banana"</span><span class="p">,</span> <span class="s">"apricot"</span><span class="p">,</span> <span class="s">"cherry"</span><span class="p">,</span> <span class="s">"blueberry"</span><span class="p">]</span>
  <span class="k">for</span> <span class="n">word</span> <span class="ow">in</span> <span class="n">words</span><span class="p">:</span>
      <span class="n">group_by_letter</span><span class="p">[</span><span class="n">word</span><span class="p">[</span><span class="mi">0</span><span class="p">]].</span><span class="n">append</span><span class="p">(</span><span class="n">word</span><span class="p">)</span>
  <span class="c1"># 结果: {'a':['apple','apricot'], 'b':['banana','blueberry'], 'c':['cherry']}
</span></code></pre></div>          </div>
        </li>
        <li>有序字典（OrderedDict）
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">OrderedDict</span>

  <span class="c1"># 保持插入顺序（Python 3.7+ 普通字典也有序，但OrderedDict有额外功能）
</span>  <span class="n">ordered</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span>
  <span class="n">ordered</span><span class="p">[</span><span class="s">'z'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
  <span class="n">ordered</span><span class="p">[</span><span class="s">'a'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">2</span>
  <span class="n">ordered</span><span class="p">[</span><span class="s">'c'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">3</span>
  <span class="k">print</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">ordered</span><span class="p">.</span><span class="n">keys</span><span class="p">()))</span>  <span class="c1"># ['z', 'a', 'c'] 保持插入顺序
</span>
  <span class="c1"># 移动到开头或结尾
</span>  <span class="n">ordered</span><span class="p">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="s">'z'</span><span class="p">)</span>  <span class="c1"># 将'z'移动到最后
</span>  <span class="n">ordered</span><span class="p">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="s">'a'</span><span class="p">,</span> <span class="n">last</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>  <span class="c1"># 将'a'移动到开头
</span></code></pre></div>          </div>
        </li>
        <li>计数器（Counter）
          <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">Counter</span>

  <span class="c1"># 统计元素出现次数
</span>  <span class="n">words</span> <span class="o">=</span> <span class="p">[</span><span class="s">"apple"</span><span class="p">,</span> <span class="s">"banana"</span><span class="p">,</span> <span class="s">"apple"</span><span class="p">,</span> <span class="s">"cherry"</span><span class="p">,</span> <span class="s">"banana"</span><span class="p">,</span> <span class="s">"apple"</span><span class="p">]</span>
  <span class="n">word_count</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">words</span><span class="p">)</span>
  <span class="k">print</span><span class="p">(</span><span class="n">word_count</span><span class="p">)</span>  <span class="c1"># Counter({'apple': 3, 'banana': 2, 'cherry': 1})
</span>
  <span class="c1"># 常见操作
</span>  <span class="k">print</span><span class="p">(</span><span class="n">word_count</span><span class="p">.</span><span class="n">most_common</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span>  <span class="c1"># [('apple', 3), ('banana', 2)]
</span>  <span class="k">print</span><span class="p">(</span><span class="n">word_count</span><span class="p">.</span><span class="n">total</span><span class="p">())</span>  <span class="c1"># 6 (总计数)
</span>
  <span class="c1"># 合并计数器
</span>  <span class="n">counter1</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">([</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'a'</span><span class="p">])</span>
  <span class="n">counter2</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">([</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">])</span>
  <span class="k">print</span><span class="p">(</span><span class="n">counter1</span> <span class="o">+</span> <span class="n">counter2</span><span class="p">)</span>  <span class="c1"># Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})
</span></code></pre></div>          </div>
        </li>
      </ul>

      <p><strong>九、字典与JSON</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">json</span>

<span class="c1"># 字典转JSON字符串
</span><span class="n">data</span> <span class="o">=</span> <span class="p">{</span><span class="s">'name'</span><span class="p">:</span> <span class="s">'Alice'</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span> <span class="mi">25</span><span class="p">,</span> <span class="s">'city'</span><span class="p">:</span> <span class="s">'Beijing'</span><span class="p">}</span>
<span class="n">json_str</span> <span class="o">=</span> <span class="n">json</span><span class="p">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">ensure_ascii</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="c1"># 结果: 格式化的JSON字符串
</span>
<span class="c1"># JSON字符串转字典
</span><span class="n">parsed_data</span> <span class="o">=</span> <span class="n">json</span><span class="p">.</span><span class="n">loads</span><span class="p">(</span><span class="n">json_str</span><span class="p">)</span>
<span class="c1"># 结果: 恢复为字典
</span>
<span class="c1"># 字典与文件
</span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s">'data.json'</span><span class="p">,</span> <span class="s">'w'</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s">'utf-8'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
    <span class="n">json</span><span class="p">.</span><span class="n">dump</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">f</span><span class="p">,</span> <span class="n">ensure_ascii</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>

<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s">'data.json'</span><span class="p">,</span> <span class="s">'r'</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s">'utf-8'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
    <span class="n">loaded_data</span> <span class="o">=</span> <span class="n">json</span><span class="p">.</span><span class="n">load</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</code></pre></div>      </div>

      <p><strong>十、字典排序</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">scores</span> <span class="o">=</span> <span class="p">{</span><span class="s">'Alice'</span><span class="p">:</span> <span class="mi">85</span><span class="p">,</span> <span class="s">'Bob'</span><span class="p">:</span> <span class="mi">92</span><span class="p">,</span> <span class="s">'Charlie'</span><span class="p">:</span> <span class="mi">78</span><span class="p">,</span> <span class="s">'David'</span><span class="p">:</span> <span class="mi">95</span><span class="p">}</span>

<span class="c1"># 按键排序
</span><span class="n">sorted_by_key</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">scores</span><span class="p">.</span><span class="n">items</span><span class="p">()))</span>
<span class="c1"># 结果: {'Alice':85, 'Bob':92, 'Charlie':78, 'David':95}（按字母顺序）
</span>
<span class="c1"># 按值排序（降序）
</span><span class="n">sorted_by_value</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">scores</span><span class="p">.</span><span class="n">items</span><span class="p">(),</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">reverse</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="c1"># 结果: {'David':95, 'Bob':92, 'Alice':85, 'Charlie':78}
</span>
<span class="c1"># 获取前N个最高分
</span><span class="n">top_2</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">scores</span><span class="p">.</span><span class="n">items</span><span class="p">(),</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">reverse</span><span class="o">=</span><span class="bp">True</span><span class="p">)[:</span><span class="mi">2</span><span class="p">])</span>
<span class="c1"># 结果: {'David':95, 'Bob':92}
</span></code></pre></div>      </div>

      <p><strong>十一、字典合并</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">dict1</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span> <span class="mi">2</span><span class="p">}</span>
<span class="n">dict2</span> <span class="o">=</span> <span class="p">{</span><span class="s">'b'</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span> <span class="mi">4</span><span class="p">}</span>
<span class="n">dict3</span> <span class="o">=</span> <span class="p">{</span><span class="s">'c'</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s">'d'</span><span class="p">:</span> <span class="mi">6</span><span class="p">}</span>

<span class="c1"># 方法1: update()（修改原字典）
</span><span class="n">merged1</span> <span class="o">=</span> <span class="n">dict1</span><span class="p">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">merged1</span><span class="p">.</span><span class="n">update</span><span class="p">(</span><span class="n">dict2</span><span class="p">)</span>  <span class="c1"># dict1的'b'被dict2的'b'覆盖
</span>
<span class="c1"># 方法2: 字典解包（Python 3.5+）
</span><span class="n">merged2</span> <span class="o">=</span> <span class="p">{</span><span class="o">**</span><span class="n">dict1</span><span class="p">,</span> <span class="o">**</span><span class="n">dict2</span><span class="p">,</span> <span class="o">**</span><span class="n">dict3</span><span class="p">}</span>
<span class="c1"># 后面的字典覆盖前面的相同键
</span>
<span class="c1"># 方法3: collections.ChainMap
</span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">ChainMap</span>
<span class="n">chain</span> <span class="o">=</span> <span class="n">ChainMap</span><span class="p">(</span><span class="n">dict1</span><span class="p">,</span> <span class="n">dict2</span><span class="p">,</span> <span class="n">dict3</span><span class="p">)</span>
<span class="c1"># 查询时按顺序查找，不创建新字典
</span><span class="k">print</span><span class="p">(</span><span class="n">chain</span><span class="p">[</span><span class="s">'b'</span><span class="p">])</span>  <span class="c1"># 2（来自dict1）
</span>
<span class="c1"># 方法4: 使用 | 运算符（Python 3.9+）
</span><span class="n">merged3</span> <span class="o">=</span> <span class="n">dict1</span> <span class="o">|</span> <span class="n">dict2</span>  <span class="c1"># {'a':1, 'b':3, 'c':4}
</span></code></pre></div>      </div>

      <p><strong>十二、实用代码片段</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 1. 反转字典（值:键列表）
</span><span class="n">original</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span><span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="s">'d'</span><span class="p">:</span><span class="mi">3</span><span class="p">}</span>
<span class="n">reversed_dict</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">original</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
    <span class="n">reversed_dict</span><span class="p">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">[]).</span><span class="n">append</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
<span class="c1"># 结果: {1:['a','c'], 2:['b'], 3:['d']}
</span>
<span class="c1"># 2. 字典扁平化
</span><span class="n">nested</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:{</span><span class="s">'b'</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span><span class="mi">2</span><span class="p">},</span> <span class="s">'d'</span><span class="p">:{</span><span class="s">'e'</span><span class="p">:</span><span class="mi">3</span><span class="p">,</span> <span class="s">'f'</span><span class="p">:{</span><span class="s">'g'</span><span class="p">:</span><span class="mi">4</span><span class="p">}}}</span>
<span class="k">def</span> <span class="nf">flatten_dict</span><span class="p">(</span><span class="n">d</span><span class="p">,</span> <span class="n">parent_key</span><span class="o">=</span><span class="s">''</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s">'.'</span><span class="p">):</span>
    <span class="n">items</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">d</span><span class="p">.</span><span class="n">items</span><span class="p">():</span>
        <span class="n">new_key</span> <span class="o">=</span> <span class="sa">f</span><span class="s">"</span><span class="si">{</span><span class="n">parent_key</span><span class="si">}{</span><span class="n">sep</span><span class="si">}{</span><span class="n">k</span><span class="si">}</span><span class="s">"</span> <span class="k">if</span> <span class="n">parent_key</span> <span class="k">else</span> <span class="n">k</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
            <span class="n">items</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">flatten_dict</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="n">new_key</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="n">sep</span><span class="p">).</span><span class="n">items</span><span class="p">())</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">items</span><span class="p">.</span><span class="n">append</span><span class="p">((</span><span class="n">new_key</span><span class="p">,</span> <span class="n">v</span><span class="p">))</span>
    <span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="n">items</span><span class="p">)</span>
<span class="c1"># 结果: {'a.b':1, 'a.c':2, 'd.e':3, 'd.f.g':4}
</span>
<span class="c1"># 3. 过滤字典
</span><span class="n">data</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span><span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span><span class="mi">3</span><span class="p">,</span> <span class="s">'d'</span><span class="p">:</span><span class="mi">4</span><span class="p">,</span> <span class="s">'e'</span><span class="p">:</span><span class="mi">5</span><span class="p">}</span>
<span class="n">filtered</span> <span class="o">=</span> <span class="p">{</span><span class="n">k</span><span class="p">:</span><span class="n">v</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span><span class="n">v</span> <span class="ow">in</span> <span class="n">data</span><span class="p">.</span><span class="n">items</span><span class="p">()</span> <span class="k">if</span> <span class="n">v</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">}</span>  <span class="c1"># {'c':3, 'd':4, 'e':5}
</span>
<span class="c1"># 4. 按多个条件排序字典列表
</span><span class="n">students</span> <span class="o">=</span> <span class="p">[</span>
    <span class="p">{</span><span class="s">'name'</span><span class="p">:</span><span class="s">'Alice'</span><span class="p">,</span> <span class="s">'score'</span><span class="p">:</span><span class="mi">85</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span><span class="mi">20</span><span class="p">},</span>
    <span class="p">{</span><span class="s">'name'</span><span class="p">:</span><span class="s">'Bob'</span><span class="p">,</span> <span class="s">'score'</span><span class="p">:</span><span class="mi">92</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span><span class="mi">19</span><span class="p">},</span>
    <span class="p">{</span><span class="s">'name'</span><span class="p">:</span><span class="s">'Charlie'</span><span class="p">,</span> <span class="s">'score'</span><span class="p">:</span><span class="mi">85</span><span class="p">,</span> <span class="s">'age'</span><span class="p">:</span><span class="mi">21</span><span class="p">}</span>
<span class="p">]</span>
<span class="n">sorted_students</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">students</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="p">(</span><span class="o">-</span><span class="n">x</span><span class="p">[</span><span class="s">'score'</span><span class="p">],</span> <span class="n">x</span><span class="p">[</span><span class="s">'age'</span><span class="p">]))</span>
<span class="c1"># 按分数降序，年龄升序
</span></code></pre></div>      </div>

      <p><strong>十三、性能与注意事项</strong></p>

      <ul>
        <li>
          <p>时间复杂度</p>

          <table>
            <thead>
              <tr>
                <th>操作</th>
                <th>平均时间复杂度</th>
                <th>说明</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td>查找键</td>
                <td>O(1)</td>
                <td>基于哈希表</td>
              </tr>
              <tr>
                <td>插入键值对</td>
                <td>O(1)</td>
                <td>可能需要扩容</td>
              </tr>
              <tr>
                <td>删除键值对</td>
                <td>O(1)</td>
                <td> </td>
              </tr>
              <tr>
                <td>遍历</td>
                <td>O(n)</td>
                <td>遍历所有元素</td>
              </tr>
            </tbody>
          </table>
        </li>
        <li>注意事项
          <ol>
            <li><strong>键必须可哈希</strong>：不能使用列表、字典等可变对象作为键</li>
            <li><strong>字典无序</strong>：Python 3.6 前无序，3.7+ 保持插入顺序</li>
            <li><strong>内存使用</strong>：字典比列表占用更多内存</li>
            <li><strong>哈希冲突</strong>：当哈希冲突严重时，性能会下降</li>
            <li><strong>并发安全</strong>：字典不是线程安全的，多线程访问需要加锁</li>
          </ol>
        </li>
        <li>最佳实践
          <ol>
            <li>使用 <code class="language-plaintext highlighter-rouge">get()</code> 方法安全访问</li>
            <li>使用 <code class="language-plaintext highlighter-rouge">setdefault()</code> 设置默认值</li>
            <li>使用字典推导式简化代码</li>
            <li>大量数据时考虑使用 <code class="language-plaintext highlighter-rouge">defaultdict</code> 或 <code class="language-plaintext highlighter-rouge">Counter</code></li>
            <li>需要保持顺序时使用 <code class="language-plaintext highlighter-rouge">OrderedDict</code>（Python 3.7+ 普通字典也有序）</li>
          </ol>
        </li>
      </ul>

      <p><strong>十四、字典与其它数据结构转换</strong></p>

      <div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># 字典 ↔ 列表
</span><span class="n">data</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span><span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span><span class="mi">3</span><span class="p">}</span>
<span class="n">keys_list</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">data</span><span class="p">.</span><span class="n">keys</span><span class="p">())</span>      <span class="c1"># ['a', 'b', 'c']
</span><span class="n">values_list</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">data</span><span class="p">.</span><span class="n">values</span><span class="p">())</span>  <span class="c1"># [1, 2, 3]
</span><span class="n">items_list</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">data</span><span class="p">.</span><span class="n">items</span><span class="p">())</span>    <span class="c1"># [('a',1), ('b',2), ('c',3)]
</span>
<span class="c1"># 列表 → 字典
</span><span class="n">pairs</span> <span class="o">=</span> <span class="p">[(</span><span class="s">'a'</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="s">'b'</span><span class="p">,</span><span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="s">'c'</span><span class="p">,</span><span class="mi">3</span><span class="p">)]</span>
<span class="n">dict_from_list</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="n">pairs</span><span class="p">)</span>  <span class="c1"># {'a':1, 'b':2, 'c':3}
</span>
<span class="c1"># 两个列表 → 字典
</span><span class="n">keys</span> <span class="o">=</span> <span class="p">[</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">]</span>
<span class="n">values</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="n">dict_from_two_lists</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">values</span><span class="p">))</span>  <span class="c1"># {'a':1, 'b':2, 'c':3}
</span></code></pre></div>      </div>

    </details>
  </li>
  <li><strong>4.5 字符串操作</strong>
    <ul>
      <li>字符串方法：<code class="language-plaintext highlighter-rouge">split()</code>、<code class="language-plaintext highlighter-rouge">join()</code>、<code class="language-plaintext highlighter-rouge">strip()</code>、<code class="language-plaintext highlighter-rouge">replace()</code>、<code class="language-plaintext highlighter-rouge">find()</code>、<code class="language-plaintext highlighter-rouge">startswith()</code>、<code class="language-plaintext highlighter-rouge">endswith()</code></li>
      <li>字符串格式化-&gt;<a href="#二-基础语法">详情见2.4-输入与输出</a></li>
      <li>原始字符串：<code class="language-plaintext highlighter-rouge">r"string"</code></li>
    </ul>

    <p><strong>python字符串常用方法：</strong></p>

    <table>
      <thead>
        <tr>
          <th>类别</th>
          <th>方法</th>
          <th>描述</th>
          <th>示例</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>大小写</td>
          <td><code class="language-plaintext highlighter-rouge">upper()</code></td>
          <td>转大写</td>
          <td><code class="language-plaintext highlighter-rouge">"hi".upper()</code> → <code class="language-plaintext highlighter-rouge">'HI'</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">lower()</code></td>
          <td>转小写</td>
          <td><code class="language-plaintext highlighter-rouge">"HI".lower()</code> → <code class="language-plaintext highlighter-rouge">'hi'</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">title()</code></td>
          <td>单词首字母大写</td>
          <td><code class="language-plaintext highlighter-rouge">"hello world".title()</code> → <code class="language-plaintext highlighter-rouge">'Hello World'</code></td>
        </tr>
        <tr>
          <td>查找</td>
          <td><code class="language-plaintext highlighter-rouge">find()</code></td>
          <td>查找子串位置</td>
          <td><code class="language-plaintext highlighter-rouge">"hello".find('l')</code> → <code class="language-plaintext highlighter-rouge">2</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">count()</code></td>
          <td>统计出现次数</td>
          <td><code class="language-plaintext highlighter-rouge">"hello".count('l')</code> → <code class="language-plaintext highlighter-rouge">2</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">startswith()</code></td>
          <td>是否以指定开头</td>
          <td><code class="language-plaintext highlighter-rouge">"file.txt".startswith('file')</code> → <code class="language-plaintext highlighter-rouge">True</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">endswith()</code></td>
          <td>是否以指定结尾</td>
          <td><code class="language-plaintext highlighter-rouge">"file.txt".endswith('.txt')</code> → <code class="language-plaintext highlighter-rouge">True</code></td>
        </tr>
        <tr>
          <td>替换</td>
          <td><code class="language-plaintext highlighter-rouge">replace()</code></td>
          <td>替换子串</td>
          <td><code class="language-plaintext highlighter-rouge">"hello".replace('l', 'x')</code> → <code class="language-plaintext highlighter-rouge">'hexxo'</code></td>
        </tr>
        <tr>
          <td>分割</td>
          <td><code class="language-plaintext highlighter-rouge">split()</code></td>
          <td>分割字符串</td>
          <td><code class="language-plaintext highlighter-rouge">"a,b,c".split(',')</code> → <code class="language-plaintext highlighter-rouge">['a','b','c']</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">join()</code></td>
          <td>连接字符串</td>
          <td><code class="language-plaintext highlighter-rouge">'-'.join(['a','b'])</code> → <code class="language-plaintext highlighter-rouge">'a-b'</code></td>
        </tr>
        <tr>
          <td>修剪</td>
          <td><code class="language-plaintext highlighter-rouge">strip()</code></td>
          <td>去除两侧空白</td>
          <td><code class="language-plaintext highlighter-rouge">"  hi  ".strip()</code> → <code class="language-plaintext highlighter-rouge">'hi'</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">lstrip()</code>/<code class="language-plaintext highlighter-rouge">rstrip()</code></td>
          <td>去除左/右侧空白</td>
          <td><code class="language-plaintext highlighter-rouge">"  hi  ".lstrip()</code> → <code class="language-plaintext highlighter-rouge">'hi  '</code></td>
        </tr>
        <tr>
          <td>检查</td>
          <td><code class="language-plaintext highlighter-rouge">isdigit()</code></td>
          <td>是否全数字</td>
          <td><code class="language-plaintext highlighter-rouge">"123".isdigit()</code> → <code class="language-plaintext highlighter-rouge">True</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">isalpha()</code></td>
          <td>是否全字母</td>
          <td><code class="language-plaintext highlighter-rouge">"abc".isalpha()</code> → <code class="language-plaintext highlighter-rouge">True</code></td>
        </tr>
        <tr>
          <td> </td>
          <td><code class="language-plaintext highlighter-rouge">isalnum()</code></td>
          <td>是否字母或数字</td>
          <td><code class="language-plaintext highlighter-rouge">"abc123".isalnum()</code> → <code class="language-plaintext highlighter-rouge">True</code></td>
        </tr>
      </tbody>
    </table>
  </li>
</ul>

<h2 id="五-函数">五、 函数</h2>
<ul>
  <li><strong>5.1 函数定义与调用</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def function_name(parameters):
    """文档字符串"""
    # 函数体
    return value
</code></pre></div>    </div>
  </li>
  <li><strong>5.2 参数传递</strong>
    <ul>
      <li>位置参数</li>
      <li>关键字参数</li>
      <li>默认参数</li>
      <li>可变参数：<code class="language-plaintext highlighter-rouge">*args</code></li>
      <li>关键字可变参数：<code class="language-plaintext highlighter-rouge">**kwargs</code></li>
    </ul>
  </li>
  <li><strong>5.3 返回值</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">return</code> 语句</li>
      <li>返回多个值</li>
    </ul>
  </li>
  <li><strong>5.4 变量作用域</strong>
    <ul>
      <li>局部变量 vs 全局变量</li>
      <li><code class="language-plaintext highlighter-rouge">global</code> 关键字</li>
      <li><code class="language-plaintext highlighter-rouge">nonlocal</code> 关键字</li>
    </ul>
  </li>
  <li><strong>5.5 函数高级特性</strong>
    <ul>
      <li>匿名函数：<code class="language-plaintext highlighter-rouge">lambda</code>
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>lambda x, y: x + y
</code></pre></div>        </div>
      </li>
      <li>高阶函数：<code class="language-plaintext highlighter-rouge">map()</code>、<code class="language-plaintext highlighter-rouge">filter()</code>、<code class="language-plaintext highlighter-rouge">reduce()</code></li>
      <li>闭包</li>
      <li>装饰器
        <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def decorator(func):
def wrapper(*args, **kwargs):
    # 装饰逻辑
    return func(*args, **kwargs)
return wrapper
</code></pre></div>        </div>
      </li>
    </ul>
  </li>
  <li><strong>5.6 生成器与迭代器</strong>
    <ul>
      <li>迭代器协议：<code class="language-plaintext highlighter-rouge">__iter__()</code> 和 <code class="language-plaintext highlighter-rouge">__next__()</code></li>
      <li>生成器：<code class="language-plaintext highlighter-rouge">yield</code> 关键字</li>
      <li>生成器表达式</li>
    </ul>
  </li>
</ul>

<p><strong>python函数进阶：</strong><a href="/python/python%E5%87%BD%E6%95%B0/">pyhon函数</a></p>

<h2 id="六-模块与包">六、 模块与包</h2>
<ul>
  <li><strong>6.1 模块导入</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">import module</code></li>
      <li><code class="language-plaintext highlighter-rouge">from module import name</code></li>
      <li><code class="language-plaintext highlighter-rouge">import module as alias</code></li>
      <li>模块搜索路径</li>
    </ul>
  </li>
  <li><strong>6.2 模块编写</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">if __name__ == "__main__":</code></li>
      <li>模块文档字符串</li>
    </ul>
  </li>
  <li><strong>6.3 包结构</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">__init__.py</code> 文件</li>
      <li>子包</li>
      <li>相对导入与绝对导入</li>
    </ul>
  </li>
  <li><strong>6.4 常用标准库模块</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">os</code>：操作系统接口</li>
      <li><code class="language-plaintext highlighter-rouge">sys</code>：系统相关参数和函数</li>
      <li><code class="language-plaintext highlighter-rouge">math</code>：数学函数</li>
      <li><code class="language-plaintext highlighter-rouge">random</code>：生成随机数</li>
      <li><code class="language-plaintext highlighter-rouge">datetime</code>：日期和时间处理</li>
      <li><code class="language-plaintext highlighter-rouge">json</code>：JSON 编解码</li>
      <li><code class="language-plaintext highlighter-rouge">re</code>：正则表达式</li>
      <li><code class="language-plaintext highlighter-rouge">collections</code>：容器数据类型</li>
      <li><code class="language-plaintext highlighter-rouge">itertools</code>：迭代器工具</li>
      <li><code class="language-plaintext highlighter-rouge">functools</code>：高阶函数工具</li>
    </ul>
  </li>
</ul>

<h2 id="七-面向对象编程">七、 面向对象编程</h2>
<ul>
  <li><strong>7.1 类与对象</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class MyClass:
    def __init__(self, param):
        self.param = param
        
    def method(self):
        return self.param
</code></pre></div>    </div>
  </li>
  <li><strong>7.2 属性与方法</strong>
    <ul>
      <li>实例属性</li>
      <li>类属性</li>
      <li>实例方法</li>
      <li>类方法：<code class="language-plaintext highlighter-rouge">@classmethod</code></li>
      <li>静态方法：<code class="language-plaintext highlighter-rouge">@staticmethod</code></li>
    </ul>
  </li>
  <li><strong>7.3 继承</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class ChildClass(ParentClass):
    def __init__(self, param):
        super().__init__(param)
</code></pre></div>    </div>
    <ul>
      <li>单继承与多继承</li>
      <li>方法重写</li>
      <li><code class="language-plaintext highlighter-rouge">super()</code> 函数</li>
    </ul>
  </li>
  <li><strong>7.4 特殊方法</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">__init__()</code>：构造方法</li>
      <li><code class="language-plaintext highlighter-rouge">__str__()</code>、<code class="language-plaintext highlighter-rouge">__repr__()</code>：字符串表示</li>
      <li><code class="language-plaintext highlighter-rouge">__len__()</code>、<code class="language-plaintext highlighter-rouge">__getitem__()</code>、<code class="language-plaintext highlighter-rouge">__setitem__()</code>：容器方法</li>
      <li><code class="language-plaintext highlighter-rouge">__eq__()</code>、<code class="language-plaintext highlighter-rouge">__lt__()</code> 等：比较方法</li>
      <li><code class="language-plaintext highlighter-rouge">__add__()</code>、<code class="language-plaintext highlighter-rouge">__mul__()</code> 等：运算符重载</li>
    </ul>
  </li>
  <li><strong>7.5 属性访问控制</strong>
    <ul>
      <li>公有属性</li>
      <li>私有属性：<code class="language-plaintext highlighter-rouge">_</code> 和 <code class="language-plaintext highlighter-rouge">__</code> 前缀</li>
      <li><code class="language-plaintext highlighter-rouge">@property</code> 装饰器</li>
    </ul>
  </li>
  <li><strong>7.6 高级主题</strong>
    <ul>
      <li>抽象基类</li>
      <li>元类</li>
      <li>描述符</li>
      <li>混入类</li>
    </ul>
  </li>
</ul>

<h2 id="八-文件操作">八、 文件操作</h2>
<ul>
  <li><strong>8.1 文件打开与关闭</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">open()</code> 函数</li>
      <li>文件模式：<code class="language-plaintext highlighter-rouge">'r'</code>、<code class="language-plaintext highlighter-rouge">'w'</code>、<code class="language-plaintext highlighter-rouge">'a'</code>、<code class="language-plaintext highlighter-rouge">'b'</code>、<code class="language-plaintext highlighter-rouge">'+'</code></li>
      <li><code class="language-plaintext highlighter-rouge">close()</code> 方法</li>
      <li><code class="language-plaintext highlighter-rouge">with</code> 语句</li>
    </ul>
  </li>
  <li><strong>8.2 文件读写</strong>
    <ul>
      <li>读取：<code class="language-plaintext highlighter-rouge">read()</code>、<code class="language-plaintext highlighter-rouge">readline()</code>、<code class="language-plaintext highlighter-rouge">readlines()</code></li>
      <li>写入：<code class="language-plaintext highlighter-rouge">write()</code>、<code class="language-plaintext highlighter-rouge">writelines()</code></li>
    </ul>
  </li>
  <li><strong>8.3 文件指针操作</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">seek()</code> 方法</li>
      <li><code class="language-plaintext highlighter-rouge">tell()</code> 方法</li>
    </ul>
  </li>
  <li><strong>8.4 文件与目录管理</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">os</code> 模块：<code class="language-plaintext highlighter-rouge">listdir()</code>、<code class="language-plaintext highlighter-rouge">mkdir()</code>、<code class="language-plaintext highlighter-rouge">remove()</code>、<code class="language-plaintext highlighter-rouge">rename()</code></li>
      <li><code class="language-plaintext highlighter-rouge">os.path</code> 模块：<code class="language-plaintext highlighter-rouge">exists()</code>、<code class="language-plaintext highlighter-rouge">isdir()</code>、<code class="language-plaintext highlighter-rouge">isfile()</code>、<code class="language-plaintext highlighter-rouge">join()</code></li>
      <li><code class="language-plaintext highlighter-rouge">shutil</code> 模块：文件复制、移动、删除</li>
    </ul>
  </li>
</ul>

<h2 id="九-异常处理进阶">九、 异常处理进阶</h2>
<ul>
  <li><strong>9.1 异常层次结构</strong>
    <ul>
      <li>BaseException</li>
      <li>Exception</li>
      <li>标准异常类</li>
    </ul>
  </li>
  <li><strong>9.2 自定义异常</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class MyException(Exception):
    def __init__(self, message):
        self.message = message
</code></pre></div>    </div>
  </li>
  <li><strong>9.3 异常链</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">raise ... from ...</code></li>
    </ul>
  </li>
  <li><strong>9.4 警告处理</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">warnings</code> 模块</li>
    </ul>
  </li>
</ul>

<h2 id="十-并发编程">十、 并发编程</h2>
<ul>
  <li><strong>10.1 多线程</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">threading</code> 模块</li>
      <li>创建线程</li>
      <li>线程同步：<code class="language-plaintext highlighter-rouge">Lock</code>、<code class="language-plaintext highlighter-rouge">RLock</code>、<code class="language-plaintext highlighter-rouge">Semaphore</code>、<code class="language-plaintext highlighter-rouge">Event</code>、<code class="language-plaintext highlighter-rouge">Condition</code></li>
      <li>线程间通信：<code class="language-plaintext highlighter-rouge">Queue</code></li>
    </ul>
  </li>
  <li><strong>10.2 多进程</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">multiprocessing</code> 模块</li>
      <li>创建进程</li>
      <li>进程间通信：<code class="language-plaintext highlighter-rouge">Pipe</code>、<code class="language-plaintext highlighter-rouge">Queue</code>、<code class="language-plaintext highlighter-rouge">Manager</code></li>
      <li>进程池</li>
    </ul>
  </li>
  <li><strong>10.3 异步编程</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">asyncio</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">async</code>/<code class="language-plaintext highlighter-rouge">await</code> 语法</li>
      <li>协程</li>
      <li>异步IO操作</li>
    </ul>
  </li>
</ul>

<h2 id="十一-网络编程">十一、 网络编程</h2>
<ul>
  <li><strong>11.1 Socket 编程</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">socket</code> 模块</li>
      <li>TCP 客户端/服务器</li>
      <li>UDP 客户端/服务器</li>
    </ul>
  </li>
  <li><strong>11.2 HTTP 编程</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">http.client</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">urllib</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">requests</code> 第三方库</li>
    </ul>
  </li>
  <li><strong>11.3 Web 框架基础</strong>
    <ul>
      <li>Flask 简介</li>
      <li>Django 简介</li>
      <li>FastAPI 简介</li>
    </ul>
  </li>
</ul>

<h2 id="十二-数据库编程">十二、 数据库编程</h2>
<ul>
  <li><strong>12.1 SQLite</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">sqlite3</code> 模块</li>
    </ul>
  </li>
  <li><strong>12.2 MySQL</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">mysql-connector-python</code></li>
      <li><code class="language-plaintext highlighter-rouge">pymysql</code></li>
    </ul>
  </li>
  <li><strong>12.3 PostgreSQL</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">psycopg2</code></li>
    </ul>
  </li>
  <li><strong>12.4 ORM</strong>
    <ul>
      <li>SQLAlchemy</li>
      <li>Django ORM</li>
    </ul>
  </li>
  <li><strong>12.5 NoSQL</strong>
    <ul>
      <li>MongoDB：<code class="language-plaintext highlighter-rouge">pymongo</code></li>
      <li>Redis：<code class="language-plaintext highlighter-rouge">redis</code></li>
    </ul>
  </li>
</ul>

<h2 id="十三-测试与调试">十三、 测试与调试</h2>
<ul>
  <li><strong>13.1 调试工具</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">pdb</code> 调试器</li>
      <li><code class="language-plaintext highlighter-rouge">logging</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">assert</code> 语句</li>
    </ul>
  </li>
  <li><strong>13.2 单元测试</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">unittest</code> 框架</li>
      <li><code class="language-plaintext highlighter-rouge">pytest</code> 框架</li>
    </ul>
  </li>
  <li><strong>13.3 性能分析</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">timeit</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">cProfile</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">line_profiler</code> 第三方库</li>
    </ul>
  </li>
</ul>

<h2 id="十四-代码规范与工程化">十四、 代码规范与工程化</h2>
<ul>
  <li><strong>14.1 代码规范</strong>
    <ul>
      <li>PEP 8</li>
      <li>代码格式化工具：<code class="language-plaintext highlighter-rouge">black</code>、<code class="language-plaintext highlighter-rouge">autopep8</code></li>
      <li>代码检查工具：<code class="language-plaintext highlighter-rouge">pylint</code>、<code class="language-plaintext highlighter-rouge">flake8</code></li>
    </ul>
  </li>
  <li><strong>14.2 项目结构</strong>
    <ul>
      <li>模块化设计</li>
      <li>包管理</li>
      <li>配置文件</li>
    </ul>
  </li>
  <li><strong>14.3 文档</strong>
    <ul>
      <li>文档字符串</li>
      <li>Sphinx 文档生成</li>
    </ul>
  </li>
  <li><strong>14.4 版本控制</strong>
    <ul>
      <li>Git 基础</li>
      <li>GitHub/GitLab 使用</li>
    </ul>
  </li>
  <li><strong>14.5 打包与发布</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">setuptools</code></li>
      <li><code class="language-plaintext highlighter-rouge">wheel</code></li>
      <li>发布到 PyPI</li>
    </ul>
  </li>
</ul>

<h2 id="十五-高级主题">十五、 高级主题</h2>
<ul>
  <li><strong>15.1 元编程</strong>
    <ul>
      <li>装饰器高级用法</li>
      <li>元类</li>
      <li>描述符协议</li>
    </ul>
  </li>
  <li><strong>15.2 类型注解</strong>
    <ul>
      <li>类型提示</li>
      <li><code class="language-plaintext highlighter-rouge">typing</code> 模块</li>
      <li><code class="language-plaintext highlighter-rouge">mypy</code> 静态类型检查</li>
    </ul>
  </li>
  <li><strong>15.3 并发模式</strong>
    <ul>
      <li>生产者-消费者模式</li>
      <li>线程池/进程池模式</li>
      <li>异步模式</li>
    </ul>
  </li>
  <li><strong>15.4 内存管理</strong>
    <ul>
      <li>引用计数</li>
      <li>垃圾回收</li>
      <li>内存分析工具</li>
    </ul>
  </li>
  <li><strong>15.5 C 扩展</strong>
    <ul>
      <li>Cython</li>
      <li>ctypes</li>
      <li>CFFI</li>
    </ul>
  </li>
</ul>

<h2 id="十六-应用领域">十六、 应用领域</h2>
<ul>
  <li><strong>16.1 Web 开发</strong>
    <ul>
      <li>Django/Flask/FastAPI</li>
      <li>RESTful API</li>
      <li>WebSocket</li>
    </ul>
  </li>
  <li><strong>16.2 数据分析</strong>
    <ul>
      <li>NumPy</li>
      <li>pandas</li>
      <li>Matplotlib</li>
      <li>SciPy</li>
    </ul>
  </li>
  <li><strong>16.3 机器学习</strong>
    <ul>
      <li>scikit-learn</li>
      <li>TensorFlow</li>
      <li>PyTorch</li>
    </ul>
  </li>
  <li><strong>16.4 网络爬虫</strong>
    <ul>
      <li>Requests</li>
      <li>BeautifulSoup</li>
      <li>Scrapy</li>
    </ul>
  </li>
  <li><strong>16.5 自动化运维</strong>
    <ul>
      <li>系统管理</li>
      <li>网络管理</li>
      <li>监控告警</li>
    </ul>
  </li>
  <li><strong>16.6 游戏开发</strong>
    <ul>
      <li>Pygame</li>
      <li>PyOpenGL</li>
    </ul>
  </li>
</ul>

<h2 id="十七-学习资源">十七、 学习资源</h2>
<ul>
  <li><strong>17.1 官方文档</strong>
    <ul>
      <li>Python 官方文档</li>
      <li>PEP 索引</li>
    </ul>
  </li>
  <li><strong>17.2 在线学习平台</strong>
    <ul>
      <li>Coursera</li>
      <li>edX</li>
      <li>中国大学 MOOC</li>
    </ul>
  </li>
  <li><strong>17.3 书籍推荐</strong>
    <ul>
      <li>入门：《Python编程：从入门到实践》</li>
      <li>进阶：《流畅的Python》</li>
      <li>算法：《Python算法教程》</li>
    </ul>
  </li>
  <li><strong>17.4 社区与论坛</strong>
    <ul>
      <li>Stack Overflow</li>
      <li>GitHub</li>
      <li>Python 中文社区</li>
    </ul>
  </li>
  <li><strong>17.5 实践项目</strong>
    <ul>
      <li>Web 应用开发</li>
      <li>数据分析项目</li>
      <li>自动化脚本编写</li>
      <li>开源项目贡献</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="Python" /><category term="Python" /><summary type="html"><![CDATA[Python 编程语言 系统学习大纲]]></summary></entry><entry><title type="html">unittest相关</title><link href="https://xdh2580.github.io/unittest/unittest/" rel="alternate" type="text/html" title="unittest相关" /><published>2026-03-24T00:00:00+00:00</published><updated>2026-03-24T00:00:00+00:00</updated><id>https://xdh2580.github.io/unittest/unittest</id><content type="html" xml:base="https://xdh2580.github.io/unittest/unittest/"><![CDATA[<h1 id="python-unittest-单元测试框架-系统学习大纲">Python unittest 单元测试框架 系统学习大纲</h1>

<h2 id="一-unittest-框架概述">一、 unittest 框架概述</h2>
<ul>
  <li><strong>1.1 单元测试的重要性</strong>
    <ul>
      <li>验证代码最小单元（函数、方法、类）的正确性</li>
      <li>提高代码质量，减少bug</li>
      <li>支持重构，确保修改不会破坏现有功能</li>
      <li>作为代码文档，展示如何使用被测试代码</li>
    </ul>
  </li>
  <li><strong>1.2 unittest 框架简介</strong>
    <ul>
      <li>Python标准库自带的单元测试框架</li>
      <li>受到JUnit的启发，采用xUnit风格</li>
      <li>提供完整的测试基础设施：测试发现、执行、报告</li>
    </ul>
  </li>
  <li><strong>1.3 unittest 核心概念</strong>
    <ul>
      <li><strong>测试用例 (TestCase)</strong>：测试的基本单元</li>
      <li><strong>测试固件 (Fixture)</strong>：测试运行前后的设置和清理</li>
      <li><strong>测试套件 (TestSuite)</strong>：测试用例的集合</li>
      <li><strong>测试运行器 (TestRunner)</strong>：执行测试并展示结果</li>
      <li><strong>断言 (Assertion)</strong>：验证代码行为是否符合预期</li>
    </ul>
  </li>
</ul>

<h2 id="二-环境搭建与第一个测试">二、 环境搭建与第一个测试</h2>
<ul>
  <li><strong>2.1 unittest 内置特性</strong>
    <ul>
      <li>Python标准库的一部分，无需额外安装</li>
      <li>适用于Python 2.7+ 和 Python 3.x</li>
    </ul>
  </li>
  <li><strong>2.2 创建第一个测试用例</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>python
import unittest
class TestStringMethods(unittest.TestCase):
def test_upper(self):
    self.assertEqual('foo'.upper(), 'FOO')
    
def test_isupper(self):
    self.assertTrue('FOO'.isupper())
    self.assertFalse('Foo'.isupper())

if __name__ == '__main__':
unittest.main()
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="三-测试用例-testcase-详解">三、 测试用例 (TestCase) 详解</h2>
<ul>
  <li><strong>3.1 测试方法命名规范</strong>
    <ul>
      <li>测试方法必须以<code class="language-plaintext highlighter-rouge">test_</code>开头</li>
      <li>这是测试发现机制识别测试方法的方式</li>
      <li>方法名应该描述要测试的功能</li>
    </ul>
  </li>
  <li><strong>3.2 测试类的组织结构</strong>
    <ul>
      <li>继承<code class="language-plaintext highlighter-rouge">unittest.TestCase</code>类</li>
      <li>一个测试类通常测试一个模块或一个类</li>
      <li>相关的测试方法组织在同一个测试类中</li>
    </ul>
  </li>
  <li><strong>3.3 跳过测试</strong>
    <ul>
      <li>使用<code class="language-plaintext highlighter-rouge">@unittest.skip(reason)</code>装饰器无条件跳过</li>
      <li>使用<code class="language-plaintext highlighter-rouge">@unittest.skipIf(condition, reason)</code>条件跳过</li>
      <li>使用<code class="language-plaintext highlighter-rouge">@unittest.skipUnless(condition, reason)</code>条件跳过</li>
      <li>在测试方法中使用<code class="language-plaintext highlighter-rouge">self.skipTest(reason)</code>方法跳过</li>
    </ul>
  </li>
  <li><strong>3.4 预期失败测试</strong>
    <ul>
      <li>使用<code class="language-plaintext highlighter-rouge">@unittest.expectedFailure</code>装饰器标记预期失败的测试</li>
      <li>如果测试通过，则标记为”unexpected success”</li>
      <li>如果测试失败，则标记为”expected failure”</li>
    </ul>
  </li>
</ul>

<h2 id="四-断言方法-assertions">四、 断言方法 (Assertions)</h2>
<ul>
  <li><strong>4.1 基本断言方法</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertEqual(a, b, msg=None)</code>：a == b</li>
      <li><code class="language-plaintext highlighter-rouge">assertNotEqual(a, b, msg=None)</code>：a != b</li>
      <li><code class="language-plaintext highlighter-rouge">assertTrue(x, msg=None)</code>：bool(x) is True</li>
      <li><code class="language-plaintext highlighter-rouge">assertFalse(x, msg=None)</code>：bool(x) is False</li>
      <li><code class="language-plaintext highlighter-rouge">assertIs(a, b, msg=None)</code>：a is b</li>
      <li><code class="language-plaintext highlighter-rouge">assertIsNot(a, b, msg=None)</code>：a is not b</li>
      <li><code class="language-plaintext highlighter-rouge">assertIsNone(x, msg=None)</code>：x is None</li>
      <li><code class="language-plaintext highlighter-rouge">assertIsNotNone(x, msg=None)</code>：x is not None</li>
      <li><code class="language-plaintext highlighter-rouge">assertIn(a, b, msg=None)</code>：a in b</li>
      <li><code class="language-plaintext highlighter-rouge">assertNotIn(a, b, msg=None)</code>：a not in b</li>
    </ul>
  </li>
  <li><strong>4.2 比较断言方法</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertGreater(a, b, msg=None)</code>：a &gt; b</li>
      <li><code class="language-plaintext highlighter-rouge">assertGreaterEqual(a, b, msg=None)</code>：a &gt;= b</li>
      <li><code class="language-plaintext highlighter-rouge">assertLess(a, b, msg=None)</code>：a &lt; b</li>
      <li><code class="language-plaintext highlighter-rouge">assertLessEqual(a, b, msg=None)</code>：a &lt;= b</li>
    </ul>
  </li>
  <li><strong>4.3 异常和警告断言</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertRaises(exception, callable, *args, **kwargs)</code>：验证调用callable时抛出指定异常</li>
      <li><code class="language-plaintext highlighter-rouge">assertRaisesRegex(exception, regex, callable, *args, **kwargs)</code>：验证异常消息匹配正则表达式</li>
      <li><code class="language-plaintext highlighter-rouge">assertWarns(warning, callable, *args, **kwargs)</code>：验证调用callable时发出指定警告</li>
      <li><code class="language-plaintext highlighter-rouge">assertWarnsRegex(warning, regex, callable, *args, **kwargs)</code>：验证警告消息匹配正则表达式</li>
    </ul>
  </li>
  <li><strong>4.4 序列和容器断言</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertListEqual(a, b, msg=None)</code>：比较列表</li>
      <li><code class="language-plaintext highlighter-rouge">assertTupleEqual(a, b, msg=None)</code>：比较元组</li>
      <li><code class="language-plaintext highlighter-rouge">assertSetEqual(a, b, msg=None)</code>：比较集合</li>
      <li><code class="language-plaintext highlighter-rouge">assertDictEqual(a, b, msg=None)</code>：比较字典</li>
      <li><code class="language-plaintext highlighter-rouge">assertSequenceEqual(a, b, msg=None)</code>：比较序列</li>
      <li><code class="language-plaintext highlighter-rouge">assertMultiLineEqual(a, b, msg=None)</code>：比较多行字符串</li>
    </ul>
  </li>
  <li><strong>4.5 近似值断言</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertAlmostEqual(a, b, places=7, msg=None)</code>：round(a-b, places) == 0</li>
      <li><code class="language-plaintext highlighter-rouge">assertNotAlmostEqual(a, b, places=7, msg=None)</code>：round(a-b, places) != 0</li>
    </ul>
  </li>
  <li><strong>4.6 正则表达式断言</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">assertRegex(text, regex, msg=None)</code>：text匹配regex</li>
      <li><code class="language-plaintext highlighter-rouge">assertNotRegex(text, regex, msg=None)</code>：text不匹配regex</li>
    </ul>
  </li>
  <li><strong>4.7 自定义失败消息</strong>
    <ul>
      <li>所有断言方法都接受可选的<code class="language-plaintext highlighter-rouge">msg</code>参数</li>
      <li>当断言失败时，会显示自定义消息</li>
    </ul>
  </li>
</ul>

<h2 id="五-测试固件-test-fixtures">五、 测试固件 (Test Fixtures)</h2>
<ul>
  <li><strong>5.1 方法级别的固件</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">setUp()</code>：在每个测试方法执行前调用</li>
      <li><code class="language-plaintext highlighter-rouge">tearDown()</code>：在每个测试方法执行后调用</li>
      <li>用于准备测试环境和清理资源</li>
    </ul>
  </li>
  <li><strong>5.2 类级别的固件</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">setUpClass()</code>：在整个测试类开始执行前调用一次（使用<code class="language-plaintext highlighter-rouge">@classmethod</code>装饰器）</li>
      <li><code class="language-plaintext highlighter-rouge">tearDownClass()</code>：在整个测试类结束后调用一次（使用<code class="language-plaintext highlighter-rouge">@classmethod</code>装饰器）</li>
      <li>用于执行耗时的初始化操作，如数据库连接</li>
    </ul>
  </li>
  <li><strong>5.3 模块级别的固件</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">setUpModule()</code>：在模块中的所有测试开始前执行</li>
      <li><code class="language-plaintext highlighter-rouge">tearDownModule()</code>：在模块中的所有测试结束后执行</li>
      <li>直接在模块中定义，不是测试类的一部分</li>
    </ul>
  </li>
  <li><strong>5.4 固件执行顺序</strong>
    <ol>
      <li><code class="language-plaintext highlighter-rouge">setUpModule()</code></li>
      <li><code class="language-plaintext highlighter-rouge">setUpClass()</code></li>
      <li><code class="language-plaintext highlighter-rouge">setUp()</code></li>
      <li>测试方法</li>
      <li><code class="language-plaintext highlighter-rouge">tearDown()</code></li>
      <li><code class="language-plaintext highlighter-rouge">tearDownClass()</code></li>
      <li><code class="language-plaintext highlighter-rouge">tearDownModule()</code></li>
    </ol>
  </li>
</ul>

<h2 id="六-测试套件-testsuite-与测试发现">六、 测试套件 (TestSuite) 与测试发现</h2>
<ul>
  <li><strong>6.1 手动创建测试套件</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>import unittest

def suite():
    suite = unittest.TestSuite()
    suite.addTest(TestStringMethods('test_upper'))
    suite.addTest(TestStringMethods('test_isupper'))
    # 或添加整个测试类
    suite.addTest(unittest.makeSuite(TestStringMethods))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    runner.run(suite())
</code></pre></div>    </div>
  </li>
  <li><strong>6.2 自动测试发现</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">unittest.discover(start_dir, pattern='test*.py', top_level_dir=None)</code></li>
      <li>自动发现指定目录下的所有测试</li>
      <li>命令行使用：<code class="language-plaintext highlighter-rouge">python -m unittest discover -s project_directory -p "test_*.py"</code></li>
    </ul>
  </li>
  <li><strong>6.3 测试发现的参数</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">-s</code> 或 <code class="language-plaintext highlighter-rouge">--start-directory</code>：开始发现的目录</li>
      <li><code class="language-plaintext highlighter-rouge">-p</code> 或 <code class="language-plaintext highlighter-rouge">--pattern</code>：匹配测试文件的模式</li>
      <li><code class="language-plaintext highlighter-rouge">-t</code> 或 <code class="language-plaintext highlighter-rouge">--top-level-directory</code>：项目的顶级目录</li>
      <li><code class="language-plaintext highlighter-rouge">-v</code> 或 <code class="language-plaintext highlighter-rouge">--verbose</code>：详细输出</li>
    </ul>
  </li>
</ul>

<h2 id="七-测试运行器-testrunner-与测试结果">七、 测试运行器 (TestRunner) 与测试结果</h2>
<ul>
  <li><strong>7.1 TextTestRunner</strong>
    <ul>
      <li>默认的测试运行器</li>
      <li>在控制台输出文本格式的结果</li>
      <li>可以指定详细程度：<code class="language-plaintext highlighter-rouge">runner = unittest.TextTestRunner(verbosity=2)</code></li>
    </ul>
  </li>
  <li><strong>7.2 测试结果对象</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">TestResult</code> 类存储测试结果</li>
      <li>包含测试通过、失败、错误、跳过的数量</li>
      <li>可以自定义结果处理</li>
    </ul>
  </li>
  <li><strong>7.3 自定义测试运行器</strong>
    <ul>
      <li>继承<code class="language-plaintext highlighter-rouge">unittest.TextTestRunner</code>类</li>
      <li>重写<code class="language-plaintext highlighter-rouge">_makeResult</code>方法</li>
      <li>创建自定义的<code class="language-plaintext highlighter-rouge">TestResult</code>子类</li>
    </ul>
  </li>
  <li><strong>7.4 测试结果格式</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">.</code>：测试通过</li>
      <li><code class="language-plaintext highlighter-rouge">F</code>：测试失败</li>
      <li><code class="language-plaintext highlighter-rouge">E</code>：测试错误</li>
      <li><code class="language-plaintext highlighter-rouge">s</code>：测试跳过</li>
      <li><code class="language-plaintext highlighter-rouge">x</code>：预期失败</li>
      <li><code class="language-plaintext highlighter-rouge">u</code>：意外成功</li>
    </ul>
  </li>
</ul>

<h2 id="八-mock-对象与补丁">八、 Mock 对象与补丁</h2>
<ul>
  <li><strong>8.1 unittest.mock 模块简介</strong>
    <ul>
      <li>Python 3.3+ 内置，Python 2.7 需要单独安装<code class="language-plaintext highlighter-rouge">mock</code>库</li>
      <li>用于替换测试中的依赖项</li>
      <li>创建模拟对象，验证调用</li>
    </ul>
  </li>
  <li><strong>8.2 Mock 对象</strong>
    <ul>
      <li>创建Mock对象：<code class="language-plaintext highlighter-rouge">mock_obj = Mock()</code></li>
      <li>配置返回值：<code class="language-plaintext highlighter-rouge">mock_obj.method.return_value = 42</code></li>
      <li>配置副作用：<code class="language-plaintext highlighter-rouge">mock_obj.method.side_effect = Exception('Error')</code></li>
      <li>验证调用：<code class="language-plaintext highlighter-rouge">mock_obj.method.assert_called_once_with(arg1, arg2)</code></li>
    </ul>
  </li>
  <li><strong>8.3 MagicMock 对象</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">MagicMock</code>是<code class="language-plaintext highlighter-rouge">Mock</code>的子类</li>
      <li>预定义了所有魔术方法</li>
      <li>适用于模拟需要支持Python协议的对象</li>
    </ul>
  </li>
  <li><strong>8.4 补丁 (patching)</strong>
    <ul>
      <li><strong>装饰器方式</strong>：<code class="language-plaintext highlighter-rouge">@patch('module.ClassName')</code></li>
      <li><strong>上下文管理器方式</strong>：<code class="language-plaintext highlighter-rouge">with patch('module.function'):</code></li>
      <li><strong>手动起停方式</strong>：<code class="language-plaintext highlighter-rouge">patcher = patch('module.attribute'); mock_obj = patcher.start()</code></li>
      <li>可以补丁类、函数、属性、字典等</li>
    </ul>
  </li>
  <li><strong>8.5 patch.object</strong>
    <ul>
      <li>补丁对象的特定属性</li>
      <li><code class="language-plaintext highlighter-rouge">@patch.object(SomeClass, 'class_method')</code></li>
    </ul>
  </li>
  <li><strong>8.6 常见mock使用场景</strong>
    <ul>
      <li>模拟外部API调用</li>
      <li>模拟数据库操作</li>
      <li>模拟文件系统操作</li>
      <li>模拟网络请求</li>
      <li>模拟随机数生成</li>
    </ul>
  </li>
</ul>

<h2 id="九-子测试-subtests">九、 子测试 (Subtests)</h2>
<ul>
  <li><strong>9.1 子测试的概念</strong>
    <ul>
      <li>允许在一个测试方法中运行多个相似的测试</li>
      <li>当子测试失败时，不会终止整个测试方法</li>
      <li>可以识别是哪个子测试失败了</li>
    </ul>
  </li>
  <li><strong>9.2 使用子测试</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class NumbersTest(unittest.TestCase):
    def test_even(self):
        for i in range(0, 6):
            with self.subTest(i=i):
                self.assertEqual(i % 2, 0)
</code></pre></div>    </div>
  </li>
  <li><strong>9.3 子测试的优势</strong>
    <ul>
      <li>减少重复代码</li>
      <li>更清晰的测试输出</li>
      <li>并行测试多个场景</li>
    </ul>
  </li>
</ul>

<h2 id="十-测试加载器与自定义">十、 测试加载器与自定义</h2>
<ul>
  <li><strong>10.1 TestLoader 类</strong>
    <ul>
      <li>负责加载测试</li>
      <li>默认使用<code class="language-plaintext highlighter-rouge">unittest.defaultTestLoader</code></li>
      <li>可以自定义测试加载规则</li>
    </ul>
  </li>
  <li><strong>10.2 自定义测试加载</strong>
    <ul>
      <li>重写<code class="language-plaintext highlighter-rouge">loadTestsFromModule</code>、<code class="language-plaintext highlighter-rouge">loadTestsFromTestCase</code>、<code class="language-plaintext highlighter-rouge">loadTestsFromName</code>方法</li>
      <li>自定义测试发现逻辑</li>
    </ul>
  </li>
  <li><strong>10.3 测试用例排序</strong>
    <ul>
      <li>默认按测试方法名的字母顺序执行</li>
      <li>使用<code class="language-plaintext highlighter-rouge">unittest.TestLoader.sortTestMethodsUsing</code>自定义排序</li>
      <li>可以实现测试之间的依赖关系</li>
    </ul>
  </li>
</ul>

<h2 id="十一-与其它工具集成">十一、 与其它工具集成</h2>
<ul>
  <li><strong>11.1 与 doctest 集成</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">unittest</code>可以运行<code class="language-plaintext highlighter-rouge">doctest</code>测试</li>
      <li><code class="language-plaintext highlighter-rouge">unittest.main()</code>会自动发现和运行doctest</li>
    </ul>
  </li>
  <li><strong>11.2 测试覆盖率</strong>
    <ul>
      <li>使用<code class="language-plaintext highlighter-rouge">coverage.py</code>测量测试覆盖率</li>
      <li>安装：<code class="language-plaintext highlighter-rouge">pip install coverage</code></li>
      <li>运行：<code class="language-plaintext highlighter-rouge">coverage run -m unittest discover</code></li>
      <li>报告：<code class="language-plaintext highlighter-rouge">coverage report</code> 或 <code class="language-plaintext highlighter-rouge">coverage html</code></li>
    </ul>
  </li>
  <li><strong>11.3 与 pytest 结合使用</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">pytest</code>可以运行<code class="language-plaintext highlighter-rouge">unittest</code>测试用例</li>
      <li>可以混合使用<code class="language-plaintext highlighter-rouge">unittest</code>和<code class="language-plaintext highlighter-rouge">pytest</code>风格</li>
    </ul>
  </li>
  <li><strong>11.4 持续集成</strong>
    <ul>
      <li>Jenkins, Travis CI, GitHub Actions等CI工具支持unittest</li>
      <li>通常通过<code class="language-plaintext highlighter-rouge">python -m unittest discover</code>运行测试</li>
      <li>可以生成JUnit格式的XML报告</li>
    </ul>
  </li>
</ul>

<h2 id="十二-最佳实践与常见模式">十二、 最佳实践与常见模式</h2>
<ul>
  <li><strong>12.1 测试组织结构</strong>
    <ul>
      <li>测试代码与生产代码分离</li>
      <li>测试文件以<code class="language-plaintext highlighter-rouge">test_</code>开头</li>
      <li>测试类以<code class="language-plaintext highlighter-rouge">Test</code>开头</li>
      <li>测试方法以<code class="language-plaintext highlighter-rouge">test_</code>开头</li>
    </ul>
  </li>
  <li><strong>12.2 测试设计原则</strong>
    <ul>
      <li>每个测试只测试一个功能</li>
      <li>测试应该是独立的，不依赖执行顺序</li>
      <li>使用有意义的测试名称</li>
      <li>测试应该快速执行</li>
    </ul>
  </li>
  <li><strong>12.3 测试数据库操作</strong>
    <ul>
      <li>使用内存数据库（如SQLite）</li>
      <li>使用测试固件准备测试数据</li>
      <li>每个测试后清理数据</li>
    </ul>
  </li>
  <li><strong>12.4 测试Web应用</strong>
    <ul>
      <li>使用测试客户端模拟HTTP请求</li>
      <li>Flask-Testing, Django测试工具</li>
    </ul>
  </li>
  <li><strong>12.5 测试异步代码</strong>
    <ul>
      <li>Python 3.8+ 支持异步测试</li>
      <li>使用<code class="language-plaintext highlighter-rouge">IsolatedAsyncioTestCase</code></li>
      <li>使用<code class="language-plaintext highlighter-rouge">async/await</code>语法</li>
    </ul>
  </li>
</ul>

<h2 id="十三-常见问题与调试">十三、 常见问题与调试</h2>
<ul>
  <li><strong>13.1 测试失败与错误</strong>
    <ul>
      <li><strong>失败 (Failure)</strong>：断言失败</li>
      <li><strong>错误 (Error)</strong>：测试代码本身有异常</li>
      <li>查看详细的失败信息定位问题</li>
    </ul>
  </li>
  <li><strong>13.2 测试调试技巧</strong>
    <ul>
      <li>使用<code class="language-plaintext highlighter-rouge">pdb</code>调试器</li>
      <li>在测试中打印调试信息</li>
      <li>使用<code class="language-plaintext highlighter-rouge">-v</code>参数获取详细输出</li>
    </ul>
  </li>
  <li><strong>13.3 测试性能问题</strong>
    <ul>
      <li>避免在测试中执行耗时操作</li>
      <li>使用mock替代外部依赖</li>
      <li>考虑使用<code class="language-plaintext highlighter-rouge">setUpClass</code>代替<code class="language-plaintext highlighter-rouge">setUp</code></li>
    </ul>
  </li>
</ul>

<h2 id="十四-实战示例与项目结构">十四、 实战示例与项目结构</h2>
<ul>
  <li><strong>14.1 简单函数测试</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code># calculator.py
def add(a, b):
    return a + b

# test_calculator.py
import unittest
from calculator import add

class TestCalculator(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add(2, 3), 5)
        
    def test_add_negative_numbers(self):
        self.assertEqual(add(-1, -1), -2)
</code></pre></div>    </div>
  </li>
  <li><strong>14.2 类测试示例</strong></li>
  <li><strong>14.3 使用mock的测试示例</strong></li>
  <li><strong>14.4 典型项目结构</strong>
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>project/
├── src/
│   ├── __init__.py
│   ├── module1.py
│   └── module2.py
├── tests/
│   ├── __init__.py
│   ├── test_module1.py
│   ├── test_module2.py
│   └── integration/
│       └── test_integration.py
├── setup.py
└── requirements.txt
</code></pre></div>    </div>
  </li>
</ul>

<h2 id="十五-进阶主题">十五、 进阶主题</h2>
<ul>
  <li><strong>15.1 参数化测试</strong>
    <ul>
      <li>使用第三方库<code class="language-plaintext highlighter-rouge">parameterized</code></li>
      <li>安装：<code class="language-plaintext highlighter-rouge">pip install parameterized</code></li>
      <li>使用<code class="language-plaintext highlighter-rouge">@parameterized.expand</code>装饰器</li>
    </ul>
  </li>
  <li><strong>15.2 测试夹具工厂</strong>
    <ul>
      <li>创建可重用的测试数据</li>
      <li>使用工厂模式生成测试对象</li>
    </ul>
  </li>
  <li><strong>15.3 测试并行执行</strong>
    <ul>
      <li>使用第三方库加速测试执行</li>
      <li><code class="language-plaintext highlighter-rouge">pytest-xdist</code>支持并行运行unittest测试</li>
    </ul>
  </li>
  <li><strong>15.4 自定义断言</strong>
    <ul>
      <li>创建领域特定的断言方法</li>
      <li>继承<code class="language-plaintext highlighter-rouge">unittest.TestCase</code>并添加自定义断言</li>
    </ul>
  </li>
</ul>

<h2 id="十六-资源与进一步学习">十六、 资源与进一步学习</h2>
<ul>
  <li><strong>16.1 官方文档</strong>
    <ul>
      <li>Python官方unittest文档</li>
      <li><code class="language-plaintext highlighter-rouge">unittest.mock</code>文档</li>
    </ul>
  </li>
  <li><strong>16.2 相关工具</strong>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">pytest</code>：功能更丰富的测试框架</li>
      <li><code class="language-plaintext highlighter-rouge">nose2</code>：unittest的扩展</li>
      <li><code class="language-plaintext highlighter-rouge">coverage.py</code>：测试覆盖率工具</li>
    </ul>
  </li>
  <li><strong>16.3 最佳实践资源</strong>
    <ul>
      <li>《Python测试驱动开发》</li>
      <li>《Python工匠：案例、技巧与工程实践》</li>
      <li>开源项目的测试代码参考</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="unittest" /><category term="unittest" /><summary type="html"><![CDATA[Python unittest 单元测试框架 系统学习大纲]]></summary></entry><entry><title type="html">软件测试基础和理论相关</title><link href="https://xdh2580.github.io/%E6%B5%8B%E8%AF%95%E7%90%86%E8%AE%BA/%E8%BD%AF%E4%BB%B6%E6%B5%8B%E8%AF%95%E5%9F%BA%E7%A1%80%E5%92%8C%E7%90%86%E8%AE%BA/" rel="alternate" type="text/html" title="软件测试基础和理论相关" /><published>2026-03-23T00:00:00+00:00</published><updated>2026-03-23T00:00:00+00:00</updated><id>https://xdh2580.github.io/%E6%B5%8B%E8%AF%95%E7%90%86%E8%AE%BA/%E8%BD%AF%E4%BB%B6%E6%B5%8B%E8%AF%95%E5%9F%BA%E7%A1%80%E5%92%8C%E7%90%86%E8%AE%BA</id><content type="html" xml:base="https://xdh2580.github.io/%E6%B5%8B%E8%AF%95%E7%90%86%E8%AE%BA/%E8%BD%AF%E4%BB%B6%E6%B5%8B%E8%AF%95%E5%9F%BA%E7%A1%80%E5%92%8C%E7%90%86%E8%AE%BA/"><![CDATA[<h1 id="软件测试理论与基础-完整学习大纲">软件测试理论与基础 完整学习大纲</h1>

<h2 id="一-软件测试基础概念">一、 软件测试基础概念</h2>
<ul>
  <li><strong>1.1 软件测试的定义与目标</strong>
    <ul>
      <li><strong>定义</strong>：通过运行或评价软件，以验证其是否满足规定要求或识别与实际结果之间的差异的过程。</li>
      <li><strong>核心目标</strong>：
        <ul>
          <li>发现缺陷（主要目标）。</li>
          <li>验证软件是否满足需求规格说明书和用户需求。</li>
          <li>建立对软件质量的信心。</li>
          <li>预防缺陷。</li>
        </ul>
      </li>
    </ul>
  </li>
  <li><strong>1.2 软件缺陷</strong>
    <ul>
      <li>定义：软件中存在的、会破坏其正常运行能力的问题、错误或故障。</li>
      <li>常见缺陷来源：需求、设计、编码、测试、环境。</li>
      <li>缺陷生命周期：新建 -&gt; 打开 -&gt; 分配 -&gt; 修复 -&gt; 验证 -&gt; 关闭（或重新打开）。</li>
    </ul>
  </li>
  <li><strong>1.3 质量、质量保证与质量控制</strong>
    <ul>
      <li><strong>软件质量</strong>：软件产品满足明确或隐含需求的能力的特性总和（ISO 9126模型）。</li>
      <li><strong>质量保证</strong>：一套有计划的、系统性的活动，确保开发过程遵循既定标准和规程，旨在<strong>预防</strong>缺陷。</li>
      <li><strong>质量控制</strong>：识别缺陷的操作技术和活动，旨在<strong>识别</strong>缺陷（如测试）。</li>
      <li><strong>QA vs QC</strong>：QA关注过程，QC关注产品。</li>
    </ul>
  </li>
  <li><strong>1.4 测试的基本原则（七大原则 - ISTQB）</strong>
    <ol>
      <li><strong>测试证明缺陷的存在</strong>：测试无法证明软件无缺陷。</li>
      <li><strong>穷尽测试是不可能的</strong>：必须基于风险和优先级进行测试。</li>
      <li><strong>尽早测试</strong>：测试活动应尽早介入开发生命周期，以降低成本。</li>
      <li><strong>缺陷集群性</strong>：缺陷往往集中存在于少数模块中。</li>
      <li><strong>杀虫剂悖论</strong>：重复同样的测试用例会发现的新缺陷越来越少。</li>
      <li><strong>测试活动依赖于上下文</strong>：没有一种“放之四海而皆准”的测试方法。</li>
      <li><strong>不存在缺陷的谬论</strong>：即使软件符合需求，但如果需求本身是错的，软件仍是不可用的。</li>
    </ol>
  </li>
</ul>

<h2 id="二-软件开发生命周期与测试模型">二、 软件开发生命周期与测试模型</h2>
<ul>
  <li><strong>2.1 软件开发生命周期 (SDLC) 模型</strong>
    <ul>
      <li><strong>瀑布模型</strong>：线性的、阶段性的开发模型，测试通常在开发后期进行。</li>
      <li><strong>V模型</strong>：强调测试与开发的并行性，每个开发阶段对应一个测试级别。</li>
      <li><strong>增量与迭代模型</strong>：软件被分解为多个部分，逐步构建和测试。</li>
      <li><strong>敏捷模型 (Scrum, Kanban, XP)</strong>：强调迭代、协作和快速响应变化。测试是每个迭代的核心部分。</li>
    </ul>
  </li>
  <li><strong>2.2 测试模型与测试过程</strong>
    <ul>
      <li><strong>测试过程</strong>：通用的测试活动集合，包括测试计划、设计、执行、评估、报告。</li>
      <li><strong>测试左移</strong>：在开发生命周期的早期引入测试活动（如需求评审、静态测试）。</li>
      <li><strong>测试右移</strong>：在软件发布后进行测试（如A/B测试、线上监控、众测）。</li>
      <li><strong>测试级别</strong>：与SDLC阶段对应的测试活动（组件、集成、系统、验收）。</li>
    </ul>
  </li>
</ul>

<h2 id="三-测试的层次与类型">三、 测试的层次与类型</h2>
<ul>
  <li><strong>3.1 测试级别</strong>
    <ul>
      <li><strong>单元测试</strong>：验证单个软件单元（如函数、类、模块）的功能。通常由开发者完成。</li>
      <li><strong>集成测试</strong>：验证多个单元、组件或系统之间的交互。关注接口和数据流。</li>
      <li><strong>系统测试</strong>：在完整的、集成的系统上执行测试，以验证其是否满足指定的需求。关注端到端流程。</li>
      <li><strong>验收测试</strong>：由用户/客户执行，以确定是否接受软件。包括：
        <ul>
          <li><strong>用户验收测试</strong>：验证是否满足用户需求。</li>
          <li><strong>运营验收测试</strong>：验证可维护性、兼容性、部署等。</li>
          <li><strong>Alpha/Beta测试</strong>：在受控/不受控的实际用户环境中进行。</li>
        </ul>
      </li>
    </ul>
  </li>
  <li><strong>3.2 测试类型 (按测试目标/特性分类)</strong>
    <ul>
      <li><strong>功能测试</strong>：验证软件功能是否符合需求规格。</li>
      <li><strong>非功能测试</strong>：验证软件的质量属性。
        <ul>
          <li><strong>性能测试</strong>：负载、压力、耐力、尖峰、容量测试。</li>
          <li><strong>安全性测试</strong>：漏洞、渗透、授权、认证测试。</li>
          <li><strong>可用性测试</strong>：用户界面、用户体验、可访问性。</li>
          <li><strong>兼容性测试</strong>：跨浏览器、跨平台、跨设备、向后兼容。</li>
          <li><strong>可靠性测试</strong>：在指定条件下无故障运行的能力。</li>
          <li><strong>可移植性测试</strong>：软件在不同环境间迁移的能力。</li>
        </ul>
      </li>
      <li><strong>结构测试 (白盒测试)</strong>：基于代码内部结构进行测试。</li>
      <li><strong>与变更相关的测试</strong>：
        <ul>
          <li><strong>回归测试</strong>：验证修改后的软件未对现有功能产生负面影响。</li>
          <li><strong>再测试 (确认测试)</strong>：对已修复的缺陷进行重新测试。</li>
        </ul>
      </li>
    </ul>
  </li>
</ul>

<h2 id="四-静态测试与动态测试">四、 静态测试与动态测试</h2>
<ul>
  <li><strong>4.1 静态测试</strong>
    <ul>
      <li><strong>定义</strong>：在不运行软件的情况下检查其表示（文档、代码）。</li>
      <li><strong>形式</strong>：评审、静态分析。</li>
      <li><strong>对象</strong>：需求文档、设计文档、源代码、测试用例、用户手册。</li>
      <li><strong>优点</strong>：早期发现缺陷，成本低。</li>
    </ul>
  </li>
  <li><strong>4.2 动态测试</strong>
    <ul>
      <li><strong>定义</strong>：通过运行软件来验证其行为。</li>
      <li><strong>形式</strong>：执行测试用例，观察输出。</li>
    </ul>
  </li>
  <li><strong>4.3 评审</strong>
    <ul>
      <li><strong>正式评审</strong>：有严格的流程和角色，如审查。</li>
      <li><strong>非正式评审</strong>：走查、结对编程、同行评审。</li>
      <li><strong>评审角色</strong>：作者、主持人、评审员、记录员。</li>
      <li><strong>评审过程</strong>：计划 -&gt; 启动会议 -&gt; 个人准备 -&gt; 评审会议 -&gt; 返工 -&gt; 跟踪。</li>
    </ul>
  </li>
</ul>

<h2 id="五-黑盒白盒与灰盒测试技术">五、 黑盒、白盒与灰盒测试技术</h2>
<ul>
  <li><strong>5.1 黑盒测试技术 (基于规格)</strong>
    <ul>
      <li><strong>定义</strong>：无需了解内部结构，基于输入和输出进行测试。</li>
      <li><strong>等价类划分</strong>：将输入域划分为有效/无效等价类，从每个类中选取代表性值。</li>
      <li><strong>边界值分析</strong>：关注输入域的边界值（上点、离点）。</li>
      <li><strong>决策表测试</strong>：处理多个输入条件与输出动作之间的逻辑关系。</li>
      <li><strong>状态转换测试</strong>：测试系统在不同状态间的转换。</li>
      <li><strong>用例测试</strong>：基于用户场景或业务流程设计测试用例。</li>
    </ul>
  </li>
  <li><strong>5.2 白盒测试技术 (基于结构)</strong>
    <ul>
      <li><strong>定义</strong>：基于代码内部逻辑结构进行测试。</li>
      <li><strong>语句覆盖</strong>：每条可执行语句至少执行一次。</li>
      <li><strong>判定覆盖 (分支覆盖)</strong>：每个判断的真假分支至少执行一次。</li>
      <li><strong>条件覆盖</strong>：每个判断中的每个条件取真/假至少一次。</li>
      <li><strong>判定/条件覆盖</strong>：同时满足判定覆盖和条件覆盖。</li>
      <li><strong>路径覆盖</strong>：覆盖程序中所有可能的路径（通常不可行）。</li>
    </ul>
  </li>
  <li><strong>5.3 灰盒测试</strong>
    <ul>
      <li><strong>定义</strong>：结合黑盒和白盒的方法，基于有限的内部知识（如接口定义、架构图）进行测试。</li>
    </ul>
  </li>
</ul>

<h2 id="六-测试分析与设计">六、 测试分析与设计</h2>
<ul>
  <li><strong>6.1 测试分析与设计活动</strong>
    <ul>
      <li><strong>评审测试依据</strong>：分析需求、用户故事、架构等。</li>
      <li><strong>识别测试条件</strong>：确定“测试什么”。</li>
      <li><strong>设计测试用例</strong>：详细描述输入、执行条件、预期结果。</li>
      <li><strong>建立测试数据与环境需求</strong>。</li>
    </ul>
  </li>
  <li><strong>6.2 测试用例设计</strong>
    <ul>
      <li><strong>好的测试用例特征</strong>：可追溯、可重复、具体、独立。</li>
      <li><strong>测试用例要素</strong>：用例ID、标题、优先级、预置条件、测试步骤、测试数据、预期结果、实际结果、状态。</li>
    </ul>
  </li>
  <li><strong>6.3 测试用例管理</strong>
    <ul>
      <li><strong>测试用例的粒度</strong>：高层次的检查点 vs 详细的操作步骤。</li>
      <li><strong>管理工具</strong>：Excel, TestLink, Jira (Zephyr), TestRail, QMetry。</li>
    </ul>
  </li>
</ul>

<h2 id="七-测试流程与文档">七、 测试流程与文档</h2>
<ul>
  <li><strong>7.1 基本测试流程 (ISTQB)</strong>
    <ol>
      <li><strong>测试计划与控制</strong>：定义目标、策略、资源和日程。监控测试进度。</li>
      <li><strong>测试分析与设计</strong>：将测试目标转化为具体的测试条件和用例。</li>
      <li><strong>测试实现与执行</strong>：准备测试环境、数据，执行测试用例，记录结果。</li>
      <li><strong>评估出口准则与报告</strong>：根据预定义标准评估是否完成测试，并生成报告。</li>
      <li><strong>测试结束活动</strong>：存档测试资产，总结经验教训。</li>
    </ol>
  </li>
  <li><strong>7.2 关键测试文档</strong>
    <ul>
      <li><strong>测试计划</strong>：定义测试的总体方法、目标、范围、资源、日程、风险。</li>
      <li><strong>测试设计规格说明</strong>：详细描述测试条件、测试用例和测试数据。</li>
      <li><strong>测试用例</strong>：执行测试的最小单元。</li>
      <li><strong>测试规程</strong>：执行一组测试用例的步骤。</li>
      <li><strong>缺陷报告</strong>：描述发现的缺陷。</li>
      <li><strong>测试总结报告</strong>：总结测试活动和结果，评估产品质量。</li>
    </ul>
  </li>
</ul>

<h2 id="八-缺陷管理">八、 缺陷管理</h2>
<ul>
  <li><strong>8.1 缺陷生命周期与状态流转</strong>
    <ul>
      <li>新建 -&gt; 打开 -&gt; 分配 -&gt; 修复 -&gt; 验证 -&gt; 关闭/重新打开/延迟/拒绝。</li>
    </ul>
  </li>
  <li><strong>8.2 缺陷报告</strong>
    <ul>
      <li><strong>要素</strong>：标题、严重程度、优先级、复现步骤、实际结果、预期结果、环境、附件（截图、日志）。</li>
      <li><strong>编写原则</strong>：客观、准确、清晰、可复现。</li>
    </ul>
  </li>
  <li><strong>8.3 缺陷严重程度与优先级</strong>
    <ul>
      <li><strong>严重程度</strong>：缺陷对系统功能的影响程度（致命、严重、一般、轻微）。</li>
      <li><strong>优先级</strong>：修复缺陷的紧急程度（高、中、低）。两者无必然联系。</li>
    </ul>
  </li>
</ul>

<h2 id="九-测试管理">九、 测试管理</h2>
<ul>
  <li><strong>9.1 测试估算</strong>
    <ul>
      <li><strong>方法</strong>：基于经验的猜测、基于工作分解、基于测试点分析、使用历史数据、德尔菲法。</li>
    </ul>
  </li>
  <li><strong>9.2 测试策略与测试计划</strong>
    <ul>
      <li><strong>测试策略</strong>：高层次文档，描述测试的总体方法和目标。</li>
      <li><strong>测试计划</strong>：基于策略，描述具体“如何做”。</li>
    </ul>
  </li>
  <li><strong>9.3 测试监控与控制</strong>
    <ul>
      <li><strong>监控指标</strong>：测试用例通过率、缺陷发现率、缺陷密度、测试执行进度、需求覆盖率。</li>
      <li><strong>控制动作</strong>：根据监控结果调整测试计划、资源、范围。</li>
    </ul>
  </li>
  <li><strong>9.4 配置管理</strong>
    <ul>
      <li>确保所有测试工件（用例、脚本、数据）都被版本控制，并与正确的软件版本对应。</li>
    </ul>
  </li>
  <li><strong>9.5 风险与测试</strong>
    <ul>
      <li><strong>项目风险</strong>：可能影响项目成功的事件（如资源短缺）。</li>
      <li><strong>产品风险</strong>：软件中可能存在的问题（如性能不达标）。</li>
      <li><strong>基于风险的测试</strong>：将测试重点放在风险最高的区域。</li>
    </ul>
  </li>
</ul>

<h2 id="十-测试技术与趋势">十、 测试技术与趋势</h2>
<ul>
  <li><strong>10.1 自动化测试</strong>
    <ul>
      <li><strong>何时自动化</strong>：重复性高、回归测试、多配置测试、性能测试。</li>
      <li><strong>金字塔模型</strong>：单元测试（底层，量大）、集成/服务测试（中层）、UI测试（顶层，量少）。</li>
      <li><strong>自动化框架</strong>：数据驱动、关键字驱动、混合驱动、行为驱动开发。</li>
    </ul>
  </li>
  <li><strong>10.2 性能测试 (扩展)</strong>
    <ul>
      <li>负载测试、压力测试、耐力测试、尖峰测试。</li>
    </ul>
  </li>
  <li><strong>10.3 安全测试 (扩展)</strong>
    <ul>
      <li>OWASP Top 10，渗透测试，漏洞扫描。</li>
    </ul>
  </li>
  <li><strong>10.4 探索性测试</strong>
    <ul>
      <li>在测试设计的同时进行测试执行，强调测试人员的自由度和创造力，以发现计划外缺陷。</li>
    </ul>
  </li>
  <li><strong>10.5 测试驱动开发与行为驱动开发</strong>
    <ul>
      <li><strong>TDD</strong>：先写失败的单元测试，再写最小代码使其通过，然后重构。</li>
      <li><strong>BDD</strong>：用自然语言描述功能行为（Given-When-Then），促进业务、开发和测试的协作。</li>
    </ul>
  </li>
  <li><strong>10.6 敏捷与DevOps中的测试</strong>
    <ul>
      <li><strong>持续测试</strong>：在CI/CD流水线中自动化执行测试。</li>
      <li><strong>测试左移</strong>：开发人员承担更多测试责任（如单元测试）。</li>
      <li><strong>测试右移</strong>：关注生产环境监控和反馈。</li>
    </ul>
  </li>
</ul>

<h2 id="十一-测试团队与职业">十一、 测试团队与职业</h2>
<ul>
  <li><strong>11.1 测试角色与职责</strong>
    <ul>
      <li><strong>测试经理/主管</strong>：管理团队、计划、资源、报告。</li>
      <li><strong>测试分析师/设计师</strong>：设计测试用例、分析需求。</li>
      <li><strong>测试工程师</strong>：执行测试、报告缺陷、可能编写自动化脚本。</li>
      <li><strong>自动化测试工程师</strong>：专攻测试自动化框架和脚本开发。</li>
      <li><strong>性能/安全测试专家</strong>。</li>
    </ul>
  </li>
  <li><strong>11.2 测试人员的技能</strong>
    <ul>
      <li><strong>硬技能</strong>：测试技术、工具使用、领域知识、编程/脚本。</li>
      <li><strong>软技能</strong>：沟通、批判性思维、好奇心、怀疑精神、细致。</li>
    </ul>
  </li>
  <li><strong>11.3 职业认证</strong>
    <ul>
      <li><strong>ISTQB</strong>：国际软件测试资格认证委员会，提供基础、高级、专家级别认证。</li>
      <li><strong>CSTE, CSQA</strong> 等。</li>
    </ul>
  </li>
</ul>

<h2 id="十二-标准术语与资源">十二、 标准、术语与资源</h2>
<ul>
  <li><strong>12.1 主要术语标准</strong>
    <ul>
      <li><strong>ISO/IEC/IEEE 29119</strong>：软件测试国际标准系列。</li>
      <li><strong>ISTQB术语表</strong>。</li>
    </ul>
  </li>
  <li><strong>12.2 学习资源</strong>
    <ul>
      <li><strong>书籍</strong>：《软件测试的艺术》、《Google软件测试之道》、《敏捷软件测试》。</li>
      <li><strong>网站/社区</strong>：Ministry of Testing, Software Testing Help, InfoQ, Stack Overflow。</li>
      <li><strong>认证机构</strong>：ISTQB官方站点。</li>
    </ul>
  </li>
</ul>]]></content><author><name>xdh2580</name></author><category term="测试理论" /><category term="测试基础" /><category term="测试理论" /><summary type="html"><![CDATA[软件测试理论与基础 完整学习大纲]]></summary></entry></feed>