>>> s=set('cheeseshop')  使用工厂方法创建

 >>> s

 {'h', 'c', 'o', 's', 'e', 'p'}

 >>> type(s)

 <type 'set'>

 >>> s={'chessseshop','bookshop'}直接创建，类似于list的[]和dict的{}，不同于dict的是其中的值，set会将其中的元素转换为元组

 >>> s

 {'bookshop', 'chessseshop'}

 >>> type(s)

 <type 'set'>

 不可变集合创建：

 >>> t=frozenset('bookshop')

 >>> t

 frozenset({'h', 'o', 's', 'b', 'p', 'k'})

 >>> 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'])

 >>> del s  #删除集合

 >>> t.add('z')

 Traceback (most recent call last):

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

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

 >>> 'k' in s

 False

 >>> 'k' in t

 True

 >>> 'c' not in t

 True

 >>> s == t

 False

 >>> s != t

 True

 >>> u = frozenset(s)

 >>> s == u

 True

 >>> set('posh') == set('shop')

 True

 >>> set('shop') < set('cheeseshop')

 True

 >>> set('bookshop') >= set('shop')

 True

 >>> s=set('cheeseshop')

 >>> s

 {'h', 'c', 'o', 's', 'e', 'p'}

 >>> for i in s:

     print(i)

 h

 c

 o

 s

 e

 p

 >>> t=frozenset('bookshop')

 >>> t

 frozenset({'h', 'o', 's', 'b', 'p', 'k'})

 >>> for i in t:

     print(i)

 h

 o

 s

 b

 p

 k

 两个集合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其中之一的成员。联合符号有一个等价的方法，union().

 >>> s | t

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

 你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合，该集合中的每

 个元素同时是两个集合中的成员，即，属于两个集合的成员。交集符号有一个等价的方法，intersection()

 >>> s & t

 set(['h', 's', 'o', 'p']

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

 于集合 t。差符号有一个等价的方法，difference().

 >>> s - t

 set(['c', 'e'])

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

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

 的成员，不能同时属于两个集合。对称差分有一个等价的方法，symmetric_difference().

 >>> s ^ t

 set(['k', 'b', 'e', 'c'])

 上面的示例中，左边的 s 是可变集合，而右边的 t 是一个不可变集合. 注意上面使用集合操作

 运算符所产生的仍然是可变集合,但是如果左右操作数的顺序反过来，结果就不一样了:

 >>> t | s

 frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])

 >>> t ^ s

 frozenset(['c', 'b', 'e', 'k'])

 >>> t - s frozenset(['k', 'b'])

 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 not

 in s)，将引发 KeyError 错误

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

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

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

 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.intersec- tion(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 中的所有元素