Python 自动化指南（繁琐工作自动化）第二版：二流程控制

Posted 2023-04-06 布客飞龙

原文：https://automatetheboringstuff.com/2e/chapter2/

所以，你知道单个指令的基本原理，程序就是一系列指令。但是编程的真正优势不仅仅是像周末跑腿一样一个接一个地运行指令。根据表达式的求值方式，程序可以决定跳过指令，重复指令，或者从几条指令中选择一条来运行。事实上，你几乎从来不希望你的程序从第一行代码开始，简单地执行每一行，一直到最后。流程控制语句可以决定在什么条件下执行哪些 Python 指令。

这些流程控制语句直接对应于流程图中的符号，所以我将提供本章中讨论的代码的流程图版本。图 2-1 显示了下雨时该做什么的流程图。沿着箭头所指的路线从头到尾走。

图 2-1：告诉你如果下雨该怎么做的流程图

在一个流程图中，从起点到终点通常有不止一条路线。计算机程序中的代码行也是如此。流程图用菱形表示这些分支点，而其他步骤用矩形表示。开始和结束步骤用圆角矩形表示。

但是在学习流程控制语句之前，你首先需要学习如何表示那些是和否选项，并且你需要理解如何将那些分支点写成 Python 代码。为此，让我们研究一下布尔值、比较运算符和布尔运算符。

布尔值

整数、浮点和字符串数据类型有无限多的可能值，而布尔数据类型只有两个值：True和False。（Boolean是大写的，因为数据类型是以数学家乔治·布尔的名字命名的。）当作为 Python 代码输入时，布尔值True和False缺少放在字符串两边的引号，它们总是以大写字母T或F开头，单词的其余部分是小写的。在交互式 Shell 中输入以下内容。（其中一些指令是故意不正确的，它们会导致错误消息出现。）

   >>> spam = True # ➊
   >>> spam
   True
   >>> true # ➋
   Traceback (most recent call last):
     File "<pyshell#2>", line 1, in <module>
       true
   NameError: name 'true' is not defined
   >>> True = 2 + 2 # ➌
   SyntaxError: can't assign to keyword

像任何其他值一样，布尔值在表达式中使用，并且可以存储在变量 ➊ 中。如果你没有使用合适的大小写 ➋ 或者你试图使用True和False作为变量名 ➌，Python 会给你一个错误信息。

比较运算符

比较运算符，也称为关系运算符，比较两个值并向下求值为一个布尔值。表 2-1 列出了比较运算符。

表 2-1： 比较运算符

运算符	含义
==	等于
!=	不等于
<	小于
>	大于
<=	小于或等于
>=	大于或等于

这些运算符根据您给它们的值计算为True或False。现在让我们尝试一些操作符，从==和!=开始。

>>> 42 == 42
True
>>> 42 == 99
False
>>> 2 != 3
True
>>> 2 != 2
False

如您所料，当两边的值相同时，==（等于）计算为True，当两个值不同时，!=（不等于）计算为True。==和!=操作符实际上可以处理任何数据类型的值。

   >>> 'hello' == 'hello'
   True
   >>> 'hello' == 'Hello'
   False
   >>> 'dog' != 'cat'
   True
   >>> True == True
   True
   >>> True != False
   True
   >>> 42 == 42.0
   True
   >>> 42 == '42' # ➊
   False

请注意，整数或浮点值总是不等于字符串值。表达式42 == '42'➊ 的计算结果为False，因为 Python 认为整数42不同于字符串'42'。

另一方面，<、>、<=和>=操作符只能处理整数和浮点值。

   >>> 42 < 100
   True
   >>> 42 > 100
   False
   >>> 42 < 42
   False
   >>> eggCount = 42
   >>> eggCount <= 42 # ➊
   True
   >>> myAge = 29
   >>> myAge >= 10 # ➋
   True

==和=运算符的区别

您可能已经注意到， == 操作符（等于）有两个等号，而 = 操作符（赋值）只有一个等号。这两个运算符很容易混淆。请记住以下几点：

• ==运算符（等于）询问两个值是否相同。
• =操作符（赋值）将右边的值放入左边的变量。

为了帮助记住哪个是哪个，请注意 == 运算符（等于）由两个字符组成，就像！= 运算符（不等于）由两个字符组成。

