devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python筑基之旅-集合

作者：菜鸟追梦旅行 | 2024-05-28 08:49:31

赞

踩

Python筑基之旅-集合

目录

 一、集合

1、集合的定义

2、集合的语法

3、获取集合的属性和方法

4、获取集合的帮助信息

5、集合的用法

5-1、创建集合

5-1-1、创建空集合(必须使用set()函数)

5-1-2、使用花括号创建集合(包含元素)

5-1-3、使用set()函数创建集合(包含元素)

5-1-4、尝试使用花括号创建空集合(会被解释为空字典)

5-2、集合的操作

5-2-1、添加元素

5-2-2、删除元素

5-2-3、检查元素是否存在

5-2-4、交集

5-2-5、并集

5-2-6、差集

5-2-7、对称差集

5-2-8、更新集合

5-3、集合的用法

5-3-1、add()方法

5-3-2、clear()方法

5-3-3、copy()方法

5-3-4、difference()方法

5-3-5、difference_update()方法

5-3-6、discard()方法

5-3-7、intersection()方法

5-3-8、intersection_update()方法

5-3-9、isdisjoint()方法

5-3-10、issubset()方法

5-3-11、issuperset()方法

5-3-12、pop()函数

5-3-13、remove()方法

5-3-14、symmetric_difference()方法

5-3-15、symmetric_difference_update()方法

5-3-16、union()方法

5-3-17、update()方法

二、推荐阅读

1、Python-VBA函数之旅-set()函数

2、Python算法之旅

3、Python函数之旅

4、个人主页-神奇夜光杯-CSDN

 一、集合

1、集合的定义

        在Python中，集合(set)是一种无序且不包含重复元素的数据类型。集合是可变的，但它是无序的，所以不支持索引或切片操作，你可以使用集合来执行成员检测、消除重复元素等操作。

2、集合的语法

        你可以使用花括号{}或set()函数来创建集合，但是，如果你使用花括号{}并且没有包含任何元素，Python会将其解释为一个空字典，而不是一个空集合，因此，在创建空集合时，你应该使用set()函数。

3、获取集合的属性和方法

        用dir()函数获取set所有属性和方法的列表

  1. print(dir(set))
  2. # ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
  3. # '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', 
  4. # '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', 
  5. # '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', 
  6. # '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy',
  7. # 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 
  8. # 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

