07 映射和集合类型 - 《Python 核心编程》

? 映射类型: 字典

? 操作符

? 内建函数

? 内建方法

? 字典的键

? 集合类型

? 操作符

? 内建函数

? 内建方法

? 相关模块

7.1 映射类型：字典

    字典是Python 语言中唯一的映射类型。

    映射类型对象里哈希值(键) 和指向的对象(值)是一对多的关系。

    字典类型和序列类型容器类(列表、元组)的区别是存储和访问数据的方式不同。

    序列类型只 用数字类型的键(从序列的开始起按数值顺序索引)。

    映射类型可以用其他对象类型做键；一般最常 见的是用字符串做键(keys)，和序列类型的键不同，映射类型的键(keys)直接，或间接地和存储的数据值相关联。

    映射类型中的数据是无序排列的。

    字典的键必须是可哈希的 。

    Python 的字典是作为可变的哈希表实现的。

如何创建字典和给字典赋值

    花括号({})

        创建字典只需要把字典赋值给一个变量，不管这个字典是否包含元素：

            >>> dict1 = {}

            >>> dict2 = {'name': 'earth', 'port': 80}

            >>> dict1, dict2 

            ({}, {'port': 80, 'name': 'earth'})

    工厂方法 (dict()    )

        用工厂方法 dict() 来创建字典

            >>> fdict = dict((['x', 1], ['y', 2]))

            >>> fdict

            {'y': 2, 'x': 1}

    内建方法fromkeys()
        从Python 2.3 版本起, 可以用一个很方便的内建方法fromkeys() 来创建一个"默认"字典, 字 典中元素具有相同的值 (如果没有给出， 默认为None):

            >>> ddict = {}.fromkeys(('x', 'y'), -1)

            >>> ddict

            {'y': -1, 'x': -1}

            >>>

            >>> edict = {}.fromkeys(('foo', 'bar'))

            >>> edict

            {'foo': None, 'bar': None}

如何访问字典中的值

    循环遍历

         循环查看它的键

            要想遍历一个字典(一般用键), 你只需要循环查看它的键, 像这样：

                >>> dict2 = {'name': 'earth', 'port': 80}

                >>>

                >>>> for key in dict2.keys():

                ...             print 'key=%s, value=%s' % (key, dict2[key])

                ...

                key=name, value=earth

                key=port, value=80

                >>>> for key in dict2:

                ...             print 'key=%s, value=%s' % (key, dict2[key])

                ...

         迭代器

            用迭代器来轻松地访问类序列对象(sequence-like objects)，比如字典和文件。

                >>> dict2 = {'name': 'earth', 'port': 80} 

                >>> 

                >>>> for key in dict2: 

                ... print 'key=%s, value=%s' % (key, dict2[key]) 

                ... 

                key=name, value=earth 

                key=port, value=80

    得到字典中某个元素的值 

        要得到字典中某个元素的值， 可以用你所熟悉的字典键加上中括号来得到

            >>> dict2['name']

        检查一个字典中是否有某个键的最好方法是用字典的  has_key()方法， 或者， in 或 not in 操作符.

            >>> 'server' in dict2 # 或 dict2.has_key('server') 

            False 

            >>> 'name' in dict # 或 dict2.has_key('name') 

            True 

如何更新字典

    添加一个新数据项或新元素(即，一个键-值对)

    修改一个已存在的数据项

    删除一个已存在的数据项

        >>> dict2 = {'name':'earth','port':80} 

        >>> dict2['name'] = 'venus'                 # 更新已有条目,如果字典中该键已经存在，则字典中该键对应的值将被新值替代。

        >>> dict2['port'] = 6969                       # 更新已有条目

        >>> dict2['arch'] = 'sunos5'                 # 增加新条目

        >>>

