每种脚本语言都有指定的词或关键字，具有特定的定义和使用准则。Python也不例外。任何Python程序的基本组成部分都是Python关键字。
本教程将为您提供对所有Python关键字的基本概述，并详细讨论一些经常使用的重要关键字。
Python关键字是具有定义的唯一单词，具有我们只能应用于这些函数的特定含义和功能。您永远不需要将任何关键字导入您的程序中，因为它们始终存在。
Python的内置方法和类与关键字不同。内置方法和类始终存在；然而，它们在应用中不像关键字那样受限。
给Python关键字分配特定的含义意味着您无法在代码中将它们用于其他目的。如果您尝试这样做，将收到一个SyntaxError的消息。如果您尝试分配任何内容给内置方法或类型，您将不会收到SyntaxError消息；然而，这仍然不是一个好主意。
Python在最新版本（即Python 3.8）中包含35个关键字。这里我们展示了一个完整的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中，上述关键字可能会有所变化。可能会引入一些新的关键字，而其他的关键字可能会被删除。将以下语句写入代码窗口，您可以随时检索当前正在使用的版本中的关键字集合。
代码
# Python program to demonstrate the application of iskeyword()
# importing keyword library which has lists
import keyword
# displaying the complete list using "kwlist()."
print("The set of keywords in this version is: ")
print( keyword.kwlist )
输出：
The set of keywords in this version is :
['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']
通过调用help()函数，您可以获取当前提供的关键字列表：
代码
help("keywords")
Python的关键字集合随着新版本的引入而不断演变。例如，await和async关键字直到Python 3.7才被引入。而且，在Python 2.7中，print和exec这两个单词构成了关键字，但在Python 3+中，它们被改为内置方法，不再是关键字的一部分。在下面的段落中，您将发现许多方法来确定Python中的某个单词是否是关键字。
有很多优秀的Python IDE可供选择。它们都会以不同于代码中其他术语的方式突出显示关键字。这个功能将帮助您在编码过程中立即识别Python关键字，以免误用它们。
有多种方法可以在Python REPL中检测可接受的Python关键字，并进一步了解它们。
最后，如果尝试分配给它、使用一个方法命名或执行其他任何操作时收到SyntaxError，并且它不被允许，那么它很可能是一个关键字。这个方法可能有点难以观察，但它仍然是Python告诉您是否误用关键字的一种技巧。
以下各节根据关键字的使用频率对Python关键字进行分类。例如，第一类别包括所有用作值的关键字，而下一组包括用作运算符的关键字。这些分类将有助于理解关键字的使用方式，并帮助您整理庞大的Python关键字集合。
在布尔范式中，真指任何求值为真的变量。将一个项作为输入传递给bool()，以查看它是否为真。如果返回True，则该项的值为真。非空字符串和列表、非零数字以及许多其他对象都是真值的示例。
假指任何在布尔表达式中返回假的项。将一个项作为输入传递给bool()，以查看它是否为假。如果返回False，则该项的值为假。空字符串、0、{}和[]都是假值的示例。
在此示例中，有三个Python关键字用作值。这些是独立的值，我们可以无限次地重复使用，并且每次都对应同一个实体。这些值很可能会被频繁地看到和使用。
关键字True和False
在传统的计算机语言中，这些关键字是以小写字母输入的（true和false）；然而，在Python中，它们每次都是大写字母输入。在Python脚本中，True关键字表示布尔真状态。False是一个关键字，与True相等，只不过它具有负面的布尔状态，即假。
True和False是可以分配给变量或参数并直接进行比较的关键字。
代码
print( 4 == 4 )
print( 6 > 9 )
print( True or False )
print( 9 <= 28 )
print( 6 > 9 )
print( True and False )
输出：
True
False
True
True
False
False
因为第一、第三和第四个语句是真的，所以解释器对这些语句给出True，对其他语句给出False。在Python中，True和False是等同于1和0的。我们可以使用附带的插图来支持这个说法：
代码
print( True == 3 )
print( False == 0 )
print( True + True + True)
输出:
False
True
3
None关键字
None是Python中的一个关键字，表示“什么也没有”。在不同的计算机语言中，None被称为nil、null或undefined。
如果一个函数没有返回语句，则默认输出为None：
代码
print( None == 0 )
print( None == " " )
print( None == False )
A = None
B = None
print( A == B )
输出:
False
False
False
True
如果一个no_return_function没有返回值，它将简单地返回None值。None由在程序流中未满足返回表达式的函数返回。考虑以下场景：
代码
def no_return_function():
num1 = 10
num2 = 20
addition = num1 + num2
number = no_return_function()
print( number )
输出：
None
这个程序有一个带有返回值的函数，执行多个操作并包含一个返回表达式。因此，如果我们显示一个数字，我们得到的是None，这是当没有返回语句时的默认值。下面是一个示例：
代码
def with_return( num ):
if num % 4 == 0:
return False
number = with_return( 67 )
print( number )
输出：
None
几个Python关键字被用作运算符来执行数学运算。在许多其他计算机语言中，这些运算符由字符表示，如&，|和!。在Python中，所有这些都是关键字操作：
| Mathematical Operations | Operations in Other Languages | Python Keyword |
|---|---|---|
| AND, ∧ | && |
and |
| OR, ∨ | || |
or |
| NOT, ¬ | ! |
not |
| CONTAINS, ∈ | in | |
| IDENTITY | === |
is |
编程人员在创建Python时考虑了清晰性。因此，其他使用Python字符的计算机语言中的许多运算符都是英文单词，称为关键字。
and关键字
Python关键字and确定左侧和右侧操作数and是否为真或假。如果两个组件都为真，则结果为True。如果其中一个为假，则结果也为False：
and真值表
| X | Y | X and Y |
|---|---|---|
| True | True | True |
| False | True | False |
| True | False | False |
| False | False | False |
<component1> and <component2>
值得注意的是，and语句的结果并不总是True或False。因为and的特殊行为，这是这样的。它不会将输入处理成相应的布尔值，而是如果是假则返回
or关键字
Python中的or关键字用于检查至少有一个输入是否为真。如果第一个参数为真，则or操作返回它；否则，返回第二个参数：
<component1> or <component2>
与and关键字类似，or关键字也不会将其输入更改为相应的布尔值。相反，结果是根据它们是真还是假来确定的。
or真值表
| X | Y | X or Y |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
非关键字
在Python中，非关键字被用来获取变量的相反布尔值：
非关键字被用于在条件语句或其他布尔方程中切换布尔解释或结果。与and、or不同，非关键字确定特定的布尔状态，True或False，然后返回它们的反义值。
| X | not X |
|---|---|
| True | False |
| False | True |
代码
False and True
False or True
not True
输出：
False
True
False
in 关键字
Python中的in关键字是一个强大的约束检查器，也被称为成员运算符。如果您提供一个要查找的元素和一个容器或序列来查找，它将根据给定的元素是否在给定的容器中，给出True或False：
<an_element> in <a_container>
在字符串中测试特定字符是使用in关键字的一个很好的示例：
代码
container = "Javatpoint"
print( "p" in container )
print( "P" in container )
输出：
True
False
列表、字典、元组、字符串或任何通过方法contains()或可迭代的数据类型都可以使用关键字in来操作。
关键字is
在Python中，它用于检查对象的标识。操作用于确定两个参数是否相同。它还确定两个参数是否与唯一对象相关联。
当对象相同时，返回True；否则返回False。
代码
print( True is True )
print( False is True )
print( None is not None )
print( (9 + 5) is (7 * 2) )
输出：
True
False
False
True
真、假和空值在Python中都是相同的，因为只有一个版本。
代码
print( [] == [] )
print( [] is [] )
print( {} == {} )
print( {} is {} )
输出：
True
False
True
False
一个空的字典或列表与另一个空的字典或列表是相同的。然而，它们并不是完全相同的实体，因为它们在内存中是独立存储的。这是因为列表和字典都是可变的。
代码
print( '' == '' )
print( '' is '' )
输出：
True
True
字符串和元组与列表和字典不同，它们是不可更改的。因此，两个相等的字符串或元组也是相同的。它们都指向唯一的内存区域。
非局部关键字的使用方式与全局关键字的使用方式相当类似。非局部关键字被设计用来表明一个函数内部的变量（即嵌套函数）并不是局部的，而是位于外部函数中。如果我们需要在嵌套函数中改变其值，就必须用nonlocal来定义一个非局部参数。否则，嵌套函数会使用该名称创建一个局部变量。下面的示例将帮助我们澄清这一点。
代码
def the_outer_function():
var = 10
def the_inner_function():
nonlocal var
var = 14
print("The value inside the inner function: ", var)
the_inner_function()
print("The value inside the outer function: ", var)
the_outer_function()
输出：
The value inside the inner function: 14
The value inside the outer function: 14
在这种情况下，the_inner_function（）放在the_outer_function中。
the_outer_function具有一个名为var的变量。Var不是全局变量，正如你可能注意到的那样。因此，如果我们希望在the_inner_function（）中更改它，我们应该使用nonlocal来声明它。
结果，变量在嵌套的the_inner_function中被有效更新，如结果所示。以下是如果不使用nonlocal关键字会发生的情况：
代码
def the_outer_function():
var = 10
def the_inner_function():
var = 14
print("Value inside the inner function: ", var)
the_inner_function()
print("Value inside the outer function: ", var)
the_outer_function()
输出：
Value inside the inner function: 14
Value inside the outer function: 10
迭代过程和循环是基本的编程要点。为了生成和操作循环，Python有多个关键字。这些关键字几乎在每个Python程序中都会被使用和观察到。知道如何正确使用它们可以帮助你成为一个更好的Python开发者。
for关键字
for循环是Python中最常见的循环方式。它是由两个Python关键字组合而成的，它们是for和in，如前所述。
while关键字
Python的while循环使用while这个词，并像其他计算机语言的while循环一样工作。在while关键字后面的代码块会被重复执行，直到while关键字后面的条件变为假。
break关键字
如果你想快速跳出循环，可以使用break关键字。我们可以在for循环和while循环中都使用这个关键字。
continue关键字
如果你希望跳到下一个循环迭代，可以使用Python的continue关键字。与其他许多计算机语言类似，continue关键字允许你停止执行当前的循环迭代，并进入下一个迭代。
代码
# Program to show the use of keywords for, while, break, continue
for i in range(15):
print( i + 4, end = " ")
# breaking the loop when i = 9
if i == 9:
break
print()
# looping from 1 to 15
i = 0 # initial condition
while i < 15:
# When i has value 9, loop will jump to next iteration using continue. It will not print
if i == 9:
i += 3
continue
else:
# when i is not equal to 9, adding 2 and printing the value
print( i + 2, end = " ")
i += 1
输出：
4 5 6 7 8 9 10 11 12 13
2 3 4 5 6 7 8 9 10 14 15 16
try: 这个关键字用于处理异常，并与except关键字一起使用来处理程序中的问题。当发生某种错误时，程序会检查”try”块中的代码，但不会执行该块中的代码。
except: 如前所述，它与”try”一起使用来处理异常。
finally: 无论”try”部分的结果如何，”finally”部分都会被执行。
raise: raise关键字可以用于明确地引发一个异常。
assert: 这种方法用于帮助进行故障排除。通常用于确保代码正确。如果表达式被解释为true，则不会发生任何情况；然而，如果它为false，则会引发”AssertionError”。错误输出后面可以跟一个逗号，也可以打印出来。
代码
# initializing the numbers
var1 = 4
var2 = 0
# Exception raised in the try section
try:
d = var1 // var2 # this will raise a "divide by zero" exception.
print( d )
# this section will handle exception raised in try block
except ZeroDivisionError:
print("We cannot divide by zero")
finally:
# If exception is raised or not, this block will be executed every time
print("This is inside finally block")
# by using assert keyword we will check if var2 is 0
print ("The value of var1 / var2 is : ")
assert var2 != 0, "Divide by 0 error"
print (var1 / var2)
输出结果：
We cannot divide by zero
This is inside finally block
The value of var1 / var2 is :
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
Input In [44], in ()
15 # by using assert keyword we will check if var2 is 0
16 print ("The value of var1 / var2 is : ")
---> 17 assert var2 != 0, "Divide by 0 error"
18 print (var1 / var2)
AssertionError: Divide by 0 error
在Python中，空语句被称为pass。它作为其他东西的替身。当运行它时，什么都不会发生。
假设我们拥有一个尚未编码的函数，但我们希望将来这样做。如果我们在代码的中间只写这个：
代码
def function_pass( arguments ):
结果：
def function_pass( arguments ):
^
IndentationError: expected an indented block after function definition on line 1
如图所示，将引发IndentationError错误。相反，我们使用pass命令创建一个空容器。
代码
def function_pass( arguments ):
pass
我们也可以使用pass关键字创建一个空的类。
Code
class passed_class:
pass
返回表达式用于退出函数并生成结果。
如果我们没有明确返回一个值，那么默认情况下会返回None关键字。下面的示例演示了这一点。
代码
def func_with_return():
var = 13
return var
def func_with_no_return():
var = 10
print( func_with_return() )
print( func_with_no_return() )
输出：
13
None
删除关键字用于删除对对象的任何引用。在Python中，每个实体都是一个对象。我们可以使用del命令来删除变量的引用。
代码
var1 = var2 = 5
del var1
print( var2 )
print( var1 )
输出：
5
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Input In [42], in ()
2 del var1
3 print( var2 )
----> 4 print( var1 )
NameError: name 'var1' is not defined
我们可以注意到变量var1的引用已经被移除。因此，它不再被识别。然而，var2仍然存在。
从列表或字典等集合中删除条目也是可能的，可以使用del语句实现：
代码
list_ = ['A','B','C']
del list_[2]
print(list_)
输出:
['A', 'B']
本文链接：http://so.lmcjl.com/news/17431/