封装和结构及set
封装
- 将多个值使用逗号分割，组合在一起
- 本质上返回一个元组，只是省略了小括号
- python特有语法
In [56]: a=1
In [57]: b=2
In [58]: c=3
In [59]: c,b,a=b,c,a#左侧为解构，右侧为封装
In [60]: a
Out[60]: 1
In [61]: b
Out[61]: 3
In [62]: c
Out[62]: 2
In [63]: t=1,2#将1,2封装成元组
In [64]: t
Out[64]: (1, 2)
解构
- 把线性结构的元素解开，并序列的赋给其他变量
- 左边接纳的变量数要和右边解开的元素个数一致
In [66]: lst=[3,5]
In [67]: first,second=lst
In [68]: first
Out[68]: 3
In [69]: second
Out[69]: 5
—————————————————————————-
In [81]: a,b={100,66}#由于set是无序结构所以a,b会随机从列表中拿取元素
In [82]: a
Out[82]: 66
In [83]: b
Out[83]: 100
In [84]: a,b={10,20,30}#右侧value多左侧解构少于值所以报错
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-84-658256ee5b54> in <module>()
—-> 1 a,b={10,20,30}
ValueError: too many values to unpack (expected 2)
———————————————————————————–
In [89]: a,*b={19,20,21,22}#*号可以接收0个或多个数值
In [90]: a
Out[90]: 19
In [91]: b
Out[91]: [20, 21, 22]
————————————————————————————
In [92]: [a,b]=(10,29)#左右的类型不做要求
In [93]: a
Out[93]: 10
In [94]: b
Out[94]: 29
In [95]: (c,d)={100,200}
In [96]: c
Out[96]: 200
In [97]: d
Out[97]: 100
python3的解构
- 使用*变量名接收，但不能单独使用
- 被*变量名收集后组成一个列表
In [99]: lst
Out[99]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
In [100]: a,*b,c=lst
In [101]: a
Out[101]: 1
In [102]: b##*b接收下来多个元素组成列表
Out[102]: [3, 5, 7, 9, 11, 13, 15, 17]
In [103]: c
Out[103]: 19
““
<div class=”se-preview-section-delimiter”></div>
#####丢弃变量
* 如果不关心一个变量，就可以定义该变量的名字为_
* _是个合法标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非明确知道这个数据需要使用
* 总结：_ 这个变量本身无任何语义，没有任何可读性，python中很多库都在使用这个变量，请不要在不明确变量作用域的情况下使用 _ 导致和库中的 _ 冲突
<div class=”se-preview-section-delimiter”></div>
“`python
In [111]: lst
Out[111]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
In [112]: head,*_,tail=lst#当只想取出开头和结尾值时可以这样使用
In [113]: head
Out[113]: 1
In [114]: _
Out[114]: [3, 5, 7, 9, 11, 13, 15, 17]
In [115]: tail
Out[115]: 19
#应用：只想取出某个值时可以这样匹配_的值虽然不用但是最后赋值应该是5，因为赋值即定义
In [116]: lst=[1,2,(3,4),5]
In [117]: *_,(*_,a),_=lst
In [118]: a
Out[118]: 4
练习
1.环境变量JAVA_HOME=/usr/bin,返回变量名和路径
In [119]: key,val=”JAVA_HOME=/usr/bin”.split(“=”)
In [120]: key
Out[120]: ‘JAVA_HOME’
In [121]: val
Out[121]: ‘/usr/bin’
2.对列表[1,9,8,5,6,7,4,3,2]使用冒泡法排序，要求使用封装和解构来交互数据
lst=[1,9,8,5,6,7,4,3,2]
length=len(lst)
for i in range(length):
for j in range(length-i-1):
if lst[j] > lst[j+1]:
lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)
集set
- set翻译成集合
- collection翻译为集合类型，是一个大概念
- 可变的，无序的，不重复的元素集合
- set()定义一个新的空集合
- set(iterable)定义一个新的集合，注意：此处可以set([list]),因为set函数只是将列表的值插入到set中而非list本身
- set 元素要求必须可以hash(),list、set、bytearray不可hash
- 元素不可以索引
- set可以迭代
In [123]:s1=set()
In [124]: s1
Out[124]: set()
In [125]: s2=set(list(range(10)))
In [126]: s2
Out[126]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [127]: s3=set(range(10))
In [128]: s3
Out[128]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [129]: s4={}######（此处证明使用空的大括号代表类型为字典）
In [130]: type(s4)
Out[130]: dict
In [131]: s5={4,5,6,’a’}
In [132]: s6={(1,2,3),4}
In [133]: s7={[1,2,3],”a”}###报错证明list不可以被hash，同样bytearray，set这种可变类型的集合也不可以hash
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-133-4d6d1503b10e> in <module>()
—-> 1 s7={[1,2,3],”a”}
TypeError: unhashable type: ‘list’
set增加、删除、修改查询
- add(elem):增加元素到set中，如果存在不做操作
- update(*others):合并其他元素到set集合中来，参数others必须是可迭代的对象，就地修改
- remove(elem):从set中移除一个元素，如果不存在抛出keyerror
- discard(elem):从set中移除一个元素，不存在什么都不做。不抛错
- pop()->item:移除并返回任意的元素，空集返回keyerroe
- clear():移除所有元素
- 修改：无此操作，要么删除要么加入.(无索引)
- 查询：非线性结构，无法索引
- 遍历：可以迭代所有元素
- 成员运算符：in和not in 判断元素是否在set中.复杂度为O(1)
#增
In [41]: a
Out[41]: set()
In [42]: a.add(b)#add无法添加可迭代类型
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-42-a1cb1b03d031> in <module>()
—-> 1 a.add(b)
TypeError: unhashable type: ‘list’
In [43]: b
Out[43]: [1, 2, 3]
In [44]: a.add(1)
In [45]: a
Out[45]: {1}
In [46]: a.update(b)##update只能添加可迭代类型
In [47]: a
Out[47]: {1, 2, 3}
——————————————————————————–
#删：
In [50]: a
Out[50]: {1, 2, 3, ‘abcd’}
In [51]: a.remove(1)#删除单个元素
In [52]: a.remove(1)#删除不存在单个元素，报错
—————————————————————————
KeyError Traceback (most recent call last)
<ipython-input-52-b0bac4dc7509> in <module>()
—-> 1 a.remove(1)
KeyError: 1
In [53]: a.discard(1)#删除不存在的元素，不反回内容
In [54]: a.discard(2)
In [55]: a
Out[55]: {3, ‘abcd’}
In [56]: a.pop()#随机删除
Out[56]: 3
In [57]: a
Out[57]: {‘abcd’}
set成员运算符的比较
扩展：list，set效率比较
#增
In [41]: a
Out[41]: set()
In [42]: a.add(b)#add无法添加可迭代类型
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-42-a1cb1b03d031> in <module>()
—-> 1 a.add(b)
TypeError: unhashable type: ‘list’
In [43]: b
Out[43]: [1, 2, 3]
In [44]: a.add(1)
In [45]: a
Out[45]: {1}
In [46]: a.update(b)##update只能添加可迭代类型
In [47]: a
Out[47]: {1, 2, 3}
——————————————————————————–
#删：
In [50]: a
Out[50]: {1, 2, 3, ‘abcd’}
In [51]: a.remove(1)#删除单个元素
In [52]: a.remove(1)#删除不存在单个元素，报错
—————————————————————————
KeyError Traceback (most recent call last)
<ipython-input-52-b0bac4dc7509> in <module>()
—-> 1 a.remove(1)
KeyError: 1
In [53]: a.discard(1)#删除不存在的元素，不反回内容
In [54]: a.discard(2)
In [55]: a
Out[55]: {3, ‘abcd’}
In [56]: a.pop()#随机删除
Out[56]: 3
In [57]: a
Out[57]: {‘abcd’}
扩展：list，set效率比较
set和线性结构
- 线性结构的查询时间复杂度为O(n)，即随着数据规模的增大而增加耗时
- set，dict等结构，内部使用hash值作为key，时间复杂度为O(1)，查询时间和数据规模无关
- 可hash类型数据：
- 数值型int，float，complex
- 布尔型True，False
- 字符串string，bytes
- tuple
- None
- 一上都是不可变类型，成为可哈希类型，hashable
- set的元素必须是可hash的
集合
- 基本概念：
- 全集：所有元素的集合。例如实数集，所有实数组成的集合就是全集
- 子集subset&超集superset：一个集合A所有元素都在另一个集合B内，A是B的子集，B是A的超集
- 真子集&真超集：A是B子集，且A不等于B，A就是B的真子集，B是A的真超集
- 并集：多个集合合并的结果
- 交集：多个集合的公共部分
- 差集：集合中除去和其他集合公共部分
- 运算：
- 并集：将两个集合A和B的所有元素合并到一起，组成的集合称为集合A与集合B的并集
- union(*others):返回和多个集合合并后的新集合
- |运算符重载，等同于union
- update(*other):和多个集合合并，就地修改
- |=等同于update
In [31]: A={“a”,”b”,’c’,’d’}
In [32]: B={‘e’,’f’,’a’,’b’}
In [33]: A | B#返回合并后的结果，并不会对原数据做修改
Out[33]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [34]: A
Out[34]: {‘a’, ‘b’, ‘c’, ‘d’}
In [35]: B
Out[35]: {‘a’, ‘b’, ‘e’, ‘f’}
In [36]: A |= B#将合并后的结果赋值给A，原地更改。
In [37]: A
Out[37]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [38]: B
Out[38]: {‘a’, ‘b’, ‘e’, ‘f’}
In [40]: A.union(B)#同一
Out[40]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [41]: A.update(B)#同二
In [42]: A
Out[42]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
- 交集：集合A和B，由所有属于A且属于B的元素组成的集合
* intersection(*other):返回多个集合交集
* &：等同于intersection
* intersection_update(*other):获取多个集合的交集，并就地修改
* &=：等同于intersection_update
In [43]: A
Out[43]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [44]: B
Out[44]: {‘a’, ‘b’, ‘e’, ‘f’}
In [45]: A&B#求出两个集合的交集，返回结果，不对元数据修改
Out[45]: {‘a’, ‘b’, ‘e’, ‘f’}
In [46]: A&=B#就地修改A的值
In [47]: A
Out[47]: {‘a’, ‘b’, ‘e’, ‘f’}
In [48]: B
Out[48]: {‘a’, ‘b’, ‘e’, ‘f’}
In [49]: A.intersection(B)#同一
Out[49]: {‘a’, ‘b’, ‘e’, ‘f’}
In [50]: A.intersection_update(B)#同二
In [51]: A
Out[51]: {‘a’, ‘b’, ‘e’, ‘f’}
In [52]: B
Out[52]: {‘a’, ‘b’, ‘e’, ‘f’}
- 差集：集合A和B，由所有属于A且不属于B的元素组成的集合
- difference(*other)：返回多个集合的差集
- -：等同difference
- difference_update(*other)：获取多个集合的差集并就地修改
- -=：等同于difference_update
In [54]: A
Out[54]: {‘e’, ‘x’, ‘y’, ‘z’}
In [55]: B
Out[55]: {‘a’, ‘b’, ‘e’, ‘f’}
In [56]: A-B#求A于B的差集
Out[56]: {‘x’, ‘y’, ‘z’}
In [57]: A.difference(B)#同上
Out[57]: {‘x’, ‘y’, ‘z’}
In [58]: B.difference(A)#求B于A的差集
Out[58]: {‘a’, ‘b’, ‘f’}
In [59]: A-=B#求A于B的差集并将结果原地修改
In [60]: A
Out[60]: {‘x’, ‘y’, ‘z’}
In [61]: B
Out[61]: {‘a’, ‘b’, ‘e’, ‘f’}
In [64]: A.difference_update(B)#同上
In [65]: A
Out[65]: {‘x’, ‘y’, ‘z’}
- 对称差集：集合A和B，由所有不属于A和B的交集元素组成的集合，(A-B)U(B-A)
* symmetric_differece(other):返回和另一个集合的差集
* ^：等同于symmetric_differece
* symmetric_differece_update(other):获取和另一个集合的差集并就地修改
* ^=：等同于symmetric_differece_update.
In [70]: A
Out[70]: {‘a’, ‘x’, ‘y’, ‘z’}
In [71]: B
Out[71]: {‘a’, ‘b’, ‘e’, ‘f’}
In [72]: A^B#求出对称差集的集合，并打印
Out[72]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [73]: A.symmetric_difference(B)#同上
Out[73]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [74]: A^=B#求出对称集合并将结果赋予A，原地修改==A.symmetric_differece_update(B)
In [75]: A
Out[75]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [76]: B
Out[76]: {‘a’, ‘b’, ‘e’, ‘f’}
集合运算
- issubset(other)、<=:判断当前集合是否是另一个集合的子集
- set1<set2:判断set1是否是set2的真子集
- issuperset(other)、>=:判断当前集合是否是other的超集
- set1>set2:判断set1是否是set2的真超集
- isdisjoint(other):当前集合和另一个集合没有交集，没有交集则返回True
In [83]: A
Out[83]: {‘a’, ‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [84]: B
Out[84]: {‘a’, ‘b’, ‘e’, ‘f’}
In [86]: A<=B#判断A是不是B的子集
Out[86]: False
In [87]: B<=A#判断B是不是A的子集
Out[87]: True
In [88]: A>B#判断A是不是B的真超集
Out[88]: True
In [89]: A>=B#判断A是不是B的超集
Out[89]: True
In [90]: A.isdisjoint(B)#如果没有交集返回True，此处有交集
Out[90]: False
集合应用：
1.共同好友：你的好友A、B、C,他的好友C、B、D，求共同的好友
In [104]: user1={‘A’,’B’,’C’}
In [105]: user2={‘B’,’C’,’D’}
In [106]: user1 & user2#共同的好友，求交集问题。
Out[106]: {‘B’, ‘C’}
2.微信群提醒：XXX与群里其他人都不是微信朋友关系
userID in/isdisjoint （A|B|C…..） == False,A、B、C等是微信好友的并集，用户ID不在这个并集中，说明他和任何人都是不朋友
3.权限判断：
有一个API，要求权限同时具备A、B、C才能访问，用户权限是B、C、D，判断用户能否访问该API
API集合A，权限集合P
A-P={},A-P为空集，说明P包含A
A.issubset(P),A是P的子集
A&P=A也行
有一个API，要求权限具备A、B、C任意一项就可访问，用户权限时B、C、D,判断用户能否访问该API
1.API集合A，权限集合P
2.A&P != {}就可以
3.A.isdisjoint(P)==False表示有交集
4.一个总任务列表，存储所有任务，一个完成的任务列表。找出未完成的任务
业务中，任务ID一般不可以重复
所有任务ID放到一个set中，假设为ALL
所有已完成的任务ID放到一个set中，假设为COMPLETED，他是ALL的子集
ALL-COMPLETED=UNCOMPLETED
集合练习：
1.随机产2组各10个数字列表，要求：
每个数字取值范围[10,20]
统计20个数字中，一共有多少个不同的数字
2组中，不重复的数字有几个？分别是什么？
2组中，重复的数字有几个？分别是什么？
import random
num1=list()
num2=list()
for _ in range(10):
num1.append(random.randint(10,20))
num2.append(random.randint(10,20))
#print(num1,num2)
#print(“diff number is {}”.format(len(set(num1+num2))))
#not repeat number is :
#print(“Not repeat nubmer is:{}not repeat count:{}”.format(set(num1)|set(num2),len(set(num1)|set(num2))))
#repeat number is :
#print(“repeat nuber is :{}repeat count:{}”.format(set(num1)&set(num2),len(set(num1)&set(num2))))
s1=set(num1)
s2=set(num2)
print(s1.union(s2))
print(s1.symmetric_difference(s2))
print(s1.intersection(s2))
本文来自投稿，不代表Linux运维部落立场，如若转载，请注明出处：http://www.178linux.com/87688
