一、什么是关键字？

在Python中一共有39个关键字，而且其中有4个软关键字。

软关键字的意思就是只有在特定的场景下才是关键字，例如在一些模式匹配才会生效，平时可以当做普通名字来使用！

二、39 个关键字

（一）流程控制类（12 个）

1. if

• 作用：用来做条件判断，满足条件就执行后面的代码块。
• 常用场景：根据不同条件走不同的逻辑，比如判断成绩是否及格。
• 错误点：容易忘记后面的冒号:，或者条件表达式写错（比如把==写成=）。
• 基础案例：

score = 85

if score >= 60:
   print("及格啦！")  # 条件满足，会执行

• 进阶案例：多个条件组合判断

score = 85

subject = "数学"

if score >= 90 and subject == "数学":
   print("获得数学优秀奖励！")

2. else

• 作用：和if配对使用，条件不满足时执行的代码块；也能在循环后面用，循环正常结束后执行（没被 break 打断）。
• 常用场景：处理条件不满足的情况，或者循环结束后的收尾工作。
• 错误点：不能单独使用，必须和if或者循环配对；缩进容易搞错。
• 基础案例：if-else 配对

score = 50
if score >= 60:
   print("及格啦！")
else:
   print("不及格，要加油哦！")  # 条件不满足，执行这里

• 进阶案例：循环后的 else（判断是否找到目标）

numbers = [1, 2, 3, 4]
target = 5
for num in numbers:
   if num == target:
       print("找到目标啦！")
       break
else:  # 循环正常结束（没break），执行这里

   print("没找到目标...")  # 这里会执行，因为target不在列表里

3. elif（else if 的缩写）

• 作用：多个条件判断时用，相当于 “否则如果”，放在if和else之间。
• 常用场景：多分支判断，比如成绩分等级（A、B、C、D）。
• 错误点：容易写成else if，这是错误的，必须用elif；后面也要加冒号:。
• 基础案例：成绩分等级

score = 75
if score >= 90:
   print("A等级")
elif score >= 80:
   print("B等级")
elif score >= 70:
   print("C等级")
else:
   print("D等级")  # 输出C等级

4. for

• 作用：用来循环遍历可迭代对象（比如列表、字符串、字典等）。
• 常用场景：遍历数据，逐个处理，比如打印列表里的每个元素。
• 错误点：忘记冒号:；在循环里修改正在遍历的列表，可能导致结果异常。
• 基础案例：遍历列表

fruits = ["苹果", "香蕉", "橘子"]
for fruit in fruits:
   print(fruit)  # 依次打印每个水果

• 进阶案例：遍历字典的键和值

person = {"名字": "张三", "年龄": 20, "性别": "男"}

for key, value in person.items():

   print(f"{key}: {value}")  # 打印键值对

5. while

• 作用：条件循环，只要条件为真，就一直执行循环体。
• 常用场景：不知道循环次数，只知道结束条件时用，比如猜数字游戏。
• 错误点：如果条件永远为真，会导致死循环（记得在循环里修改条件）；忘记冒号:。
• 基础案例：猜数字游戏（简单版）

target = 5

while True:  # 无限循环，直到猜对
   guess = int(input("猜一个数字："))
   if guess == target:
       print("猜对啦！")
       break  # 退出循环
   else:
       print("猜错了，再试试！")

6. break

• 作用：跳出当前所在的循环（for 或 while），不管循环条件是否满足，直接结束循环。
• 常用场景：当找到目标或者满足某个结束条件时，提前退出循环。
• 错误点：不能在循环外使用；多层循环时，只能跳出一层循环。
• 基础案例：提前退出循环

for i in range(1, 6):
   if i == 3:
       break  # 遇到3就结束循环
   print(i)  # 打印1, 2

7. continue

• 作用：跳过当前循环的剩余代码，直接进入下一次循环。
• 常用场景：当遇到某个条件时，不想处理当前元素，直接跳过。
• 错误点：不能在循环外使用；容易和 break 搞混，一个是跳过本次，一个是结束循环。
• 基础案例：跳过偶数，只打印奇数

for i in range(1, 6):
   if i % 2 == 0:
       continue  # 是偶数，跳过本次循环
   print(i)  # 打印1, 3, 5

8. match（软关键字，3.10 + 引入的模式匹配）

• 作用：根据不同的模式匹配数据，有点像升级版的 switch-case，更灵活。
• 常用场景：处理不同结构的数据，比如解析 API 返回的不同状态。
• 错误点：后面必须跟表达式；case 块里的模式要写对，比如用_表示任意值。
• 基础案例：简单模式匹配

