[搬运+翻译][从零学编程]Python3Ⅱ：控制结构 - Minecraft(我的世界)中文论坛

Python中的另外一种类型叫做[ruby=Boolean]布尔值[/ruby]。布尔值有两个可能的值：[ruby=真]True[/ruby]和[ruby=假]False[/ruby]。它们可以通过对值的比较来产生，在这个例子下，要用到相等操作符==。

>>> my_boolean = True

>>> my_boolean

True



>>> 2 == 3

False

>>> "hello" == "hello"

True

注意不要搞混赋值（一个等号）和比较（两个等号）。

Part题：
Python中两个布尔值是什么？
A. True和False
B. true和false
C. [ruby=真实]Truth[/ruby]和[ruby=虚假]Falsity[/ruby]

另外一个比较操作符，叫做不等操作符（!=），当被比较的两个值不相等时算作True，如果相等就算作False。

>>> 1 != 1

False

>>> "十一" != "七"

True

>>> 2 != 10

True

Part题：
这行代码的输出是？

>>> 7 != 8

A. True
B. False

Python也有判断一个数字是否大于或小于另一个数字的操作符，分别是 > 和 < 。

>>> 7 > 5

True

>>> 10 < 10

False

Part题：
这行代码的输出是？

>>> 7 > 7.0

A. True
B. False

大于等于和小于等于的操作符分别是 >= 和 <= 。
它们和大于/小于操作符差不多，除了它们在两个值相等的时候都会返回True。

>>> 7 <= 8

True

>>> 9 >= 9.0

True

大于/小于操作符也可以用来按字典比较字符串（英文单词的字母顺序由其组成字母决定）。

Part题：
这行代码的输出是？

>>> 8.7 <= 8.70

A. 出现错误
B. True
C. False

你可以用if语句来运行一段需要条件符合才能运行的代码。
如果一个条件被算作True，那么就运行一段代码。否则，就不运行那段代码。
一个if语句长这样：

if 条件:

  语句

Python用缩进（每行开头的空格）来界定代码块。其他语言，如C，使用方括号来做到这一点，但是在Python中缩进是强制性的；没了它，程序就不会工作。如你所看到的一样，if中的语句应该被缩进。

Part题：
if语句中的哪些部分要被缩进？
A. 全部部分
B. 第一行
C. if中的语句

这是一个if语句的举例：

if 10 > 5:

   print("10大于5")



print("程序终结")

表达式先检测10是不是大于5。由于10确实大于5，被缩进的语句被运行了，输出“10大于5”。然后，没有被缩进的语句，不属于if语句的范围，被运行了，输出“程序终结”。
注意if语句表达式后面的冒号 ( : )。

由于这个程序包含几行代码，你应该为它创建一个单独的文件运行。

Part题：
下面代码的输出是？

spam = 7

if spam > 5:

  print("five")

if spam > 8:

  print("eight")

A. 没有输出
B. five
C. eight

为了实现更复杂的条件检测，if语句可以被嵌套，也就是if语句中还有if语句。这也就是说里面的if语句是外面的if的一部分。这是一种检测几条条件是否都成立的方法。
举例：

num = 12

if num > 5:

   print("大于5")

   if num <=47:

      print("5和47之间")

结果：

>>>

大于5

5和47之间

>>>

Part题：
下面代码的输出是？

num = 7

if num > 3:

  print("3")

  if num < 5:

    print("5")

    if num == 7:

      print("7")

一个else语句要跟随在一个if语句的后面，包含着当if语句的条件被计算为False时要运行的代码。
和if一样，代码块要缩进。

x = 4

if x == 5:

   print("Yes")

else:

   print("No")

结果：

>>>

No

>>>

Part题：
下面代码的结果是？

if 1 + 1 == 2:

  if 2 * 2 == 8:

    print("if")

  else:

    print("else")

A. 没有输出
B. if
C. else

你也一样可以连接一串if和else语句来判断一系列可能性是否为真。
举例：

num = 7

if num == 5:

  print("数字是5")

else: 

  if num == 11:

    print("数字是11")

  else:

    if num == 7:

      print("数字是7")

    else: 

      print("数字不是5、11或7")

结果：

>>>

数字是7

>>>

Part题：
填空以比较变量，并输出对应文字：

x = 10

y = 20

__ x > y _

  print("if语句")

_____

  print("else语句")

elif语句（else if的缩写）是if和else语句连接时的快捷写法。一串if elif语句可以在最后有一个else语句，在当之前的if或elif语句的条件没有一个被算作True时执行。
举例：

