Python 中的关键字列表

本教程提供有关 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其余三个语句。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自动返回一个对象。None程序流不会遇到 return 语句的函数也会返回。例如：
def a_void_function():
a = 1
b = 2
c = a + b

x = a_void_function()
print(x)
Output(输出) :
没有任何
这个程序有一个不返回值的函数，尽管它在内部做了一些操作。所以当我们打印X，我们得到None哪个是自动返回的（隐式）。同样，这是另一个例子：
def improper_return_function(a):
if (a % 2) == 0:
return True
x = improper_return_function(3)
print(x)
Output(输出) :
None
虽然这个函数有一个return语句，但并不是在所有情况下都能达到。该函数True仅在输入为偶数时返回。
如果我们给函数一个奇数，None则隐式返回。

and, or , not

and, or,not是 Python 中的逻辑运算符。仅当两个操作数都and为 时True才会产生True。真值表and如下：

orTrue如果任何操作数为 ，则结果为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
在这里，我们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 ““, line 301, in runcode
File ““, line 1, in
AssertionError
为了我们更好地理解，我们还可以提供一条消息以AssertionError.
>>> a = 4
>>> assert a > 5, “The value of a is too small”
Traceback (most recent call last):
File ““, line 301, in runcode
File ““, line 1, in
AssertionError: The value of a is too small
此时我们可以注意到，
assert condition, message
相当于，
if not condition:
raise AssertionError(message)

async, await

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

async def main():
print(‘Hello’)
await asyncio.sleep(1)
print(‘world’)
为了运行程序，我们使用
asyncio.run(main())
在上面的程序中，async关键字指定函数将异步执行。
在这里，首先 你好被打印。该await关键字使程序等待 1 秒。然后世界 被打印。

break, continue

breakandcontinue用于内部for和while循环来改变它们的正常行为。
break将结束它所在的最小循环，并且控制流到循环正下方的语句。continue导致结束循环的当前迭代，但不是整个循环。
这可以通过以下两个例子来说明：
for i in range(1,11):
if i == 5:
break
print(i)
Output(输出) :
1
2
3
4
这里，for循环打算打印从 1 到 10 的数字。但是当if条件满足时一世等于 5，我们就跳出循环。因此，仅打印范围 1 到 4。
for i in range(1,11):
if i == 5:
continue
print(i)
Output(输出) :
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 ““, line 301, in runcode
File ““, line 1, in
NameError: name ‘a’ is not defined
>>> b
5
在这里我们可以看到变量的引用 一种被删除了。所以，不再定义。但乙 仍然存在。
del 也用于从列表或字典中删除项目：
>>> a = [‘x’,’y’,’z’]
>>> del a[1]
>>> a [‘x’, ‘z’]

if, else, elif

if, else, elif 用于条件分支或决策。
当我们想要测试某个条件并仅在条件为真时才执行块时，我们使用ifand 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)
Output(输出) :
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))
Output(输出) :
0.1
Exception caught
None
这里，函数reciprocal()返回输入数字的倒数。
当我们输入 10 时，我们得到 0.1 的正常输出。但是当我们输入 0 时，aZeroDivisionError会自动升高。
这被我们的try…except块捕获并返回None。我们也可以ZeroDivisionError通过检查输入并在其他地方处理它来显式提高，如下所示：
if num == 0:
raise ZeroDivisionError(‘cannot divide’)

finally

finally与try…exceptblock 一起使用来关闭资源或文件流。
finally即使存在未处理的异常，Using 也能确保其中的代码块得到执行。例如：
try:
Try-block
except exception1:
Exception1-block
except exception2:
Exception2-block
else:
Else-block
finally:
Finally-block
这里如果 中有异常Try-block，则在exceptorelse块中处理。但是无论执行顺序如何，我们都可以放心，Finally-block即使出现错误也会执行。这对于清理资源很有用。
了解有关Python 编程中的异常处理的更多信息。

for

for用于循环。一般我们for在知道要循环的次数时使用。
在 Python 中，我们可以将它与任何类型的序列一起使用，例如列表或字符串。这是一个for用于遍历名称列表的示例：
names = [‘John’,’Monica’,’Steven’,’Robin’]
for i in names:
print(‘Hello ‘+i)
Output(输出) :
Hello John
Hello Monica
Hello Steven
Hello Robin
了解有关Python for 循环的更多信息。

