映射類型
    定義：鍵值對，鍵不能重復，值可以重復。Python中的映射類型是字典(dict)
    映射的創建
        1. 字面值創建
            eg. d = {'a' : 100, 'b':200 }
        2. 工廠函數dict()創建
            eg1. d = dict([['x', 1], ['y':2]])
            eg2. d = dict(x=1, y=2)
            eg3. d = dict( zip(('x', 'y'), (1,2)) )
        3. 其他函數
            d = dict.fromkeys( (1,2,3), 'value' ) #創建一個dict，鍵為1,2,3，值為value
    映射的使用
        1. 鍵值讀寫
            []操作符：
                可以用來獲得值或者設置/新建值
                在讀取的時候，如果鍵不存在，則拋出一個錯誤
                eg.
                    a = {'x':1, 'y':2}
                    a['z'] = 3         #鍵不存在，則創建鍵值對
                    a['x'] = '6'    #鍵存在，則更新值
                    a['y']            #獲得鍵對應的值
                    #! a['p']        沒有對應的鍵會拋出Error!
            get(key, default=None)
                用來獲取值時，如果鍵不存在也不會拋出錯誤，會返回default值
            NOTE: 沒有set方法
        2. 遍歷：
            keys --> 鍵遍歷
            values --> 值遍歷
            items --> 鍵值遍歷
            利用sorted(dict) --> 有序的鍵遍歷(對鍵排序)
            eg. TestTraversal.py
        3. 常用操作
            刪除
                del a['x']    #刪除鍵為'x'的條目
                a.clear        #清除字典
                a.pop('x')    #刪除鍵為'x'的條目并返回其值
                a.popitem()    #彈出一個(k,v)對并返回。如果a為空則報錯
            判斷
                k in/not in dict
        4. 常用函數表
            方法名字                操作
            dict.clear()        刪除字典中所有元素
            dict.copy()            返回字典(淺復制)的一個副本
            dict.fromkeysc(seq,
            val=None)            創建并返回一個新字典，以seq 中的元素做該字典的鍵，val 做該字典
                                中所有鍵對應的初始值(如果不提供此值，則默認為None)
            dict.get(key,
            default=None)        對字典dict 中的鍵key,返回它對應的值value，如果字典中不存在此
                                鍵，則返回default 的值(注意，參數default 的默認值為None)
            dict.has_key(key)    如果鍵(key)在字典中存在，返回True，否則返回False.
                                在Python2.2版本引入in 和not in 后，此方法幾乎已廢棄不用了，但
                                仍提供一個可工作的接口。
            dict.items()        返回一個包含字典中(鍵, 值)對元組的列表
            dict.keys()            返回一個包含字典中鍵的列表
            dict.iter()            方法iteritems(), iterkeys(), itervalues()與它們對應的非迭代方法
                                一樣，不同的是它們返回一個迭代子，而不是一個列表。
            dict.pop(key
            [, default])        和方法get()相似，如果字典中key 鍵存在，刪除并返回dict[key]，如果
                                key 鍵不存在，且沒有給出default 的值，引發KeyError 異常。
            dict.setdefault(key,
            default=None)        和方法set()相似，如果字典中不存在key 鍵，由dict[key]=default為它賦值。
            dict.update(dict2)    將字典dict2 的鍵-值對添加到字典dict
            dict.values()        返回一個包含字典中所有值的列表
    映射的鍵
        什么可以做為映射的鍵？ --> 可hash的
        什么可hash？
            1. 不可變對象 (數字，字符串。。。)
            2. 僅包含不可變對象的不可變容器（僅包含不可變對象的元組）
            3. 實現了__hash__()方法的類（可能是可變對象）

集合類型（Set）
    特點：無順序，不能重復
    分類：可修改的集合和不可修改的集合
    創建：
        >>> s = set('cheeseshop')
        >>> s
        set(['c', 'e', 'h', 'o', 'p', 's'])
        >>> t = frozenset('bookshop')
        >>> t
        frozenset(['b', 'h', 'k', 'o', 'p', 's'])
    使用：
        >>> 'k' in s
        False
        >>> 'k' in t
        True
        >>> 'c' not in t
        True
        >>> for i in s:
        ... print i
    操作
        函數/方法名                    等價運算符                說明
    所有集合類型
        len(s)                                            集合基數: 集合s 中元素的個數
        set([obj])                                         可變集合工廠函數; obj 必須是支持迭代的，由obj 中
                                                        的元素創建集合，否則創建一個空集合
        frozenset([obj])                                不可變集合工廠函數; 執行方式和set()方法相同，但它
                                                        返回的是不可變集合
                                    obj in s             成員測試：obj 是s 中的一個元素嗎?
                                    obj not in s         非成員測試：obj 不是s 中的一個元素嗎?
                                    s == t                 等價測試: 測試s 和t 是否具有相同的元素?
                                    s != t                 不等價測試: 與==相反
                                    s < t                 (嚴格意義上)子集測試; s != t 而且s 中 所 有的元素都是t 的成員
        s.issubset(t)                 s <= t                 子集測試(允許不嚴格意義上的子集): s 中所有的元素    都是t 的成員
                                    s > t                 (嚴格意義上)超集測試: s != t 而且t 中所有的元素都是s 的成員
        s.issuperset(t)             s >= t                 超集測試(允許不嚴格意義上的超集): t 中所有的元素    都是s 的成員
        s.union(t)                     s | t                 合并操作：s 或t 中的元素
        s.intersection(t)             s & t                 交集操作：s 和t 中的元素
        s.difference(t)             s - t                 差分操作: s 中的元素，而不是t 中的元素
        s.symmetric_difference(t)    s ^ t                 對稱差分操作：s 或t 中的元素，但不是s 和t 共有的元素
        s.copy()                                         復制操作:返回s 的(淺復制)副本
    僅用于可變集合
        s.update(t)                 s |= t (Union)         修改操作: 將t 中的成員添加s
        s.intersection_update(t)     s &= t                 交集修改操作: s 中僅包括s 和t 中共有的成員
        s.difference_update(t)         s -= t                 差修改操作: s 中包括僅屬于s 但不屬于t 的成員
        s.symmetric_
        difference_
        update(t)                     s ^= t                 對稱差分修改操作: s 中包括僅屬于s 或僅屬于t 的成員
        s.add(obj)                                         加操作: 將obj 添加到s
        s.remove(obj)                                     刪除操作: 將obj 從s 中刪除；如果s 中不存在obj,將引發KeyError
        s.discard(obj)                                     丟棄操作: remove()的友好版本-如果s中存在obj,從s中刪除它
        s.pop()                                         Pop 操作: 移除并返回s 中的任意一個元素
        s.clear()                                         清除操作: 移除s 中的所有元素