---

一、前言

Python 的保留字，也称为关键字（keywords），是指在编程语言中具有特殊含义并被用于特定目的的单词或标识符。这些保留字在 Python 中有特殊的语法和用途，不能被用作普通的变量名或函数名。

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

这些保留字大致可以分为几类：

控制流语句：如if、for、while等，用于控制程序的执行流程。
循环和条件表达式：如break、continue、pass等，用于控制循环或条件表达式的行为。
异常处理：如try、except、finally等，用于处理程序中的异常情况。
函数定义：如def、return等，用于定义函数和指定函数的返回值。
类定义：如class等，用于定义新的类。
模块和导入：如import、from…import等，用于导入模块或特定的函数或类。
变量和类型声明：如global、nonlocal、assert等，用于声明全局变量、非局部变量、断言等。
其他：如with、yield等，用于实现特定的功能，如上下文管理器、生成器等。

---

二、关键字

1.总表（共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

1. False：布尔值，表示“假”。在布尔运算中用作False值。
2. None：表示空值或无值。常用于表示变量没有指向任何对象。
3. True：布尔值，表示“真”。在布尔运算中用作True值。
4. and：逻辑运算符，用于将两个条件组合在一起。如果两个条件都为真，则返回True。
5. as：用于类型别名，通常在导入模块或使用函数时使用。
6. assert：断言关键字，用于测试代码中的某个条件是否为真。如果条件为假，则会引发AssertionError异常。
7. async：用于定义异步函数。异步函数允许在等待某些操作（如I/O操作）完成时执行其他代码。
8. await：用于在异步函数内部等待另一个异步操作完成。通常与asyncio库中的事件循环一起使用。
9. break：跳出当前循环。
10. class：定义一个类。
11. continue：跳过当前循环的剩余部分，进入下一次循环。
12. def：定义一个函数。
13. del：删除一个对象或变量。
14. elif：条件语句的一部分，用于在if语句中添加更多的条件。
15. else：条件语句的另一部分，用于在if语句中添加一个默认情况。
16. except：异常处理的一部分，用于捕获和处理异常。
17. finally：异常处理的一部分，无论是否发生异常都会执行。
18. for：循环关键字，用于遍历序列或迭代器中的元素。
19. from：导入模块或从模块中导入特定的函数或变量。
20. global：声明一个变量为全局变量，即该变量可以在函数外部访问和修改。
21. if：条件语句的关键字，用于根据条件执行不同的代码块。
22. import：导入模块或库，以便在代码中使用其函数和类。
23. in：成员关系测试运算符，用于检查一个元素是否存在于序列中。
24. is：身份运算符，用于比较两个对象是否引用相同的内存地址。这与使用“==”运算符检查值是否相等不同。
25. lambda：定义匿名函数的关键字。匿名函数是一种没有名称的简单函数，通常用于一次性的短小操作。
26. nonlocal：声明一个变量为非局部变量，即该变量可以在函数内部访问和修改，但只能在当前函数内部访问和修改。
27. not：逻辑运算符，用于将条件取反。
28. or：逻辑运算符，用于将两个条件组合在一起。如果两个条件中有一个为真，则返回True。
29. pass：空操作符，用于表示一个无操作的状态。
30. raise：引发一个异常。
31. return：从函数中返回一个值或对象。
32. try：异常处理的一部分，用于捕获和处理异常。
33. while：循环关键字，用于重复执行一段代码直到条件不再满足。
34. with：上下文管理关键字，用于确保代码块在执行完毕后正确地清理资源或执行其他操作。
35. yield：生成器关键字，用于从函数中返回一个生成器对象。

2.拆分

2.1 False None True

1. False：布尔值，表示“假”。在布尔运算中用作False值。
2. None：表示空值或无值。常用于表示变量没有指向任何对象。
3. True：布尔值，表示“真”。在布尔运算中用作True值。

代码如下（示例）：

def analyze_booleans():  

    # 定义一个布尔变量  
    False_valid = False  	
  
    # 判断并输出结果  
    if False_valid:  
        print("False_valid is True")  
    else:  
        print("False_valid is False")  
	
    # 定义一个可能为None的变量  
    None_value = None  
  
    # 检查变量是否为None  
    if None_value is None:  
        print("None_value is None")  
    else:  
        print("None_value is not None")  
		
    # 定义一个布尔变量  
    True_valid = True  	
  
    # 判断并输出结果  
    if True_valid:  
        print("True_valid is True")  
    else:  
        print("True_valid is False")  		
  