status = "success"
match status:
   case "success":
       print("操作成功！")  # 匹配成功，执行这里
   case "fail":
       print("操作失败！")
   case _:  # 匹配其他任意值
       print("未知状态")

• 进阶案例：匹配复杂数据结构（比如元组）

point = (2, 3)
match point:
   case (0, 0):
       print("原点")
   case (x, 0):
       print(f"在x轴上，x坐标是{x}")
   case (0, y):
       print(f"在y轴上，y坐标是{y}")
   case (x, y):
       print(f"坐标是({x}, {y})")  # 匹配任意坐标，这里会执行

9. case（软关键字，和 match 配对使用）

• 作用：定义 match 中的具体匹配模式，每个 case 对应一种情况。
• 常用场景：和 match 一起用，写不同的匹配分支。
• 错误点：不能单独使用，必须在 match 块里；模式语法要正确，比如用|表示或关系。
• 基础案例：多个模式匹配

num = 5
match num:
   case 1 | 2 | 3:  # 匹配1或2或3
       print("小数字")
   case 4 | 5 | 6:
       print("中数字")  # 匹配5，执行这里
   case _:
       print("大数字")

10. try

• 作用：用来检测代码块中的异常（错误），一旦发生异常，就跳转到 except 处理。
• 常用场景：处理可能出错的代码，比如文件读取、用户输入错误等。
• 错误点：try 块后面必须跟 except 或 finally；多个 except 的顺序要注意，子类异常要放在前面。
• 基础案例：简单异常处理

try:
   num = int(input("输入一个数字："))
   print(f"你输入的是{num}")
except ValueError:  # 处理值错误（比如输入字母）
   print("输入错误，必须是数字！")

11. except

• 作用：和 try 配对，用来处理具体的异常类型，捕获异常后执行对应的代码块。
• 常用场景：针对不同的异常做不同的处理，比如文件不存在、类型错误等。
• 错误点：可以省略异常类型（捕获所有异常），但不建议，最好指定具体类型；可以有多个 except 处理不同异常。
• 基础案例：处理多种异常

try:
   with open("test.txt", "r") as f:
       content = f.read()
except FileNotFoundError:  # 文件不存在错误
   print("文件没找到！")
except PermissionError:  # 没有权限访问
   print("没有访问权限！")

12. finally

• 作用：不管有没有异常，都会执行的代码块，通常用于资源释放（比如关闭文件、数据库连接）。
• 常用场景：确保资源一定被释放，比如打开文件后，不管有没有错误，都要关闭文件。
• 错误点：不能单独使用，必须和 try 一起用；即使 try 里有 return，finally 也会执行。
• 基础案例：确保文件关闭

f = None
try:
   f = open("test.txt", "r")
   content = f.read()
except FileNotFoundError:
   print("文件没找到！")
finally:
   if f:
       f.close()  # 不管有没有异常，都会关闭文件

（二）数据类型与运算类（8 个）

13. True

• 作用：表示布尔值真，是 bool 类型的一个常量。
• 常用场景：条件判断中的真，比如if True: print("真")。
• 错误点：不能写成小写 true，必须大写；虽然 True 本质上等于 1，但不要当数字用。
• 基础案例：布尔判断

is_ok = True
if is_ok:
   print("状态正常！")  # 会执行

14. False

• 作用：表示布尔值假，是 bool 类型的另一个常量。
• 常用场景：条件判断中的假，比如if not False: print("不是假")。
• 错误点：不能写成小写 false，必须大写；False 本质上等于 0，但不要当数字用。
• 基础案例：布尔判断

is_error = False
if not is_error:
   print("没有错误！")  # 会执行

15. None

• 作用：表示空值，相当于其他语言的 null，是 NoneType 类型的唯一值。
• 常用场景：初始化变量，表示没有值；函数没有返回值时，默认返回 None。
• 错误点：不能用==和 False 比较（None 不等于 False）；判断是否为 None 要用is None。
• 基础案例：判断函数返回值

def get_name():
   return None  # 没有名字时返回None
name = get_name()
if name is None:
   print("名字为空！")  # 会执行

16. and

• 作用：逻辑与运算符，两边都为真时，结果才为真（True and True = True）。
• 常用场景：组合多个条件，比如同时满足两个条件才执行。
• 错误点：不要和按位与&搞混；短路特性：左边为假时，右边不执行。
• 基础案例：条件组合