4、获取集合的帮助信息

        用help()函数获取set的帮助信息

  1. help(set)
  2. # Help on class set in module builtins:
  3. # 
  4. # class set(object)
  5. #  |  set() -> new empty set object
  6. #  |  set(iterable) -> new set object
  7. #  |  
  8. #  |  Build an unordered collection of unique elements.
  9. #  |  
  10. #  |  Methods defined here:
  11. #  |  
  12. #  |  __and__(self, value, /)
  13. #  |      Return self&value.
  14. #  |  
  15. #  |  __contains__(...)
  16. #  |      x.__contains__(y) <==> y in x.
  17. #  |  
  18. #  |  __eq__(self, value, /)
  19. #  |      Return self==value.
  20. #  |  
  21. #  |  __ge__(self, value, /)
  22. #  |      Return self>=value.
  23. #  |  
  24. #  |  __getattribute__(self, name, /)
  25. #  |      Return getattr(self, name).
  26. #  |  
  27. #  |  __gt__(self, value, /)
  28. #  |      Return self>value.
  29. #  |  
  30. #  |  __iand__(self, value, /)
  31. #  |      Return self&=value.
  32. #  |  
  33. #  |  __init__(self, /, *args, **kwargs)
  34. #  |      Initialize self.  See help(type(self)) for accurate signature.
  35. #  |  
  36. #  |  __ior__(self, value, /)
  37. #  |      Return self|=value.
  38. #  |  
  39. #  |  __isub__(self, value, /)
  40. #  |      Return self-=value.
  41. #  |  
  42. #  |  __iter__(self, /)
  43. #  |      Implement iter(self).
  44. #  |  
  45. #  |  __ixor__(self, value, /)
  46. #  |      Return self^=value.
  47. #  |  
  48. #  |  __le__(self, value, /)
  49. #  |      Return self<=value.
  50. #  |  
  51. #  |  __len__(self, /)
  52. #  |      Return len(self).
  53. #  |  
  54. #  |  __lt__(self, value, /)
  55. #  |      Return self<value.
  56. #  |  
  57. #  |  __ne__(self, value, /)
  58. #  |      Return self!=value.
  59. #  |  
  60. #  |  __or__(self, value, /)
  61. #  |      Return self|value.
  62. #  |  
  63. #  |  __rand__(self, value, /)
  64. #  |      Return value&self.
  65. #  |  
  66. #  |  __reduce__(...)
  67. #  |      Return state information for pickling.
  68. #  |  
  69. #  |  __repr__(self, /)
  70. #  |      Return repr(self).
  71. #  |  
  72. #  |  __ror__(self, value, /)
  73. #  |      Return value|self.
  74. #  |  
  75. #  |  __rsub__(self, value, /)
  76. #  |      Return value-self.
  77. #  |  
  78. #  |  __rxor__(self, value, /)
  79. #  |      Return value^self.
  80. #  |  
  81. #  |  __sizeof__(...)
  82. #  |      S.__sizeof__() -> size of S in memory, in bytes
  83. #  |  
  84. #  |  __sub__(self, value, /)
  85. #  |      Return self-value.
  86. #  |  
  87. #  |  __xor__(self, value, /)
  88. #  |      Return self^value.
  89. #  |  
  90. #  |  add(...)
  91. #  |      Add an element to a set.
  92. #  |      
  93. #  |      This has no effect if the element is already present.
  94. #  |  
  95. #  |  clear(...)
  96. #  |      Remove all elements from this set.
  97. #  |  
  98. #  |  copy(...)
  99. #  |      Return a shallow copy of a set.
  100. #  |  
  101. #  |  difference(...)
  102. #  |      Return the difference of two or more sets as a new set.
  103. #  |      
  104. #  |      (i.e. all elements that are in this set but not the others.)
  105. #  |  
  106. #  |  difference_update(...)
  107. #  |      Remove all elements of another set from this set.
  108. #  |  
  109. #  |  discard(...)
  110. #  |      Remove an element from a set if it is a member.
  111. #  |      
  112. #  |      Unlike set.remove(), the discard() method does not raise
  113. #  |      an exception when an element is missing from the set.
  114. #  |  
  115. #  |  intersection(...)
  116. #  |      Return the intersection of two sets as a new set.
  117. #  |      
  118. #  |      (i.e. all elements that are in both sets.)
  119. #  |  
  120. #  |  intersection_update(...)
  121. #  |      Update a set with the intersection of itself and another.
  122. #  |  
  123. #  |  isdisjoint(...)
  124. #  |      Return True if two sets have a null intersection.
  125. #  |  
  126. #  |  issubset(self, other, /)
  127. #  |      Test whether every element in the set is in other.
  128. #  |  
  129. #  |  issuperset(self, other, /)
  130. #  |      Test whether every element in other is in the set.
  131. #  |  
  132. #  |  pop(...)
  133. #  |      Remove and return an arbitrary set element.
  134. #  |      Raises KeyError if the set is empty.
  135. #  |  
  136. #  |  remove(...)
  137. #  |      Remove an element from a set; it must be a member.
  138. #  |      
  139. #  |      If the element is not a member, raise a KeyError.
  140. #  |  
  141. #  |  symmetric_difference(...)
  142. #  |      Return the symmetric difference of two sets as a new set.
  143. #  |      
  144. #  |      (i.e. all elements that are in exactly one of the sets.)
  145. #  |  
  146. #  |  symmetric_difference_update(...)
  147. #  |      Update a set with the symmetric difference of itself and another.
  148. #  |  
  149. #  |  union(...)
  150. #  |      Return the union of sets as a new set.
  151. #  |      
  152. #  |      (i.e. all elements that are in either set.)
  153. #  |  
  154. #  |  update(...)
  155. #  |      Update a set with the union of itself and others.
  156. #  |  
  157. #  |  ----------------------------------------------------------------------
  158. #  |  Class methods defined here:
  159. #  |  
  160. #  |  __class_getitem__(...) from builtins.type
  161. #  |      See PEP 585
  162. #  |  
  163. #  |  ----------------------------------------------------------------------
  164. #  |  Static methods defined here:
  165. #  |  
  166. #  |  __new__(*args, **kwargs) from builtins.type
  167. #  |      Create and return a new object.  See help(type) for accurate signature.
  168. #  |  
  169. #  |  ----------------------------------------------------------------------
  170. #  |  Data and other attributes defined here:
  171. #  |  
  172. #  |  __hash__ = None

5、集合的用法

5-1、创建集合
5-1-1、创建空集合(必须使用set()函数)
  1. # 创建空集合(须使用set()函数）
  2. empty_set = set()
  3. print(type(empty_set)) # 输出：<class 'set'>
5-1-2、使用花括号创建集合(包含元素)
  1. # 使用花括号创建集合(包含元素)
  2. my_set = {1, 2, 3, 4}
  3. print(type(my_set)) # 输出：<class 'set'>
5-1-3、使用set()函数创建集合(包含元素)
  1. # 使用set()函数创建集合(包含元素)
  2. another_set = set([1, 2, 3, 4])
  3. print(type(another_set)) # 输出：<class 'set'>
