Python中字典和集合

Python中字典和集合

映射類型：
    表示一個任意對象的集合，且能夠經過另外一個幾乎是任意鍵值的集合進行索引
    與序列不一樣，映射是無序的，經過鍵進行索引
        任何不可變對象均可用做字典的鍵，如字符串、數字、元組等
        包含可變對象的列表、字典和元組不能用做鍵
        引用不存在的鍵會引起KeyError異常

1)字典

dict    {  }    空字典
            { key1:value1,key2:value2,... }
        字典在其它編程語言中又稱做關聯數組或散列表；

    經過鍵實現元素存取；無序集合；可變類型容器，長度可變，異構，嵌套
                                                 
    支持的操做：
        len(D)                      返回D中的項目數                       
        D[k]                        返回D中鍵k的值
        D[k] = x                    將D[k]的值設爲x                    
                    >>> d1 = {'x':1,'y':2,'z':3}
                    >>> d1['x']
                    1
                    >>> d1['z']                 經過鍵索引
                    3   
        del D[k]                    從D中刪除D[k]
                    >>> del d1['x']
                    >>> d1
                    {'y': 2, 'z': 3}
        k in D                      若是k是D中的值，則返回True
             
     支持的方法：
        D.clear()                   清除全部元素
        D.copy()                    複製一個副本
                    >>> d1 = {'x':1,'y':2,'z':3}
                    >>> id(d1)
                    45320640
                    >>> d2 = d1.copy()                深複製
                    >>> id(d2)
                    45997776            
                    >>> d3 = d1                       淺複製
                    >>> id(d3)
                    45320640                           d一、d3指向同一對象，d2指向另外一對象
        D.get(k[,d])                取得對應鍵的值，若不存在則返回d(默認爲空)
                    >>> d1.get('y')
                    2
        D.has_key(k)                是否存在鍵值，返回True或False.(僅在pyhton2中使用)
        D.items()                   轉換爲(key,value)元組組成的列表
                    >>> d1.items()
                    [('y', 2), ('x', 1), ('z', 3)]
                    >>> t1,t2,t3 = d1.items()
                    >>> t1
                    ('y', 2)
                    >>> t2
                    ('x', 1)
                    >>> t3
                    ('z', 3)
                    >>> m1,m2 = {'x':1,'y':2}
                    >>> print m1
                    'y'
                    >>> print m2
                    'x'                                 保存的是鍵，而不是值!!!
        D.values()                  值列表
                    >>> d1.values()
                    [2, 1, 3]
        D.keys()                    鍵列表
                    >>> d1.keys()
                    ['y', 'x', 'z']
        D.pop(k[,d])                彈出指定鍵值，若不指定則會觸發異常
                    >>> d1.pop()
                    TypeError: pop expected at least 1 arguments, got 0
                    >>> d1.pop('x')
                    1
                    >>> d1
                    {'y': 2, 'z': 3}
        D.popitem()                  隨機彈出    
                    >>> d1.popitem()
                    ('y', 2)
                    >>> d1.popitem()
                    ('z', 3)
                    >>> d1.popitem()               
                    KeyError: 'popitem(): dictionary is empty'               爲空時異常
                    >>> d1
                    { }
        D.update(m)                   合併字典
                    >>> d1 = { 'x':1,'y':2,'z':3 }
                    >>> d2={'c':'hello','y':66}
                    >>> d1.update(d2)
                    >>> d1
                    {'y': 66, 'x': 1, 'c': 'hello', 'z': 3}             若鍵存在則會覆蓋，不存在就添加   
        D.iteritems()                   返回一個迭代器對象
                    >>> d1 = { 'x':1,'y':2,'z':3 }
                    >>> i1 = d1.iteritems()
                    >>> i1.next()                   使用next方式遍歷每個元素
                    ('y', 2)
                    >>> i1.next()
                    ('x':1)
                    >>> i1.next()
                    ('z':3)
                    >>> i1.next()
                    StopIteration                   遍歷結束後不會從新開始
        D.iterkeys()        ->     an iterator over the keys of D
                    >>> i2 = d1.iterkey()
                    >>> i2.next()
                    'y'
        D.itervalues()      ->      an iterator over the values of D
                    >>> i3 = d1.iterkey()
                    >>> i3.next()
                    2
        D.viewvalues()                              返回相似集合方式的字典(值組成)
                    >>> d1.viewvalues()
                    dict_values([2, 1, 3])
        D.viewitems()       ->      a set-like object providing a view on D's items(鍵值對)
                    >>> d1.viewitems()
                    dict_items([('y', 2), ('x', 1), ('z', 3)])
        D.viewkeys()        ->      a set-like object providing a view on D's keys
                    >>> d1.viewkeys()
                    dict_keys(['y', 'x', 'z'])
                    
                    >>> d2 = dict(x=1,y=2,z=3)              定義字典另外一種方式
                    >>> d2
                    {'y': 2, 'x': 1, 'z': 3}

    補充：zip   返回元組組成的列表
            >>> zip('xyz','123')
            [('x', '1'), ('y', '2'), ('z', '3')]            一一對應生成列表
            >>> zip('xyzm','123')
            [('x', '1'), ('y', '2'), ('z', '3')]            多餘項被捨棄
            >>> zip('xyz','123','qer')
            [('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]                
            >>> dict(zip('xyz','123'))                      構造字典
            {'y': '2', 'x': '1', 'z': '3'}

2)集合

無序排列、可哈希；
  支持集合關係測試
        成員關係測試：
            in
            not in
            迭代
  不支持：索引、元素獲取、切片

  集合的類型：  set()    frozenset()
                可變       不可變
  沒有特定語法格式，只能經過工廠函數建立   
      例：
            >>> s1=set(1,2,3)                                       
            TypeError: set expected at most 1 arguments, got 3              錯誤方式
            >>> s1 = set([1,2,3])                                           正確方式
            >>> s1
            set([1, 2, 3])
            >>> type(s1)
            set
  支持的方法和操做：

3)小結