如何删除字典元素和字典

        del dict2['name']    # 删除键为“name”的条目

        dict2.clear()             # 删除dict2 中所有的条目

        del dict2                  # 删除整个dict2 字典

        dict2.pop('name')   # 删除并返回键为“name”的条目

    核心笔记： 避免使用内建对象名字作为变量的标识符 

        如果在Python 2.3 前，你已经开始使用Python，你可能用dict 作为一个字典的标识符。但是， 

        因为 dict() 现在已成为 Python 的类型和工厂方法，重载dict()会给你带来麻烦和潜在的bugs。 

        编译器允许你做这样的重载，它认为你是聪明的，知道自己正在做什么！小心。请不要用 dict, list, 

        file, bool, str, input, len 这样的内建类型为变量命名。

7.2 映射类型操作符

字典可以和所有的标准类型操作符一起工作,但却不支持像拼接（concatenation）和重复 (repetition)这样的操作。这些操作对序列有意义，可对映射类型行不通。

标准类型操作符

映射类型操作符

    字典的键查找操作符（[ ]）

        键查找操作符是唯一仅用于字典类型的操作符，它和序列类型里单一元素的切片(slice)操作符很相象。

        对序列类型来说，用索引做唯一参数或下标(subscript)以获取一个序列中某个元素的值。

        对字典类型来说，是用键(key)查询(字典中的元素),所以键是参数(argument), 而不是一个索引 (index)。

        键查找操作符既可以用于给字典赋值，也可以用于从字典中取值： 

            d[k] = v 通过键'k'，给字典中某元素赋值'v' 

            d[k] 通过键'k'，查询字典中某元素的值

    (键)成员关系操作( in ,not in)

        从Python 2.2 起，程序员可以不用has_key()方法，而用 in 和 not in 操作符来检查某个键 是否存在于字典中： 

            >>> 'name' in dict2 

            True 

            >>> 'phone' in dict2 

            False

7.3 映射类型的内建函数和工厂函数

标准类型函数[type()、str()和cmp()]

    cmp() 内建函数

        字典是通过这样的算法来比较的： 首先是字典的大小，然后是键，最 后是值。

        可是，用 cmp() 做字典的比较一般不是很有用。

         *字典比较算法

        (1)比较字典长度 

        如果字典的长度不同，那么用 cmp(dict1, dict2) 比较大小时，如果字典 dict1 比 dict2 长， cmp()返回正值，如果 dict2 比 dict1 长，则返回负值。

        也就是说，字典中的键的个数越多，这个字典就越大，即: 

            len(dict1) > len(dict2) ==> dict1 > dict2 

        (2)比较字典的键 

        如果两个字典的长度相同，那就按字典的键比较；键比较的顺序和 keys()方法返回键的顺序相 同。(注意: 相同的键会映射到哈希表的同一位置，这保证了对字典键的检查的一致性。) 

        这时， 如果两个字典的键不匹配时，对这两个(不匹配的键)直接进行比较。

        当dict1 中第一个不同的键大于dict2 中第一个不同的键，cmp()会返回正值。 

        (3)比较字典的值 

        如果两个字典的长度相同而且它们的键也完全匹配，则用字典中每个相同的键所对应的值进行比较。

        一旦出现不匹配的值，就对这两个值进行直接比较。

        若dict1 比dict2 中相同的键所对应的值大，cmp()会返回正值。

        (4) Exact Match

            到此为止，即，每个字典有相同的长度、相同的键、每个键也对应相同的值，则字典完全匹配， 返回0 值。

 

            

            图 7-1 字典是如何进行比较的

