—— 路漫漫其修远兮，吾将上下而求索。

前路漫漫，我用Python探索世界。Hello，大家好，今天笔者将给大家分享Python中39个关键字的详细解释，无论你是新手还是老司机，这都是必须掌握的关键知识，你可以将其当做你的快速查阅手册。

39个关键字概览：

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个。

Keywords

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 完成，而是可以在此期间处理其他任务。

Tips：异步编程是Python中一个高阶主题，涉及到很多复杂的知识，感兴趣的朋友可以阅读《流畅的Python（第2版）》中的第21章，里面有详细的讲解。同时，本书也是Python编程的“圣经”，亚马逊4.7星评，豆瓣评分9.4，是Python进阶书籍的不二选择。目前已更新到第2版，书中代码支持Python 3.10+。获得业内大咖的顶力推荐：

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)

31：return

在Python中，return 关键字用于返回函数结果。该关键字是使用频率最高的关键字之一，因为只要有点深度和实用性的程序都需要函数，而函数大多都需要返回值的，这样可以提升代码的复用性。

from datetime import date


def get_today_date() -> str:
    today: date = date.today()
    return today.strftime("%Y-%m-%d")

def noreturn_func():
    today: date = date.today()
    print(today)

    # 默认使用语句：return None

if __name__ == '__main__':
    print(get_today_date()) # 2024-10-10
    noreturn_func() # 2024-10-10

其实，每个函数都使用了 return 关键字，没有使用的函数在程序编译时，默认使用 return None。

32：try

在前面的例子中，我们其实就接触过 try 关键字。在Python中，该关键字用于提高代码的容错性，在该关键字的代码块中，我们可以运行一些危险代码（也就是可能会抛出异常的代码），这样在遇到相应异常的时候，程序可以正常执行，而不会直接终止。

person_info: dict[str, str | int] = {
    'name': 'Jackzhang',
    'gender': 'Male',
    'age': 28,
}

try:
    print(f"name: {person_info['name']}")
    print(f"gender: {person_info['gender']}")
    print(f"age: {person_info['age']}")
    print(f"loc city: {person_info['loc_city']}")
except KeyError as e:
    print(f'{e} is not a valid key!')

输出：

name: Jackzhang
gender: Male
age: 28
'loc_city' is not a valid key!

如果不使用 try...except 语句块，那么程序就会抛出异常并终止运行。

## 33：while

在Python中，除了 for 循环之外，还有一种循环结构，也就是通过 while 关键字定义的循环。不过在使用这种循环的时候一定要记得在循环体中声明退出条件，否则会陷入死循环，导致程序一直运行。

import time

is_count: bool = True
i: int = 1

print('Please start count:')
while is_count:
    if i == 5:  # 退出循环的条件
        is_count = False

    print(f'Count {i}')
    time.sleep(1)
    i += 1

print('Counting is over!')

34：with

虽然Python具有垃圾自动回收机制，但是有些特定场景中，我们需要手动关闭已打开的资源，避免资源浪费，降低程序或机器性能。比如，在打开文件或连接数据库后，通常我们需要手动关闭（使用 close() 函数）或数据库连接，否则在程序结束前文件或数据库连接将会一直处于打开状态。

with 关键字是一个上下文管理器，使用它可以省去我们手动关闭资源的操作，在执行完相应的操作后，程序会自动为我们关闭资源。这样，可以提升代码的简洁性和性能。

# 不使用 with 关键字
file = open('test.txt', 'r')
content: list[str] = file.readlines()
file.close()    # 手动关闭文件

# 使用 with 关键字
with open('test.txt', 'r') as file:
    content: list[str] = file.readlines()
    # 不需要手动关闭文件

35：yield

在Python中，yield 关键字用于创建生成器。生成器的好处就是它不会一次性将所有元素加载进内存中，而是逐一加载，这样有利于内存的高效利用。

from typing import Generator

def gen_numbers(limit: int) -> Generator:
    for i in range(limit):
        yield i

if __name__ == '__main__':
    numbers: Generator = gen_numbers(10)
    print(next(numbers))
    print(next(numbers))
    print(next(numbers))
    print(list(numbers))

输出：