如何獲取使用幫助：
        獲取對象支持使用的屬性和方法：dir()
        某方法的具體使用幫助：help(list.pop)
        獲取可調用對象的文檔字串：print obj.__doc__
        
    容器、類型、對象：
        一、列表、元組、字典字面量可在無換行符下分佈在多行內，最後一個字符後可跟逗號(若空則不可以使用)    

        二、全部對象都有引用計數(sys模塊中getrefcount方法);
                >>> import sys
                >>> s1
                set([1, 2, 3])
                >>> sys.getrefcount(s1)                 查看s1的引用計數
                3
                
        三、列表和字典都支持兩種類型的複製操做：淺複製和深複製；深複製可以使用copy模塊中的deepcopy()實現。
    
        四、Python中的全部對象都是「第一類的」，這意味着使用標識符命名的全部對象都具備相同狀態，因而，可以命名全部對象均可以直接當數據進行處理；
    
        五、全部序列都支持迭代；(非負整數的有序集合)
    
        六、全部序列都支持的操做和方法：
            s[i]            索引                s[i:j]      切片            
            s[i:j:stride]   擴展切片            len(s)
            min(s)          max(s)              sum(s)
            all(s)          全部爲true          any(s)      任意爲true
            s1 + s2: 鏈接                       s1 * N: 重複
            成員關係判斷：
                obj in s1
                obj not in s1
                
        七、可變序列的操做：
            s[index] = value        元素賦值
            s[i:j] = t              切片賦值
            s[i:j:stride] = t       擴展切片賦值
            del s[index]            元素刪除
            del s[i:j]              切片刪除
            del s[i:j:stride]       擴展切片刪除
   
        引用計數和垃圾回收：
            全部對象都有引用計數
                給對象分配一個新名稱或將其放入一個容器內，其引用計數都會增長
                用del語句或爲變量從新賦值時，其引用計數會減小
                sys.getrefcount()能夠得到對象的當前引用計數
            一個對象的引用計數器歸零時，它將被垃圾收集機制回收