num = 7

if num == 5:

   print("数字是5")

elif num == 11:

   print("数字是11")

elif num == 7:

   print("数字是7")

else:

   print("数字不是5、11或7")

输出：

>>>

数字是7

>>>

在其他编程语言中，与elif等价效果的语句有不同的形式，包括else if、elseif或elsif。

Part题：
“else if”的缩写是：

对于那些需要不止一个条件的if语句来说，布尔逻辑可以为其组合出更复杂的判断条件。
Python中的布尔操作符有[ruby=与]and[/ruby]、[ruby=或]or[/ruby]和[ruby=非]not[/ruby]。
and操作符需要两个参数，在只有两个参数都是True的时候自身才算作True。否则，它就算作False。

>>> 1 == 1 and 2 == 2

True

>>> 1 == 1 and 2 == 3

False

>>> 1 != 1 and 2 == 2

False

>>> 2 < 1 and 3 >  6

False

Python用单词作为它的布尔操作符，但在很多其他编程语言中用诸如 && 、 || 和 ! 的符号。

Part题：
下面代码的结果是？

if (1 == 1) and (2 + 2 > 3):

  print("true")

else:

  print("false")

A. true
B. false
C. true false

or操作符也需要两个参数。当两个参数中至少有一个参数为True的时候才算作True，也就是说只有在当两个参数都是False的时候才返回False。

>>> 1 == 1 or 2 == 2

True

>>> 1 == 1 or 2 == 3

True

>>> 1 != 1 or 2 == 2

True

>>> 2 < 1 or 3 >  6

False

Part题：
填空输出“Welcome”。

age = 15

money = 500

if age > 18 __ money > 100:

  _____("Welcome")

不像我们到现在为止看到的其他操作符，not只需要一个参数，并且将它反相。
not True的结果是False，not False的结果是True。

>>> not 1 == 1

False

>>> not 1 > 7

True

你可以用布尔操作符将几个判断语句连接在一起，作为if语句的条件。

Part题：
下面代码的结果是？

if not True:

  print("1")

elif not (1 + 1 == 3):

  print("2")

else:

  print("3")

运算优先级是编程中一个举足轻重的概念。它是对数学中的运算顺序的一个扩展（乘法先于加法等），扩展了其他的运算（操作）符，比如布尔逻辑中的运算符。

下面的代码说明了 == 比 or 有着更高的优先级。

>>> False == False or True

True

>>> False == (False or True)

False

>>> (False == False) or True

True

Python的运算顺序和数学是一致的：先括号，再指数运算，之后乘除，最后加减。

Part题：
下面代码的结果是？

if 1 + 1 * 3 == 6:

  print("Yes")

else:

  print("No")

A. Yes
B. No

下表列出了Python中所有的运算（操作）符，运算优先级由高到低。

操作符	描述
**	指数运算（乘方）
~, +, -	二进制补码，一元加和一元减（后两者的方法名分别是+@和-@）
*, /, %, //	乘，除，取余，向下取整除
+, -	加法和减法
>>, <<	二进制右移、左移
&	按位与
^	按位异或
\|	按位或
in, not in, is, is not, <, <=, >, >=, !=, ==	比较运算符，相等运算符，成员和身份运算符
not	布尔非
and	布尔与
or	布尔或
*=, %=, /=, //=, -=, +=, =, =	赋值运算符

同一行的运算符有同样的优先级。

Part题：
下面代码的结果是？

x = 4

y = 2

if not 1 + 1 == y or x == 4 and 7 == 8:

  print("Yes")

elif x > y:

  print("No")

A. Yes
B. No
C. Yes No

如果条件算作True，if语句就执行一次，否则就不会执行。
while语句与它相似，不同的是while可以运行不止一次。只要条件符合，while中的语句会被重复执行。一旦条件被算作False，就去执行下一部分代码。
下面是一个while循环将变量从1加到5，然后终结。

i = 1

while i <=5:

   print(i)

   i = i + 1



print("完成！")

结果：

>>>

1

2

3

4

5

完成！

>>>

while循环体中的语句被重复执行。这被叫做[ruby=iteration]迭代[/ruby]。

Part题：
这段代码输出几个数字？

i = 3

while i>=0:

  print(i)

  i = i - 1

死循环是一种特殊的while循环；它永远不会停止。它的条件永远算作True。
死循环的一个例子：

while 1==1:

  print("在循环中")

