Python必备技巧之集合Set的使用

目录
  • 定义一个集合
  • 集合的大小和成员资格
  • 集合的9种操作
    • 计算集合并集
    • 计算集合交集
    • 计算集合之间差异
    • 计算集合间对称差
    • 计算后集合中是否有包含前集合的元素
    • 计算一个集合是否是另一个集合的子集
    • 计算一个集合是否是另一个集合的真子集
    • 计算一个集合是否是另一个集合的超集
    • 计算一个集合是否是另一个集合的正确超集
  • 集合的9种修改
    • update计算并集
    • intersection_update 计算交集
    • difference_update 按差异修改被处理集合
    • symmetric_difference_update 按对称差修改被处理集合
    • add 元素添加到集合中
    • remove 集合中移除一个元素
    • discard 集合中移除一个元素
    • pop 集合中移除一个随机元素
    • clear 清空集合
  • 被冻结集合

在数学中,对集合的严格定义可能是抽象的且难以掌握。但实际上可以将集合简单地认为是定义明确的不同对象的集合,通常称为元素或成员。

Python 提供了一个内置的集合类型来将对象分组到一个集合中。集合与其他对象类型的区别在于可以对执行的独特操作。

定义一个集合

集合是无序的,并且元素是唯一的,集合本身可以修改,但集合中包含的元素必须是不可变类型。

构建集合的方式

# 构建的set数据会自动进行去重
x = set(<iter>)
# list方式
>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}
# tuple方式
>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}
# 字符串方式
>>> s = 'quux'
>>> list(s)
['q', 'u', 'u', 'x']
>>> set(s)
{'x', 'u', 'q'}

集合元素set后自动排序并且元素必须是不可变的。

>>> x = {42, 'foo', (1, 2, 3), 3.14159}
>>> x
{42, 'foo', 3.14159, (1, 2, 3)}
# list和dict不能被set
>>> a = [1, 2, 3]
>>> {a}
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    {a}
TypeError: unhashable type: 'list'

>>> d = {'a': 1, 'b': 2}
>>> {d}
Traceback (most recent call last):
  File "<pyshell#72>", line 1, in <module>
    {d}
TypeError: unhashable type: 'dict'

集合的大小和成员资格

方法 len() 、in 、 not in 的应用。

>>> x = {'foo', 'bar', 'baz'}
>>> len(x)
3
>>> 'bar' in x
True
>>> 'qux' in x
False

集合的9种操作

计算集合并集

# x1.union(x2[, x3 ...])
# x1 | x2 [| x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 | x2
{'baz', 'quux', 'qux', 'bar', 'foo'}
>>> x1.union(x2)
{'baz', 'quux', 'qux', 'bar', 'foo'}

# 更多的集合并集操作
>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}
>>> a.union(b, c, d)
{1, 2, 3, 4, 5, 6, 7}
>>> a | b | c | d
{1, 2, 3, 4, 5, 6, 7}

计算集合交集

# x1.intersection(x2[, x3 ...])
# x1 & x2 [& x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1.intersection(x2)
{'baz'}
>>> x1 & x2
{'baz'}

# 更多的集合交集操作
>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}
>>> a.intersection(b, c, d)
{4}
>>> a & b & c & d
{4}

计算集合之间差异

# x1.difference(x2[, x3 ...])
# x1 - x2 [- x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1.difference(x2)
{'foo', 'bar'}
>>> x1 - x2
{'foo', 'bar'}

# 更多的集合差异操作
>>> a = {1, 2, 3, 30, 300}
>>> b = {10, 20, 30, 40}
>>> c = {100, 200, 300, 400}
>>> a.difference(b, c)
{1, 2, 3}
>>> a - b - c
{1, 2, 3}

计算集合间对称差

# x1.symmetric_difference(x2)
# x1 ^ x2 [^ x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1.symmetric_difference(x2)
{'foo', 'qux', 'quux', 'bar'}
>>> x1 ^ x2
{'foo', 'qux', 'quux', 'bar'}

# 更多的集合对称差操作
>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}
>>> a ^ b ^ c
{100, 5, 10}

计算后集合中是否有包含前集合的元素

# x1.isdisjoint(x2)
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1.isdisjoint(x2)
False
>>> x2 - {'baz'}
{'quux', 'qux'}
>>> x1.isdisjoint(x2 - {'baz'})
True

# x1.isdisjoint(x2)是True,那么x1 & x2是空集
>>> x1 = {1, 3, 5}
>>> x2 = {2, 4, 6}
>>> x1.isdisjoint(x2)
True
>>> x1 & x2
set()

