字典和集合

字典 dict

字典 dict是一种无序的可变容器，序列的索引对它失效，它的索引是自定义的

形式：
d = {}
d = {‘key1’:‘value1’,‘key2’:‘value2’}
d = dict(a=1,b=2)
d = dict([(‘name’,‘libai’),(‘age’,30)])
d = dict.fromkeys(迭代对象) 将一个迭代对象的每个元素作为键，值默认全部为None

字典方法

例： d = {'name': 'libai', 'age': 30}
     d1 = {'name': 'dufu','grade':1}
增  改
    d[键] = 值                ： 如果键不存在则添加元素，如果键存在为修改
                                d['score'] = 100     d['name'] = 'dufu'
    d.setdefault(键，值)       : 如果键不存在则添加此元素，并且返回"值"。如果键存在则不做修改，并且返回相应字典中的"值"
    d.update(d1)              :  将两个字典合并，d1不变，d要根据d1进行修改 

删
    del()                     : 通用删除方法  del(d1)   del(d['name'])   只会返回None
    d.clear()                 : 将一个字典清空
    d.pop(键)                 : 根据索引进行删除元素，并且会返回元素的值
    d.popitem()               : 随机弹出一个元素，返回 （键，值）

查
    d['name']                 : 根据索引进行查找，如果存在则返回值，如果不存在则报错
    d.get(键,[默认值])         : 查找对应键的值，如果存在则返回相应值，如果不存在则返回默认值 （默认值默认为None）
    d.keys()                  : 获得字典中所有的键，可以将结果变成列表或元组后使用
    d.values()                : 获得字典中所有的值，可以将结果变成列表或元组后使用
    d.items()                 : 将一个字典变成列表的形式  dict_items([('name', 'dufu'), ('score', 100)])

其它方法：
    d.copy()                 : 深拷贝

字典的特性

哈希运算 散列算法
    哈然是一种单向算法，并且不可逆
    常见  : md5 sha1 sha256  sha512
    对不同的值进行同样的hash运算可能会得到相同的值，我们称之为碰撞。如果发生了碰撞，说明这个hash算法就不安全。
    只有sha512没有发生过碰撞


字典中的值可以是任意类型的数据
字典中的键必须为不可变类型，即不可为列表字典
    因为字典对元素中的键做了hash运算，这个可以大大提高字典的速度。hash运算不能计算可变类型
    如果数据量很大字典会比列表快很多。

练习：

参考：
#输入ip、访问次数、流量、等待时间
#用字典的方式构建
'''输入要查询的ip
如果ip存在则显示访问次数、流量、等待时间
如果ip不存在则返回 ip is not exists'''
allip = {}
ip = input('ip:\n'.strip())
count = input('{} count is : \n'.format(ip))
size = input('{} size is :\n'.format(ip).strip())
time = input('{} time is: \n'.format(ip).strip())
allip[ip] = [count,size,time]

ask = input('please input ip:\n'.strip())
reset = allip.get(ask,'{} is not exists'.format(ask))
print(reset)

集合 set

集合里面不能有重复的元素，集合是无序的，并且为不可变元素。（可以理解为将字典中的值去掉）

形式：
    s = set()
    s = set(迭代对象)       可以将一个迭代对象变成集合   set('abc123123')  set([1,2,3,3,2,1,'abc'])
    s = {'abc',1,3.14}

集合的操作方法

例： 
    tmps1 = {1,2,3,'a','haha'}
    tmps2 = {3,'66','haha'}

增      ：add(添加元素) 、 update（将两个集合合并到一块）
    tmps1.add('abc')        
    tmps1.update(tmps2)

删       : 
    clear （清空）                                      tmps1.clear()
    pop （随机弹出一个元素）                             tmps1.pop()
    discard（删除一个元素，如果元素不存在什么也不做）      tmps1.discard('val')
    remove （删除指定元素，若不存在则异常）               tmps2.remove('val')

判断    ：
    isdisjoint      (没有交集返回True)      
    issubset        (A.issubset(B),判断集合A是不是集合B的子集)
    issuperset      (A.issuperset(B),判断集合A是不是集合B的父集合)

        tmps1.isdisjoint(tmps2)
        tmps1.issubset(tmps2)
        tmps1.issuperset(tmps2)

求差集：    -     difference                            
            A.difference(B)                 在集合A中但不再集合B中,相当于 A - B
            difference_update               A.difference_update(B)，类似difference，区别是将结果赋值给A.
            symmetric_difference           返回两个集合中不同的元素（本质为去掉公共元素）
            symmetric_difference_update    A.symmetric_difference_update(B),返回两个集合中的不同元素，并将结果赋值给A

求交集：  &   、 intersection    
        A.intersection(B)               返回两个集合的交集，相当于 A &　B
        intersection_update             A.intersection_update(B),返回集合A和集合B的交集，并将结果赋值给A
            tmps1 & tmps2
            tmps1.intersection(tmps2)
            tmps1.intersection_update(tmps2)

求并集：   |  、  union     返回两个集合的并集,即所有元素
            tmps1.union(tmps2)
            tmps1 | tmps2

深拷贝：copy  （深拷贝）
            tmps1 = tmps2.copy()