# 调用函数进行分析  
analyze_booleans()

1. True 和 False 在这里用作条件判断。在第一个条件中，如果 False_valid 为 True，则输出 “False_valid is True”，否则输出 “False_valid is False”。这里使用了 if-else 语句来根据布尔值进行判断。
2. None 在这里用于表示一个变量没有指向任何对象。在第二个条件中，我们检查 None_value 是否为 None。如果是，则输出 “None_value is None”，否则输出 “None_value is not None”。这里使用了 is 运算符来检查变量是否为 None。
3. 第三个条件同第一个条件，如果 True_valid 为 True，则输出 “True_valid is True”，否则输出 “True_valid is False”。

输出结果：

2.2 and not or

这3个关键字都是逻辑运算符，放在一起讲。

1. and：逻辑运算符，用于将两个条件组合在一起。如果两个条件都为真，则返回True。
2. not：逻辑运算符，用于将条件取反。
3. or：逻辑运算符，用于将两个条件组合在一起。如果两个条件中有一个为真，则返回True。

代码如下（示例）：

# 定义两个变量
x = 5
y = 3

# 使用 and 进行逻辑与判断
if x > 3 and y > 2:
    print("x大于3并且y大于2")
else:
    print("x不大于3或者y不大于2")

# 使用 or 进行逻辑或判断
if x > 3 or y > 5:
    print("x大于3或者y大于5")
else:
    print("x不大于3并且y不大于5")

# 使用 not 进行逻辑非判断
if not x > 5:
    print("x不大于5")
else:
    print("x大于5")

在这个例子中，我们定义了两个变量 x 和 y，然后分别使用 and、or 和 not 进行逻辑判断。具体作用如下：

and：当 and 连接两个条件时，只有当两个条件都为真时，整个表达式才为真。
or：当 or 连接两个条件时，只要有一个条件为真，整个表达式就为真。
not：not 用于对一个条件进行取反，如果条件为真，则取反后为假；如果条件为假，则取反后为真。

通过这个例子，我们可以清晰地看到这三个关键字在逻辑判断中的作用。

输出结果：

2.3 as from import

1. as：用于类型别名，通常在导入模块或使用函数时使用。
2. from：导入模块或从模块中导入特定的函数或变量。
3. import：导入模块或库，以便在代码中使用其函数和类。

代码如下（示例）：

import turtle as tu # 导入turtle 模块,并将其命名为 tu
form random import randint,uniform,choice # 从random库中导入randint、uniform、choice 函数

在上面的示例中，import 和 as 在这个例子中的作用是将 turtle 模块导入当前代码中，并将其起一个别名 tu，以便在后续的代码中使用这个别名来代替 turtle 模块的名称。from random import randint, uniform, choice 表示从 Python 标准库中的 random 模块中导入了 randint、uniform 和 choice 这三个函数，因此在后续的代码中，你可以直接使用这三个函数，而不需要输入 random.randint()、random.uniform() 或 random.choice()。

2.4 assert

assert：断言关键字，用于测试代码中的某个条件是否为真。如果条件为假，则会引发AssertionError异常。

代码如下（示例）：

def divide(x, y):
    assert y != 0, "除数不能为0"
    return x / y

print(divide(6, 2))  # 正常情况，输出3.0
print(divide(6, 0))  # 会触发 AssertionError，输出"除数不能为0"

在上面的代码中，assert y != 0, “除数不能为0” 表示断言 y != 0 必须为真，否则会触发 AssertionError 异常，并且异常的描述信息为 “除数不能为0”。在第二次调用 divide 函数时，由于除数为 0，触发了 AssertionError 异常。

输出结果：

2.5 async await

1. async：用于定义异步函数。异步函数允许在等待某些操作（如I/O操作）完成时执行其他代码。
2. await：用于在异步函数内部等待另一个异步操作完成。通常与asyncio库中的事件循环一起使用

代码如下（示例）：

import asyncio  
  
async def say_hello():  
    print("Hello, world!")  
    await asyncio.sleep(1)  
    print("One second later...")  
  
# 运行异步函数  
asyncio.run(say_hello())

