Python --集合

已于 2023-09-11 13:14:40 修改
阅读量99 收藏
点赞数
分类专栏： python 文章标签： python
于 2023-07-10 11:58:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25500415/article/details/131631880
版权

目录

1， 什么是集合

2， 集合操作

2-1， 创建

2-1-1， 创建可变集合(set)

2-1-2， 创建不可变集合(frozenset)

2-2， 查询集合元素

2-3， 成员判断

2-4， 修改集合(可变集合)

2-4-1， 成员作为整体添加(add)

2-4-2， 成员作为序列添加(update)

2-5， 删除集合元素(可变集合)

2-5-1， 随机删除(pop)

2-5-2， 指定元素删除(remove)

2-5-2， 指定元素删除(discard)

3， 集合比较

3-1， 相等

3-2， 子集

3-3， 超集

4， 集合运算

4-1， 并集

4-2， 交集

4-3， 差补

4-4， 对称分差

5， 集合符合运算

6， 集合内建函数

1， 什么是集合

集合是一组无序排列的可hash的值(不可变集合)， 集合中的元素不能重复

集合分为可变集合、不可变集合，可变集合不可hash，不能用着集合中的元素

2， 集合操作

2-1， 创建

集合分为可变集合和不可变集合

2-1-1， 创建可变集合(set)

可变集合的元素可添加， 删除， 通过其工厂方法set(iter)， 创建可变集合

# 入参为字符串， 通过set()创建可变集合
In [7]: s = set('cheeseshop')
In [8]: s
Out[8]: {'c', 'e', 'h', 'o', 'p', 's'}

# 入参为列表， 通过set()创建可变集合
In [11]: s = set(list('cheeseshop'))
In [12]: s
Out[12]: {'c', 'e', 'h', 'o', 'p', 's'}

# 入参为元组， 通过set()创建可变集合
In [13]: s = set(tuple('cheeseshop'))
In [14]: s
Out[14]: {'c', 'e', 'h', 'o', 'p', 's'}

2-1-2， 创建不可变集合(frozenset)

不可变集合元素不能添加，删除， 通过其工厂方法frozenset(iter)， 创建不可变集合

# 入参为字符串， 通过frozenset()创建不可变集合
In [9]: t = frozenset('bookshop')
In [10]: t
Out[10]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 入参为列表， 通过frozenset()创建不可变集合
In [15]: t = frozenset(list('bookshop'))
In [16]: t
Out[16]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 入参为元组， 通过frozenset()创建不可变集合
In [17]: t = frozenset(tuple('bookshop'))
In [18]: t
Out[18]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

2-2， 查询集合元素

因为集合是无序的，只能通过for循环迭代访问集合的元素，不能通过切片或索引方式进行访问

In [20]: for i in s:
    ...:     print(i)
    ...:
o
e
s
c
h
p

2-3， 成员判断

通过in, not in，判读是否是集合的元素， 返回bool值

In [25]: 'c' in s
Out[25]: True

In [26]: 'c' not in s
Out[26]: False

2-4， 修改集合(可变集合)

2-4-1， 成员作为整体添加(add)

通过集合A.add('xxx')， 可添加单个元素'xxx'到集合A中

# 将元素'aaaa'添加到可变集合s中
In [28]: s.add('aaaa')

In [29]: s
Out[29]: {'aaaa', 'c', 'e', 'h', 'o', 'p', 's'}

2-4-2， 成员作为序列添加(update)

通过集合A.update('xyz')， 可添加'x'、'y'、'z'三个元素到集合A中

# 将'123'做为一个序列添加，集合元素中多处1,2,3三个元素
In [30]: s.update('123')

In [31]: s
Out[31]: {'1', '2', '3', 'aaaa', 'c', 'e', 'h', 'o', 'p', 's'}

# 不可变集合修改会报错
In [34]: t
Out[34]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

In [35]: t.add('1')
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-35-05b9ad947067> in <module>
----> 1 t.add('1')

AttributeError: 'frozenset' object has no attribute 'add'

说明：集合的修改针对可变集合而言，对不可变集合进行修改会报错

2-5， 删除集合元素(可变集合)

2-5-1， 随机删除(pop)