0
1
2
[3, 4, 5, 6, 7, 8, 9]

通过输出可以看出，生成器中的元素是逐一加载进内存并取出（使用内置的 next() 函数），并且取出后生成器中对应的元素就会消失，类似于从堆栈中弹出元素。所以，在输出 2 之后，我们一次性输出剩余元素，是从 3 开始的。

由于生成器中的元素会耗尽，所以需要特别注意，如果最后一个元素已经取出，还继续取数据的话，会抛出异常 StopIteration：

from typing import Generator

def gen_numbers(limit: int) -> Generator:
    for i in range(limit):
        yield i

if __name__ == '__main__':
    numbers: Generator = gen_numbers(10)
    print(next(numbers))
    print(next(numbers))
    print(next(numbers))
    print(list(numbers))
    print(next(numbers))    # 抛出异常 StopIteration

Soft Keywords

36. 下划线（_）

在Python中，下划线可以看做是一个占位符，它表示在后续代码中我们不需要的标识符。比如，

# 在循环体中不使用迭代因子，所以用下划线代替
for _ in range(3):
    print('balabala')

# 多变量赋值，不需要的元素，可以全部放到“星号+下划线”表示的标识符中
val_list: list[int] = [1, 2, 3, 4, 5]
a, b, *_, c = val_list
print(a, b, c)  # 1, 2, 5

# 用下划线定义魔法函数，即双下划线方法（Dunder methods）
class Person:
    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

还有，在 match...case 语句（Python 3.10+）中，下划线可以用于表示剩余的所有情况。

weather: str = 'cloudy'

match weather:
    case 'rain':
        print('Bad day!')
    case 'sunny':
        print('Sunshine day!')
    case 'cloudy':
        print('Not bad day!')
    case _:
        print('Unknown weather!')
# Not bad day!

37-38. match 和 case

match 和 case 是Python 3.10版本新增的语句，它允许我们更加轻松地进行多条件判断和控制，类似于其他编程语言中的 switch...case 语句，但是更加灵活和强大。

weather: tuple[str, int] = 'rain', 6

match weather:
    case 'rain', serverity if serverity <= 5:
        print(f'Rain ({serverity})')
    case 'rain', serverity if serverity > 5:
        print(f'Very hard rain! ({serverity})')
    case 'cloudy', serverity:
        print('CloudCream, anyone? ({serverity})')
    case _:
        print('Unknown weather, damn you global warming!')
# Very hard rain! (6)

39. type

最后一个关键字，也就是Python 3.12版本才将其列为关键字之一的 type。这意味着，我们可以利用它来自定义数据类型，比如，

看这里 👀👀：在Python中，我们都知道不能将内置关键字（保留字）用作变量，否则会直接提示语法错误。但是，对于软关键字，我们是可以将其用作变量的，并且是合法不会报错的。看下面的示例。

最后的话

文章有点长，但是很实用。希望对你有所帮助，成为你的日常编程查阅小手册📓📓📓。Happy coding!

推荐阅读👇👇👇

Python必知必会：每个程序员都必须知道的22个Python单行代码！

Python必知必会：15个令人相见恨晚的Python字符串格式化技巧！

24个令人眼前一亮的Python技巧—提升你的代码水平和质量（二）

24个令人眼前一亮的Python技巧—提升你的代码水平和质量（一）

10个令人相见恨晚的Python高效编程技巧！

- END -

🌟 如果你喜欢这篇文章并且愿意支持我的话，你可以：🌟

• 👍👍👍 点赞文章
• ⤴️⤴️⤴️ 转发文章
• ⚛️⚛️⚛️ 点击在看
• 🧑‍🤝‍🧑🧑‍🤝‍🧑🧑‍🤝‍🧑 让文章被推荐给更多人，找到更多志同道合的伙伴
• 👏👏👏 欢迎给我留言

关注我，第一时间接收更多关于Python、数据分析和机器学习的深入分析和最新趋势。我们一起探索数据的力量，解锁AI的潜能。你的每一次互动都是对我的极大鼓励，也是我们共同成长的动力！

👇👇👇 关注并开启星标提醒，让知识与技能的火花不断在你的职业道路上燃烧吧！