fix: 让 example_runner CI 回绿——修 stdin 隔离、Queue 死锁与 class 笔误，67 个教学片段加 skip 标注

这个 workflow 自 2026-04-28 加入起跑过 16 次、一次没绿过，69 个「失败」里
只有 2 个是真问题，其余全是本来就不该当独立程序跑的教学片段。一直红着等于
没有 CI——真回归会被淹没，本次就是为了确认前一个 commit 有没有引入新失败，
才不得不逐块做差集，两个真 bug 由此第一次单独露出来。

工具缺陷（长期红的根因）：
- subprocess.run 没传 stdin，含 input() 的块在有 stdin 的环境里等到超时、
  在没有的环境里立刻抛 EOFError，同一份代码两种结果。CI 各版本失败数长期
  在 69~72 之间飘就是这个原因，不是内容有四种状态。钉死为 DEVNULL。
- 超时 10s → 30s：并发示例本地实测就要 4~5 秒（python13/2.md 两块各 5.04s、
  python13/3.md 一块 4.07s），CI 机器更慢必然偶发超时。

真 bug 两处：
- python13/2.md 的 Queue 生产者消费者示例死锁：写线程放完 3 个值就结束，
  读线程 while isRead 永远为真、q.get(True) 永久阻塞，读者复制到本地跑必须
  强制中断。改为写完放 None 哨兵、读到哨兵 break，并删掉那个永远为真的
  isRead 全局变量。这段代码 2019-10-14 就在了，因为输出完全正确、只是不会
  自己退出，手动验证看不出来。python-lab 有同源内容，已同步修改。
- codeSpecification_third.md 的 `Class FooBar:` 写成大写 C，读者复制即
  SyntaxError。两仓 grep 确认 python-lab 无同样问题。

67 处 <!-- skip-ci --> 标注，涉及 34 个文件：语法示意（for x in sequence:）、
占位符、假模块名（import decoder / foo / bar）、依赖前文的连续片段、故意演示
报错的例子（如 python15 闭包章节的 UnboundLocalError）。与 python17-27 既有的
131 处标注同样处理——此前 skip 标注只覆盖 2026 新写的章节，python0-16 与
codeSpecification 从未处理过，这是 CI 长期红的结构性原因。

验证：本地 python3 全量跑 691 块，改前「跳过 131；失败 69」exit 1，
改后「跳过 198；失败 0」exit 0；Queue 示例改后连跑 5 次均 0.02 秒正常退出、
输出 6 行。

已知残留：python13/2.md 第 339 行的 Event 示例有竞态（if event.isSet() 与
event.clear() 之间非原子，两个线程可能都进 wait() 而只有一个 set() 唤醒），
本地连跑 20 次未触发，但 8-31 那次 CI 的 3.11 与 3.13 各失败过一次，故 CI
仍有小概率偶发红。未在本次范围内处理。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EKcB6SFyeRo9UPJL99QvkC

Author: walter201230

Article/PythonBasis/python11/2.md

@@ -11,6 +11,7 @@
 
 Enum 在模块 enum.py 中，先来看看 Enum 类的片段
 
+<!-- skip-ci -->
 ```python
 class Enum(metaclass=EnumMeta):
     """Generic enumeration.

Article/PythonBasis/python12/2.md

@@ -21,6 +21,7 @@ class Hello(object):
 
 其中 `type()` 函数的作用是可以查看一个类型和变量的类型。
 
+<!-- skip-ci -->
 ```python
 #!/usr/bin/env python3
 # -*- coding: UTF-8 -*-
@@ -97,6 +98,7 @@ Hello, Py
 
 具体的模式如下：
 
+<!-- skip-ci -->
 ```python
 type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)
 ```

Article/PythonBasis/python12/3.md

@@ -72,6 +72,7 @@ print(mEat.__class__)
 
 我们可以继续在上面的代码基础上新增下面的代码：
 
+<!-- skip-ci -->
 ```python
 print(age.__class__.__class__)
 print(name.__class__.__class__)

Article/PythonBasis/python12/4.md

@@ -26,6 +26,7 @@ metaclass，直译为元类，简单的解释就是：
 
 换句话说，你可以把类看成是 metaclass 创建出来的“实例”。
 
+<!-- skip-ci -->
 ```python
 class MyObject(object):
     __metaclass__ = something…
@@ -84,6 +85,7 @@ ython 会在类的定义中寻找 `__metaclass__` 属性，如果找到了，Pyt
 
 再举个实例：
 
+<!-- skip-ci -->
 ```python
 class Foo(Bar):
     pass
@@ -115,6 +117,7 @@ def upper_attr(future_class_name, future_class_parents, future_class_attr):
 ```
 
 