age = 25
is_student = True
if age >= 18 and is_student:
   print("成年学生，可以享受优惠！")  # 两个条件都满足，执行

17. or

• 作用：逻辑或运算符，只要有一个为真，结果就为真（True or False = True）。
• 常用场景：多个条件满足一个就行，比如登录时用户名或邮箱登录。
• 错误点：不要和按位或|搞混；短路特性：左边为真时，右边不执行。
• 基础案例：条件组合

username = "张三"
email = ""
if username or email:  # 只要有一个不为空就可以
   print("登录信息有效！")  # username不为空，执行

18. not

• 作用：逻辑非运算符，取反，真变假，假变真（not True = False）。
• 常用场景：对条件取反，比如判断是否不等于某个值。
• 错误点：注意优先级，比如not a and b相当于(not a) and b。
• 基础案例：条件取反

is_negative = False
if not is_negative:

   print("不是负数！")  # 会执行

19. in

• 作用：判断一个元素是否在可迭代对象中（比如列表、字符串、字典的键）。
• 常用场景：检查元素是否存在，比如列表里有没有某个值。
• 错误点：字典中判断的是键是否存在，不是值；注意和not in区分。
• 基础案例：检查元素存在

fruits = ["苹果", "香蕉", "橘子"]
if "香蕉" in fruits:
   print("有香蕉！")  # 会执行

• 进阶案例：字典中检查键

person = {"名字": "张三", "年龄": 20}
if "名字" in person:
   print("有名字属性！")  # 会执行

20. is

• 作用：判断两个对象是否是同一个对象（内存地址相同），不是值相等。
• 常用场景：判断是否为 None（推荐用 is None），或者比较小整数（Python 会缓存小整数，可能有坑）。
• 错误点：不要和==搞混，==是值相等，is 是身份相等；对于列表、字典等可变对象，即使值相同，is 也为 False。
• 基础案例：判断是否为 None

x = None
if x is None:
   print("x是None！")  # 会执行

• 注意坑：

a = 1000
b = 1000
print(a is b)  # 可能为False（Python对大整数不缓存，地址不同）
print(a == b)  # True（值相等）

（三）定义与声明类（7 个）

21. def

• 作用：用来定义函数，是函数声明的关键字。
• 常用场景：封装重复代码，提高复用性，比如定义一个加法函数。
• 错误点：后面要加冒号:；函数体要缩进；函数名不能是关键字。
• 基础案例：定义简单函数

def add(a, b):
   return a + b  # 返回两个数的和
result = add(3, 5)
print(result)  # 8

• 进阶案例：带默认参数的函数

def greet(name, age=18):
   print(f"你好，{name}，你的年龄是{age}")
greet("张三")  # 年龄用默认值18
greet("李四", 20)  # 传入年龄20

22. class

• 作用：用来定义类，是面向对象编程的基础，创建对象的模板。
• 常用场景：封装数据和方法，比如定义一个学生类。
• 错误点：后面要加冒号:；类名首字母通常大写（约定俗成）；方法第一个参数是 self（代表实例本身）。
• 基础案例：定义简单类

class Student:
   def __init__(self, name, age):  # 初始化方法
       self.name = name  # 实例变量
       self.age = age
   def study(self):  # 实例方法
       print(f"{self.name}在学习！")
student = Student("张三", 20)
student.study()  # 输出：张三在学习！

23. lambda

• 作用：定义匿名函数（没有名字的函数），通常用于简单的函数表达式。
• 常用场景：配合高阶函数（比如 map、filter）使用，简化代码。
• 错误点：只能写一个表达式，不能写语句（比如 print、if-else 语句不行，但可以用表达式形式的 if-else）；参数列表外不能有其他代码。
• 基础案例：简单匿名函数

add = lambda x, y: x + y  # 定义加法函数
print(add(3, 5))  # 8

• 进阶案例：配合 map 使用

numbers = [1, 2, 3, 4]
doubled = map(lambda x: x * 2, numbers)
print(list(doubled))  # [2, 4, 6, 8]

24. global

• 作用：在函数内部声明使用全局变量，否则函数内同名变量会被视为局部变量。count = 0 # 全局变量 def increment(): global count # 声明使用全局的count count += 1 increment() print(count) # 1（全局变量被修改）
• 常用场景：需要在函数中修改全局变量时使用。
• 错误点：如果只是读取全局变量，不需要 global；如果要修改，必须声明 global，否则会报错。
• 基础案例：修改全局变量
• 错误案例（不声明 global 直接修改）：

