Python 关键字

最后修改于 2023 年 10 月 18 日

在本 Python 编程教程中，我们将介绍 Python 语言中的关键字。

Python 关键字

Python 关键字 是构成 Python 语言词汇表的特殊词。它是一个保留字，不能用作标识符。

Python 关键字列表

以下是 Python 编程语言的关键字列表。

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

Python 是一种动态语言。它会随着时间变化。关键字列表将来可能会更改。

#!/usr/bin/env python

# keywords.py

import sys
import keyword

print("Python version: ", sys.version_info)
print("Python keywords: ", keyword.kwlist)

此脚本打印 Python 的版本及其实际的关键字列表。

$ ./keywords.py
Python version:  sys.version_info(major=3, minor=5, micro=2, releaselevel='final', serial=0)
Python keywords:  ['False', 'None', 'True', 'and', 'as', 'assert', '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 3.5.2 的 Python 关键字列表。

Python 控制流程

while 关键字是控制程序流程的基本关键字。while 循环内的语句将一直执行，直到表达式的计算结果为 False。

#!/usr/bin/env python

# while_kwd.py

numbers = [22, 34, 12, 32, 4]
mysum = 0

i = len(numbers)

while i != 0:

   i -= 1
   mysum = mysum + numbers[i]

print("The sum is:", mysum)

在我们的脚本中，我们想计算 numbers 列表中所有值的总和。我们使用 while 循环。我们确定列表的长度。while 循环会一遍又一遍地执行，直到 i 等于零。在循环体中，我们递减计数器并计算值的总和。

$ ./while_kwd.py
The sum is: 104

值的总和为 104。

如果需要，break 关键字用于中断循环。

#!/usr/bin/env python

# break_kwd.py

import random

while True:

    val = random.randint(1, 30)
    print(val, end=" ")

    if val == 22:
        break

print()

在我们的示例中，我们打印随机整数。如果数字等于 22，则循环将使用 break 关键字中断。

$ ./break_kwd.py
14 14 30 16 16 20 23 15 17 22

下一个示例显示了 continue 关键字。它用于中断当前循环，而不会跳出整个循环。它启动一个新的循环。

#!/usr/bin/env python

# continue_kwd.py

num = 0

while num < 1000:

      num = num + 1

      if num % 2 == 0:
         continue

      print(num, end=" ")

在示例中，我们打印所有小于 1000 且不能被 2 整除的数字。

if 关键字是一个常见的控制流程关键字。它用于确定要执行的语句。

#!/usr/bin/env python

# if_kwd.py

age = 17

if age > 18:

    print("Driving licence issued")
else:

    print("Driving licence not permitted")

if 关键字测试该人是否年满 18 岁。如果满足条件，则颁发驾驶执照。else 关键字是可选的。除非条件为 True，否则将执行 else 关键字之后的语句。

接下来我们看看如何使用 elif 关键字组合这些语句。

#!/usr/bin/env python

# elif_kwd.py

name = "Luke"

if name == "Jack":
    print("Hello Jack!")

elif name == "John":
    print("Hello John!")

elif name == "Luke":
    print("Hello Luke!")

else:
    print("Hello there!")

如果第一个测试结果为 False，我们将继续下一个测试。如果没有任何测试为 True，则执行 else 语句。

$ ./elif_kwd.py
Hello Luke!

for 关键字用于按它们在容器中出现的顺序迭代集合中的项目。

#!/usr/bin/env python

# for_kwd.py

lyrics = """\
Are you really here or am I dreaming
I can't tell dreams from truth
for it's been so long since I have seen you
I can hardly remember your face anymore
"""


for i in lyrics:

    print(i, end=" ")

在示例中，我们有一个包含歌曲节的 lyrics 变量。我们迭代文本并逐个字符打印文本。print 语句中的逗号可以防止在每行新行上打印每个字符。

$ ./for_kwd.py
A r e   y o u   r e a l l y   h e r e   o r   a m   I   d r e a m i n g
I   c a n ' t   t e l l   d r e a m s   f r o m   t r u t h
f o r   i t ' s   b e e n   s o   l o n g   s i n c e   I   h a v e   s e e n   y o u
I   c a n   h a r d l y   r e m e m b e r   y o u r   f a c e   a n y m o r e

Python 布尔表达式

首先，我们介绍用于处理布尔值和表达式的关键字：is、or、and 和 not。

#!/usr/bin/env python

# objects.py

print(None == None)
print(None is None)

print(True is True)

print([] == [])
print([] is [])

print("Python" is "Python")

== 运算符测试相等性。is 关键字测试对象身份。我们是否在谈论同一个对象。请注意，多个变量可以引用同一个对象。

$ ./objects.py
True
True
True
True
False
True

输出可能会让您感到惊讶。在 Python 语言中，只有一个 None 和一个 True 对象。这就是为什么 True 等于 True 并且也与其相同的原因。无论如何，只有一个真理。空列表 [] 等于另一个空列表 []；但它们不是同一个。Python 将它们放入两个不同的内存位置。它们是两个不同的对象。因此，is 关键字返回 False。另一方面，"Python" is "Python" 返回 True。这是因为优化。如果两个字符串字面量相等，则它们被放入同一内存位置。字符串是一个不可变实体，因此不会造成任何损害。

not 关键字否定布尔值。

#!/usr/bin/env python

# not_kwd.py

grades = ["A", "B", "C", "D", "E", "F"]

grade = "L"

if grade not in grades:
    print("unknown grade")

在我们的示例中，我们测试 grade 值是否在可能的 grade 列表中。

$ ./not_kwd.py
unknown grade

如果布尔表达式中的所有条件都必须满足，则使用关键字 and。

#!/usr/bin/env python

# and_kwd.py

sex = "M"
age = 26

if age < 55 and sex == "M":
    print("a young male")

在我们的示例中，我们测试是否满足两个条件。如果变量 age 小于 55 并且变量 sex 等于 "M"，则将字符串 "a young male" 打印到控制台。

$ ./and_kwd.py
a young male

如果至少要满足一个条件，则使用关键字 or。

#!/usr/bin/env python

# or_kwd.py

name = "Jack"

if (name == "Robert" or name == "Frank" or name == "Jack"
      or name == "George" or name == "Luke"):
    print("This is a male")

如果至少一个表达式为真，则执行 print 语句。

当我们使用 Python 编程语言中的 and/or 关键字时，会发生短路求值。短路求值 意味着仅当第一个参数不足以确定表达式的值时，才对第二个参数求值：当 and 的第一个参数计算结果为 false 时，总值必须为 false；当 or 的第一个参数计算结果为 true 时，总值必须为 true。

以下是一个典型的例子。

#!/usr/bin/env python

# short_circuit.py

x = 10
y = 0

if (y != 0 and x/y < 100):
    print("a small value")

表达式的第一部分计算结果为 false。表达式的第二部分未计算。否则，我们将得到一个 ZeroDivisionError。

Python 模块

以下关键字与模块一起使用。模块是我们组织 Python 代码的文件。

import 关键字用于将其他模块导入 Python 脚本。

#!/usr/bin/env python

# import_kwd.py

import math

print(math.pi)

我们使用 import 关键字将 math 模块导入脚本的命名空间。我们打印 PI 值。

如果我们想给模块一个不同的别名，我们使用 as 关键字。

#!/usr/bin/env python

# as_kwd.py

import random as rnd

for i in range(10):
    print (rnd.randint(1, 10), end=" ")

print()

在这种情况下，我们导入 random 模块。我们打印十个随机整数。我们为 random 模块提供了一个不同的别名，即 rnd。在脚本中，我们使用新别名引用该模块。

$ ./as_kwd.py
1 2 5 10 10 8 2 9 7 2

from 关键字用于从模块导入特定变量、类或函数。

#!/usr/bin/env python

# from_kwd.py

from sys import version

print(version)

从 sys 模块中，我们导入 version 变量。如果要打印它，则无需使用模块名称。version 变量已直接导入到我们的命名空间，我们可以直接引用它。

$ ./from_kwd.py
3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)]

