Python 关键字列表

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

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

上述关键字可能会在不同版本的 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 中的布尔值。它们是 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

不返回任何值的 void 函数将自动返回一个 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 中的逻辑运算符。仅当两个操作数都为 True 时，and 才结果为 True。and 的真值表如下所示

如果任一操作数为 True，则 or 的结果为 True。or 的真值表如下所示

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

以下是一些使用示例

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

在这里，我们通过为其命名 myAlias 来导入 math 模块。现在我们可以使用此名称引用 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 可确保即使存在未处理的异常，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("Inner function: ",a)
    inner_function()
    print("Outer function: ",a)

outer_function()

输出

Inner function:  10
Outer function:  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("Inner function: ",a)
    inner_function()
    print("Outer function: ",a)

outer_function()

输出

Inner function:  10
Outer function:  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 循环内的语句将继续执行，直到 while 循环的条件求值为 False 或遇到 break 语句。以下程序对此进行了说明。

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 的 0 次方到 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 循环中打印。