第039讲：集合（上）

小古比鱼

集合与字典关系“暧昧”，具有唯一性（互异性，可用于查重或去重）和无序性（随机性）。本节讲解了创建集合的三种方式，集合的基本操作以及集合的部分内置方法，涉及子集（真子集）、超集（真超集）、并集、交集、差集、对称差集（并集与交集的差集）等集合相关概念，既可用集合的内置方法来实现，亦可用简易的运算符来实现，灵活方便！需要注意的是，使用运算符操作时符号两边都必须是集合类型的数据，而使用方法操作时参数可以是任意可迭代对象。

wangtuan

1. >>> type({})
   
2. <class 'dict'>
   
3. >>> type({"one"})
   
4. <class 'set'>
   
5. >>> type({"one":1})
   
6. <class 'dict'>
   
7. >>> ['集合中所有元素都应该是独一无二的，并且也是无序的']
   
8. ['集合中所有元素都应该是独一无二的，并且也是无序的']
   
9. >>> {'FishC','Python'}
   
10. {'FishC', 'Python'}
    
11. >>> {s for s in "FishC"}
    
12. {'C', 's', 'h', 'i', 'F'}
    
13. >>> set("FishC")
    
14. {'C', 's', 'h', 'i', 'F'}
    
15. >>> ['由于集合是无序的，所以我们不能使用下标索引的方式进行访问']
    
16. ['由于集合是无序的，所以我们不能使用下标索引的方式进行访问']
    
17. >>> s = set('FishC')
    
18. >>> S[0]
    
19. Traceback (most recent call last):
    
20.   File "<pyshell#9>", line 1, in <module>
    
21.     S[0]
    
22. NameError: name 'S' is not defined
    
23. >>> 'C' in s
    
24. True
    
25. >>> 'c' not in s
    
26. True
    
27. >>> for each in s:
    
28.         print(each)
    
29. 
    
30.        
    
31. C
    
32. s
    
33. h
    
34. i
    
35. F
    
36. >>> set([1,1,2,3,5])
    
37. {1, 2, 3, 5}
    
38. >>> ['如上所示，因为集合内所有元素是唯一的，所以可以进行去重的效果']
    
39. ['如上所示，因为集合内所有元素是唯一的，所以可以进行去重的效果']
    
40. >>> s = [1,1,2,3,5]
    
41. >>> len(s) == len(set(s))
    
42. False
    
43. >>> ['上述判断既可以用来判断序列中是否有重复的元素，如果二者相等，则没有重复的元素，否则就有重复的元素']
    
44. ['上述判断既可以用来判断序列中是否有重复的元素，如果二者相等，则没有重复的元素，否则就有重复的元素']
    
45. >>> t = s.copy()
    
46. >>> t
    
47. [1, 1, 2, 3, 5]
    
48. >>> s = set('FishC')
    
49. >>> S
    
50. Traceback (most recent call last):
    
51.   File "<pyshell#23>", line 1, in <module>
    
52.     S
    
53. NameError: name 'S' is not defined
    
54. >>> s
    
55. {'C', 's', 'h', 'i', 'F'}
    
56. >>> s.isdisjoint(set('Python'))
    
57. False
    
58. >>> s.isdisjoint(set('Java'))
    
59. True
    
60. >>> ['a.isdisjoint(b) 即是用来判断 a 和 b 两个集合是否有交集' ]
    
61. ['a.isdisjoint(b) 即是用来判断 a 和 b 两个集合是否有交集']
    
62. >>> s.isdisjoint('Java')
    
63. True
    
64. >>> s.isdisjoint('Python')
    
65. False
    
66. >>> ['如果要检测某一个集合是否是另一个集合的子集，可以使用 issubset() 方法']
    
67. ['如果要检测某一个集合是否是另一个集合的子集，可以使用 issubset() 方法']
    
68. >>> s.issubset('FishC.com.cn')
    
69. True
    
70. >>> ['如果要检测某一个集合是否是另一个集合的超集，可以使用 issuperset() 方法']
    
71. ['如果要检测某一个集合是否是另一个集合的超集，可以使用 issuperset() 方法']
    
72. >>> s.issupperset('Fish')
    
73. Traceback (most recent call last):
    
74.   File "<pyshell#33>", line 1, in <module>
    
75.     s.issupperset('Fish')
    
