本帖最后由 45gfg9 于 2020-3-20 13:23 编辑

---

Prev: Python3Ⅳ：异常 & 文件
Next: None

2021.12 数据，可能有更多内容

索引贴
答案帖

---

Prev: Python3Ⅳ：异常 & 文件
Next: None



1 None


1.1 None（一）


None对象用来表示值的缺失。
它与其他编程语言中的null类似。
与其他“空”值，例如0、[]和空字符串一样，它在转换为布尔值时为False。
在Python控制台中输入时，它以一个空字符串表示。
```py
>>> None == None
True
>>> None
>>> print(None)
None
>>>
```


Part题：
“None”常用来表示什么？
A. 缺失值
B. 假值
C. 无效值


1.2 None（二）


None会在当函数不显式返回值的时候返回。
```py
def some_func():
print("Hi!")


var = some_func()
print(var)
```
结果：
```py
>>>
Hi!
None
>>>
```


Part题：
下面代码输出什么？
```py
foo = print()
if foo == None:
print(1)
else:
print(2)
```





2 字典


2.1 字典（一）


字典（Dictionaries）是一种用来任意将键（key）映射到值（value）的数据类型。
列表可以想成有确定范围整数键的字典。
字典可以用与列表相同的方式来索引，即包含键的方括号。
例
```py
ages = {"Dave": 24, "Mary": 42, "John": 58}
print(ages["Dave"])
print(ages["Mary"])
```
出
```py
>>>
24
42
>>>
```

字典内每个元素都以键：值对表示。

Part题：
填空创建有两个元素的有效字典。
```py
cars = {"BMW" _ "blue" _ "Volvo": "red" _
```


2.2 字典（二）


尝试索引不属于字典的一个键会返回KeyError。
例
```py
primary = {
"red": [255, 0, 0],
"green": [0, 255, 0],
"blue": [0, 0, 255],
}


print(primary["red"])
print(primary["yellow"])
```
出
```py
>>>
[255, 0, 0]


KeyError: 'yellow'
>>>
```
如你所见，字典可以以任意类型数据作为值。

空字典用{}定义。

Part题：
下面代码的结果是？
```py
test = { }
print(test[0]}
```
A. KeyError
B. None
C. 0


2.3 字典（三）


只有不可变（immutable）对象才能作为字典的键。不可变对象是不能被改变的对象。到现在，你见过所有的可变（mutable）对象只有列表和字典。尝试用可变对象作为字典键会产生TypeError。
```py
bad_dict = {
[1, 2, 3]: "one two three",
}
```
出
```py
>>>
TypeError: unhashable type: 'list'
>>>
```


Part题：
下面哪个不能用作字典的键？
A. "one two three"
B. False
C. {2: 4, 3: 9, 4: 16,}



3 字典函数


3.1 字典（四）


与列表相似，字典的键也可以被赋值。
但字典不像列表的是，一个新的键也可以被赋值，而不是只能赋给存在的键。
```py
squares = {1: 1, 2: 4, 3: "error", 4: 16,}
squares[8] = 64
squares[3] = 9
print(squares)
```
出
```py
{1: 1, 2: 4, 3: 9, 4: 16, 8: 64}
```


Part题：
下面代码的输出是？
```py
primes = {1: 2, 2: 3, 4: 7, 7: 17}
print(primes[primes[4]])
```


3.2 字典（五）


若要确定一个字典里是否含某个键，可以用in和not in，就像用在列表上一样。
例
```py
nums = {
1: "one",
2: "two",
3: "three",
}
print(1 in nums)
print("three" in nums)
print(4 not in nums)
```
出
```py
>>>
True
False
True
>>>
```


Part题：
用选项填空，如果"pairs"字典中有112为键，就输出"Yes"。
```py
if ______ ______ ______:
print("Yes")
```
`pairs  print  in  112  not  if`


3.3 字典（六）


一个有用的字典方法是get。它与索引干同样的事，但如果字典中找不到键，它会返回另一个指定的值（默认是None）。
例
```py
pairs = {1: "apple",
"orange": [2, 3, 4],
True: False,
None: "True",
}


print(pairs.get("orange"))
print(pairs.get(7))
print(pairs.get(12345, "not in dictionary"))
```
出
```py
>>>
[2, 3, 4]
None
not in dictionary
>>>
```


Part题：
下面代码的结果是？
```py
fib = {1: 1, 2: 1, 3: 2, 4: 3}
print(fib.get(4, 0) + fib.get(7, 5))
```





