第八章 列表与字典类型

列表

列表的属性：

• 任意对象的有序集合；
• 通过偏移访问；
• 可变长度、异构以及任意嵌套；
• 属于“可变序列”的分类；
• 对象引用数组；

列表的实际应用

基本列表操作

列表的拼接（+）

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

列表重复（*）

>>> ["NI"] * 4
['NI', 'NI', 'NI', 'NI']

列表转换为字符串 str()

>>> str([1, 2]) + "34"
'[1, 2]34'

字符串转换为列表 list()

>>> [1, 2] + list("34")
[1, 2, '3', '4']

列表迭代和推导

列表迭代

>>> for i in [1, 2, 3]:
...     print(i)
... 
1
2
3

列表推导（列表生成式）

>>> res = [c * 4 for c in "SPAM"]
>>> 
>>> res
['SSSS', 'PPPP', 'AAAA', 'MMMM']

内置函数map()实现迭代

>>> list(map(abs, [-1, -2, -3, -4]))
[1, 2, 3, 4]

索引、分片和矩阵

索引

# list[index]
>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L[2]
'SPAM'

分片

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L[1:]
['Spam', 'SPAM']

矩阵

在列表中嵌套列表，构成矩阵数据类型；
特别注意元素索引时的用法；

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix[0]
[1, 2, 3]
>>> matrix[0][1]
2
>>> 
>>> matrix = [[1, 2, 3],]
>>> 
>>> matrix = [[1, 2, 3],
...           [4, 5, 6],
...           [7, 8, 9]]
>>> 
>>> matrix[1][1]
5

原位置修改列表

由于列表是可变的，它们支持原位置改变列表对象的操作。也就是有些操作直接修改列表对象；

索引与分片的赋值

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L[1] = "eggs"
>>> 
>>> L
['spam', 'eggs', 'SPAM']
>>>
>>> L[0:2] = ["eat", "more"]
>>> 
>>> L
['eat', 'more', 'SPAM']

因为被赋值的序列长度不一定要与被赋值的分片的长度相匹配，所以分片赋值能够用来替换（覆盖）、增长（插入）、缩短（删除）主体列表。

列表头部原位的一种拼接方式 extend()方法

>>> L = [1, 2, 3]
>>> 
>>> L.extend([4, 5, 6])
>>> L
[1, 2, 3, 4, 5, 6]

列表末尾增加一个元素 append()

>>> L = [1, 2, 3]
>>> 
>>> L.append(4)
>>> 
>>> L
[1, 2, 3, 4]

列表排序 sort()

>>> L = ["a", "e", "r", "y", "q"]
>>> 
>>> L.sort()
>>> L
['a', 'e', 'q', 'r', 'y']
>>> 
>>> L.sort(reverse=True)
>>> L
['y', 'r', 'q', 'e', 'a']
>>> L.sort(reverse=False)
>>> L
['a', 'e', 'q', 'r', 'y']

列表排序，并返回一个新的结果对象 sorted()

>>> L = ["a", "e", "r", "y", "q"]
>>> 
>>> sorted(L)
['a', 'e', 'q', 'r', 'y']
>>> 
>>> L
['a', 'e', 'r', 'y', 'q']

原位置反转列表 reverse()

>>> L = [2, 4, 1, 6]
>>> L.reverse()
>>> L
[6, 1, 4, 2]

反转列表并返回新的结果，迭代器结果 reverse()

>>> L = ["a", "e", "r", "y", "q"]
>>> reversed(L)
<list_reverseiterator object at 0x1074d0b90>
>>> 
>>> L
['a', 'e', 'r', 'y', 'q']
>>>
>>>
>>> list(reversed(L))
['q', 'y', 'r', 'e', 'a']

删除末端元素并返回所删除的元素 pop()

>>> L = [2, 4, 1, 6]
>>> 
>>> L.pop()
6

查找某元素的偏移 list.index()

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L.index("Spam")
1

通过值删除元素 remove()

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L.remove("spam")
>>> L
['Spam', 'SPAM']

指定位置插入元素 insert()

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> L.insert(1, "toast")
>>> L
['spam', 'toast', 'Spam', 'SPAM']

原位置删除某项或片段 del()

>>> L = ["spam", "Spam", "SPAM"]
>>> 
>>> del L[0]
>>> L
['Spam', 'SPAM']

获得列表的长度 len()

>>> L = ["spam", "Spam", "SPAM"]
>>> len(L)
3

返回列表的最大元素 max()

>>> L = ["a", "e", "r", "y", "q"]
>>> 
>>> max(L)
'y'
>>> 
>>> L = [2, 4, 1, 6]
>>> max(L)
6

返回列表的最小元素 min()

>>> L = ["a", "e", "r", "y", "q"]
>>> min(L)
'a'
>>> 
>>> L = [2, 4, 1, 6]
>>> min(L)
1