你会经常使用比较运算符来比较一个变量的值和其他值，就像在eggCount <= 42➊和myAge >= 10➋ 的例子中一样。（毕竟，您可以直接输入True，而不是在代码中输入'dog' != 'cat'。）在学习流程控制语句时，您将会看到更多这样的例子。

布尔运算符

三个布尔运算符（and、or和not）用于比较布尔值。像比较运算符一样，它们将这些表达式计算为一个布尔值。让我们详细研究一下这些操作符，从and操作符开始。

二元布尔运算符

and和or运算符总是采用两个布尔值（或表达式），所以它们被认为是二元运算符。如果两个布尔值都是True，则and运算符将表达式求值为True；否则，求值为False。使用and在交互式 Shell 中输入一些表达式，查看它的运行情况。

>>> True and True
True
>>> True and False
False

真值表显示了布尔运算符的每一个可能的结果。表 2-2 是and运算符的真值表。

表 2-2：和运算符真值表

表达式	求值为…
True and True	True
True and False	False
False and True	False
False and False	False

另一方面，如果两个布尔值之一为True，则or运算符将表达式求值为True。如果两者都是False，则求值为False。

>>> False or True
True
>>> False or False
False

你可以在or运算符的真值表中看到它的每一个可能的结果，如表 2-3 所示。

表 2-3：或运算符真值表

表达式	求值为…
True or True	True
True or False	True
False or True	True
False or False	False

not运算符

与and和or不同，not运算符只对一个布尔值（或表达式）进行运算。这使得它成为一元运算符。not操作符只计算相反的布尔值。

   >>> not True
   False
   >>> not not not not True # ➊
   True

就像在演讲和写作中使用双重否定一样，你可以嵌套not操作符 ➊，尽管在真实的程序中没有理由这样做。表 2-4 显示了not的真值表。

表 2-4：非运算符真值表

表达式	求值为…
not True	False
not False	True

混合布尔和比较运算符

由于比较运算符的计算结果为布尔值，因此您可以在带有布尔运算符的表达式中使用它们。

回想一下，and、or和not操作符被称为布尔操作符，因为它们总是对布尔值True和False进行操作。虽然像4 < 5这样的表达式不是布尔值，但它们是计算结果为布尔值的表达式。尝试在交互式 Shell 中输入一些使用比较运算符的布尔表达式。

>>> (4 < 5) and (5 < 6)
True
>>> (4 < 5) and (9 < 6)
False
>>> (1 == 2) or (2 == 2)
True

计算机会先计算左边的表达式，然后再计算右边的表达式。当它知道了每一个的布尔值后，它将计算整个表达式的布尔值。你可以把计算机对(4 < 5) and (5 < 6)的求值过程想象成如下：

您也可以在表达式中使用多个布尔运算符以及比较运算符：

>>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2
True

布尔运算符的运算顺序与数学运算符一样。在任何数学和比较操作符求值之后，Python 首先求值not操作符，然后是and操作符，然后是or操作符。

流程控制要素

流程控制语句通常以称为条件的部分开始，后面总是跟着称为子句的代码块。在您了解 Python 的特定流程控制语句之前，我将介绍什么是条件和块。

条件

到目前为止，你看到的布尔表达式都可以被认为是条件，和表达式是一回事；条件只是流程控制语句上下文中一个更具体的名称。条件总是向下求值为布尔值，True或False。一个流程控制语句根据它的条件是True还是False来决定做什么，几乎每个流程控制语句都使用一个条件。

代码块

Python 代码行可以在块中组合在一起。您可以从代码行的缩进来判断一个块何时开始和结束。块有三个规则。

• 当缩进增加时，块开始。
• 块可以包含其他块。
• 当缩进量减少到零或包含块的缩进量时，块结束。

通过查看一些缩进的代码，块更容易理解，所以让我们在一个小游戏程序的一部分中找到块，如下所示：

  name = 'Mary'
  password = 'swordfish'
  if name == 'Mary':
       print('Hello, Mary') # ➊
       if password == 'swordfish':
           print('Access granted.') # ➋
       else:
           print('Wrong password.') # ➌

您可以在autbor.com/blocks查看该程序的执行情况。第一块代码 ➊ 从第print('Hello, Mary')行开始，包含其后的所有行。在这个块里面是另一个块 ➋，其中只有一行代码：print('Access Granted.')。第三块 ➌ 也是一行长：print('Wrong password.')。

程序执行