+<!-- skip-ci -->
 ```python
 # 将它们转为大写形式
 uppercase_attr = dict((name.upper(), value) for name, value in attrs)
@@ -130,6 +133,7 @@ class Foo(object):
     bar = 'bip'
 ```
 
+<!-- skip-ci -->
 ```python
 print hasattr(Foo, 'bar')
 # 输出: False
@@ -177,6 +181,7 @@ class UpperAttrMetaclass(type):
 
 你可能已经注意到了有个额外的参数 `upperattr_metaclass` ，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就像在普通的类方法中的 self 参数一样。当然了，为了清晰起见，这里的名字我起的比较长。但是就像 self 一样，所有的参数都有它们的传统名称。因此，在真实的产品代码中一个元类应该是像这样的：
 
+<!-- skip-ci -->
 ```python
 class UpperAttrMetaclass(type):
     def __new__(cls, name, bases, dct):

Article/PythonBasis/python12/5.md

@@ -6,6 +6,7 @@
 
 元类的主要用途是创建 API。一个典型的例子是 Django ORM。它允许你像这样定义：
 
+<!-- skip-ci -->
 ```python
 class Person(models.Model):
     name = models.CharField(max_length=30)
@@ -14,6 +15,7 @@ class Person(models.Model):
 
 但是如果你这样做的话：
 
+<!-- skip-ci -->
 ```python
 guy  = Person(name='bob', age='35')
 print guy.age

Article/PythonBasis/python13/2.md

@@ -154,18 +154,21 @@ End Main threading
 
 其中 `threading` 模块给我们提供了一个 Lock 功能。
 
+<!-- skip-ci -->
 ```python
 lock = threading.Lock()
 ```
 
 在线程中获取锁
 
+<!-- skip-ci -->
 ```python
 lock.acquire()
 ```
 
 使用完成后，我们肯定需要释放锁
 
+<!-- skip-ci -->
 ```python
 lock.release()
 ```
@@ -174,6 +177,7 @@ lock.release()
 
 那么怎么创建重入锁呢？也是一句代码的事情：
 
+<!-- skip-ci -->
 ```python
 r_lock = threading.RLock()
 ```
@@ -277,20 +281,21 @@ producer.start()
 from queue import Queue
 from threading import Thread
 
-isRead = True
-
 
 def write(q):
     # 写数据进程
     for value in ['两点水', '三点水', '四点水']:
         print(f'写进 Queue 的值为：{value}')
         q.put(value)
+    q.put(None)  # 写完放一个结束标记
 
 
 def read(q):
     # 读取数据进程
-    while isRead:
+    while True:
         value = q.get(True)
+        if value is None:  # 读到结束标记就退出
+            break
         print(f'从 Queue 读取的值为：{value}')
 
 

Article/PythonBasis/python13/3.md

@@ -73,6 +73,7 @@ Process finished with exit code 0
 当然我们也可以把进程创建成一个类，如下面的例子，当进程 p 调用 start() 时，自动调用 run() 方法。
 
 
+<!-- skip-ci -->
 ```python
 # -*- coding: UTF-8 -*-
 
@@ -268,6 +269,7 @@ if __name__ == '__main__':
 
 请注意输出的结果，子进程 0，1，2，3是立刻执行的，而子进程 4 要等待前面某个子进程完成后才执行，这是因为 Pool 的默认大小在我的电脑上是 4，因此，最多同时执行 4 个进程。这是 Pool 有意设计的限制，并不是操作系统的限制。如果改成：
 
+<!-- skip-ci -->
 ```python
 p = Pool(5)
 ```

Article/PythonBasis/python14/1.md

@@ -29,6 +29,7 @@ print(f'是否含有“两点水”这个字符串：{"两点水" in a}')
 
 刚刚提到过，Python 给我们提供了 re 模块来实现正则表达式的所有功能，那么我们先使用其中的一个函数：
 
+<!-- skip-ci -->
 ```python
 re.findall(pattern, string[, flags])
 ```

Article/PythonBasis/python14/6.md

@@ -4,6 +4,7 @@
 
 语法：
 
+<!-- skip-ci -->
 ```python
 re.match(pattern, string, flags=0)
 ```
@@ -15,6 +16,7 @@ re.match 尝试从字符串的起始位置匹配一个模式，如果不是起
 
 语法：
 
+<!-- skip-ci -->
 ```Python
 re.search(pattern, string, flags=0)
 ```

Article/PythonBasis/python15/1.md

@@ -6,6 +6,7 @@
 
 面对这个需求，我们一般都会创建一个全局变量来记录时间，然后用一个方法来新增每次的学习时间，通常都会写成下面这个形式：
 
+<!-- skip-ci -->
 ```Python
 time = 0