Python 关键字与语言机制字典。Python 3 共 35 个关键字（含 async/await/match 等新增），逐条给语义、示例与边界。软关键字（如 type/case）不在此列，因可作标识符。
本文目录
- 1. False / True / None – 三个常量字面量
- 2. and / or / not – 逻辑运算符
- 3. if / elif / else – 条件分支
- 4. for / else – 迭代循环
- 5. while / else – 条件循环
- 6. break / continue / pass – 流程控制
- 7. def – 函数定义
- 8. lambda – 匿名函数
- 9. class – 类定义
- 10. return / yield – 返回与产出
- 11. global / nonlocal – 作用域声明
- 12. import / from / as – 导入
- 13. try / except / else / finally – 异常处理
- 14. raise / assert – 抛出与断言
- 15. async / await – 协程
- 16. with / as – 上下文管理器
- 17. del – 删除引用
- 18. in / is – 成员与身份
- 19. elif / else 外的 match / case（3.10+）
- 20. type – 类型别名（3.12+ 软关键字）
- 21. 软关键字与保留字边界
1. False / True / None – 三个常量字面量
描述
Python 的三个内置常量：False/True 是 bool 单例，None 是空值单例。三者都是单例（内存中只有一份），身份比较用 is 更准。 在条件判断、默认返回值、可选参数等场景反复出现。三者都是单例对象，CPython 里 False/True/None 各只有一份，所以 is 比较既快又准。
语法和示例
x = None
x is None # 推荐：判断 None 用 is
x == None # 能跑但不推荐
bool(None) # False
True + True # 2（bool 是 int 的子类）
[False, True] == [0, 1] # True
1. 作为默认参数与返回值
def find(k, default=None):
return cache.get(k, default)
1. 集合/字典里 False 与 0 冲突
{False, 0, True, 1} # {False, True}（只留两个）
d = {False: 'a'}; d[0] # 'a'（同一个键）
1. 布尔运算返回 None 时的陷阱
result = maybe() or None # 0/''/[] 也会变 None
1. 判空的三种语义
if x is None: ... # 只判 None
if not x: ... # 判所有假值
if x is not None: ... # 只排除 None
注意事项
- 判断 None 永远用 is / is not，不用 ==
- bool 是 int 子类：True+1 == 2，集合里 {True, 1} 会被去重
- None 不是 0 也不是空字符串，if not x 会把 0/”/[] 也当假值
- False 与 0 在 dict 键里等价（hash 相同）
2. and / or / not – 逻辑运算符
描述
短路求值的逻辑运算符，返回的是「操作数本身」而不是 bool。这是 Python 与多数语言的关键差异。 与 C/Java 不同，Python 的 and/or 不是布尔运算而是「选择操作数」：a or b 在 a 为真时返回 a，否则返回 b。这让它们能当默认值语法用，也带来假值陷阱。
语法和示例
1 and 2 # 2（返回最后一个真值）
0 and 2 # 0（第一个假值）
'' or 'default' # 'default'（返回第一个真值）
not 0 # True
1. 惯用写法
name = user_name or '匿名'
val = x if x is not None else 0 # 只判 None 时不能用 or（0 会被吞）
1. 返回操作数的证据
print(0 or 'b') # 'b'
print('a' or 'b') # 'a'
print(1 and 0) # 0
print('' and 'x') # ''
print(None or [] or 'default') # 'default'
1. 安全的默认值（只判 None）
val = arg if arg is not None else 0
1. 短路避免异常
if obj and obj.name: ... # obj 为 None 时不访问 .name
if key in d and d[key]: ...
注意事项
- and/or 返回操作数本身，不是 bool——写 `if a and b:` 没事，但赋值时要清楚
- 用 or 做默认值会吞掉 0/”/[] 等合法假值——要只判 None 用三元或 is None
- not 优先级高于 and/or，混合时加括号更清楚
- 与 C 不同：Python 没有 && || ! 符号
3. if / elif / else – 条件分支
描述
条件语句。注意 Python 没有 switch 的替代是 3.10+ 的 match，if 链适合少量分支。 Python 没有 switch 语句，条件分发靠 if 链或 3.10+ 的 match。链式比较和赋值表达式能让条件写得更紧凑。
语法和示例
if score >= 90:
grade = 'A'
elif score >= 60:
grade = 'B'
else:
grade = 'F'
1. 三元（条件表达式）
label = 'ok' if ok else 'fail'
1. 链式比较
if 0 < x <= 10: ...
1. 赋值表达式（海象，3.8+）
if (n := len(data)) > 10:
print(n)
1. 字典分发优于长 if 链
actions = {'a': do_a, 'b': do_b}
action = actions.get(cmd, do_default)
action()
1. 条件表达式的嵌套（可读性差时改用 if）
level = 'high' if n > 100 else 'mid' if n > 50 else 'low'
1. 常见误用：把赋值写进条件
if (x := compute()) > 0: # 正确（海象）
use(x)
注意事项
- 链式比较 0 < x 0 and x <= 10 更高效
- 三元表达式两分支类型最好一致，否则静态检查会报 Union
- 海象运算符必须加括号才能用在 if 条件里
- elif 链超过 4-5 个分支考虑字典分发或 match
4. for / else – 迭代循环
描述
遍历可迭代对象。else 子句在「循环正常结束（没被 break）」时执行——这是 Python 独有特性。 for 遍历任何可迭代对象（列表/元组/字符串/字典/生成器/文件）。else 子句在「循环未被 break」时执行，适合「查找未命中」的场景。
语法和示例
for i in range(3): ...
for ch in 'abc': ...
for idx, val in enumerate(items): ...
for k, v in d.items(): ...
1. for-else：找质数的经典写法
for n in nums:
if is_prime(n):
print('找到', n)
break
else:
print('没有质数')
1. 遍历字典的三种方式
for k in d: ... # 键
for k, v in d.items(): ... # 键值
for v in d.values(): ... # 值
1. 遍历文件（惰性逐行，不占内存）
for line in open('a.txt', encoding='utf-8'): ...
1. 带索引与同时遍历多个
for i, (a, b) in enumerate(zip(xs, ys)): ...
1. enumerate 反向（从 1 开始）
for i, v in enumerate(items, 1): ...
注意事项
- for-else 的 else 不是「否则」，而是「没 break 过」——极易读错，团队里慎用
- 遍历时修改列表（append/remove）行为不可预期——用副本 for x in list[:] 或推导式
- 遍历 dict 时改 dict 会抛 RuntimeError
- range 是惰性序列，不会一次生成全部整数
5. while / else – 条件循环
描述
条件为真时重复执行。同样支持 else（正常结束才执行）。适合「不知道循环次数」的场景。 适合「退出条件在循环内计算」的场景。Python 没有 do-while，需要「至少执行一次」时写成 while True + break。
语法和示例
n = 10
while n > 0:
n -= 1
1. while-else
while queue:
item = queue.pop()
if item.ok:
break
else:
print('队列处理完毕')
1. do-while 的等价写法
while True:
v = next_value()
if v is None: break
process(v)
1. 带超时的等待
import time
deadline = time.monotonic() + 30
while time.monotonic() < deadline:
if ready(): break
time.sleep(0.1)
else:
raise TimeoutError()
注意事项
- 循环里忘改条件变量 = 死循环；建议用 `while True:` + break 更明确
- while-else 与 for-else 同理，易误读
- while 循环体内修改迭代对象要格外小心
- 高频率空转的 while 会占满 CPU——需要等待时用 sleep 或事件
6. break / continue / pass – 流程控制
描述
break 跳出最近一层循环；continue 进入下一轮；pass 是空语句占位（什么都不做）。三者不可混用。 break 只跳出最近一层循环，Python 没有带标签的 break——多层跳出要靠函数封装或标志位。pass 是语法占位，不产生任何操作。
语法和示例
for i in range(10):
if i == 5: break
if i % 2: continue
print(i)
1. pass 用于占位
def todo(): pass
class Empty: pass
if cond: pass
1. 多层跳出：用函数 return
def find_pair(grid):
for row in grid:
for cell in row:
if cell == target:
return cell # 直接跳出两层
return None
1. 标志位方式
found = False
for x in xs:
for y in ys:
if match(x, y):
found = True; break
if found: break
注意事项
- Python 没有带标签的 break，多层跳出用函数 return 或标志位
- pass 与 continue 不同：pass 什么都不做继续往下执行
- 空函数体必须写 pass，否则 IndentationError
- continue 在 finally 块里会有意外行为，避免这样写
7. def – 函数定义
描述
定义函数。支持默认参数、可变位置参数 *args、可变关键字参数 **kwargs、仅限关键字参数、类型注解。 函数是第一类对象，可赋值、传参、返回。签名支持位置参数、默认参数、仅位置参数（/）、仅关键字参数（*）、可变参数。3.8+ 的 / 分隔让「仅位置」成为可能。
语法和示例
def greet(name, times=1, *, upper=False):
msg = f'hi {name}'
return msg.upper() if upper else msg
def sum_all(*nums): # 任意个位置参数 → 元组
return sum(nums)
def config(**kw): # 任意关键字参数 → 字典
return kw
greet('a') # 'hi a'
greet('a', upper=True) # 仅限关键字
sum_all(1, 2, 3) # 6
1. 完整签名的参数顺序
def full(pos_only, /, normal, *args, kw_only=True, **kw): ...
1. 类型注解（不强制，但便于静态检查）
def add(a: int, b: int = 0) -> int: ...
1. 文档字符串（help() 会显示）
def greet(name):
'''打招呼。
:param name: 名字
:return: 问候语
'''
return f'hi {name}'
1. 函数属性与装饰
def counter():
counter.n += 1
return counter.n
counter.n = 0
注意事项
- 默认参数只在定义时求值一次——默认值用可变对象（[] / {}）是经典 bug
- 仅限关键字参数（* 之后）能防止调用方误传位置参数
- *args 收集成 tuple，**kwargs 收集成 dict（有序）
- 函数是第一类对象：可赋值、可传参、可返回
8. lambda – 匿名函数
描述
单表达式的匿名函数，常用于排序键、回调。不能含语句（不能赋值/多行）。 单表达式匿名函数，本质是 def 的简写。真正价值在「作为参数临时传一个短函数」，而非赋值给变量。
语法和示例
square = lambda x: x * x
sorted(items, key=lambda u: u.age)
max(data, key=lambda p: p['score'])
1. 与 def 等价但仅限单表达式
(lambda a, b: a + b)(1, 2)
1. 排序键的三种写法
sorted(users, key=lambda u: u['age'])
sorted(users, key=lambda u: (u['dept'], -u['age'])) # 多级
sorted(words, key=str.lower)
1. max/min 的 key
max(rows, key=lambda r: r['score'])
1. 与 map/filter 配合
list(map(lambda x: x.strip(), lines))
list(filter(lambda x: x > 0, nums))
1. 循环里绑定的坑
fns = [lambda i=i: i for i in range(3)] # 正确：i=i 固定当前值
注意事项
- lambda 只能一个表达式，复杂逻辑用 def
- 赋值给变量时 PEP8 建议用 def（可读性与堆栈友好）
- lambda 内不能写 print/赋值/循环
- 闭包捕获变量是引用捕获，循环里创建 lambda 要绑定默认参数 lambda x, i=i: …
9. class – 类定义
描述
定义类。支持继承、多重继承（MRO）、类属性/实例属性、类方法/静态方法/属性装饰器。 Python 类支持多重继承（C3 线性化）、描述符协议、元类等高级特性，但日常只需 __init__、类属性/实例属性、@property、@classmethod/@staticmethod。
语法和示例
class User:
kind = 'human' # 类属性（全实例共享）
def __init__(self, name):
self.name = name # 实例属性
def greet(self): return f'hi {self.name}'
@classmethod
def create(cls, name): return cls(name)
@staticmethod
def helper(): return 1
@property
def label(self): return f'<{self.name}>'
1. 类属性的共享陷阱
class Bad:
items = [] # 全实例共享同一列表！
def add(self, x): self.items.append(x)
a, b = Bad(), Bad()
a.add(1); b.items # [1] —— b 也受影响
1. 正确做法
class Good:
def __init__(self): self.items = []
1. 继承与 MRO
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
D.__mro__ # (D, B, C, A, object)
注意事项
- 类属性是共享的，可变类属性（列表/字典）会被所有实例共用——实例属性要在 __init__ 里设
- 多重继承用 C3 线性化，super() 沿 MRO 走而不是「父类」
- property 只读；要可写再加 @x.setter
- classmethod 的 cls 支持子类工厂（多态构造）
10. return / yield – 返回与产出
描述
return 结束函数并返回值；yield 把函数变成生成器（惰性产出，可暂停恢复）。两者互斥于同一层。 yield 让函数变成生成器工厂：调用时不执行，每次 next 前进到下一个 yield 并暂停。这让「无限序列」「流式处理」成为可能。
语法和示例
def f(): return 1
def gen(n):
for i in range(n):
yield i # 惰性产出
g = gen(3)
list(g) # [0,1,2] 消费后耗尽
1. 生成器可双向传值
def echo():
v = yield 'first'
yield f'got {v}'
1. 生成器处理大文件（不占内存）
def read_lines(path):
with open(path, encoding='utf-8') as f:
for line in f:
yield line.rstrip()
1. 生成器管道
def numbers():
for i in range(10**6): yield i
evens = (n for n in numbers() if n % 2 == 0)
first = next(evens)
1. yield from 委托（减少嵌套）
def chain_all(*iterables):
for it in iterables:
yield from it
注意事项
- 生成器只能消费一次，第二次遍历为空
- 生成器函数调用时不执行，首次 next() 才跑到第一个 yield
- return 在生成器里表示「停止产出」（3.3+ 返回值进 StopIteration.value）
- 生成器表达式惰性，列表推导式立即求值占内存
11. global / nonlocal – 作用域声明
描述
global 声明函数内要修改模块级变量；nonlocal 声明要修改外层函数的变量。不声明则只读。 Python 的作用域规则 LEGB：Local → Enclosing → Global → Builtin。函数内赋值默认创建局部变量，要改外层必须显式声明。
语法和示例
count = 0
def bump():
global count
count += 1
def outer():
n = 0
def inner():
nonlocal n
n += 1
inner()
return n
1. 没有声明时的实际行为
x = 10
def f():
x = 20 # 创建局部 x，全局不变
print(x) # 20
f(); print(x) # 10
1. 计数器（模块级状态）
_count = 0
def bump():
global _count
_count += 1
1. 闭包计数器（用 nonlocal 更干净）
def make_counter():
n = 0
def inc():
nonlocal n
n += 1; return n
return inc
注意事项
- 不用 global 就只能读不能改（改会创建新的局部变量）
- nonlocal 找不到外层变量会 SyntaxError
- 滥用 global 让状态难追踪——优先用参数传递或类封装
- global 只影响模块级，不影响其他模块
12. import / from / as – 导入
描述
import 导入模块；from … import 导入名称；as 起别名。支持相对导入（同包内）。 导入是执行模块顶层代码并绑定名字。Python 的导入有缓存（sys.modules），重复 import 不会重复执行。
语法和示例
import os
import os.path as p
from os import path
from os.path import join, exists
from . import sibling # 相对导入（包内）
import numpy as np
1. 导入的几种形态
import os
import os.path as osp
from collections import OrderedDict
from typing import Optional, List
1. 条件导入（可选依赖）
try:
import ujson as json
except ImportError:
import json
1. 延迟导入（避免循环依赖）
def need_pandas():
import pandas as pd
return pd
注意事项
- import 是执行整个模块（顶层代码会跑），不是纯声明
- 循环导入会报 ImportError——用延迟导入或重构依赖
- from . import x 只能在包内使用，顶层脚本会报错
- 通配导入 from m import * 污染命名空间，PEP8 不建议
13. try / except / else / finally – 异常处理
描述
except 按类型捕获（从上到下匹配）；else 在无异常时执行；finally 无论如何都执行。 Python 的异常处理按类型匹配，从上到下第一个匹配的 except 生效。else 在 try 体无异常时执行，finally 无论如何都执行。
语法和示例
try:
risky()
except (ValueError, KeyError) as e:
log(e)
except Exception:
raise
else:
print('无异常才跑')
finally:
cleanup()
1. 完整结构
try:
v = int(s)
except ValueError: # 类型不匹配
v = 0
except (TypeError, OverflowError): # 多类型
raise
else:
log('ok', v) # 成功后
finally:
close() # 总会执行
1. EAFP 风格（Python 偏好）
try:
val = d[k]
except KeyError:
val = default
1. 异常链
raise AppError('wrap') from original
注意事项
- except 顺序：子类必须在前，否则父类的分支会先命中
- 裸 except: 会吞掉 KeyboardInterrupt/SystemExit（应写 except Exception）
- finally 里 return 会吞掉 try 的异常与返回值
- 异常链用 raise X from e 保留根因
14. raise / assert – 抛出与断言
描述
raise 主动抛异常（可带原因）；assert 校验不变量，-O 优化时被移除，别用于业务校验。 raise 抛异常，可带 from 保留因果链；assert 是开发者断言，优化模式下（python -O）被整条移除，绝不能用于输入校验。
语法和示例
raise ValueError('bad input')
raise ValueError('bad') from cause # 保留异常链
assert x > 0, 'must be positive' # python -O 时移除
1. 抛自定义异常
class AppError(Exception): pass
raise AppError('boom')
1. 带原因
try:
parse(s)
except ValueError as e:
raise AppError('解析失败') from e
1. assert 仅用于内部不变量
def area(w, h):
assert w > 0 and h > 0, f'非法尺寸 {w}x{h}'
return w * h
1. 反例：assert 不能校验用户输入（-O 时失效）
1. assert isinstance(x, int)
注意事项
- assert 会被 python -O 移除——绝不能用于参数校验
- raise 后不要再写代码（不可达）
- 自定义异常应继承 Exception（不是 BaseException）
- 重抛用裸 raise 保留原堆栈，不要 raise e（会重置堆栈）
15. async / await – 协程
描述
async def 定义协程函数；await 等待可等待对象（协程/Future/Task）。必须运行在事件循环里。 协程是「可暂停的函数」，await 是暂停点。事件循环在等待时切换执行其他任务，实现单线程内的并发 IO。
语法和示例
import asyncio
async def fetch(i):
await asyncio.sleep(0.1)
return i
async def main():
rs = await asyncio.gather(*(fetch(i) for i in range(3)))
asyncio.run(main())
1. 并发多个请求并处理各自异常
async def fetch_all(urls):
rs = await asyncio.gather(*[fetch(u) for u in urls],
return_exceptions=True)
for r in rs:
if isinstance(r, Exception): log(r)
else: use(r)
1. 限流（信号量）
sem = asyncio.Semaphore(10)
async def guarded(u):
async with sem:
return await fetch(u)
1. 超时与取消
task = asyncio.create_task(fetch(u))
try:
await asyncio.wait_for(task, timeout=5)
except asyncio.TimeoutError:
task.cancel()
注意事项
- async def 调用后返回协程对象，不 await 就永远不执行（RuntimeWarning）
- asyncio.run 只能有一个，且不能在已有事件循环里调用（Jupyter 需 await 直接跑）
- 协程里做阻塞 IO（time.sleep/requests）会卡住整个循环——用 aiohttp/run_in_executor
- await 只能出现在 async def 内
16. with / as – 上下文管理器
描述
with 保证资源正确释放（进入调 __enter__，退出调 __exit__，异常也会触发）。 with 保证 __exit__ 被调用（即使内部抛异常），是资源管理的标准方式：文件、锁、数据库连接、临时目录。
语法和示例
with open('a.txt') as f:
data = f.read()
with open('a') as src, open('b', 'w') as dst:
dst.write(src.read())
1. 自定义
from contextlib import contextmanager
@contextmanager
def tag(name):
print(f'<{name}>')
yield
print(f'</{name}>')
1. 嵌套与并列
with open('a') as fa, open('b', 'w') as fb:
fb.write(fa.read())
1. 异常在 with 内也会关闭资源
with open('a') as f:
raise RuntimeError() # f 仍会关闭
1. 忽略特定异常（3.4+ contextlib.suppress）
from contextlib import suppress
with suppress(FileNotFoundError):
os.remove('a.tmp')
注意事项
- 多个 with 可用逗号并列（3.10+ 也支持括号换行）
- contextmanager 装饰的函数必须 yield 一次（且只能一次）
- __exit__ 返回 True 会吞掉异常——别误返回 True
- async with 用于异步资源（aiohttp session 等）
17. del – 删除引用
描述
删除名字绑定（变量/属性/下标元素）。只删引用不保证释放内存（还有别的引用时对象仍活）。 del 解除名字与对象的绑定：变量名、字典键、列表元素、对象属性都能删。对象是否被释放取决于还有没有其他引用。
语法和示例
del x
del d['k']
del obj.attr
del lst[0]
1. 各种删除目标
x = [1, 2]; del x[0] # [2]
d = {'k': 1}; del d['k'] # {}
del obj.attr
del x # 名字消失，再访问 NameError
1. 删后重建（名字可复用）
del x
x = 'new'
1. 循环中删除要倒序
for i in reversed(range(len(lst))):
if should_drop(lst[i]): del lst[i]
注意事项
- del 删的是「名字绑定」，不是对象本身
- 遍历列表时 del 元素会导致跳过——倒序遍历或新建列表
- del 后可重新赋值（名字可复用）
- 想显式触发 GC 用 gc.collect()，不是 del
18. in / is – 成员与身份
描述
in 判断成员（容器/字符串）；is 判断对象身份（同一内存对象）。两者语义完全不同。 in 是容器成员判断（走 __contains__ 或 __iter__），is 是对象身份（同一内存地址）。二者语义正交，不能互换。
语法和示例
3 in [1,2,3] # True
'k' in {'k':1} # True（判键）
'a' in 'cat' # True
x is None # 身份
a is b # 是否同一对象
1. in 的性能差异
x in [1,2,3] # O(n)
x in {1,2,3} # O(1) 集合/字典
'k' in {'k': 1} # 字典判键（不是值）
'a' in 'abc' # 子串判断
1. is 的正确用途
x is None; x is True
CONST = object() # 哨兵对象，用 is 判断
if val is CONST: ...
注意事项
- is 用于 None/True/False/单例，其他一律用 ==（小整数/字符串缓存会误导）
- in 对 list 是 O(n)，对 set/dict 是 O(1)——大集合判成员用 set
- in 对字符串是子串判断，不是字符集合
- 1 == True 为 True，但 1 is True 为 False
19. elif / else 外的 match / case（3.10+）
描述
结构化模式匹配：按形状与类型分发，支持字面量、序列、映射、类模式、守卫。比 if 链清晰。 结构化模式匹配：既能按值匹配，也能按形状（序列长度、字典键、类属性）解构绑定。比 if-elif 链更清晰，且可穷尽检查。
语法和示例
match cmd.split():
case ['go', d]: ...
case ['drop', *items]: ...
case {'op': 'set', 'key': k}: ...
case [x, y] if x == y: ...
case _: ...
1. 序列模式与剩余捕获
match cmd:
case ['go', direction]: move(direction)
case ['drop', *items]: drop_all(items)
case ['look'] | ['l']: look()
1. 映射模式（需的键必须存在）
match payload:
case {'type': 'msg', 'text': t}: send(t)
1. 类模式（按属性匹配）
match point:
case Point(x=0, y=y): on_axis_y(y)
1. 守卫
match n:
case int() if n < 0: neg()
case int(): pos()
注意事项
- match 是语句不是表达式，不能直接赋值（用 3.10+ 的 if 表达式替代）
- case _ 兜底应放最后，且会掩盖「漏处理新类型」的问题
- case 里的变量名是绑定，不是常量比较（要比较常量用字面量或守卫
- 类模式 case Point(x=0): 会调属性，不调构造
20. type – 类型别名（3.12+ 软关键字）
描述
3.12 起 type X = … 声明类型别名（惰性求值，支持前向引用）。此前用 X = TypeAlias。 type 语句创建惰性求值的类型别名，支持前向引用（可引用尚未定义的类），比赋值别名更适合复杂泛型。
语法和示例
type Vector = list[float]
type Callback = Callable[[int], str]
def f(v: Vector) -> Vector: ...
1. 3.12+
type Vec = list[float]
type Matrix = list[Vec]
type Handler = Callable[[str], Awaitable[None]]
type Tree[T] = dict[T, list['Tree[T]']] # 递归别名
1. 3.11 及以前
from typing import TypeAlias, Optional
Vector: TypeAlias = list[float]
注意事项
- type 语句是惰性求值，可引用尚未定义的类
- 3.11 及以前用 Assign 或 TypeAlias
- type 是软关键字，仍可作变量名（但会与别名语法冲突
21. 软关键字与保留字边界
描述
Python 3 的硬关键字 35 个不可作标识符；软关键字（match/case/type/_）在特定上下文才有特殊含义，平时可作变量名。 35 个硬关键字在任何位置都是关键字；软关键字（match/case/type/_）只在特定语法位置有特殊含义，平时可作变量名。
语法和示例
match = 1 # 合法（match 是软关键字）
case = 2 # 合法
_ = 3 # 合法（但 _ 惯用作丢弃值）
1. 硬关键字如 if/for/class 不能作变量名
1. 硬关键字作标识符 → SyntaxError
1. class = 1 ✗
1. 软关键字可以
match = 1 # ✓
case = 2 # ✓
type = 'text' # ✓（3.12 起与 type 语句共存）
1. 访问与关键字同名的属性
getattr(obj, 'class')
d['if']
注意事项
- 35 个硬关键字：False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield
- 软关键字在 match 语句里才是关键字，其余场景是普通名字
- _ 在 match 里是通配符，在交互式解释器里是上次结果
- 读到以关键字命名的属性用 getattr(obj, ‘class’) 而不是 obj.class
这个系列的其他文档
- Python 内置函数详解——内置函数分类
- Python 标准库详解——标准库模块
- 完整学习路线——按顺序学完这个系列