# Python 关键字

> 原文： [http://zetcode.com/lang/python/keywords/](http://zetcode.com/lang/python/keywords/)

在 Python 编程教程的这一部分中，我们介绍了 Python 语言中的关键字。

## Python 关键字

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

## Python 关键字列表

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

```py
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 是一种动态语言。 它随时间变化。 关键字列表将来可能会更改。

`keywords.py`

```py
#!/usr/bin/env python

# keywords.py

import sys
import keyword

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

```

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

```py
$ ./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`为止。

`while_kwd.py`

```py
#!/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)

```

在我们的脚本中，我们要计算数字列表中所有值的总和。 我们利用`while`循环。 我们确定列表的长度。 反复执行`while`循环，直到`i`等于零为止。 在循环的主体中，我们递减计数器并计算值的总和。

```py
$ ./while_kwd.py
The sum is: 104

```

值的总和为 104。

如果需要，可使用`break`关键字来中断循环。

`break_kwd.py`

```py
#!/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`关键字中断循环。

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

```

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

`continue_kwd.py`

```py
#!/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`关键字是常见的控制流关键字。 它用于确定要执行的语句。

`if_kwd.py`

```py
#!/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`关键字合并语句。

`elif_kwd.py`

```py
#!/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`语句。

```py
$ ./elif_kwd.py
Hello Luke!

```

这是输出。

`for`关键字用于遍历集合中的项目，以便它们出现在容器中。

`for_kwd.py`

```py
#!/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`语句中的逗号阻止将每个字符打印在新行上。

```py
$ ./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`。

`objects.py`

```py
#!/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`关键字测试对象身份。 我们是否在谈论同一对象。 请注意，多个变量可能引用同一对象。

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

```

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

`not`关键字取反布尔值。

`not_kwd.py`

```py
#!/usr/bin/env python

# not_kwd.py

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

grade = "L"

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

```

在我们的示例中，我们测试了等级值是否来自可能等级的列表。

```py
$ ./not_kwd.py
unknown grade

```

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

`and_kwd.py`

```py
#!/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"`字符串打印到控制台。

```py
$ ./and_kwd.py
a young male

```

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

`or_kwd.py`

```py
#!/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")

```

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

当我们使用 Python 编程语言中的和/或关键字工作时，就会进行短路求值。 短路求值意味着仅当第一个参数不足以确定表达式的值时，才求值第二个参数：当和的第一个参数求值为`false`时，总值必须为`false`； 当或的第一个参数为`true`时，总值必须为`true`。

一个典型的例子如下。

`short_circuit.py`

```py
#!/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 脚本。

`import_kwd.py`

```py
#!/usr/bin/env python

# import_kwd.py

import math

print(math.pi)

```

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

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

`as_kwd.py`

```py
#!/usr/bin/env python

# as_kwd.py

import random as rnd

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

print()

```

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

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

```

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

`from_kwd.py`

```py
#!/usr/bin/env python

# from_kwd.py

from sys import version

print(version)

```

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

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

```

## Python 函数

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

`def_kwd.py`

```py
#!/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`关键字创建一个新的匿名函数。 匿名函数未绑定到特定名称。

`lambda_kwd.py`

```py
#!/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`关键字创建新函数。 取而代之的是，我们动态使用内联函数。

```py
$ ./lambda_kwd.py
1 4 9 16 25

```

如果要访问在函数外部定义的变量，请使用`global`关键字。

`global_kwd.py`

```py
#!/usr/bin/env python

# global_kwd.py

x = 15

def function():

    global x
    x = 45

function()
print(x)

```

通常，在函数内部分配`x`变量时，我们会创建一个新的局部变量，该局部变量仅在该函数中有效。 但是，如果使用`global`关键字，则会在函数定义中更改变量`ouside`。

```py
$ ./global_kwd.py
45

```

## Python 异常

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

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

```

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

`try_except_finally.py`

```py
#!/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`关键字创建用户定义的异常。

`raise_kwd.py`

```py
#!/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')

```

在该示例中，我们仅期望是/否值。 对于其他可能性，我们提出一个例外。

```py
$ ./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`关键字删除对象。

`del_kwd.py`

```py
#!/usr/bin/env python

# del_kwd.py

a = [1, 2, 3, 4]

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

```

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

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

```

这是示例的输出。

`pass`关键字不执行任何操作。 在某些情况下，这是一个非常方便的关键字。

```py
def function():
    pass

```

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

`assert`关键字用于调试目的。 我们可以将其用于对我们显而易见的测试条件。 例如，我们有一个计算工资的程序。 我们知道薪水不能少于零。 因此，我们可以在代码中添加这样的断言。 如果断言失败，则解释器抱怨。

`assert_kwd.py`

```py
#!/usr/bin/env python

# assert_kwd.py

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

assert salary > 0

```

在程序执行期间，犯了一个错误。 薪水变成负数。

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

```

`AssertionError`无法执行脚本。

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

`class_kwd.py`

```py
#!/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 代码。

`exec_kwd.py`

```py
#!/usr/bin/env python

# exec_kwd.py

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

```

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

```py
$ ./exec_kwd.py
1 2 3 4 5

```

这是示例输出。

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

`in_kwd.py`

```py
#!/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`。

```py
$ ./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`关键字与生成器一起使用。

`yield_kwd.py`

```py
#!/usr/bin/env python

# yield_kwd.py

def gen():

    x = 11
    yield x

it = gen()

print(it.__next__())

```

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

```py
$ ./yield_kwd.py
11

```

在 Python 教程的这一部分中，我们介绍了 Python 关键字。