Python筑基之旅-集合

news2024/11/26 6:56:31

目录

 一、集合

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所有属性和方法的列表

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

4、获取集合的帮助信息

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

help(set)
# Help on class set in module builtins:
# 
# class set(object)
#  |  set() -> new empty set object
#  |  set(iterable) -> new set object
#  |  
#  |  Build an unordered collection of unique elements.
#  |  
#  |  Methods defined here:
#  |  
#  |  __and__(self, value, /)
#  |      Return self&value.
#  |  
#  |  __contains__(...)
#  |      x.__contains__(y) <==> y in x.
#  |  
#  |  __eq__(self, value, /)
#  |      Return self==value.
#  |  
#  |  __ge__(self, value, /)
#  |      Return self>=value.
#  |  
#  |  __getattribute__(self, name, /)
#  |      Return getattr(self, name).
#  |  
#  |  __gt__(self, value, /)
#  |      Return self>value.
#  |  
#  |  __iand__(self, value, /)
#  |      Return self&=value.
#  |  
#  |  __init__(self, /, *args, **kwargs)
#  |      Initialize self.  See help(type(self)) for accurate signature.
#  |  
#  |  __ior__(self, value, /)
#  |      Return self|=value.
#  |  
#  |  __isub__(self, value, /)
#  |      Return self-=value.
#  |  
#  |  __iter__(self, /)
#  |      Implement iter(self).
#  |  
#  |  __ixor__(self, value, /)
#  |      Return self^=value.
#  |  
#  |  __le__(self, value, /)
#  |      Return self<=value.
#  |  
#  |  __len__(self, /)
#  |      Return len(self).
#  |  
#  |  __lt__(self, value, /)
#  |      Return self<value.
#  |  
#  |  __ne__(self, value, /)
#  |      Return self!=value.
#  |  
#  |  __or__(self, value, /)
#  |      Return self|value.
#  |  
#  |  __rand__(self, value, /)
#  |      Return value&self.
#  |  
#  |  __reduce__(...)
#  |      Return state information for pickling.
#  |  
#  |  __repr__(self, /)
#  |      Return repr(self).
#  |  
#  |  __ror__(self, value, /)
#  |      Return value|self.
#  |  
#  |  __rsub__(self, value, /)
#  |      Return value-self.
#  |  
#  |  __rxor__(self, value, /)
#  |      Return value^self.
#  |  
#  |  __sizeof__(...)
#  |      S.__sizeof__() -> size of S in memory, in bytes
#  |  
#  |  __sub__(self, value, /)
#  |      Return self-value.
#  |  
#  |  __xor__(self, value, /)
#  |      Return self^value.
#  |  
#  |  add(...)
#  |      Add an element to a set.
#  |      
#  |      This has no effect if the element is already present.
#  |  
#  |  clear(...)
#  |      Remove all elements from this set.
#  |  
#  |  copy(...)
#  |      Return a shallow copy of a set.
#  |  
#  |  difference(...)
#  |      Return the difference of two or more sets as a new set.
#  |      
#  |      (i.e. all elements that are in this set but not the others.)
#  |  
#  |  difference_update(...)
#  |      Remove all elements of another set from this set.
#  |  
#  |  discard(...)
#  |      Remove an element from a set if it is a member.
#  |      
#  |      Unlike set.remove(), the discard() method does not raise
#  |      an exception when an element is missing from the set.
#  |  
#  |  intersection(...)
#  |      Return the intersection of two sets as a new set.
#  |      
#  |      (i.e. all elements that are in both sets.)
#  |  
#  |  intersection_update(...)
#  |      Update a set with the intersection of itself and another.
#  |  
#  |  isdisjoint(...)
#  |      Return True if two sets have a null intersection.
#  |  
#  |  issubset(self, other, /)
#  |      Test whether every element in the set is in other.
#  |  
#  |  issuperset(self, other, /)
#  |      Test whether every element in other is in the set.
#  |  
#  |  pop(...)
#  |      Remove and return an arbitrary set element.
#  |      Raises KeyError if the set is empty.
#  |  
#  |  remove(...)
#  |      Remove an element from a set; it must be a member.
#  |      
#  |      If the element is not a member, raise a KeyError.
#  |  
#  |  symmetric_difference(...)
#  |      Return the symmetric difference of two sets as a new set.
#  |      
#  |      (i.e. all elements that are in exactly one of the sets.)
#  |  
#  |  symmetric_difference_update(...)
#  |      Update a set with the symmetric difference of itself and another.
#  |  
#  |  union(...)
#  |      Return the union of sets as a new set.
#  |      
#  |      (i.e. all elements that are in either set.)
#  |  
#  |  update(...)
#  |      Update a set with the union of itself and others.
#  |  
#  |  ----------------------------------------------------------------------
#  |  Class methods defined here:
#  |  
#  |  __class_getitem__(...) from builtins.type
#  |      See PEP 585
#  |  
#  |  ----------------------------------------------------------------------
#  |  Static methods defined here:
#  |  
#  |  __new__(*args, **kwargs) from builtins.type
#  |      Create and return a new object.  See help(type) for accurate signature.
#  |  
#  |  ----------------------------------------------------------------------
#  |  Data and other attributes defined here:
#  |  
#  |  __hash__ = None

