字典、集合的使用

Dict：

　　在Python中内置了字典:dict，全称是dictionary，使用 键、值的方式来储存数据(key,value)，具有很快的查找速度，其中的key是不可变对象。

　　例如通过一个学生的名字来查找成绩，在list中的用法是要创建两个list

name = ["LiLei","Hanmeimei","Tom","Jack"]
score = [50,70,94,41]

通过name中的索引来查找score中的成绩；而使用dict的时候就可以用一个 "名字"-"成绩"的对照表来查找成绩，而且无论dict中的人数有多少，查询速度都不会变慢。

result = {"LiLei":50,"Hanmeimei":70,"Tom":94,"Jack":41}
print(result["LiLei"])
50

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，有两个办法

1、把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

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

　　dict就是第二种实现方式，给定一个名字，比如'Lilei'，dict在内部就可以直接计算出Lilei对应的存放成绩的"页码"，也就是50这个数字存放的内存地址，直接取出来，所以速度非常快。

你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

 

增加和更改:

　　除了初始化的方法把数据放到dict中，还可以通过添加key来给字典添加元素，需要注意的是字典中的key是唯一性的，如果重复就是会修改value的值。

result["Jerry"] = 1000 #在字典中添加新的key和value
result["Hanmeimei"] = 88 #修改Hanmeimei的成绩为88
print(result)
>>>{'Hanmeimei': 88, 'Tom': 94, 'Jerry': 1000, 'Jack': 41, 'LiLei': 50}

查找：

　　在查找字典中的元素时，都是通过key来进行查找，但是如果字典中没有key的值就会报错，避免程序报错，有两个办法

　　1、通过 in 判断key是否存在

　　2、使用get()方法来获取，如果key不存在就返回None.

print('alex' in result)
>>>False
print(result.get('abc'))
>>>None
print(result.get('Tom'))
>>>94

删除：

　　dict中通过pop(key)的方法来删除元素，在字典中，元素的排列是无序的

result.pop('Hanmeimei')
print(result)
{'Jack': 41, 'Jerry': 1000, 'Tom': 94, 'LiLei': 50}

和list相比：

　　时间 ：dict  < list 

　　内存 ：dict  > list

　　可以理解为dict就是牺牲内存换时间的方法。

其他方法

# dict.keys(self)       dict.values(self) 
result = {"LiLei":50,"Hanmeimei":70,"Tom":94,"Jack":41}
resultName = result.keys()
resultScore = result.values()
print(resultName,resultScore)
dict_keys(['Jack', 'LiLei', 'Tom', 'Hanmeimei']) dict_values([41, 50, 94, 70])

#items(self)
print(result.items())
dict_items([('Jack', 41), ('LiLei', 50), ('Tom', 94), ('Hanmeimei', 70)])

result = {"LiLei":50,"Hanmeimei":70,"Tom":94,"Jack":41}
print(result)
result.setdefault("abc",100)
print(result)
{'Jack': 41, 'LiLei': 50, 'Tom': 94, 'Hanmeimei': 70}
{'Jack': 41, 'abc': 100, 'LiLei': 50, 'Tom': 94, 'Hanmeimei': 70}

result = {"LiLei":50,"Hanmeimei":70,"Tom":94,"Jack":41,"abc":100}
dic = {"Zzz":99,"abc":0}
result.update(dic)
print(result)
{'Zzz': 99, 'Hanmeimei': 70, 'abc': 0, 'Tom': 94, 'LiLei': 50, 'Jack': 41}

dict循环:

#方法1
for key in info:
    print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据量大时莫用
    print(k,v)

 

集合：

　　set和dict类似，也是存储一组无序的key的集合，但不同的是set只存key，不存value，由于key是唯一性，所以set会去重，set中没有重复的key。

　　要创建一个set，需要通过list来创建(list中只能有基本数据类型，不可嵌套可迭代数据类型):

name = ["LiLei","Hanmeimei","Tom","Jack","Jack"]
name = set(name)
print(name)
>>>{'Hanmeimei', 'Tom', 'Jack', 'LiLei'}

　　可以简单的把set理解成数学中的集合，可以得到这个集合的合集，交集，并集，差集，对称差集，判断是否为父集，子集等...

# 合集 | union
number_1 = set([1,2,3,4,5])
number_2 = set([4,5,6,7,8])

number_3 = number_1 | number_2
number_3 = number_1.union(number_2)
print(number_3)
{1, 2, 3, 4, 5, 6, 7, 8}

# 交集 & intersection
number_4 = number_1 & number_2
number_4 = number_1.intersection(number_2)
print(number_4)
{4, 5}

# 差集 - difference  (number_1有number_2没有)
number_5 = number_1 - number_2
number_5 = number_1.difference(number_2)
print(number_5)
{1,2,3}

# 对称差集 ^ symmetric_difference
number_6 = number_1 ^ number_2
number_6 = number_1.symmetric_difference(number_2)
print(number_6)
{1, 2, 3, 6, 7, 8}

# <= t是否为b的子集
t = set([3,4,5])
b = set([3,4,5,6,7])
print(t.issubset(b))
# print(t <= b)
True

# >= t是否为b的父集
print(t.issuperset(b))
# print(t >= b)
False

# 基本操作：

# 添加一项：add
t.add(9)
print(t)
{9, 3, 4, 5}

# 添加多项
print(id(t))
t.update(b)
print(t,id(t))
4332189736
{3, 4, 5, 6, 7, 9} 4332189736

# 删除
t.remove(9)
print(t)
{3, 4, 5, 6, 7}

# t的长度
len(t)

#测试 x 是不是t的成员
x in t

# 测试x 不是t的成员
x not in t

#测试m和l的交集是否为None,如果为None返回True

m = set([12,3,4])
l = set([5,7])
print(m.isdisjoint(l))
True