Python 函数

在这里，我们描述与函数关联的关键字。def 关键字用于创建新的用户定义函数。函数是我们组织代码的对象。

#!/usr/bin/env python

# def_kwd.py

def root(x):

    return x * x

a = root(2)
b = root(15)

print(a, b)

此示例演示了一个新的简单函数。该函数计算一个数的平方。return 键与函数定义密切相关；它退出函数并返回值。然后，该值将分配给 a 和 b 变量。

lambda 关键字创建一个新的匿名函数。匿名函数不绑定到特定的名称。

#!/usr/bin/env python

# lambda_kwd.py

a = lambda x: x * x

for i in (1, 2, 3, 4, 5):

    print(a(i), end=" ")

print()

正如您在前面的示例中看到的那样，我们没有使用 def 关键字创建一个新函数。取而代之的是，我们使用一个内联函数。

$ ./lambda_kwd.py
1 4 9 16 25

如果我们想访问在函数外部定义的变量，我们使用 global 关键字。

#!/usr/bin/env python

# global_kwd.py

x = 15

def function():

    global x
    x = 45

function()
print(x)

通常，在函数内向 x 变量赋值时，我们创建一个新的局部变量，该变量仅在该函数中有效。但是，如果我们使用 global 关键字，我们就会更改函数定义之外的变量。

