python-6:集合 之二 frozenset 无序不可变类集合

Posted 优雅的代码

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python-6:集合 之二 frozenset 无序不可变类集合相关的知识,希望对你有一定的参考价值。

set(可变集合)与frozenset(不可变集合)的区别
set无序排序且不重复,是可变的,有add(),remove()等方法。既然是可变的,所以它不存在哈希值。基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交集), difference(差集)和sysmmetric difference(对称差集)等数学运算. 
sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合,sets不记录元素位置或者插入点。因此,sets不支持 indexing, 或其它类序列的操作。
frozenset是冻结的集合,它是不可变的,存在哈希值,好处是它可以作为字典的key,也可以作为其它集合的元素。缺点是一旦创建便不能更改,没有add,remove方法。


一、集合的创建

set()和 frozenset()工厂函数分别用来生成可变和不可变的集合。如果不提供任何参数,默认
会生成空集合。如果提供一个参数,则该参数必须是可迭代的,即,一个序列,或迭代器,或支持
迭代的一个对象,例如:一个列表或一个字典。

复制代码
 1 >>> s=set(\'cheeseshop\')  使用工厂方法创建
 2 >>> s
 3 {\'h\', \'c\', \'o\', \'s\', \'e\', \'p\'}
 4 >>> type(s)
 5 <type \'set\'>
 6 
 7 >>> s={\'chessseshop\',\'bookshop\'}直接创建,类似于list的[]和dict的{},不同于dict的是其中的值,set会将其中的元素转换为元组
 8 >>> s
 9 {\'bookshop\', \'chessseshop\'}
10 >>> type(s)
11 <type \'set\'>
12 
13 不可变集合创建:
14 >>> t=frozenset(\'bookshop\')
15 >>> t
16 frozenset({\'h\', \'o\', \'s\', \'b\', \'p\', \'k\'})
复制代码

二、更新可变集合

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

复制代码
 1 >>> s.add(\'z\')  #添加
 2 >>> s
 3 set([\'c\', \'e\', \'h\', \'o\', \'p\', \'s\', \'z\'])
 4 >>> s.update(\'pypi\') #添加
 5 >>> s
 6 set([\'c\', \'e\', \'i\', \'h\', \'o\', \'p\', \'s\', \'y\', \'z\'])
 7 >>> s.remove(\'z\') #删除
 8 >>> s
 9 set([\'c\', \'e\', \'i\', \'h\', \'o\', \'p\', \'s\', \'y\'])
10 >>> s -= set(\'pypi\')#删除
11 >>> s
12 set([\'c\', \'e\', \'h\', \'o\', \'s\'])
13 >>> del s  #删除集合
复制代码

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

1 >>> t.add(\'z\')
2 Traceback (most recent call last):
3 File "<stdin>", line 1, in ?
4 AttributeError: \'frozenset\' object has no attribute \'add\'

三、成员关系 (in, not in)

1 >>> \'k\' in s
2 False
3 >>> \'k\' in t
4 True
5 >>> \'c\' not in t
6 True

四、集合等价/不等价

复制代码
1 >>> s == t
2 False
3 >>> s != t
4 True
5 >>> u = frozenset(s)
6 >>> s == u
7 True
8 >>> set(\'posh\') == set(\'shop\')
9 True
复制代码

五、子集/超集

1 >>> set(\'shop\') < set(\'cheeseshop\')
2 True
3 >>> set(\'bookshop\') >= set(\'shop\')
4 True

六、遍历访问集合中的值(可变集合和非可变都支持)

复制代码
 1 >>> s=set(\'cheeseshop\')
 2 >>> s
 3 {\'h\', \'c\', \'o\', \'s\', \'e\', \'p\'}
 4 >>> for i in s:
 5     print(i)    
 6 h
 7 c
 8 o
 9 s
10 e
11 p
12 
13 
14 >>> t=frozenset(\'bookshop\')
15 >>> t
16 frozenset({\'h\', \'o\', \'s\', \'b\', \'p\', \'k\'})
17 >>> for i in t:
18     print(i)    
19 h
20 o
21 s
22 b
23 p
24 k
复制代码

七、集合类型操作符(所有的集合类型)

1.联合( | )

1 两个集合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员,即,属于两个集合其中之一的成员。联合符号有一个等价的方法,union().
2 >>> s | t
3 set([\'c\', \'b\', \'e\', \'h\', \'k\', \'o\', \'p\', \'s\'])

2.交集( & )

1 你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合,该集合中的每
2 个元素同时是两个集合中的成员,即,属于两个集合的成员。交集符号有一个等价的方法,intersection()
3 >>> s & t
4 set([\'h\', \'s\', \'o\', \'p\']

3.差补/相对补集( – )

1 两个集合(s 和 t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属
2 于集合 t。差符号有一个等价的方法,difference().
3 >>> s - t
4 set([\'c\', \'e\'])

4.对称差分( ^ )

1 和其他的布尔集合操作相似, 对称差分是集合的 XOR(又称"异或 ").
2 两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素,只能是属于集合 s 或者集合 t
3 的成员,不能同时属于两个集合。对称差分有一个等价的方法,symmetric_difference().
4 >>> s ^ t
5 set([\'k\', \'b\', \'e\', \'c\'])

5.混合集合类型操作

复制代码
1 上面的示例中,左边的 s 是可变集合,而右边的 t 是一个不可变集合. 注意上面使用集合操作
2 运算符所产生的仍然是可变集合,但是如果左右操作数的顺序反过来,结果就不一样了:
3 >>> t | s
4 frozenset([\'c\', \'b\', \'e\', \'h\', \'k\', \'o\', \'p\', \'s\'])
5 >>> t ^ s
6 frozenset([\'c\', \'b\', \'e\', \'k\'])
7 >>> t - s frozenset([\'k\', \'b\'])
复制代码

如果左右两个操作数的类型相同, 既都是可变集合或不可变集合, 则所产生的结果类型是相同
的,但如果左右两个操作数的类型不相同(左操作数是 set,右操作数是 frozenset,或相反情况),
所产生的结果类型与左操作数的类型相同。

八、可变集合类型的方法

 

复制代码
 1 s.update(t) 用 t 中的元素修改 s, 即,s 现在包含 s 或 t 的成员
 2 s.intersection_update(t) s 中的成员是共同属于 s 和 t 的元素。
 3 s.difference_update(t) s 中的成员是属于 s 但不包含在 t 中的元素
 4 s.symmetric_difference_update(t) s 中的成员更新为那些包含在 s 或 t 中,但不 是 s
 5 和 t 共有的元素
 6 s.add(obj) 在集合 s 中添加对象 obj
 7 s.remove(obj) 从集合 s 中删除对象 obj;如果 obj 不是集合 s 中的元素(obj not
 8 in s),将引发 KeyError 错误
 9 s.discard(obj) 如果 obj 是集合 s 中的元素,从集合 s 中删除对象 obj;
10 s.pop() 删除集合 s 中的任意一个对象,并返回它
11 s.clear() 删除集合 s 中的所有元素
复制代码

九、集合类型操作符、函数和方法

函数/方法名 等价运算符 说明
所有集合类型:

复制代码
 1 len(s) 集合基数: 集合 s 中元素的个数
 2 set([obj]) 可变集合工厂函数; obj 必须是支持迭代的,由 obj 中
 3 的元素创建集合,否则创建一个空集合
 4 frozenset([obj]) 不可变集合工厂函数; 执行方式和 set()方法相同,
 5 但它返回的是不可变集合
 6 obj in s 成员测试:obj 是 s 中的一个元素吗?
 7 obj not in s 非成员测试:obj 不是 s 中的一个元素吗?
 8 s == t 等价测试: 测试 s 和 t 是否具有相同的元素?
 9 s != t 不等价测试: 与==相反
10 s < t (严格意义上)子集测试; s != t 而且 s 中 所 有
11 的元素都是 t 的成员
12 s.issubset(t) s <= t 子集测试(允许不严格意义上的子集): s 中所有的元素
13 都是 t 的成员
14 s > t (严格意义上)超集测试: s != t 而且 t 中所有的元素
15 都是 s 的成员
16 s.issuperset(t) s >= t 超集测试(允许不严格意义上的超集): t 中所有的元素
17 都是 s 的成员
18 s.union(t) s | t 合并操作: s 或 t 中的元素
19 s.intersec- tion(t) s & t 交集操作: s 和 t 中的元素
20 s.difference(t) s - t 差分操作: s 中的元素,而不是 t 中的元素
21 s.symmetric_difference(t)s ^ t 对称差分操作:s 或 t 中的元素,但不是 s 和 t 共有
22 的元素
23 s.copy() 复制操作:返回 s 的(浅复制)副本
复制代码

仅用于可变集合:

复制代码
 1 s.update(t) s |= t (Union) 修改操作: 将 t 中的成员添加 s
 2 s.intersection_update(t) s &= t 交集修改操作: s 中仅包括 s 和 t 中共有的成员
 3 s.difference_update(t) s -= t 差修改操作: s 中包括仅属于 s 但不属于 t 的成员
 4 s.symmetric_
 5 difference_
 6 update(t) s ^= t 对称差分修改操作: s 中包括仅属于 s 或仅属于 t 的
 7 成员
 8 s.add(obj) 加操作: 将 obj 添加到 s
 9 s.remove(obj) 删除操作: 将 obj 从 s 中删除;如果 s 中不存在
10 obj,将引发 KeyError
11 s.discard(obj) 丢弃操作: remove() 的 友 好 版 本 - 如
12 果 s 中存在 obj,
13 从 s 中删除它
14 s.pop() Pop 操作: 移除并返回 s 中的任意一个元素
15 s.clear() 清除操作: 移除 s 中的所有元素
复制代码

以上是关于python-6:集合 之二 frozenset 无序不可变类集合的主要内容,如果未能解决你的问题,请参考以下文章

LoadRunner之二“集合点”

python的循環之二

python的循環之二

Collection方法之二 向集合中添加自定义的元素

Java_集合之二

Java 集合系列之二:List基本操作