4 元组


4.1 元组（一）


元组（Tuples）与列表很相似，除了它们是不可变的。还有，它们是用圆括号而不是方括号创建的。
例
```py
words = ("spam", "eggs", "sausages",)
```
你可以索引元组的值，与列表一样：
```py
print(words[0])
```
尝试给元组元素重新赋值会产生TypeError。
```py
words[1] = "cheese"
```
出
```py
>>>
TypeError: 'tuple' object does not support item assignment
>>>
```

与列表和字典相似，元组可以嵌套。

Part题：
填空分别创建列表、字典和元组。
```py
# 列表
list = _ "one", "two" _


# 字典
dict = _ 1:"one", 2:"two" _


# 元组
tp = _ "one, "two" _
```


4.2 元组（二）


元组可以不用括号，只要将值用逗号分隔来创建。
```py
my_tuple = "one", "two", "three"
print(my_tuple[0])
```
出
```py
>>>
one
>>>
```
空的元组可以用一对空的圆括号创建。
```py
tpl = ()
```

元组比列表效率更高，但不能被改变。

Part题：
下面代码的结果是？
```py
tuple = (1, (1, 2, 3))
print(tuple[1])
```
A. (1, 2, 3)
B. 1
C. ((1, 2, 3))





5 列表切片


5.1 列表切片（一）


列表切片（List slices）提供了一种更高级的从列表中取值的方法。基本的列表切片涉及到用两个冒号分隔的整数索引列表。这会返回一个新的列表，包含以前列表中两个索引中间的所有值。
```py
squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares[2:6])
print(squares[3:8])
print(squares[0:1])
```
出
```py
>>>
[4, 9, 16, 25]
[9, 16, 25, 36, 49]
[0]
>>>
```

与range的参数类似，切片中包含第一个索引，但不包含第二个。

Part题：
下面代码的结果？
```py
sqs = [0, 1, 4, 9, 16, 25, 36, 49, 64]
print(sqs[4:7])
```
A. [25, 36, 49]
B. [16, 25, 36]
C. [16, 25, 36, 49]


5.2 列表切片（二）


如果略去切片中第一个数，会从列表起始切片。
如果略去第二个数，会切片至列表末尾。
例
```py
squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares[:7])
print(squares[7:])
```
出
```py
>>>
[0, 1, 4, 9, 16, 25, 36]
[49, 64, 81]
>>>
```

元组也可以切片。

Part题：
填空，取列表的前两个值。
```py
list = ["a", "b", "c", "d"]
a = list[0 __ ]
```


5.3 列表切片（三）


列表切片也可以有第三个数，指定步进数，只包括切片中间隔的值。
```py
squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares[::2])
print(squares[2:8:3])
```
出
```py
>>>
[0, 4, 16, 36, 64]
[4, 25]
>>>
```

[2:8:3]在第二个到第八个元素中每隔两个元素取一个。

Part题：
下面代码的输出？
```py
sqs = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(sqs[1::4])
```
A. 出错
B. [1, 25, 81]
C. [0, 1, 4]
D. [1, 25]


5.4 列表切片（四）


负数也可以用于列表切片（和普通的列表索引）。当负数用在切片索引的第一个或第二个数时，会从列表末尾算起。
```py
squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares[1:-1])
```
出
```py
>>>
[1, 4, 9, 16, 25, 36, 49, 64]
>>>
```

如果用负数作为步进值，那么切片从后往前完成。
用[::-1]切片是一种常用且地道的将列表倒序的方法。

Part题：
下面代码输出？
```py
sqs = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(sqs[7:5:-1])
```
A. []
B. [49, 36]
C. [49]



6 列表推导式


6.1 列表推导式（一）


列表推导式（List comprehension）是一种有用且快捷的创建那种值遵循某个简单规律的列表。
举例，我们可以这样做：
```py
# 一个列表推导式
cubes = [i**3 for i in range(5)]


print(cubes)
```
出
```py
>>>
[0, 1, 8, 27, 64]
>>>
```

列表推导式的灵感来源于数学中的集合建构式符号（set-builder notation）。

Part题：
下面这个列表推导式会产生什么？
```py
nums = [i*2 for i in range(10)]
```
A. 一个有0-10之间所有偶数的列表
B. 一个有0-18之间所有偶数的列表
C. 一个有0-10之间所有数字的列表