映射类型相关的函数

    dict() 

        dict() 工厂函数被用来创建字典。

        如果不提供参数，会生成空字典。

        当容器类型对象做为一个参数传递给方法dict() 时，如果参数是可以迭代的，那每个可迭代的元素必须成对出现，在每个值对中，第一个元素是字典的键、第二个元素是字典中的值。

            >>> dict(zip(('x', 'y'), (1, 2))) 

            {'y': 2, 'x': 1} 

            >>> dict([['x', 1], ['y', 2]]) 

            {'y': 2, 'x': 1} 

            >>> dict([('xy'[i-1], i) for i in range(1,3)]) 

            {'y': 2, 'x': 1}

        如果输入参数是(另)一个映射对象，比如，一个字典对象，对其调用dict()会从存在的字典里 复制内容来生成新的字典。

        新生成的字典是原来字典对象的浅复制版本， 它与用字典的内建方法copy() 生成的字典对象是一样的。

        但是从已存在的字典生成新的字典速度比用copy()方法慢，我们推荐使用copy()。

            >>> dict(x=1, y=2) 

            {'y': 2, 'x': 1} 

            >>> dict8 = dict(x=1, y=2) 

            >>> dict8 

            {'y': 2, 'x': 1} 

            >>> dict9 = dict(**dict8) 

            >>> dict9 

            {'y': 2, 'x': 1} 

            >>> dict9 = dict8.copy() 

            >>> dict9 

            {'y': 2, 'x': 1}

    len()

        对字典调用内建函数len()，它会返回所有元素(键-值对)的数目：

            >>> dict2 = {'name': 'earth', 'port': 80} 

            >>> dict2 

            {'port': 80, 'name': 'earth'} 

            >>> len(dict2) 

            2

    hash()

        内建函数hash()本身并不是为字典设计的方法，但它可以判断某个对象是否可以做一个字典的键。

        将一个对象作为参数传递给 hash(), 会返回这个对象的哈希值。

        只有这个对象是可哈希的， 才可作为字典的键 (函数的返回值是整数，不产生错误或异常)。

        如果用比较操作符来比较两个数值，发现它们是相等的，那么即使二者的数据类型不同， 它 们也会得到相同的哈希值。

        如果非可哈希类型作为参数传递给hash()方法，会产生TypeError 错误(因此，如果使用这样的对象作为键给字典赋值时会出错)。

            >>> hash([]) 

            Traceback (most recent call last): 

              File "<stdin>", line 1, in <module> 

            TypeError: unhashable type: 'list' 

            >>> dict2[{}] = 'foo' 

            Traceback (most recent call last): 

              File "<stdin>", line 1, in <module> 

            TypeError: unhashable type: 'dict' 

            >>>

            >>> hash(tuple()) 

            3527539 

            >>>

7.4 映射类型内建方法

