Python 关键字列表及示例

本教程提供有关Python中使用的所有关键字的简要信息。

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

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

Python编程语言中的关键字

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中的真假值。它们是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在python中与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中的逻辑运算符。 并且只有两个操作数都为True时，结果才为True。 and的True，False表如下：

 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

Python中的asyncio库提供了async和await关键字。它们用于在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 时就满足了条件，我们从循环中中断了。因此，仅打印范围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 and 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 and if ... else语句的更多信息。

except, raise, try

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

异常基本上是错误，表明在执行我们的程序时出现了问题。在Python异常的几个实例IOError，ValueError，ZeroDivisionError，ImportError，NameError，TypeError等。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列表的示例：

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

输出结果

Hello John
Hello Monica
Hello Steven
Hello Robin

了解有关Python for loop的更多信息。

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

输出结果

Inner function:  10
Outer function:  10

在此，inner_function()嵌套在outer_function中。

变量a位于outer_function()中。因此，如果要在inner_function()中进行修改a，则必须将其声明为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是非本地的。因此，将创建一个具有相同名称的新局部变量，但不修改非局部变量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的幂，直到生成加到99的2的幂。我们可以使用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循环中。