Python——集合(set)

最新推荐文章于 2022-12-31 23:00:00 发布
最新推荐文章于 2022-12-31 23:00:00 发布
阅读量829 收藏
点赞数
分类专栏： Python 文章标签： Python 集合 set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39754970/article/details/103268866
版权

集合(set)：

集合是一些唯一的、不可变的对象组成的一个无序集合体（collection），这些对象支持与数学集合论相对应的操作，一个元素在集合中只能出现一次，不管它被添入了多少次，因此集合被广泛的应用于数值和数据库的工作中

因为集合是其他对象的集合体，因此集合具有列表与字典的共同行为，如可迭代

一个集合的行为类似于一个有键无值的字典，但由于集合是无序的，而且不会把键映射到值，因此集合既不是序列也不是映射类型，而是自成一体的类型

集合的定义：

Python2.6及之前的版本：

  • set() -> new empty set object
  • set(iterable) -> new set object
# Python2.6及之前版本的集合定义

#空集合的定义
s = set()
print(s)
# 输出结果：set()


# 使用列表或可迭代对象进行集合的定义
s = set([1, 'a', (2, 3)])
print(s)
# 列表为无序集合体，所以输出是无序的
# 输出结果：{(2, 3), 1, 'a'}

s = set(range(4))
print(s)
# 输出结果：{0, 1, 2, 3}


# 在集合中重复出现的元素将会被删除
s = set([1, 1, 2, 3, 1])
print(s)
print(len(s))
# 输出结果：{1, 2, 3}
# {1, 2, 3}
# 3

Python3.X与Python2.7中的定义方式：

  • 使用集合字面量形式，该形式使用花括号来定义集合
# 该形式不能用于定义空集合，会被认为是字典类型
s = {}
print(type(s))
# 输出结果：<class 'dict'>

s = set()
print(type(s))
# 输出结果：<class 'set'>

s = {1}
print(type(s))
# 输出结果：<class 'set'>



# 正确定义形式
s = {1, 'a', (2, 3)}
print(s)
# 输出结果：{(2, 3), 1, 'a'}

# 使用集合推导形式来定义集合
s = {x ** 2 for x in [1, 2, 3, 4]}
print(s)
# 输出结果：{16, 1, 4, 9}

集合只能包含不可变的（可哈希化的）对象类型，因此不能将不可哈希的类型插入集合中，如list、dict、 bytearray，否则将会报错

可hash的类型：

  • 数值型：int，float，complex
  • 布尔型：True，False
  • 字符串：string，bytes
  • 元组：tuple
  • None
# 使用hash()函数测试
l = [1, 2, 3]
print(hash(l))
# 输出结果：TypeError: unhashable type: 'list'

s = set([1, [2, 3]])
print(s)
# 输出结果：TypeError: unhashable type: 'list'

集合中的方法：

  • S.add(…)，Add an element to a set，This has no effect if the element is already present
# #S.add()
s = {1, 2, 3}
s.add(4)
print(s)
# 输出结果：{1, 2, 3, 4}

# add()仅能接收一个参数
s.add(4, 5)
print(s)
# 输出结果：TypeError: add() takes exactly one argument (2 given)
  • S.update(…)，Update a set with the union of itself and others
# S.update()
s = {1, 2, 3}
s.update([4, 5, 6], [7, 8])
print(s)
# 输出结果：{1, 2, 3, 4, 5, 6, 7, 8}

# update仅能接收可迭代类型的对象
s.update(4)
print(s)
# 输出结果：TypeError: 'int' object is not iterable
  • S.remove(…)，Remove an element from a set; it must be a member
# S.remove()
# remove()仅能接收一个参数
s = {1, 2, 3, 4, 5}
s.remove(4)
s.remove(2)
print(s)
# 输出结果：{1, 3, 5}

s = {'a', 'b'}
s.remove('a')
print(s)
# 输出结果：{'b'}

# remove()中接收的参数必须是集合中存在的成员
s = {1, 2, 3}
s.remove(4)
print(s)
# 输出结果：KeyError: 4
# 由于集合通过哈希值作为key遍历，所以此处会输出KeyError
  • S.discard(…)，Remove an element from a set if it is a member，If the element is not a member, do nothing
# S.discard()
# discard()仅接收一个参数
s = {1 ,2 ,3}
s.discard(1)
# 输出结果：{2, 3}

# discard()一个不存在的值
s.discard(4)
print(s)
# 输出结果：{1, 2, 3}
  • S.pop(…) -> item，Remove and return an arbitrary set element，Raises KeyError if the set is empty
