python集合操作 - 不止于python

集合定义

确定的无序的一组数据就是集合

集合中的值不会重复(唯一, 所有相同的数据只会保留一份)

集合中的元素没有任何顺序

集合中可以使用整数，浮点数，布尔值，复数，字符串，集合，冰冻集合等

集合基本操作

创建空集合

变量 = set()

1
2
3

In [1]: s1 = set()  
In [2]: s1  
Out[2]: set()

有数据(元素)的集合

单个元素或多个的元素的集合

变量 = {值,值….}

In [3]: s2 = {1}  
In [4]: s2  
Out[4]: {1}  
  
In [5]: s3 = {1,2}  
In [6]: s3  
Out[6]: {1, 2}

创建冰冻集合

冰冻集合一旦创建则不可以进行任何修改, 包括添加元素

3.1 空的冰冻集合

变量 = frozenset()

1
2
3

In [7]: s11 = frozenset()  
In [8]: s11  
Out[8]: frozenset()

3.2 有值的冰冻集合

变量 = frozenset(容器类数据)

1
2
3

In [107]: s22 = frozenset((1,2,3))  
In [108]: s22  
Out[108]: frozenset({1, 2, 3})

成员检测

4.1 检测一个数据是否在集合中

值 in 集合

In [9]: s4 = {1,2,3}  
In [10]: 1 in s4  
Out[10]: True  
  
In [11]: 11 in s4  
Out[11]: False

4.2 检测一个数据是否不在集合中

值 not in 集合

In [12]: 1 not in s4  
Out[12]: False  
  
In [13]: 11 not in s4  
Out[13]: True

集合常用函数操作

add(值): 向集合中添加一个元素

In [14]: s5 = {1}  
In [15]: s5.add(1)  
# 添加相同元素, 集合会自定去重  
In [16]: s5.add(1)  
In [17]: s5  
Out[17]: {1}

pop(): 随机删除集合中的一个元素

1 2	In [18]: s5.pop() Out[18]: 1

remove(值): 删除集合中的某个元素

值不存在报错

In [19]: s5 = {1,2,3}  
In [20]: s5.remove(1)  
In [21]: s5.remove(1)  
---------------------------------------------------------------------------  
KeyError Traceback (most recent call last)  
<ipython-input-21-340b41c1eeb6> in <module>  
----> 1 s5.remove(1)  
KeyError: 1

discard(值): 删除集合中的某个元素

值不存在不会报错

In [22]: s5.discard(2)  
# 移除不存在的值不会报错  
In [23]: s5.discard(2)  
In [24]: s5  
Out[24]: {3}

clear(): 清空集合

In [25]: s5  
Out[25]: {3}  
In [26]: s5.clear()  
In [27]: s5  
Out[27]: set()

copy(): 复制集合

In [28]: s5 = {1,2,3}  
In [29]: s6 = s5.copy()  
In [30]: s6  
Out[30]: {1, 2, 3}

difference(集合): 差集

获取存在于集合1但是不存在于集合2中的数据的集合

In [31]: s7 = {1,2,3}  
In [32]: s8 = {2,3,4}  
In [33]: s7.difference(s8)  
Out[33]: {1}

difference_update(集合): 移除两个集合都存在的元素

直接在原集合上修改, 没有返回值

1
2
3

In [34]: s7.difference_update(s8)  
In [35]: s7  
Out[35]: {1}

intersection(集合): 交集

获取即存在于集合1又存在于集合2中的数据组成的集合

In [36]: s7 = {1,2,3}  
In [37]: s8 = {2,3,4}  
In [38]: s7.intersection(s8)  
Out[38]: {2, 3}

intersection_update(集合): 交集更新

移除集合1中不存在于集合2中的元素, 直接在原集合上修改, 没有返回值

1
2
3

In [41]: s7.intersection_update(s8)  
In [42]: s7  
Out[42]: {2, 3}

union(集合): 并集

将集合1和集合2中所有数据新建一个集合（去重）

In [43]: s8 = {2,3,4}  
In [44]: s7 = {1,2,3}  
In [45]: s7.union(s8)  
Out[45]: {1, 2, 3, 4}

update(集合): 并集更新

将集合1和集合2中所有数据新建一个集合(去重)

1
2
3

In [46]: s7.update(s8)  
In [47]: s7  
Out[47]: {1, 2, 3, 4}