这个程序会无限输出“在循环中”。

你可以通过快捷键Ctrl+C或关闭程序来停止程序的运行。

Part题：
按要求填空：用循环将x的值每次增加2，并输出偶数。

x = 0

_____ x <=20_

  _____ (x)

  x += 2

如果要提前结束一个while循环，可以用到break语句。
当在循环内遇到break语句时，它会立即终结循环。

i = 0

while 1==1:

  print(i)

  i = i + 1

  if i >= 5:

    print("退出中")

    break



print("完成")

结果：

>>>

0

1

2

3

4

退出中

完成

>>>

在循环外使用break语句会产生错误。

Part题：
这段代码输出几个数字？

i = 5

while True:

  print(i)

  i = i - 1

  if i <= 2:

    break

另一个可以在循环中使用的语句叫做continue。
与break不同的是，continue会跳回到循环的最开始，而不是终结循环。

i = 0

while True:

   i = i +1

   if i == 2:

      print("跳过2")

      continue

   if i == 5:

      print("退出中")

      break

   print(i)



print("完成")

结果：

>>>

1

跳过2

3

4

退出中

完成

>>>

基本上来说，continue会停止当前的这次迭代，从下一次迭代继续运行。

在循环外使用continue语句会产生错误。

Part题：
哪个语句会停止当前的迭代，从下一次开始？

[ruby=Lists]列表[/ruby]是Python中的另一种对象。它被用做存储一列被索引的数据。
一个列表可以通过方括号和以逗号分隔的数据创建。
列表中的某个特定数据可以通过在方括号中使用它的索引获得。
举例：

words = ["Hello", "world", "!"]

print(words[0])

print(words[1])

print(words[2])

结果：

>>>

Hello

world

!

>>>

要注意列表中的第一项数据的索引是0而不是1。

Part题：
这段代码的结果是？

nums = [5, 4, 3, 2, 1]

print(nums[1])

用一对空的方括号可以创建一个空列表。

empty_list = []

print(empty_list)

结果：

>>>

[]

>>>

基本上来说，列表中的最后一项不需要跟逗号。但是标上一个是完全可以的，有些时候也鼓励这么做。

Part题：
这个列表中有几项？

[2,]

A. 1
B. 2
C. 3

一般而言，一个列表包含着一种数据类型，但是也可能包含不同种数据类型。
列表也可以嵌套列表。

number = 3

things = ["string", 0, [1, 2, number], 4.56]

print(things[1])

print(things[2])

print(things[2][2])

结果：

>>>

0

[1, 2, 3]

3

>>>

列表中的列表常被用来代表二维网格，因为Python中没有其他编程语言有的多_维数组。

Part题：
填空创建一个列表并输出它的第三项。

list = _ 42, 55, 67]

print(list[ _ ])

如果索引超出列表的界限，会产生一个IndexError。
有些类型，例如字符串，可以像列表一样被索引。对字符串的索引就像是在索引一个包含着字符串中每个字符的列表。
对于其他类型，例如整型，尝试对其索引会产生一个TypeError。

str = "Hello world!"

print(str[6])

结果：

>>>

w

>>>

Part题：
下面哪一行代码会产生错误？

num = [5, 4, 3, [2], 1]

print(num[0])

print(num[3][0])

print(num[5])

A. 第二行
B. 第三行
C. 第四行

列表中特定的数据可以被重新赋值。
举例：

nums = [7, 7, 7, 7, 7]

nums[2] = 5

print(nums)

结果：

>>>

[7, 7, 5, 7, 7]

>>>

Part题：
这段代码的结果是？

nums = [1, 2, 3, 4, 5]

nums[3] = nums[1]

print(nums[3])

列表可以像字符串一样加乘。
举例：

nums = [1, 2, 3]

print(nums + [4, 5, 6])

print(nums * 3)

结果：

>>>

[1, 2, 3, 4, 5, 6]