$ ./global_kwd.py
45

Python 异常

接下来，我们将使用与异常处理一起使用的关键字。

$ cat films
Fargo
Aguirre, der Zorn Gottes
Capote
Grizzly man
Notes on a scandal

这是一个文件，其中包含一些电影标题。在代码示例中，我们将读取它。

#!/usr/bin/env python

# try_except_finally.py

f = None

try:

    f = open('films', 'r')

    for i in f:

        print(i, end="")

except IOError:

    print("Error reading file")

finally:

    if f:
        f.close()

我们尝试读取一个电影文件。如果没有发生异常，我们将文件的内容打印到控制台。可能会发生异常。例如，如果我们提供了不正确的文件名。在这种情况下，会引发 IOError 异常。except 关键字捕获异常并执行其代码块。finally 关键字始终在最后执行。我们用它来清理我们的资源。

在下一个示例中，我们将展示如何使用 raise 关键字创建用户定义的异常。

#!/usr/bin/env python

# raise_kwd.py

class YesNoException(Exception):

   def __init__(self):

       print('This is not a yes or no answer')


answer = 'y'

if (answer != 'yes' and answer != 'no'):
    raise YesNoException

else:
    print('Correct value')

在示例中，我们只期望 yes/no 值。对于其他可能性，我们引发一个异常。

$ ./raise_kwd.py
This is not a yes or no answer
Traceback (most recent call last):
  File "./raise_kwd.py", line 15, in <module>
    raise YesNoException
__main__.YesNoException

其他关键字

del 关键字删除对象。

#!/usr/bin/env python

# del_kwd.py

a = [1, 2, 3, 4]

print(a)
del a[:2]
print(a)

在我们的示例中，我们有一个包含四个整数的列表。我们从列表中删除第一个数字。结果将打印到控制台。

$ ./del_kwd.py
[1, 2, 3, 4]
[3, 4]

pass 关键字什么也不做。它在某些情况下是一个非常有用的关键字。

def function():
    pass

我们有一个函数。此函数尚未实现。（稍后会实现。）函数的主体不能为空。因此，我们可以在此处使用 pass 关键字，而不是打印诸如“函数尚未实现”之类的语句，或类似的内容。

assert 关键字用于调试目的。我们可以使用它来测试对我们来说显而易见的条件。例如，我们有一个计算工资的程序。我们知道工资不能小于零。因此，我们可以将这样的断言放入代码中。如果断言失败，解释器会报错。

#!/usr/bin/env python

# assert_kwd.py

salary = 3500
salary -= 3560 # a mistake was done

assert salary > 0

在程序的执行过程中，出现了错误。工资变为负数。

$ ./assert_kwd.py
Traceback (most recent call last):
  File "./assert_kwd.py", line 8, in <module>
    assert salary > 0
AssertionError

脚本的执行将因 AssertionError 而失败。

class 关键字用于创建新的用户定义对象。

#!/usr/bin/env python

# class_kwd.py

class Square:

    def __init__(self, x):
        self.a = x

    def area(self):
        print(self.a * self.a)


sq = Square(12)
sq.area()

在代码示例中，我们创建了一个新的 Square 类。然后我们实例化该类并创建一个对象。我们计算了正方体对象的面积。

exec 关键字动态执行 Python 代码。

#!/usr/bin/env python

# exec_kwd.py

exec("for i in [1, 2, 3, 4, 5]: print(i, end=' ')")

我们使用 for 循环从列表中打印五个数字；所有内容都在 exec 关键字中。

$ ./exec_kwd.py
1 2 3 4 5

接下来，我们提到 in 关键字。关键字测试某个值是否存在于序列中。

#!/usr/bin/env python

# in_kwd.py

print(4 in (2, 3, 5, 6))

for i in range(25):
    print(i, end=" ")

print()

在此示例中，in 关键字测试数字 4 是否在元组中。第二种用法是在 for 循环中遍历元组。内置函数 range 返回整数 0 .. 24。

$ ./in_kwd.py
False
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

yield 关键字与生成器一起使用。

#!/usr/bin/env python

# yield_kwd.py


def gen():

    x = 11
    yield x


it = gen()

print(it.__next__())

yield 关键字退出生成器并返回值。

$ ./yield_kwd.py
11

在本 Python 教程中，我们介绍了 Python 关键字。