Python的保留字

什么是Python的保留字?

Python的保留字(也称关键字)是语言中预先定义、具有特殊语法意义的标识符,不能用作变量名、函数名或其他自定义名称。截至Python 3.12,标准库共包含35个保留字,它们是构建所有Python程序的基石。这些保留字严格区分大小写,且其含义在语言层面被固化——试图重新赋值或覆盖将引发SyntaxError错误。

保留字的存在确保了代码的语法一致性与可读性。例如,若允许if作为变量名,解释器将无法区分是条件判断语句还是变量引用,导致逻辑混乱。因此,掌握保留字不仅是语法规范要求,更是避免运行时错误的关键。

🔍 保留字的三大特征
  • 不可变性:无法通过赋值改变其语法角色,如True = 1直接报错
  • 上下文无关:无论在模块、函数还是类中,保留字行为一致
  • 跨版本稳定:核心保留字(如def、return)自Python 1.0起保持不变

值得注意的是,Python保留字数量随版本演进略有调整。Python 3.7新增async与await(原为上下文相关关键字),3.10引入match与case(PEP 634模式匹配),3.12新增type(PEP 695类型别名)。开发者需定期查阅官方文档以应对语法演进。

Python 3.12完整保留字列表(35个)

以下列表按字母序排列,标注各保留字的核心功能与典型使用场景。每个词汇均经过Python 3.12.2版本实测验证,确保准确性。

📋 35个保留字速查表
保留字类型核心用途典型场景
False布尔值假值表示逻辑运算、条件判断
None空值无值占位符默认参数、初始化变量
True布尔值真值表示循环控制、状态标记
and逻辑运算符逻辑与组合条件判断
as别名关键字导入/异常重命名import math as m
assert断言调试时验证条件assert x > 0, "负值无效"
async异步异步函数定义async def fetch():
await异步等待协程结果await asyncio.sleep(1)
break控制流跳出循环if i == 5: break
class类定义声明新类class MyClass:
continue控制流跳过本次循环if x < 0: continue
def函数定义声明函数def calc():
del删除删除对象引用del list[0]
elif条件分支多重条件elif score > 60:
else条件分支默认分支else: print("默认")
except异常处理捕获异常except ValueError:
finally异常处理无论是否异常均执行finally: cleanup()
for循环遍历序列for item in items:
from导入模块部分导入from os import path
global作用域声明全局变量global count
if条件分支条件判断if x == 0:
import导入导入模块import json
in成员运算符成员检测if 'a' in s:
is身份运算符对象身份比较if x is None:
lambda匿名函数定义简单函数square = lambda x: x**2
nonlocal作用域声明嵌套作用域变量nonlocal outer_var
not逻辑运算符逻辑非if not found:
or逻辑运算符逻辑或if x or y:
pass空操作占位符def todo(): pass
raise异常处理抛出异常raise TypeError("类型错误")
return函数返回返回函数值return result
try异常处理尝试执行代码try: risky_op()
while循环条件循环while count < 10:
with上下文管理资源管理with open("file") as f:
yield生成器生成器返回yield value
match模式匹配结构化匹配match command:
case模式匹配匹配分支case "start":
type类型别名声明类型别名type Vector = list[float]

特别说明:Python 3.10+的match/case(PEP 634)与3.12的type(PEP 695)是重大语法革新。前者提供类似switch-case但更强大的结构化匹配能力;后者简化类型别名声明,提升类型提示可读性。例如:

type Point = tuple[float, float]
def distance(p: Point) -> float:
    return (p[0]**2 + p[1]**2)**0.5

流程控制类保留字详解

流程控制类保留字(共11个)构成程序逻辑的骨架,包括条件判断、循环控制与异常处理机制。掌握其组合用法是编写健壮代码的前提。

条件分支:if/elif/else

Python的条件分支支持链式判断,但需注意elif必须依附于if,不可单独使用。常见误区是混淆==(值相等)与is(身份相同):

def check_status(code):
    if code is None:  # 身份检查用'is'
        return "未初始化"
    if code == 200:   # 值比较用'=='
        return "成功"
    elif code == 404:
        return "未找到"
    else:
        return "未知状态"

在处理None时必须用is,因为None是单例对象,身份检查更高效且语义明确。若误用== None,当code为自定义类且重载了__eq__时可能导致意外行为。

循环控制:for/while/break/continue

for循环支持序列遍历与迭代器协议,而while依赖条件表达式。二者均可配合break与continue实现灵活控制:

def find_first_even(nums):
    for n in nums:
        if n % 2 == 0:
            print(f"找到首个偶数: {n}")
            break
    else:  # for循环的else子句
        print("未找到偶数")
find_first_even([1,3,5,7])  # 输出:未找到偶数

此处for...else结构是Python特有语法:当循环自然结束(非break中断)时执行else块。此设计避免了额外状态变量,提升代码简洁性。