[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>>

列表和字符串在许多地方有相似之处——字符串可以被想成不能改变其中字符的列表。

Part题：
填空创建列表，对其第二项重新赋值，并输出整个列表。

nums = [33, 42, 56 _

nums[ _ ] = 22

print( ____ )

使用in操作符可以检测一项数据是否存在于列表中。如果这项数据在列表中出现一次以上，返回True。否则就返回False。

words = ["spam", "egg", "spam", "sausage"]

print("spam" in words)

print("egg" in words)

print("tomato" in words)

结果：

>>>

True

True

False

>>>

in操作符也可以用来检测一个字符串是不是另一个字符串的子字符串。

Part题：
这段代码的结果是？

nums = [10, 9, 8, 7, 6, 5]

nums[0] = nums[1] - 5

if 4 in nums:

  print(nums[3])

else:

  print(nums[4])

如果要检测一项数据是否不存在于列表中，可以按下面几种方式的一种使用not操作符。

nums = [1, 2, 3]

print(not 4 in nums)

print(4 not in nums)

print(not 3 in nums)

print(3 not in nums)

结果：

>>>

True

True

False

False

>>>

Part题：
按要求填空：如果列表中包含'z'，就输出"Yes"。

letters = ['a', 'b', 'z']

__ "z" __ letters:

  print("Yes")

另一种更改列表的方法是使用append方法。它会将一项数据添加到一个现有列表的末尾。

nums = [1, 2, 3]

nums.append(4)

print(nums)

结果：

>>>

[1, 2, 3, 4]

>>>

append前的点( . )意味着append是列表类的一个[ruby=method]方法[/ruby]。关于方法，我们以后会讲到。

Part题：
这段代码的结果是？

words = ["hello"]

words.append("world")

print(words[1])

A. 产生错误
B. hello
C. world

使用len函数可以获取列表中的项数。

nums = [1, 3, 5, 2, 4]

print(len(nums))

结果：

>>>

5

>>>

不像append，len是个普通的函数，而不是一个方法。这意味着它写在列表被调用前，也就不需要写点。

Part题：
这段代码的结果是？

letters = ["a", "b", "c"]

letters.append("d")

print(len(letters))

insert方法与append相似，但它允许你在列表的任意位置插入新的一项，而不是只在最后。

words = ["Python", "fun"]

index = 1

words.insert(index, "is")

print(words)

结果：

>>>

['Python', 'is', 'fun']

>>>

Part题：
这段代码的结果是？

nums = [9, 8, 7, 6, 5]

nums.append(4)

nums.insert(2, 11)

print(len(nums))

index方法寻找某一项在列表中第一次出现时的索引，并返回这个索引。
如果项不存在于列表中，就产生一个ValueError。

letters = ['p', 'q', 'r', 's', 'p', 'u']

print(letters.index('r'))

print(letters.index('p'))

print(letters.index('z'))

结果：

>>>

2

0

ValueError: 'z' is not in list

>>>

对于列表，还有几个有用的函数和方法。
max(list)：返回列表中的最大值
min(list)：返回列表中的最小值
list.count(obj)：统计一项在列表中出现多少次
list.remove(obj)：从列表中移除一项
list.reverse()：将列表中项的顺序反过来

Part题：
选择下面的选项填空，将'z'添加到list的末尾，并输出list的长度。

list.______ ('z')

print( ______ ______ )

len (list) insert index append

range函数创建一串序列数字。
下面的代码创建了一个包含0-9整数的列表。

numbers = list(range(10))

print(numbers)

结果：

>>>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

对list的调用是必须的，因为range自己创建一个range对象，必须转换为列表才能使用。

Part题：
这段代码的结果是？

nums = list(range(5))

print(nums[4])

如果调用range的时候有一个参数，就产生一个包含从0开始直至那个参数的对象。
如果有两个参数，就产生一个包含从第一个参数至第二个参数的对象。
举例：

numbers = list(range(3, 8))

print(numbers)



print(range(20) == range(0, 20))

结果：

>>>

[3, 4, 5, 6, 7]



True

>>>

Part题：
这段代码的结果是？

nums = list(range(5, 8))

print(len(nums))

range可以有第三个参数，指定了序列中数字的间隔。第三个参数必须是整型。

numbers = list(range(5, 20, 2))

print(numbers)

结果：

>>>

[5, 7, 9, 11, 13, 15, 17, 19]

>>>

Part题：
这段代码的结果是？

nums = list(range(3, 15, 3))

print(nums[2])

A. 0
B. 3
C. 9
D. 12

有时候需要对列表中的每一项都执行操作。这被称作迭代，可以通过while循环和一个计数变量实现。
举例：

words = ["hello", "world", "spam", "eggs"]

counter = 0

max_index = len(words) - 1



while counter <= max_index:

   word = words[counter]

   print(word + "!")

   counter = counter + 1

结果：

>>>

hello!

world!

spam!

eggs!

>>>

上面的例子迭代列表中所有的项，通过索引访问值，最后将它加上感叹号输出。

Part题：
哪种结构能用来迭代列表？
A. if语句
B. 循环
C. 变量赋值

用while迭代列表需要挺多代码的，所以Python也提供for循环达到相同的目标。
上面的例子可以写成效果等同的下面例子：

words = ["hello", "world", "spam", "eggs"]

for word in words:

  print(word + "!")

结果：

>>>

hello!

world!

spam!

eggs!

>>>

Python中的for循环和其他编程语言中的foreach循环相似。

Part题：
填空创建一个有效的for循环。

letters = ['a', 'b', 'c']

___ l __ letters _

  print(l)

for循环常被用作将代码循环执行一定次数。这样做的方法是将循环和range对象结合起来。

for i in range(5):

  print("hello!")

结果：

>>>

hello!

hello!

hello!

hello!

hello!

>>>

当在for循环中使用range对象时不需要对它调用list，因为不需要将其索引，所以也就不需要转换为列表。

Part题：
填空创建一个for循环，仅输出范围中的偶数。

___ i in range(0, 20, _ ):

  print( _ )

这一章是关于Python中的一个例程：一个简单的计算器。每一小节解释了程序的不同部分。
第一部分是总体目录，在直到用户输入"quit"前都会一直接受输出，所以需要用到一个while循环。

while True:

   print("选项：")

   print("输入 'add' 将两数相加")

   print("输入 'subtract' 将两数相减")

   print("输入 'multiply' 将两数相乘")

   print("输入 'divide' 将两数相除")

   print("输入 'quit' 结束程序")

   user_input = input(": ")



   if user_input == "quit":

      break

   elif user_input == "add":

      ...

   elif user_input == "subtract":

      ...

   elif user_input == "multiply":

      ...

   elif user_input == "divide":

      ...

   else:

      print("未知输入")

上面的代码是我们程序的起点。它接受用户输入，将输入与选项通过if/elif语句比较。
break语句用作停止while循环，在这个例子中是当用户输入"quit"的时候。

Part题：
如果将程序中的break语句换成"continue"，会有什么后果？
A. 要输入两次"quit"才能退出
B. 会和原来一样正常运行
C. 会无限运行下去

程序的下一部分是得到用户想要操作的数字。
下面的代码实现了加法计算，对于其他部分也可以如法炮制。

elif user_input == "add":

  num1 = float(input("输入第一个数字："))

  num2 = float(input("输入第二个数字："))

现在，当用户输入"add"的时候，程序指示用户输入两个数字，并将其存储在对应的变量中。

按这样来看，当指示用户输入的时候得到的不是数字时，程序会崩溃。在之后的模块中我们会学到如何解决这种问题。

Part题：
为什么代码中对float的调用是必要的？
A. 为了删掉输入中的空格
B. 为了将输入转化为浮点数
C. 为了检查输入是不是数字

程序的最后部分处理用户的输入，并输出。
下面是对于加法部分的代码。

elif user_input == "add":

  num1 = float(input("输入第一个数字："))

  num2 = float(input("输入第二个数字："))

  result = str(num1 + num2)

  print("结果是" + result)

现在我们已经有了一个能指示用户输入，然后计算，最终显示出和的程序。

对于其他部分（减、乘、除），也要写相似的代码。
输出的那行也可以放在if语句外，这样就可以省略代码中重复的部分。

Part题：
填空，使计算器能处理乘法。

elif user_input == "multiply":

  num1 = float(input("输入第一个数字："))

  num2 = _____(input("输入第二个数字："))

  result = str(num1 _ num2)

  print("结果是" + ______ )

1. 这段代码的输出是？

list = [1, 1, 2, 3, 5, 8, 13]

print(list[list[4]])

2. 这段代码的作用是？

for i in range(10):

  if not i % 2 == 0:

    print(i+1)

A. 输出0到8之间的所有偶数
B. 输出2到10之间的所有偶数
C. 输出1到9之间的所有奇数

3. 这段代码会输出多少行？

while False:

  print("循环中...")

A. 0
B. 1
C. ∞

4. 按要求填空：如果列表中有偶数项，就输出其中的第一项。

list = [1, 2, 3, 4]

if ___ (list) % 2 == 0 _

  print(list[ _ ])

5. 这段代码的输出是？

letters = ['x', 'y', 'z']

letters.insert(1, 'w')

print(letters[2])

6. 按要求填空：用for循环迭代列表，并输出列表中的项。

list = [1, 2, 3]

___ var __ list:

  print( ___ )