5-1-4、尝试使用花括号创建空集合(会被解释为空字典)
  1. # 尝试使用花括号创建空集合(会被解释为空字典)
  2. wrong_empty_set = {}  # 这将是一个空字典，而不是空集合
  3. print(type(wrong_empty_set)) # 输出：<class 'dict'>
5-2、集合的操作
5-2-1、添加元素
  1. # 添加元素
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. my_set.add(7)
  4. print(my_set) # 输出：{3, 5, 6, 7, 8, 24, 10, 11}
5-2-2、删除元素
  1. # 删除元素
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. # my_set.remove(9)  # 如果元素不存在，会抛出KeyError，可以使用discard()代替
  4. my_set.remove(5)
  5. print(my_set) # 输出：{3, 6, 8, 24, 10, 11}
5-2-3、检查元素是否存在
  1. # 检查元素是否存在
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. if 6 in my_set:
  4.     print("6 is in the set") # 输出：6 is in the set
5-2-4、交集
  1. # 交集
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. another_set = {7, 8, 12}
  4. intersection = my_set & another_set
  5. print(intersection) # 输出：{8}
5-2-5、并集
  1. # 并集
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. another_set = {7, 8, 12}
  4. union = my_set | another_set
  5. print(union) # 输出：{3, 5, 6, 7, 8, 10, 11, 12, 24}
5-2-6、差集
  1. # 差集(my_set中有的但another_set中没有的)
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. another_set = {7, 8, 12}
  4. difference = my_set - another_set
  5. print(difference) # 输出：{3, 5, 6, 10, 11, 24}
5-2-7、对称差集
  1. # 对称差集(在my_set或another_set中，但不同时在两个中的元素)
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. another_set = {7, 8, 12}
  4. symmetric_difference = my_set ^ another_set
  5. print(symmetric_difference) # 输出：{3, 5, 6, 7, 10, 11, 12, 24}
5-2-8、更新集合
  1. # 更新集合，添加another_set中的所有元素，但不包括已经在my_set中的元素
  2. my_set = {3, 5, 6, 8, 10, 11, 24}
  3. another_set = {7, 8, 12}
  4. my_set.update(another_set)
  5. print(my_set) # 输出：{3, 5, 6, 7, 8, 10, 11, 12, 24}
5-3、集合的用法
5-3-1、add()方法
  1. # 1、方法：set_name.add
  2. # 2、语法：set_name.add(element)
  3. # 3、参数：
  4. # 3-1、set_name：表示set对象的名称
  5. # 3-2、element：表示你想要添加到集合中的元素
  6. # 4、功能：用于向集合中添加一个元素
  7. # 5、返回值：一个新的集合
  8. # 6、说明：
  9. # 6-1、由于set是无序的，所以打印集合时元素的顺序可能会不同，但是，集合的内容(即包含的元素)将保持不变
  10. # 6-2、如果你尝试将一个集合(或其他可迭代对象)中的所有元素添加到另一个集合中，可以使用update()方法，而不是多次调用add()方法
  11. # 7、示例：
  12. # 创建一个空的set
  13. my_set = set()
  14. # 使用add()方法添加元素
  15. my_set.add(1)
  16. my_set.add(2)
  17. my_set.add(3)
  18. # 打印集合
  19. print(my_set)  # 输出：{1, 2, 3}或{3, 2, 1}，因为set是无序的
  20. # 尝试添加已存在的元素，这不会有任何效果(因为set不包含重复元素)
  21. my_set.add(2)
  22. print(my_set)  # 输出：{1, 2, 3}或{3, 2, 1}，因为set是无序的
5-3-2、clear()方法
  1. # 1、方法：set_name.clear
  2. # 2、语法：set_name.clear()
  3. # 3、参数：
  4. # 3-1、set_name：表示set对象的名称
  5. # 4、功能：用于移除集合中的所有元素，将其变为一个空集合
  6. # 5、返回值：一个空集合
  7. # 6、说明：
  8. # 6-1、clear()方法会直接修改原集合，而不是返回一个新的集合；如果你需要保留原始集合并创建一个新的空集合，你应该使用set()构造函数来创建一个新的空集合
  9. # 7、示例：
  10. # 创建一个包含几个元素的set
  11. my_set = {1, 2, 3, 4, 5}
  12. # 打印原始集合
  13. print(my_set)  # 输出：可能是{1, 2, 3, 4, 5}或类似(因为set是无序的)
  14. # 使用clear()方法清空集合
  15. my_set.clear()
  16. # 打印清空后的集合
  17. print(my_set)  # 输出:set()，集合已变为空集合
  18. # 再次尝试打印集合元素(可选，以确认集合为空)
  19. for element in my_set:
  20.     print(element)  # 由于集合为空，这一行不会被执行