count = 0
def increment():
   count += 1  # 报错！因为没声明global，Python认为这是局部变量，但还没赋值

25. nonlocal

• 作用：在嵌套函数中，声明使用外层函数的变量，而不是全局变量。
• 常用场景：闭包中修改外层函数的变量。
• 错误点：不能用于全局变量，只能用于外层函数的变量；Python 3 才有的关键字。
• 基础案例：闭包中修改外层变量

def outer():
   x = 10
   def inner():
       nonlocal x  # 声明使用外层的x
       x += 1
       print(x)
   inner()
outer()  # 11（外层的x被修改）

26. assert

• 作用：调试时用的断言，检查某个条件是否为真，如果为假，抛出 AssertionError 异常。
• 常用场景：调试代码，确保程序状态符合预期，比如函数参数是否合法。
• 错误点：正式发布的代码中，断言会被忽略（除非用 – O 参数运行），所以不能依赖断言做错误处理。
• 基础案例：检查参数

def divide(a, b):
   assert b != 0, "除数不能为0！"  # 断言b不为0
   return a / b
divide(10, 0)  # 抛出AssertionError: 除数不能为0！

27. async /await（成对出现，异步编程用）

• 作用：async用来定义异步函数，await用来等待异步操作完成（比如 IO 操作）。
• 常用场景：处理高并发的 IO 密集型任务，比如网络请求、文件读写，提高效率。
• 错误点：await只能在async定义的函数内使用；异步函数调用时需要用asyncio.run()来运行。
• 基础案例：简单异步函数

import asyncio
async def fetch_data():
   await asyncio.sleep(1)  # 模拟异步IO操作
   return "数据获取完成！"
async def main():
   result = await fetch_data()  # 等待异步函数执行
   print(result)
asyncio.run(main())  # 输出：数据获取完成！

（四）上下文与作用域类（4 个）

28. with

• 作用：上下文管理器，用于自动管理资源，比如文件、数据库连接的打开和关闭。
• 常用场景：代替 try-finally，更简洁，确保资源释放。
• 错误点：需要对象支持上下文管理器协议（实现enter和exit方法）；缩进要正确。
• 基础案例：文件操作

with open("test.txt", "w") as f:  # 打开文件，f是文件对象
   f.write("Hello, World!")  # 写入内容，离开with块自动关闭文件

29. del

• 作用：删除变量、列表中的元素、字典中的键等。
• 常用场景：释放不再需要的对象，或者删除容器中的元素。
• 错误点：删除变量只是解除引用，不一定立即释放内存（由垃圾回收机制处理）；删除列表元素时，索引要正确。
• 基础案例：删除变量

x = 10
del x  # 删除变量x，之后再访问x会报错

• 进阶案例：删除列表元素fruits = [“苹果”, “香蕉”, “橘子”] del fruits[1] # 删除索引1的元素（香蕉） print(fruits) # [“苹果”, “橘子”]

30. from

• 作用：和 import 一起用，从模块中导入指定的内容（函数、类、变量等）。
• 常用场景：只导入需要的部分，避免导入整个模块，节省资源。
• 错误点：from module import *会导入模块所有内容，可能导致命名冲突；导入的是模块中的名称，修改会影响原模块。
• 基础案例：导入指定函数

from math import sqrt  # 从math模块导入sqrt函数
print(sqrt(16))  # 4

31. import

• 作用：导入模块，让我们可以使用模块中的功能。
• 常用场景：使用第三方库或 Python 内置模块，比如 math、os 等。
• 错误点：模块名要正确，不能和变量名冲突；循环导入会导致错误（比如 A 导入 B，B 又导入 A）。
• 基础案例：导入整个模块

import math  # 导入math模块
print(math.sqrt(25))  # 5（使用模块中的sqrt函数）

• 进阶案例：导入模块并取别名

import pandas as pd  # 取别名pd，方便使用
df = pd.DataFrame()  # 创建数据框

（五）其他关键字（8 个）

32. pass

• 作用：空语句，占位符，当需要写语句但暂时不想写内容时用。
• 常用场景：定义空函数、空类，或者在条件判断中占位。
• 错误点：不能省略，比如定义一个空函数，必须用 pass，否则会报错。
• 基础案例：空函数

def do_nothing():
   pass  # 占位，否则函数体为空会报错

• 进阶案例：空类class EmptyClass: pass # 占位，否则类体为空会报错

33. return