5、集合的用法

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

二、推荐阅读

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

2、Python算法之旅

3、Python函数之旅

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1708917.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

鸿蒙OS开发：【一次开发，多端部署】（app市场首页）项目

鸿蒙OS开发：【一次开发，多端部署】（app市场首页）项目

一多应用市场首页 介绍 本示例展示了应用市场首页&#xff0c;页面中包括Tab栏、运营横幅、精品应用、精品游戏等。 本示例使用一次开发多端部署中介绍的自适应布局能力和响应式布局能力进行多设备&#xff08;或多窗口尺寸&#xff09;适配&#xff0c;保证应用在不同设备或…
阅读更多...
【pyspark速成专家】11_Spark性能调优方法2

【pyspark速成专家】11_Spark性能调优方法2

目录 ​编辑 二&#xff0c;Spark任务UI监控 三&#xff0c;Spark调优案例 二&#xff0c;Spark任务UI监控 Spark任务启动后&#xff0c;可以在浏览器中输入 http://localhost:4040/ 进入到spark web UI 监控界面。 该界面中可以从多个维度以直观的方式非常细粒度地查看Spa…
阅读更多...
大数据技术Hbase列数据库——topic1

大数据技术Hbase列数据库——topic1

目录 搭建单机版Hbase验证方法一验证方法二 搭建单机版Hbase 验证方法一 使用 jps 命令查看 HMaster 进程是否启动 首先使用xftp 7上传hbase-2.1.0安装压缩包到虚拟机进行解压缩到某一地址&#xff0c;这里解压缩到了上传的路径即/root/software/ tar -zxvf hbase-2.1.0-bi…
阅读更多...
OrangePi AIpro (8T)使用体验，性能测试报告

OrangePi AIpro (8T)使用体验，性能测试报告

前言 这段时间收到了CSDN和香橙派的邀请&#xff0c;对OrangePi AIpro进行体验测评&#xff0c;在此感谢CSDN对我的信任&#xff0c;也感谢香橙派能做出如此优秀的开发板。 可喜可贺&#xff0c;周三晚上我收到了官方寄出的OrangePi AIpro。出于对国产芯片的好奇&#xff0c…
阅读更多...
苹果与OpenAI合作在即：iOS 18中的ChatGPT引发期待与担忧

苹果与OpenAI合作在即：iOS 18中的ChatGPT引发期待与担忧

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
idea的project structure下project [lauguage ]()level 没有java的sdk17选项如何导入

idea的project structure下project [lauguage ]()level 没有java的sdk17选项如何导入

idea的project structure下project lauguage level 没有java的sdk17选项如何导入 别导入了&#xff0c;需要升级idea版本。idea中没有project language level没有17如何添加 - CSDN文库 别听这文章瞎扯淡 2021版本就是没有&#xff0c;直接卸载升级到最新版本就可以了。没办法…
阅读更多...
马斯克的 xAI 帝国！60亿融资背后的超级布局？

马斯克的 xAI 帝国！60亿融资背后的超级布局？

在全球科技竞技场&#xff0c;每个重大融资事件都是对行业格局的一次重塑。近日&#xff0c;埃隆马斯克的人工智能初创企业 xAI 成功完成了一轮规模空前的融资——60亿美元&#xff0c;此举无疑在业界投下了一枚震撼弹&#xff0c;标志着 AI 领域内一场新的竞赛拉开了序幕。 …
阅读更多...
SwiftUI中AppStorage的介绍使用

SwiftUI中AppStorage的介绍使用

在Swift中&#xff0c;AppStorage是SwiftUI中引入的一个属性包装器&#xff0c;在这之前我们要存储一些轻量级的数据采用UserDefaults进行存取。而AppStorage用于从UserDefaults中读取值&#xff0c;当值改变时&#xff0c;它会自动重新调用视图的body属性。也就是说&#xff0…
阅读更多...
CC1310 Debug interface is locked

CC1310 Debug interface is locked

XDS110连接CC1310板子&#xff0c;打开Smart RF 弹出窗口如下&#xff1a; 解决办法&#xff1a; 1 打开SmartRF Flash Programmer 2 选择连接的设备CC1310, 弹出如下窗口&#xff0c;点击OK。 3 点击Tools图标&#xff0c;选择CC26XX/CC13XX Forced Mass Erase。 4 在弹出的…
阅读更多...
骆驼大赛

骆驼大赛