在前一章的hello.py程序中，Python 开始执行程序顶端往下的指令，一个接一个。程序执行（或简称执行）是当前正在执行的指令的术语。如果你把源代码打印在纸上，并在执行的时候把手指放在每一行上，你可以把手指想象成程序的执行。

然而，并不是所有的程序都是直接向下执行的。如果您用手指跟踪一个带有流程控制语句的程序，您可能会发现自己根据条件跳过源代码，并且可能会跳过整个子句。

流程控制语句

现在，让我们探索流程控制中最重要的部分：语句本身。这些语句代表你在图 2-1 的流程图中看到的菱形，它们是你的程序将要做出的实际决定。

if语句

最常见的流程控制语句是if语句。如果语句的条件是True，那么if语句的子句（即if语句后面的块）将会执行。如果条件为False，则跳过该子句。

简单地说，if语句可以理解为，“如果这个条件为真，则执行子句中的代码”。在 Python 中，if语句由以下内容组成：

• if关键字
• 条件（即计算结果为True或False的表达式）
• 一个冒号
• 从下一行开始，一个缩进的代码块（称为if子句）

例如，假设你有一些代码来检查某人的名字是否是爱丽丝。（假设name之前被赋予了某个值。）

if name == 'Alice':
    print('Hi, Alice.')

所有流程控制语句都以冒号结尾，后跟一个新的代码块（子句）。这个if语句的子句是带有print('Hi, Alice.')的块。图 2-2 显示了这段代码的流程图。

图 2-2：if语句的流程图

if-else语句

一个if子句可以选择跟一个else语句。只有当if语句的条件为False时，才会执行else子句。用简单的英语来说，else语句可以理解为，“如果这个条件为真，执行这个代码。否则，执行该代码”。else语句没有条件，在代码中，else语句总是由以下内容组成：

• else关键字
• 一个冒号
• 从下一行开始，一个缩进的代码块（称为else子句）

回到Alice的例子，让我们看一些代码，如果这个人的名字不是Alice，这些代码使用一个else语句来提供不同的问候。

if name == 'Alice':
    print('Hi, Alice.')
else:
    print('Hello, stranger.')

图 2-3 显示了这段代码的流程图。

图 2-3：一个else语句的流程图

elif语句

虽然只有if或else子句中的一个会执行，但您可能希望执行多个可能子句中的一个。elif语句是一个else if语句，总是跟在一个if或另一个elif语句之后。它提供了另一个条件，仅当所有之前的条件都为False时才检查该条件。在代码中，elif语句总是由以下内容组成：

• elif关键字
• 条件（即计算结果为True或False的表达式）
• 一个冒号
• 从下一行开始，一个缩进的代码块（称为elif子句）

让我们给名称检查器添加一个elif来看看这个语句的运行情况。

if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')

这一次，你检查这个人的年龄，如果他们小于 12 岁，程序会告诉他们一些不同的东西。你可以在图 2-4 中看到流程图。

图 2-4：一条elif语句的流程图

如果age < 12是True并且name == 'Alice'是False，则elif子句执行。然而，如果两个条件都是False，则两个子句都被跳过。不能保证至少有一个条款会被执行。当有一串elif语句时，只有一个或没有一个子句会被执行。一旦发现其中一个语句的条件是True，其余的elif子句将被自动跳过。例如，打开一个新的文件编辑器窗口，输入以下代码，保存为vampire.py :

name = 'Carol'
age = 3000
if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')
elif age > 2000:
    print('Unlike you, Alice is not an undead, immortal vampire.')
elif age > 100:
    print('You are not Alice, grannie.')

您可以在autbor.com/vampire查看该程序的执行情况。这里，我又添加了两个elif语句，让姓名检查器根据age用不同的答案问候一个人。图 2-5 显示了此操作的流程图。

图 2-5：vampire.py程序中多个elif语句的流程图

然而，elif语句的顺序很重要。让我们重新排列它们来引入一个 bug。请记住，一旦发现一个True条件，其余的elif子句就会被自动跳过，所以如果你调换了vampire.py中的一些子句，就会遇到问题。将代码更改为如下所示，并保存为vampire2.py :

   name = 'Carol'
   age = 3000
   if name == 'Alice':
       print('Hi, Alice.')
   elif age < 12:
       print('You are not Alice, kiddo.')
   elif age > 100: # ➊
       print('You are not Alice, grannie.')
   elif age > 2000:
       print('Unlike you, Alice is not an undead, immortal vampire.')

