qidao123.com技术社区-IT企服评测·应用市场

标题: python中set和frozenset方法和区别 [打印本页]
作者: 老婆出轨    时间: 2023-5-17 17:17
标题: python中set和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'>
  7. >>> s={'chessseshop','bookshop'}#直接创建，类似于list的[]和dict的{}，不同于dict的是其中的值，set会将其中的元素转换为元组
  8. >>> s
  9. {'bookshop', 'chessseshop'}
  10. >>> type(s)
  11. <type 'set'>
  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
  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.联合( | )
两个集合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其中之一的成员。联合符号有一个等价的方法，union().
  1. >>> s | t
  2. set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
复制代码
2.交集( & )
你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合，该集合中的每个元素同时是两个集合中的成员，即，属于两个集合的成员。交集符号有一个等价的方法，intersection()
  1. >>> s & t
  2. set(['h', 's', 'o', 'p']
复制代码
3.差补/相对补集( – )
两个集合(s 和 t)的差补或相对补集是指一个集合 C，该集合中的元素，只属于集合 s，而不属于集合 t。差符号有一个等价的方法，difference().
  1. >>> s - t
  2. set(['c', 'e'])
复制代码
4.对称差分( ^ )
和其他的布尔集合操作相似， 对称差分是集合的 XOR(又称"异或 ").
两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素，只能是属于集合 s 或者集合 t的成员，不能同时属于两个集合。对称差分有一个等价的方法，symmetric_difference().
  1. >>> s ^ t
  2. set(['k', 'b', 'e', 'c'])
复制代码
5.混合集合类型操作
上面的示例中，左边的 s 是可变集合，而右边的 t 是一个不可变集合. 注意上面使用集合操作运算符所产生的仍然是可变集合,但是如果左右操作数的顺序反过来，结果就不一样了:
  1. >>> t | s
  2. frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
  3. >>> t ^ s#Python小白学习交流群：711312441
  4. frozenset(['c', 'b', 'e', 'k'])
  5. >>> 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 中的所有元素
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/) Powered by Discuz! X3.4