第040讲：集合（下）

小古比鱼

集合分为可变集合与不可变集合。上节介绍的方法不会对集合内容进行改动，适用于所有集合；本节介绍的方法会对集合内容进行改动，故仅适用于可变集合。其中，add()方法是将传入的字符串整体作为一个元素插入集合中，与update()等方法迭代获取传入字符串中的每一个字符进行处理有所不同；remove()方法与discard()方法的区别在于当指定的元素不存在时，前者会抛出KeyError异常，后者则不会抛出异常。
后半节讲解了“可哈希”的概念，即某个对象的哈希值（可通过内置函数hash()来获取）在其整个程序的生命周期中保持不变。Python中大多数不可变对象都是可哈希的，而可变对象则是不可哈希的，这有点类似于Python对象的唯一标识值id，增量赋值后可变序列的id值不改变，不可变序列的id值会改变！字典的键和集合的元素都必须是可哈希的，故不能为可变对象；字典和集合本身是可变对象，不可哈希，故不可直接实现嵌套，但使用不可变集合却可以实现嵌套！
本节最后还讲了一个“奇技淫巧”——将列表转换成集合可以大幅提升程序的执行效率，因为集合的背后有散列表的支持，而列表则没有；换句话说，列表的每次查找都需要从头到尾地扫描，而集合则只需要简单的查表操作。以空间换时间，这也正是字典和集合高效背后的玄机！

wangtuan

1. >>> ['frozenset()  对象是不可变的']
   
2. ['frozenset()  对象是不可变的']
   
3. >>> t = frozenset('FishC')
   
4. >>> t
   
5. frozenset({'C', 'i', 's', 'F', 'h'})
   
6. >>> s = set('FishC')
   
7. >>> s
   
8. {'C', 'i', 's', 'F', 'h'}
   
9. >>> s.update([1,1],'23')
   
10. >>> s
    
11. {1, 'C', '3', 'i', '2', 's', 'F', 'h'}
    
12. >>> t.update([1,1],'23')
    
13. Traceback (most recent call last):
    
14.   File "<pyshell#7>", line 1, in <module>
    
15.     t.update([1,1],'23')
    
16. AttributeError: 'frozenset' object has no attribute 'update'
    
17. >>> s.intersection_update('FishC')
    
18. >>> s
    
19. {'C', 'i', 's', 'F', 'h'}
    
20. >>> s.difference_update('Php','Python')
    
21. >>> s
    
22. {'C', 'i', 's', 'F'}
    
23. >>> s.symmetric_difference_update('Python')
    
24. >>> s
    
25. {'t', 'C', 'P', 'h', 'i', 'n', 'y', 's', 'F', 'o'}
    
26. >>> ['上节课讲到的 没有update, 他们只是返回计算结果，而加上update 之后，是对集合进行更新']
    
27. ['上节课讲到的 没有update, 他们只是返回计算结果，而加上update 之后，是对集合进行更新']
    
28. >>> ['s.update()  即是 s.unionupdate(),即是合并集合']
    
29. ['s.update()  即是 s.unionupdate(),即是合并集合']
    
30. >>> s.add('45')
    
31. >>> s
    
32. {'t', 'C', '45', 'P', 'h', 'i', 'n', 'y', 's', 'F', 'o'}
    
33. >>> ['add() 方法与 update() 方法不同，前者是将整个字符串当作一个元素插入集合，而后者是将字符串 分开呈一个个元素后再插入集合']
    
34. ['add() 方法与 update() 方法不同，前者是将整个字符串当作一个元素插入集合，而后者是将字符串 分开呈一个个元素后再插入集合']
    
35. >>> s.remove('晚买')
    
36. Traceback (most recent call last):
    
37.   File "<pyshell#19>", line 1, in <module>
    
38.     s.remove('晚买')
    
39. KeyError: '晚买'
    
40. >>> s.discard('晚买')
    
41. >>> s
    