5-3-3、copy()方法
  1. # 1、方法：original_set.copy
  2. # 2、语法：new_set = original_set.copy()
  3. # 3、参数：
  4. # 3-1、original_set：表示你想要复制的原始set对象的名称
  5. # 3-2、new_set：一个新的set对象，它包含original_set的元素
  6. # 4、功能：用于创建一个集合的浅拷贝(shallow copy)
  7. # 5、返回值：浅拷贝会创建一个新的集合对象，并复制原集合中所有的元素
  8. # 6、说明：
  9. # 6-1、浅拷贝创建的新集合对象，与原集合属于不同的对象，它们仅仅只是包含的元素完全相同，鉴于集合的无序性，打印时的顺序不一定相同
  10. # 7、示例：
  11. # 创建一个包含几个元素的set
  12. original_set = {1, 2, 3, 4, 5}
  13. # 使用copy()方法创建一个新的集合
  14. new_set = original_set.copy()
  15. # 打印原始集合
  16. print("Original set:", original_set)  # 输出：Original set: {1, 2, 3, 4, 5}
  17. # 打印新集合
  18. print("New set:", new_set)  # 输出：New set: {1, 2, 3, 4, 5}
  19. # 修改原始集合
  20. original_set.add(6)
  21. # 再次打印两个集合
  22. print("Modified original set:", original_set)  # 输出：Modified original set: {1, 2, 3, 4, 5, 6}
  23. print("New set(unchanged):", new_set)  # 输出:New set(unchanged): {1, 2, 3, 4, 5}
  24. # 创建深拷贝(如果需要)
  25. # 如果你需要创建一个真正的“深拷贝”(即，拷贝所有的层次)，你可以使用copy模块中的deepcopy()函数
  26. import copy
  27. # 创建一个集合
  28. original_set = {1, 2, 3, 4, 5}
  29. # 使用deepcopy()方法创建深拷贝
  30. deep_copied_set = copy.deepcopy(original_set)
  31. # 修改深拷贝集合
  32. deep_copied_set.add(8)
  33. # 打印原集合和深拷贝后的集合
  34. print("原集合:", original_set) # 输出：原集合: {1, 2, 3, 4, 5}  原集合中的元素并未新增，因为deepcopy()创建了原集合中所有层次的完全独立的副本
  35. print("深拷贝后的集合:", deep_copied_set) # 输出：深拷贝后的集合: {1, 2, 3, 4, 5, 8}
5-3-4、difference()方法
  1. # 1、方法：set1.difference
  2. # 2、语法：
  3. # 2-1、set1.difference(set2)
  4. # 2-2、set1 - set2
  5. # 3、参数：
  6. # 3-1、set1(必须)：表示一个做为参考基准的目标集合
  7. # 3-2、set2(必须)：表示一个与目标集合做对比的集合
  8. # 4、功能：用于计算两个集合之间的差集的方法
  9. # 5、返回值：返回一个新的集合，该集合包含所有在set1中但不在set2中的元素
  10. # 6、说明：
  11. # 7、示例：
  12. # 创建两个集合
  13. set1 = {1, 2, 3, 4, 5}
  14. set2 = {4, 5, 6, 7, 8}
  15. # 使用difference()方法
  16. difference_set = set1.difference(set2)
  17. print(difference_set)  # 输出: {1, 2, 3}
  18. # 使用-运算符
  19. difference_set_operator = set1 - set2
  20. print(difference_set_operator)  # 输出: {1, 2, 3}
5-3-5、difference_update()方法
  1. # 1、方法：set.difference_update
  2. # 2、语法：set.difference_update(other_set)
  3. # 3、参数：
  4. # 3-1、set(必须)：表示一个做为参考基准的目标集合
  5. # 3-2、other_set(可选)：表示与目标集合做对比的其他集合，可以是空集合
  6. # 4、功能：用于从集合中移除那些在另一个集合中存在的元素
  7. # 5、返回值：直接修改后的原集合
  8. # 6、说明：
  9. # 6-1、与difference()方法不同，difference_update()会直接修改原集合，而不是返回一个新的集合
  10. # 7、示例：
  11. # 创建三个集合
  12. set1 = {1, 2, 3, 4, 5}
  13. set2 = {4, 5, 6, 7, 8}
  14. set3 = set()
  15. # 使用difference_update()方法
  16. set1.difference_update(set2)
  17. print(set1)  # 输出: {1, 2, 3}，set1被修改了
  18. # 注意到set2没有改变
  19. print(set2)  # 输出: {4, 5, 6, 7, 8}
  20. # other_set不设定集合对象
  21. set2.difference_update()
  22. print(set2) # 输出: {4, 5, 6, 7, 8}
  23. # other_set设定为空集合
  24. set2.difference_update(set3)
  25. print(set2) # 输出: {4, 5, 6, 7, 8}
