Python 中的关键字列表

提示

1. Python 关键字概述：Python 中的关键字是保留字，不能用作变量名、函数名或其他标识符。
2. 关键字列表：Python 包含多个关键字，如 False、None、True、and、as、assert、async、await、break、class、continue 等，每个关键字有特定的用途和语义。
3. 关键字的用法示例：关键字如 if, else, elif 用于条件判断；for 和 while 用于循环；try, except, finally 用于异常处理；import 和 from 用于模块导入；class 用于定义类；def 用于定义函数。

Python中的关键字是保留字，我们不能将关键字用作变量名、函数名或任何其他标识符。

以下是Python编程中所有关键字的列表

Python 编程语言中的关键字

|  |  |  Python Keywords List|  |   | | --- | --- | --- || False| await| else| import| pass | | None| break| except| in| raise | | True| class| finally| is| return | | and| continue| for| lambda| try | | as| def| from| nonlocal| while | | assert| del| global| not| with | | async| elif| if| or| yield |

以上关键字在不同版本的Python中可能会有所改变。可能会添加一些新的关键字或删除一些现有的关键字。您可以通过在提示符中输入以下内容，始终获取当前版本中的关键字列表。

>>> import keyword
>>> print(keyword.kwlist)
['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']

Python中关键字的描述及示例

True, False

True 和 False 是Python中的真值。它们是比较操作或逻辑（布尔）操作的结果。例如：

>>> 1 == 1
True
>>> 5 > 3
True
>>> True or False
True
>>> 10 <= 1
False
>>> 3 > 7
False
>>> True and False
False

这里我们可以看到，前三个语句为真，因此解释器返回 True，剩下的三个语句为假，因此返回 False。Python中的 True 和 False 与 1 和 0 是相同的。下面的示例可以证明这一点：

>>> True == 1
True
>>> False == 0
True
>>> True + True
2

None

None 是Python中表示值缺失或空值的特殊常量。

它是其自身数据类型 NoneType 的一个对象。我们不能创建多个 None 对象，但可以将其赋值给变量。这些变量将彼此相等。

必须特别注意 None 并不意味着 False、0 或任何空列表、字典、字符串等。例如：

>>> None == 0
False
>>> None == []
False
>>> None == False
False
>>> x = None
>>> y = None
>>> x == y
True

没有返回任何内容的空函数将自动返回一个 None 对象。函数中程序流程未遇到 return 语句时，也会返回 None。例如：

def a_void_function():
    a = 1
    b = 2
    c = a + b

x = a_void_function()
print(x)

输出

None

这个程序有一个函数，尽管它在内部执行了一些操作，但不返回任何值。因此，当我们打印 x 时，我们得到的是自动（隐式地）返回的 None。同样，这里还有另一个例子：

def improper_return_function(a):
    if (a % 2) == 0:
        return True

x = improper_return_function(3)
print(x)

输出

None

尽管这个函数有一个 return 语句，但它并不是在每种情况下都会达到。该函数只有在输入是偶数时才会返回 True。

如果我们给函数一个奇数，就会隐式地返回 None。

and, or, not

and、or、not 是 Python 中的逻辑运算符。and 运算符仅当两个操作数均为 True 时才会返回 True。and 的真值表如下所示：

and 运算的真值表

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

or 运算符在任一操作数为 True 时将返回 True。or 的真值表如下所示：

or 运算的真值表

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

not 运算符用于反转真值。not 的真值表如下所示：

not 运算的真值表

A	not A
True	False
False	True

以下是它们使用的一些例子：

>>> True and False
False
>>> True or False
True
>>> not False
True

as

as 用于在导入模块时创建别名。这意味着在导入模块时为其指定一个不同的名称（用户定义的）。

例如，Python 有一个标准模块叫做 math。假设我们想使用别名来计算余弦 pi 值。我们可以如下使用 as 进行操作：

>>> import math as myAlias
>>> myAlias.cos(myAlias.pi)
-1.0

这里我们导入了 math 模块，并将其命名为 myAlias。现在我们可以使用这个名称来引用 math 模块。使用这个名称，我们计算了 cos(pi) 并得到 -1.0 作为答案。

assert

assert 用于调试目的。

在编程时，有时我们希望了解内部状态或检查我们的假设是否正确。assert 帮助我们做到这一点，并更方便地发现错误。assert 后跟一个条件。

如果条件为真，什么也不会发生。但如果条件为假，将引发 AssertionError。例如：