这段代码定义了一个异步函数 say_hello，该函数首先打印 “Hello, world!”，然后使用 await asyncio.sleep(1) 来等待 1 秒，最后再打印 “One second later…”。在主程序中使用 asyncio.run(say_hello()) 来运行这个异步函数。

1. async def say_hello(): 中的 async 关键字用来定义这是一个异步函数。这使得函数内部可以包含 await 表达式，并且在函数外部调用时，需要通过异步事件循环来执行。
2. 在 say_hello 函数内部，await asyncio.sleep(1) 用于暂停当前的异步函数，等待 1 秒后再继续执行。这里的 await 关键字用于等待一个异步操作的完成，而不会阻塞整个事件循环。

输出结果：

2.6 break continue

1. break：跳出当前循环。
2. continue：跳过当前循环的剩余部分，进入下一次循环。
   代码如下（示例）：

continue、break主要用在for循环和while循环中，代码如下（示例）：

numbers = [1, 2, 3, 4, 5] # 第二种输出结果需更改为numbers = [5, 4, 3, 2, 1]

for num in numbers:
    if num == 3:
        continue  # 如果数字等于 3，则跳过本次循环，继续下一次循环
    if num == 5:
        break  # 如果数字等于 5，则跳出循环
    print(num)

print("Loop ends")

1. 当 num 的值为 3 时，continue 关键字会使程序跳过当前循环，直接进入下一次循环，因此数字 3 不会被打印出来。
2. 当 num 的值为 5 时，break 关键字会立即退出循环，整个循环结构终止执行，因此后面的数字也不会被打印出来。

因此，整个程序的功能是遍历列表 numbers 中的元素，并打印出每个数字，但在遇到数字 3 时跳过，遇到数字 5 时终止循环。最后输出 “Loop ends” 表示循环结束。

输出结果：

2.7 class def

1. class：定义一个类。
2. def：定义一个函数。

代码如下（示例）：

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14 * self.radius ** 2

circle1 = Circle(5)
area = circle1.calculate_area()

print("Area:", area)

这个程序的功能是定义一个 Circle 类，用于表示圆形，该类有一个属性 radius 表示圆的半径，并且有calculate_area() 用于计算圆的面积。

输出结果：

2.8 del

1. del：删除一个对象或变量。

代码如下（示例）：

# 定义一个列表  
my_list = [1, 2, 3, 4, 5]  
  
# 输出原始列表  
print("原始列表:", my_list)  
  
# 使用del关键字删除索引为2的元素（即数字3）  
del my_list[2]  
  
# 输出修改后的列表  
print("修改后的列表:", my_list)

输出结果：

2.9 if elif else

1. if：条件语句的关键字，用于根据条件执行不同的代码块。
2. elif：条件语句的一部分，用于在if语句中添加更多的条件。
3. else：条件语句的另一部分，用于在if语句中添加一个默认情况。

代码如下（示例）：

x = 10  
if x > 5:  
    print("x 大于 5")  
elif x == 5:  
    print("x 等于 5")  
else:  
    print("x 小于 5")

输出结果：

2.10 try except finally raise

1. try：用于尝试执行一段代码，如果出现异常，可以通过后续的代码进行捕获和处理。
2. except：用于捕获try代码块中抛出的异常。可以指定捕获特定类型的异常，也可以捕获所有类型的异常。
3. finally：无论try代码块中是否抛出异常，finally代码块中的代码都会被执行。这对于需要清理资源的场景非常有用。
4. raise：用于手动抛出一个异常。可以在except代码块中使用raise关键字重新抛出捕获到的异常，或者在需要的地方抛出新的异常。

代码如下（示例）：

try:  
    # 尝试执行一段代码  
    x = 10 / 2  
    y = x / 0  # 这将触发 ZeroDivisionError 异常  
except ZeroDivisionError:  
    # 捕获除零错误并打印错误信息  
    print("捕获到除零错误!")  
    raise  # 重新抛出捕获到的异常  
finally:  
    # 无论是否发生异常，都会执行这段代码  
    print("finally 代码块被执行")

首先，我们通过除法将10除以2，得到5。然后，我们尝试将5除以0，这将触发ZeroDivisionError异常。我们使用except关键字捕获这个异常，并打印出错误信息。在except代码块中，我们还使用raise关键字重新抛出捕获到的异常。最后，我们使用finally关键字确保无论是否发生异常，都会执行一段代码。

输出结果：

2.11 for in while