76. AttributeError: 'set' object has no attribute 'issupperset'
    
77. >>> s.issuperset('Fish')
    
78. True
    
79. >>> ['并集--将集合与其他集合的元素合并在一起']
    
80. ['并集--将集合与其他集合的元素合并在一起']
    
81. >>> s.union({1,2,3})
    
82. {'F', 1, 2, 'C', 's', 'h', 'i', 3}
    
83. >>> ['交集就是找到多个集合之间共同的那些元素，使用 intrsection() 方法']
    
84. ['交集就是找到多个集合之间共同的那些元素，使用 intrsection() 方法']
    
85. >>> s.intersection('Fish')
    
86. {'F', 's', 'h', 'i'}
    
87. >>> ['差集--对于两个集合A、B，由所有属于集合A且不属于集合B的元素所组成的集合，叫做集合A与集合B的差集']
    
88. ['差集--对于两个集合A、B，由所有属于集合A且不属于集合B的元素所组成的集合，叫做集合A与集合B的差集']
    
89. >>> s.difference('Fish')
    
90. {'C'}
    
91. >>> s.union({1,2,3},'Python')
    
92. {1, 2, 3, 'C', 'h', 'i', 'P', 't', 's', 'y', 'n', 'F', 'o'}
    
93. >>> s.intersection('Php','Python')
    
94. {'h'}
    
95. >>> s.difference('Php','Python')
    
96. {'F', 'C', 's', 'i'}
    
97. >>> ['上述方法都是可以同时有多个参数的']
    
98. ['上述方法都是可以同时有多个参数的']
    
99. >>> ['对称差集--对于两个集合A、B，先排除集合A与集合B的所有共同元素，由剩余的元素组成的集合，叫做集合A与集合B的对称差集']
    
100. ['对称差集--对于两个集合A、B，先排除集合A与集合B的所有共同元素，由剩余的元素组成的集合，叫做集合A与集合B的对称差集']
     
101. >>> s.symmetric_difference('Python')
     
102. {'t', 'C', 's', 'i', 'y', 'n', 'F', 'P', 'o'}
     
103. >>> s <= set('FishC')
     
104. True
     
105. >>> s < set('FishC')
     
106. False
     
107. >>> s < set('FishC.com.cn')
     
108. True
     
109. >>> s > set('FishC')
     
110. False
     
111. >>> s >= set('FishC')
     
112. True
     
113. >>> s | {1,2,3} | set('Python')
     
114. {'t', 1, 2, 3, 'C', 's', 'h', 'i', 'y', 'n', 'F', 'P', 'o'}
     
115. >>> s & set('Php') & set('Python')
     
116. {'h'}
     
117. >>> s - set('Php') - set('Python')
     
118. {'F', 's', 'C', 'i'}
     
119. >>> s ^ set('Python')
     
120. {'C', 'i', 'P', 't', 's', 'n', 'y', 'F', 'o'}
     
121. >>> ['使用运算符，符号两边都必须是集合类型']
     
122. ['使用运算符，符号两边都必须是集合类型']
     
123. >>> s <= 'FishC'
     
124. Traceback (most recent call last):
     
125.   File "<pyshell#57>", line 1, in <module>
     
126.     s <= 'FishC'
     
127. TypeError: '<=' not supported between instances of 'set' and 'str'
     
128. >>> ['运算符号  <  <=  是表示是否为子集，  >  >= 是表示是否为超集，   | 表示并集， & 表示交集， - 表示差集（切记差集是 由所有属于前一个集合且不属于后一个集合的元素构成的集合），^ 表示对称差集  ']
     
129. ['运算符号  <  <=  是表示是否为子集，  >  >= 是表示是否为超集，   | 表示并集， & 表示交集， - 表示差集（切记差集是 由所有属于前一个集合且不属于后一个集合的元素构成的集合），^ 表示对称差集  ']
     
130. >>>

复制代码

码农心

真的想要迈进这扇门里面啊

炎凉来寻

学习打卡

chenjinchao

so difficult

migu_sm1

Learning...The replies become less and less.

lxping

思维导图运算符运算中，关于子集、真子集以及超集真超集的判断书写有误吧。应该是
< 真子集判断
<= 子集判断
> 真超集判断
>= 超集判断

jgz1818

前面听着很精神，后面听着听着就想睡了

FengHL

