DevOps系列文章 之 Python基础

集合

1.定义

1、集合是一个无序的,不重复的数据组合,它的主要作用如下:

1.去重,把一个列表变成集合,就自动去重了

2.关系测试,测试两组数据之前的交集、差集、并集等关系

2、集合类型

1.数学上,把set称做由不同的元素组成的集合,集合(set)的成员通常被称做集合元素

2.集合对象是一组无序排列的可哈希的值

3.集合有两种类型 :可变集合set 、不可变集合frozense

>>> s1 = set('hello')
>>> s2 = frozenset('hello')
>>> s1
set(['h', 'e', 'l', 'o'])
>>> s2
frozenset(['h', 'e', 'l', 'o'])

3、集合类型操作符

1.集合支持用in和not in操作符检查成员
2.能够通过len()检查集合大小
3.能够使用for迭代集合成员
4.不能取切片,没有键

>>> len(s2)
4
>>> for ch in s1:
... print ch
helo

• |:联合,取并集
• &:交集
• -:差补

>>> s1 = set('abc')
>>> s2 = set('cde')
>>> s1 | s2
set(['a', 'c', 'b', 'e', 'd'])
>>> s1 & s2
set(['c'])
>>> s1 - s2
set(['a', 'b'])

4、集合内建方法

1.set.add():作为一个整体添加成员,一次只能添加一个
2.set.update():把里面的元素分散添加成员,可以批量添加
3.set.remove():移除成员

>>> print s1
set(['h', 'e', 'l', 'o'])
>>> s1.add('new')
>>> print s1
set(['h', 'e', 'l', 'o', 'new'])
>>> s1.update('new')
>>> print s1
set(['e', 'h', 'l', 'o', 'n', 'w', 'new'])
>>> s1.remove('n')
>>> print s1
set(['e', 'h', 'l', 'o', 'w', 'new'])

4. s.issubset(t):如果s是t的子集,则返回True,否则返回False
5.s.issuperset(t):如果t是s的超集,则返回True,否则返回False
6.s.union(t):返回一个新集合,该集合是s和t的并集
7.s.intersection(t):返回一个新集合,该集合是s和t的交集

8.s.difference(t):返回一个新集合,该集合是s的成员,但不是t的成员

集合方法:

函数 描述
1

add(self, *args, **kwargs)

 是把要传入的元素做为一个整个添加到集合中
2

clear(self, *args, **kwargs)

 清空集合里面的所有元素
3

copy(self, *args, **kwargs)

复制集合里面的所有元素 ,返回一个浅复制
4

difference(self, *args, **kwargs)

求两个集合里面的不同的元素 ,又称差
5

difference_update(self, *args, **kwargs)

 返回删除了 set “集合2”中含有的元素后的 set “集合1” 
6

discard(self, *args, **kwargs)

 如果在 set “集合”中存在元素 x, 则删除 
7

intersection(self, *args, **kwargs)

求两个集合里面相同的元素,又称并 ,

返回只保留含有 set “集合2”中元素的 set “集合1” 

8

intersection_update(self, *args, **kwargs)

 ,

返回只保留含有 set “集合2”中元素的 set “集合1” ,并更新自己

9

isdisjoint(self, *args, **kwargs)

 判断两个集合是不是不相交,并返回
10

issubset(self, *args, **kwargs)

 判断集合是不是包含其他集合,等同于a>=b
11

issuperset(self, *args, **kwargs)

判断集合是不是被其他集合包含,等同于a<=b 
12

pop(self, *args, **kwargs)

 删除并且返回 set “集合”中的一个不确定的元素, 如果为空则引发 KeyError 
13

remove(self, *args, **kwargs)

 从 set “集合”中删除元素 , 如果不存在则引发 KeyError 
14

symmetric_difference(self, *args, **kwargs)

 返回一个新的 set 包含 外面 和 里面 中不重复的元素

也就是两个集合不重复的元素 

15

symmetric_difference_update(self, *args, **kwargs)

 返回含有 set “里面”或者 set “外面”中有而不是两者都有的元素的 set “外面” 
16

union(self, *args, **kwargs)

把两个集合连接起来,又称并 
17

update(self, *args, **kwargs)

 可以在集合里面添加多项

集合使用

1,定义集合
    

#第一种方法
nums = [1,2,3,4,5,6,7]
num_set = set(nums)
print(num_set)
结果:
set([1, 2, 3, 4, 5, 6, 7])
#第二种方法
num_set ={1,2,3,4,5,6,7}
print num_set
结果:

 set([1, 2, 3, 4, 5, 6, 7])


  

2,增(更新)

set.add()  

set.update([])
 

nums = {1,2,3,4,5,6,7}
#set.add()增加只能增加一个,不能增加多个值
# nums.add(8)
# print(nums)
#set.update()可以增加一个字符串,可以增加多个值
# nums.update([8])
# print(nums)
# nums.update('8')
# print(nums)
nums.update([8,9,10])
print(nums)



  

3,删
 

