Python中的字典和集合

1. 字典（`dict`）

字典（dict,全称： dictionary ）是python内置的一种使用“键值对结构”存储数据的存储模型。在其它语言中也称为map或者是object(对象)

1.1 字典的操作

创建/查询/修改字典

# 创建字典：变量名 = {键1：值1，键2：值2，……}
d = {'kendny': 99, 'Mary': 88}
# 添加数据：变量名[键] = 值	（字典中没有对应的键）
d['Tom'] = 87	
# 获取数据：	 变量名[键]
d['kendny'] # 或 d.kendny
# 修改数据：变量名[键] = 值	（字典中存在对应的键）
d['kendny'] = 100

# 通过键名取字典的值， 如果键名不存在， 就会报错； 通常可以通过 in或者get()方法判断键是否存在
if 'Thomas' in d:
    value = d['Thomas']
    
 # 或者
value = d.get('Thomas'); # 不存在value什么值都没有

常见操作字典的函数

函数	说明	实例
`len（d）`	获取字典d中元素的长度	`len（d）`
`d.setdefault(key, value)`	向字典中添加新的键值对，如果存在对应的键，则忽略该操作；返回添加成功键值对的值。	`d.setdefault(‘f’, 33)``
`d1.update(d2)`	使用新字典中的数据对原始字典数据进行更新	`dict1 = {"name":"itcast","age":11} dict2 = {"address":"北京","age":22} dict1.update(dict2)`
`d.pop(key)`	从字典中删除指定键key对应的键值对，如果键`key`不存在将报错；返回值：被删除的值`value`	d.pop(‘Mary’)
`popitem()`	从字典中删除字典最后一个键值对；返回值：被删除的键值对，以元组的形式返回	`d.popitem()`
`d.get(key)`	从字典中获取键为`key`的值，如果`key`不存在，则什么都不返回，也不报错	`d.get(key)`
`d.keys()`	以列表的形式返回字典中所有的键名	`d.keys()`
`d.values()`	以列表的形式返回字典中所有的键值	`d.value()`
`d.items()`	将字典中的每一项键值对转化成元组，并以列表的方式返回	`d.items()`
`d.clear()`	清除字典中的元素	`d.clear()`

1.2 字典的特点

字典不具备索引的概念，但可以通过字典的键key操作字典中存储的数据值value
字典（dict）内部存放的顺序和键key放入的顺序是没有关系的。
字典可以根据键（key）进行数据的添加、删除、修改、查询等操作
字典通过键（key）计算位置的算法称为哈希算法（Hash）
要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等不可变类型的数据可作为字典的键
字典的key是唯一的且必须是不可变的类型（对象），如纯元素可以作为字典的key

*为什么字典dict*查找速度这么快？

因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

总结：字典的查找方式就是第二种，字典在内部可以直接通过键key直接计算出对应的存放值的内存地址，直接取出来，所以速度非常快。

2 集合（set）

集合（set）是python内置的一种存储无序不重复数据的数据存储模型

2. 1 集合的操作

创建集合
```
s = {1, 2, 3} # 创建集合
```
集合是无序不重复数据的数据存储模型，它没有索引的概念，集合中的数据可以进行添加、删除等操作；

常见集合的函数

函数	说明	实例
`len(s)`	获取集合中元素的个数	`len(s)`
`s.add(data)`	向集合s中添加数据data	`s.add(4)`
`s.remove(data)`	从集合中删除指定的数据，如果数据不存在将报错	`s.remove(2)`
`s.discard(data)`	删除集合中的data元素，若data不存在，什么都不做	`s.remove(22)`
`s.pop()`	从集合中删除字典的第一个元素并返回（不需要参数）	`s.pop()`
`s.clear()`	清空集合中的数据	`s.clear()`
`s.copy()`	复制集合	`ns=s.copy()`
`s1.difference(s2)`	计算2个集合的差集(在s1中，但不在s2中)
`s1.union(s2)`	计算2个集合的并集``
`s1.intersection(s2)`	计算2个集合的交集

集合中的其它操作

s = {1, 2, 3}
>>> 2 in s    #True 集合的成员检测
>>> {'*' + i '*' for i in s} # 集合推导式
>>> {i for i in s if i>1} # 带有条件的集合推导式

# 多循环集合推导式
>>>colors = {'red','blue','pink'}
>>>sizes = {36,37,38,39}
>>>result = {c + str(s) for c in colors for s in sizes}
print(result)

#difference() 计算2个集合的差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.difference(girls)# result = a + b
print(result)

#difference_update()  计算2个集合的差集(差集更新操作)
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.difference_update(girls)#a = a + b  a += b
print(dreamers)

#union()  并集操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.union(girls)
print(result)

#update()  并集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.update(girls)
print(dreamers)

#intersection()  计算2个集合的交集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.intersection(girls)
print(result)

#intersection_update  交集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.intersection_update(girls)
print(dreamers)

#超集和子集
boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
zoudu = {'wzc','lyb','wym'}
girls = {'lsy','mmf','syj'}

#issuperset()  检测当前集合是否是另一个集合的超集
result = boys.issuperset(zoudu)
print(result)

#issubset()  检测当前集合是否是另一个集合的子集
result = zoudu.issubset(boys)
print(result)

#isdisjoint()  检测2个集合是否不存在交集  存在交集 False
result = boys.isdisjoint(girls)
print(result)

#symmetric_difference()  对称差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.symmetric_difference(girls)
print(result)

#symmetric_difference_update()  对称更新差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.symmetric_difference_update(girls)
print(dreamers)

#冰冻集合
#冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
#创建冰冻集合
#一般不会创建空的冰冻集合
var = frozenset()
print(var,type(var))

#带有数据的冰冻集合
var = frozenset(('qs','szx','bjh','acs'))
print(var,type(var))

#成员检测
result = 'szx' in var
print(result)

#遍历冰冻集合
for i in var:
    print(i)

#集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
result = {i for i in var}
print(result,type(result))

#函数
#冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
var = frozenset(('qs','szx','bjh','acs'))

#copy()
result = var.copy()
print(result)

#集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
var1 = frozenset(('qs','szx','bjh','acs'))
var2 = {'szx','bjh','lc','wb'}

#冰冻集合操作
result = var1.union(var2)
print(result)

#普通集合操作(冰冻集合是参考集合)
result = var2.union(var1)
print(result)

# 集合支持一系列标准操作，包括并集、交集、差集和对称差集
a = t | s          # t 和 s的并集 
   
b = t & s          # t 和 s的交集 
   
c = t – s          # 求差集（项在t中，但不在s中） 
   
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）

3 字典和几种常见的存储数据型比较

列表list和dict

在进行数据存储与查找方面，列表list是用时间换取空间，它存储数据占用的空间小，浪费内存很少。但是查找和插入的时间随着元素的增加而增加；字典dict是用空间换取时间，它存储数据占用大量的空间，内存浪费多。
字典set和dict

集合和字典检索的原理是一样的，唯一区别就是没有存储对应的value值；字典的键值和集合的元素不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证集合（字典键值）不会有重复的元素。

将列表/元组转化成集合

l = [1, 2, 3, 4]
s1 = set(l)

t = (1, 2, 3, 4)
s2 = set(t)