带你系统梳理 Python 全 39 个关键字（含 4 个软关键字），从基础语法到进阶用法

2026-06-22 18:44:40

一、什么是关键字？用简单的话来说，Python中的关键字就是Python 已经存在的特殊词语，这些特殊的词语在Python中都有自己固定的意思，既然是Python固定好的，那么就不能随便使用，不能随便给变量来命名，或者给函数命名，在Python中一共有39个关机那字，而且其中有4个事软关键字。

软关键字的意思就是只有在特定的场景下才是关键字，例如在一些模式匹配才会生效，平时可以当做普通名字来使用，不过建议也不要乱用，避免踩坑！

二、39 个关键字（一）流程控制类（12 个）1. if作用：用来做条件判断，满足条件就执行后面的代码块。常用场景：根据不同条件走不同的逻辑，比如判断成绩是否及格。错误点：容易忘记后面的冒号:，或者条件表达式写错（比如把==写成=）。基础案例：代码语言：python复制score = 85

if score >= 60:

print("及格啦！") # 条件满足，会执行进阶案例：多个条件组合判断代码语言：python复制score = 85

subject = "数学"

if score >= 90 and subject == "数学":

print("获得数学优秀奖励！")2. else作用：和if配对使用，条件不满足时执行的代码块；也能在循环后面用，循环正常结束后执行（没被 break 打断）。常用场景：处理条件不满足的情况，或者循环结束后的收尾工作。错误点：不能单独使用，必须和if或者循环配对；缩进容易搞错。基础案例：if-else 配对代码语言：python复制score = 50

if score >= 60:

print("及格啦！")

else:

print("不及格，要加油哦！") # 条件不满足，执行这里进阶案例：循环后的 else（判断是否找到目标）代码语言：python复制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；后面也要加冒号:。基础案例：成绩分等级代码语言：python复制score = 75

if score >= 90:

print("A等级")

elif score >= 80:

print("B等级")

elif score >= 70:

print("C等级")

else:

print("D等级") # 输出C等级4. for作用：用来循环遍历可迭代对象（比如列表、字符串、字典等）。常用场景：遍历数据，逐个处理，比如打印列表里的每个元素。错误点：忘记冒号:；在循环里修改正在遍历的列表，可能导致结果异常。基础案例：遍历列表代码语言：python复制fruits = ["苹果", "香蕉", "橘子"]

for fruit in fruits:

print(fruit) # 依次打印每个水果进阶案例：遍历字典的键和值代码语言：python复制person = {"名字": "张三", "年龄": 20, "性别": "男"}

for key, value in person.items():

print(f"{key}: {value}") # 打印键值对5. while作用：条件循环，只要条件为真，就一直执行循环体。常用场景：不知道循环次数，只知道结束条件时用，比如猜数字游戏。错误点：如果条件永远为真，会导致死循环（记得在循环里修改条件）；忘记冒号:。基础案例：猜数字游戏（简单版）代码语言：python复制target = 5

while True: # 无限循环，直到猜对

guess = int(input("猜一个数字："))

if guess == target:

print("猜对啦！")

break # 退出循环

else:

print("猜错了，再试试！")6. break作用：跳出当前所在的循环（for 或 while），不管循环条件是否满足，直接结束循环。常用场景：当找到目标或者满足某个结束条件时，提前退出循环。错误点：不能在循环外使用；多层循环时，只能跳出一层循环。基础案例：提前退出循环代码语言：python复制for i in range(1, 6):

if i == 3:

break # 遇到3就结束循环

print(i) # 打印1, 27. continue作用：跳过当前循环的剩余代码，直接进入下一次循环。常用场景：当遇到某个条件时，不想处理当前元素，直接跳过。错误点：不能在循环外使用；容易和 break 搞混，一个是跳过本次，一个是结束循环。基础案例：跳过偶数，只打印奇数代码语言：python复制for i in range(1, 6):

if i % 2 == 0:

continue # 是偶数，跳过本次循环

print(i) # 打印1, 3, 58. match（软关键字，3.10 + 引入的模式匹配）作用：根据不同的模式匹配数据，有点像升级版的 switch-case，更灵活。常用场景：处理不同结构的数据，比如解析 API 返回的不同状态。错误点：后面必须跟表达式；case 块里的模式要写对，比如用_表示任意值。基础案例：简单模式匹配代码语言：python复制status = "success"

match status:

case "success":

print("操作成功！") # 匹配成功，执行这里

case "fail":

print("操作失败！")

case _: # 匹配其他任意值

print("未知状态")进阶案例：匹配复杂数据结构（比如元组）代码语言：python复制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 块里；模式语法要正确，比如用|表示或关系。基础案例：多个模式匹配代码语言：python复制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 的顺序要注意，子类异常要放在前面。基础案例：简单异常处理代码语言：python复制try:

num = int(input("输入一个数字："))