5-3-6、discard()方法
  1. # 1、方法：set.discard
  2. # 2、语法：set.discard(element)
  3. # 3、参数：
  4. # 3-1、set(必须)：表示一个做为参考基准的原集合
  5. # 3-2、element(必须)：表示待从原集合中移除的一个指定元素
  6. # 4、功能：用于尝试从集合中移除一个指定的元素
  7. # 5、返回值：在原集合基础上移除指定元素后形成的集合，若指定元素不存在于原集合中，则返回原集合
  8. # 6、说明：
  9. # 6-1、如果元素存在于集合中，它将被移除；如果元素不存在于集合中，则不会有任何错误或异常抛出
  10. # 7、示例：
  11. # 创建一个集合
  12. my_set = {1, 2, 3, 4, 5}
  13. # 使用discard()方法尝试移除元素
  14. my_set.discard(3)  # 元素3存在，将被移除
  15. print(my_set)  # 输出: {1, 2, 4, 5}
  16. # 尝试移除一个不存在的元素
  17. my_set.discard(6)  # 元素6不存在，不会有任何影响
  18. print(my_set)  # 输出: {1, 2, 4, 5}，集合没有改变
5-3-7、intersection()方法
  1. # 1、方法：set1.intersection
  2. # 2、语法：
  3. # 2-1、set1.intersection(set2)
  4. # 2-2、set1.intersection(set2, set3, ...)
  5. # 2-3、set1.intersection(*other_sets)  其中other_sets是一个包含其他集合的序列
  6. # 3、参数：
  7. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  8. # 3-2、set2/set3/*other_sets(可选)：表示与原集合做对比的其他一个或多个集合
  9. # 4、功能：用于返回两个或更多集合的交集，即返回包含在所有集合中都有的元素的新集合
  10. # 5、返回值：
  11. # 5-1、无交集：返回一个空集合
  12. # 5-2、有交集：返回一个非空的新集合
  13. # 6、说明：
  14. # 6-1、intersection()方法不会修改原始的集合，而是返回一个新的集合
  15. # 7、示例：
  16. # 7-1、两个集合的交集
  17. # 创建两个集合
  18. set1 = {1, 2, 3, 4, 5}
  19. set2 = {4, 5, 6, 7, 8}
  20. # 计算交集
  21. result = set1.intersection(set2)
  22. # 打印结果
  23. print(result)  # 输出: {4, 5}
  24. # 7-2、多个集合的交集
  25. # 创建三个集合
  26. set1 = {1, 2, 3, 4, 5}
  27. set2 = {4, 5, 6, 7, 8}
  28. set3 = {5, 8, 9, 10}
  29. # 使用 * 操作符计算交集
  30. result = set1.intersection(set2, set3)
  31. # 或者使用包含集合的列表
  32. other_sets = [set2, set3]
  33. result = set1.intersection(*other_sets)
  34. # 打印结果
  35. print(result)  # 输出: {5}
5-3-8、intersection_update()方法
  1. # 1、方法：set1.intersection_update
  2. # 2、语法：
  3. # 2-1、set1.intersection_update(set2)
  4. # 2-2、set1.intersection_update(set2, set3, ...)
  5. # 2-3、set1.intersection_update(*other_sets)  其中other_sets是一个包含其他集合的序列
  6. # 3、参数：
  7. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  8. # 3-2、set2/set3/*other_sets(可选)：表示与原集合做对比的其他一个或多个集合
  9. # 4、功能：用于更新一个集合，使其只包含该集合和指定集合(或集合序列)的交集
  10. # 5、返回值：经过处理的原集合
  11. # 6、说明：
  12. # 6-1、与intersection()方法不同，intersection_update()会直接修改原集合，而不是返回一个新的集合
  13. # 6-2、如果你需要保留原集合，你应该先使用intersection()方法来计算交集，然后将结果赋值给一个新的变量
  14. # 7、示例：
  15. # 7-1、两个集合的交集更新
  16. # 创建两个集合
  17. set1 = {1, 2, 3, 4, 5}
  18. set2 = {4, 5, 6, 7, 8}
  19. # 使用intersection_update()更新 set1
  20. set1.intersection_update(set2)
  21. # 打印更新后的set1
  22. print(set1)  # 输出: {4, 5}
  23. # 7-2、多个集合的交集更新
  24. # 创建三个集合
  25. set1 = {1, 2, 3, 4, 5}
  26. set2 = {4, 5, 6, 7, 8}
  27. set3 = {5, 8, 9, 10}
  28. # 使用intersection_update()更新set1
  29. set1.intersection_update(set2, set3)
  30. # 或者使用包含集合的列表
  31. other_sets = [set2, set3]
  32. set1.intersection_update(*other_sets)
  33. # 打印更新后的set1
  34. print(set1)  # 输出: {5}