统计某个元素在列表中出现的次数 count()

>>> L = [2, 4, 1, 6, 2, 3, 2]
>>> 
>>> L.count(2)
3

清空列表 clear()

>>> L = [2, 4, 1, 6, 2, 3, 2]
>>> L.clear()
>>> L
[]

字典

字典的属性：

• 通过键而不是偏移量来读取；
• 任意对象的无序集合；
• 长度可变、异构、任意嵌套；
• 属于“可变映射”类型；
• 对象引用表（散列表）；

字典的基本操作

创建及访问其中元素

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D["spam"]
2

获得字典中元素的个数 len(list)

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> len(D)
3

获得字典key的列表 keys()

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D.keys()
dict_keys(['spam', 'ham', 'eggs'])
>>> 
>>> list(D.keys())
['spam', 'ham', 'eggs']

字典中增加元素

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D["new_ele"] = "4"
>>> 
>>> D
{'spam': 2, 'ham': 1, 'eggs': 3, 'new_ele': '4'}

修改字典中的元素

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D["ham"] = 4
>>> 
>>> D
{'spam': 2, 'ham': 4, 'eggs': 3}

其他字典方法

获得字典中的所有值的列表 values()

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D.values()
dict_values([2, 1, 3])
>>> 
>>> list(D.values())
[2, 1, 3]

获得（key, value）对元组 items()

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D.items()
dict_items([('spam', 2), ('ham', 1), ('eggs', 3)])
>>> 
>>> list(D.items())
[('spam', 2), ('ham', 1), ('eggs', 3)]

读取字典元素的方法 get()

我们使用普通方法读取字典中的值时，当值不存在时系统会报错。但使用get()方法时可以避免这一种错误的发生,当键不存在时返回None；

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D["egg"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'egg'
>>> 
>>> D.get("egg")
>>> print(D.get("egg"))
None

同时可以指定默认值；

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D.get("egg", 88)
88

字典拼接 update()

>>> D = {"spam": 2, "ham": 1, "eggs": 3}
>>> 
>>> D1 = {"toast": 4, "muffin": 5}
>>> 
>>> D.update(D1)
>>> 
>>> D
{'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}

删除字典中某个指定key的元素，并返回key对应的值 pop(key)

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}
>>> 
>>> D.pop("muffin")
5
>>> D
{'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4}

使用for循环迭代字典中的键

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}
>>> 
>>> 
>>> for key in D:
...     print(key)
... 
spam
ham
eggs
toast
muffin

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}
>>> for key in D.keys():
...     print(key)
... 
spam
ham
eggs
toast
muffin

字典用法注意事项

在使用字典时，有几点需要注意：

• 序列运算无效；
• 对新索引赋值会添加项；
• 键不一定总是字符串；

用字典模拟灵活的列表：整数键

>>> L = []
>>> L[99] = "spam"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> 
>>> D = {}
>>> 
>>> D[99] = "spam"
>>> 
>>> D[99] 
'spam'

对稀疏数据结构使用字典：用元组作键

>>> Matrix = {}
>>> Matrix[(1, 2, 3)] = 88
>>> Matrix[(3, 4, 5)] = 99
>>> 
>>> x = 1; y = 2; z = 3
>>> Matrix[(x, y, z)]
88

避免键不存在错误

>>> Matrix = {}
>>> Matrix[(1, 2, 3)] = 88
>>> Matrix[(3, 4, 5)] = 99
>>> 
>>> Matrix
{(1, 2, 3): 88, (3, 4, 5): 99}
>>> 
>>> if (1, 2, 3) in Matrix:
...     print(Matrix[1, 2, 3])
... else:
...     print(0)
... 
88

>>> Matrix = {}
>>> Matrix[(1, 2, 3)] = 88
>>> Matrix[(3, 4, 5)] = 99
>>> 
>>> Matrix
{(1, 2, 3): 88, (3, 4, 5): 99}
>>> 
>>> try:
...     print(Matrix[1, 2, 3])
... except KeyError:
...     print(0)
... 
88

>>> Matrix = {}
>>> Matrix[(1, 2, 3)] = 88
>>> Matrix[(3, 4, 5)] = 99
>>> 
>>> Matrix
{(1, 2, 3): 88, (3, 4, 5): 99}
>>> 
>>> Matrix.get((2, 3, 4), 0)
0

创建字典的其他方式

D = {"name": "Bob", "age": 40}

D = {"cto": {"name": "Bob", "age": 40}}

D = dict("name"="Bob", "age"=40)

D = dict([("name", "Bob"), ("age", 40)])

D = dict(zip(keyslist, valueslist))

>>> D = dict.fromkeys(["a", "b"], 0)
>>> D
{'a': 0, 'b': 0}