基本的字典方法关注他们的键和值(这些方法在不按任何顺序遍历字典的键或值时很有用。)

    has_key()

        等效(键)成员关系操作( in ,not in)

            >>> dict2 = dict((('port',8043),('name','E10'))) 

            >>> 'port' in dict2 

            True 

            >>> 'port' not in dict2 

            False 

            >>> dict2.has_key('port') 

            True 

            >>>

    keys(), values(), items()

        keys()方法，返回一个列表，包含字典中所有的键.

        values()方法，返回一个列表，包含字典中所有的值.

        items(), 返回一个包含所有(键, 值)元组的列表.

        这些方法在不按任何顺序遍历字典的键或值时很有用。

        keys()方法很有用，它返回一个包含字典中所有键的列表，此方法可以与for 循环一起使用来 获取字典中的值。

            >>> dict2 = dict((('port',8043),('name','E10'))) 

            >>> dict2.keys() 

            ['port', 'name'] 

            >>> dict2.values() 

            [8043, 'E10'] 

            >>> dict2.items() 

            [('port', 8043), ('name', 'E10')] 

            >>> for eachKey in dict2.keys(): 

            ... print 'dict2 key ',eachKey, 'has value',dict2[eachKey] 

            ... 

            dict2 key port has value 8043 

            dict2 key name has value E10 

            >>>

    sorted() 内建函数

        sorted()的内建函数，返回 一个有序的迭代子:

            >>> for k in dict2: 

            ... print k,dict2[k] 

            ... 

            port 8043 

            name E10 

            >>>

            >>> for k in sorted(dict2): 

            ... print k,dict2[k] 

            ... 

            name E10 

            port 8043 

            >>>

    update()

        update()方法可以用来将一个字典的内容添加到另外一个字典中。

        字典中原有的键如果与新添 加的键重复，那么重复键所对应的原有条目的值将被新键所对应的值所覆盖。

        原来不存在的条目则被添加到字典中。

            >>> dict2= {'host':'earth', 'port':80} 

            >>> dict3= {'host':'venus', 'server':'http'} 

            >>> dict2.update(dict3) 

            >>> dict2 

            {'server': 'http', 'port': 80, 'host': 'venus'}

    clear() 

        clear()方法可以用来删除字典中的所有的条目。

            >>> dict3.clear() 

            >>> dict3 

            {}

    copy()

        copy() 方法返回一个字典的副本。注意这只是浅复制。

            >>> dict2 = {0:[],} 

            >>> dict2 

            {0: []} 

            >>> dict3= dict2.copy() 

            >>> dict3[0].append(1) 

            >>> dict3 

            {0: [1]} 

            >>> dict2 

            {0: [1]} 

            >>>

    get()

        get()方法和键查找(key-lookup)操作符( [ ] )相似，不同的是它允许你为不存在的 键提供默认值。

        如果该键不存在，也未给出它的默认值，则返回None。

        此方法比采用键查找(key-lookup)更灵活，因为你不必担心因键不存在而引发异常。

            >>> dict2 = {'host':'venus','port':80} 

            >>> dict2.get('host') 

            'venus' 

            >>> dict2.get('hello') 

            >>> dict2.get('hello','world') 

            'world' 

            >>>

    setdefault()

        setdefault()是自 2.0 才有的内建方法, 使得代码更加简洁，它实现了常用的语法: 检查字典 中是否含有某键。

        如果字典中这个键存在，你可以取到它的值。 

        如果所找的键在字典中不存在，你可以给这个键赋默认值并返回此值。

            >>> dict2 

            {'host': 'venus', 'port': 80} 

            >>> dict2.setdefault('port',8080) 

            80 

            >>> dict2.setdefault('prot','tcp') 

            'tcp' 

            >>> dict2 

            {'host': 'venus', 'prot': 'tcp', 'port': 80} 

            >>>

    fromkeys()

            >>> {}.fromkeys('xyz') 

            {'y': None, 'x': None, 'z': None} 

            >>> 

            >>> {}.fromkeys(('love', 'honor'), True) 

            {'love': True, 'honor': True}

            >>>

    iteritems(), iterkeys(), 和itervalues() 

        目前，keys(), items(), 和 values()方法的返回值都是列表。数据集如果很大会导致很难 处理，这也正是iteritems(), iterkeys(), 和itervalues() 方法被添加到 Python 2.2 的主要原因。

        这些函数与返回列表的对应方法相似，只是它们返回惰性赋值的迭代器，所以节省内存。

        未来的Python 版本中，甚至会更灵活，那时这些方法将会返回强大的对象，暂叫做视图(views)。

        视图(views)是访问容器对象的接口集。举例来说，你可以从一个视图(views)中删除某个字典的键，从而改变某个字典。

7.5 字典的键

    字典中的值没有任何限制，他们可以是任意Python 对象，即，从标准对象到用户自定义对象皆可。

    字典中的键是有类型限制的。

不允许一个键对应多个值

    你必须明确一条原则：每个键只能对应一个项。也就是说，一键对应多个值是不允许的。(像列 表、元组和其他字典这样的容器对象是可以的。) 

    当有键发生冲突(即，字典键重复赋值)，取最后(最近)的赋值。

    Python 并不会因字典中的键存在冲突而产生一个错误，它不会检查键的冲突是因为，如果真这 样做的话，在每个键-值对赋值的时候都会做检查，这将会占用一定量的内存。

            >>> foo = 'foo' 

            >>> dict3 = {foo:1, foo:2, foo:3}     # foo被替换2次

            >>> dict3 

            {'foo': 3} 

            >>> dict3[foo] = 4    # foo被替换1次

            >>> dict3 

            {'foo': 4} 

            >>>

