python集合操作

不止于python

发布于 2023-09-05 14:17:38

1890

发布于 2023-09-05 14:17:38

文章被收录于专栏：不止于python

集合定义

确定的无序的一组数据就是集合集合中的值不会重复(唯一, 所有相同的数据只会保留一份) 集合中的元素没有任何顺序集合中可以使用整数，浮点数，布尔值，复数，字符串，集合，冰冻集合等

集合基本操作

1. 创建空集合

变量 = set()

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

2. 有数据(元素)的集合

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

变量 = {值,值....}

In [3]: s2 = {1}
In [4]: s2
Out[4]: {1}

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

3. 创建冰冻集合

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

3.1 空的冰冻集合

变量 = frozenset()

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

3.2 有值的冰冻集合

变量 = frozenset(容器类数据)

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

4. 成员检测

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

集合常用函数操作

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

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

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

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

3. 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

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

值不存在不会报错

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

5. clear(): 清空集合

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

6. copy(): 复制集合

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

7. difference(集合): 差集

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

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

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

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

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

9. intersection(集合): 交集

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

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

10. intersection_update(集合): 交集更新

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

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

11. 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}

12. update(集合): 并集更新

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

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

13. 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

14. 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

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

两个集合没有重复的元素

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

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

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

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

In [65]: s7.symmetric_difference(s9)
Out[65]: {1}

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

17. 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}

18. len(集合): 集合长度

In [71]: s9
Out[71]: {2, 3}

In [72]: len(s9)
Out[72]: 2

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

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

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

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

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

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

集合推导式

1. 简单的集合推导式

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

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

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

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

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

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

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

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)}

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

新的集合数量由判断条件决定 = 符合条件的剩余的集合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)}