1. set类型本身是可变的，由此其内容可以使用 add() 和 remove() 这样的方法来改变
2. set 元素是由具有唯一性的hashable对象所组成的无序多项集，由此其元素不重复
3. 由上，集合并不记录元素位置或插入顺序。 相应地，集合不支持下标、切片或其他序列类的操作
4. 由于set类型本身是可变的，不具有hash值，而set的元素必须是hashable，因此一个set对象不可作为另一个set的元素
5. frozenset是set的不可变版本，可作为另一个set的一个元素存在

1. 使用花括号内以逗号分隔元素的方式: {'jack', 'sjoerd'}
2. 使用集合推导式: {c for c in 'abracadabra' if c not in 'abc'}
3. 使用类型构造器: set(), set('foobar'), set(['a', 'b', 'foo'])

• len(s) 返回集合 s 中的元素数量（即 s 的基数）。
• x in s 检测 x 是否为 s 中的成员。

• x not in s 检测 x 是否非 s 中的成员。
• s.isdisjoint(other) 如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。
• s.issubset(other)
• set <= other 检测是否集合中的每个元素都在 other 之中。
• set < other 检测集合是否为 other 的真子集，即 set <= other and set != other。
• s.issuperset(other)
• set >= other 检测是否 other 中的每个元素都在集合之中。
• set > other 检测集合是否为 other 的真超集，即 set >= other and set != other。
• s.union(*others) set | other | ... 并集运算，返回一个新集合，其中包含来原集合和others指定集合中的所有去重的元素。
• s.intersection(*others) set & other & ... 交集运算，返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。
• s.difference(*others) set - other - ... 差集运算，返回一个新集合，其中包含存在于原集合中但在 others 指定的集合中不存在的元素。
• s.symmetric_difference(other) set ^ other 对称差运算，返回一个新集合，其中包含交集元素之外的元素。
• s.copy() 返回原集合的浅拷贝。

• s.update(*others) set |= other | ... 交集更新，添加来自 others 中的所有元素，去重。
• s.intersection_update(*others) set &= other & ...并集更新，只保留其中在所有 others 中也存在的元素。
• s.difference_update(*others) set -= other | ... 差集更新，移除其中也存在于 others 中的元素。
• s.symmetric_difference_update(other) set ^= other 对称差更新，只保留存在于集合的一方而非共同存在的元素。
• s.add(elem) 将元素 elem 添加到集合中。
• s.remove(elem) 从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发 KeyError。
• s.discard(elem) 如果元素 elem 存在于集合中则将其移除。
• s.pop() 从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError。
• s.clear() 从集合中移除所有元素。

1. dict属于可变对象，因此dict对象本身非hashable
2. 字典的键 几乎 可以是任何值。 非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键

• 使用花括号内以逗号分隔 键: 值 对的方式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}
• 使用字典推导式: {}, {x: x ** 2 for x in range(10)}
• 使用类型构造器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)
• 如果没有给出位置参数，将创建一个空字典：dict()
• 如果给出位置参数并且其属于映射对象，将创建一个具有与映射对象相同键值对的字典。映射对象包括：字典dict、collections.defaultdict, collections.OrderedDict 以及 collections.Counter
• 如果给出位置参数但是其并非一个映射对象，那么就必须是一个可迭代的对象，并且该可迭代对象中的每一个元素本身必须为一个刚好包含两个子元素的可迭代对象：dict([('foo', 100), ('bar', 200)])
• 如果一个键出现一次以上，该键的最后一个值将成为其在新字典中对应的值。
• 如果给出了关键字参数，则关键字参数及其值会被加入到基于位置参数创建的字典。 如果要加入的键已存在，来自关键字参数的值将替代来自位置参数的值。

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f

• key in d 如果 d 中存在键 key 则返回 True，否则返回 False。
• key not in d 等价于 not key in d。
• == 当且仅当两个字典具有相同的 (键, 值) 对时才会相等（不考虑顺序）。 排序比较 ('<', '<=', '>=', '>') 会引发 TypeError。
• list(d) 返回字典 d 中使用的所有键的列表。
• len(d) 返回字典 d 中的项数。
• d[key] 返回 d 中key的值。 除非定义了__missing__()方法，否则如果映射中不存在 key 则会引发 KeyError。
• d.get(key[, default])如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。
• d[key] = value 将 d[key] 的值设为 value。
• del d[key] 将 d[key] 项从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。
• d.clear() 移除字典中的所有元素。
• d.copy() 返回原字典的浅拷贝。
• iter(d) 返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。
• reversed(d) 返回一个逆序获取字典键的迭代器。 这是 reversed(d.keys()) 的快捷方式。
• fromkeys(iterable[, value]) 是一个返回新字典的类方法，使用来自 iterable 的键创建一个新字典，并将键值设为 value。value 默认为 None。
• d.pop(key[, default]) 如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。
• d.popitem() 从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回。适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。 如果字典为空，将引发 KeyError。
• setdefault(key[, default])如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。
• d.update([other]) 使用来自 other 的键/值对更新字典，如果other中的key与原字典中的key重复，则覆盖原有的值。other可以是一个字典对象，也可以是一个包含键/值对（以长度为二的元组或其他可迭代对象表示）的可迭代对象。 如果给出了关键字参数，则会以其所指定的键/值对更新字典: d.update(red=1, blue=2)。
• d | other 合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。
• d |= other 用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。
• d.items() 返回：dict_items([(key1, value1), (key2, value2), (key3, value3), ...])
• d.keys() 返回：dict_keys([key1, key2, key3, ...])
• d.values() 返回：dict_values([value1, value1, value1, ...])