映射类型
    定义：键值对，键不能重复，值可以重复。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 中的所有元素