5-3-9、isdisjoint()方法
  1. # 1、方法：set1.isdisjoint
  2. # 2、语法：set1.isdisjoint(set2)
  3. # 3、参数：
  4. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  5. # 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
  6. # 4、功能：用于检查两个集合是否没有交集
  7. # 5、返回值：一个布尔值
  8. # 6、说明：
  9. # 6-1、如果两个集合没有共同的元素，则isdisjoint()返回True；如果它们有至少一个共同的元素，则返回False
  10. # 6-2、isdisjoint()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合是否有交集
  11. # 7、示例：
  12. # 7-1、两个没有交集的集合
  13. # 创建两个没有交集的集合
  14. set1 = {1, 2, 3}
  15. set2 = {4, 5, 6}
  16. # 使用isdisjoint()检查它们是否有交集
  17. result = set1.isdisjoint(set2)
  18. # 打印结果
  19. print(result)  # 输出: True
  20. # 7-2、两个有交集的集合
  21. # 创建两个有交集的集合
  22. set1 = {1, 2, 3, 4}
  23. set2 = {4, 5, 6}
  24. # 使用isdisjoint()检查它们是否有交集
  25. result = set1.isdisjoint(set2)
  26. # 打印结果
  27. print(result)  # 输出: False
5-3-10、issubset()方法
  1. # 1、方法：set1.issubset
  2. # 2、语法：
  3. # 2-1、set1.issubset(set2)
  4. # 2-2、set1 <= set2
  5. # 3、参数：
  6. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  7. # 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
  8. # 4、功能：用于检查一个集合是否是另一个集合的子集
  9. # 5、返回值：一个布尔值
  10. # 6、说明：
  11. # 6-1、如果第一个集合的所有元素都存在于第二个集合中，则结果为True；否则为False
  12. # 6-2、issubset()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合之间的子集关系
  13. # 7、示例：
  14. # 7-1、一个集合是另一个集合的子集
  15. # 创建两个集合
  16. set1 = {1, 2, 3}
  17. set2 = {1, 2, 3, 4, 5}
  18. # 使用issubset()检查set1是否是set2的子集
  19. result = set1.issubset(set2)
  20. # 打印结果
  21. print(result)  # 输出: True
  22. # 或者使用<=运算符
  23. result = set1 <= set2
  24. print(result)  # 输出: True
  25. # 7-2、一个集合不是另一个集合的子集
  26. # 创建两个集合
  27. set1 = {1, 2, 3, 6}
  28. set2 = {1, 2, 3, 4, 5}
  29. # 使用issubset()检查set1是否是set2的子集
  30. result = set1.issubset(set2)
  31. # 打印结果
  32. print(result)  # 输出: False
  33. # 或者使用 <= 运算符
  34. result = set1 <= set2
  35. print(result)  # 输出: False
5-3-11、issuperset()方法
  1. # 1、方法：set1.issuperset
  2. # 2、语法：
  3. # 2-1、set1.issuperset(set2)
  4. # 2-2、set1 >= set2
  5. # 3、参数：
  6. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  7. # 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
  8. # 4、功能：用于检查一个集合是否是另一个集合的超集
  9. # 5、返回值：一个布尔值
  10. # 6、说明：
  11. # 6-1、如果第一个集合包含第二个集合的所有元素，则结果为True；否则为False
  12. # 6-2、issuperset()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合之间的超集关系
  13. # 7、示例：
  14. # 7-1、一个集合是另一个集合的超集
  15. # 创建两个集合
  16. set1 = {1, 2, 3, 4, 5}
  17. set2 = {1, 2, 3}
  18. # 使用issuperset()检查set1是否是set2的超集
  19. result = set1.issuperset(set2)
  20. # 打印结果
  21. print(result)  # 输出: True
  22. # 或者使用 >= 运算符
  23. result = set1 >= set2
  24. print(result)  # 输出: True
  25. # 7-2、一个集合不是另一个集合的超集
  26. # 创建两个集合
  27. set1 = {1, 2, 3}
  28. set2 = {1, 2, 3, 4, 5}
  29. # 使用issuperset()检查set1是否是set2的超集
  30. result = set1.issuperset(set2)
  31. # 打印结果
  32. print(result)  # 输出: False
  33. # 或者使用 >= 运算符
  34. result = set1 >= set2
  35. print(result)  # 输出: False