set1.remove(1)

    
nums = {1,2,3,4,5,6,7}
nums.remove(7)
print(nums)
结果:
{1, 2, 3, 4, 5, 6}



  

4,查:无法通过下标索引

5,改:不可变类型无法修改元素

6,交( &)
    

nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#交的方式一:&
a = nums1&nums2
print(a)
#并的方式二:intersaction
b = nums1.intersection(nums2)
print(b)
 
结果:
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}



  

7,并(|)
 

nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#并的方式一:|
a = nums1|nums2
print(a)
#并的方式二:uniom
b = nums1.union(nums2)
print(b)
 
结果:
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}


  

8,差(-)
    

nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#差的方式一:-
a1 = nums1-nums2
print(a1)
a2 = nums2-nums1
print(a2)
#差的方式二:difference
b1 = nums1.difference(nums2)
print(b1)
b2 = nums2.difference(nums1)
print(b2)
 
结果:
{6}
{8, 9, 10, 7}
{6}
{8, 9, 10, 7}



  

9,对称差集(^)
    

nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#对称差集表示方法一:^
a1 = nums1^nums2
print(a1)
#对称差集表示方法二:symmetric_difference
a2 = nums2.symmetric_difference(nums1)
print(a2)
 
结果:
{6, 7, 8, 9, 10}
{6, 7, 8, 9, 10}



10,集合转换
    

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))
 
结果:
[0, 1, 2, 3] 
(0, 1, 2, 3) 
{0, 1, 2, 3} 


补充:frozenset

  

冰冻集合,是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)

  下面创建冰冻集合(一般不会创建空的冰冻集合)

  同时下面包含函数的补充

    
#创建带数据的冰冻集合
info = frozenset(('xuexi','gongzuo','kaoyan','xiuxi'))
print(info,type(info))
#成员监测
result = 'gongzuo' in info
print(result)
#遍历冰冻集合
for i in info:
    print(i)
#集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
result = {i for i in info}
print(result,type(result))
 
#函数
#冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
info = frozenset(('xuexi','gongzuo','kaoyan','xiuxi'))
 
#copy()
result = info.copy()
print(result)
 
#集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
info = frozenset(('xuexi','gongzuo','kaoyan','xiuxi'))
info2 = {'xuexi','gongzuo','kaoyan','xiuxi'}
#冰冻集合操作
result = info.union(info2)
print(result)
 
#普通集合操作(冰冻集合是参考集合)
result = info2.union(info)
print(result)

集合操作实例

>>> s = set(["hello world"])
>>> s.add('python')   #添加
>>> s
set(['python', 'hello world'])
>>> 

>>> s.clear() #清空内容
>>> s
set([])
>>> 
>>> s = set(["hello world"])
>>> s2 = s.copy()
>>> s2
set(['hello world'])
>>> 

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> a.difference(b)  #差集,返回a集合中有但b集合中没有的元素,a中的元素不变
set([2, 4])
>>> 
>>> b.difference(a) #差集,返回b集合中有但a集合中没有的元素
set([9, 7])
>>> 

>>> a.difference_update(b)  #差集,返回a集合中有但b集合中没有的元素,并且把其结果更新到a集合中
>>> a
set([2, 4])

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> b.difference_update(a) #差集,返回b集合中有但a集合中没有的元素,并且把其结果更新到a集合中
>>> b
set([7, 9])
>>> 

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])

>>> a.discard(3) #删除集合中之指定的元素,有则删除,没有则不报异常
>>> a
set([1, 2, 4, 5])
>>> a.discard(6)
>>> a
set([1, 2, 4, 5])
>>> 

>>> a.intersection(b)  #返回交集,即两者共有的元素
set([1, 5])
>>> b.intersection(a) 
set([1, 5])
>>> 


>>> a.intersection_update(b)  #返回交集,把两者共有的元素更新到a集合中
>>> a
set([1, 5])
>>> 

>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> a.isdisjoint(b)  #判断是否不是交集,是则返回True
False
>>> b.isdisjoint(a)
False

>>> a.issubset(b) #判断a是否是b的子集,是则返回True
False


>>> a.issuperset(b) #判断a是否是b的超集,是则返回True
False

>>> a.pop()
1
>>> a
set([2, 3, 4, 5])
>>> 
>>> a.remove(3)
>>> a
set([2, 4, 5])
>>> 

>>> a.symmetric_difference(b) #对称差集,即把a中没有但b中有的以及b中有的但a中没有的重新组合在一起显示
set([2, 4, 7, 9])
>>> a.symmetric_difference_update(b)
>>> a
set([2, 4, 7, 9])
>>> 

>> a.union(b)  #并集
set([1, 2, 3, 4, 5, 7, 9])

s.update(t)将t中所有项添加到t中,t为任意支持迭代对象
>>> a.update("10")
>>> a
set([2, 4, 7, 9, '1', '0'])
>>> a.update(b)
>>> a
set([1, 2, 3, 4, 5, 7, 9, '1', '0'])
>>> 

你可能感兴趣的:(前端,python)