键必须是可哈希的

    所有不可变的类型都是可哈希的，因此它们都可以做为字典的键，哈希值相同的对象具有相同的键(如 1 和 1.0)。

    一个实现了__hash__() 特殊方法的类，因为__hash__()方法返回一个整数，所以仍然是用不可变 的值(做字典的键)。

    用元组做有效的键，必须要加限制：元 组中只包括像数字和字符串这样的不可变参数，才可以作为字典中有效的键。

    为什么键必须是可哈希的？

        解释器调用哈希函数，根据字典中键的值来计算存储你的数据的位 置。

        如果键是可变对象，它的值可改变。

        如果键发生变化，哈希函数会映射到不同的地址来存储数据。

        如果这样的情况发生，哈希函数就不可能可靠地存储或获取相关的数据。

        选择可哈希的键的原因就是因为它们的值不能改变。

7.6 集合类型

        数学上， 把set 称做由不同的元素组成的集合，集合(set)的成员通常被称做集合元素(set elements)。

    Python 把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值。 

    是的，集合成员可以做字典中的键。数学集合转为Python 的集合对象很有效，集合关系测试和union、

    intersection 等操作符在Python 里也同样如我们所预想地那样工作。

        和其他容器类型一样，集合支持用 in 和 not in 操作符检查成员, 由 len() 内建函数得到集 

    合的基数(大小), 用for 循环迭代集合的成员。但是因为集合本身是无序的，你不可以为集合创建 

    索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。

    集合(sets)有两种不同的类型， 可变集合(set) 和  不可变集合(frozenset)。

    可变集合(set)不是可哈希的，因此既不能用做字典的键也不能做其他集合中的元素。

    不可变集合(frozenset)则正好相反，即，他们有哈希值，能被用做字典的键或是作为集合中的一个成员。

        表 7.3 集合操作符和关系符号

        数学符号            Python 符号        说明

        

如何创建集合类型和给集合赋值

    工厂方法 set()和 frozenset()

        集合与列表( [ ] )和字典( { } ) 不同，没有特别的语法格式。

        列表和字典可以分别用他们自 己的工厂方法 list() 和 dict() 创建，这也是集合被创建的唯一方法 - 用集合的工厂方法 set() 和 frozenset().

             >>> s = set('set')

            >>> s 

            set(['s', 'e', 't']) 

            >>> type(s) 

            <type 'set'> 

            >>> fs = frozenset('frozenset') 

            >>> fs 

            frozenset(['e', 'f', 'o', 'n', 's', 'r', 't', 'z']) 

            >>> type(fs) 

            <type 'frozenset'> 

            >>>

            >>> len(s) 

            3 

            >>> len(fs) 

            8 

            >>> s < fs 

            True 

            >>> 's' in s 

            True 

            >>>

如何访问集合中的值

    你可以遍历查看集合成员或检查某项元素是否是一个集合中的成员

        >>> 'k' in s 

        False 

        >>> 'k' in t 

        True 

        >>> 'c' not in t 

        True

        >>> for i in s:

        ... print i

如何更新集合

    用各种集合内建的方法和操作符添加和删除集合的成员

        >>> s.add('z') 

        >>> s 

        set(['c', 'e', 'h', 'o', 'p', 's', 'z']) 

        >>> s.update('pypi') 

        >>> s 

        set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y', 'z']) 

        >>> s.remove('z') 

        >>> s 

        set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y']) 

        >>> s -= set('pypi') 

        >>> s 

        set(['c', 'e', 'h', 'o', 's'])

    只有可变集合能被修改。试图修改不可变集合会引发异常。 

        >>> t.add('z') 

        Traceback (most recent call last): 

        File "<stdin>", line 1, in ? 

        AttributeError: 'frozenset' object has no attribute 'add'

