暑期实践第十二天 2022-7-15

今日学习进度：序列，字典相关

1.all()和any()函数

all()函数函数是判断可迭代对象中是否所有元素的值都为真

any()函数则是判断可迭代对象中是否存在某个元素的值为真。

>>> x = [1, 1, 0]
>>> y = [1, 1, 9]
>>> all(x)
False
>>> all(y)
Ture
>>> any(x)
True
>>> any(y)
True

2.enumerate()函数

用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组的列表：

>>> seasons = ["Spring", "Summer", "Fall", "Winter"]
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

它有一个 start 参数，可以自定义序号开始的值：

>>> for i, j in enumerate(seasons, start=10):
...     print(i, "->", j)
... 
10 -> Spring
11 -> Summer
12 -> Fall
13 -> Winter

3，zip()函数

zip()函数用于创建一个聚合多个可迭代对象的迭代器。

做法是将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第 i 个元组包含来自每个参数的第 i 个元素。

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> z = [7, 8, 9]
>>> zipped = zip(x, y, z)
>>> list(zipped)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

如果传入的可迭代对象长度不一致，那么将会以最短的那个为准

>>> z = "Hello"
>>> zipped = zip(x, y, z)
>>> list(zipped)
[(1, 4, 'H'), (2, 5, 'e'), (3, 6, 'l')]

我们不关心较长的可迭代对象多出的数据时，使用 zip() 函数无疑是最佳的选择，因为它自动裁掉多余的部分。

但是，如果那些值对于我们来说是有意义的，我们可以使用 itertools 模块的 zip_longest() 函数来代替：

>>> import itertools
>>> zipped = itertools.zip_longest(x, y, z)
>>> list(zipped)
[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's'), (None, None, 'h'), (None, None, 'C')]

4.map()函数

会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器：

>>> mapped = map(ord, "FishC")
>>> list(mapped)
[70, 105, 115, 104, 67]

如果指定的函数需要两个参数，后面跟着的可迭代对象的数量也应该是两个：

>>> mapped = map(pow, [2, 3, 10], [5, 2, 3]))
>>> list(mapped)
[32, 9, 1000]

如果可迭代对象的长度不一致，那么 Python 采取的做法跟 zip() 函数一样，都是在最短的可迭代对象终止时结束

>>> list(map(max, [1, 3, 5], [2, 2, 2], [0, 3, 9, 8]))
[2, 3, 9]

5.filter()函数

与 map() 函数类似，filter()函数也是需要传入一个函数作为参数，不过 filter() 函数是根据提供的函数，对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回:

>>> filter(str.islower, "Hello")
<filter object at 0x000001B5170FEFA0>

上面代码我们传入的是字符串的 islower() 方法，作用就是判断传入的参数是否为小写字母，结合到 filter() 函数中使用，就是剔除大写字母，保留小写字母的作用。

如果提供的函数是 None，则会假设它是一个 “鉴真” 函数，即可迭代对象中所有值为假的元素会被移除：

>>> list(filter(None, [True, False, 1, 0]))
[True, 1]

6.可迭代对象与迭代器的最大差别：

可迭代对象可以对其进行重复的操作，而迭代器则是一次性的

将可迭代对象转换为迭代器：iter() 函数。

通过 type() 函数，我们可以观察到这个区别：

>>> type(x)
<class 'list'>
>>> type(y)
<class 'list_iterator'>

最后，BIF 里面有一个 next() 函数，它是专门针对迭代器的。

它的作用就是逐个将迭代器中的元素提取出来：

>>> next(y)
1
>>> next(y)
2
>>> next(y)
3
>>> next(y)
4
>>> next(y)
5
>>> next(y)
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    next(y)
StopIteration

现在如果不想它抛出异常，那么可以给它传入第二个参数：

>>> z = iter(x)
>>> next(z, "无")
1
>>> next(z, "无")
2
>>> next(z, "无")
3
>>> next(z, "无")
4
>>> next(z, "无")
5
>>> next(z, "无")
'无'

7.创建字典的方法

总共有六种：

a = {"A":"AS", "B":"BE", "C":"CAN"}
b = dict(A="AS", B="BE", C="CAN")
c = dict([("A", "AS"), ("B", "BE"), ("C", "CAN")])
d = dict({"A":"AS", "B":"BE", "C":"CAN"})
e = dict({"A":"AS", "B":"BE"}, C="CAN")
f = dict(zip(["A", "B", "C"], ["AS", "BE", "CAN"]))
a == b == c == d == e == f
True

8.增加字典方法

首先是 fromkeys(iterable[, value]) 方法，这个可以算是字典中最特殊的方法，它可以使用 iterable 参数指定的可迭代对象来创建一个新字典，并将所有的值初始化为 value 参数指定的值：

d = dict.fromkeys("ASCII", 250)
d
{'A': 250, 'S': 250, 'C': 250, 'I': 250}

如果不指定 value 参数，则采用默认值 None：

d = dict.fromkeys("ASCII")
d
{'A': None, 'S': None, 'C': None, 'I': None}

如果需要修改某个键的值，这么做：

d['A'] = 'as'
d
{'A': 'as', 'S': None, 'C': None, 'I': None}

