字典和集合

字典 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()