# S.pop()
s = {1 ,2 ,3}
s.pop()
i = s.pop()

print(s)
print(i)
# 输出结果：
# {3}
# 2

# pop()不能接收参数
# s = {1 ,2 ,3}
# s.pop(1)
# print(s)
# 输出结果：TypeError: pop() takes no arguments (1 given)

# 当集合为空时，使用pop()会报错
s = set()
s.pop()
print(s)
# 输出结果：KeyError: 'pop from an empty set'
  • S.clear(…)，Remove all elements from this set
# S.clear()
s = {1 ,2 ,3}
s.clear()
print(s)
# 输出结果：set()
  • S.copy(…) ->new set，Return a shallow copy of a set
# S.copy()
s = {1 ,2 ,3}
s1 = s.copy()
print(s1)
# 输出结果：{1, 2, 3}

set和线性结构：

在线性结构中查询操作的时间复杂度为O(n)，查询时间随数据规模的增大而增大

在set、dict等结构中，其内部使用hash值作为key，时间复杂度可以做到O(1)，且查询时间与数据规模无关，效率极高

集合运算（仅能用于集合）：

交集：

  • S.intersection(…) ->set ，Return the intersection of two or more sets as a new set， 等同于 set1 & set2
  • S.intersection_update(…)， 等同于 set1 &= set2 
# S.intersection()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = s1.intersection(s2)
s4 = s1 & s2
print(s1, s2, s3, s4)
# {1, 2, 3, 4}
{3, 4, 5, 6}
{3, 4}
{3, 4}
# s1与s2不改变


# S.intersection_update()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
s1.intersection_update(s2)
s2 &= s3
print(s1, s2)
# 输出结果：
# {3, 4}
# {5, 6}
# s1与s2改变

并集：

  • S.union(…) ->new set ，Return the union of sets as a new set，等同于 set 1 | set 2
  • S.update(…) ，等同于 set 1 |= set 2
# S.union()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = s1.union(s2)
s4 = s1 | s2
print(s1, s2, s3, s4)
# 输出结果：
# {1, 2, 3, 4}
# {3, 4, 5, 6}
# {1, 2, 3, 4, 5, 6}
# {1, 2, 3, 4, 5, 6}



# S.update()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
s1.update(s2)
s2 |= s3
print(s1, s2)
# 输出结果：
# {1, 2, 3, 4, 5, 6}
# {3, 4, 5, 6, 7, 8}

差集：

  • S.difference(…) ->new set，Return the difference of two or more sets as a new set，all elements that are in this set but not the others，等同于 set 1 - set 2
  • S.difference_update(…)，Remove all elements of another set from this set ，等同于 set 1 -= set 2 
# S.difference()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = s1.difference(s2)
s4 = s1 - s2
print(s1, s2, s3, s4)
# 输出结果：
# {1, 2, 3, 4}
# {3, 4, 5, 6}
# {1, 2}
# {1, 2}


# S.difference_update()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
s1.difference_update(s2)
s2 -= s3
print(s1, s2)
# 输出结果：
# {1, 2}
# {3, 4}

对称差集（XOR）：

  • S.symmetric_difference(…) ->new set ，Return the symmetric difference of two sets as a new set，all elements that are in exactly one of the sets，等同于 set1 ^ set2
  • S.symmetric_difference_update(…)，Update a set with the symmetric difference of itself and another ，等同于 set1 ^= set2 
# S.symmetric_difference()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = s1.symmetric_difference(s2)
s4 = s1 ^ s2
print(s1, s2, s3, s4)
# 输出结果：
# {1, 2, 3, 4}
# {3, 4, 5, 6}
# {1, 2, 5, 6}
# {1, 2, 5, 6}


# S.symmetric_difference_update()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
s1.symmetric_difference_update(s2)
s2 ^= s3
print(s1, s2)
# 输出结果：
# {1, 2, 5, 6}
# {3, 4, 7, 8}

其他集合运算：

  • S.issubset(…) -> Bool，Report whether another set contains this set等同于set1 <= set2，若判断是否是真子集，使用 set1 < set2 形式
  • S.issuperset(…) -> Bool， Report whether this set contains another set 等同于set1 >= set2，若判断是否是真超集，使用 set1 > set2 形式
  • S.isdisjoint(…) -> Bool， Return True if two sets have a null intersection
# S.issubset()
s1 = {1, 2}
s2 = {1, 2, 3}
s3 = s2.copy()

print(s1.issubset(s2))
print(s1 <= s3)
print(s2 < s3)
# 输出结果：
# True
# True
# False


