Python Set集合 定义 创建 基本方法 集合运算 交并差集 对称差集 增加 删除 遍历

本文介绍Python中Set集合的基本概念,创建方法及常用操作。探讨集合如何用于成员测试、删除重复项及数学运算,如并集、交集、差集等。详解set与frozenset的区别及其应用场景。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Python Set集合 定义 创建 基本方法

定义

  • Set Types-Set,frozenset

  • set 对象是由具有唯一性的 hashable对象所组成的无序多项集。常见的用途包括成员测试、从序列中删除重复项以及计算数学运算,如交集、并集、差分和对称差分

  • 与其他集合一样,set支持x in setlen(set)For x in set。集合是无序集合,不记录元素位置或插入顺序。因此,集合不支持索引、切片或其他类似序列的行为。

  • 当前有两种内置的set类型,setfrozenset。集合类型是可变的-可以使用add()remove()等方法更改内容。因为它是可变的,所以它没有哈希值,不能用作字典键或另一个集合的元素。frozenset类型是不可变的和可散列的-它的内容在创建之后不能被更改;因此,它可以用作字典键或另一个集合的元素。

  • 除了set构造函数之外,还可以通过在大括号中放置逗号分隔的元素列表(例如:{'jack','sjoerd})来创建非空集(不是frozensets)。

  • 返回一个新的set或frozenset对象,其元素取自iterable。集合的元素必须是可哈希的。要表示集合的集合,内部集合必须是frozenset对象。如果未指定iterable,则返回一个新的空集。

创建

集合可以通过多种方式创建:

  1. 使用逗号分隔的大括号内元素列表:{'jack', 'sjoerd'}

  2. 使用集合理解:{c for c in 'abracadabra' if c not in 'abc'}

  3. 使用类型构造函数:set()set('foobar')set(['a','b','foo'])

>>> {c for c in 'abracadabra' if c not in 'abc'}
{'d', 'r'}
>>> set('foobar')
{'b', 'r', 'f', 'o', 'a'}
>>> set(['a','b','foo'])
{'b', 'foo', 'a'}

显示

  • 集合显示 集合显示由大括号表示,并且由于缺少分隔键和值的冒号而与字典显示区分开来:
set_display ::=  "{" (starred_list | comprehension) "}"
  • 集合显示产生一个新的可变集合对象, 由表达式序列或推导式指定的内容。 当提供一个逗号分隔的表达式列表时,它的元素从左到右求值并添加到集合对象中。 当提供了一个推导式时,集合是由推导式产生的元素构造的。

  • 不能用 {} 构造空集; 这个字面量构造了一个空字典。

方法

集合操作

查看

setfrozenset 的实例提供以下操作:

  • len(s) 返回集合s中元素的数量(s的基数)。

  • x in s 测试 xs中的成员资格。

  • x not in s中测试 x是否为 s中的非成员。

>>> a = set("fyznb")
{'z', 'b', 'n', 'f', 'y'}
>>> b = {'a', 'b', 'x', 'y'}
{'y', 'b', 'x', 'a'}
>>> len(b)
4
>>> 'x' in b, 'c' not in b
(True, True)
  • isdisjoint(other)如果集合中没有与 other共有的元素则返回 True。 当且仅当两个集合的交集为空集合时,两者为不相交集合。
>>> a, b
({'z', 'b', 'n', 'f', 'y'}, {'y', 'b', 'x', 'a'})
>>> a.isdisjoint(b), a.isdisjoint({'c', 'd'})
(False, True)
  • issubset(other)

    • set <= other 测试set中的每个元素是否都在 other中。
    • set < other 测试set是否是other的真子集,即set <= other and set != other
    >>> set("abc").issubset(set('abcd'))
    True
    >>> set("abc") <= set('abcd')
    True
    >>> set("abc") < set('abc')
    False
    
  • issuperset(other)

    • set >= other 测试 other中的每个元素是否都在set中。
    • set > other 测试该set是否是other的真超集,即set >= other and set != other
    >>> set("abcd").issuperset(set('ab'))
    True
    >>> set("abcd") >= set('ab')
    True
    >>> set("abcd") > set('ab')
    True
    
运算
  • 并集union(*others)

    • set | other | ...返回一个包含set中的元素和others的新集合。
  • 交集intersection(*others)

    • set & other & ...返回一个新的集合,其中包含setothers共有的元素。
>>> set("abc").union(set("bcd"))
{'d', 'c', 'a', 'b'}
>>> set("abc") | set("bcd")
{'d', 'c', 'a', 'b'}
>>> set("abc").intersection(set("bcd"))
{'b', 'c'}
>>> set("abc") & set("bcd")
{'b', 'c'}
  • 差集difference(*others)

    • set - other - ...返回一个新集合,该集合中的元素不在others中。
  • 对称差集symmetric_difference(other)

    • set ^ other 返回一个新集合,其中的元素或属于set或属于 other 指定的其他集合,但不能同时属于两者。
>>> set("abc").difference(set("bcd"))
{'a'}
>>> set("abc") - set("bcd")
{'a'}
>>> set("abc").symmetric_difference(set("bcd"))
{'d', 'a'}
>>> set("abc") ^ set("bcd")
{'d', 'a'}

Notes:union()intersection()difference()symmetric_difference()issubset()issuperset()方法的非运算符版本将接受任何可迭代对象作为参数。 相比之下,它们的基于运算符的对应物需要设置它们的参数。 这排除了像 set('abc') & 'cbs'这样容易出错的结构,而支持更易读的 set('abc').intersection('cbs')

set&frozenset的区别

setfrozenset均支持集合与集合的比较。 两个集合当且仅当每个集合中的每个元素均包含于另一个集合之内(即各为对方的子集)时则相等。 一个集合当且仅当其为另一个集合的真子集(即为后者的子集但两者不相等)时则小于另一个集合。 一个集合当且仅当其为另一个集合的真超集(即为后者的超集但两者不相等)时则大于另一个集合。

set的实例与 frozenset的实例之间基于它们的成员进行比较。 例如 set('abc') == frozenset('abc')返回 Trueset('abc') in set([frozenset('abc')])也一样。

子集与相等比较并不能推广为完全排序函数。 例如,任意两个非空且不相交的集合不相等且互不为对方的子集,因此以下 所有 比较均返回 False: a<b, a==b, or a>b

由于集合仅定义了部分排序(子集关系),因此由集合构成的列表list.sort()方法的输出并无定义。

集合的元素,与字典的键类似,必须为 hashable

混合了 set实例与 frozenset的二进制位运算将返回与第一个操作数相同的类型。例如: frozenset('ab') | set('bc') 将返回 frozenset 的实例。

下面列出了可用于 set而不能用于不可变的 frozenset实例的操作:

自运算
  • update(*others)
    • set |= other | ...更新集合,添加来自 others 中的所有元素。
  • intersection_update(*others)
    set &= other & ...更新集合,只保留其中在所有 others 中也存在的元素。
>>> s = {'b', 'c', 'a'}
>>> s.update(set("bcd"))
#   s |= set("bcd")
>>> s
{'d', 'c', 'a', 'b'}
>>> s.intersection_update(set("bcd"))
#   s &= set("bcd")
>>> s
{'b', 'd', 'c'}
  • difference_update(*others)
    set -= other | ...更新集合,移除其中也存在于 others 中的元素。
  • symmetric_difference_update(other)
    set ^= other更新集合,只保留存在于集合的一方而非共同存在的元素。
>>> s = {'b', 'c', 'a'}
>>> s.difference_update(set("bcd"))
#   s -= set("bcd")
>>> s
{'a'}
>>> s.symmetric_difference_update(set("bcd"))
#   s ^= set("bcd")
>>> s
{'b', 'd', 'c', 'a'}
增删改
  • add(elem)将元素 elem添加到集合中。
  • remove(elem)从集合中移除元素 elem。 如果 elem不存在于集合中则会引发 KeyError
  • discard(elem)如果元素 elem存在于集合中则将其移除。
  • pop()从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError
>>> s = {'b', 'd', 'c', 'a'}
>>> s.add("e")
{'e', 'd', 'b', 'c', 'a'}
>>> s.remove("e")
{'d', 'b', 'c', 'a'}
>>> s.discard("e")
>>> s.remove("e")
KeyError: 'e'
>>> s.pop()
'd'
  • clear()从集合中移除所有元素。
  • copy()返回集合的浅拷贝。
>>> s = {'b', 'd', 'c', 'a'}
>>> sa = s.copy()
>>> s.clear()
>>> s, sa
(set(), {'b', 'd', 'c', 'a'})

Notes,非运算符版本的 update(), intersection_update(), difference_update()symmetric_difference_update()方法将接受任意可迭代对象作为参数。

Notes__contains__(), remove()discard() 方法的 elem参数可能是一个 set。 为支持对一个等价的 frozenset进行搜索,会根据 elem临时创建一个该类型对象。

集合遍历

由于set 对象是由具有唯一性的 hashable对象所组成的无序多项集,故不能用下标来访问,但可以使用迭代把集合中的值读出来。也可以转为其它格式查看

>>> s = {'b', 'd', 'c', 'a'}

>>> for i in s:
	print(i, end = ' ')

	
b d c a 

>>> list(s)  # 列表
['b', 'd', 'c', 'a']
>>> tuple(s) # 元组
('b', 'd', 'c', 'a')
<think>好的,我现在需要帮助用户理解如何用编程语言模拟集合对称差集运算提供示例代码和算法解释。首先,我得回忆一下对称差集定义根据用户提供的引用[2],对称差集集合的XOR操作,也就是属于两个集合中恰好一个的元素组成的集合。例如,集合s和t的对称差集包含那些在st中但不同时在两者中的元素。 接下来,我需要考虑如何用算法实现这个操作。常见的方法有两种:第一种是分别找出只在s中的元素和只在t中的元素,然后将它们合。这可以通过遍历两个集合,检查每个元素是否存在于另一个集合中来实现。第二种方法是利用集合运算的性质,对称差集等于集减去交集,即(s ∪ t) - (s ∩ t)。这两种方法各有优劣,第一种可能更直观,第二种则可以利用现有的集合操作函数来简化代码。 然后,我需要考虑如何在不同的编程语言中实现这个操作。例如,Python中可以直接使用s ^ t者symmetric_difference()方法,但用户可能需要自己实现,比如在教学理解底层机制的情况下。如果是自己实现,可以用循环遍历每个元素,检查是否符合条件。例如,对于集合s中的每个元素,如果不在t中,就加入结果集;同样处理集合t中的元素,如果不在s中,也加入结果集。 另外,需要考虑时间复杂度的优化。如果使用哈希表类似的数据结构,检查元素是否存在的时间复杂度是O(1),那么整个算法的时间复杂度是O(n+m),其中n和m是两个集合的大小。但如果使用数组列表,检查存在性可能需要O(n)时间,导致整体复杂度为O(nm),这在数据量大时效率不高。因此,建议使用哈希集合来实现以提高效率。 用户可能需要示例代码,所以我得用常见的语言比如Python来展示。Python本身支持集合操作,但为了演示算法,可以手动实现。例如,创建一个空集合遍历第一个集合中的元素,添加到结果中如果不在第二个集合里,然后同样处理第二个集合的元素。 同时,需要考虑边界情况,比如空集合的情况,者两个集合有部分重叠的情况。测试用例可以帮助验证实现的正确性,比如s = {1,2,3}, t = {3,4,5},对称差集应该是{1,2,4,5}。 最后,要确保回答结构清晰,先解释算法步骤,再给出代码示例,分析时间和空间复杂度,可能还要提到优化方法。用户的问题可能涉及到性能分析,所以在相关问题上可以引导他们考虑这些方面。同时,根据用户提供的引用,可能需要引用相关的资料,但在这里用户给的引用可能不太相关,所以需要谨慎处理。</think>### 对称差集运算的算法实现 对称差集(Symmetric Difference)是集合运算中的一种,定义为:**属于集合A集合B,但不同时属于两者的元素组成的集合**。数学表达式为: $$A \triangle B = (A \cup B) - (A \cap B) = (A - B) \cup (B - A)$$ ### 实现步骤 1. **遍历集合A**:将集合A中所有**不在集合B中**的元素加入结果集; 2. **遍历集合B**:将集合B中所有**不在集合A中**的元素加入结果集; 3. **返回结果集**。 ### 代码实现(Python示例) ```python def symmetric_difference(s1, s2): # 方法1:手动实现 result = set() for x in s1: if x not in s2: result.add(x) for x in s2: if x not in s1: result.add(x) return result # 方法2:直接使用内置运算符 # return s1 ^ s2 # 测试示例 s = {1, 2, 3} t = {3, 4, 5} print(symmetric_difference(s, t)) # 输出 {1, 2, 4, 5} ``` ### 算法分析 1. **时间复杂度**: - 若使用哈希表存储集合(如Python的`set`),时间复杂度为$O(n + m)$,其中$n$和$m$为两个集合的大小; - 若使用列表存储集合,时间复杂度会退化为$O(n \times m)$。 2. **空间复杂度**: 结果集最多包含$n + m$个元素,因此空间复杂度为$O(n + m)$。 ### 优化方法 - **利用集合操作特性**:直接使用$s1 ^ s2$运算符(Python内置),底层采用哈希优化,效率更高[^2]; - **行化处理**:对于大规模数据,可将集合分块后遍历
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SK Primin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值