6.2 列表推导式（二）


列表推导式也可以包含if语句，确保列表中的元素都符合条件。
例
```py
evens=[i**2 for i in range(10) if i**2 % 2 == 0]


print(evens)
```
出
```py
>>>
[0, 4, 16, 36, 64]
>>>
```


Part题：
创建一个包含0-20内3的倍数的列表。
```py
a = _ i for i in range(20) __ i% _ ==0]
```


6.3 列表推导式（三）


尝试用列表推导式创建一个非常大的列表会产生MemoryError。
下面代码展示列表推导式用尽内存的情况。
```py
even = [2*i for i in range(10**100)]
```
出
```py
>>>
MemoryError
>>>
```

这个问题可以用生成器（generators）解决，在下一模块讲。

Part题：
填空创建一个5-9范围内数字乘10的列表。
```py
a = [x*10 ___ x __ range( _ , 9)]
```





7 字符串格式化


7.1 字符串格式化（一）


到现在，要想将字符串与非字符串合并，你需要先转换为字符串再相加。
字符串格式化提供了一种更强大的方法，能将非字符串嵌入字符串。字符串格式化用到字符串的format方法来替换字符串中的参数。
例
```py
# 字符串格式化
nums = [4, 5, 6]
msg = "Numbers: {0} {1} {2}". format(nums[0], nums[1], nums[2])
print(msg)
```
出
```py
>>>
Numbers: 4 5 6
>>>
```

format函数中每个实参都对应字符串中的一个位置，由花括号{ }指定。

Part题：
下面代码的结果？
```py
print("{0}{1}{0}".format("abra, "cad"))
```


7.2 字符串格式化（二）


字符串故事也可用命名参数完成。
例
```py
a = "{x}, {y}".format(x=5, y=12)
print(a)
```
出
```py
>>>
5, 12
>>>
```


Part题：
下面代码的输出？
```py
str="{c}, {b}, {a}".format(a=5, b=9, c=7)
print(str)
```
A. 5, 9, 7
B. 9, 7, 5
C. 7, 9, 5



8 一些有用的函数


8.1 字符串函数


Python包含许多有用的内置函数和方法来完成常见任务。
join - 将一列表的字符串以另一个字符串为分隔符合并。
replace - 将一个字符串的子串用另一个字符串替换。
startswith和endswith - 判断字符串是否以一个子串开始或结束。
要改变字符串的大小写，你可以用lower和upper。
split方法与join相反，将一个字符串以某分隔符分割成列表。
举一些例：
```py
print(", ".join(["spam", "eggs", "ham"]))
#输出 "spam, eggs, ham"


print("Hello ME".replace("ME", "world"))
#输出 "Hello world"


print("This is a sentence.".startswith("This"))
# 输出 "True"


print("This is a sentence.".endswith("sentence."))
# 输出 "True"


print("This is a sentence.".upper())
# 输出 "THIS IS A SENTENCE."


print("AN ALL CAPS SENTENCE".lower())
#输出 "an all caps sentence"


print("spam, eggs, ham".split(", "))
#输出 "['spam', 'eggs', 'ham']"
```


Part题：
填空将字符串转大写。
```py
a = "Spam"
b = a._____()
```


8.2 数字函数


用max或min函数确定列表中的最大值或最小值。
用abs计算一个数字与0的距离（绝对值）。
用round将一个数字舍入到某个确定的小数位。
用sum计算列表的总和。
举一些例：
```py
print(min(1, 2, 3, 4, 0, 2, 1))
print(max([1, 4, 9, 2, 5, 6, 8]))
print(abs(-99))
print(abs(42))
print(sum([1, 2, 3, 4, 5]))
```
出
```py
>>>
0
9
99
42
15
>>>
```


Part题：
下面代码的输出是？
```py
a=min([sum([11, 22]), max(abs(-30), 2)])
print(a)
```


8.3 列表函数


在条件语句中常常用到的有all和any，它们分别检测是否所有的元素都算为True和是否至少有一个元素算为True。
enumerate函数可以用来同时遍历列表的索引和值。
例
```py
nums = [55, 44, 33, 22, 11]


if all([i > 5 for i in nums]):
   print("All larger than 5")


if any([i % 2 == 0 for i in nums]):
   print("At least one is even")


for v in enumerate(nums):
   print(v)
```
出
```py
>>>
All larger than 5
At least one is even
(0, 55)
(1, 44)
(2, 33)
(3, 22)
(4, 11)
>>>
```