#S.issuperset()
s1 = {1, 2}
s2 = {1, 2, 3}
s3 = s2.copy()

print(s2.issuperset(s1))
print(s3 >= s1)
print(s3 > s2)
# 输出结果：
# True
# True
# False


# S.isdisjoint()
s1 = {1, 2, 3}
s2 = {4, 5, 6}
s3 = {2, 3, 4}

print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))
# 输出结果：
# True
# False

使用运算符与函数进行集合运算的区别：

  • 使用运算符仅能够进行集合与集合间的运算，使用函数能够进行集合与可迭代对象间的运算（包括列表），运算后结果为集合类型
# 使用函数与运算符进行集合运算的区别
s1 = {1, 2, 3, 4}
t = (3, 4, 5, 6)
# 此处使用函数进行集合运算，t为元组类型
s2 = s1.intersection(t)
print(s2)
# 输出结果：{3, 4}

s1 = {1, 2, 3, 4}
t = (3, 4, 5, 6)
# 此处使用运算符进行运算
s2 = s1 & t
print(s2)
# 输出结果：TypeError: unsupported operand type(s) for &: 'set' and 'tuple'

为什么使用集合：

  • 过滤集合体中的重复项
# 使用集合过滤集合体中的重复项

l = [1 ,2 ,3, 5, 1, 1, 4, 2]
l = list(set(l))
print(l)
# 输出结果：[1, 2, 3, 4, 5]
# 由于集合是无序的，所以在该过程中会重新排序
  • 进行顺序无关的等价性测试
# 进行顺序无关的等价性测试
l1, l2 = [1, 2, 3], [3, 2, 1]
print(l1 == l2)
print(set(l1) == set(l2))
print(sorted(set(l1)) == sorted(set(l2)))
# 输出结果：
# False
# True
# True
  • 提取其他可迭代对象中的差异
# 提取其他可迭代对象中的差异
str1 = 'hello world'
str2 = 'helloworld'

print(set(str1) - set(str2))
print(set(str1) & set(str2))
# 输出结果：
# {' '}
# {'h', 'r', 'e', 'd', 'o', 'w', 'l'}
  • 遍历环形结构时，可使用集合记录以访问的位置
  • 处理大数据集
  • 处理朋友的朋友问题，如：
    • 共同好友
    • XXX与群里其他人都不是微信朋友关系
    • 权限判断
    • ......
  • ......