42. {'t', 'C', '45', 'P', 'h', 'i', 'n', 'y', 's', 'F', 'o'}
    
43. >>> s.pop()
    
44. 't'
    
45. >>> s.pop()
    
46. 'C'
    
47. >>> s.pop()
    
48. '45'
    
49. >>> s.pop()
    
50. 'P'
    
51. >>> s
    
52. {'h', 'i', 'n', 'y', 's', 'F', 'o'}
    
53. >>> s.clear()
    
54. >>> s
    
55. set()
    
56. >>> ['集合元素的删除，可以使用 remove() 方法和 discard() 方法，两者的区别是，如果要删除的元素原集合中没有，那么前者就会报错，而后者会静默处理； pop() 方法是随机剔除集合中的一个元素；  clear() 则是将一个集合变为一个空集合']
    
57. ['集合元素的删除，可以使用 remove() 方法和 discard() 方法，两者的区别是，如果要删除的元素原集合中没有，那么前者就会报错，而后者会静默处理； pop() 方法是随机剔除集合中的一个元素；  clear() 则是将一个集合变为一个空集合']
    
58. >>> ['通过 hash() 函数可以获得一个对象的 哈希 值']
    
59. ['通过 hash() 函数可以获得一个对象的 哈希 值']
    
60. >>> hash(1)
    
61. 1
    
62. >>> hash(1.0)
    
63. 1
    
64. >>> hash(1.001)
    
65. 2305843009213441
    
66. >>> ['整数的 哈希 值是整数，两个相同值的  哈希 值是相同的']
    
67. ['整数的 哈希 值是整数，两个相同值的  哈希 值是相同的']
    
68. >>> ['Python 中 大多不可变的对象都是 可哈希 的，而可变的对象都是 不可哈希 的，可哈希 就是其哈希值是不变的']
    
69. ['Python 中 大多不可变的对象都是 可哈希 的，而可变的对象都是 不可哈希 的，可哈希 就是其哈希值是不变的']
    
70. >>> hash('FishC')
    
71. -5249203814098794668
    
72. >>> hash([1,2,3])
    
73. Traceback (most recent call last):
    
74.   File "<pyshell#37>", line 1, in <module>
    
75.     hash([1,2,3])
    
76. TypeError: unhashable type: 'list'
    
77. >>> ['如上所示：字符串是不可变的，其有哈希值，而列表是可变的，因此其没有哈希值']
    
78. ['如上所示：字符串是不可变的，其有哈希值，而列表是可变的，因此其没有哈希值']
    
79. >>> hash((1,2,3))
    
80. 529344067295497451
    
81. >>> {'Python':520,'FishC':1314}
    
82. {'Python': 520, 'FishC': 1314}
    
83. >>> {[1,2,3]:'FishC'}
    
84. Traceback (most recent call last):
    
85.   File "<pyshell#41>", line 1, in <module>
    
86.     {[1,2,3]:'FishC'}
    
87. TypeError: unhashable type: 'list'
    
88. >>> ['可哈希的对象才可以作为 键，因此上述不可哈希的列表不能作为字典的键']
    
89. ['可哈希的对象才可以作为 键，因此上述不可哈希的列表不能作为字典的键']
    
90. >>> {'Python','FishC',520,1314}
    
91. {520, 1314, 'FishC', 'Python'}
    
92. >>> {'Python','FishC',520,1314,[1,2,3]}
    
93. Traceback (most recent call last):
    
94.   File "<pyshell#44>", line 1, in <module>
    
95.     {'Python','FishC',520,1314,[1,2,3]}
    
96. TypeError: unhashable type: 'list'
    
97. >>> x = {1,2,3}
    
98. >>> y = {x,4,5}
    
99. Traceback (most recent call last):
    
100.   File "<pyshell#46>", line 1, in <module>
     
101.     y = {x,4,5}
     
102. TypeError: unhashable type: 'set'
     
