我要评论一、开篇：关键字——python的"保留词汇表"
每种编程语言都有一组"关键字"（keywords），它们是语言内置的、具有特殊含义的单词。你不能用它们来做变量名、函数名或类名——它们已经被python"预订"了。
如果把python语言比作汉语，那关键字就是汉语中的"的地得"、“你我他”——它们出现的频率极高，是构建句子（程序逻辑）不可或缺的骨架。
这篇文章，我会把python所有35个关键字逐一拆解。不用死记硬背，理解每个关键字的用途和典型使用场景，自然就记住了。
二、关键字全列表
python 3.12共有35个关键字。让我先用代码把它们列出来：
import keyword
# 查看所有关键字
print(keyword.kwlist)
# ['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']
print(f'python 3.12共有 {len(keyword.kwlist)} 个关键字')
# 判断某个词是否是关键字
print(keyword.iskeyword('if')) # true
print(keyword.iskeyword('hello')) # false
你也可以用 help('keywords') 在python交互环境中查看完整的关键字列表和简要说明。
下面我把它们按功能分类，逐一讲解。
三、条件控制关键字（5个）
3.1 if / elif / else
这三个是最基本的条件判断关键字，用于"根据不同条件执行不同代码"。
score = 85
if score >= 90:
print('成绩优秀')
elif score >= 80:
print('成绩良好')
elif score >= 60:
print('成绩及格')
else:
print('成绩不及格')
if：如果…（开一个条件判断）elif：否则如果…（在前一个条件不成立时，再判断新条件）else：否则…（前面所有条件都不成立时执行）
注意：elif 是 else if 的缩写，python中写 else if（带空格）是不对的。
3.2 match / case
python 3.10新增的模式匹配关键字，类似于其他语言中的 switch-case，但功能更强大：
status_code = 404
match status_code:
case 200:
print('成功')
case 301 | 302:
print('重定向')
case 404:
print('未找到')
case 500:
print('服务器错误')
case _: # _ 匹配任何情况（默认分支）
print('未知状态码')
match-case 不仅仅是简单的值匹配，它还可以匹配数据结构：
def process_command(command):
match command:
case {'action': 'create', 'data': data}:
print(f'创建：{data}')
case {'action': 'delete', 'id': id_}:
print(f'删除id：{id_}')
case {'action': 'update', 'id': id_, 'data': data}:
print(f'更新id {id_} 的数据为 {data}')
case _:
print('未知命令')
process_command({'action': 'create', 'data': 'hello'})
process_command({'action': 'delete', 'id': 42})
四、循环控制关键字（5个）
4.1 for / in
for 和 in 是python中最常用的循环结构：
# 遍历列表
fruits = ['苹果', '香蕉', '橘子']
for fruit in fruits:
print(fruit)
# 遍历字典
student_scores = {'小明': 85, '小红': 92, '小刚': 78}
for name, score in student_scores.items():
print(f'{name}: {score}分')
# 遍历range
for i in range(1, 6):
print(f'第{i}次循环')
in 关键字还有两种其他用法：
- 成员测试：
'苹果' in fruits→true - 在列表推导式中：
[x for x in range(10)]
4.2 while
while 是另一个循环结构，在条件为true时持续执行：
count = 0
while count < 5:
print(f'计数：{count}')
count += 1
# 无限循环（需要手动break）
while true:
user_input = input('输入q退出：')
if user_input == 'q':
break
print(f'你输入了：{user_input}')
4.3 break / continue
这两个关键字在循环体内部用于控制循环的执行流程：
# break：立即终止整个循环
for i in range(1, 11):
if i == 6:
break # i=6时直接跳出循环
print(i)
# 输出：1 2 3 4 5
# continue：跳过本次循环的剩余部分，进入下一次迭代
for i in range(1, 11):
if i % 2 == 0:
continue # 偶数时跳过打印
print(i)
# 输出：1 3 5 7 9
记忆口诀：
break：打破循环，循环结束continue：继续下一次，跳过当前
五、函数相关关键字（4个）
5.1 def / return
def 定义函数，return 返回结果：
def calculate_bmi(weight_kg, height_m):
"""计算bmi指数"""
if height_m <= 0:
return none # 提前返回——参数无效
bmi = weight_kg / (height_m ** 2)
return round(bmi, 1)
result = calculate_bmi(70, 1.75)
print(f'bmi: {result}') # bmi: 22.9
return 可以返回0个值（return）、1个值（return x）、或多个值（return x, y, z）。如果没有写 return，函数隐式返回 none。
5.2 lambda
lambda 用于创建简短的匿名函数（不需要写 def）：
# 常规函数写法
def add(x, y):
return x + y
# lambda等价写法
add = lambda x, y: x + y
print(add(3, 5)) # 8
# lambda常用作高阶函数的参数
numbers = [1, 5, 3, 7, 2]
sorted_numbers = sorted(numbers, key=lambda x: -x) # 按降序排列
print(sorted_numbers) # [7, 5, 3, 2, 1]
lambda语法限制：lambda函数体只能是一个表达式，不能包含多条语句或多行代码。复杂逻辑用 def。
5.3 yield
yield 关键字用于创建生成器函数（generator）。和 return 不同，yield 不结束函数，而只是"暂停"函数并返回一个值：
def countdown(n):
"""从n倒数到1的生成器"""
print('生成器开始工作...')
while n > 0:
yield n # 暂停，返回n的值
n -= 1
print('生成器工作结束')
# 调用生成器函数返回一个生成器对象
counter = countdown(3)
# 逐个获取值（每次resume，从上次暂停的位置继续执行）
print(next(counter)) # 输出：生成器开始工作... 3
print(next(counter)) # 输出：2
print(next(counter)) # 输出：1
print(next(counter)) # 输出：生成器工作结束 stopiteration异常
六、类相关关键字（1个）
6.1 class
class 定义一个新类：
class dog:
"""狗类"""
species = '犬科' # 类属性
def __init__(self, name, age):
self.name = name # 实例属性
self.age = age
def bark(self):
"""叫的方法"""
return f'{self.name}：汪汪！'
def __str__(self):
return f'狗({self.name}, {self.age}岁)'
my_dog = dog('旺财', 3)
print(my_dog.bark()) # 旺财：汪汪！
print(my_dog) # 狗(旺财, 3岁)
七、异常处理关键字（4个）
7.1 try / except / finally
这三个关键字组成python的异常处理机制：
try:
# 尝试执行可能会出错的代码
number = int(input('请输入一个数字：'))
result = 100 / number
print(f'100除以{number}等于{result}')
except valueerror:
# 捕获"值错误"异常（输入的不是数字）
print('错误：请输入一个有效的数字！')
except zerodivisionerror:
# 捕获"除以零"异常
print('错误：不能除以零！')
except exception as e:
# 捕获其他所有异常
print(f'发生了未知错误：{e}')
finally:
# 无论是否发生异常，都会执行
print('程序结束（finally块）')
异常处理的结构：
try:
可能出错的代码
except 异常类型1:
处理方案1
except 异常类型2:
处理方案2
finally:
无论是否异常都会执行的清理代码
7.2 raise
raise 用于主动抛出异常：
def check_age(age):
if age < 0:
raise valueerror('年龄不能为负数！')
if age > 150:
raise valueerror('年龄不能超过150！')
return f'年龄{age}是有效的'
print(check_age(25)) # 年龄25是有效的
print(check_age(-5)) # valueerror: 年龄不能为负数！
7.3 assert
assert 用于断言某个条件为true，如果为false则抛出 assertionerror：
def calculate_average(scores):
assert len(scores) > 0, '分数列表不能为空！'
return sum(scores) / len(scores)
print(calculate_average([85, 92, 78])) # 85.0
print(calculate_average([])) # assertionerror: 分数列表不能为空！
assert 主要用于开发和调试阶段。生产环境中可以用 python -o 参数禁用所有assert语句。
八、模块与导入关键字（5个）
8.1 import / from / as
# 方式一：导入整个模块 import math print(math.sqrt(16)) # 4.0 # 方式二：从模块中导入特定函数 from math import sqrt, pi print(sqrt(16)) # 4.0（不需要加math.前缀） print(pi) # 3.141592653589793 # 方式三：导入并取别名 import numpy as np arr = np.array([1, 2, 3]) from datetime import datetime as dt print(dt.now())
三种导入方式的选择：
import module：代码最清晰，但调用时需加模块名前缀from module import name：写得简洁，但可能和其他名字冲突import module as alias：当模块名太长或和项目中其他名字冲突时使用
8.2 global / nonlocal
这两个关键字用于在函数内部修改外层变量的值：
# global：在函数内部修改全局变量
total_calls = 0
def my_function():
global total_calls
total_calls += 1
print(f'这个函数被调用了 {total_calls} 次')
my_function() # 这个函数被调用了 1 次
my_function() # 这个函数被调用了 2 次
# nonlocal：在嵌套函数中修改外层函数的变量
def outer():
count = 0
def inner():
nonlocal count
count += 1
return count
return inner
counter = outer()
print(counter()) # 1
print(counter()) # 2
print(counter()) # 3
九、逻辑运算符与值关键字（7个）
9.1 and / or / not
# and：两者都为true才返回true
print(true and true) # true
print(true and false) # false
# or：任意一个为true就返回true
print(true or false) # true
print(false or false) # false
# not：取反
print(not true) # false
print(not false) # true
# 实际应用
age = 20
has_id = true
if age >= 18 and has_id:
print('可以进入')
if age < 18 or not has_id:
print('不能进入')
and 和 or 在python中会短路求值：
a and b：如果a为false，不计算b（因为结果肯定是false）a or b：如果a为true，不计算b（因为结果肯定是true）
# 短路求值的实际应用 name = none # safe_name = name.upper() # 会报错！ safe_name = name and name.upper() # 安全：name为none，不执行.upper() print(safe_name) # none
9.2 is / not (有单独说，但和in搭配)
is 不是比较值是否相等，而是判断两个变量是否指向同一个对象：
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b) # true（值相等）
print(a is b) # false（不同的对象）
print(a is c) # true（同一个对象）
# is 最常见的用法：判断none
result = none
if result is none:
print('没有结果')
# is not
if result is not none:
print('有结果')
9.3 true / false / none
这三个是python的内置常量关键字：
# true和false：布尔类型
is_active = true
is_deleted = false
# none：空值，表示"没有值"
user = none
def find_user(name):
# 如果找不到用户，返回none
return none
result = find_user('不存在的用户')
if result is none:
print('没找到这个用户')
true、false、none 都是关键字（在python 3中），不能被赋值。它们同时也是单例对象——整个程序中只有一个true、一个false、一个none。
十、其他关键字（4个）
10.1 del
del 用于删除对象（实际上是删除引用，减少引用计数）：
# 删除变量
x = 10
del x
# print(x) # nameerror: name 'x' is not defined
# 删除列表元素
fruits = ['苹果', '香蕉', '橘子', '葡萄']
del fruits[1] # 删除索引1的元素
print(fruits) # ['苹果', '橘子', '葡萄']
# 删除字典键值对
user = {'name': '小明', 'age': 25, 'city': '北京'}
del user['city']
print(user) # {'name': '小明', 'age': 25}
# 删除整个列表的切片
numbers = [1, 2, 3, 4, 5, 6]
del numbers[1:4]
print(numbers) # [1, 5, 6]
10.2 pass
pass 是一个空操作语句——它什么都不做。用于需要语法上有一条语句但逻辑上不需要做任何事情的地方：
# 占位符：函数体还没想好怎么写
def future_function():
pass # todo: 以后实现
# 空类
class emptybase:
pass
# 异常处理时忽略某些异常
try:
risky_operation()
except connectionerror:
pass # 连接错误可以忽略，继续执行
10.3 with
with 语句用于创建上下文管理器，最常见的是文件操作：
# 不用with的写法（需要手动关闭文件）
f = open('data.txt', 'r', encoding='utf-8')
try:
content = f.read()
print(content)
finally:
f.close()
# 用with的写法（自动关闭文件，简洁且安全）
with open('data.txt', 'r', encoding='utf-8') as f:
content = f.read()
print(content)
# 出了with代码块，文件自动关闭
with 确保资源（文件、网络连接、锁等）在使用完后被正确地释放，即使过程中发生了异常。
10.4 async / await
python 3.5+引入的异步编程关键字：
import asyncio
async def fetch_data(url):
"""模拟异步获取数据"""
print(f'开始获取：{url}')
await asyncio.sleep(1) # 模拟网络请求的等待
print(f'获取完成：{url}')
return f'{url}的数据'
async def main():
# 同时发起多个请求，并发执行
tasks = [
fetch_data('https://api1.example.com'),
fetch_data('https://api2.example.com'),
fetch_data('https://api3.example.com'),
]
results = await asyncio.gather(*tasks)
for result in results:
print(result)
# 运行异步程序
asyncio.run(main())
async 声明一个协程函数，await 等待一个异步操作完成。在await等待期间，python可以去执行其他任务。
十一、关键字速查表
为了方便复习和查阅，我把35个关键字按使用频率和重要程度排列：
| 级别 | 关键字 | 简要说明 |
|---|---|---|
| ⭐⭐⭐ | if elif else | 条件判断 |
| ⭐⭐⭐ | for in while | 循环 |
| ⭐⭐⭐ | def return | 定义和返回函数 |
| ⭐⭐⭐ | import from as | 导入模块 |
| ⭐⭐⭐ | class | 定义类 |
| ⭐⭐⭐ | try except finally | 异常处理 |
| ⭐⭐⭐ | true false none | 布尔值和空值 |
| ⭐⭐ | and or not | 逻辑运算符 |
| ⭐⭐ | break continue | 循环控制 |
| ⭐⭐ | with pass | 上下文管理和占位符 |
| ⭐⭐ | lambda | 匿名函数 |
| ⭐⭐ | is del | 身份判断和删除 |
| ⭐ | yield | 生成器 |
| ⭐ | global nonlocal | 作用域 |
| ⭐ | assert raise | 断言和抛出异常 |
| ⭐ | match case | 模式匹配（3.10+） |
| ⭐ | async await | 异步编程 |
十二、本篇小结
35个python关键字是python语法的基础骨架。不需要死记硬背，在持续的编码实践中，你会自然而然地掌握每一个。
今天的关键收获：
- 分类理解：按功能将关键字分为条件、循环、函数、类、异常、模块、逻辑、其他八大类
- 掌握核心：
if/elif/else、for/in、def/return、import、class、try/except是日常使用频率最高的 - 注意区分：
elif（不是else if）、is和==的区别、and/or的短路求值 - 不要赋值：关键字不能用作变量名，ide会帮你高亮提醒
你可以随时用 import keyword; print(keyword.kwlist) 来查看当前python版本的所有关键字。
以上就是python入门之35个常用关键字用途和典型使用场景盘点的详细内容，更多关于python关键字的资料请关注代码网其它相关文章！
发表评论