30个Python关键字详解，你的编程查阅小手册，收藏！

大家好，今天给大家分享Python中30个关键字的详细解释，无论你是新手还是老司机，这都是必须掌握的关键知识，你可以将其当做你的快速查阅手册。

30个关键字概览：

from keyword import kwlist, softkwlist      def dispaly_keywords() -> None:       print('Keywords:')       for i, kw in enumerate(kwlist, start=1):           print(f'{i:2}: {kw}')          print('Soft keywords:')       for i, skw in enumerate(softkwlist, start=1):           print(f'{i:2}: {skw}')      def main() -> None:       dispaly_keywords()      if __name__ == '__main__':       main()   

输出：

Keywords:    1: False    2: None    3: True    4: and    5: as    6: assert    7: async    8: await    9: break   10: class   11: continue   12: def   13: del   14: elif   15: else   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   29: pass   30: raise   31: return   32: try   33: while   34: with   35: yield   Soft keywords:    1: _    2: case    3: match    4: type   

PS：在Python 3.12版本之前，type 并没有被视为软关键字之一。因此，如果你的Python版本低于3.12，那么关键字数量应该是38个。

1：False

False 关键字是在Python中我们经常用到的2个布尔值之一（另一个是True），常常用在条件判断语句中。并且，在很多情况下，它等价于整数0。

is_adult: bool = False      print(is_adult)         # False   print(int(is_adult))    # 0   

2：None

None 表示如果某个变量被指定为 None 的话，则它的值缺失（即不存在）。我常常将其用在变量初始化中，比如：

names: list[str] = ['Jackzhang', 'Alex', 'Lora']   target_name: str | None = None   for name in names:       if 'anna' in name.lower():           target_name = name   print(target_name)     # None   

再比如，你试图从数据库中选择某个用户，该用户并不存在，则Python要么抛出异常，要么返回 None。

class User:       ...      selected_user: User | None = None   print(selected_user)    # None   

3：True

与 False 一样，True 是2个布尔值之一，它是整数值1的另一种常量表示。在所有条件语句中，只有条件为 True，才会执行其下的相应语句。

is_adult: bool = True      print(is_adult)         # True   print(int(is_adult))    # 1   

由于 True 是整数1的另一种常量表示，所以你甚至可以用它来做四则运算：

print(True + True)  # 2   print(True - True)  # 0   print(True * True)  # 1   print(True // True)  # 1   

PS：在Python中，整除用双斜杠 // 表示，单斜杠 / 的结果是浮点数。

4：and

and 关键字常用于多条件判断中，and 连接的两个表达式同时为 True 时，整个条件方可成立。

learning_duration: float = 25.3   score: int = 95      if learning_duration > 20 and score > 90:       print('The course is passed!')   

5：as

as 与SQL语言一样，用于起别名，可以将复杂且长度较长的标识符用一个简洁的别名代替，提升代码的简洁性。有以下两种使用场景：

• 导入第三方库时

import math as m   import pandas as pd      print(m.sin(20))   df: pd.DataFrame = pd.read_excel('path/to/file.xlsx')   print(df.head())   

• 在 with 语句中

with open('test.txt', 'r') as file:       content = file.readlines()       print(content)   

6：assert

assert 关键字用于断言某个条件是否为真。如果条件为真，则继续正常执行，如果条件为假，则程序会抛出一个 AssertError 异常，并且你可以自定义异常提示信息。常常用在调试阶段。

基本用法

name = 123   assert isinstance(name, str), 'name must be str.'   

这里，我们判断 name 的数据类型，如果不是字符串类型的话（即条件为假），则抛出一个 AssertError 异常。

多个断言你可以在一个代码块中使用多个断言：

x: int = 10   y: int = -20   assert x > 0, 'x must be positive'   assert y > 0, 'y must be positive'   assert x < y, 'x must be less than y'   

注意，虽然可以使用多个断言，但是当遇到第一个不满足的条件并抛出 AssertError 异常后，其后的断言将不再执行。因为程序已经终止。

7-8：async 和 await

在Python中，async 和 await 关键字是实现异步编程的核心工具，所以我们放在一起说。它们让Python具有并发处理多个任务的能力，尤其是那些涉及大量I/O操作的任务，例如网络请求、数据库操作等。

• async 关键字