计算一个集合是否是另一个集合的子集

# x1.issubset(x2)
# x1 <= x2
>>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issubset({'foo', 'bar', 'baz', 'qux', 'quux'})
True
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 <= x2
False
# 一个集合被认为是它自身的一个子集
>>> x = {1, 2, 3, 4, 5}
>>> x.issubset(x)
True
>>> x <= x
True

计算一个集合是否是另一个集合的真子集

# x1 < x2
>>> x1 = {'foo', 'bar'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2
True
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2
False
# 子集与真子集的判断
>>> x = {1, 2, 3, 4, 5}
>>> x <= x
True
>>> x < x
False

计算一个集合是否是另一个集合的超集

# x1.issuperset(x2)
# x1 >= x2
>>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issuperset({'foo', 'bar'})
True
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 >= x2
False

# 集合被认为是本身的一个子集,默认为自身超集
>>> x = {1, 2, 3, 4, 5}
>>> x.issuperset(x)
True
>>> x >= x
True

计算一个集合是否是另一个集合的正确超集

# x1 > x2
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar'}
>>> x1 > x2
True
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 > x2
False
# 集合不是其自身的正确超集
>>> x = {1, 2, 3, 4, 5}
>>> x > x
False

集合的9种修改

尽管集合中包含的元素必须是不可变类型,但集合本身可以修改。

update计算并集

# x1.update(x2[, x3 ...])
# x1 |= x2 [| x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>> x1 |= x2
>>> x1
{'qux', 'foo', 'bar', 'baz'}
>>> x1.update(['corge', 'garply'])
>>> x1
{'qux', 'corge', 'garply', 'foo', 'bar', 'baz'}

intersection_update 计算交集

# x1.intersection_update(x2[, x3 ...])
# x1 &= x2 [& x3 ...]
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>> x1 &= x2
>>> x1
{'foo', 'baz'}
>>> x1.intersection_update(['baz', 'qux'])
>>> x1
{'baz'}

difference_update 按差异修改被处理集合

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>> x1 -= x2
>>> x1
{'bar'}
>>> x1.difference_update(['foo', 'bar', 'qux'])
>>> x1
set()

symmetric_difference_update 按对称差修改被处理集合

# x1.symmetric_difference_update(x2)
# x1 ^= x2
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>> x1 ^= x2
>>> x1
{'bar', 'qux'}
>>>
>>> x1.symmetric_difference_update(['qux', 'corge'])
>>> x1
{'bar', 'corge'}

add 元素添加到集合中

>>> x = {'foo', 'bar', 'baz'}
>>> x.add('qux')
>>> x
{'bar', 'baz', 'foo', 'qux'}

remove 集合中移除一个元素

>>> x = {'foo', 'bar', 'baz'}
>>> x.remove('baz')
>>> x
{'bar', 'foo'}
# 如果元素步存在则引发异常
>>> x.remove('qux')
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    x.remove('qux')
KeyError: 'qux'

discard 集合中移除一个元素

>>> x = {'foo', 'bar', 'baz'}
>>> x.discard('baz')
>>> x
{'bar', 'foo'}
>>> x.discard('qux')
>>> x
{'bar', 'foo'}

pop 集合中移除一个随机元素

>>> x = {'foo', 'bar', 'baz'}
>>> x.pop()
'bar'
>>> x
{'baz', 'foo'}
>>> x.pop()
'baz'
>>> x
{'foo'}
>>> x.pop()
'foo'
>>> x
set()
>>> x.pop()
Traceback (most recent call last):
  File "<pyshell#82>", line 1, in <module>
    x.pop()
KeyError: 'pop from an empty set'

clear 清空集合

>>> x = {'foo', 'bar', 'baz'}
>>> x
{'foo', 'bar', 'baz'}
>>>
>>> x.clear()
>>> x
set()

被冻结集合

freezeset 为 Python的内置类型,不可变、不可操作。

>>> x = frozenset(['foo', 'bar', 'baz'])
>>> x
frozenset({'foo', 'baz', 'bar'})
>>> len(x)
3
>>> x & {'baz', 'qux', 'quux'}
frozenset({'baz'})

尝试修改 freezeset 的方法会失败

>>> x = frozenset(['foo', 'bar', 'baz'])
>>> x.add('qux')
Traceback (most recent call last):
  File "<pyshell#127>", line 1, in <module>
    x.add('qux')
AttributeError: 'frozenset' object has no attribute 'add'
>>> x.pop()
Traceback (most recent call last):
  File "<pyshell#129>", line 1, in <module>
    x.pop()
AttributeError: 'frozenset' object has no attribute 'pop'
>>> x.clear()
Traceback (most recent call last):
  File "<pyshell#131>", line 1, in <module>
    x.clear()
AttributeError: 'frozenset' object has no attribute 'clear'
>>> x
frozenset({'foo', 'bar', 'baz'})

以上就是Python必备技巧之集合Set的使用的详细内容,更多关于Python集合Set的资料请关注我们其它相关文章!

(0)

相关推荐

  • 详解python的集合set的函数

    目录 常用 查询 增加 删除 交.并.补.对称差 交集 并集 补集 对称差 其他 总结 s={ x1,x2,x3.....}: 集合有自动去重的功能,而且可以进行交并补运算,而且集合是无序的,每次打印的结果不一样,故不可以用元素下标进行取值.因无法取值,故无法对特定的值进行修改.但是可以进行删除操作. s=set():表示创建一个空的集合.注意:s={}表示创建一个空的字典. 常用 查询 x in s,s为一个集合,返回bool类型,判断x是否在集合s中. 增加 s.add(“x”):将“x”添

  • python set集合使用方法解析

    这篇文章主要介绍了python set集合使用方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 定义 定义:在{}中用逗号隔开,集合具备以下3个特点: 1.每个元素必须是不可变类型 2.集合内没有重复元素 3.集合内元素无序 my_set = {1, 2, 3, 4} # 本质上 my_set = set({1, 2, 3, 4}) # 注意1:列表是索引对应值,字典是key对应值,均可以取得单个值. # 而集合类型既没有索引也没有key

  • Python 集合之set详解

    目录 引言 集合的定义 集合常用操作 集合添加元素 集合移除元素 集合统计.清空元素 集合元素获取(遍历) 集合之间的运算 集合差运算 - 集合并运算 | 集合交运算 & 集合异或运算 ^ 应用场景 普通for循环去重 利用集合简单去重 去重保持原来的顺序 总结 引言 set(集合)虽然用的很少,但它是一个无序的不重复元素序列,用来简单的去重挺快的. 集合的定义 set(集合) 与列表类似,不同之处在于集合的 元素不重复 集合和字典一样也是用 {} 定义,但元素之间使用 , 分隔,或者使用 se

  • python基础之set集合详解

    一.set 集合 集合(set)是一个无序的不重复元素序列. 可以使用大括号 {} 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典. 二.创建集合 print({"1", "2", "3"})  # {'2', '3', '1'} print(set("123"))  # {'2', '3', '1'} print(set((1, 2, 3)))  #

  • Python学习之集合set

    目录 集合 (set) 一 .合集的一些常用命令 1.set 定义合集 2.add 添加元素 3.clear 清空 4.pop 随机删除一个元素 5.remove 指定删除 6.discard 指定删除 二.关系运算 1.交集 找到两个集合相同的元素 2.并集 合并两个集合 3.差集 保留前者与后者不同的元素 去除相同的元素 4.交叉补集 只保留两者不同的部分 5.isdisjoint 判断是否有交集返回布尔值 6.issubset判断后者是否包含前者 返回布尔值 7.issuperset判断前

  • Python 数据类型--集合set

    目录 一.定义 二.操作 三.运算 一.定义 集合中的元素是无序的.唯一的.不可变的类型.集合是一个特殊的列表,可以对数据去重. lists = [1,3,5,7,3,4,6,2,7,9] print(set(lists)) 使用大括号{}或set()函数吧数据集合在一起. set()中的参数可以是元组.字符串.列表,还可以是一个集合.这个参数只要是一个序列即可. 创建一个空集合必须用set(),不能使用大括号.{}是用来定义空字典的. 二.操作 add(),把要传入的元素作为一个整体添加到集合

  • Python必备技巧之集合Set的使用

    目录 定义一个集合 集合的大小和成员资格 集合的9种操作 计算集合并集 计算集合交集 计算集合之间差异 计算集合间对称差 计算后集合中是否有包含前集合的元素 计算一个集合是否是另一个集合的子集 计算一个集合是否是另一个集合的真子集 计算一个集合是否是另一个集合的超集 计算一个集合是否是另一个集合的正确超集 集合的9种修改 update计算并集 intersection_update 计算交集 difference_update 按差异修改被处理集合 symmetric_difference_up

  • Python必备技巧之字符数据操作详解

    目录 字符串操作 字符串 + 运算符 字符串 * 运算符 字符串 in 运算符 内置字符串函数 字符串索引 字符串切片 字符串切片中的步幅 将变量插入字符串 修改字符串 内置字符串方法 bytes对象 定义文字bytes对象 bytes使用内置bytes()函数定义对象 bytes对象操作,操作参考字符串. bytearray对象,Python 支持的另一种二进制序列类型 字符串操作 字符串 + 运算符 +运算符用于连接字符串,返回一个由连接在一起的操作数组成的字符串. >>> s =

  • Python必备技巧之字典(Dictionary)详解

    目录 定义字典 字典的访问 字典键与列表索引 增量构建字典 字典键的限制 字典值的限制 运算符和内置函数 内置字典方法 Python中的字典由于是对象的集合属于复合数据类型,类似于列表. 定义字典 字典是 Python 对数据结构的实现,通常称为关联数组.字典由键值对的集合组成.每个键值对将键映射到其关联的值. 可以通过将逗号分隔的键值对列表括在花括号 ( {} ) 中来定义字典.冒号 ( : ) 将每个键与其关联的值分开. d = { <key>: <value>, <ke

  • Python必备技巧之Pandas数据合并函数

    目录 1. concat 2. append 3. merge 4. join 5. combine 总结 1. concat concat是pandas中专门用于数据连接合并的函数,功能非常强大,支持纵向合并和横向合并,默认情况下是纵向合并,具体可以通过参数进行设置. pd.concat( objs: 'Iterable[NDFrame] | Mapping[Hashable, NDFrame]', axis=0, join='outer', ignore_index: 'bool' = Fa

  • Python必备技巧之函数的使用详解

    目录 1.如何用函数 2.默认参数陷阱 2.1针对可变数据类型,不可变不受影响 3.名称空间和作用域 4.闭包函数 5.函数的参数 5.1定义阶段 5.2调用阶段 6.装饰器:闭包函数的应用 6.1装饰器的实现必须遵循两大原则 6.2装饰器语法糖 6.3无参装饰器 6.4有参装饰器 7.题目 1.如何用函数 先定义后调用,定义阶段只检测语法,不执行代码 调用阶段,开始执行代码 函数都有返回值 定义时无参,调用时也是无参 定义时有参,调用时也必须有参 2.默认参数陷阱 2.1针对可变数据类型,不可

  • 新手必备的Python实用技巧和工具

    一.交换变量 x = 6 y = 5 x, y = y, x print x >>> 5 print y >>> 6 二.if 语句在行内 print "Hello" if True else "World" >>> Hello 三.连接 下面的最后一种方式在绑定两个不同类型的对象时显得很cool. nfc = ["Packers", "49ers"] afc = [&qu

  • Python爬虫必备技巧详细总结

    自定义函数 import requests from bs4 import BeautifulSoup headers={'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:93.0) Gecko/20100101 Firefox/93.0'} def baidu(company): url = 'https://www.baidu.com/s?rtt=4&tn=news&word=' + company print(url

  • Python数据类型之Set集合实例详解

    本文实例讲述了Python数据类型之Set集合.分享给大家供大家参考,具体如下: set集合 1.概述 set与dict类似,但set是一组key的集合,与dict的区别在于set不存储value. 本质:无序且无重复元素的集合(具有自动去重的功能). 2.set的创建 语法: set1 = set([1, 2, 3, 4, 5]) 注意:创建set需要一个list或者tuple或者dist作为输入集合,重复的元素在set中会被自动的过滤 s1 = set([1, 2, 3, 4, 5]) pr

  • Python学习笔记之集合的概念和简单使用示例

    本文实例讲述了Python学习笔记之集合的概念和简单使用.分享给大家供大家参考,具体如下: 集合 概念解释:一个包含唯一元素的可变和无序的集合数据类型.集合的一个用途是快速删除列表中的重复项. numbers = [1, 2, 6, 3, 1, 1, 6] unique_nums = set(numbers) print(unique_nums) # {1, 2, 3, 6} 支持 in 运算符, 使用 add 方法将元素添加到集合中,并使用 pop 方法删除元素(会随机删除一个元素) frui

  • Python字典生成式、集合生成式、生成器用法实例分析

    本文实例讲述了Python字典生成式.集合生成式.生成器用法.分享给大家供大家参考,具体如下: 字典生成式: 跟列表生成式一样,字典生成式用来快速生成字典,不同的是,字典需要两个值 #d = {key: value for (key, value) in iterable} d1 = {'x': 1, 'y': 2, 'z': 3} d2 = {k: v for (k, v) in d1.items()} print(d2) 集合生成式: 集合生成式格式和列表生成式类似,不过用的是大括号: s1

随机推荐