您可以在autbor.com/vampire2查看该程序的执行情况。假设在执行这段代码之前，age变量包含值3000。您可能希望代码打印出字符串'Unlike you, Alice is not an undead, immortal vampire.'。但是因为age > 100条件是True（毕竟 3000 大于 100）➊，所以打印出字符串'You are not Alice, grannie.'，其余的elif语句自动跳过。记住，最多只会执行一个子句，对于elif语句，顺序很重要！

图 2-6 显示了先前代码的流程图。请注意age > 100和age > 2000的钻石是如何交换的。

可选地，您可以在最后一个elif语句之后有一个else语句。在这种情况下，保证至少有一个（且只有一个）子句会被执行。如果每个if和elif语句中的条件都是False，则执行else子句。例如，让我们重新创建Alice程序来使用if、elif和else子句。

name = 'Carol'
age = 3000
if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')
else:
    print('You are neither Alice nor a little kid.')

您可以在autbor.com/littlekid查看该程序的执行情况。图 2-7 显示了这个新代码的流程图，我们将它保存为littleKid.py。

简单地说，这种类型的流程控制结构应该是“如果第一个条件为真，就这样做。否则，如果第二个条件为真，就这样做。否则，做点别的”。当你一起使用if、elif和else语句时，记住这些关于如何排序的规则，以避免类似图 2-6 中的错误。首先，总是恰好有一个if语句。您需要的任何elif语句都应该遵循if语句。第二，如果您想确保至少有一个子句被执行，那么用一个else语句来关闭这个结构。

图 2-6：vampire2.py程序的流程图。X路径在逻辑上永远不会发生，因为如果年龄大于 2000 ，它就已经大于 100 。

图 2-7：之前littleKid.py程序的流程图

####while循环语句

您可以使用while语句让一段代码反复执行。只要while语句的条件为True，就会执行while子句中的代码。在代码中，while语句总是由以下内容组成：

• while关键字
• 条件（即计算结果为True或False的表达式）
• 一个冒号
• 从下一行开始，一个缩进的代码块（称为while子句）

你可以看到一个while语句看起来类似于一个if语句。区别在于他们的行为方式。在一个if子句的末尾，程序在if语句之后继续执行。但是在一个while子句的末尾，程序执行会跳回到while语句的开头。while子句通常被称为*while循环或简称为循环*。

让我们看一下使用相同条件并基于该条件采取相同动作的if语句和while循环。下面是带有if语句的代码：

spam = 0
if spam < 5:
    print('Hello, world.')
    spam = spam + 1

下面是带有while语句的代码：

spam = 0
while spam < 5:
    print('Hello, world.')
    spam = spam + 1

这些语句是相似的——if和while都检查spam的值，如果小于 5，它们就打印一条消息。但是当您运行这两个代码片段时，每一个都会发生非常不同的事情。对于if语句，输出只是"Hello, world."。但是对于while语句，是"Hello, world."重复了五次！看看这两段代码的流程图，图 2-8 和 2-9 ，看看为什么会这样。

图 2-8：if语句代码的流程图

图 2-9：while语句代码的流程图

带有if语句的代码检查条件，如果条件为真，它只打印一次Hello, world.。另一方面，带有while循环的代码将打印五次。五次打印后循环停止，因为spam中的整数在每次循环迭代结束时增加 1，这意味着在spam < 5为False之前循环将执行五次。

在while循环中，总是在每次迭代开始时检查条件（即每次循环执行时）。如果条件为True，则执行该子句，然后再次检查条件。第一次发现条件为False，跳过while子句。

烦人的while循环

这里有一个小的示例程序，它会一直要求你键入，字面意思是，your name。选择文件 -> 新建打开一个新的文件编辑器窗口，输入以下代码，将文件保存为yourName.py :

   name = '' # ➊
   while name != 'your name': # ➋
       print('Please type your name.')
       name = input() # ➌
   print('Thank you!') # ➍

您可以在autbor.com/yourname查看该程序的执行情况。首先，程序将变量name➊设置为一个空字符串。这是如此的以至于name != 'your name'条件将求值为True并且程序执行将进入while循环的子句 ➋。

这个子句中的代码要求用户键入他们的名字，这个名字被分配给name变量 ➌。因为这是块的最后一行，所以执行返回到while循环的开始，并重新求值条件。如果name中的值不等于字符串'your name'，则条件为True，执行再次进入while子句。