• 用来定义一个异步函数，即一个可以暂停执行、并允许其他任务执行的函数。这样的函数我们称为协程（coroutine）。协程与普通函数的区别在于，协程可以在执行过程中被挂起，等待其他协程执行完毕后再恢复。

• 异步函数通过 async def 定义，并且异步函数执行时会返回一个协程对象，而不是直接执行函数体。

• await 关键字

• await 用于暂停一个异步函数的执行，直到等待的协程执行完成。

• 只有在异步函数中才能使用 await，并且 await 后必须跟一个可等待对象，例如协程、任务或 asyncio 的一些I/O操作。

• 异步编程的工作原理

异步编程的核心在于并发地执行多个任务，而不必等待每个任务顺序执行。比如，你可以同时发起多个网络请求，程序不必等第一个请求完成后再发送下一个，而是可以在等待过程中处理其他任务。

通过 async 和 await，Python可以利用事件循环（event loop）来调度这些异步任务，当某个任务暂停等待（例如等待网络响应）时，事件循环可以调度其他任务继续执行，从而提升程序的效率。

• 使用场景

• I/O密集型操作：处理网络请求、文件读写、数据库查询等需要等待的操作，异步编程可以并发执行多个任务，提升程序性能。

• 事件驱动编程：例如网络服务器、用户界面响应等，异步编程可以使系统在处理一个时间的同时，也能继续处理其他事件。

• 基本用法

import asyncio      # 定义一个异步函数   async def my_async_func():       print('执行异步任务...')       await asyncio.sleep(2)  # 模拟耗时操作       print('任务执行完成')      # 在异步环境中运行   asyncio.run(my_async_func())   

• 并发执行多个任务

通过 asyncio.create_task() 函数，我们可以并发地执行多个任务，而不需要一个个地顺序执行。

import asyncio      # 定义异步函数   async def task1():       print('任务1开始')       await asyncio.sleep(2)       print('任务1结束')      async def task2():       print('任务2开始')       await asyncio.sleep(1)       print('任务2结束')      async def main():       # 创建异步任务       taks1 = asyncio.create_task(task1())       taks2 = asyncio.create_task(task2())          # 并发执行       await taks1       await taks2      asyncio.run(main())   

从输出中我们可以看出，任务 taks1 和 taks2 是并发执行的。虽然 taks1 需要2秒执行时间，但 taks2 在1秒后就已经完成了。这样，程序不会浪费时间等待 taks1 完成，而是可以在此期间处理其他任务。

9：break

break 关键字用在循环中，用于终止整个循环。

for i in range(1, 10):       if i == 6:           break       else:           print(i)   

当要搜索的范围比较大时，使用 break 关键字可以显著提升程序性能，因为只要找到目标后就会直接退出循环，不必再继续搜索。

10：class

class 关键字用于定义类，它是面向对象编程的核心概念之一。比如，我们定义一个 Person 类：

class Person(object):       def __init__(self, name: str, age: int) -> None:           self.name = name           self.age = age          def describe(self):           print(f'{self.name} is {self.age} years old!')      if __name__ == '__main__':       person = Person(name='John', age=25)       person.describe()   # John is 25 years old!   

11：continue

continue 关键字也是用在循环中，与 break 关键字的区别在于，continue 用于退出本次循环，忽略其后的代码，转而执行下一次循环。

names: list[str] = ['Jack', 'Tom', 'James']   for name in names:       if name == 'Tom':           print(f'{name} is not who we want to find!')           continue       print(f'Hello {name}!')   

12：def

def 是 definition 或 define 的缩写，熟悉Python的伙伴应该都知道，这个关键字用于定义函数，可以提高代码的复用性，避免重复造轮子。

def my_function():       print('This is a simple function')      if __name__ == '__main__':       my_function()   # This is a simple function   

13：del

顾名思义，del 也就是 delete 的缩写，它用于删除对象。比如，删除变量后再引用，会得到 NameError 错误：

name: str = 'Jackzhang'   print(f'my name is {name}!')   # my name is Jackzhang!      del name   print(name) # NameError: name 'name' is not defined   

另外，在利用pandas处理表格数据时，我们可以通过 del 关键字删除不需要的列：