print(f"你输入的是{num}")

except ValueError: # 处理值错误（比如输入字母）

print("输入错误，必须是数字！")11. except作用：和 try 配对，用来处理具体的异常类型，捕获异常后执行对应的代码块。常用场景：针对不同的异常做不同的处理，比如文件不存在、类型错误等。错误点：可以省略异常类型（捕获所有异常），但不建议，最好指定具体类型；可以有多个 except 处理不同异常。基础案例：处理多种异常代码语言：python复制try:

with open("test.txt", "r") as f:

content = f.read()

except FileNotFoundError: # 文件不存在错误

print("文件没找到！")

except PermissionError: # 没有权限访问

print("没有访问权限！")12. finally作用：不管有没有异常，都会执行的代码块，通常用于资源释放（比如关闭文件、数据库连接）。常用场景：确保资源一定被释放，比如打开文件后，不管有没有错误，都要关闭文件。错误点：不能单独使用，必须和 try 一起用；即使 try 里有 return，finally 也会执行。基础案例：确保文件关闭代码语言：python复制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，但不要当数字用。基础案例：布尔判断代码语言：python复制is_ok = True

if is_ok:

print("状态正常！") # 会执行14. False作用：表示布尔值假，是 bool 类型的另一个常量。常用场景：条件判断中的假，比如if not False: print("不是假")。错误点：不能写成小写 false，必须大写；False 本质上等于 0，但不要当数字用。基础案例：布尔判断代码语言：python复制is_error = False

if not is_error:

print("没有错误！") # 会执行15. None作用：表示空值，相当于其他语言的 null，是 NoneType 类型的唯一值。常用场景：初始化变量，表示没有值；函数没有返回值时，默认返回 None。错误点：不能用==和 False 比较（None 不等于 False）；判断是否为 None 要用is None。基础案例：判断函数返回值代码语言：python复制def get_name():

return None # 没有名字时返回None

name = get_name()

if name is None:

print("名字为空！") # 会执行16. and作用：逻辑与运算符，两边都为真时，结果才为真（True and True = True）。常用场景：组合多个条件，比如同时满足两个条件才执行。错误点：不要和按位与&搞混；短路特性：左边为假时，右边不执行。基础案例：条件组合代码语言：python复制age = 25

is_student = True

if age >= 18 and is_student:

print("成年学生，可以享受优惠！") # 两个条件都满足，执行17. or作用：逻辑或运算符，只要有一个为真，结果就为真（True or False = True）。常用场景：多个条件满足一个就行，比如登录时用户名或邮箱登录。错误点：不要和按位或|搞混；短路特性：左边为真时，右边不执行。基础案例：条件组合代码语言：python复制username = "张三"

email = ""

if username or email: # 只要有一个不为空就可以

print("登录信息有效！") # username不为空，执行18. not作用：逻辑非运算符，取反，真变假，假变真（not True = False）。常用场景：对条件取反，比如判断是否不等于某个值。错误点：注意优先级，比如not a and b相当于(not a) and b。基础案例：条件取反代码语言：python复制is_negative = False

if not is_negative:

print("不是负数！") # 会执行19. in作用：判断一个元素是否在可迭代对象中（比如列表、字符串、字典的键）。常用场景：检查元素是否存在，比如列表里有没有某个值。错误点：字典中判断的是键是否存在，不是值；注意和not in区分。基础案例：检查元素存在代码语言：python复制fruits = ["苹果", "香蕉", "橘子"]

if "香蕉" in fruits:

print("有香蕉！") # 会执行进阶案例：字典中检查键代码语言：python复制person = {"名字": "张三", "年龄": 20}

if "名字" in person:

print("有名字属性！") # 会执行20. is作用：判断两个对象是否是同一个对象（内存地址相同），不是值相等。常用场景：判断是否为 None（推荐用 is None），或者比较小整数（Python 会缓存小整数，可能有坑）。错误点：不要和==搞混，==是值相等，is 是身份相等；对于列表、字典等可变对象，即使值相同，is 也为 False。基础案例：判断是否为 None代码语言：python复制x = None

if x is None:

print("x是None！") # 会执行注意坑：代码语言：python复制a = 1000

b = 1000

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

print(a == b) # True（值相等）（三）定义与声明类（7 个）21. def作用：用来定义函数，是函数声明的关键字。常用场景：封装重复代码，提高复用性，比如定义一个加法函数。错误点：后面要加冒号:；函数体要缩进；函数名不能是关键字。基础案例：定义简单函数代码语言：python复制def add(a, b):

return a + b # 返回两个数的和

result = add(3, 5)

print(result) # 8进阶案例：带默认参数的函数代码语言：python复制def greet(name, age=18):

print(f"你好，{name}，你的年龄是{age}")

greet("张三") # 年龄用默认值18