5-3-12、pop()函数
  1. # 一个模拟set.pop()行为的自定义函数
  2. def set_pop(s):
  3.     if not s:
  4.         raise KeyError('pop from an empty set')
  5.         # 将集合转换为列表，弹出第一个元素，然后更新集合
  6.     item = list(s)[0]
  7.     s.remove(item)
  8.     return item
  9. # 示例用法
  10. my_set = {1, 2, 3, 4, 5}
  11. item = set_pop(my_set)
  12. print(item)  # 输出：1
  13. print(my_set)  # 输出：{2, 3, 4, 5}
5-3-13、remove()方法
  1. # 1、方法：set.remove
  2. # 2、语法：set.remove(element)
  3. # 3、参数：
  4. # 3-1、set(必须)：表示一个做为参考基准的原集合
  5. # 3-2、element(必须)：表示待从原集合中移除的一个指定元素
  6. # 4、功能：用于从集合中移除指定的元素
  7. # 5、返回值：在原集合基础上移除指定元素后形成的集合，若指定元素不存在于原集合中，则返回原集合
  8. # 6、说明：
  9. # 6-1、如果元素存在于集合中，则将其移除；如果元素不存在，则会引发一个KeyError异常
  10. # 6-2、如果你不确定元素是否存在于集合中，并且不希望因为尝试移除不存在的元素而引发异常，那么discard()方法是一个更好的选择
  11. # 7、示例：
  12. # 7-1、成功移除元素
  13. # 创建一个集合
  14. my_set = {1, 2, 3, 4, 5}
  15. # 移除元素 3
  16. my_set.remove(3)
  17. # 打印集合
  18. print(my_set)  # 输出: {1, 2, 4, 5}
  19. # 7-2、尝试移除不存在的元素(将引发异常)
  20. # 创建一个集合
  21. my_set = {1, 2, 3, 4, 5}
  22. # 尝试移除元素6(不存在于集合中)
  23. try:
  24.     my_set.remove(6)
  25. except KeyError:
  26.     print("元素6不存在于集合中") # 输出：元素6不存在于集合中
  27. # 打印集合
  28. print(my_set)  # 输出: {1, 2, 3, 4, 5}
5-3-14、symmetric_difference()方法
  1. # 1、方法：set1.symmetric_difference
  2. # 2、语法：
  3. # 2-1、set1.symmetric_difference(set2)
  4. # 2-2、set1 ^ set2
  5. # 3、参数：
  6. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  7. # 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
  8. # 4、功能：用于计算两个集合的对称差集
  9. # 5、返回值：返回一个新的集合，其中包含对称差集的结果
  10. # 6、说明：
  11. # 6-1、symmetric_difference()方法不会修改原始的集合，而是返回一个新的集合，其中包含对称差集的结果
  12. # 6-2、你可以使用symmetric_difference_update()方法来更新一个集合，使其包含与另一个集合的对称差集，这个方法会修改原始的集合
  13. # 7、示例：
  14. # 7-1、计算两个集合的对称差集
  15. # 创建两个集合
  16. set1 = {1, 2, 3, 4}
  17. set2 = {3, 4, 5, 6}
  18. # 使用symmetric_difference()方法计算对称差集
  19. symmetric_diff = set1.symmetric_difference(set2)
  20. # 打印结果
  21. print(symmetric_diff)  # 输出: {1, 2, 5, 6}
  22. # 使用^运算符计算对称差集
  23. symmetric_diff_op = set1 ^ set2
  24. print(symmetric_diff_op)  # 输出: {1, 2, 5, 6}
  25. # 7-2、使用空集合计算对称差集
  26. # 创建一个集合和一个空集合
  27. set1 = {1, 2, 3}
  28. set2 = set()
  29. # 使用symmetric_difference()方法计算对称差集
  30. symmetric_diff = set1.symmetric_difference(set2)
  31. # 打印结果
  32. print(symmetric_diff)  # 输出: {1, 2, 3}
  33. # 使用^运算符计算对称差集
  34. symmetric_diff_op = set1 ^ set2
  35. print(symmetric_diff_op)  # 输出: {1, 2, 3}