import pandas as pd   from datetime import datetime      data = {'name': ['Alice', 'Bob', 'Charlie'],           'birthday': ['1990-05-01', '1985-07-12', '2000-10-30']}   data_df: pd.DataFrame = pd.DataFrame(data=data)   print(data_df)      data_df['birthday'] = pd.to_datetime(data_df['birthday'])   today: datetime = datetime.today()   data_df['age'] = data_df['birthday'].apply(       lambda x: today.year - x.year - ((today.month, today.day) < (x.month, x.day)))   del data_df['birthday']   print(data_df)   

这里，我们利用 birthday 列计算年龄，然后删除 birthday 列。

PS：你知道计算年龄时为什么要减去 ((today.month, today.day) < (x.month, x.day)) 吗？

14：elif

在Python中，elif 用于条件分支语句中的多条件判断。例如，下面的示例中，我们根据年龄判断所属阶段：

age: int = 20      if 0 < age <= 1:       print('Infant')         # 婴儿   elif age <= 3:       print('Toddler')        # 幼儿   elif age <= 5:       print('Preschooler')    # 学龄前儿童   elif age <= 12:       print('Child')          # 小学生   elif age <= 19:       print('Teenager')       # 青少年   elif age <= 35:       print('Young Adult')    # 青年   elif age <= 64:       print('Adult')          # 成年人   # Adult   

15：else

else 关键字同样用在条件分支语句中，用于表示除了前面条件之外的其他所有情况。比如，在上面的示例中，加上一个 else 语句，就可以表示除婴儿、幼儿等之外的年龄阶段，即“老年人”。

age: int = 80      if 0 < age <= 1:       print('Infant')         # 婴儿   elif age <= 3:       print('Toddler')        # 幼儿   elif age <= 5:       print('Preschooler')    # 学龄前儿童   elif age <= 12:       print('Child')          # 小学生   elif age <= 19:       print('Teenager')       # 青少年   elif age <= 35:       print('Young Adult')    # 青年   elif age <= 64:       print('Adult')          # 成年人   else:       print('Elderly Person') # 老年人   # Elderly Person   

16-17：except 和 finally

Python中，对异常的捕获和处理的完整语句是 try...except...finally，所以我们将 except 和 finally 放在一起说明。其中，正常的逻辑代码放在 try 子句中，程序发生异常时的处理代码放在 except 子句中，无论是否发生异常都要执行的代码放在 finally 子句中。

例如，考虑一个连接数据库操作的示例：

from sqlalchemy import create_engine   from sqlalchemy.orm import sessionmaker      conn_str: str = rf'mssql+pyodbc://username:password@server/db_name?driver=driver_name&port=port_no'   try:       engine = create_engine(conn_str)       session_factory = sessionmaker(bind=engine)       session = session_factory()       # orm 和 data 分别是用户定义的对象关系映射对象和要插入的数据字典       session.bulk_insert_mappings(orm, data)   except Exception as e:       session.rollback()       print(f'数据库操作错误：{e}')   finally:       session.close()   

这里，在 try 子句中，我们执行正常的数据库连接和数据插入操作，在 except 子句中，如果捕获到异常，则进行事务回滚操作，并输出错误信息；而在 finally 子句中，则执行关闭会话的操作（用于释放资源）。

18：for

我们都知道，for 关键字用在循环中，它是python中重要的循环语句之一，用于迭代对象。

from typing import Any      elements: list[Any] = [1, True, 'Jack', 888]   for element in elements:       print(element)   

19：from

from 关键字用在程序顶部的导入语句中，当我们需要从某个包中导入具体的对象时，就需要用到该关键字。比如，

from datetime import datetime      print(f'Today is {datetime.today()}')   # Today is 2024-10-01 00:21:37.433556   

20：global

global 关键字用于定义全局变量，局部的修改会影响全局。

name: str = 'Jack'      def change_name() -> None:       global name          name = 'James'      change_name()   print(name) # James   

这里，最开始 name 并不是全局变量，在 change_name 方法中我们使用 global 关键字将其声明为全局变量，然后再修改其值。最后输出的修改后的值。

21：if

if 是条件语句的关键字，日常编程任务中最常用的语句之一。

code: int = int(input("Enter a number: "))      if code % 2 == 0:       print('Congratulations!')   

22：import

几乎在所有的python脚本中，都会用到 import 关键字。因为Python的强大之处就是它有非常强大且丰富的第三方库生态，借助第三方库，我们可以实现很多复杂的逻辑功能。而除了Python内置的库之外，其他第三方库都需要通过 import 关键字导入。比如，