目录 一&#xff0c;主版图 二&#xff0c;骰子 三&#xff0c;初始设置 四&#xff0c;核心规则 五&#xff0c;结算 这是适合5-8人玩的一个概率推理类的回合制桌游。 一&#xff0c;主版图 赛道由16个格子组成&#xff0c;编号为1-16。 一共7个骆驼&#xff0c;其中正…
阅读更多...
就说说Java初学者求职准备项目的正确方式

就说说Java初学者求职准备项目的正确方式

当下不少Java初学者也知道求职时项目的重要程度&#xff0c;但在简历上写项目和准备面试项目时&#xff0c;真有可能走弯路&#xff0c;这样的话&#xff0c;加重学习负担还是小事&#xff0c;还真有可能导致无法入职。 1 对于在校生和应届生来说&#xff0c;你去跑通个学习项…
阅读更多...
四川汇聚荣聚荣科技有限公司好不好？

四川汇聚荣聚荣科技有限公司好不好？

在当今科技飞速发展的时代&#xff0c;企业要想在激烈的市场竞争中脱颖而出&#xff0c;必须具备强大的技术实力和良好的市场口碑。那么&#xff0c;作为一家专注于科技创新的公司&#xff0c;四川汇聚荣聚荣科技有限公司究竟如何呢?接下来&#xff0c;我们将从四个方面进行详…
阅读更多...
探索Python列表的奥秘：从零开始学习

探索Python列表的奥秘：从零开始学习

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、列表简介与用途 二、列表的创建与访问 三、列表的增删改查 四、列表生成式与高级操作…
阅读更多...
信创加持 YashanDB通过商用密码产品认证

信创加持 YashanDB通过商用密码产品认证

近期&#xff0c;深算院自主研发的“YashanDB V23”成功获得由国家密码管理局商用密码检测中心颁发的《商用密码产品认证证书》&#xff0c;通过GM/T 0028《密码模块安全技术要求》安全等级第二级认证。这标志着YashanDB密码技术和密码管理领域达到了国家标准&#xff0c;能够全…
阅读更多...
股民用脚投票 退退退！

股民用脚投票 退退退！

倒计时2天&#xff0c;看来今年首只非ST类要退市的股票诞生了。 继上周五封S跌停后&#xff0c;今天正源&#xff08;股份&#xff09;再度被股民用脚投票一字跌停&#xff0c; 这已经连续第18个交易日股价低于1块钱了。 按照退市新规&#xff0c;连续20个交易日股价低于1元是…
阅读更多...
专业渗透测试 Phpsploit-Framework（PSF）框架软件小白入门教程（九）

专业渗透测试 Phpsploit-Framework（PSF）框架软件小白入门教程（九）

本系列课程&#xff0c;将重点讲解Phpsploit-Framework框架软件的基础使用&#xff01; 本文章仅提供学习&#xff0c;切勿将其用于不法手段&#xff01; 继续接上一篇文章内容&#xff0c;讲述如何进行Phpsploit-Framework软件的基础使用和二次开发。 现在&#xff0c;我们…
阅读更多...
信息标记形式 (XML, JSON, YAML)

信息标记形式 (XML, JSON, YAML)

文章目录 &#x1f5a5;️介绍&#x1f5a5;️三种形式&#x1f3f7;️XML (Extensible Markup Language)&#x1f516;规范&#x1f516;注释&#x1f516;举例&#x1f516;其他 &#x1f3f7;️JSON (JavaScript Object Notation)&#x1f516;规范&#x1f516;注释&#x…
阅读更多...
机器之心 | 清华接手，YOLOv10问世：性能大幅提升，登上GitHub热榜

机器之心 | 清华接手，YOLOv10问世：性能大幅提升，登上GitHub热榜

本文来源公众号“机器之心”&#xff0c;仅用于学术分享&#xff0c;侵权删&#xff0c;干货满满。 原文链接&#xff1a;清华接手&#xff0c;YOLOv10问世&#xff1a;性能大幅提升&#xff0c;登上GitHub热榜 相同性能情况下&#xff0c;延迟减少 46%&#xff0c;参数减少 2…
阅读更多...
知识产权与标准化

知识产权与标准化

知识产权与标准化 导航 文章目录 知识产权与标准化导航一、知识产权概述二、保护范围与对象三、保护期限四、知识产权归属五、侵权判定六、标准的分类 一、知识产权概述 知识产权:知识产权是指人们就其智力劳动成果所依法享有的专有权利&#xff0c;通常是国家赋予创造者对其…
阅读更多...
SNP数据转型解析：云服务在现代企业数字化转型的必要性

SNP数据转型解析：云服务在现代企业数字化转型的必要性

为什么当今的企业想为数字化工作环境做好准备并保持竞争力&#xff0c;很难避免使用云服务呢&#xff1f; 要理解为什么企业没有云的替代选择&#xff0c;我们需要了解云服务的含义 - 它不仅仅指存储数据的另一个位置。各种云模型提供了极大的灵活性&#xff0c;可以根据需要操…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023