通过s.pop()，随机删除可变集合的某个元素， 返回删除的元素

# 随机删除可变集合中的一个元素， 返回删除的元素
In [39]: s.pop()
Out[39]: 'o'

2-5-2， 指定元素删除(remove)

通过s.remove('xxx')，指定元素删除， 无返回值，指定元素不存在，会报错

# 删除可变集合中的元素'aaaa'， 无返回值
In [42]: s.remove('aaaa')

# 指定的元素不存在，会报错
In [325]: s.remove(1)
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-325-1283ae146fa1> in <module>
----> 1 s.remove(1)

KeyError: 1

2-5-2， 指定元素删除(discard)

通过s.discard('xxx')，指定元素删除， 无返回值，指定元素不存在，不会报错

# 删除可变集合中元素'b'
In [327]: s.discard('b')

# 若指定元素不存在，不报错
In [329]: s.discard(1)

# 清空可变集合s的元素
In [45]: s.clear()

说明：集合元素的删除针对可变集合而言，对不可变集合进行修改会报错

3， 集合比较

集合之间比较， 与集合类型没有关系， 仅与集合元素相关， 若两个集合含有相同的元素，则两个集合相等；

3-1， 相等

In [58]: t
Out[58]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

In [60]: u
Out[60]: {'b', 'h', 'k', 'o', 'p', 's'}

# u是可变集合，t是不可变集合；但是他们的元素都相同，所以两个集合相等
In [63]: u == t
Out[63]: True

3-2， 子集

通过s1 < s2(非严格子集)、s1 <= s2(严格子集)方法，判断是否是子集， 返回bool值

In [75]: s1
Out[75]: {'h', 'o', 'p', 's'}

In [76]: s2
Out[76]: {'c', 'e', 'h', 'o', 'p', 's'}

In [77]: t1
Out[77]: frozenset({'c', 'e', 'h', 'o', 'p', 's'})

# 可变集合进行比较
In [78]: s1 < s2
Out[78]: True

In [79]: s1 <= s2
Out[79]: True

# 可变集合与不可变集合也可比较
In [80]: s1 < t1
Out[80]: True

In [82]: s1 <= t1
Out[82]: True

3-3， 超集

通过s1 > s2(非严格超集)、s1 >= s2(严格超集)，判断是否是超集， 返回bool值

In [87]: s1
Out[87]: {'c', 'e', 'h', 'o', 'p', 's'}

In [88]: s2
Out[88]: {'h', 'o', 'p', 's'}

In [89]: t1
Out[89]: {'c', 'e', 'h', 'o', 'p', 's'}

# 可变集合进行比较
In [90]: s1 > s2
Out[90]: True

In [91]: s2 >= s2
Out[91]: True

# 可变集合与不可变集合进行比较
In [92]: t1 > s2
Out[92]: True

In [93]: t1 >= s2
Out[93]: True

4， 集合运算

集合之间运算， 与集合类型没有关系， 运算的结果类型与左值一值

4-1， 并集

通过s | t ，计算两个集合并集， 返回新的集合

In [98]: s1
Out[98]: {'c', 'e', 'h', 'o', 'p', 's'}

In [99]: s2
Out[99]: {'b', 'h', 'k', 'o', 'p', 's'}

In [100]: t1
Out[100]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 计算集合s1与s2的并集
In [101]: s1 | s2
Out[101]: {'b', 'c', 'e', 'h', 'k', 'o', 'p', 's'}

# 不同类型集合并集， 结果类型与左值一值
In [103]: t1 | s1
Out[103]: frozenset({'b', 'c', 'e', 'h', 'k', 'o', 'p', 's'})

4-2， 交集

通过s & t ，计算两个集合交集， 返回新的集合

In [104]: s1
Out[104]: {'c', 'e', 'h', 'o', 'p', 's'}

In [105]: s2
Out[105]: {'b', 'h', 'k', 'o', 'p', 's'}

In [106]: t1
Out[106]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 计算集合s1与s2的交集
In [107]: s1 & s2
Out[107]: {'h', 'o', 'p', 's'}

# 不同类型集合取交集， 结果类型与左值一值
In [108]: t1 & s1
Out[108]: frozenset({'h', 'o', 'p', 's'})