>>> a = 4
>>> assert a < 5
>>> assert a > 5
Traceback (most recent call last):
    File "<string>", line 301, in runcode
    File "<interactive input>", line 1, in <module>
AssertionError

为了更好地理解，我们还可以提供一个信息，与 AssertionError 一起打印。

>>> a = 4
>>> assert a > 5, "The value of a is too small"
Traceback (most recent call last):
    File "<string>", line 301, in runcode
    File "<interactive input>", line 1, in <module>
AssertionError: The value of a is too small

在这一点上，我们可以注意到，

assert condition, message

等同于，

if not condition:
    raise AssertionError(message)

async, await

async 和 await 关键字由 Python 的 asyncio 库提供。它们用于编写 Python 中的并发代码。例如，

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('world')

运行程序时，我们使用

asyncio.run(main())

在上面的程序中，async 关键字指定该函数将异步执行。

这里，首先打印 "Hello"。await 关键字使程序等待 1 秒。然后打印 "world"。

break, continue

break 和 continue 在 for 循环和 while 循环中使用，

用于改变它们的正常行为。

break 将结束它所在的最小循环，并且控制流转到循环下方的立即语句。continue 导致结束循环的当前迭代，但不是整个循环。

以下两个示例可以说明这一点：

for i in range(1, 11):
    if i == 5:
        break
    print(i)

输出

1
2
3
4

这里，for 循环打算打印从 1 到 10 的数字。但当 i 等于 5 时满足了 if 条件，并且我们从循环中跳出。因此，只打印了 1 到 4 的范围。

for i in range(1, 11):
    if i == 5:
        continue
    print(i)

输出

1
2
3
4
6
7
8
9
10

这里我们对同一个程序使用了 continue。因此，当条件满足时，那次迭代被跳过。但我们并没有退出循环。因此，除了 5 之外的所有值都被打印出来了。

了解更多关于 Python break 和 continue 语句。### class

class 用于在 Python 中定义新的用户定义类。

类是一组相关的属性和方法的集合，试图代表现实世界的情况。这种在类中将数据和函数放在一起的思想是面向对象编程（OOP）概念的核心。

类可以在程序的任何地方定义。但是，最佳实践是在一个模块中定义一个类。以下是一个示例用法：

class ExampleClass:
    def function1(parameters):
 …
    def function2(parameters):
 …

了解更多关于 Python 对象和类。

def

def 用于定义用户定义的函数。

函数是一组相关语句的块，它们一起执行某些特定任务。它帮助我们将代码组织成可管理的块，并且也可以用来做一些重复性的任务。

def 的用法如下所示：

def function_name(parameters):
 …

了解更多关于 Python 函数。

del

del 用于删除对对象的引用。在 Python 中，一切都是对象。我们可以使用 del 删除变量引用

>>> a = b = 5
>>> del a
>>> a
Traceback (most recent call last):
    File "<string>", line 301, in runcode
    File "<interactive input>", line 1, in <module>
NameError: name 'a' is not defined
>>> b
5

在这里我们可以看到，变量 a 的引用被删除了。所以，它不再被定义。但是 b 仍然存在。

del 也用于从列表或字典中删除项：

>>> a = ['x','y','z']
>>> del a[1]
>>> a
['x', 'z']

if, else, elif

if, else, elif 用于条件分支或决策。

当我们想要测试某个条件并且只有在条件为真时才执行一个块时，我们使用 if 和 elif。elif 是 else if 的缩写。else 是当条件为假时执行的块。以下例子将使这一点更加清晰：

def if_example(a):
    if a == 1:
    print('One')
    elif a == 2:
    print('Two')
    else:
    print('Something else')

if_example(2)
if_example(4)
if_example(1)

输出

Two
Something else
One

在这里，函数检查输入的数字，并且如果它是 1 或 2 时打印结果。任何其他的输入都将导致代码的 else 部分执行。

了解更多关于 Python if 和 if...else 语句。

except, raise, try

except, raise, try 与 Python 中的异常一起使用。

异常基本上是错误，表明在执行我们的程序时出了问题。IOError、ValueError、ZeroDivisionError、ImportError、NameError、TypeError 等是 Python 中的一些异常示例。try...except 块用于在 Python 中捕获异常。

我们可以使用 raise 关键字显式地引发异常。以下是一个例子：

def reciprocal(num):
    try:
    r = 1/num
    except:
    print('Exception caught')
    return
    return r

