目录
字典
-
定义
python中唯一实现映射关系的内置类型；
字典的关键符号是大括号（{}）和冒号（:）
##创建词典的6种方法
>>> a = {'一周':'7天','一天':'24小时','一小时':'60分钟'}
>>>
>>> b = dict(一周='7天',一天='24小时',一小时='60分钟')
>>>
##使用列表作为参数，列表中的每个元素是使用元组包裹起来的键值对
>>> c = dict([('一周','7天'), ('一天','24小时'), ('一小时','60分钟')])
>>>
>>> d = dict({'一周':'7天','一天':'24小时','一小时':'60分钟'})
>>>
>>> e = dict({'一周':'7天','一天':'24小时'},一小时='60分钟')
>>>
>>> f = dict(zip(['一周','一天','一小时'],['7天','24小时','60分钟']))
>>>
>>> a == b == c == d == e ==f
True
>>> -
增、删、改、查
1、增
fromkeys(iterable[, value]) ：这个可以算是字典中最特殊的方法，它可以使用 iterable 参数指定的可迭代对象来创建一个新字典，并将所有的值初始化为 value 参数指定的值；如果不指定 value 参数，则采用默认值 None；
>>> x = dict.fromkeys('Hello')
>>> x
{'H': None, 'e': None, 'l': None, 'o': None}
>>> x = dict.fromkeys('Hello',1)
>>> x
{'H': 1, 'e': 1, 'l': 1, 'o': 1}
##如果修改在字典中找不到对应的键，那么同样的操作就会变成增加一个新的键值对放在最后面
>>> x['p'] = 2
>>> x
{'H': 0, 'e': 1, 'l': 1, 'o': 1, 'p': 2}
>>> 2、删
pop()：可以删除字典中的指定元素；如果 pop() 一个不存在的键，那么会抛出异常，如果想不触发异常，可以指定一个 default 参数；
>>> x
{'H': 0, 'e': 1, 'l': 1, 'o': 1, 'p': 2}
>>>
>>> x.pop('p')
2
>>> x
{'H': 0, 'e': 1, 'l': 1, 'o': 1}
>>> x.pop('p')
Traceback (most recent call last):
File "<pyshell#39>", line 1, in <module>
x.pop('p')
KeyError: 'p'
>>> x.pop('p','输入的值不存在，请确认')
'输入的值不存在，请确认'
>>>popitem()：在 Python3.7 之前，它是随机删除一个键值对，在 Python3.7 之后，它删除的是最后一个加入字典的键值对；
>>> x
{'H': 0, 'e': 1, 'l': 1, 'o': 1}
>>> x.popitem()
('o', 1)
>>> del 关键字也可以删除一个指定的字典元素
>>> x
{'H': 0, 'e': 1, 'l': 1}
>>> del x['l']
>>> x
{'H': 0, 'e': 1}
>>> clear() ：清空字典中的内容；
>>> x
{'H': 0, 'e': 1}
>>> x.clear()
>>> x
{}
>>> 3、改
update() ：可以同时给它传入多个键值对，也可以直接给它传入另外一个字典，或者一个包含键值对的可迭代对象；
##修改单个方法
>>> x = dict.fromkeys('Hello',1)
>>> x
{'H': 1, 'e': 1, 'l': 1, 'o': 1}
>>> x['H'] = 0
>>> x
{'H': 0, 'e': 1, 'l': 1, 'o': 1}
>>> x = dict.fromkeys('Hello',)
>>> x
{'H': None, 'e': None, 'l': None, 'o': None}
>>> x.update({'H':10,'e':20})——>第一种
>>> x
{'H': 10, 'e': 20, 'l': None, 'o': None}
>>> x.update(l=30,o='40')——>第二种
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40'}
>>>
>>> x.update([('H',1),('e',2)])——>第三种
>>> x
{'H': 1, 'e': 2, 'l': 30, 'o': '40'}
>>>
##字典是基于散列表实现的，由于 “键的值如果相等，哈希值就必须一致” 的原理，所以 1.0 和 1 在字典中认为是同一个键，对同一个键进行重复赋值，Python 会用新的值去覆盖旧的值
>>> x[1] = 'python'
>>> x
{'H': 1, 'e': 1, 'l': 1, 'o': 1, 1: 'python'}
>>> x[1.0] = 'hello'
>>> x
{'H': 1, 'e': 1, 'l': 1, 'o': 1, 1: 'hello'}
>>> 4、查
get() ：它可以传入一个 default 参数，指定找不到键时返回的值；
setdefault()：查找一个键是否存在于字典中，如果在，返回它对应的值；如果不在，给它指定一个新的值;
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40'}
>>> x['H']
10
>>> x['p']
Traceback (most recent call last):
File "<pyshell#72>", line 1, in <module>
x['p']
KeyError: 'p'
>>>
>>> x.get('p','没有')
'没有'
>>> x.get('H','没有')
10
>>>
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40'}
>>> x.setdefault('p',50)
50
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40', 'p': 50}
>>> -
视图对象
items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象，视图对象就是字典的一个动态视图，这意味着当字典内容改变时，视图对象的内容也会相应地跟着改变。
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40', 'p': 50}
>>>
>>> items = x.items()
>>> keys = x.keys()
>>> values = x.values()
>>> items
dict_items([('H', 10), ('e', 20), ('l', 30), ('o', '40'), ('p', 50)])
>>> keys
dict_keys(['H', 'e', 'l', 'o', 'p'])
>>> values
dict_values([10, 20, 30, '40', 50])
>>> x.pop('p')
50
>>> items
dict_items([('H', 10), ('e', 20), ('l', 30), ('o', '40')])
>>> keys
dict_keys(['H', 'e', 'l', 'o'])
>>> values
dict_values([10, 20, 30, '40'])
>>> x
{'H': 10, 'e': 20, 'l': 30, 'o': '40'}
>>>
##在 Python3.8 之后的版本中，可以使用 reversed() 函数对字典内部的键值对进行逆向操作
>>> list(reversed(x))
['o', 'l', 'e', 'H']
>>> -
嵌套
字典也是可以嵌套的，某个键的值是另外一个字典
>>> x = {'小明':{'语文':70,'数学':80},'小红':{'语文':80,'数学':70}}
>>> x['小明']['语文']
70
>>>
##跟列表的道理是一样的，浅拷贝第一层的修改是不会相互影响的，但是对于嵌套层会影响
>>> y = x.copy()
>>> x['小明']['语文'] = 80
>>> x
{'小明': {'语文': 80, '数学': 80}, '小红': {'语文': 80, '数学': 70}}
>>> y
{'小明': {'语文': 80, '数学': 80}, '小红': {'语文': 80, '数学': 70}}
>>> -
字典推导式
##求编码值
>>> x = {i:ord(i) for i in 'python'}
>>> x
{'p': 112, 'y': 121, 't': 116, 'h': 104, 'o': 111, 'n': 110}
>>>
##因为一个键必须是唯一的，所以每个键都被覆盖了
>>> d = {x:y for x in [1,2] for y in [3,4]}
>>> d
{1: 4, 2: 4}
>>>
>>> for x in [1,2]:
for y in [3,4]:
print(f'd[{x}] = {y}')
d[x] = y
d[1] = 3
d[1] = 4
d[2] = 3
d[2] = 4
>>> d
{1: 4, 2: 4}
>>> 集合
集合是独一无二、无序和无索引的。
-
特点
1、随机性
创建一个集合通常有三种方法：
使用花括号，元素之间以逗号分隔：{"Hello", "Python"}
使用集合推导式：{s for s in "Hello"}
使用类型构造器，也就是 set()：set("Hello")
>>> x = {"Hello", "Python"}
>>> y = {i for i in 'Hello'}
>>> z = set('Hello')
>>> type(x)
<class 'set'>
>>> type(y)
<class 'set'>
>>> type(z)
<class 'set'>
>>>
>>> x
{'Python', 'Hello'}
>>> y
{'e', 'o', 'l', 'H'}
>>> z
{'e', 'o', 'l', 'H'}
>>>
>>> x = frozenset('hello')
>>> x
frozenset({'e', 'h', 'l', 'o'})
>>> x.update([1,2],'ab')
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
x.update([1,2],'ab')
AttributeError: 'frozenset' object has no attribute 'update'
>>> y = set('hello')
>>> y
{'e', 'h', 'l', 'o'}
>>> y.update([1,2],'ab')
>>> y
{1, 'h', 2, 'e', 'a', 'b', 'o', 'l'}
>>> 2、唯一性
##使用[]、{}也可以
>>> set((1,2,1,3,4))
{1, 2, 3, 4}
>>>-
方法
set()可变集合，frozenset()不可变集合；
下表列举的方法既适用于 set 对象，也适用于 frozenset 对象：
| 方法 | 含义 |
| s.copy() | 返回 s 集合的一个浅拷贝 |
| s.isdisjoint(other) | 如果 s 集合中没有与 other 容器存在共同的元素，那么返回 True，否则返回 False |
| s.issubset(other) | 如果 s 集合是 other 容器的子集（注1），那么返回 True，否则返回 False |
| s.issuperset(other) | 如果 s 集合是 other 容器的超集（注2），那么返回 True，否则返回 False |
| s.union(*others) | 返回一个新集合，其内容是 s 集合与 others 容器的并集（注3） |
| s.intersection(*others) | 返回一个新集合，其内容是 s 集合与 others 容器的交集（注4） |
| s.difference(*others) | 返回一个新集合，其内容是存在于 s 集合中，但不存在于 others 容器中的元素（注5） |
| s.symmetric_difference(other) | 返回一个新集合，其内容是排除掉 s 集合和 other 容器中共有的元素后，剩余的 |
下表列举的方法只适用于 set 对象：
| 方法 | 含义 |
| s.update(*others) | 使用 others 容器中的元素来更新集合 |
| s.intersection_update(*others) | 更新 s 集合，其内容是 s 集合与 others 容器的交集（见注 4） |
| s.difference_update(*others) | 更新 s 集合，其内容是 s 集合与 others 容器的差集（见注 5） |
| s.symmetric_difference_update(other) | 更新 s 集合，其内容是排除掉 s 集合和 other 容器中共有的元素后，剩余的所有元素 |
| s.add(elem) | 将 elem 元素添加到 s 集合中 |
| s.remove(elem) | 将 elem 元素从 s 集合中移除（如果不存在该元素，则抛出 KeyError 异常） |
| s.discard(elem) | 将 elem 元素添加到 s 集合中移除（如果不存在该元素，也没有关系） |
| s.pop() | 从 s 集合中移除并返回任意一个元素（如果集合为空，则抛出 KeyError 异常） |
| s.clear() | 删除 s 集合中的所有元素 |
注：
1：对于两个集合 A、B，如果集合 A 中任意一个元素都是集合 B 中的元素，我们就说这两个集合有包含关系，称集合 A 为集合 B 的子集（Subset）。
2：对于两个集合 A、B，如果集合 B 中任意一个元素都是集合 A 中的元素，我们就说这两个集合有包含关系，称集合 A 为集合 B 的超集（Superset）。
3：对于两个集合 A、B，把他们所有的元素合并在一起组成的集合，叫做集合 A 与集合 B 的并集（Union）。
4：对于两个集合 A、B，由所有属于集合 A 且属于集合 B 的元素所组成的集合，叫做集合 A 与集合 B 的交集（Intersection）。
5：对于两个集合 A、B，由所有属于集合 A 且不属于集合 B 的元素所组成的集合，叫做集合 A 与集合 B 的差集（Difference）。
6：others 参数表示支持多个容器（参数类型可以是集合，也可以是序列）；other 参数则表示单个容器。
-
运算符运算（符号两边都要是集合）
| 方法 | 含义 |
| < | 判断子集 |
| <= | 判断真子集 |
| > | 判断超集 |
| >= | 判断真超集 |
| | | 判断并集 |
| & | 判断交集 |
| - | 差集 |
| ^ | 对称差集 |
>>> set('a') < set('hello')
False
>>> set('a') < set('helloa')
True
>>> set('hello') < set('hello')
False
>>> set('hello') <= set('hello')
True
>>>
>>> {1,2,3} | set('hello')
{1, 2, 3, 'e', 'h', 'o', 'l'}
>>>
>>> set('ox') & set('hello')
{'o'}
>>>
>>> set('ox') - set('hello')
{'x'}
>>>
>>> set('ox') ^ set('hello')
{'e', 'h', 'x', 'l'}
>>> -
可哈希
想要正确地创建字典和集合，是有一个刚性需求的 —— 那就是字典的键，还有集合的元素，它们都必须是可哈希的,使用hash()函数；
如果一个对象是可哈希的，那么就要求它的哈希值必须在其整个程序的生命周期中都保持不变。
-
嵌套
因为集合它是一个可变的容器，而可变的容器则是不可哈希，因此可以借助frozenset()方法；
>>> x = frozenset({1,2,3})
>>> y = {x,'hello'}
>>> y
{frozenset({1, 2, 3}), 'hello'}
>>>