issuperset(集合): 检测一个集合是不是另外一个集合的超集

就是检测集合2中的元素是否在都集合1中

In [49]: s7 = {1,2,3}  
In [50]: s8 = {2,3,4}  
In [51]: s9 = {2,3}  
  
In [52]: s7.issuperset(s8)  
Out[52]: False  
  
In [53]: s7.issuperset(s9)  
Out[53]: True

issubset(集合): 检测一个集合是不是另外一个集合的子集

检测集合1的元素是否在集合2中

In [58]: s7 = {1,2,3}  
In [59]: s8 = {4,5,6}  
In [60]: s9 = {2,3}  
  
In [61]: s9.issubset(s7)  
Out[61]: True  
  
In [62]: s9.issubset(s8)  
Out[62]: False

isdisjoint(集合): 检测2个集合是否不相交

两个集合没有重复的元素

In [63]: s7.isdisjoint(s9)  
Out[63]: False  
  
In [64]: s8.isdisjoint(s9)  
Out[64]: True

symmetric_difference(集合): 对称差集操作

返回两个集合中不重复的元素集合

In [65]: s7.symmetric_difference(s9)  
Out[65]: {1}  
  
In [66]: s8.symmetric_difference(s9)  
Out[66]: {2, 3, 4, 5, 6}

symmetric_difference_update(集合): 对称差集更新操作

在原始集合1中移除与集合2中的重复元素，并将不重复的元素插入到集合1中

In [67]: s7.symmetric_difference_update(s9)  
In [68]: s7  
Out[68]: {1}  
  
In [69]: s8.symmetric_difference_update(s9)  
In [70]: s8  
Out[70]: {2, 3, 4, 5, 6}

len(集合): 集合长度

In [71]: s9  
Out[71]: {2, 3}  
  
In [72]: len(s9)  
Out[72]: 2

max(集合): 集合中的最大值

1 2	In [74]: max(s9) Out[74]: 3

min(集合): 集合中的最小值

1 2	In [73]: min(s9) Out[73]: 2

sum(集合): 计算列中所有元素的和

1 2	In [75]: sum(s9) Out[75]: 5

集合推导式

简单的集合推导式

格式：{变量可以操作 for 变量 in 集合}

结果：遍历集合中的每个值，将每个值获取之后组成新的集合, 可以对获取的值进行修改

In [76]: s1 = {1,2,3}  
In [77]: s2 = {i for i in s1}  
In [78]: s2  
Out[78]: {1, 2, 3}

带有判断条件的集合推导式

格式：{变量 for 变量 in 集合 if 条件表达式}

结果：遍历集合中的每个值，根据判断条件决定是否取出指定的值组成新的集合，可以对获取的值进行修改

1
2
3

In [79]: s3 = {i for i in s1 if i > 2}  
In [80]: s3  
Out[80]: {3}

多个集合的同时循环的集合推导式

变量1和变量2可以进行其它计算或操作

新的集合中元素个数=集合1中元素个数 * 集合2中的元素个数

格式：{变量1+变量2 for 变量1 in 集合1 for 变量2 in 集合2}

结果：同时遍历集合1和集合2中的每个值，将集合1中的每个值和集合2中的每个值进行运算得到新的集合

In [81]: s1 = {1,2,3}  
In [82]: s2 = {1,2,3}  
In [83]: s3 = {(i, ii) for i in s1 for ii in s2}  
In [84]: s3  
Out[84]: {(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)}

带有判断条件的多个集合的同时循环集合推导式

新的集合数量由判断条件决定 = 符合条件的剩余的集合1个数 * 符合条件的剩余的集合2个数

格式：{变量1+变量2 for 变量1 in 集合1 for 变量2 in 集合2 if 条件表达式}

结果：同时遍历集合1和集合2中的每个值，根据判断条件将集合1中的值和集合2中的值进行运算，得到新的集合

In [91]: s4 = {(i,ii) for i in s1 for ii in s2 if i > 1 and ii > 1}  
In [92]: s4  
Out[92]: {(2, 2), (2, 3), (3, 2), (3, 3)}  
  
In [96]: s5 = {(i,ii) for i in s1 for ii in s2 if i > 2 and ii > 2}  
In [97]: s5  
Out[97]: {(3, 3)}

点个在看你最好看