print(reciprocal(10))
print(reciprocal(0))

输出

0.1
Exception caught
None

在这里，函数 reciprocal() 返回输入数字的倒数。

当我们输入 10 时，我们得到了正常的输出 0.1。但当我们输入 0 时，自动引发了 ZeroDivisionError。

这被我们的 try…except 块捕获了，我们返回了 None。我们也可以通过检查输入并在其他地方处理它来显式地引发 ZeroDivisionError，

如下所示：

if num == 0:
    raise ZeroDivisionError('cannot divide')

finally

finally 用于 try…except 代码块，用于关闭资源或文件流。

使用 finally 可以确保即使出现未处理的异常，其内部的代码块也会被执行。例如：

try:
    Try-block
except exception1:
    Exception1-block
except exception2:
    Exception2-block
else:
    Else-block
finally:
    Finally-block

在这里，如果 Try-block 中出现异常，它会在 except 或 else 块中得到处理。但无论执行流程如何，我们都可以确信，即使出现错误，Finally-block 也会被执行。这在清理资源时非常有用。

了解更多关于 Python 编程中的异常处理。

for

for 用于循环。通常当我们知道想要循环的次数时，我们会使用 for。

在 Python 中，我们可以将其与任何类型的序列（如列表或字符串）一起使用。这里有一个例子，展示了如何使用 for 遍历姓名列表：

names = ['John', 'Monica', 'Steven', 'Robin']
for i in names:
    print('Hello ' + i)

输出

Hello John
Hello Monica
Hello Steven
Hello Robin

了解更多关于 Python for 循环。

from, import

import 关键字用于将模块导入当前命名空间。from…import 用于将特定的属性或函数导入当前命名空间。例如：

import math

将导入 math 模块。现在我们可以使用其中的 cos() 函数，如 math.cos()。但如果我们只想导入 cos() 函数，可以使用 from 这样做：

from math import cos

现在我们可以简单地使用 cos() 函数，无需编写 math.cos()。

了解更多关于 Python 模块和 import 语句。

global

global 用于声明函数内的变量是全局的（函数外的）。

如果我们需要读取全局变量的值，不必将其定义为 global。这是默认理解的。

如果我们需要在函数内修改全局变量的值，则必须使用 global 声明它。否则，会创建一个具有该名称的局部变量。

以下示例将帮助我们澄清这一点。

globvar = 10
def read1():
    print(globvar)
def write1():
    global globvar
    globvar = 5
def write2():
    globvar = 15

read1()
write1()
read1()
write2()
read1()

输出

10
5
5

这里，read1() 函数只是读取 globvar 的值。因此，我们不需要将其声明为 global。但 write1() 函数正在修改值，所以我们需要将变量声明为 global。

我们可以在输出中看到，修改确实发生了（10 变成了 5）。write2() 也试图修改这个值。但我们没有将其声明为 global。

因此，创建了一个新的局部变量 globvar，它在这个函数之外不可见。尽管我们将这个局部变量修改为了 15，全局变量仍然未改变。这在我们的输出中清晰可见。

in

in 用于测试序列（列表、元组、字符串等）是否包含某个值。如果值存在，它返回 True，否则返回 False。例如：

>>> a = [1, 2, 3, 4, 5]
>>> 5 in a
True
>>> 10 in a
False

in 的第二个用途是在 for 循环中遍历一个序列。

for i in 'hello

':
    print(i)

输出

h
e
l
l
o

is

is 在 Python 中用于测试对象身份。虽然 == 运算符用于测试两个变量是否相等，但 is 用于测试两个变量是否引用同一个对象。

如果对象相同，它返回 True，否则返回 False。

>>> True is True
True
>>> False is False
True
>>> None is None
True

我们知道在 Python 中只有一个实例 True、False 和 None，因此它们是相同的。

>>> [] == []
True
>>> [] is []
False
>>> {} == {}
True
>>> {} is {}
False

一个空列表或字典等于另一个空的。但它们不是相同的对象，因为它们在内存中位于不同位置。这是因为列表和字典是可变的（值可以被改变）。

>>> '' == ''
True
>>> '' is ''
True
>>> () == ()
True
>>> () is ()
True

与列表和字典不同，字符串和元组是不可变的（一旦定义，值就不能更改）。因此，两个相等的字符串或元组也是相同的。它们引用同一个内存位置。

lambda

lambda 用于创建匿名函数（没有名称的函数）。它是一个内联函数，不包含 return 语句。它包括一个表达式，该表达式被评估并返回。例如：