5-3-15、symmetric_difference_update()方法
  1. # 1、方法：set.symmetric_difference_update
  2. # 2、语法：set.symmetric_difference_update(other_set)
  3. # 3、参数：
  4. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  5. # 3-2、other_set(可选)：表示与原集合做对比的其他集合，可以是空集合
  6. # 4、功能：用于更新一个集合，使其包含与另一个集合的对称差集，这意味着它会移除两个集合中都存在的元素，并添加仅存在于其中一个集合中的元素。
  7. # 5、返回值：经过处理后的原集合
  8. # 6、说明：
  9. # 6-1、symmetric_difference_update()方法直接修改调用它的集合，而不是返回一个新的集合
  10. # 6-2、如果想保留原始集合不变并获取对称差集，应该使用symmetric_difference()方法
  11. # 7、示例：
  12. # 7-1、使用symmetric_difference_update()更新集合
  13. # 创建两个集合
  14. set1 = {1, 2, 3, 4}
  15. set2 = {3, 4, 5, 6}
  16. # 使用symmetric_difference_update()更新set1
  17. set1.symmetric_difference_update(set2)
  18. # 打印更新后的set1
  19. print(set1)  # 输出: {1, 2, 5, 6}
  20. # 注意：set1已经被修改，它现在包含与set2的对称差集
  21. # 7-2、使用空集合进行symmetric_difference_update()
  22. # 创建一个集合和一个空集合
  23. set1 = {1, 2, 3}
  24. set2 = set()
  25. # 使用symmetric_difference_update()更新set1
  26. set1.symmetric_difference_update(set2)
  27. # 打印更新后的set1
  28. print(set1)  # 输出: {1, 2, 3}
  29. # 因为set2是空的，所以set1没有发生变化
5-3-16、union()方法
  1. # 1、方法：set1.union
  2. # 2、语法：
  3. # 2-1、set1.union(set2, ...)
  4. # 2-2、set1 | set2 | ...
  5. # 3、参数：
  6. # 3-1、set1(必须)：表示一个做为参考基准的原集合
  7. # 3-2、set2(可选)：表示与原集合做合并处理的其他集合，可以是空集合
  8. # 4、功能：用于合并两个或多个集合中的所有元素，并返回一个新的集合，其中包含所有独特的元素(注：独特，表示保持元素的唯一性)
  9. # 5、返回值：一个新的集合，其中包含所有独特的元素
  10. # 6、说明：
  11. # 6-1、如果某个元素在两个集合中都存在，它只会在结果集合中出现一次
  12. # 6-2、union()方法不会修改原始集合，而是返回一个新的集合，其中包含所有输入集合的并集
  13. # 7、示例：
  14. # 7-1、使用union()方法合并两个集合
  15. # 创建两个集合
  16. set1 = {1, 2, 3}
  17. set2 = {3, 4, 5}
  18. # 使用union()方法合并集合
  19. union_set = set1.union(set2)
  20. # 打印结果
  21. print(union_set)  # 输出: {1, 2, 3, 4, 5}
  22. # 7-2、使用 | 运算符合并两个集合
  23. # 创建两个集合
  24. set1 = {1, 2, 3}
  25. set2 = {3, 4, 5}
  26. # 使用 | 运算符合并集合
  27. union_set = set1 | set2
  28. # 打印结果
  29. print(union_set)  # 输出: {1, 2, 3, 4, 5}
  30. # 7-3、合并多个集合
  31. # 创建三个集合
  32. set1 = {1, 2, 3}
  33. set2 = {3, 4, 5}
  34. set3 = {5, 6, 7}
  35. # 使用union()方法合并多个集合
  36. union_set = set1.union(set2, set3)
  37. # 打印结果
  38. print(union_set)  # 输出: {1, 2, 3, 4, 5, 6, 7}
5-3-17、update()方法
  1. # 1、方法：set.update
  2. # 2、语法：set.update(iterable, ...)
  3. # 3、参数：
  4. # 3-1、iterable：一个或多个可迭代对象，如列表、元组、集合等
  5. # 4、功能：用于向集合中添加元素
  6. # 5、返回值：修改原始集合或返回None
  7. # 6、说明：
  8. # 6-1、update()方法会修改原始集合，向其添加元素，但不会返回新的集合(它返回None)
  9. # 6-2、如果要添加的元素已经存在于集合中，update()方法不会有任何效果
  10. # 6-3、当你传递多个可迭代对象给update()方法时，它会依次处理每个可迭代对象，并将它们中的所有元素添加到集合中
  11. # 7、示例：
  12. # 7-1、使用update()方法向集合中添加元素
  13. # 创建一个集合
  14. my_set = {1, 2, 3}
  15. # 使用update()方法添加元素
  16. my_set.update([4, 5])  # 添加列表中的元素
  17. # 打印更新后的集合
  18. print(my_set)  # 输出: {1, 2, 3, 4, 5}
  19. # 7-2、使用update()方法添加多个元素和集合
  20. # 创建一个集合
  21. my_set = {1, 2, 3}
  22. # 使用update()方法添加多个元素和另一个集合
  23. my_set.update([4, 5], {6, 7})  # 添加列表和集合中的元素
  24. # 打印更新后的集合
  25. print(my_set)  # 输出: {1, 2, 3, 4, 5, 6, 7}

二、推荐阅读

1、Python-VBA函数之旅-set()函数

2、Python算法之旅

3、Python函数之旅

4、个人主页-神奇夜光杯-CSDN

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/636637
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号