数据类型--集合

Posted 风之岚翔

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据类型--集合相关的知识,希望对你有一定的参考价值。

数据类型的种类

常用的:
1、数字
2、字符串
3、列表
4、元祖
5、集合

不常用的:
队列
有序字典
默认字典

集合的特点

1、无序
2、去重(重要)
3、可嵌套
4、关系测试(重要)

 

创建集合

(一)、回顾:创建列表的2中方法:

1、li = []  #直接创建
2、list() #可以将其他数据类型转换成列表(相当于在内存有创建一个)

注意:
     它会自动去执行list里面的构造方法__init__。
     list __init__,内部执行for循环(11,22,33,44)转换成[11,22,33,44]
     在定义  li=[]的时候,会内部调用list()这种方式。

 

一、创建集合的注意事项:

1、无序,不重复的序列

1 set = {11,22,11,22}
2 print(set)
3 
4 输出结果:
5 {11, 22}

2、用“{}”来代替,里面每个元素就是一个值,跟字典的区别就是无需key:values。
3、set的功能: set()  == list() 
4、将列表转换成集合的方法:

1 li = [11,22,11,22]
2 s1 = set(li)
3 print(s1,type(s1))
4 
5 显示结果:
6 {11, 22} <class set>

 

二、创建集合的三种方式:

1、普通创建方法:

1 1、se = {11,22} 
2 例如:se = {"123","456"}

2、创建空集合:

1 s2 = set()             
2 这个是通过__init__进行转换的

3、转其他数据类型换成集合

1 s3 = set([11,22,33,4])

 

操作集合

一、添元素:

1 创建空集合:
2 s = set()
3 s.add(123)
4 s.add(123)
5 s.add(123)
6 print(s)
7 
8 显示结果:
9 {123}


注意:上面示例添加了3次123,但是只能显示一个,因为set集合有去重功能。
扩展:爬虫访问过的url放到一个set()中,可以通过去重功能,过滤掉访问过的url。

 

 

二、清空set里的所有内容:

1 s.clear()
2 print(s)
3 
4 显示结果:
5 set()

 

 

 

 

 

三、A中存在B中不存在的

注意:

A是指谁调用的表(s1的位置),
B就是被调用的表(s2的位置);
 1 #s1中存在s2中不存在的:
 2 s1 = {11,22,33}
 3 s2 = {22,33,44}
 4 s3 = s1.difference(s2)
 5 print(s3)
 6 
 7 
 8 #s2中存在s1中不存在的
 9 s3 = s2.difference(s1)
10 print(s3)
11 
12 显示结果:
13 {11}
14 {44}

 

 

 

四、取出A中存在,B中不存在的,然后将结果替换掉A中的元素:

1 s1.difference_update(s2)
2 print("s1:",s1)
3 
4 显示结果:
5 s1: {11}

注意:如果后续的代码不需要s1里面的元素时,可以使用带有Update方法来替换掉

 

 

五、对称差距
把A中存在的B中不存在的取出,
在把B中存在的A中不存在的取出;

 1 s1 = {11,22,33}
 2 s2 = {22,33,44}
 3 
 4 s3 = s1.symmetric_difference(s2)
 5 print(s3)
 6 print(s1)
 7 print(s2)
 8 
 9 显示结果:
10 {11, 44}
11 {33, 11, 22}
12 {33, 44, 22}

 

 

 

六、对称差距更新s1

取出A中存在B中不存在的元素,
取出B中存在A中不存在的元素,
将结果更新到A中

1 s1.symmetric_difference_update(s2)
2 print("更新s1",s1)
3 
4 显示结果:
5 更新s1 {11, 44}

注意:如果后续的代码不需要s1里面的元素时,可以使用带有Update方法来替换掉

 

 

七、移除元素:

#移除指定元素,不存在不报错:(以后推荐使用这个避免bug)
s1 = {11,22,33}
s1.discard(1111)
print("移除1111,数据不存在,不会报错:",s1)


#移除指定元素,如果不存在就直接报错。
s1 = {11,22,33}
s1.remove(22)
print("移除指定元素,有就不报错:",s1)

# s1.remove(111)
# print("移除指定元素,没有就报错:",s1)

#移除某个元素,并获取移除元素的值。(随机移除,不需要加参数,因为集合是无序的)
s1 = {11,22,33,44}
ret = s1.pop() #不用加参数
print("集合无序,随机移除,返回移除的数据",s1)
print("显示pop移除的元素:",ret)


显示结果:
移除1111,数据不存在,不会报错: {33, 11, 22}
移除指定元素,有就不报错: {33, 11}
集合无序,随机移除,返回移除的数据 {11, 44, 22}
显示pop移除的元素: 33

注意:使用pop的场景:以后再学到队列的时候会使用到,一般情况下移除一个元素,然后把移除的这个元素赋值到一个变量,然后在其他引用。

 

 

八、取出A和B之间的交集:

1 s1 = {11,22,33}
2 s2 = {22,33,44}
3 s3 = s1.intersection(s2)
4 print("取出s1和s2的交集:",s3)
5 
6 
7 显示结果:
8 取出s1和s2的交集: {33, 22}

 

 

九、取出A和B之间的交集,并更新到A里:

1 s1 = {11,22,33}
2 s2 = {22,33,44}
3 
4 s1.intersection_update(s2)
5 print("取出A和B之间的交集,并更新到A里:",s1)
6 
7 输出结果:
8 取出A和B之间的交集,并更新到A里: {33, 22}

 

十、判断是否为包含于被包含的关系:

 1 s1 = {11,22,33}
 2 s2 = {22,33}
 3 s3 = s1.issuperset(s2)
 4 print("s1是s2的父序列:",s3)
 5 
 6 s3 = s2.issubset(s1)
 7 print("s2是s1的子序列:",s3)
 8 
 9 