但是一旦用户输入your name，while循环的条件将是'your name' != 'your name'，其值为False。现在条件是False，而不是程序执行重新进入while循环的子句，Python 跳过它并继续运行程序的剩余部分 ➍。图 2-10 显示了yourName.py程序的流程图。

图 2-10：yourname.py程序的流程图

现在，让我们来看看yourName.py的运行情况。按下F5来运行它，在你给程序它想要的东西之前，输入几次your name以外的东西。

Please type your name.
Al
Please type your name.
Albert
Please type your name.
%#@#%*(^&!!!
Please type your name.
your name
Thank you!

如果你从来不输入your name，那么while循环的条件将永远不会是False，程序将会一直询问下去。这里，input()调用让用户输入正确的字符串，让程序继续运行。在其他程序中，条件可能永远不会真正改变，这可能是一个问题。让我们看看如何打破while循环。

break语句

让程序执行尽早脱离while循环的子句有一个捷径。如果执行到了一个break语句，它会立即退出while循环的子句。在代码中，break语句只包含break关键字。

很简单，对吧？这里有一个程序，它和前面的程序做同样的事情，但是它使用了一个break语句来避免循环。输入以下代码，并将文件保存为yourName2.py :

   while True: # ➊
       print('Please type your name.')
       name = input() # ➋
       if name == 'your name': # ➌
           break # ➍
   print('Thank you!') # ➎

您可以在autbor.com/yourname2查看该程序的执行情况。第一行 ➊ 创建无限循环；这是一个条件始终为True的while循环。（毕竟，表达式True的值总是小于值True。）程序执行进入这个循环后，只有执行了一条break语句才会退出循环。（永远不会退出的无限循环是常见的编程错误。）

就像之前一样，这个程序要求用户输入your name➋。然而，现在当执行仍在while循环中时，一个if语句检查 ➌ 是否等于'your name'。如果该条件为True，则break语句运行 ➍，执行移出循环至print('Thank you!')➎。否则，包含break语句的if语句的子句被跳过，这将执行放在while循环的末尾。此时，程序执行跳回到while语句的开始处 ➊ 以重新检查条件。由于这个条件仅仅是布尔值True，执行进入循环，要求用户再次输入your name。该程序的流程图见图 2-11 。

运行yourName2.py，输入您为yourName.py输入的相同文本。重写的程序应该以与原始程序相同的方式响应。

图 2-11：无限循环的yourName2.py程序的流程图。注意，X 路径在逻辑上永远不会发生，因为循环条件总是真。

continue语句

像break语句一样，continue语句也在循环中使用。当程序执行到一个continue语句时，程序执行立即跳回到循环的开始，并重新求值循环的条件。（这也是执行到循环末尾时发生的情况。）

让我们用continue写一个要求输入名字和密码的程序。在新的文件编辑器窗口中输入以下代码，并将程序保存为swordfish.py。

陷入无限循环？

如果你曾经运行过一个程序，它有一个错误导致它陷入无限循环，按下CTRL+C或者从 IDLE 的菜单中选择Shell -> 重启 Shell 。这将向你的程序发送一个键盘中断错误，并导致它立即停止。尝试通过在文件编辑器中创建一个简单的无限循环来停止程序，并将程序保存为infiniteLoop.py。

while True:
    print('Hello, world!')

当你运行这个程序时，它会打印出'Hello, world!'，永远显示在屏幕上，因为while语句的条件总是为真。如果你想简单地立即终止你的程序，CTRL+C也很方便，即使它没有陷入无限循环。

  while True:
      print('Who are you?')
      name = input()
       if name != 'Joe': # ➊
           continue # ➋
       print('Hello, Joe. What is the password? (It is a fish.)')
       password = input() # ➌
       if password == 'swordfish':
           break # ➍
   print('Access granted.')     # ➎

如果用户输入除了Joe➊ 之外的任何名字，则continue语句 ➋ 使程序执行跳回到循环的开始。当程序重新求值条件时，执行将总是进入循环，因为条件仅仅是值True。一旦用户通过了那个if语句，他们就会被要求输入密码 ➌。如果输入的密码是swordfish，则运行break语句 ➍，执行跳出while循环打印Access granted➎。否则，执行继续到while循环的结尾，然后跳回到循环的开始。该程序的流程图见图 2-12 。

图 2-12：swordFish.py。X路径逻辑上永远不会发生，因为循环条件总是真。

“真”和“假”值