异常处理:try/except/else/finally

异常处理机制通过try捕获风险操作,except处理特定异常,else在无异常时执行,finally确保清理逻辑运行:

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return None
    except TypeError:
        print("类型错误")
        return None
    else:
        print("除法成功")
        return result
    finally:
        print("操作结束")
safe_divide(10, 0)  # 输出:操作结束;返回None

注意except后必须跟异常类型,否则会捕获所有异常(包括KeyboardInterrupt),阻碍程序正常退出。生产环境应避免裸except。

数据类型与值相关保留字

Python内置三大基础值:True、False(布尔值)、None(空值)。它们在逻辑运算与状态表示中具有不可替代性。

布尔值的真值测试

所有对象均有隐式真值(truthy/falsy),以下对象被视为False:

自定义类可通过实现__bool__或__len__方法控制真值行为:

class Container:
    def __init__(self, items):
        self.items = items
    def __len__(self):
        return len(self.items)
c = Container([])
if c:  # len(c)==0 → False
    print("非空容器")
else:
    print("空容器")  # 输出此行

None的深度解析

None是NoneType的唯一实例,常用于:

经典反例:用可变对象作默认参数

def bad_func(lst=[]):
    lst.append("新元素")
    return lst
print(bad_func())  # ['新元素']
print(bad_func())  # ['新元素', '新元素']  # 累积副作用!

正确写法:

def good_func(lst=None):
    if lst is None:
        lst = []
    lst.append("新元素")
    return lst

身份运算符:is/is not

is比较对象身份(内存地址),==比较值。小整数(-5~256)和短字符串被缓存(id()相同),但大整数/长字符串可能不同:

a = 256
b = 256
print(a is b)  # True(缓存)
a = 257
b = 257
print(a is b)  # False(新对象)

生产环境应仅对None使用is,其他比较用==。

函数与作用域相关保留字

函数定义与作用域管理是Python高级特性的核心,涉及def、lambda、return、yield、global、nonlocal六大保留字。

函数定义:def

def声明函数时,函数体必须缩进,且可包含默认参数、可变参数、类型提示等:

def calc(a: int, b: int = 0) -> int:
    """计算a与b的和"""
    return a + b
print(calc(5))  # 默认b=0 → 5

匿名函数:lambda

lambda创建单表达式函数,常用于sorted、map等高阶函数:

words = ["apple", "banana", "cherry"]
words.sort(key=lambda x: len(x))  # 按长度排序

注意:lambda函数体只能是单个表达式,不能包含语句(如print、if)。复杂逻辑应使用def。

返回值:return/yield

return结束函数并返回值;yield将函数转为生成器,支持惰性计算:

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b
f = fib(5)
print(list(f))  # [0, 1, 1, 2, 3]

生成器优势:内存占用低(不一次性存储全部结果),适合处理大数据流。

作用域控制:global/nonlocal

global声明使用全局变量;nonlocal声明使用外层函数的变量(非全局):

def outer():
    x = "外层"
    def inner():
        nonlocal x  # 修改外层x
        x = "修改后"
    inner()
    print(x)  # 输出:修改后
outer()

错误示例:

def bad():
    x = 1
    def inner():
        x = 2  # 新建局部变量x,不修改外层
    inner()
    print(x)  # 输出:1

面向对象相关保留字

Python的面向对象机制通过class、def、self(非保留字)、super(非保留字)协同实现,但保留字仅class直接参与类定义。

类定义:class

class声明新类,支持继承与多继承:

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        raise NotImplementedError
class Dog(Animal):
    def speak(self):
        return f"{self.name}汪汪叫"
dog = Dog("小黑")
print(dog.speak())  # 小黑汪汪叫

继承与super

虽然super不是保留字,但常与class配合使用。Python 3中super()自动推断参数:

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)  # 调用父类初始化

注意:多重继承时super()遵循MRO(方法解析顺序),确保每个父类方法仅调用一次。

高频使用误区与解决方案

语法错误案例

  • 保留字作变量名:class = "student" → SyntaxError: invalid syntax
  • 缩进错误:if x > 0:后无缩进 → IndentationError
  • 未闭合引号:print("hello) → SyntaxError: EOL while scanning string literal

运行时错误案例

  • None调用方法:None.upper() → AttributeError: 'NoneType' object has no attribute 'upper'
  • 除零错误:10/0 → ZeroDivisionError
  • 类型不匹配:int("abc") → ValueError

逻辑陷阱案例

  • 可变默认参数:如前文bad_func示例
  • 浅拷贝陷阱:list1 = [[1,2], [3,4]],list2 = list1.copy()修改list1[0][0]会影响list2
  • 循环变量泄露:Python 3中for循环变量不泄露,但列表推导式可能影响全局命名空间