Leetcode884. 两句话中的不常见单词 难度:简单

本文深入讲解Python中集合(set)的创建、更新、删除及各种集合操作,如交集、并集、差集、对称差集等,并对比深拷贝与浅拷贝的区别。

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

例程:

    def uncommonFromSentences(self, A, B):
        count = {}
        for word in A.split():
            count[word] = count.get(word, 0) + 1
        for word in B.split():
            count[word] = count.get(word, 0) + 1

        #Alternatively:
        #count = collections.Counter(A.split())
        #count += collections.Counter(B.split())

        return [word for word in count if count[word] == 1]

 

 

Note:

1、python set 函数

   set特性:不重复,元素不可变

  (1)创建

     ①方式一 先初始化再赋值

s = set()
s = {11,22,33,44}  #注意在创建空集合的时候只能使用s=set(),因为s={}创建的是空字典

     ②方式二 直接创建

a=set('boy')
d={'k1','k2','k2'}

     ③方式三 利用list创建

b=set(['y', 'b', 'o','o'])

     ④方式四 利用dict创建,使用dict中的key值作为set的值

Input:

c=set({"k1":'v1','k2':'v2'})
c

Output:

{'k1', 'k2'}

     ⑤方式五 使用tuple创建

e={('k1', 'k2','k2')}

  (2)更新(增加)

   update

Input:

se = {11, 22, 33}
be = {22,44,55}

se.update(be)  # 把se和be合并,得出的值覆盖se
print(se)
se.update([66, 77])  # 可增加迭代项
print(se)

Output:

{33, 22, 55, 11, 44}
{33, 66, 22, 55, 11, 44, 77}

(3)删除

discard()remove()pop()

Input:

se = {11, 22, 33}
se.discard(11)
se.discard(44)  # 移除不存的元素不会报错
print(se)

Output:

{33, 22}

Input:

se = {11, 22, 33}
se.remove(11)
se.remove(44)  # 移除不存的元素会报错
print(se)

Output:

    ---------------------------------------------------------------------------

    KeyError                                  Traceback (most recent call last)

    <ipython-input-15-7256c38824cb> in <module>()
          1 se = {11, 22, 33}
          2 se.remove(11)
    ----> 3 se.remove(44)  # 移除不存的元素会报错
          4 print(se)


    KeyError: 44

(4)常用操作  

len(s) set 的长度

x in s 测试 x 是否是 s 的成员

x not in s 测试 x 是否不是 s 的成员

s.issubset(t)  s <= t  测试是否 s 中的每一个元素都在 t 中
           s.issuperset(t) s >= t  测试是否 t 中的每一个元素都在 s 中

s.union(t) s | t  返回一个新的 set 包含 s 和 t 中的每一个元素

s.intersection(t)  s & t  返回一个新的 set 包含 s 和 t 中的公共元素

s.difference(t)  s - t  返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.symmetric_difference(t)  s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素

s.copy()  返回 set “s”的一个浅复制

(5)集合操作

     ①交集

   intersection, intersection_update,也可以使用a&b

Input:

temp1 = se.intersection(be)             #取交集,赋给新值
print(temp1)  # 22
print(se)  # {11, 22, 33}

temp2 = se.intersection_update(be)      #取交集并更新自己
print(temp2)  # None
print(se)  # 22
print(se&be)

Output:

{22}
{22}
None
{22}
{22}

   ②并集

  union,也可以使用a|b

Input:

se = {11, 22, 33}
be = {22,44,55}

temp=se.union(be)   #取并集,并赋新值
print(se)       #{33, 11, 22}
print(temp)     #{33, 22, 55, 11, 44}
print(se|be)

Output:

{33, 11, 22}
{33, 22, 55, 11, 44}
{33, 22, 55, 11, 44}

    ③差集

   difference, difference_update,也可以使用a-b

Input:

se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在,be中不存在的集合,返回新值
print(temp1)        #{33, 11}
print(se-be)
print(se)        #{33, 11, 22}

Output:

{33, 11}
{33, 11}
{33, 11, 22}

Input:

temp2 = se.difference_update(be) #找到se中存在,be中不存在的集合,覆盖掉se
print(temp2)        #None
print(se)           #{33, 11}

Output:

None
{33, 11}

Input:

se = {11, 22, 33}  # 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp)  # 33
print(se) # {11, 22}

Output:

33
{11, 22}

(6)包含关系

两个集合之间一般有三种关系,相交、包含、不相交。在Python中分别用下面的方法判断:

  • set.isdisjoint(s):判断两个集合是不是不相交
  • set.issuperset(s):判断集合是不是包含其他集合,等同于a>=b
  • set.issubset(s):判断集合是不是被其他集合包含,等同于a<=b

如果要真包含关系,就用符号操作><

Input:

se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False,判断是否不存在交集(有交集False,无交集True)
print(se.issubset(be))          #False,判断se是否是be的子集合
print(se <= be)
print(se.issuperset(be))        #True,判断se是否是be的父集合
print(se >= be)

Output:

False
False
False
True
True

 (7)合并

  symmetric_difference, symmetric_difference_update

Input:

se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项,并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项,并更新自己
print(temp2)    #None
print(se)             #{33, 11}

Output:

{33, 11}
{33, 11, 22}
None
{33, 11}

 (8)集合的转换

   ①集合可以转换为list,tuple以及str

Input:

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))

Output:

[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>
{0, 1, 2, 3} <class 'str'>

   ②不变集合

Python提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset,使用方法如下

Input:

a = frozenset("hello")
a

Output:

frozenset({'e', 'h', 'l', 'o'})

需要注意的是frozenset仍然可以进行集合操作,只是不能用带有update的方法。如果要一个有frozenset中的所有元素的普通集合,只需把它当作参数传入集合的构造函数中即可:

Input:

a = frozenset("hello")
a = set(a)
a.add(12)
a

Output:

{12, 'e', 'h', 'l', 'o'}

Output:

frozenset({'e', 'h', 'l', 'o'})
se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项,并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项,并更新自己
print(temp2)    #None
print(se)             #{33, 11}

Output:

{33, 11}
{33, 11, 22}
None
{33, 11}

 

2、深拷贝和浅拷贝

浅拷贝(copy)是在复制的时候只增加了一个指针,没有给其分配了内存空间,拷贝前后两个值指向同一内存空间,都可改变指向的内存空间中的值。

深拷贝(copy.deepcopy)是在复制的时候不但增加了一个指针,而且还给其分配了内存空间,因为两者指向不同的空间,因此两指针操作互不影响。对拷贝之后的值修改不会影响原值。

因为for.. in..是按照下标索引,因此尤其对列表值删除时要注意应采用深拷贝。


输出结果:[0, 4, 8, 12, 16, 20, 24, 28]



参考:https://www.jianshu.com/p/f60fabfefc09

           https://blog.youkuaiyun.com/guan666/article/details/71511948 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值