10 输出结果:
11 s1是s2的父序列: True
12 s2是s1的子序列: True

 

 

十一、取出A和B的并集:

1 s1 = {11,22,33}
2 s2 = {22,33,44}
3 s3 = s1.union(s2)
4 print("显示A和B的并集:",s3)
5 
6 显示结果:
7 显示A和B的并集: {33, 22, 11, 44}

 

 

十二、批量添加,批量更新(对可循环和可迭代的对象有效)

 1 #批量添加,批量更新(对可循环和可迭代的对象有效)
 2 s1 = {11,22,33}
 3 s1.add(44)
 4 s1.add(55)
 5 s1.add(66)
 6 print("往s1里添加记录",s1)
 7 
 8 #eg:列表
 9 li = [11,22,3,11,2]
10 s1.update(li)
11 print("将li列表中的元素加入到s1里:",s1)
12 
13 #eg:元祖
14 tuples = (66,77,8,10,2)
15 s1.update(tuples)
16 print("将元祖加入到s1里:",s1)
17 
18 #eg:字符串
19 st = "abiao"
20 s1.update(st)
21 print("将字符串加入到s1里:",s1)
22 
23 
24 显示结果:
25 往s1里添加记录 {33, 66, 11, 44, 22, 55}
26 将li列表中的元素加入到s1里: {33, 66, 3, 2, 11, 44, 22, 55}
27 将元祖加入到s1里: {33, 66, 3, 2, 8, 10, 11, 44, 77, 22, 55}
28 将字符串加入到s1里: {33, 66, 3, 2, o, 8, i, 10, 11, 44, 77, a, b, 22, 55}

 

 

集合的源代码:

技术分享图片
  1 class set(object):
  2     """
  3     set() -> new empty set object
  4     set(iterable) -> new set object
  5      
  6     Build an unordered collection of unique elements.
  7     """
  8     def add(self, *args, **kwargs): # real signature unknown
  9         """
 10         Add an element to a set,添加元素
 11          
 12         This has no effect if the element is already present.
 13         """
 14         pass
 15  
 16     def clear(self, *args, **kwargs): # real signature unknown
 17         """ Remove all elements from this set. 清除内容"""
 18         pass
 19  
 20     def copy(self, *args, **kwargs): # real signature unknown
 21         """ Return a shallow copy of a set. 浅拷贝  """
 22         pass
 23  
 24     def difference(self, *args, **kwargs): # real signature unknown
 25         """
 26         Return the difference of two or more sets as a new set. A中存在,B中不存在
 27          
 28         (i.e. all elements that are in this set but not the others.)
 29         """
 30         pass
 31  
 32     def difference_update(self, *args, **kwargs): # real signature unknown
 33         """ Remove all elements of another set from this set.  从当前集合中删除和B中相同的元素"""
 34         pass
 35  
 36     def discard(self, *args, **kwargs): # real signature unknown
 37         """
 38         Remove an element from a set if it is a member.
 39          
 40         If the element is not a member, do nothing. 移除指定元素,不存在不保错
 41         """
 42         pass
 43  
 44     def intersection(self, *args, **kwargs): # real signature unknown
 45         """
 46         Return the intersection of two sets as a new set. 交集
 47          
 48         (i.e. all elements that are in both sets.)
 49         """
 50         pass
 51  
 52     def intersection_update(self, *args, **kwargs): # real signature unknown
 53         """ Update a set with the intersection of itself and another.  取交集并更更新到A中 """
 54         pass
 55  
 56     def isdisjoint(self, *args, **kwargs): # real signature unknown
 57         """ Return True if two sets have a null intersection.  如果没有交集,返回True,否则返回False"""
 58         pass
 59  
 60     def issubset(self, *args, **kwargs): # real signature unknown
 61         """ Report whether another set contains this set.  是否是子序列"""
 62         pass
 63  
 64     def issuperset(self, *args, **kwargs): # real signature unknown
 65         """ Report whether this set contains another set. 是否是父序列"""
 66         pass
 67  
 68     def pop(self, *args, **kwargs): # real signature unknown
 69         """
 70         Remove and return an arbitrary set element.
 71         Raises KeyError if the set is empty. 移除元素
 72         """
 73         pass
 74  
 75     def remove(self, *args, **kwargs): # real signature unknown
 76         """
 77         Remove an element from a set; it must be a member.
 78          
 79         If the element is not a member, raise a KeyError. 移除指定元素,不存在保错
 80         """
 81         pass
 82  
 83     def symmetric_difference(self, *args, **kwargs): # real signature unknown
 84         """
 85         Return the symmetric difference of two sets as a new set.  对称差集
 86          
 87         (i.e. all elements that are in exactly one of the sets.)
 88         """
 89         pass
 90  
 91     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
 92         """ Update a set with the symmetric difference of itself and another. 对称差集,并更新到a中 """
 93         pass
 94  
 95     def union(self, *args, **kwargs): # real signature unknown
 96         """
 97         Return the union of sets as a new set.  并集
 98          
 99         (i.e. all elements that are in either set.)
100         """
101         pass
102  
103     def update(self, *args, **kwargs): # real signature unknown
104         """ Update a set with the union of itself and others. 更新 """
105         pass
View Code

 


















以上是关于数据类型--集合的主要内容,如果未能解决你的问题,请参考以下文章

如何从一个片段中删除数据,这些片段应该反映在google firebase中的其他片段中

Java方法

金蝶handler中 collection 代码片段理解

Alfred常见使用

比较 C# 中的字符串片段并从集合中删除项目

在代码片段中包含类型转换