条件将考虑其他数据类型中的一些值，相当于真和假。在条件中使用时，0，0.0，''（空字符串）被认为是假，而所有其他值被认为是真。例如，看看下面的程序：

name = ''
   while not name: # ➊
    print('Enter your name:')
    name = input()
print('How many guests will you have?')
numOfGuests = int(input())
   if numOfGuests: # ➋
       print('Be sure to have enough room for all your guests.') # ➌
print('Done')

您可以在autbor.com/howmanyguests查看该程序的执行情况。如果用户为名称输入一个空字符串，那么while语句的条件将为True➊，程序继续询问名称。如果numOfGuests的值不是 0 ➋，则认为该条件为真，程序将为用户 ➌ 打印一个提醒。

你可以输入not name != ''代替not name，输入numOfGuests != 0代替numOfGuests，但是使用真值和假值可以使您的代码更容易阅读。

运行这个程序，给它一些输入。在你自称是乔之前，这个程序不应该要求输入密码，一旦你输入了正确的密码，它就应该退出。

Who are you?
I'm fine, thanks. Who are you?
Who are you?
Joe
Hello, Joe. What is the password? (It is a fish.)
Mary
Who are you?
Joe
Hello, Joe. What is the password? (It is a fish.)
swordfish
Access granted.

您可以在autbor.com/hellojoe查看该程序的执行情况。

while循环和range()函数

while循环在它的条件为True时保持循环（这就是它的名字的原因），但是如果你只想执行一段代码一定的次数呢？你可以用一个for循环语句和range()函数来实现。

在代码中，for语句类似于for i in range(5):,包括以下内容：

• for关键字
• 变量名
• in关键字
• 调用range()方法，最多传递三个整数
• 一个冒号
• 从下一行开始，一个缩进的代码块（称为for子句）

让我们创建一个名为fiveTimes.py的新程序来帮助您查看运行中的for循环。

print('My name is')
for i in range(5):
    print('Jimmy Five Times (' + str(i) + ')')

