Python精通-Python集合操作详解

浅浅的花香味﹌ 2023-05-30 14:54 72阅读 0赞

导语
  在前面的分享中说完了基本的数据类型，基本的数据类型有六种分别是数字、字符串、列表、元组、列表、以及布尔值。接下来说的就是在Python中比基本数据类型变量等知识更加深入的数据类型叫做集合

文章目录

  • 集合
    • 定义
    • 特性
    • 创建集合
    • 集合基本操作
      • def add(self, *args, **kwargs)
      • def clear(self, *args, **kwargs)
      • def copy(self, *args, **kwargs)
      • def pop(self, *args, **kwargs)
      • def remove(self, *args, **kwargs)
      • def discard(self, *args, **kwargs)
    • 集合关系运算交、差、并集
      • def intersection(self, *args, **kwargs) 求解两个集合的交集
      • def union(self, *args, **kwargs)求两个集合的并集
      • def difference(self, *args, **kwargs) 求差集
      • def symmetric_difference(self, *args, **kwargs)交叉补集
    • 集合中的扩展操作
      • def difference_update(self, *args, **kwargs)
      • def intersection_update(self, *args, **kwargs)求交集并赋值
      • def isdisjoint(self, *args, **kwargs)
      • def issubset(self, *args, **kwargs)
      • def issuperset(self, *args, **kwargs)
      • def symmetric_difference_update(self, *args, **kwargs)
      • def update(self, *args, **kwargs)
  • 总结

集合

定义

  由不同元素组成，并且元素是一组无序排列的可hash操作的值，也就是可以作为字典的key，也就是不可变的数据类型。

特性

  集合的目的是将不同的值放到一起，不同的集合之间用来做关系运行，不需要纠结集合中的元素。

创建集合

创建一个不可变集合

  1. # 定义一个集合
  2. s = { 1,2,3,4,3,3,3,3,3,5}
  3. # 定义一个字典
  4. dic = { "name":"nihui","age":123}
  6. v = type(s)
  7. print(v)
  8. print(s)

定义一个可变集合

  1. set_test = set("hello")
  2. set_test1 = set(["lell","test","set"])
  4. print(set_test)
  5. print(set_test1)

将这个集合变成一个不可变的集合

  1. f_set_test = frozenset(set_test)
  2. print(f_set_test)

集合基本操作

def add(self, *args, **kwargs)

向集合中添加对应的元素

  1. s = { 1,2,3,4,3,5}
  2. s.add("test")
  3. print(s)

def clear(self, *args, **kwargs)

表示清空一个集合

  1. s = { 1,2,3,4,3,5}
  3. print(s)
  4. s.clear()
  6. print(s)

def copy(self, *args, **kwargs)

将已有的集合复制相同的一份

  1. s = { 1,2,3,4,3,5}
  2. print(s)
  3. v = s.copy()
  4. print(v)

def pop(self, *args, **kwargs)

随机删除一个元素

  1. s = { 1,2,3,4,3,5}
  2. print(s)
  4. v = s.pop()
  6. print(v)

def remove(self, *args, **kwargs)

删除指定的元素，如果在集合中没有对应的数据的时候会报错

  1. s = { 1,2,3,4,3,5}
  2. print(s)
  4. v = s.remove(4)
  5. print(v)
  6. print(s)

def discard(self, *args, **kwargs)

删除指定的元素，但是当删除元素不存在的时候程序不会报错。

  1. s = { 1,2,3,4,3,5}
  2. print(s)
  4. v = s.discard(3)
  5. print(v)
  6. print(s)
  8. ## 删除不存在的元素
  9. s = { 1,2,3,4,3,5}
  10. print(s)
  12. v = s.discard("nell")
  13. print(v)
  14. print(s)

集合关系运算交、差、并集

  在数学概念上如果需要求解两个集合的交集可以使用如下的代码来实现，当然这里没有用到上面提到的集合的概念，而是通过两个列表来实现这个功能。在数学和Python中的集合都是无序的。Python的集合的元素是不可重复的，所以可以用来去重。

  1. set_A = [1,2,3,4]
  2. set_B = [2,3]
  4. A_and_B = []
  5. for itemA in set_A:
  6.     if itemA in set_B:
  7.         A_and_B.append(itemA)
  9. print(A_and_B)

  将上面的列表转换成两个集合

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  8. print(a_set,b_set)

def intersection(self, *args, **kwargs) 求解两个集合的交集

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  8. print(a_set,b_set)
  10. print(a_set.intersection(b_set))
  11. print(b_set.intersection(a_set))
  12. print(a_set&b_set)

def union(self, *args, **kwargs)求两个集合的并集

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  8. print(a_set,b_set)
  10. print(a_set.union(b_set))
  11. print(a_set|b_set)

def difference(self, *args, **kwargs) 求差集

  存在于A集合但不存在与B集合中的元素

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  8. print(a_set,b_set)
  11. print(a_set.difference(b_set))
  12. print(a_set-b_set)

def symmetric_difference(self, *args, **kwargs)交叉补集

  先求出两个集合的并集，从并集中去除两个集合的交集

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  8. print(a_set,b_set)
  9. print(a_set.symmetric_difference(b_set))
  10. print(a_set^b_set)

集合中的扩展操作

def difference_update(self, *args, **kwargs)

求差集并且将结果更新到原来的集合中。也就是说在A集合中进行差集操作则会更新A集合。

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.difference_update(b_set))
  10. print(a_set)
  11. print(b_set)

在这里插入图片描述

def intersection_update(self, *args, **kwargs)求交集并赋值

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.intersection_update(b_set))
  10. print(a_set)
  11. print(b_set)

def isdisjoint(self, *args, **kwargs)

如果两个集合没有交集则返回为TRUE，否则为FALSE

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.isdisjoint(b_set))

def issubset(self, *args, **kwargs)

表示A集合是否是B集合的子集，如果是返回TRUE，否则是FALSE

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.issubset(b_set))

def issuperset(self, *args, **kwargs)

A 集合是否是B集合的父集，如果是返回TRUE，否则是FALSE

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.issuperset(b_set))

def symmetric_difference_update(self, *args, **kwargs)

交叉补集并赋值

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.symmetric_difference_update(b_set))
  10. print(a_set)
  11. print(b_set)

def update(self, *args, **kwargs)

要注意与union与update的区别。并且要注意与add的区别。

  1. set_A = [1,2,3,4,5]
  2. set_B = [2,5,7,8]
  4. a_set = set(set_A)
  5. b_set = set(set_B)
  7. print(a_set,b_set)
  9. print(a_set.update(b_set))
  10. print(a_set)

updete 用来更新多个值。可以将可迭代对象作为参数进行修改操作。

总结

  上面的内容就是集合所有的常用操作，在结束的时候在加入一点小小的东西。在Python中集合是一个可变数据类型，但是有一种集合的定义,就可以将这个集合定义为一个不可变集合。

  1. s = frozenset("hello")
  2. print(s)

  在实际操作中如果想对数据进行一个简单的去重操作，则可以使用集合进行去重。但是如果数据较为复杂的时候需要对数据进行清洗。

发表评论

表情：
评论列表 （有 0 条评论，72人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python精通-Python元组操作

    > 导语 >   在介绍元组之前那，先来回顾一个变量赋值问题。对于字符串来说一旦被创建如果需要进行修改的时候就如同下图中展示的一样，需要新开辟空间对新的值进行存储。对于其他

    系统管理员系统管理员/ 0 赞/ 93 阅读