import os      file_dir: str = r'path/to/file_dir'   file_names: list[str] = os.listdir(file_dir)   for file_name in file_names:       print(file_name)   

这里，我们通过 os 模块获取指定目录下所有文件的文件名。这在日常工作中也经常用到，比如，批量读取目录下所有的Excel文件。

23：in

在Python中，in 关键字一般用在两个地方：

• 用在迭代语句中（for循环）：

names: list[str] = ['Jack', 'James', 'Alice']      for name in names:       print(name)   

• 用于成员关系判断：

names: list[str] = ['Jack', 'James', 'Alice']      if 'Jack' in names:       print('Hi, Jack, here you are!')   

24：is

is 关键字常常用于比较两个变量是否引用同一个对象。

class Person(object):       def __init__(self, name: str, age: int) -> None:           self.name = name           self.age = age      if __name__ == '__main__':       person1: Person = Person('John', 25)       person2: Person = person1       print(person1 is person2)          person3: Person = Person('Jack', 26)       print(person1 is person3)          print(f'id(person1): {id(person1)}')       print(f'id(person2): {id(person2)}')       print(f'id(person3): {id(person3)}')   

is 操作符比较的是两个对象的内存地址，从输出中我们可以看出 person1 和 person2 的内存地址都相同，所以 person1 is person2 的结果为 True。同样地，由于 person3 和 person1 的内存地址不同，所以 person1 is person3 的结果为 False。

25：lambda

lambda 关键字用于定义匿名函数:

from typing import Callable, Any      def output_result(func: Callable, items: list[Any]) -> None:       for item in items:           print(func(item))      if __name__ == '__main__':       output_result(func=lambda x: x ** 2, items=[1, 2, 3, 4, 5])   # output:   # 1   # 4   # 9   # 16   # 25   

26：nonlocal

在Python中，nonlocal 用于将一个变量声明为非局部作用域变量，该变量属于嵌套函数外层的一个非全局作用域，而不是当前函数的局部变量或全局变量。看下面这个例子：

def outer_func() -> None:       hero: str = '赵云'          def inner_func() -> None:           nonlocal hero           hero = '李信'           print(f'内部英雄：{hero}')   # 输出：李信          inner_func()       print(f'外部英雄：{hero}')   # 输出：李信      if __name__ == '__main__':       outer_func()   

这里，在 inner_func() 中，如果注释掉 nonlocal hero，那么 hero 就只是当前函数的一个局部变量，它和外部函数的 hero 其实是两个同名但却不是同一个变量，外部函数将会输出“赵云”。

27：not

not 关键字与生活中的意思一样，表示否定的意思。在Python中，它是一个逻辑词——“非”，你可以理解为唱反调的意思，比如条件为 True，加上 not 关键字后即为 False；同样地，如果条件为 False，加上 not 关键字后即为 True。

selected_hero: str | None = None      if selected_hero is not None:       print(f'You have selected {selected_hero}')   else:       print('No hero selected...')      names: list[str] = ['Jack', 'Alice', 'John', 'Ben']      if 'John' not in names:       print('John not found')   else:       print('John found')   

28：or

or 关键字是逻辑词——“或”的意思，表示任意满足其中一个条件即可。

a, b, c = 10, 5, 40      if a > c or b < a:       print('One of conditions were satisfied.')   

29：pass

在Python中，pass 关键字表示程序遇到它会跳过，什么也不干。有时候你可以将它当作一个占位符（当然，用三点表示的省略号也是合法的）。

name: str = 'Jackzhang'      if name.startswith('Jack'):       print('Hello Jack')   else:       pass      def get_name(names: list[str]) -> str:       # ...       pass   

30：raise

在写Python程序的过程中，经常会遇到各种各样的异常导致程序终止，比如，KeyError、ValueError 等，这些都是程序自动抛出的异常。raise 关键字可以允许我们手动抛出异常。看下面这个例子：

val: int = 5.5      if not isinstance(val, int):       raise Exception('val must be an integer!')   else:       print(val)   

关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

👉Python学习路线汇总👈

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉Python必备开发工具👈

👉Python学习视频合集👈

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

👉实战案例👈

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

👉Python副业兼职路线&方法👈

学好 Python 不论是就业还是做副业赚钱都不错，但要学会兼职接单还是要有一个学习规划。

👉 这份完整版的Python全套学习资料已经上传，朋友们如果需要可以扫描下方二维码免费领取