如何删除集合中的成员和集合

    如何删除集合成员

        >>> s.remove('z')

    如何删除集合本身

        像删除任何Python 对象一样， 令集合超出它的作用范围，或调用del 将他们直接清除出当前的名字空间。

        如果它的引用计数为零，也会被标记以便被垃圾回收。

        >>> del s

        >>>

7.7 集合类型操作符

标准类型操作符（所有的集合类型）

    成员关系 (in, not in)

        就序列而言，Python 中的in 和not in 操作符决定某个元素是否是一个集合中的成员。

        >>> s = set('cheeseshop') 

        >>> t = frozenset('bookshop') 

        >>> 'k' in s 

        False 

        >>> 'k' in t 

        True 

        >>> 'c' not in t 

        True

    集合等价/不等价(==, !=)

        等价/不等价被用于在相同或不同的集合之间做比较。

        两个集合相等是指，对每个集合而言，当且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。

        两个集合相等是指，每个集合必须是另一个集合的一个子集， 即，s <= t 和 s >= t 的值均为真(True), 或(s <= t and s>= t) 的值为真(True)。

        集合等价/不等价与集合的类型或集合成员的顺序无关，只与集合的元素有关。

            >>> f = frozenset('bar') 

            >>> s=set() 

            >>> s.update(f) 

            >>> s 

            set(['a', 'r', 'b']) 

            >>> f==s 

            True 

            >>>

    子集/超集(<, <=, >, >=)

        "小于" 符号( <, <= )用来判断子集，"大于" 符号( >, >= )用来判断超集。

        "小于" 和 "大于" 意味着两个集合在比较时不能相等。

        等于号允许非严格定义的子集和超集。

            >>> s<f 

            False 

            >>> s<=f 

            True 

            >>>

集合类型操作符（所有的集合类型）

    联合( | )

        联合(union)操作和集合的OR(又称可兼析取(inclusive disjunction))其实是等价的.

        两个集 合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其中之一的成员。

        联合符号有一个等价的方法，union().

            >>> f = frozenset('frozenset') 

            >>> s = set('set') 

            >>> f 

            frozenset(['e', 'f', 'o', 'n', 's', 'r', 't', 'z']) 

            >>> s 

            set(['s', 'e', 't']) 

            >>> f|s 

            frozenset(['e', 'f', 'o', 'n', 's', 'r', 't', 'z']) 

            >>> f&s 

            frozenset(['s', 'e', 't']) 

            >>> f-s 

            frozenset(['r', 'n', 'z', 'o', 'f']) 

            >>>

    交集( & )

        交集操作比做集合的AND(或合取)操作.

        两个集合的交集是一个新集合，该集合中的每 个元素同时是两个集合中的成员，即，属于两个集合的成员。

        交集符号有一个等价的方法，intersection().

            >>> f&s 

            frozenset(['s', 'e', 't']) 

            >>> 

    差补/相对补集( – )

        两个集合(s 和t)的差补或相对补集是指一个集合C，该集合中的元素，只属于集合s，而不属于集合t。

        差符号有一个等价的方法，difference().

            >>> f-s

            frozenset(['r', 'n', 'z', 'o', 'f'])

            >>>

    对称差分( ^ )

        和其他的布尔集合操作相似，对称差分是集合的XOR(又称”异或“ (exclusive disjunction)).

        两个集合(s 和t)的对称差分是指另外一个集合C,该集合中的元素，只能是属于集合s 或者集合t 的成员，不能同时属于两个集合。

        对称差分有一个等价的方法，symmetric_difference().

            >>> f^s 

            frozenset(['f', 'o', 'n', 'r', 'z']) 

            >>>

混合集合类型操作 (是可变集合或不可变集合)

    如果左右两个操作数的类型相同，既都是可变集合或不可变集合, 则所产生的结果类型是相同 的.

    但如果左右两个操作数的类型不相同(左操作数是set，右操作数是frozenset，或相反情况)， 则所产生的结果类型与左操作数的类型相同.

