1. # 创建空集合
  2. set_instance = set()
  3. print(set_instance)
  4. """
  5. set()
  6. """
  7. # 添加元素
  8. set_instance.add('3')
  9. print(set_instance)
  10. """
  11. {'3'}
  12. """
  13. # 复制一个集合
  14. set2 = set_instance.copy()
  15. print(set2)
  16. """
  17. {'3'}
  18. """

  1. # 删除集合元素
  2. set_instance.remove('3333')
  3. print(set_instance)
  4. """
  5. {'33', '333', '3'}
  6. """
  7. # 随机移除元素并返回
  8. print(set_instance.pop())
  9. """
  10. 33
  11. """
  12. # 删除指定元素
  13. set_instance.discard('33')
  14. print('删除指定元素后的集合为:', set_instance)
  15. """
  16. 删除指定元素后的集合为: {'333', '3'}
  17. """
  18. # 清空集合
  19. set_instance.clear()
  20. print(set_instance)
  21. """
  22. set()
  23. """

  1. x = {'3333', '33', '333'}
  2. set_instance.update(x)
  3. print(set_instance)
  4. """
  5. {'33', '333', '3', '3333'}
  6. """

集合的运算

  1. x = {1, 3, 4, 5, 7}
  2. y = {3, 4, 7}
  3. # 求集合的差集
  4. print('求集合的差集', x.difference(y)) # 求集合的差集 {1, 5}
  5. # 求集合的并集
  6. print('求集合的并集', x.union(y)) # 求集合的并集 {1, 3, 4, 5, 7}
  7. # 求集合的交集
  8. print('求集合的交集', x.intersection(y)) # 求集合的并集 {3, 4, 7}
  9. # 判断两个集合是否包含相同元素 False
  10. print('判断两个集合是否包含相同元素', x.isdisjoint(y)) # 有则返回false,没有则返回true
  11. # 判断两个集合是否包含相同元素 False
  12. print('判断y集合是否完全是x子集', y.issubset(x)) # 都包含则返回True,没有则返回false
  13. # 判断两个集合是否包含相同元素 False
  14. print('判断y集合是否完全包含在x集合中', x.issuperset(y)) # 如果都包含返回 True,否则返回 False
  15. # 判断两个集合是否包含相同元素 False
  16. print('返回两个集合中不重复的元素', x.symmetric_difference(y))
  17. print(x and y) # {3, 4, 7}
  18. print(y and x) # {1, 3, 4, 5, 7}
  19. print(x - y) # {1, 5}
  20. print(y - x) # set()
  21. print(x or y) # {1, 3, 4, 5, 7}
  22. print(y or x) # {3, 4, 7}
  23. print(x ^ y) # {1, 5}
  24. print(y ^ x) # {1, 5}

集合只能存放可哈希对象

对象的可哈希性: 字典和集合底层都是使用了哈希表数据结构,当把某个对象放进集合或者作为字典的键使用,解释器需要对该对象进行哈希计算,一般可通过内置函数hash(obj)判断对象是否可哈希。 所有的不可变内置类型都是可哈希的:str、int、tuple、frozenset等 所有的可变内置类型都是不可哈希的:dict、list 用户定义的类型默认可哈希