本帖最后由 45gfg9 于 2020-3-16 17:32 编辑
Prev: Python3Ⅰ：基本概念
Next: Python3Ⅲ：函数 & 模块
索引贴
答案帖
Prev: Python3Ⅰ：基本概念
Next: Python3Ⅲ：函数 & 模块
1 布尔值 & 比较
1.1 布尔值
Python中的另外一种类型叫做布尔值 。布尔值有两个可能的值：True 和False 。它们可以通过对值的比较来产生，在这个例子下，要用到相等操作符==。
```py
>>> my_boolean = True
>>> my_boolean
True
>>> 2 == 3
False
>>> "hello" == "hello"
True
```
Part题：
Python中两个布尔值是什么？
A. True和False
B. true和false
C.Truth 和Falsity
1.2 比较（一）
另外一个比较操作符，叫做不等操作符（!=），当被比较的两个值不相等时算作True，如果相等就算作False。
```py
>>> 1 != 1
False
>>> "十一" != "七"
True
>>> 2 != 10
True
```
Part题：
这行代码的输出是？
```py
>>> 7 != 8
```
A. True
B. False
1.3 比较（二）
Python也有判断一个数字是否大于或小于另一个数字的操作符，分别是 > 和 < 。
```py
>>> 7 > 5
True
>>> 10 < 10
False
```
Part题：
这行代码的输出是？
```py
>>> 7 > 7.0
```
A. True
B. False
1.4 比较（三）
大于等于和小于等于的操作符分别是 >= 和 <= 。
它们和大于/小于操作符差不多，除了它们在两个值相等的时候都会返回True。
```py
>>> 7 <= 8
True
>>> 9 >= 9.0
True
```
Part题：
这行代码的输出是？
```py
>>> 8.7 <= 8.70
```
A. 出现错误
B. True
C. False
2 if语句
2.1 if语句（一）
你可以用if语句来运行一段需要条件符合才能运行的代码。
如果一个条件被算作True，那么就运行一段代码。否则，就不运行那段代码。
一个if语句长这样：
```py
if 条件:
语句
```
Part题：
if语句中的哪些部分要被缩进？
A. 全部部分
B. 第一行
C. if中的语句
2.2 if语句（二）
这是一个if语句的举例：
```py
if 10 > 5:
print("10大于5")
print("程序终结")
```
表达式先检测10是不是大于5。由于10确实大于5，被缩进的语句被运行了，输出“10大于5”。然后，没有被缩进的语句，不属于if语句的范围，被运行了，输出“程序终结”。
注意if语句表达式后面的冒号 ( : )。
Part题：
下面代码的输出是？
```py
spam = 7
if spam > 5:
print("five")
if spam > 8:
print("eight")
```
A. 没有输出
B. five
C. eight
2.3 if语句（三）
为了实现更复杂的条件检测，if语句可以被嵌套，也就是if语句中还有if语句。这也就是说里面的if语句是外面的if的一部分。这是一种检测几条条件是否都成立的方法。
举例：
```py
num = 12
if num > 5:
print("大于5")
if num <=47:
print("5和47之间")
```
结果：
```py
>>>
大于5
5和47之间
>>>
```
Part题：
下面代码的输出是？
```py
num = 7
if num > 3:
print("3")
if num < 5:
print("5")
if num == 7:
print("7")
```
3 else语句
3.1 else语句（一）
一个else语句要跟随在一个if语句的后面，包含着当if语句的条件被计算为False时要运行的代码。
和if一样，代码块要缩进。
```py
x = 4
if x == 5:
print("Yes")
else:
print("No")
```
结果：
```py
>>>
No
>>>
```
Part题：
下面代码的结果是？
```py
if 1 + 1 == 2:
if 2 * 2 == 8:
print("if")
else:
print("else")
```
A. 没有输出
B. if
C. else
3.2 else语句（二）
你也一样可以连接一串if和else语句来判断一系列可能性是否为真。
举例：
```py
num = 7
if num == 5:
print("数字是5")
else:
if num == 11:
print("数字是11")
else:
if num == 7:
print("数字是7")
else:
print("数字不是5、11或7")
```
结果：
```py
>>>
数字是7
>>>
```
Part题：
填空以比较变量，并输出对应文字：
```py
x = 10
y = 20
__ x > y _
print("if语句")
_____
print("else语句")
```
3.3 elif语句
elif语句（else if的缩写）是if和else语句连接时的快捷写法。一串if elif语句可以在最后有一个else语句，在当之前的if或elif语句的条件没有一个被算作True时执行。
举例：
```py
num = 7
if num == 5:
print("数字是5")
elif num == 11:
print("数字是11")
elif num == 7:
print("数字是7")
else:
print("数字不是5、11或7")
```
输出：
```py
>>>
数字是7
>>>
```
Part题：
“else if”的缩写是：
4 布尔逻辑
4.1 布尔逻辑
对于那些需要不止一个条件的if语句来说，布尔逻辑可以为其组合出更复杂的判断条件。
Python中的布尔操作符有and 、or 和not 。
and操作符需要两个参数，在只有两个参数都是True的时候自身才算作True。否则，它就算作False。
```py
>>> 1 == 1 and 2 == 2
True
>>> 1 == 1 and 2 == 3
False
>>> 1 != 1 and 2 == 2
False
>>> 2 < 1 and 3 >6
False
```
Part题：
下面代码的结果是？
```py
if (1 == 1) and (2 + 2 > 3):
print("true")
else:
print("false")
```
A. true
B. false
C. true false
4.2 布尔或
or操作符也需要两个参数。当两个参数中至少有一个参数为True的时候才算作True，也就是说只有在当两个参数都是False的时候才返回False。
```py
>>> 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”。
```py
age = 15
money = 500
if age > 18 __ money > 100:
_____("Welcome")
```
4.3 布尔非
不像我们到现在为止看到的其他操作符，not只需要一个参数，并且将它反相。
not True的结果是False，not False的结果是True。
```py
>>> not 1 == 1
False
>>> not 1 > 7
True
```
Part题：
下面代码的结果是？
```py
if not True:
print("1")
elif not (1 + 1 == 3):
print("2")
else:
print("3")
```
5 运算优先级
5.1 运算优先级（一）
运算优先级是编程中一个举足轻重的概念。它是对数学中的运算顺序的一个扩展（乘法先于加法等），扩展了其他的运算（操作）符，比如布尔逻辑中的运算符。
下面的代码说明了 == 比 or 有着更高的优先级。
```py
>>> False == False or True
True
>>> False == (False or True)
False
>>> (False == False) or True
True
```
Part题：
下面代码的结果是？
```py
if 1 + 1 * 3 == 6:
print("Yes")
else:
print("No")
```
A. Yes
B. No
5.2 运算优先级（二）
下表列出了Python中所有的运算（操作）符，运算优先级由高到低。
Part题：
下面代码的结果是？
```py
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
6 while循环
6.1 while循环（一）
如果条件算作True，if语句就执行一次，否则就不会执行。
while语句与它相似，不同的是while可以运行不止一次。只要条件符合，while中的语句会被重复执行。一旦条件被算作False，就去执行下一部分代码。
下面是一个while循环将变量从1加到5，然后终结。
```py
i = 1
while i <=5:
print(i)
i = i + 1
print("完成！")
```
结果：
```py
>>>
1
2
3
4
5
完成！
>>>
```
Part题：
这段代码输出几个数字？
```py
i = 3
while i>=0:
print(i)
i = i - 1
```
6.2 while循环（二）
死循环是一种特殊的while循环；它永远不会停止。它的条件永远算作True。
死循环的一个例子：
```py
while 1==1:
print("在循环中")
```
这个程序会无限输出“在循环中”。
Part题：
按要求填空：用循环将x的值每次增加2，并输出偶数。
```py
x = 0
_____ x <=20_
_____ (x)
x += 2
```
6.3 break语句
如果要提前结束一个while循环，可以用到break语句。
当在循环内遇到break语句时，它会立即终结循环。
```py
i = 0
while 1==1:
print(i)
i = i + 1
if i >= 5:
print("退出中")
break
print("完成")
```
结果：
```py
>>>
0
1
2
3
4
退出中
完成
>>>
```
Part题：
这段代码输出几个数字？
```py
i = 5
while True:
print(i)
i = i - 1
if i <= 2:
break
```
6.4 continue语句
另一个可以在循环中使用的语句叫做continue。
与break不同的是，continue会跳回到循环的最开始，而不是终结循环。
```py
i = 0
while True:
i = i +1
if i == 2:
print("跳过2")
continue
if i == 5:
print("退出中")
break
print(i)
print("完成")
```
结果：
```py
>>>
1
跳过2
3
4
退出中
完成
>>>
```
基本上来说，continue会停止当前的这次迭代，从下一次迭代继续运行。
Part题：
哪个语句会停止当前的迭代，从下一次开始？
7 列表
7.1 列表（一）
列表 是Python中的另一种对象。它被用做存储一列被索引的数据。
一个列表可以通过方括号和以逗号分隔的数据创建。
列表中的某个特定数据可以通过在方括号中使用它的索引获得。
举例：
```py
words = ["Hello", "world", "!"]
print(words[0])
print(words[1])
print(words[2])
```
结果：
```py
>>>
Hello
world
!
>>>
```
Part题：
这段代码的结果是？
```py
nums = [5, 4, 3, 2, 1]
print(nums[1])
```
7.2 列表（二）
用一对空的方括号可以创建一个空列表。
```py
empty_list = []
print(empty_list)
```
结果：
```py
>>>
[]
>>>
```
Part题：
这个列表中有几项？
```py
[2,]
```
A. 1
B. 2
C. 3
7.3 列表（三）
一般而言，一个列表包含着一种数据类型，但是也可能包含不同种数据类型。
列表也可以嵌套列表。
```py
number = 3
things = ["string", 0, [1, 2, number], 4.56]
print(things[1])
print(things[2])
print(things[2][2])
```
结果：
```py
>>>
0
[1, 2, 3]
3
>>>
```
Part题：
填空创建一个列表并输出它的第三项。
```py
list = _ 42, 55, 67]
print(list[ _ ])
```
7.4 列表（四）
如果索引超出列表的界限，会产生一个IndexError。
有些类型，例如字符串，可以像列表一样被索引。对字符串的索引就像是在索引一个包含着字符串中每个字符的列表。
对于其他类型，例如整型，尝试对其索引会产生一个TypeError。
```py
str = "Hello world!"
print(str[6])
```
结果：
```py
>>>
w
>>>
```
Part题：
下面哪一行代码会产生错误？
```py
num = [5, 4, 3, [2], 1]
print(num[0])
print(num[3][0])
print(num[5])
```
A. 第二行
B. 第三行
C. 第四行
8 列表操作
8.1 列表操作（一）
列表中特定的数据可以被重新赋值。
举例：
```py
nums = [7, 7, 7, 7, 7]
nums[2] = 5
print(nums)
```
结果：
```py
>>>
[7, 7, 5, 7, 7]
>>>
```
Part题：
这段代码的结果是？
```py
nums = [1, 2, 3, 4, 5]
nums[3] = nums[1]
print(nums[3])
```
8.2 列表操作（二）
列表可以像字符串一样加乘。
举例：
```py
nums = [1, 2, 3]
print(nums + [4, 5, 6])
print(nums * 3)
```
结果：
```py
>>>
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>>
```
Part题：
填空创建列表，对其第二项重新赋值，并输出整个列表。
```py
nums = [33, 42, 56 _
nums[ _ ] = 22
print( ____ )
```
8.3 列表操作（三）
使用in操作符可以检测一项数据是否存在于列表中。如果这项数据在列表中出现一次以上，返回True。否则就返回False。
```py
words = ["spam", "egg", "spam", "sausage"]
print("spam" in words)
print("egg" in words)
print("tomato" in words)
```
结果：
```py
>>>
True
True
False
>>>
```
Part题：
这段代码的结果是？
```py
nums = [10, 9, 8, 7, 6, 5]
nums[0] = nums[1] - 5
if 4 in nums:
print(nums[3])
else:
print(nums[4])
```
8.4 列表操作（四）
如果要检测一项数据是否不存在于列表中，可以按下面几种方式的一种使用not操作符。
```py
nums = [1, 2, 3]
print(not 4 in nums)
print(4 not in nums)
print(not 3 in nums)
print(3 not in nums)
```
结果：
```py
>>>
True
True
False
False
>>>
```
Part题：
按要求填空：如果列表中包含'z'，就输出"Yes"。
```py
letters = ['a', 'b', 'z']
__ "z" __ letters:
print("Yes")
```
9 列表函数
9.1 列表函数（一）
另一种更改列表的方法是使用append方法。它会将一项数据添加到一个现有列表的末尾。
```py
nums = [1, 2, 3]
nums.append(4)
print(nums)
```
结果：
```py
>>>
[1, 2, 3, 4]
>>>
```
Part题：
这段代码的结果是？
```py
words = ["hello"]
words.append("world")
print(words[1])
```
A. 产生错误
B. hello
C. world
9.2 列表函数（二）
使用len函数可以获取列表中的项数。
```py
nums = [1, 3, 5, 2, 4]
print(len(nums))
```
结果：
```py
>>>
5
>>>
```
Part题：
这段代码的结果是？
```py
letters = ["a", "b", "c"]
letters.append("d")
print(len(letters))
```
9.3 列表函数（三）
insert方法与append相似，但它允许你在列表的任意位置插入新的一项，而不是只在最后。
```py
words = ["Python", "fun"]
index = 1
words.insert(index, "is")
print(words)
```
结果：
```py
>>>
['Python', 'is', 'fun']
>>>
```
Part题：
这段代码的结果是？
```py
nums = [9, 8, 7, 6, 5]
nums.append(4)
nums.insert(2, 11)
print(len(nums))
```
9.4 列表函数（四）
index方法寻找某一项在列表中第一次出现时的索引，并返回这个索引。
如果项不存在于列表中，就产生一个ValueError。
```py
letters = ['p', 'q', 'r', 's', 'p', 'u']
print(letters.index('r'))
print(letters.index('p'))
print(letters.index('z'))
```
结果：
```py
>>>
2
0
ValueError: 'z' is not in list
>>>
```
Part题：
选择下面的选项填空，将'z'添加到list的末尾，并输出list的长度。
```py
list.______ ('z')
print( ______ ______ )
```
len (list) insert index append
10 Range
10.1 Range（一）
range函数创建一串序列数字。
下面的代码创建了一个包含0-9整数的列表。
```py
numbers = list(range(10))
print(numbers)
```
结果：
```py
>>>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
```
Part题：
这段代码的结果是？
```py
nums = list(range(5))
print(nums[4])
```
10.2 Range（二）
如果调用range的时候有一个参数，就产生一个包含从0开始直至那个参数的对象。
如果有两个参数，就产生一个包含从第一个参数至第二个参数的对象。
举例：
```py
numbers = list(range(3, 8))
print(numbers)
print(range(20) == range(0, 20))
```
结果：
```py
>>>
[3, 4, 5, 6, 7]
True
>>>
```
Part题：
这段代码的结果是？
```py
nums = list(range(5, 8))
print(len(nums))
```
10.3 Range（三）
range可以有第三个参数，指定了序列中数字的间隔。第三个参数必须是整型。
```py
numbers = list(range(5, 20, 2))
print(numbers)
```
结果：
```py
>>>
[5, 7, 9, 11, 13, 15, 17, 19]
>>>
```
Part题：
这段代码的结果是？
```py
nums = list(range(3, 15, 3))
print(nums[2])
```
A. 0
B. 3
C. 9
D. 12
11 for循环
11.1 循环
有时候需要对列表中的每一项都执行操作。这被称作迭代，可以通过while循环和一个计数变量实现。
举例：
```py
words = ["hello", "world", "spam", "eggs"]
counter = 0
max_index = len(words) - 1
while counter <= max_index:
word = words[counter]
print(word + "!")
counter = counter + 1
```
结果：
```py
>>>
hello!
world!
spam!
eggs!
>>>
```
Part题：
哪种结构能用来迭代列表？
A. if语句
B. 循环
C. 变量赋值
11.2 for循环（一）
用while迭代列表需要挺多代码的，所以Python也提供for循环达到相同的目标。
上面的例子可以写成效果等同的下面例子：
```py
words = ["hello", "world", "spam", "eggs"]
for word in words:
print(word + "!")
```
结果：
```py
>>>
hello!
world!
spam!
eggs!
>>>
```
Part题：
填空创建一个有效的for循环。
```py
letters = ['a', 'b', 'c']
___ l __ letters _
print(l)
```
11.3 for循环（二）
for循环常被用作将代码循环执行一定次数。这样做的方法是将循环和range对象结合起来。
```py
for i in range(5):
print("hello!")
```
结果：
```py
>>>
hello!
hello!
hello!
hello!
hello!
>>>
```
Part题：
填空创建一个for循环，仅输出范围中的偶数。
```py
___ i in range(0, 20, _ ):
print( _ )
```
12 简单计算器
12.1 创建计算器（一）
这一章是关于Python中的一个例程：一个简单的计算器。每一小节解释了程序的不同部分。
第一部分是总体目录，在直到用户输入"quit"前都会一直接受输出，所以需要用到一个while循环。
```py
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("未知输入")
```
Part题：
如果将程序中的break语句换成"continue"，会有什么后果？
A. 要输入两次"quit"才能退出
B. 会和原来一样正常运行
C. 会无限运行下去
12.2 创建计算器（二）
程序的下一部分是得到用户想要操作的数字。
下面的代码实现了加法计算，对于其他部分也可以如法炮制。
```py
elif user_input == "add":
num1 = float(input("输入第一个数字："))
num2 = float(input("输入第二个数字："))
```
现在，当用户输入"add"的时候，程序指示用户输入两个数字，并将其存储在对应的变量中。
Part题：
为什么代码中对float的调用是必要的？
A. 为了删掉输入中的空格
B. 为了将输入转化为浮点数
C. 为了检查输入是不是数字
12.3 创建计算器（三）
程序的最后部分处理用户的输入，并输出。
下面是对于加法部分的代码。
```py
elif user_input == "add":
num1 = float(input("输入第一个数字："))
num2 = float(input("输入第二个数字："))
result = str(num1 + num2)
print("结果是" + result)
```
现在我们已经有了一个能指示用户输入，然后计算，最终显示出和的程序。
Part题：
填空，使计算器能处理乘法。
```py
elif user_input == "multiply":
num1 = float(input("输入第一个数字："))
num2 = _____(input("输入第二个数字："))
result = str(num1 _ num2)
print("结果是" + ______ )
```
章末检测
1. 这段代码的输出是？
```py
list = [1, 1, 2, 3, 5, 8, 13]
print(list[list[4]])
```
2. 这段代码的作用是？
```py
for i in range(10):
if not i % 2 == 0:
print(i+1)
```
A. 输出0到8之间的所有偶数
B. 输出2到10之间的所有偶数
C. 输出1到9之间的所有奇数
3. 这段代码会输出多少行？
```py
while False:
print("循环中...")
```
A. 0
B. 1
C. ∞
4. 按要求填空：如果列表中有偶数项，就输出其中的第一项。
```py
list = [1, 2, 3, 4]
if ___ (list) % 2 == 0 _
print(list[ _ ])
```
5. 这段代码的输出是？
```py
letters = ['x', 'y', 'z']
letters.insert(1, 'w')
print(letters[2])
```
6. 按要求填空：用for循环迭代列表，并输出列表中的项。
```py
list = [1, 2, 3]
___ var __ list:
print( ___ )
```
Prev: Python3Ⅰ：基本概念
Next: Python3Ⅲ：函数 & 模块
2021.12 数据，可能有更多内容
索引贴
答案帖
Prev: Python3Ⅰ：基本概念
Next: Python3Ⅲ：函数 & 模块
1 布尔值 & 比较
1.1 布尔值
Python中的另外一种类型叫做
```py
>>> my_boolean = True
>>> my_boolean
True
>>> 2 == 3
False
>>> "hello" == "hello"
True
```
注意不要搞混赋值（一个等号）和比较（两个等号）。
Part题：
Python中两个布尔值是什么？
A. True和False
B. true和false
C.
1.2 比较（一）
另外一个比较操作符，叫做不等操作符（!=），当被比较的两个值不相等时算作True，如果相等就算作False。
```py
>>> 1 != 1
False
>>> "十一" != "七"
True
>>> 2 != 10
True
```
Part题：
这行代码的输出是？
```py
>>> 7 != 8
```
A. True
B. False
1.3 比较（二）
Python也有判断一个数字是否大于或小于另一个数字的操作符，分别是 > 和 < 。
```py
>>> 7 > 5
True
>>> 10 < 10
False
```
Part题：
这行代码的输出是？
```py
>>> 7 > 7.0
```
A. True
B. False
1.4 比较（三）
大于等于和小于等于的操作符分别是 >= 和 <= 。
它们和大于/小于操作符差不多，除了它们在两个值相等的时候都会返回True。
```py
>>> 7 <= 8
True
>>> 9 >= 9.0
True
```
大于/小于操作符也可以用来按字典比较字符串（英文单词的字母顺序由其组成字母决定）。
Part题：
这行代码的输出是？
```py
>>> 8.7 <= 8.70
```
A. 出现错误
B. True
C. False
2 if语句
2.1 if语句（一）
你可以用if语句来运行一段需要条件符合才能运行的代码。
如果一个条件被算作True，那么就运行一段代码。否则，就不运行那段代码。
一个if语句长这样：
```py
if 条件:
语句
```
Python用缩进（每行开头的空格）来界定代码块。其他语言，如C，使用方括号来做到这一点，但是在Python中缩进是强制性的；没了它，程序就不会工作。如你所看到的一样，if中的语句应该被缩进。
Part题：
if语句中的哪些部分要被缩进？
A. 全部部分
B. 第一行
C. if中的语句
2.2 if语句（二）
这是一个if语句的举例：
```py
if 10 > 5:
print("10大于5")
print("程序终结")
```
表达式先检测10是不是大于5。由于10确实大于5，被缩进的语句被运行了，输出“10大于5”。然后，没有被缩进的语句，不属于if语句的范围，被运行了，输出“程序终结”。
注意if语句表达式后面的冒号 ( : )。
由于这个程序包含几行代码，你应该为它创建一个单独的文件运行。
Part题：
下面代码的输出是？
```py
spam = 7
if spam > 5:
print("five")
if spam > 8:
print("eight")
```
A. 没有输出
B. five
C. eight
2.3 if语句（三）
为了实现更复杂的条件检测，if语句可以被嵌套，也就是if语句中还有if语句。这也就是说里面的if语句是外面的if的一部分。这是一种检测几条条件是否都成立的方法。
举例：
```py
num = 12
if num > 5:
print("大于5")
if num <=47:
print("5和47之间")
```
结果：
```py
>>>
大于5
5和47之间
>>>
```
Part题：
下面代码的输出是？
```py
num = 7
if num > 3:
print("3")
if num < 5:
print("5")
if num == 7:
print("7")
```
3 else语句
3.1 else语句（一）
一个else语句要跟随在一个if语句的后面，包含着当if语句的条件被计算为False时要运行的代码。
和if一样，代码块要缩进。
```py
x = 4
if x == 5:
print("Yes")
else:
print("No")
```
结果：
```py
>>>
No
>>>
```
Part题：
下面代码的结果是？
```py
if 1 + 1 == 2:
if 2 * 2 == 8:
print("if")
else:
print("else")
```
A. 没有输出
B. if
C. else
3.2 else语句（二）
你也一样可以连接一串if和else语句来判断一系列可能性是否为真。
举例：
```py
num = 7
if num == 5:
print("数字是5")
else:
if num == 11:
print("数字是11")
else:
if num == 7:
print("数字是7")
else:
print("数字不是5、11或7")
```
结果：
```py
>>>
数字是7
>>>
```
Part题：
填空以比较变量，并输出对应文字：
```py
x = 10
y = 20
__ x > y _
print("if语句")
_____
print("else语句")
```
3.3 elif语句
elif语句（else if的缩写）是if和else语句连接时的快捷写法。一串if elif语句可以在最后有一个else语句，在当之前的if或elif语句的条件没有一个被算作True时执行。
举例：
```py
num = 7
if num == 5:
print("数字是5")
elif num == 11:
print("数字是11")
elif num == 7:
print("数字是7")
else:
print("数字不是5、11或7")
```
输出：
```py
>>>
数字是7
>>>
```
在其他编程语言中，与elif等价效果的语句有不同的形式，包括else if、elseif或elsif。
Part题：
“else if”的缩写是：
4 布尔逻辑
4.1 布尔逻辑
对于那些需要不止一个条件的if语句来说，布尔逻辑可以为其组合出更复杂的判断条件。
Python中的布尔操作符有
and操作符需要两个参数，在只有两个参数都是True的时候自身才算作True。否则，它就算作False。
```py
>>> 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题：
下面代码的结果是？
```py
if (1 == 1) and (2 + 2 > 3):
print("true")
else:
print("false")
```
A. true
B. false
C. true false
4.2 布尔或
or操作符也需要两个参数。当两个参数中至少有一个参数为True的时候才算作True，也就是说只有在当两个参数都是False的时候才返回False。
```py
>>> 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”。
```py
age = 15
money = 500
if age > 18 __ money > 100:
_____("Welcome")
```
4.3 布尔非
不像我们到现在为止看到的其他操作符，not只需要一个参数，并且将它反相。
not True的结果是False，not False的结果是True。
```py
>>> not 1 == 1
False
>>> not 1 > 7
True
```
你可以用布尔操作符将几个判断语句连接在一起，作为if语句的条件。
Part题：
下面代码的结果是？
```py
if not True:
print("1")
elif not (1 + 1 == 3):
print("2")
else:
print("3")
```
5 运算优先级
5.1 运算优先级（一）
运算优先级是编程中一个举足轻重的概念。它是对数学中的运算顺序的一个扩展（乘法先于加法等），扩展了其他的运算（操作）符，比如布尔逻辑中的运算符。
下面的代码说明了 == 比 or 有着更高的优先级。
```py
>>> False == False or True
True
>>> False == (False or True)
False
>>> (False == False) or True
True
```
Python的运算顺序和数学是一致的：先括号，再指数运算，之后乘除，最后加减。
Part题：
下面代码的结果是？
```py
if 1 + 1 * 3 == 6:
print("Yes")
else:
print("No")
```
A. Yes
B. No
5.2 运算优先级（二）
下表列出了Python中所有的运算（操作）符，运算优先级由高到低。
| 操作符 |
| 描述 |
| ** |
| 指数运算（乘方） |
| ~, +, - |
| 二进制补码，一元加和一元减（后两者的方法名分别是+@和-@） |
| *, /, %, // |
| 乘，除，取余，向下取整除 |
| +, - |
| 加法和减法 |
| >>, << |
| 二进制右移、左移 |
| & |
| 按位与 |
| ^ |
| 按位异或 |
| | |
| 按位或 |
| in, not in, is, is not, <, <=, >, >=, !=, == |
| 比较运算符，相等运算符，成员和身份运算符 |
| not |
| 布尔非 |
| and |
| 布尔与 |
| or |
| 布尔或 |
| =, %=, /=, //=, -=, +=, *=, **= |
| 赋值运算符 |
同一行的运算符有同样的优先级。
Part题：
下面代码的结果是？
```py
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
6 while循环
6.1 while循环（一）
如果条件算作True，if语句就执行一次，否则就不会执行。
while语句与它相似，不同的是while可以运行不止一次。只要条件符合，while中的语句会被重复执行。一旦条件被算作False，就去执行下一部分代码。
下面是一个while循环将变量从1加到5，然后终结。
```py
i = 1
while i <=5:
print(i)
i = i + 1
print("完成！")
```
结果：
```py
>>>
1
2
3
4
5
完成！
>>>
```
while循环体中的语句被重复执行。这被叫做迭代 。
Part题：
这段代码输出几个数字？
```py
i = 3
while i>=0:
print(i)
i = i - 1
```
6.2 while循环（二）
死循环是一种特殊的while循环；它永远不会停止。它的条件永远算作True。
死循环的一个例子：
```py
while 1==1:
print("在循环中")
```
这个程序会无限输出“在循环中”。
你可以通过快捷键Ctrl+C或关闭程序来停止程序的运行。
Part题：
按要求填空：用循环将x的值每次增加2，并输出偶数。
```py
x = 0
_____ x <=20_
_____ (x)
x += 2
```
6.3 break语句
如果要提前结束一个while循环，可以用到break语句。
当在循环内遇到break语句时，它会立即终结循环。
```py
i = 0
while 1==1:
print(i)
i = i + 1
if i >= 5:
print("退出中")
break
print("完成")
```
结果：
```py
>>>
0
1
2
3
4
退出中
完成
>>>
```
在循环外使用break语句会产生错误。
Part题：
这段代码输出几个数字？
```py
i = 5
while True:
print(i)
i = i - 1
if i <= 2:
break
```
6.4 continue语句
另一个可以在循环中使用的语句叫做continue。
与break不同的是，continue会跳回到循环的最开始，而不是终结循环。
```py
i = 0
while True:
i = i +1
if i == 2:
print("跳过2")
continue
if i == 5:
print("退出中")
break
print(i)
print("完成")
```
结果：
```py
>>>
1
跳过2
3
4
退出中
完成
>>>
```
基本上来说，continue会停止当前的这次迭代，从下一次迭代继续运行。
在循环外使用continue语句会产生错误。
Part题：
哪个语句会停止当前的迭代，从下一次开始？
7 列表
7.1 列表（一）
一个列表可以通过方括号和以逗号分隔的数据创建。
列表中的某个特定数据可以通过在方括号中使用它的索引获得。
举例：
```py
words = ["Hello", "world", "!"]
print(words[0])
print(words[1])
print(words[2])
```
结果：
```py
>>>
Hello
world
!
>>>
```
要注意列表中的第一项数据的索引是0而不是1。
Part题：
这段代码的结果是？
```py
nums = [5, 4, 3, 2, 1]
print(nums[1])
```
7.2 列表（二）
用一对空的方括号可以创建一个空列表。
```py
empty_list = []
print(empty_list)
```
结果：
```py
>>>
[]
>>>
```
基本上来说，列表中的最后一项不需要跟逗号。但是标上一个是完全可以的，有些时候也鼓励这么做。
Part题：
这个列表中有几项？
```py
[2,]
```
A. 1
B. 2
C. 3
7.3 列表（三）
一般而言，一个列表包含着一种数据类型，但是也可能包含不同种数据类型。
列表也可以嵌套列表。
```py
number = 3
things = ["string", 0, [1, 2, number], 4.56]
print(things[1])
print(things[2])
print(things[2][2])
```
结果：
```py
>>>
0
[1, 2, 3]
3
>>>
```
列表中的列表常被用来代表二维网格，因为Python中没有其他编程语言有的多_维数组。
Part题：
填空创建一个列表并输出它的第三项。
```py
list = _ 42, 55, 67]
print(list[ _ ])
```
7.4 列表（四）
如果索引超出列表的界限，会产生一个IndexError。
有些类型，例如字符串，可以像列表一样被索引。对字符串的索引就像是在索引一个包含着字符串中每个字符的列表。
对于其他类型，例如整型，尝试对其索引会产生一个TypeError。
```py
str = "Hello world!"
print(str[6])
```
结果：
```py
>>>
w
>>>
```
Part题：
下面哪一行代码会产生错误？
```py
num = [5, 4, 3, [2], 1]
print(num[0])
print(num[3][0])
print(num[5])
```
A. 第二行
B. 第三行
C. 第四行
8 列表操作
8.1 列表操作（一）
列表中特定的数据可以被重新赋值。
举例：
```py
nums = [7, 7, 7, 7, 7]
nums[2] = 5
print(nums)
```
结果：
```py
>>>
[7, 7, 5, 7, 7]
>>>
```
Part题：
这段代码的结果是？
```py
nums = [1, 2, 3, 4, 5]
nums[3] = nums[1]
print(nums[3])
```
8.2 列表操作（二）
列表可以像字符串一样加乘。
举例：
```py
nums = [1, 2, 3]
print(nums + [4, 5, 6])
print(nums * 3)
```
结果：
```py
>>>
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>>
```
列表和字符串在许多地方有相似之处——字符串可以被想成不能改变其中字符的列表。
Part题：
填空创建列表，对其第二项重新赋值，并输出整个列表。
```py
nums = [33, 42, 56 _
nums[ _ ] = 22
print( ____ )
```
8.3 列表操作（三）
使用in操作符可以检测一项数据是否存在于列表中。如果这项数据在列表中出现一次以上，返回True。否则就返回False。
```py
words = ["spam", "egg", "spam", "sausage"]
print("spam" in words)
print("egg" in words)
print("tomato" in words)
```
结果：
```py
>>>
True
True
False
>>>
```
in操作符也可以用来检测一个字符串是不是另一个字符串的子字符串。
Part题：
这段代码的结果是？
```py
nums = [10, 9, 8, 7, 6, 5]
nums[0] = nums[1] - 5
if 4 in nums:
print(nums[3])
else:
print(nums[4])
```
8.4 列表操作（四）
如果要检测一项数据是否不存在于列表中，可以按下面几种方式的一种使用not操作符。
```py
nums = [1, 2, 3]
print(not 4 in nums)
print(4 not in nums)
print(not 3 in nums)
print(3 not in nums)
```
结果：
```py
>>>
True
True
False
False
>>>
```
Part题：
按要求填空：如果列表中包含'z'，就输出"Yes"。
```py
letters = ['a', 'b', 'z']
__ "z" __ letters:
print("Yes")
```
9 列表函数
9.1 列表函数（一）
另一种更改列表的方法是使用append方法。它会将一项数据添加到一个现有列表的末尾。
```py
nums = [1, 2, 3]
nums.append(4)
print(nums)
```
结果：
```py
>>>
[1, 2, 3, 4]
>>>
```
append前的点( . )意味着append是列表类的一个方法 。关于方法，我们以后会讲到。
Part题：
这段代码的结果是？
```py
words = ["hello"]
words.append("world")
print(words[1])
```
A. 产生错误
B. hello
C. world
9.2 列表函数（二）
使用len函数可以获取列表中的项数。
```py
nums = [1, 3, 5, 2, 4]
print(len(nums))
```
结果：
```py
>>>
5
>>>
```
不像append，len是个普通的函数，而不是一个方法。这意味着它写在列表被调用前，也就不需要写点。
Part题：
这段代码的结果是？
```py
letters = ["a", "b", "c"]
letters.append("d")
print(len(letters))
```
9.3 列表函数（三）
insert方法与append相似，但它允许你在列表的任意位置插入新的一项，而不是只在最后。
```py
words = ["Python", "fun"]
index = 1
words.insert(index, "is")
print(words)
```
结果：
```py
>>>
['Python', 'is', 'fun']
>>>
```
Part题：
这段代码的结果是？
```py
nums = [9, 8, 7, 6, 5]
nums.append(4)
nums.insert(2, 11)
print(len(nums))
```
9.4 列表函数（四）
index方法寻找某一项在列表中第一次出现时的索引，并返回这个索引。
如果项不存在于列表中，就产生一个ValueError。
```py
letters = ['p', 'q', 'r', 's', 'p', 'u']
print(letters.index('r'))
print(letters.index('p'))
print(letters.index('z'))
```
结果：
```py
>>>
2
0
ValueError: 'z' is not in list
>>>
```
对于列表，还有几个有用的函数和方法。
max(list)：返回列表中的最大值
min(list)：返回列表中的最小值
list.count(obj)：统计一项在列表中出现多少次
list.remove(obj)：从列表中移除一项
list.reverse()：将列表中项的顺序反过来
max(list)：返回列表中的最大值
min(list)：返回列表中的最小值
list.count(obj)：统计一项在列表中出现多少次
list.remove(obj)：从列表中移除一项
list.reverse()：将列表中项的顺序反过来
Part题：
选择下面的选项填空，将'z'添加到list的末尾，并输出list的长度。
```py
list.______ ('z')
print( ______ ______ )
```
len (list) insert index append
10 Range
10.1 Range（一）
range函数创建一串序列数字。
下面的代码创建了一个包含0-9整数的列表。
```py
numbers = list(range(10))
print(numbers)
```
结果：
```py
>>>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
```
对list的调用是必须的，因为range自己创建一个range对象，必须转换为列表才能使用。
Part题：
这段代码的结果是？
```py
nums = list(range(5))
print(nums[4])
```
10.2 Range（二）
如果调用range的时候有一个参数，就产生一个包含从0开始直至那个参数的对象。
如果有两个参数，就产生一个包含从第一个参数至第二个参数的对象。
举例：
```py
numbers = list(range(3, 8))
print(numbers)
print(range(20) == range(0, 20))
```
结果：
```py
>>>
[3, 4, 5, 6, 7]
True
>>>
```
Part题：
这段代码的结果是？
```py
nums = list(range(5, 8))
print(len(nums))
```
10.3 Range（三）
range可以有第三个参数，指定了序列中数字的间隔。第三个参数必须是整型。
```py
numbers = list(range(5, 20, 2))
print(numbers)
```
结果：
```py
>>>
[5, 7, 9, 11, 13, 15, 17, 19]
>>>
```
Part题：
这段代码的结果是？
```py
nums = list(range(3, 15, 3))
print(nums[2])
```
A. 0
B. 3
C. 9
D. 12
11 for循环
11.1 循环
有时候需要对列表中的每一项都执行操作。这被称作迭代，可以通过while循环和一个计数变量实现。
举例：
```py
words = ["hello", "world", "spam", "eggs"]
counter = 0
max_index = len(words) - 1
while counter <= max_index:
word = words[counter]
print(word + "!")
counter = counter + 1
```
结果：
```py
>>>
hello!
world!
spam!
eggs!
>>>
```
上面的例子迭代列表中所有的项，通过索引访问值，最后将它加上感叹号输出。
Part题：
哪种结构能用来迭代列表？
A. if语句
B. 循环
C. 变量赋值
11.2 for循环（一）
用while迭代列表需要挺多代码的，所以Python也提供for循环达到相同的目标。
上面的例子可以写成效果等同的下面例子：
```py
words = ["hello", "world", "spam", "eggs"]
for word in words:
print(word + "!")
```
结果：
```py
>>>
hello!
world!
spam!
eggs!
>>>
```
Python中的for循环和其他编程语言中的foreach循环相似。
Part题：
填空创建一个有效的for循环。
```py
letters = ['a', 'b', 'c']
___ l __ letters _
print(l)
```
11.3 for循环（二）
for循环常被用作将代码循环执行一定次数。这样做的方法是将循环和range对象结合起来。
```py
for i in range(5):
print("hello!")
```
结果：
```py
>>>
hello!
hello!
hello!
hello!
hello!
>>>
```
当在for循环中使用range对象时不需要对它调用list，因为不需要将其索引，所以也就不需要转换为列表。
Part题：
填空创建一个for循环，仅输出范围中的偶数。
```py
___ i in range(0, 20, _ ):
print( _ )
```
12 简单计算器
12.1 创建计算器（一）
这一章是关于Python中的一个例程：一个简单的计算器。每一小节解释了程序的不同部分。
第一部分是总体目录，在直到用户输入"quit"前都会一直接受输出，所以需要用到一个while循环。
```py
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"的时候。
break语句用作停止while循环，在这个例子中是当用户输入"quit"的时候。
Part题：
如果将程序中的break语句换成"continue"，会有什么后果？
A. 要输入两次"quit"才能退出
B. 会和原来一样正常运行
C. 会无限运行下去
12.2 创建计算器（二）
程序的下一部分是得到用户想要操作的数字。
下面的代码实现了加法计算，对于其他部分也可以如法炮制。
```py
elif user_input == "add":
num1 = float(input("输入第一个数字："))
num2 = float(input("输入第二个数字："))
```
现在，当用户输入"add"的时候，程序指示用户输入两个数字，并将其存储在对应的变量中。
按这样来看，当指示用户输入的时候得到的不是数字时，程序会崩溃。在之后的模块中我们会学到如何解决这种问题。
Part题：
为什么代码中对float的调用是必要的？
A. 为了删掉输入中的空格
B. 为了将输入转化为浮点数
C. 为了检查输入是不是数字
12.3 创建计算器（三）
程序的最后部分处理用户的输入，并输出。
下面是对于加法部分的代码。
```py
elif user_input == "add":
num1 = float(input("输入第一个数字："))
num2 = float(input("输入第二个数字："))
result = str(num1 + num2)
print("结果是" + result)
```
现在我们已经有了一个能指示用户输入，然后计算，最终显示出和的程序。
对于其他部分（减、乘、除），也要写相似的代码。
输出的那行也可以放在if语句外，这样就可以省略代码中重复的部分。
输出的那行也可以放在if语句外，这样就可以省略代码中重复的部分。
Part题：
填空，使计算器能处理乘法。
```py
elif user_input == "multiply":
num1 = float(input("输入第一个数字："))
num2 = _____(input("输入第二个数字："))
result = str(num1 _ num2)
print("结果是" + ______ )
```
章末检测
1. 这段代码的输出是？
```py
list = [1, 1, 2, 3, 5, 8, 13]
print(list[list[4]])
```
2. 这段代码的作用是？
```py
for i in range(10):
if not i % 2 == 0:
print(i+1)
```
A. 输出0到8之间的所有偶数
B. 输出2到10之间的所有偶数
C. 输出1到9之间的所有奇数
3. 这段代码会输出多少行？
```py
while False:
print("循环中...")
```
A. 0
B. 1
C. ∞
4. 按要求填空：如果列表中有偶数项，就输出其中的第一项。
```py
list = [1, 2, 3, 4]
if ___ (list) % 2 == 0 _
print(list[ _ ])
```
5. 这段代码的输出是？
```py
letters = ['x', 'y', 'z']
letters.insert(1, 'w')
print(letters[2])
```
6. 按要求填空：用for循环迭代列表，并输出列表中的项。
```py
list = [1, 2, 3]
___ var __ list:
print( ___ )
```
在if语句的第三板块.那个课后习题其实有一个你没讲到.就是python恶心扒拉的缩进.因为最下面的一个if在第二个if之下.因为第二个if为假.所以第三个if不执行.所以可能会误导只有第二个if错的从而想到输出3和7