103. >>> ['上述嵌套集合中 x 是可变的，因此不能作为 键']
     
104. ['上述嵌套集合中 x 是可变的，因此不能作为 键']
     
105. >>> x = frozenset(x)
     
106. >>> y = {x,4,5}
     
107. >>> y
     
108. {frozenset({1, 2, 3}), 4, 5}
     
109. >>>

复制代码

码农心

阿西吧什么时候我是一个成功过的人呢

JZt2902019046

打卡

基柯克

小甲鱼真的很用心，谢谢你啊

chenjinchao

卡打

sunshine_8205

已经迷糊了

墨墨在努力吖

滴滴滴~打卡

migu_sm1

Learning...

andyleesh

打卡

小蜂队

集合分为可变集合和不可变集合，set() 为一般集合，frozenset() 是不可变集合，对集合做变动操作是对于可变集合来说，add() 方法是将传入的字符串整体作为一个元素插入集合中，与update() 等方法迭代获取字符串的每一位字节处理不同；remove() 方法与 discard() 方法的区别在于指定的元素不存在时 ，前者会抛出 KeyError 异常，后者则不会抛出异常。哈希即：某个对象的哈希值（可通过内置函数hash() 来获取），在其整给程序的生命周期中保持不变，python 中大多数不可变对象都是可哈希的，而不可变对象都是不可哈希的，同时将列表转换成集合能够大幅度提升程序的执行效率，因为集合的背后有散列表的支持，而列表则没有，换句话，列表的每次查询都是从头到尾的扫描，而集合则只需要简单的查表操作。

Wynn_0303

打卡

jioug

继续坚持学习  但好像前面学习过的又忘记了

学爬虫的先生

集合（下）
        1. 冻结的集合
                >>> t = frozenset("FishC")
>>> t
frozenset({'s', 'C', 'i', 'F', 'h'})
        2.适用于set()对象的方法
                update(*others) 方法使用 others 容器中的元素来更新集合
                        >>> s = set("FishC")
>>> s
{'s', 'C', 'i', 'F', 'h'}
>>> s.update([1, 1], "23")
>>> s
{'s', 1, 'C', 'i', 'F', 'h', '3', '2'}
                intersection_update(*others) 交集
                         s.intersection_update("FishC")
>>> s
{'s', 'C', 'i', 'F', 'h'}
                difference_update(*others) 差集
                        s.difference_update("Php", "Python")
>>> s
{'s', 'C', 'i', 'F'}
                symmetric_difference_update(other) 对称差集
                        s.symmetric_difference_update("Python")
>>> s
{'s', 't', 'C', 'o', 'h', 'i', 'y', 'F', 'n', 'P'}
                add()方法 添加一个数据
                        >>> s.add("45")
>>> s
{'s', 't', 'C', 'o', 'h', 'i', 'y', 'F', '45', 'n', 'P'}
                删除数据
                         remove(elem) 指定字符
                                 s.remove("瓦迈")
                        discard(elem) 静默删除
                                s.discard("瓦迈")
                        pop() 方法 用于随机从集合中弹出一个元素
                                >>> s.pop()
's'
>>> s.pop()
't'
>>> s.pop()
'C'
>>> s
{'o', 'h', 'i', 'y', 'F', '45', 'n', 'P'}
                        clear() 方法 将集合清空
                                >>> s.clear()
>>> s
set()
                可哈希
                         hash() 函数 轻松获取一个对象的哈希值
                                >>> hash(1)
1
>>> hash(1.0)
1
>>> hash(1.001)
2305843009213441
        嵌套的集合
                不可变集合 “冰山美人” frozenset() 对象
                        >>> x = frozenset(x)
>>> y = {x, 4, 5}
>>> y
{frozenset({1, 2, 3}), 4, 5}

来自成都的momo

一周过去了才学个二十集我真的会谢

xiaohongchen

紫藤竹轩

有点迷糊了。

万恶的亚撒西

好多内容，好好学习-20250529