集合类型操作符（仅适用于可变集合）

 

    (union) update ( |= )

        这个更新方法从已存在的集合中添加(可能多个)成员。

        此方法和update()等价.

    保留/交集更新( &= )

        保留(或交集更新)操作保留与其他集合的共有成员。

        此方法和intersection_update()等价.

    差更新 ( –= )

        对集合s 和t 进行差更新操作s-=t，差更新操作会返回一个集合，该集合中的成员是集合s 去除掉集合t 中元素后剩余的元素。

        此方法和difference_update()等价.

    对称差分更新( ^= )

        对集合s 和t 进行对称差分更新操作(s^=t),对称差分更新操作会返回一个集合，该集合中的成员仅是原集合s 或仅是另一集合t 中的成员。

        此方法和symmetric_difference_update()等价.

        >>> s = set('set') 

        >>> t |=s 

        >>> t 

        set(['s', 'e', 't']) 

        >>> t &=s 

        >>> t 

        set(['s', 'e', 't']) 

        >>> t -=s 

        >>> t 

        set([]) 

        >>> t ^=s 

        >>> t 

        set(['s', 'e', 't']) 

        >>>

7.8   集合内建函数

标准类型函数

    len()

        把集合作为参数传递给内建函数len()，返回集合的基数(或元素的个数)。

集合类型工厂函数

    set() and frozenset()

        set()和frozenset()工厂函数分别用来生成可变和不可变的集合。

        如果不提供任何参数，默认会生成空集合。

        如果提供一个参数，则该参数必须是可迭代的，即，一个序列，或迭代器，或支持迭代的一个对象.

7.9 集合类型内建方法

方法（所有的集合方法）

    内建方法copy() 没有等价的操作符，和同名的字典方法一样，copy()方法比用像 set(),frozenset(), 或dict()这样的工厂方法复制对象的副本要快。

    集合类型方法

        方法名称 操作

        s.issubset(t) 如果s 是t 的子集，则返回True,否则返回False

        s.issuperset(t) 如果t 是s 的超集，则返回True,否则返回False

        s.union(t) 返回一个新集合，该集合是s 和t 的并集

        s.intersection(t) 返回一个新集合，该集合是s 和t 的交集

        s.difference(t) 返回一个新集合，该集合是s 的成员，但不是t 的成员

        s.symmetric_difference(t) 返回一个新集合，该集合是s 或t 的成员，但不是s 和t 共有的成员

        s.copy() 返回一个新集合，它是集合s 的浅复制

 

        

 

         

方法（仅适用于可变集合）

    新的方法有 add(), remove(), discard(), pop(), clear(). 这些接受对象的方法，参数必 须是可哈希的。        

    可变集合类型的方法

        方法名 操作

        s.update(t) 用t 中的元素修改s, 即，s 现在包含s 或t 的成员

        s.intersection_update(t)             s 中的成员是共同属于s 和t 的元素。

        s.difference_update(t) s 中的成员是属于s 但不包含在t 中的元素

        s.symmetric_difference_update(t) s 中的成员更新为那些包含在s 或t 中，但不 是s和t 共有的元素

        s.add(obj)           在集合s 中添加对象obj

        s.remove(obj) 从集合s 中删除对象obj；如果obj 不是集合s 中的元素(obj notin s)，将引发KeyError 错误

        s.discard(obj) 如果obj 是集合s 中的元素，从集合s 中删除对象obj；

        s.pop() 删除集合s 中的任意一个对象，并返回它

        s.clear() 删除集合s 中的所有元素

 

        

操作符和内建方法比较

    当用操作符时，操作符两边的操作数必须是集合。 在使用内建方法时，对象也可以是 迭代类型的。

    Python 的文档里写明： 采用易懂的 set('abc').intersection('cbs') 可以避免用 set('abc') [and] 'cbs' 这样容易出错的构建方法。

7.10  集合操作符、函数和方法

    集合类型操作符、函数和方法(所有集合类型)

        函数/方法名 等价运算符说明

        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 中的所有元素