4-3， 差补

通过s - t ，计算两个集合差补， 返回新的集合

​In [109]: s1
Out[109]: {'c', 'e', 'h', 'o', 'p', 's'}

In [110]: s2
Out[110]: {'b', 'h', 'k', 'o', 'p', 's'}

In [111]: t1
Out[111]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 集合集合s1和s2的差补
In [112]: s1 - s2
Out[112]: {'c', 'e'}

# 不同类型集合取差补， 结果与左值一值
In [113]: t1 - s1
Out[113]: frozenset({'b', 'k'})

4-4， 对称分差

通过s ^ t ，计算两个集合对称分差， 返回新的集合

In [114]: s1
Out[114]: {'c', 'e', 'h', 'o', 'p', 's'}

In [115]: s2
Out[115]: {'b', 'h', 'k', 'o', 'p', 's'}

In [116]: t1
Out[116]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 获取集合s1和s2的对称分差
In [117]: s1 ^ s2
Out[117]: {'b', 'c', 'e', 'k'}

# 不同类型之间的集合运算， 结果与左值一致
In [118]: t1 ^ s1
Out[118]: frozenset({'b', 'c', 'e', 'k'})

5， 集合符合运算

复合运算运算与集合的类型没有关系， 复合运算的结果直接映射到左值

# 复合运算并集
In [212]: s = set('cheeseshop')
In [213]: t = frozenset('bookshop')

In [214]: s |= t
In [215]: s
Out[215]: {'b', 'c', 'e', 'h', 'k', 'o', 'p', 's'}

In [216]: s = set('cheeseshop')
In [217]: t = frozenset('bookshop')
In [218]: t |= s

In [219]: t
Out[219]: frozenset({'b', 'c', 'e', 'h', 'k', 'o', 'p', 's'})

# 复合运算交集
In [220]: s = set('cheeseshop')
In [221]: t = frozenset('bookshop')
In [222]: s &= t
In [223]: s
Out[223]: {'h', 'o', 'p', 's'}

In [224]: s = set('cheeseshop')
In [225]: t = frozenset('bookshop')
In [226]: t &= s
In [227]: t
Out[227]: frozenset({'h', 'o', 'p', 's'})

# 复合运算差集
In [228]: s = set('cheeseshop')
In [229]: t = frozenset('bookshop')
In [230]: s -= t
In [231]: s
Out[231]: {'c', 'e'}

In [232]: s = set('cheeseshop')
In [233]: t = frozenset('bookshop')
In [234]: t -= s
In [235]: t
Out[235]: frozenset({'b', 'k'})

# 复合运算对称分差
In [236]: s = set('cheeseshop')
In [237]: t = frozenset('bookshop')
In [238]: s ^= t
In [239]: s
Out[239]: {'b', 'c', 'e', 'k'}

In [240]: s = set('cheeseshop')
In [241]: t = frozenset('bookshop')
In [242]: t ^= s
In [243]: t
Out[243]: frozenset({'b', 'c', 'e', 'k'})

6， 集合内建函数

通过内建函数进行集合间运算，与集合的类型无关

通过len(s)， 返回集合的长度

# 集合s长度为6
In [261]: len(s)
Out[261]: 6

通过s.copy()， 浅拷贝一个集合，比工厂方法块

In [266]: s
Out[266]: {'c', 'e', 'h', 'o', 'p', 's'}

# 拷贝集合s
In [267]: s1 = s.copy()

In [269]: s1
Out[269]: {'c', 'e', 'h', 'o', 'p', 's'}

通过s.issubset(t)， 判断s是否是t的子集，返回bool值

In [273]: t = frozenset(s)

In [274]: s.issubset(t)
Out[274]: True

通过s.issuperset(s)， 判断s是否是t的超集，返回bool值

In [275]: s.issuperset(t)
Out[275]: True

通过s.union(t)， 返回新集合，为s和t并集， 原集合不变

In [283]: s
Out[283]: {'c', 'e', 'h', 'o', 'p', 's'}

In [284]: t
Out[284]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回新集合
In [285]: s.union(t)
Out[285]: {'b', 'c', 'e', 'h', 'k', 'o', 'p', 's'}