from, import

import关键字用于将模块导入当前命名空间。from…import用于将特定属性或函数导入当前命名空间。例如：
import math
将导入math模块。现在我们可以将其中的cos()函数用作math.cos(). 但是如果我们只想导入cos()函数，可以使用fromas
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()
Output(输出) :
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)
Output(输出) :
h
e
l
l
o

is

is在 Python 中用于测试对象身份。而==运算符用于测试，如果两个变量相等或没有，is如果两个变量是指相同的对象用于测试。
True如果对象相同，False则返回，否则返回。
>>> True is True
True
>>> False is False
True
>>> None is None
True
我们知道True, FalseandNone在 Python 中只有一个实例，所以它们是相同的。
>>> [] == []
True
>>> [] is []
False
>>> {} == {}
True
>>> {} is {}
False
空列表或字典等于另一个空列表或字典。但它们不是相同的对象，因为它们分别位于内存中。这是因为列表和字典是可变的（值可以更改）。
>>> ‘’ == ‘’
True
>>> ‘’ is ‘’
True
>>> () == ()
True
>>> () is ()
True
与列表和字典不同，字符串和元组是不可变的（值一旦定义就不能改变）。因此，两个相等的字符串或元组也是相同的。它们引用相同的内存位置。

lambda

lambda用于创建匿名函数（没有名称的函数）。它是一个不包含return语句的内联函数。它由一个被评估和返回的表达式组成。例如：
a = lambda x: x2
for i in range(1,6):
print(a(i))
*Output(输出) :
2
4
6
8
10
在这里，我们使用lambda语句创建了一个将值加倍的内联函数。我们使用它来将包含 1 到 5 的列表中的值加倍。
了解有关Python lamda 函数的更多信息。

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()
Output(输出) :
Inner function: 10
Outer function: 10
在这里，inner_function()嵌套在outer_function.
变量 一种是在outer_function(). 所以，如果我们想在 中修改它inner_function()，我们必须将它声明为nonlocal。请注意一种 不是全局变量。
因此，我们从输出中看到变量在嵌套的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()
Output(输出) :
Inner function: 10
Outer function: 5
在这里，我们没有声明变量 一种嵌套函数内部是nonlocal. 因此，创建了一个具有相同名称的新局部变量，但非局部变量一种 没有像我们的输出中看到的那样被修改。

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())
Output(输出) :
10 None

while

while 用于 Python 中的循环。
while循环内的语句将继续执行，直到循环的条件while计算为False或break遇到语句。以下程序说明了这一点。
i = 5
while(i):
print(i)
i = i – 1
Output(输出) :
5
4
3
2
1
请注意，0 等于False。
了解有关Python while 循环的更多信息。

with

with 语句用于在上下文管理器定义的方法中包装代码块的执行。
上下文管理器是一个实现enter和exit方法的类。with语句的使用确保exit在嵌套块的末尾调用该方法。这个概念类似于try…finally块的使用。这里，是一个例子。
with open(‘example.txt’, ‘w’) as myfile:
myfile.write(‘Hello world!’)
本示例将文本写入Hello world!文件example.txt。文件对象在其中定义了enter和exit方法，因此它们充当自己的上下文管理器。
首先enter调用方法，然后with执行语句中的代码，最后exit调用方法。__exit即使出现错误也会调用方法。它基本上关闭了文件流。

yield

yield在像return语句一样的函数中使用。但yield返回一个生成器。
Generator 是一个迭代器，一次生成一个项目。大量的值将占用大量内存。生成器在这种情况下很有用，因为它一次只生成一个值，而不是将所有值存储在内存中。例如，
>>> g = (2x 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)
Output(输出) :**
0
1
4
9
16
25
在这里，该函数generator()返回一个生成器，该生成器生成从 0 到 5 的平方数。这将打印在for循环中。

                                                                                                                                               下一个教程:[Python 变量、常量和文字](https://www.yuque.com/aifanj/odpp1n/goivtn)