如果在字典中找不到对应的键，那么同样的操作就会变成增加一个新的键值对

9.删除字典的方法

删除字典中的指定元素我们可以使用 pop() 方法：

d.pop('A')
'as'
d
{'S': None, 'C': None, 'I': None}

如果 pop() 一个不存在的键，那么会抛出异常，可以指定一个 default 参数：

d.pop('E', "没有")
'没有'

跟 pop() 方法类似的还有一个 popitem()，在 Python3.7 之前，它是随机删除一个键值对，在 Python3.7 之后，它删除的是最后一个加入字典的键值对：

d.popitem()
('I', None)
d
{'S': None, 'C': None}

然后 del 关键字也可以删除一个指定的字典元素，如果 del 直接加上字典的变量名就是将整个字典删除

如果我们只希望清空字典中的内容，可以使用 clear() 方法：

d.clear()
d
{}

如果我们想要同时修改多个键值对，我们可以使用字典的 update() 方法，可以同时给它传入多个键值对，也可以直接给它传入另外一个字典，或者一个包含键值对的可迭代对象：

>>> d.update({'i':105, 'h':104})
>>> d
{'F': None, 'i': 105, 's': 115, 'h': 104, 'C': None}
>>> d.update(F='70', C='67')
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}

10.查找方法：

最简单的查方法就是你给它一个键，它返回你对应的值，如果指定的键不存在于字典中，那么会报错，这在有些时候会被认为是用户体验不佳的表现，所以更好的方法是使用 get() 方法，它可以传入一个 default 参数，指定找不到键时返回的值：
 

>>> d.get('c', "这里没有c")
'这里没有c'

还有一种情况是我们需要查找一个键是否存在于字典中，如果在，返回它对应的值；如果不在，给它指定一个新的值：

>>> d.setdefault('C', "code")
67
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}
>>> d.setdefault('c', "code")
'code'
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'c': 'code'}

对比前面直接复制的操作，这么做的一个显而易见的好处就是不会破坏到已经存在的键值对。

11.视图对象：

items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象。
 

>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'c': 'code'}
>>> items = d.items()
>>> keys = d.keys()
>>> values = d.values()
>>> items
dict_items([('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67), ('c', 'code')])
>>> keys
dict_keys(['F', 'i', 's', 'h', 'C', 'c'])
>>> values
dict_values([70, 105, 115, 104, 67, 'code'])
>>> d.pop('c')
'code'
>>> items
dict_items([('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67)])
>>> keys
dict_keys(['F', 'i', 's', 'h', 'C'])
>>> values
dict_values([70, 105, 115, 104, 67])

为了方便地实现浅拷贝，字典也提供了一个 copy() 方法：

>>> e = d.copy()
>>> e
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}

12.

使用 len() 函数来获取字典的键值对数量

>>> len(d)
5

使用 in 和 not in 来判断某个键是否存在于字典中：

>>> 'C' in d
True
>>> 'c' not in d
True

字典也可以转化为列表，使用 list() 函数就可以了

>>> list(d)
['F', 'i', 's', 'h', 'C']

list(d) 得到的是字典中所有的 “键” 构成的列表，要得到所有的 “值”，应该使用 list(d.values())：

>>> list(d.values())
[70, 105, 115, 104, 67]

那么 iter() 函数也可以作用于字典，它会将字典的键构成一个迭代器：

>>> e = iter(d)
>>> next(e)
'F'
>>> next(e)
'i'
>>> next(e)
's'
>>> next(e)
'h'
>>> next(e)
'C'
>>> next(e)
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    next(e)
StopIteration

在 Python3.8 之后的版本中，可以使用 reversed() 函数对字典内部的键值对进行逆向操作：

>>> list(reversed(d))
['C', 'h', 's', 'i', 'F']

可以看出，reversed(d) 其实相当于 reversed(d.keys()) 的缩写，那么如果我们想要获得值的逆向序列，可以这么做：

>>> list(reversed(d.values()))
[67, 104, 115, 105, 70]

13.嵌套

字典也是可以嵌套的

>>> d = {"吕布": {"语文":60, "数学":70, "英语":80}, "关羽": {"语文":80, "数学":90, "英语":70}}

如果想要获取吕布的数学成绩，那么就需要进行两次索引：

>>> d["吕布"]["数学"]
70

那嵌套的也可以是一个列表：

>>> d = {"吕布": [60, 70, 80], "关羽": [80, 90, 70]}

第二次索引，我们当然也得换成下标索引：
 

>>> d["吕布"][1]
70

14.字典推导式

c = {v:k for k, v in d.items()}
c
{1: 'A', 10: 'B', 20: 'C', 30: 'D'}
e = {v:k for v, k in d.items()}
e
{'A': 1, 'B': 10, 'C': 20, 'D': 30}

注意for 变量的顺序决定哪个变量是键哪个是值，前者是键，后者是值

当然，我们也可以加上筛选的条件：

e = {v:k for v, k in d.items() if k < 25}
e
{'A': 1, 'B': 10, 'C': 20}

利用字典推导式，我们就可以轻易地让 Python 帮你求出字符串的编码值

>>> d = {x:ord(x) for x in "FishC"}
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}