# 原集合不变
In [286]: s
Out[286]: {'c', 'e', 'h', 'o', 'p', 's'}

In [287]: t
Out[287]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

通过s.intersection(t)， 返回新集合，为s和t的交集， 原集合不变

In [286]: s
Out[286]: {'c', 'e', 'h', 'o', 'p', 's'}

In [287]: t
Out[287]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的交集
In [288]: s.intersection()
Out[288]: {'c', 'e', 'h', 'o', 'p', 's'}

# 原集合不变
In [289]: s
Out[289]: {'c', 'e', 'h', 'o', 'p', 's'}

In [290]: t
Out[290]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

通过s.difference(t)， 返回新集合，为s和t的差集， 原集合不变

In [291]: s
Out[291]: {'c', 'e', 'h', 'o', 'p', 's'}

In [292]: t
Out[292]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的差集
In [293]: s.difference(t)
Out[293]: {'c', 'e'}

# 原集合不变
In [294]: s
Out[294]: {'c', 'e', 'h', 'o', 'p', 's'}

In [295]: t
Out[295]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

通过s.symmetric_difference(t)，  返回新集合，为s和t的对称分差， 原集合不变

In [296]: s
Out[296]: {'c', 'e', 'h', 'o', 'p', 's'}

In [297]: t
Out[297]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的对称分差
In [298]: s.symmetric_difference(t)
Out[298]: {'b', 'c', 'e', 'k'}

# 原集合不变
In [299]: s
Out[299]: {'c', 'e', 'h', 'o', 'p', 's'}

In [300]: t
Out[300]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

通过s.intersection_update(t)， 返回s和t的交集，结果映射到s上

In [303]: s
Out[303]: {'c', 'e', 'h', 'o', 'p', 's'}

In [304]: t
Out[304]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的交集
In [305]: s.intersection_update(t)

# 结果映射到s上
In [306]: s
Out[306]: {'h', 'o', 'p', 's'}

通过s.difference_update(t)， 返回s和t的差集，结果映射到s上

In [310]: s
Out[310]: {'c', 'e', 'h', 'o', 'p', 's'}

In [311]: t
Out[311]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的差集
In [312]: s.difference_update(t)

结果映射到s上
In [313]: s
Out[313]: {'c', 'e'}

通过s.symmetric_difference_update(t)， 返回s和t的对称分差，结果映射到s上

In [317]: s
Out[317]: {'c', 'e', 'h', 'o', 'p', 's'}

In [318]: t
Out[318]: frozenset({'b', 'h', 'k', 'o', 'p', 's'})

# 返回s和t的对称分差
In [319]: s.symmetric_difference_update(t)