Part题：
下面代码的输出是？
```py
nums = [-1, -2, -3, -4, -5]
if all([abs(i) < 3 for i in nums]):
print(1)
else:
print(2)
```





9 文本分析器


9.1 文本分析器


接下来是一个示例项目，此程序可以分析一个范例文件，找出每个字符在文本中出现的百分比。
这一节展示如何打开并读取文件。
```py
filename = input("Enter a filename: ")


with open(filename) as f:
   text = f.read()


print(text)
```
出
```py
>>>
Enter a filename: test.txt
Ornhgvshy vf orggre guna htyl.
Rkcyvpvg vf orggre guna vzcyvpvg.
Fvzcyr vf orggre guna pbzcyvpngrq.
Syng vf orggre guna arfgrq.
Fcenfr fv orggre guna qrafr.
Ernqnovyvgl pbhagf.
Fcrpvny pnfrf nera'g fcrpvny rabthu gb oernx gur ehyrf.
Nygubhtu cenpgvpnyvgl orgnf chevgl.
Reebef fubhyq arire cnff fvyragyl.
Hayrff rkcyvpvgyl fvyraprq.
Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba bg thrff.
Gurer fubhyq or bar-- naq cersrenoylbayl bar --boivbhf jnl gb qb vg.
Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu.
Abj vf orggre guna arrire.
Nygubhtu arire vf bsgra orggre guna *evtug* abj.
Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn.
Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.
Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!
```

这只是一个用于演示用途的样例内容。

Part题：
填空用with语句读取文件内容。
```py
____ open(filename) __ f:
text = f.read()
```


9.2 文本分析器（二）


这部分程序展示一个能统计字符在字符串中出现次数的函数。
```py
def count_char(text, char):
count = 0
for c in text:
    if c == char:
   count += 1
return count
```
这个函数的参数是文件的文本和一个字符，返回的是文本中字符出现的次数。
接下来我们可以对文件内容调用它了。
```py
filename = input("Enter a filename: ")
with open(filename) as f:
text = f.read()


print(count_char(text, "r"))
```
出
```py
>>>
Enter a filename: test.txt
83
>>>
```

字符"r"在文件中出现了83次。

Part题：
为什么要将字符计数代码放在函数中？
A. 这样就能读取文件了
B. 这样就能复用了
C. 这样就能跑得更快了


9.3 文本分析器（三）


程序的下一部分是按字母表顺序找出每个字母出现频率的占比。
```py
for char in "abcdefghijklmnopqrstuvwxyz":
perc = 100 * count_char(text, char) / len(text)
print("{0} - {1}%".format(char, round(perc, 2)))
```
让我们组合在一起运行程序：
```py
def count_char(text, char):
count = 0
for c in text:
    if c == char:
   count += 1
return count


filename = input("Enter a filename: ")
with open(filename) as f:
text = f.read()


for char in "abcdefghijklmnopqrstuvwxyz":
perc = 100 * count_char(text, char) / len(text)
print("{0} - {1}%".format(char, round(perc, 2)))
```
出
```
Enter a filename: test.txt
a - 4.68%
b - 4.94%
c - 2.28%
...
```


Part题：
上面代码中round函数的作用是？
A. 减少输出的小数位数
B. 使输出更精确
C. 节省内存



模块测试


1. 元组能切片吗？


2. 下面哪个切片会反向排序列表numbers？
A. numbers[::-1]
B. numbers[::]
C. numbers[-1::]


3. 下面哪个可以描述为“不可变的列表”？
A. 元组
B. 字典
C. 数字


4. 无return语句的函数会返回什么？
A. 0
B. False
C. None


5. 下面代码的输出是？
```py
nums = (55, 44, 33, 22)
print(max(min(nums[:2]), abs(-42)))
```

45又翻新教程了 爽啦
你坛就我什么也不会了罢

可惜我都已经学过了。最开始是抱着试试看的心理看完了楼主的所有文章，后来感到非常失望。

虽然mcbbs不是很支持大家发教程贴，但我还是来看一下编程教程
虽然我是一个c语言学生，python一窍不通

格式化字符串用3.6的f-strings不好吗

好，而且建议使用f-strings

但本教程是译作，原教程没有用f-strings

目前推测原教程应该是3.4或以下

因为这里没有async/await（3.5），没有f-strings（3.6），没有:=（3.8）

        MCBBS有你更精彩~