1. for：循环关键字，用于遍历序列或迭代器中的元素。
2. in：成员关系测试运算符，用于检查一个元素是否存在于序列中。
3. while：循环关键字，用于重复执行一段代码直到条件不再满足。

代码如下（示例）：

for i in range(5):  
    print(i)
	
i = 0  
while i < 5:  
    print(i)  
    i += 1

这段代码的作用就是依次打印出0到4这5个数字，每个数字占一行，打印两次。

输出结果：

2.12 global nonlocal

1. global：声明一个变量为全局变量，即该变量可以在函数外部访问和修改。
2. nonlocal：声明一个变量为非局部变量，即该变量可以在函数内部访问和修改，但只能在当前函数内部访问和修改。

代码如下（示例）：

# 定义全局变量
global_variable = "Hello"

# 定义函数
def outer():
    outer_variable = "World"

    # 定义内部函数
    def inner():
        nonlocal outer_variable
        outer_variable = "Python"
        print(f"inner: {outer_variable}")  # 输出 inner: Python

    # 调用内部函数
    inner()

# 调用外部函数
outer()

print(f"global: {global_variable}")  # 输出 global: Hello

输出结果：

2.13 is

is：身份运算符，用于比较两个对象是否引用相同的内存地址。这与使用“==”运算符检查值是否相等不同。

代码如下（示例）：

a = [1, 2, 3]  
b = a
print(a is b)  

a = [1, 2, 3]  
b = [1, 2, 3]
print(a is b)  

在这个例子中，第一个a和b都引用同一个列表对象，所以a is b返回True。
第二个a和b的内容相同，但它们是不同的对象，所以a is b返回False。
需要注意的是，is运算符比较的是对象的身份（即内存地址），而不是它们的内容。

输出结果：

2.14 lambda

lambda：定义匿名函数的关键字。匿名函数是一种没有名称的简单函数，通常用于一次性的短小操作。

代码如下（示例）：

# 使用 lambda 关键字定义匿名函数
add_numbers = lambda x, y: x + y

# 调用匿名函数
result = add_numbers(3, 5)

# 输出结果
print(result)  # 输出 8

当涉及到简单的操作或者函数表达式时，可以使用 Python 中的lambda来定义匿名函数。

输出结果：

2.15 pass

pass：空操作符，用于表示一个无操作的状态。

代码如下（示例）：

def my_function():  
    # 这里没有任何操作，只是一个空操作  
    pass  
  
# 调用函数  
my_function()

当我们调用这个函数时，实际上没有任何事情发生，因为pass关键字就是一个空操作符。

2.16 return

return：从函数中返回一个值或对象。

代码如下（示例）：

def add_numbers(a, b):  
    # 将两个数字相加，并返回结果  
    result = a + b  
    return result  
  
# 调用函数并打印结果  
result = add_numbers(5, 4)  
print(result)  # 输出: 9

输出结果：

2.17 with

with：上下文管理关键字，用于确保代码块在执行完毕后正确地清理资源或执行其他操作。

代码如下（示例）：

with open('text.txt', 'w') as f:
    f.write('Hello, World!')

这个程序的功能是打开一个名为 text.txt 的文件，将字符串 ‘Hello, World!’ 写入文件中，然后自动关闭文件句柄。

2.18 yield

yield：生成器关键字，用于从函数中返回一个生成器对象。

代码如下（示例）：

# 定义一个生成器函数
def simple_generator():
    yield 1
    yield 2
    yield 3

# 使用生成器
gen = simple_generator()

# 通过迭代获取生成器的值
print(next(gen))  # 输出 1
print(next(gen))  # 输出 2
print(next(gen))  # 输出 3

在上述示例中，我们首先定义了一个名为 simple_generator 的生成器函数。在函数体内，我们使用 yield 关键字分别产生了整数 1、2 和 3。当生成器函数被调用时，它并不会立即执行，而是返回一个生成器对象。
接着，我们将生成器对象赋值给变量 gen。通过调用 next() 函数，我们可以逐个获取生成器产生的值。每次调用 next() 函数，生成器函数会从上一次 yield 语句的位置继续执行，直到遇到下一个 yield 或者函数结束。
在示例中，分别调用了 next(gen) 三次，分别输出了生成器产生的值 1、2 和 3。

输出结果：

---

三、总结

今天，深入解析python的35个关键字的含义与用法。

感谢你的观看，谢谢！