您可以在autbor.com/fivetimesfor](https://autbor.com/fivetimesfor/)查看该程序的执行情况。循环的子句中的代码运行了五次。第一次运行时，变量i被设置为0。子句中的print()调用将打印Jimmy Five Times (0)。在 Python 完成了对for循环的子句中所有代码的迭代之后，执行返回到循环的顶部，并且for语句将i加 1。这就是为什么range(5)在子句中导致五次迭代，其中i被设置为0，然后是1，然后是2，然后是3，然后是4。变量i将上升到传递给range()的整数，但不包括该整数。图 2-13 显示了fiveTimes.py程序的流程图。

当你运行这个程序时，在离开for循环之前，它应该打印五次Jimmy Five Times，然后是i的值。

My name is
Jimmy Five Times (0)
Jimmy Five Times (1)
Jimmy Five Times (2)
Jimmy Five Times (3)
Jimmy Five Times (4)

注

对于循环，也可以使用中的break和continue语句。continue语句将继续到循环的计数器的的下一个值，就好像程序执行已经到达循环的结尾并返回到开始。事实上，您只能在中使用break和continue语句，而和用于循环。如果你试图在其他地方使用这些语句，Python 会给你一个错误。

图 2-13：fiveTimes.py的流程图

作为另一个循环例子，考虑这个关于数学家卡尔·弗里德里希·高斯的故事。高斯小的时候，一位老师想给全班同学一些作业。老师告诉他们把从 0 到 100 的所有数字加起来。年轻的高斯想出了一个聪明的办法，在几秒钟内算出答案，但是你可以写一个带有for循环的 Python 程序来替你做这个计算。

   total = 0 # ➊
   for num in range(101): # ➋
       total = total + num # ➌
   print(total)   # ➍

结果应该是 5050。当程序首次启动时，total变量被设置为0➊。for循环 ➋ 然后执行total = total + num➌ 100 次。到循环完成所有 100

Python编程快速上手-让繁琐工作自动化-第二章习题及其答案

Python编程快速上手-让繁琐工作自动化-第二章习题及其答案

1、布尔数据类型的两个值是什么？如何拼写？

答：True和False,使用大写的T和大写的F，其他字母是小写。

2、3个布尔操作符是什么？

答：and、or和not。

3、写出每个布尔操作符的真值表(也就是操作数的每种可能组合，以及操作的结果)

答：
and:
True and True  -> True
True and False -> False
False and True -> False
Fasle and False -> False

or:
True or True -> True
True or False -> True
False or True -> True
False or False -> False

not:
not True -> False
not False -> True

4、以下表达式求值的结果是什么？

4.1、( 5 > 4 ) and ( 3 == 5 )
4.2、not ( 5 > 4 )
4.3、( 5> 4 ) or ( 3 == 5 )
4.4、not (( 5 > 4 ) or ( 3 == 5 ))
4.5、( True and True ) and ( True == False )
4.6、( not False ) or ( not True )

答: 
4.1、
(5>4) and (3 == 5)
True  and False
     False    # 最终结果               
4.2、
not (5 > 4)
not True
   False     # 最终结果
4.3、
( 5> 4 ) or ( 3 == 5 )
  True   or   False
        True # 最终结果
4.4、
not (( 5 > 4 ) or ( 3 == 5 ))
not (True      or    False)
not     True 
   False  # 最终结果
4.5、
( True and True ) and ( True == False )
       True       and   False 
               False    # 最终结果
4.6、
( not False ) or ( not True )
    True      or  Fasle 
          True   # 最终结果

5、6个比较操作符是什么？

答：==、!=、<、>、<=和>=。

6、等于操作符和赋值操作符的区别是什么？

答：==是等于操作符，它比较两个值，求值为一个布尔值，而=是赋值操作符，将值保存在变量中。

7、解释什么是条件，可以在哪里使用条件？

答：条件是一个表达式，它用于控制流语句中，求值为一个布尔值。

8、识别这段代码中的3个语句块

spam = 0
if sapm == 10:
    print(‘eggs‘)
    if spam > 5:
        print(‘bacon‘)
    else:
        print(‘ham‘)
    print(‘spam‘)
print(‘spam‘)
答：3个语句块是if语句中的全部内容，以及print(‘bacon‘)和print(‘ham‘)这两行。
print(‘eggs‘)
if spam > 5:
    print(‘bacon‘)
else:
    print(‘ham‘)
print(‘spam‘)

9、编写代码，如果变量spam中存放1，就打印Hello，如果变量中存放2，就打印Howdy，如果变量中存放其它值，就打印Greetings

答：
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Author: davie
spam = input("请输入1或者2->:")
if spam.isdigit():
    spam = int(spam)
    if spam == 1:
        print("Hello %s"%spam)
    elif spam == 2:
        print("Howdy %s"%spam)
    else:
        print("Greetings!")
else:
    print("您输入的不是数字1或者2")

10、如果程序陷在一个无限循环中，你可以按什么键？

答：按Ctrl-C来停止陷在无线循环中的程序。

11、break和continue之间的区别是什么？

答：
break：
终止整个循环:当循环或判断执行到break语句时,即使判断条件为True或者序列尚未完全被历遍,都会跳出循环或判断。

continue
跳出当次循环。当循环或判断执行到continue语句时,continue后的语句将不再执行,会跳出当次循环,继续执行循环中的下一次循环。

12、在for循环中，range(10)、range(0,10)和range(0,10,1)之间的区别是什么？

答：
效果一样，都是打印出0-9的数字。range(10)调用产生的范围是从0直到(但不包括)10，range(0,10)明确告诉循环从0开始，range(0,10,1)
明确告诉循环每次迭代变量加1。

13、编写一小段程序，利用for循环，打印出从1到10数字。然后利用while循环，编写一个等价的程序，打印出从1到10的数字

# 编写一小段程序，利用for循环，打印出从1到10数字。
for i in range(1,11):
    print(‘for loop : %s‘%i)
# 利用while循环，编写一个程序，打印出从1到10的数字
count = 0
while count <10:
    count += 1
    print("while loop：%s"%count)

14、如何在名为spam的模块中，有一个名为bacon()的函数，那么在导入spam模块后，如何调用它？

答：
from spam import bacon
spam.bacon()

15、附加题：在网上查找round()和abs()函数，弄清楚它们的作用。在交互式环境中尝试使用它们

答： 
round():四舍五入
abs()：求绝对值
>>> round(3.1414926,3)
3.141
>>> round(3.1415926,3)
3.142
>>> round(‘4.5678‘,1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: type str doesn‘t define __round__ method
>>> 
>>> abs(-10)
10
>>> abs(8)
8
>>> abs(‘09‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): ‘str‘
>>> 
这两个都必须接受数字类型的数据，否则会报错。