集合（set）

1.集合（set）

集合是一个 无序 、可变、不允许数据重复的容器。

类型	定义	公式	备注
独有功能	添加元素	data.add("郑裕玲")	1.2.1
独有功能	删除元素	data.discard("关之琳")	1.2.2
独有功能	交集	s4 = s1.intersection(s2) # 取两个集合的交集	1.2.3
独有功能	交集	s3 = s1 & s2 # 取两个集合的重复	1.2.3
独有功能	并集	s4 = s1.union(s2) # 取两个集合的合并	1.2.4
独有功能	并集	s3 = s1 | s2 # 取两个集合的合并	1.2.4
独有功能	差集	s4 = s1.difference(s2) # 差集，s1中有且s2中没有的值	1.2.5
独有功能	差集	s6 = s2.difference(s1) # 差集，s2中有且s1中没有的值	1.2.5
独有功能	差集	s3 = s1 - s2 # 差集，s1中有且s2中没有的值	1.2.5
独有功能	差集	s5 = s2 - s1 # 差集，s2中有且s1中没有的值	1.2.5
公共功能	减，计算差集	s3 = s1 - s2	1.3.1
公共功能	&，计算交集	s3 = s1 & s2	1.3.2
公共功能	|，计算并集	s3 = s1 | s2	1.3.3
公共功能	长度	data = len(v)	1.3.4
公共功能	for循环		1.3.5
转换		v2 = set(v1)	1.4

哈希的意思就是引入随机数量的输入数据，将其加密，然后得出一个固定输出数据，就叫做哈希

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 int、bool、str、tuple 。

1.1 定义

v1 = { 11, 22, 33, "alex" }

• 无序，无法通过索引取值。

• 可变，可以添加和删除元素。

  v1 = {11,22,33,44}
  v1.add(55)
  print(v1) # {11,22,33,44,55}
  

• 不允许数据重复。

  v1 = {11,22,33,44}
  v1.add(22)
  print(v1) # {11,22,33,44}
  

一般什么时候用集合呢？

```python
v1 = {11,22,33,44}
v1.add(22)
print(v1) # {11,22,33,44}
```

一般什么时候用集合呢？

就是想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。

注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

v1 = []
v11 = list()

v2 = ()
v22 = tuple()

v3 = set()

v4 = {} # 空字典
v44 = dict()

1.2 独有功能

1. 添加元素

   data = {"刘嘉玲", '关之琳', "王祖贤"}
   data.add("郑裕玲")
   print(data)
   

   data = set()
   data.add("周杰伦")
   data.add("林俊杰")
   print(data)
   

2. 删除元素

   data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
   data.discard("关之琳") 
   print(data)
   

3. 交集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   
   s4 = s1.intersection(s2) # 取两个集合的交集 
   print(s4) # {"⽪⻓⼭"}
   
   s3 = s1 & s2   			  # 取两个集合的交集
   print(s3)
   

4. 并集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s4 = s1.union(s2) 		# 取两个集合的并集  {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
   print(s4)
   s3 = s1 | s2   			# 取两个集合的并集
   print(s3)
   

5. 差集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s4 = s1.difference(s2) 		# 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
   s6 = s2.difference(s1)   	# 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}
   
   s3 = s1 - s2   			   # 差集，s1中有且s2中没有的值
   s5 = s2 - s1   			   # 差集，s2中有且s1中没有的值
   
   print(s5,s6)
   

1.3 公共功能

1. 减，计算差集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   
   s3 = s1 - s2 
   s4 = s2 - s1
   print(s3)
   print(s4)
   

2. &，计算交集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s3 = s1 & s2
   print(s3)
   

3. |，计算并集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s3 = s1 | s2
   print(s3)
   

4. 长度

   v = {"刘能", "赵四", "尼古拉斯"}
   data = len(v)
   print(data)
   

5. for循环

   v = {"刘能", "赵四", "尼古拉斯"}
   for item in v:
   	print(item)
   

1.4 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。

提示：int/list/tuple/dict都可以转换为集合。

v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}

提示：这其实也是去重的一个手段。

data = {11,22,33,3,99}

v1 = list(data) # [11,22,33,3,99]

v2 = tuple(data) # (11,22,33,3,99)

1.5 其他

1.5.1 集合的存储原理

1.5.2 元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 int、bool、str、tuple 。

• 转换成功

  v1 = [11,22,33,11,3,99,22]
  v2 = set(v1)
  print(v2) # {11,22,33,3,99}
  

• 转换失败

  v1 = [11,22,["alex","eric"],33]
  v2 = set(v1) # 报错 
  print(v2) 
  

1.5.3 查找速度特别快

因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。

• 低

  user_list = ["武沛齐","alex","李璐"]
  if "alex" in user_list:
      print("在")
  else:
      print("不在")
      
      
  user_tuple = ("武沛齐","alex","李璐")
  if "alex" in user_tuple:
      print("在")
  else:
      print("不在")
  

• 效率高

  user_set = {"武沛齐","alex","李璐"}
  if "alex" in user_set:
      print("在")
  else:
      print("不在")
  

1.5.4 对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()

data_list = [
    "alex",
    11,
    (11, 22, 33, {"alex", "eric"}, 22),
    [11, 22, 33, 22],
    {11, 22, (True, ["中国", "北京"], "沙河"), 33}
]

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}