python编程入门之十：集合
洪博hopes的博客
05-26 862
第十章：【集合】 “集合！”是我们上学军训时最不想听到的口号，同时“集合”也是我们学习数学中的小噩梦；它，既可以是动词，也可以是名词，更是python中不可或缺的“数据类型”。到本章为止，我们已经讲过很多“数据类型”了，那么不妨我们来对几个“数据类型”的“封装符号”来复习一下： #字符串： str1 = "123" str2 = '123' #列表： list1 = [1,2,3] #元组： tuple1 = (1,2,3) #字典： dict1 = {'a':'A','b':'B','c':'C'}
python——集合
weixin_53463616的博客
03-16 192
python——集合
两个Set集合，set1,set2
HeiBoyYang---->It Life
07-17 3604
有两个Set集合，set1,set2,现在想比较set1和set2中的元素，如果set1中有set2中没有，返回set1中有set2中没有的元素数组，反之亦然  import java.util.HashSet;import java.util.Set;  public clas
python初学一（set的处理方式）
鲨鱼儿的博客
11-04 1019
一、集合的基本知识：            1、概念：                         理解：没有value的字典，即由字典的key组成的字典。            2、特性：                       （1）集合的元素没有重复，重复的元素删除。                       （2）集合的元素是无序的（类似dict）。         ...
集合————set
piduocheng0577的博客
12-30 598
定义 set----->{} 无序不重复 空集合: set1 = set(),集合set2 = {1,2,3} 集合中的方法 ''' len(set1) for i in set1 in,not in set1.add(x):添加元素x,将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。 set1.update(x,y,z):添加元素x，可以是多个...
CONVERT(c1,set1,set2)
一切都是浮云
08-19 988
CONVERT(c1,set1,set2) 【功能】将源字符串c1 从一个语言字符集set2转换到另一个目的set1字符集 【参数】c1,字符串，set1,set2为字符型参数 【返回】字符串 【示例】 select convert('strutz','we8hp','f7dec') "conversion" from dual; conver ------ strutz sel...
#Python学习打卡——集合#
12-22
python学习打卡——集合set 开始今天的教程，其实也不算是教程，只是在学习python的途中总结的一点点小知识点啦。 在之前，学了字符串，列表，元组，今天开启一个类似的，那就是集合。集合这个词我们应该在数学中...
浅谈Python 集合(set)类型的操作——并交差
09-21
### Python 集合(set)类型的操作详解：并集、交集、差集与对称差集 在Python编程语言中，集合（Set）是一种非常有用的数据结构，它由一系列不重复的元素组成，并且是无序的。集合提供了一系列高效的操作方法，包括...
Python——集合、元组、字典、遍历、公共方法、引用
m0_72036727的博客
07-26 522
集合（set）是一个的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号{}或者set()函数创建集合注意创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典print(student)#输出集合，重复的元素被自动去掉。...
python学习笔记——集合与字典
12-20
【Python学习笔记——集合与字典】 集合是Python中一种重要的数据结构，它与数学中的集合概念相呼应，表示无序且元素不重复的组合。集合由固定数据类型构成，这些类型必须支持哈希运算，因为哈希运算对于快速查找和...
pythonset操作教程_Python集合（set）方式和使用方法
weixin_39957312的博客
01-29 460
集合的定义方式定义一个空集合 s = set ()包含一个元素集合 s = {"hello"}定义多个元素集合 s = {"python","java"}注意：set中元素不可重复，类似dict中的键，且无序，集合里面不能包含list集合增、删、查增：set(add)题目1：set1 = {"python",java } # 则需要增加一个phpset1.add ("php") ...
Python - set() 相关方法的使用
二进制杯莫停的博客
03-06 137
Set intersection() 方法 描述 intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。 语法 intersection() 方法语法： set.intersection(set1, set2 ... etc) 参数 set1 – 必需，要查找相同元素的集合 set2 – 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开 返回值 返回一个...
python---集合之set
qq_40626327的博客
07-28 333
1、定义 集合是无序和无索引的集合。集合不允许重复。集合用花括号来表示： set1 = {"one", "two", "three", "one"} # 重复项不会加入集合 print(set1) # 注意每次执行时打印的顺序可能是不同的 2、更改 list1 = list(set1) # 集合转换为列表 print(list1) i = list1.index("three") # 得到项目的索引号 list1[i] = "four" # 通过索引号更改项目 print(l..
python基础—set集合
TaoismHuang的博客
06-22 380
set概述 1. 概述 set集合本质上是一个无序且无重复元素的集合，但是只存储了字典中key，没有存储字典中的value。 set集合中的元素与字典中key的元素有共同的特征： set集合中元素也是唯一的 set集合中元素也是不可变的 因此set集合最常用的功能就是去重 2. set的创建 set1 = set() #创建空的set集合 set2 = {1,2,3} #创建具有元素的set...
集合的运算关系
zz2230633069的博客
08-15 2223
运算关系总共有：交集，并集，差集，对称差集 交集：set1&set2 并集：set1|set2 差集：set1-set2表示属于set1但不属于set2的集合 对称集：set1^set2=(set1-set2)|(set2-set1) 空集合的时候只能用set()函数定义，不能使用{}否则会被看成是字典 a=set() 1.添加元素： （1）a.add(x)， 元素 x...
python_04（集合）
qq_37431752的博客
01-11 267
9:09 2019/1/10/周四 //enumerate（）函数的的初步试用。 li=[{"name":"苹果","price":"10"},{"name":"西瓜","price":"20"},{"name":"橘子","price":"30"}] for i ,k
Python基础语法----数据类型
无恙的博客
09-26 3995
Python七种数据类型及其常用内置函数的使用
[转载] python set 集合详解
u013946150的博客
02-11 652
参考链接： Python集合set| pop函数 Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。从形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示： {element1,element2,...,elementn} 从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Pyt...
成都理工大学_Python程序设计_Python程序设计期末模拟试题
国家一级致癌物
12-31 3478
‌假设已导入正则表达式模块 re，那么表达式 max(re.findall(‘\d+’, ‘abc1d22e333fg’), key=len, default=‘no’) 的值为（ ）。令set1 = {0, 1, 1, 2, 2, (3, 4, 4, 5, 5)}，则print(len(set1))的结果为（ ）‏已知 f=lambda x,y:x+y，则 f([6,5],[1,2,3])的值是（ ）。‍以下哪个模块是Python自带的，无须使用pip安装，可直接通过import导入后使用？
python的set()
最新发布
07-28
- *1* [python——集合set()](https://blog.csdn.net/xiaofengdada/article/details/122278679)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值