6内置数据结构_set
set
set(集合|集):
可变的,无序的,不重复的元素的集合;
set最大用处:去重;
约定:set翻译为集合;collection翻译为集合类型,是一个大概念;
list,链表,栈,queue(两头操作用queue);
set定义、初始化:
set()-->new empty set object
set(iterable)-->new set object
set的元素:
要求必须可以hash;
目前学过的不可hash的类型有list,bytearray,set;
元素不可以索引(无序);
set可以迭代(所有集合类型都可迭代);
例:
In [1]: s1=set() #创建空集合只能用这种方式,{}是留给dict用的
In [2]: s2=set(range(5))
In [3]: s2
Out[3]: {0, 1, 2, 3, 4}
In [4]: s3=set(list(range(10)))
In [5]: s3
Out[5]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [6]: s4={} #{}优先给dict使用
In [7]: type(s4)
Out[7]: dict
In [8]: s5={9,10,11}
In [9]: type(s5)
Out[9]: set
In [10]: s6={(1,2),3,'a'}
In [11]: s7={[1],(1,),1}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-25e234815aba> in <module>()
----> 1 s7={[1],(1,),1}
TypeError: unhashable type: 'list'
In [12]: s8={bytearray(b'abc')}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-d066a36dc55b> in <module>()
----> 1 s8={bytearray(b'abc')}
TypeError: unhashable type: 'bytearray'
In [13]: s9={'abc',b'abc'}
In [16]: s10=set(['abc',b'abc']) #虽hash值一样,但可放在set中,不是冲突元素
In [17]: hash(1)
Out[17]: 1
In [18]: hash([1])
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-18-0579e98ca3ee> in <module>()
----> 1 hash([1])
TypeError: unhashable type: 'list'
In [19]: hash('abc')
Out[19]: 7077160064984426464
In [20]: hash(b'abc')
Out[20]: 7077160064984426464
In [21]: hash('abc') == hash(b'abc')
Out[21]: True
In [22]: hash('abc') is hash(b'abc')
Out[22]: False
In [23]: s11=set(s10)
In [24]: s11
Out[24]: {'abc', b'abc'}
set增加元素:
add(elem),增加一个元素到set中;如果元素存在,什么都不做do nothing;
update(*others),合并其它元素到set集合中来;参数others必须是可迭代对象;就地修改;
例:
In [25]: s=set()
In [26]: s.add(1)
In [27]: s
Out[27]: {1}
In [28]: s.add(2)
In [29]: s.add(1)
In [30]: s
Out[30]: {1, 2}
In [31]: s.update({1,2,3},{2,3,4}) #update(*other),把多个集合的元素合并到当前集合,不是解构的概念,others是iterable
In [32]: s
Out[32]: {1, 2, 3, 4}
set删除:
remove(elem),从set中移除一个元素;元素不存在,抛出KeyError异常,为什么是KeyError,key是hash值,根据hash值来定位删除;
discard(elem),从set中移除一个元素,元素不存在,do nothing;
pop()-->item,移除并返回任意的元素,为什么是任意元素?无序,不可以索引;空集返回KeyError异常;
clear(),移除所有元素,注意GC;
例:
In [33]: s.remove(2)
In [34]: s
Out[34]: {1, 3, 4}
In [35]: s.discard(5)
In [36]: s.pop()
Out[36]: 1
In [37]: s.pop()
Out[37]: 3
In [38]: s.pop()
Out[38]: 4
In [39]: s.pop()
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-39-c88c8c48122b> in <module>()
----> 1 s.pop()
KeyError: 'pop from an empty set'
set修改、查询:
修改,要么删除,要么加入新的元素,为什么没有修改?可变类型list,bytearray均不可hash;
查询,非线性结构无法索引;
遍历,可迭代所有元素;
成员运算符,in,not in,效率?很高,相当于用index遍历list,O(1);
set成员运算符的比较:
list和set比较:
list随着值的增加耗时是数量级的增加;
set,随着值的增加,基本不变,适用于在集合中查找某个值,set中查时先转为key(hash值)再查;
set和线性结构:
线性结构的查询时间复杂度是O(n),即随着数据规模的增大而增加耗时;
set,dict等结构,内部使用hash值作为key,时间复杂度可以做到O(1),查询时间和数据规模无关;
可hashable类型:数值型(int,float,complex);布尔型(True,False);字符串(string,bytes);tuple;None;以上都是不可变类型;
注:set的元素必须是可hashable的;
set基本概念:
全集,所有元素的集合,如实数集,所有实数组成的集合就是全集;
子集subset,超集superset,一个集合A所有元素都在另一个集合B内,A是B的子集,B是A的超集;
真子集和真超集,A是B的子集,且A不等于B,A就是B的真子集,B是A的真超集;
并集,多个集合合并的结果;
交集,多个集合的公共部分;
差集,集合中除去和其它集合公共部分;
集合运算:
并集:
将两个集合A和B的所有元素合并到一起,组成的集合称作集合A和集合B的并集;
union(*others),返回多个集合合并后的新集合;
|,运算符重载,等同union(*others);
update(*others),和多个集合合并,就地修改;
|=,等同update(*others);
例:
In [40]: s1={1,2,3}
In [41]: s2={2,3,4}
In [43]: s1.union(s2)
Out[43]: {1, 2, 3, 4}
In [44]: s1
Out[44]: {1, 2, 3}
In [45]: s2
Out[45]: {2, 3, 4}
In [47]: s3=s2.union(s1)
In [48]: s3
Out[48]: {1, 2, 3, 4}
In [49]: s1 | s2
Out[49]: {1, 2, 3, 4}
In [50]: s2 | s1
Out[50]: {1, 2, 3, 4}
In [51]: s3 |= {5,6} | {7,8} #类似a += 1+2
In [52]: s3
Out[52]: {1, 2, 3, 4, 5, 6, 7, 8}
交集:
集合A和B,属于A且属于B的元素组成的集合;
intersection(*others),返回多个集合的交集;
&,等同intersection(*others);
intersection_update(*others),获取和多个集合的交集,并就地修改;
&=,等同intersection_update(*others);
例:
In [53]: s1 & s2
Out[53]: {2, 3}
In [54]: s3=s1 & s2
In [55]: s3
Out[55]: {2, 3}
In [56]: s1.intersection(s2)
Out[56]: {2, 3}
In [57]: s2.intersection(s1)
Out[57]: {2, 3}
In [58]: s3.intersection_update(s2)
In [59]: s3
Out[59]: {2, 3}
In [60]: s3.intersection_update(s1)
In [61]: s3
Out[61]: {2, 3}
差集(常用):
集合A和B,属于A但不属于B的元素组成的集合;
difference(*others),返回多个集合的差集;
-,等同difference(*others);
difference_update(*others),获取和多个集合的差集,并就地修改;
-=,等同difference_update(*others);
A-B=A-A∩B
A-B=A
A-B=环形
A-B=None
例:
In [62]: s1
Out[62]: {1, 2, 3}
In [63]: s2
Out[63]: {2, 3, 4}
In [64]: s3
Out[64]: {2, 3}
In [65]: s1-s2
Out[65]: {1}
In [66]: s2-s1
Out[66]: {4}
In [67]: s1-=s2
In [68]: s1
Out[68]: {1}
对称差集:
集合A和B,不属于A和B的交集元素组成的集合,记作(A-B)∪(B-A);
symmetric_difference(other),返回一个集合的差集;
^,等同symmetric_difference(other);
symmetric_difference_update(other),获取和另一个集合的差集,并就地修改;
^=,等同symmetric_difference_update(other);
例:
In [70]: s1={1,2,3}
In [71]: s2
Out[71]: {2, 3, 4}
In [72]: s1^s2
Out[72]: {1, 4}
In [73]: s2^=s1
In [74]: s2
Out[74]: {1, 4}
In [75]: s1
Out[75]: {1, 2, 3}
issubset(other),<=,判断当前集合是否是另一个集合的子集;
set1 < set2,判断set1是否是set2的真子集;
issuperset(other),>=,判断当前集合是否是other的超集;
set1>set2,判断set1是否是set2的真超集;
isdisjoint(other),当前集合和另一个集合有没有交集,没有交集返回True,用于判断交集;
例:
In [76]: s1={1,4,5,6}
In [77]: s2={1,3,4,5,6}
In [78]: s1>s2
Out[78]: False
In [79]: s1>=s2
Out[79]: False
In [80]: s1<s2
Out[80]: True
In [81]: s1<=s2
Out[81]: True
In [82]: s1.issubset(s2)
Out[82]: True
In [83]: s2.issuperset(s1)
Out[83]: True
In [84]: s1.issuperset(s1&s2)
Out[84]: True
In [85]: s3=set()
In [86]: {}>s3 #{}是dict,
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-86-f3e15203fad2> in <module>()
----> 1 {}>s3
TypeError: unorderable types: dict() > set()
In [88]: set() == s3
Out[88]: True
In [89]: s3={10}
In [90]: s1
Out[90]: {1, 4, 5, 6}
In [91]: s1.isdisjoint(s3) #没有交集返回True
Out[91]: True
集合set应用:
共同好友:你好好友A,B,C,他的好友B,C,D,求共同好友?
{'A','B','C'}.intersection({'B','C','D'})
微信群提醒:xxx与群里其它人都不是微信朋友关系?
userid not in (A | B | C | D) 返回False,A,B,C,D为集合
权限判断:
有一个API,要求权限同时具备A,B,C才能访问,用户权限是B,C,D,判断用户是否能访问API?
A={'A','B','C'}
B={'B','C','D'}
A >= B返回False
A - B == set() #方一,A-B为空集,B包含A
A.issubset(B) #方二,A是B的子集
A & B == A #方三
有一个API,要求权限具备A,B,C任意一项就可访问,用户权限是B,C,D,判断用户是否能访问该API?
A={'A','B','C'}
B={'B','C','D'}
A & B != set() #方1,返回True
A.isdisjoint(B) #方2,返回False表示有交集
一个总任务列表,存储所有任务,一个完成的任务列表,找出未完成的任务?
任务ID不可以重复;
所有任务ID放到一个set中,如A集合;
所有已完成的任务ID放到另一个set中,如B集合;
A - B = UNCOMPLETED,未完成任务ID;
转载于:https://blog.51cto.com/jowin/2388527
6内置数据结构_set相关推荐
- python内置数据结构教程_python课程第二周 内置数据结构——列表和元组
5种内置数据结构:列表.元组.字典.集合.字符串.列表.字典.字符串三种被称为线性结构.针对线性结构的操作有:切片.封包和解包.成员运算符.迭代. 针对数据结构的操作有解析式:解析式分为列表解析.生成 ...
- python数据结构的列表_Python内置数据结构——列表list
内置数据结构分类: 数值型 int , float , complex , bool 序列对象 字符串 str 列表 list tuple(元组) 键值对 集合 set 字典 dict 数字型int ...
- go 判断元素是否在slice_Go内置数据结构原理
作者:jackshi,腾讯 PCG 后台开发工程师 从C++切换到Go语言一年多了,有必要深入了解一下Go语言内置数据结构的实现原理,本文结合示例与Go源码深入到Go语言的底层实现. 数组 定义 数组 ...
- 【Redis源码剖析】 - Redis内置数据结构之压缩列表ziplist
在前面的一篇文章[Redis源码剖析] - Redis内置数据结构之双向链表中,我们介绍了Redis封装的一种"传统"双向链表list,分别使用prev.next指针来指向当前节点 ...
- 【Redis源代码剖析】 - Redis内置数据结构之压缩字典zipmap
原创作品,转载请标明:http://blog.csdn.net/Xiejingfa/article/details/51111230 今天为大家带来Redis中zipmap数据结构的分析,该结构定义在 ...
- python数据结构与算法面试_python面试总结4(算法与内置数据结构)
算法与内置数据结构 常用算法和数据结构 sorted dict/list/set/tuple 分析时间/空间复杂度 实现常见数据结构和算法 数据结构/算法 语言内置 内置库 线性结构 list(列表) ...
- Python内置数据结构--列表
本节内容: 列表 元组 字符串 集合 字典 本节先介绍列表. 一.列表 一种容器类型.列表可以包含任何种类的对象,比如说数字.子串.嵌套其他列表.嵌套元组. 任意对象的有序集合,通过索引访问其中的元素 ...
- python 取array并集_Python内置数据结构原理与性能简易分析
ins @ngladc 文末左下方阅读原文指向了本人博客链接,不含广告.参考资料中的相关链接,可以在博客文章的最下方获取.推荐苹果手机用户使用浅色模式观看. 前言 对于一些算法题,可以使用Python ...
- python 内置方法赋值_Python内置数据结构之字符串str
1. 数据结构回顾 所有标准序列操作(索引.切片.乘法.成员资格检查.长度.最小值和最大值)都适用于字符串,但是字符串是不可变序列,因此所有的元素赋值和切片赋值都是非法的. >>> ...
最新文章
- MySQL 目录结构信息
- java集合框架图(一)
- redux ngrx_另一个减少Redux(NGRX)应用程序样板的指南
- 常用的方法论-PARR
- navicat 导出的sql文件,再导入,运行SQL文件成功,数据库中却没有表
- json字符串转成formdata_FormData 数据转化为 json 数据
- 关于bridge-nf-call-iptables的设计问题
- 怎样提高你的Google Adsense收入
- Windows ZIP Archive安装和卸载MySQL 8.0
- Java个人博客项目
- 谈谈编程器软件开发与设计
- SMP、NUMA、MPP模型介绍
- 一篇文章带你认识数学建模中的方程与方程组
- 计算机英语期末试题,计算机英语期末考试试题
- 网站关键词怎么合理布局提升网站排名
- 私有化短链接管理系统-魔众短链接系统 v1.0.0
- 入侵检测系统和入侵防护系统的区别
- 蓝桥杯2019 c/c++ B组真题
- go zap + lumberjack 日志按大小分割demo整理
- (1)一次意外的屠魔之旅
热门文章
- 关于Jenkins找不到依赖Jar包问题
- Java中Integer类的方法
- 动态调用链接库(dll) 续
- ppz css栅格框架
- DR.com客户端解密过程逆向分析
- 计算机与生命科学专业排名,2019软科世界一流学科排名发布,54个专业TOP10牛校榜单全给你...
- c语言程序设计 第三版 哈工大,c语言程序设计 哈工大 苏小红 第三章习题
- 为什么用redis做缓存而不是mybatis自带的缓存_如何用Java设计一个本地缓存,涨姿势了...
- 计算机控制常用数据通信标准,计算机控制数据通信基础要点.ppt
- 线条边框简笔画图片大全_儿童简笔画画大全人物