greet("李四", 20) # 传入年龄2022. class作用：用来定义类，是面向对象编程的基础，创建对象的模板。常用场景：封装数据和方法，比如定义一个学生类。错误点：后面要加冒号:；类名首字母通常大写（约定俗成）；方法第一个参数是 self（代表实例本身）。基础案例：定义简单类代码语言：python复制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）；参数列表外不能有其他代码。基础案例：简单匿名函数代码语言：python复制add = lambda x, y: x + y # 定义加法函数

print(add(3, 5)) # 8进阶案例：配合 map 使用代码语言：python复制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 直接修改）：代码语言：python复制count = 0

def increment():

count += 1 # 报错！因为没声明global，Python认为这是局部变量，但还没赋值25. nonlocal作用：在嵌套函数中，声明使用外层函数的变量，而不是全局变量。常用场景：闭包中修改外层函数的变量。错误点：不能用于全局变量，只能用于外层函数的变量；Python 3 才有的关键字。基础案例：闭包中修改外层变量代码语言：python复制def outer():

x = 10

def inner():

nonlocal x # 声明使用外层的x

x += 1

print(x)

inner()

outer() # 11（外层的x被修改）26. assert作用：调试时用的断言，检查某个条件是否为真，如果为假，抛出 AssertionError 异常。常用场景：调试代码，确保程序状态符合预期，比如函数参数是否合法。错误点：正式发布的代码中，断言会被忽略（除非用 - O 参数运行），所以不能依赖断言做错误处理。基础案例：检查参数代码语言：python复制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()来运行。基础案例：简单异步函数代码语言：python复制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方法）；缩进要正确。基础案例：文件操作代码语言：python复制with open("test.txt", "w") as f: # 打开文件，f是文件对象

f.write("Hello, World!") # 写入内容，离开with块自动关闭文件29. del作用：删除变量、列表中的元素、字典中的键等。常用场景：释放不再需要的对象，或者删除容器中的元素。错误点：删除变量只是解除引用，不一定立即释放内存（由垃圾回收机制处理）；删除列表元素时，索引要正确。基础案例：删除变量代码语言：python复制x = 10

del x # 删除变量x，之后再访问x会报错进阶案例：删除列表元素fruits = ["苹果", "香蕉", "橘子"]

del fruits[1] # 删除索引1的元素（香蕉）

print(fruits) # ["苹果", "橘子"]30. from作用：和 import 一起用，从模块中导入指定的内容（函数、类、变量等）。常用场景：只导入需要的部分，避免导入整个模块，节省资源。错误点：from module import *会导入模块所有内容，可能导致命名冲突；导入的是模块中的名称，修改会影响原模块。基础案例：导入指定函数代码语言：python复制from math import sqrt # 从math模块导入sqrt函数

print(sqrt(16)) # 431. import作用：导入模块，让我们可以使用模块中的功能。常用场景：使用第三方库或 Python 内置模块，比如 math、os 等。错误点：模块名要正确，不能和变量名冲突；循环导入会导致错误（比如 A 导入 B，B 又导入 A）。基础案例：导入整个模块代码语言：python复制import math # 导入math模块

print(math.sqrt(25)) # 5（使用模块中的sqrt函数）进阶案例：导入模块并取别名代码语言：python复制import pandas as pd # 取别名pd，方便使用

df = pd.DataFrame() # 创建数据框（五）其他关键字（8 个）32. pass作用：空语句，占位符，当需要写语句但暂时不想写内容时用。常用场景：定义空函数、空类，或者在条件判断中占位。错误点：不能省略，比如定义一个空函数，必须用 pass，否则会报错。基础案例：空函数代码语言：python复制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 会直接结束函数；可以返回多个值（用元组形式）。基础案例：返回单个值进阶案例：返回多个值代码语言：python复制def divide(a, b):

quotient = a // b

remainder = a % b

return quotient, remainder # 返回元组

q, r = divide(10, 3)

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

while n > 0:

yield n # 每次返回n，暂停执行

n -= 1

for num in countdown(5):

print(num) # 依次打印5,4,3,2,135. 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 类。基础案例：抛出内置异常代码语言：python复制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 中是软关键字。基础案例：代码语言：python复制value = "任意值"

match value:

case _: # 匹配所有情况

print("不管是什么，都执行这里") # 会执行38. 软关键字：*（在模式匹配中表示收集多个元素）作用：在 match-case 中，匹配多个元素并收集到列表中，类似函数的 * args。常用场景：匹配可变数量的元素，比如元组中的多个值。错误点：只能在模式匹配的解构中使用，比如case (a, *rest):。基础案例：代码语言：python复制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。常用场景：编写模式匹配时，先占位，后续再补充代码。错误点：平时是一个内置对象，在模式匹配中作为软关键字。基础案例：代码语言：python复制def handle_value(value):

match value:

case 1:

print("处理1")

case 2:

print("处理2")

case ...: # 其他情况暂时不处理

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