看视频觉得还行，一做动手题就懵

andyleesh

打卡，感觉最近学的都是基础中的基础，所以比较空洞

小蜂队

集合与字典关系较为“暧昧”，都是用的{}，不同的是在写法上有有明显的区别，集合具有确定性，无序性，唯一性，本节讲解了集合的基本操作，以及集合的部分内置方法涉及子集（真子集），超集（真超集），并集，差集，对称差集等集合相关概念，即可用集合的内置方法来实现，亦可用简易的运算符来实现，需要注意的是使用运算符时符号两边的类型必须是集合类型的数据，而使用方法操作时参数可以是任意的可迭代对象

Wynn_0303

打卡

学爬虫的先生

集合
        创建集合的三种方式
                使用花括号，元素之间以逗号分隔：{"FishC", "Python"}
                使用集合推导式：{s for s in "FishC"}
                使用类型构造器，也就是 set()：set("FishC")
        集合的随机性
                集合无序的特征，传进去的是 'F'、'i'、's'、'h'、'C'，它这里显示的却是 'i'、'C'、's'、'F'、'h'，在你们的电脑上结果还可能不一样，这就是随机性
        in 和 not in 来判断某个元素是否存在于集合中
                >>> 'C' in s
True
>>> 'c' not in s
True
        唯一性
                >>> set([1, 1, 2, 3, 5])
{1, 2, 3, 5}
                        在实际开发中，我们经常需要去检测一个列表中是否存在相同的元素？

那么在没有学习过集合之前，我们很有可能需要通过迭代来统计每个元素出现的次数，从而判断是否唯一……

但是，现在，咱们只需要这么写：

                                >>> s = [1, 1, 2, 3, 5]
>>> len(s) == len(set(s))
False
>>> s = [1, 2, 3, 5]
>>> len(s) == len(set(s))
True
        集合的方法
                copy() 方法
                        >>> t = s.copy()
>>> t
{'h', 's', 'i', 'F', 'C'}
                检测两个集合之间是否毫不相干，可以使用 isdisjoint(other) 方法
                        >>> s.isdisjoint(set("Python"))
False
>>> s.isdisjoint(set("JAVA"))
True
                要检测该集合是否为另一个集合的子集，可以使用 issubset(other) 方法
                        >>> s.issubset("FishC.com.cn")
True
                检测该集合是否为另一个集合的超集，可以使用 issuperset(other) 方法
                        >>> s.issuperset("Fish")
True
                并集，union方法
                        >>> s.union({1, 2, 3})
{1, 2, 3, 'h', 's', 'i', 'F', 'C'}
                交集 intersection方法
                        >>> s.intersection("Fish")
{'h', 's', 'i', 'F'}
                差集，difference方法
                        >>> s.difference("Fish")
{'C'}
                求对称差集 symmetric_difference方法
                        >>> s.symmetric_difference("Python")
{'t', 'y', 'F', 's', 'P', 'C', 'n', 'o', 'i'}
                （<=）检测子集
                        >>> s <= set("FishC")
True
                （<）检测真子集
                        >>> s < set("FishC")
False
>>> s < set("FishC.com.cn")
True
                （>）检测真超集
                         s > set("FishC")
False
                （>=）检测超集
                        s >= set("FishC")
True
                并集使用管道符（|）
                        >>> s | {1, 2, 3} | set("Python")
{1, 2, 3, 'y', 'h', 'n', 'i', 'P', 's', 'o', 't', 'C', 'F'}
                交集使用 and 符号（&）
                        >>> s & set("Php") & set("Python")
{'h'}
                差集使用减号（-
                        >>> s - set("Php") - set("Python")
{'s', 'C', 'F', 'i'}
                对称差集使用脱字符（^）
                        >>> s ^ set("Python")
{'t', 'y', 'F', 's', 'P', 'C', 'n', 'o', 'i'}
                都是支持多个参数
        注意事项
                使用运算符的话，符号两边都必须是集合类型的数据才可以，不然会报错。
                        >>> s <= "FishC"
Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    s <= "FishC"
TypeError: '<=' not supported between instances of 'set' and 'str'
>>> s | [1, 2, 3]
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    s | [1, 2, 3]
TypeError: unsupported operand type(s) for |: 'set' and 'list'

littlewhale

打卡~~~
已经开始逐渐迷离状

来自成都的momo

给我一拳