• 作用：从函数中返回值，结束函数执行；没有 return 时，默认返回 None。def add(a, b): return a + b # 返回和 result = add(3, 5) print(result) # 8
• 常用场景：函数处理完逻辑后，返回结果给调用者。
• 错误点：在循环或条件判断中，return 会直接结束函数；可以返回多个值（用元组形式）。
• 基础案例：返回单个值
• 进阶案例：返回多个值

def divide(a, b):
   quotient = a // b
   remainder = a % b
   return quotient, remainder  # 返回元组
q, r = divide(10, 3)
print(q, r)  # 3 1

34. yield

• 作用：生成器函数中使用，每次调用生成器的 next () 方法时，返回一个值，暂停执行，下次从这里继续。
• 常用场景：处理大文件或大量数据，按需生成，节省内存。
• 错误点：生成器函数用 yield 而不是 return；yield 返回的是生成器对象，需要迭代才能获取值。
• 基础案例：简单生成器

def countdown(n):
   while n > 0:
       yield n  # 每次返回n，暂停执行
       n -= 1
for num in countdown(5):
   print(num)  # 依次打印5,4,3,2,1

35. as

• 作用：给导入的模块、上下文管理器中的对象取别名，或者在异常处理中给异常对象取别名。import numpy as np # 给numpy取别名np arr = np.array([1, 2, 3]) try: x = 1 / 0 except ZeroDivisionError as e: # 给异常对象e取别名 print(f”错误信息：{e}”) # 输出：division by zero
• 常用场景：简化名称，比如给长模块名取短别名；捕获异常时获取异常信息。
• 错误点：不同场景用法不同，比如import module as alias和with open() as f。
• 基础案例：取别名

36. raise

• 作用：主动抛出异常，可以是内置异常，也可以是自定义异常。
• 常用场景：在函数中检查到错误条件时，抛出异常让调用者处理。
• 错误点：可以不带参数，重新抛出当前异常；自定义异常需要继承 Exception 类。
• 基础案例：抛出内置异常

def check_age(age):

   if age < 0:
       raise ValueError("年龄不能为负数！")  # 抛出值错误
   print(f"年龄是{age}")
check_age(-5)  # 抛出ValueError: 年龄不能为负数！

• 进阶案例：自定义异常class TooYoungError(Exception): pass def check_age(age): if age < 18: raise TooYoungError(“未满18岁，禁止访问！”) check_age(15) # 抛出TooYoungError: 未满18岁，禁止访问！

37. 软关键字：_（下划线，在模式匹配中作为通配符）

• 作用：在 match-case 中表示匹配任意值，相当于 “随便什么都行”。
• 常用场景：模式匹配中不想处理的情况，用_来占位。
• 错误点：平时可以当变量名用（虽然不推荐），但在 match-case 中是软关键字。
• 基础案例：

value = "任意值"
match value:
   case _:  # 匹配所有情况
       print("不管是什么，都执行这里")  # 会执行

38. 软关键字：*（在模式匹配中表示收集多个元素）

• 作用：在 match-case 中，匹配多个元素并收集到列表中，类似函数的 * args。
• 常用场景：匹配可变数量的元素，比如元组中的多个值。
• 错误点：只能在模式匹配的解构中使用，比如case (a, *rest):。
• 基础案例：

numbers = (1, 2, 3, 4, 5)
match numbers:
   case (first, *rest):  # first是1，rest是[2,3,4,5]
       print(f"第一个数是{first}，剩下的是{rest}")  # 会执行

39. 软关键字：…（Ellipsis，在模式匹配中表示占位符）

• 作用：在模式匹配中，暂时不处理的情况，作为占位符，类似 pass。
• 常用场景：编写模式匹配时，先占位，后续再补充代码。
• 错误点：平时是一个内置对象，在模式匹配中作为软关键字。
• 基础案例：

def handle_value(value):
   match value:
       case 1:
           print("处理1")
       case 2:
           print("处理2")
       case ...:  # 其他情况暂时不处理
           pass

三、新手常见错误总结

1. 把关键字当变量名：比如if = 10，会报错，因为 if 是关键字，不能用来命名。
2. 忘记冒号:：在 if、else、elif、for、while、def、class、match 等后面，都需要加冒号，新手经常忘记。
3. 混淆is和==：is是身份比较（内存地址），==是值比较，尤其是在判断 None 时，要用is None，而不是== None。
4. 循环里修改正在遍历的列表：比如for item in list: list.append(item)，会导致循环无限执行，因为列表长度变了。
5. lambda 中写语句：lambda 只能有一个表达式，不能写 print、if-else 语句（可以用表达式形式的 if-else，比如x if condition else y）。