a = lambda x: x*2
for i in range(1, 6):
    print(a(i))

输出

2
4
6
8
10

在这里，我们使用 lambda 语句创建了一个内联函数，用于加倍值。我们用它来加倍包含 1 到 5 的列表中的值。

了解更多关于 Python lambda 函数。

nonlocal

nonlocal 关键字的使用与 global 关键字非常相似。nonlocal 用于声明嵌套函数（函数内的函数）中的变量不是局部的，意味着它位于外部封闭函数中。如果我们需要在嵌套函数内修改非局部变量的值，那么我们必须用 nonlocal 声明它。否则，在嵌套函数内部将创建一个同名的局部变量。以下示例将帮助我们澄清这一点。

def outer_function():
    a = 5
    def inner_function():
    nonlocal a
    a = 10
    print("内部函数: ",a)
    inner_function()
    print("外部函数: ",a)

outer_function()

输出

内部函数: 10
外部函数: 10

在这里，inner_function() 嵌套在 outer_function() 中。

变量 a 在 outer_function() 中。所以，如果我们想在 inner_function() 中修改它，我们必须将其声明为 nonlocal。注意 a 不是全局变量。

因此，我们从输出中看到，变量在嵌套的 inner_function() 中成功修改了。不使用 nonlocal 关键字的结果如下：

def outer_function():
    a = 5
    def inner_function():
    a = 10
    print("内部函数: ",a)
    inner_function()
    print("外部函数: ",a)

outer_function()

输出

内部函数: 10
外部函数: 5

在这里，我们没有声明嵌套函数内的变量 a 是 nonlocal 的。因此，创建了一个同名的新局部变量，但非局部变量 a 没有被修改，正如我们在输出中所见。

pass

pass 在 Python 中是一个空语句。执行它时什么也不会发生。它被用作占位符。

假设我们有一个尚未实现的函数，但我们希望将来实现它。仅在程序中间写入，

def function(args):

将会导致 IndentationError。相反，我们可以用 pass 语句构造一个空白体。

def function(args):
    pass

在一个空的 class 中也可以做同样的事情。

class example:
    pass

return

return 语句用于退出函数并返回一个值。

如果我们不显式返回一个值，将自动返回 None。以下示例验证了这一点。

def func_return():
    a = 10
    return a

def no_return():
    a = 10

print(func_return())
print(no_return())

输出

10
None

while

while 用于 Python 中的循环。

只要 while 循环的条件评估为 False 或遇到 break 语句，while 循环内的语句就会继续执行。以下程序说明了这一点。

i = 5
while(i):
    print(i)
    i = i – 1

输出

5
4
3
2
1

注意 0 等于 False。

了解更多关于 Python while 循环。

with

with 语句用于在上下文管理器定义的方法内包装代码块的执行。

上下文管理器是实现了 __enter__ 和 __exit__ 方法的类。使用 with 语句可以确保在嵌套块的末尾调用 __exit__ 方法。这个概念类似于使用 try…finally 块。这里有一个例子。

with open('example.txt', 'w') as my_file:
    my_file.write('Hello world!')

这个例子将文本 Hello world! 写入文件 example.txt。文件

对象在其中定义了 __enter__ 和 __exit__ 方法，因此它们充当自己的上下文管理器。

首先调用 __enter__ 方法，然后执行 with 语句内的代码，最后调用 __exit__ 方法。即使出现错误，也会调用 __exit__ 方法。它基本上关闭了文件流。

yield

yield 在函数中像 return 语句一样使用。但是 yield 返回一个生成器。

生成器是一次生成一个项目的迭代器。一个大的值列表会占用大量内存。在这种情况下，生成器很有用，因为它一次只生成一个值，而不是在内存中存储所有值。例如，

>>> g = (2**x for x in range(100))

将创建一个生成器 g，它生成 2 的幂，直到 2 的 99 次幂。我们可以使用 next() 函数生成数字，如下所示。

>>> next(g)
1
>>> next(g)
2
>>> next(g)
4
>>> next(g)
8
>>> next(g)
16

依此类推……这种类型的生成器是由函数中的 yield 语句返回的。这里是一个例子。

def generator():
    for i in range(6):
    yield i*i

g = generator()
for i in g:
    print(i)

输出

0
1
4
9
16
25

在这里，函数 generator() 返回一个生成器，生成从 0 到 5 的数字的平方。这在 for 循环中打印出来。