# 结果映射到s上
In [320]: s
Out[320]: {'b', 'c', 'e', 'k'}
qq_25500415
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 集合长度_python---集合
weixin_39589511的博客
12-23 1486
集合是一个无序的，不重复的数据组合，它的主要作用是：1.去重，把列表变为集合就去重了。2.关系测试，测试两组数据之前的差集，交集，并集等关系#创建两个集合list_1=set([1,3,4,5,6,6,5,7,9])list_2=set([2,4,5,6,8,10])print(list_1,list_2)#输出：{1,3,4,5,6,7,9}{2,4,5,6,8,...
python-snippets:适用于Visual Studio Code的Python代码段
05-08
Python代码片段集合。 最初是从PyCharm，TextMate，SublimeText和其他编辑器/ IDE移植的。 如果您想贡献，请随时 谢谢！ 特征 基本片段 缩写 描述 环保 ＃！/ usr / bin / env python env3 ＃！/ usr / bin / ...
Python--集合
墨上烟雨
06-22 1978
一、创建集合。
Python -- 集合
热门推荐
天行健 君子以自强不息，地势坤 君子以厚德载物。
03-24 3万+
集合 集合概述:Python中的集合(set)与数学中的集合概念类似 也是用于保存不重复的元素。它有可变集合(set)和不可变集合(frozenset)两种。 在形式上，集合的所有元素都放在一对大括号中，两个相邻元素间使用逗号“”分隔。 集合最好的应用就是去重，因为集合中的每个元素都是唯一的。 1.1 集合的创建 示例: 直接使用{}创建集合 collection = {1, 2, 3, 4, 5} print(collection) 运行结果: 示例: 使用set()函数创建集合 lists
python----集合
weixin_50627146的博客
03-31 2739
python集合包含，集合的关系运算，集合的方法、集合的去重
Python------集合详解
ChinaYouxin的博客
01-15 1804
Python中的集合，初学者也可轻松理解
python-set集合操作
2201_75373590的博客
11-22 1085
【代码】python-set集合操作。
python--集合（十六）
Bruce小鬼
05-17 1013
python--集合（十六） 更多原创性能测试文章关注 十年性能测试专家&7DGroup公众号 一、创建集合 # 集合 ''' 集合特性 1、无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。 集合上可以定义序关系，定义了序关系后，元素之间就可以按照序关系排序。但就集合本身的特性而言，元素之间没有必然的序。 2、互异性：一个集合中，任何两个元素都认为是不......
Python -- 字典
天行健 君子以自强不息，地势坤 君子以厚德载物。
03-24 2504
1. 字典 字典概述:在许多应用中需要利用关键词查找对应信息，例如，通过学号来检索某学生的信息。 其中，通过学号查找所对应学生的信息的方式称为“映射”。 Python语言的字典(dictionary)类型就是一种映射。其他编程语言中也提供类似的结构， 例如，哈希(Hash)、关联数组等。 1.1 字典的创建 1.1.1 Python zip函数及用法 zip() 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串 以及 range() 区间构成的列表）“压缩”成一个
python- 集合的运算符
weixin_37770279的博客
05-27 2656
# coding:utf-8 ''' 1、&、|、- 运算符 & 符，可以计算两个集合的交集，与集合的intersection()函数实现的功能一样 | 符，可以计算两个集合的并集，与集合的union()函数实现的功能是一样 - 符，运算符可以计算两个集合的差集，与集合的difference()函数实现的功能一样 ''' set_1 = {1,2,3,4,5,6} set_2 = {4,5,6,7,8,9} print('分别使用intersection()函数和.
python-dateutil包
hang916的博客
04-10 8731
我用dateutil包主要是用来解析时间 安装 用pip安装 pip install python-dateutil parse 字符串可以很随意，可以是任意字符串，汉字，英文，数字等等 >>> from dateutil.parser import parse >>> parse("Apr.10") # 默认年份是系统年份 d...
python-集合使用场景.docx
06-11
python 集合使用场景 Python集合使用场景 Python中的集合是一种无序、可变的数据类型，它可以存储不同类型的元素，但每个元素只能出现一次。集合是一种非常有用的数据结构，它可以在许多场景中使用。本文将介绍...
Python-Bits-and-Bytes
03-27
Python的位和字节 这是我为较大的项目测试代码块时创建的草图集合。 随便带您想要的东西，并从中学习！
flink-python-examples:使用flinks新的python API的示例集合
05-14
使用Apache Flink:trade_mark:的新python API的示例集合。 要使用最新的Flink构建来设置本地环境，请参见指南： 。 此处的示例使用v0.10.0 python API，旨在用作简单用例的演示。 当前，Python API支持DataSet ...
Python-推荐系统资源集合
08-11
A collection of resources for Recommender Systems (RecSys)
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1371
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 448
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Java——简单图书管理系统
m0_74100417的博客
06-09 1553
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
python迁移数据教程
2402_85292291的博客
06-13 637
if os.path.isfile(src_item_path): dest_item_path = os.path.join(dest_folder, item) shutil.copy2(src_item_path, dest_item_path) # 如果item是目录，递归调用migrate_data函数。2. 准备源文件夹和目标文件夹： 在您的计算机上创建两个文件夹，分别为源文件夹（source_folder）和目标文件夹（destination_folder）。将您希望迁移的数据放入源文件夹。
python-devel-2.7.5
11-24
在Python编程中，开发环境是指为开发者提供编写、编辑、调试和测试代码的一系列工具和库的集合。它包含了各种功能，以便开发者可以更轻松地进行Python程序的开发和调试。 python-devel-2.7.5是针对Python 2.7.5版本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值