第 3 天 set集合 字典 队列 函数

1、set 无序不重复集合

1.1创建一个名为s1的set集合对象
 >>> s1 = set() 

1.2向集合中添加元素add（）方法:

>>> s1 = set()
>>> s1.add('alex')
>>> s1
{'alex'}
>>> 

set的应用场景：
访问过，就把访问过的元素放入set，最后判断set中 是否存在已访问的元素！
set的优点：
set 访问速度快，解决的运算重复的问题！

>>> l1 = ['j','k','j','o','k']
>>> s2 = set(l1)
>>> s2
{'k', 'j', 'o'} ##移除重复元素
>>>

返回2个集合的不同元素：difference(),difference_update()

>>> s2=set(['alex','jim','jim','eric','tony','alex'])
>>> s2
{'jim', 'eric', 'alex', 'tony'} ##使用有重复元素的列表创建set集合，set会剔除重复个数，只留单个！ (移除重复元素的功能！)
>>> 
>>> s2.difference(['jim','eric']) ##set的difference()方法，把2 个set中的元素进行对比，返回不同的元素列表！（即创建新的集合）
{'alex', 'tony'} ##返回的新的集合
>>> 

difference() 没有改变原来的集合，只是生成，并返回了一个新的集合！

>>> s2 ##
{'jim', 'eric', 'alex', 'tony'}
## difference_update()修改了原来s2集合的元素。修改的元素为 difference_update()的参数的不同参数！
>>> s2.difference_update(['jim','eric']) ##修改后并未创建(或返回)新的集合，而是在原来集合上进行修改！
>>> s2 ##原来的s2集合被修改了！
{'alex', 'tony'}
>>>

difference()与 difference_update()的区别：
difference() 没有修改原来的集合，只是返回了 不同的元素。
difference_update()把原来的集合 修改为了 返回不同的元素的集合！

移除元素discard()方法：

>>> s1 = set(['j','k','j','o','k'])
>>> s1
{'o', 'j', 'k'}
>>> s1.discard('o')
>>> s1
{'j', 'k'}
>>> s1.discard('k')
>>> s1
{'j'}
>>>

取2 个集合的交集intersection()方法：

>>> s1 = set(['j','k','j','o','k'])
>>> s2 = set(['k','1','3','j'])
>>> s1.intersection(s2)
{'j', 'k'}
>>> s2.intersection(s1)
{'j', 'k'}
>>>

判断2 个集合是否有交集isdisjoint()，没有交集返回True，有交集返回False！

>>> s1
{'o', 'j', 'k'}
>>> s2
{'j', '1', 'k', '3'}
>>> s3
{'l', 'e', 'a', 'x'}
>>> s3.isdisjoint(s1)
True
>>> s3.isdisjoint(s2)
True
>>> s1.isdisjoint(s2)
False
>>> s2.isdisjoint(s1)
False
>>> s2.isdisjoint(s3)
True
>>> s1.isdisjoint(s3)
True
>>>

判断是否是子集 issubset()：

>>> s1
{'o', 'j', 'k'}
>>> s4 = set(['o', 'j'])
>>> s4
{'o', 'j'}
>>> s4.issubset(s1)
True
>>>

判断是否是父集issuperset():

>>> s1
{'o', 'j', 'k'}
>>> s4
{'o', 'j'}
>>> s4.issuperset(s1)
False
>>> s1.issuperset(s4)
True
>>>

移除元素，并返回移除的元素pop():

>>> s3
{'l', 'e', 'a', 'x'}
>>> s3.pop()
'l'
>>> 
>>> s3
{'e', 'a', 'x'}
>>>

指定元素进行移除操作remove()，不返回被移除的元素：

>>> s3
{'e', 'a', 'x'}
>>> s3.remove('a')
>>> s3
{'e', 'x'}

pop() 和remove()的区别：
pop() 移除第一个元素(从第一个元素开始移除！)，并返回被移除的元素.不带参数！
remove() 指定要移除的元素，不返回信息。需要传入指定元素作为参数！

差集symmetric_difference：

>>> s1 = set(['j','3'])
>>> s1
{'j', '3'}
>>> s2
{'j', '1', 'k', '3'}
>>> s1.symmetric_difference(s2)
{'1', 'k'} ##返回 2 个集合相差的集合！
>>> s1
{'j', '3'}
>>> s2
{'j', '1', 'k', '3'}
>>>

difference()和symmetric_difference()的区别：

>>> s1 = set(['2','3','4','5','6'])
>>> s2 = set(['3','5','6','8'])
>>> s1.difference(s2) ##以s1 为参考，循环s2 
{'2', '4'}
>>> s1.symmetric_difference(s2) ##分别以s1 、s2为参考，分别循环s1和s2
{'4', '2', '8'}
>>> 
>>> s2.difference(s1)
{'8'}
>>> s2.symmetric_difference(s1)
{'4', '2', '8'}
>>>

把2个集合相差的元素 更新到原来的集合中symmetric_difference_update（）

>>> s1
{'j', '3'}
>>> s2
{'j', '1', 'k', '3'}
>>> s1.symmetric_difference_update(s2)
>>> s1
{'1', 'k'}
>>> s2
{'j', '1', 'k', '3'}
>>>

取2 个集合的并集union()：

>>> s1
{'1', 'k'}
>>> s2
{'j', '1', 'k', '3'}
>>> s1.union(s2)
{'1', 'k', '3', 'j'}
>>>

更新集合元素update():

>>> s1
{'1', 'k'}
>>> s2
{'j', '1', 'k', '3'}
>>> s1.update(s2)
>>> s1
{'1', 'k', '3', 'j'}
>>> s2
{'j', '1', 'k', '3'}
>>>

set的应用场景：
old_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':'h2', 'cpu_count': 2, 'mem_capicity': 80 }, ##需要删除的条目
"#3":{ 'hostname':'h3', 'cpu_count': 2, 'mem_capicity': 80 } ##需要更新到new_dict中的条目
}

new_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':'h3', 'cpu_count': 2, 'mem_capicity': 80 }, ##需要添加的条目
"#4":{ 'hostname':'h4', 'cpu_count': 2, 'mem_capicity': 80 } ##需要更新到new_dict中的条目

}

old_set = set(old_dict.keys()) ##{'#2', '#1', '#3'}
new_set = set(new_dict.keys()) ##{'#1', '#4', '#3'}

# print(new_set)

##获取要更新的集合(获取new_dict和old_dict 的key的交集{'#1', '#3'})
update_set = old_set.intersection(new_set)
# print(update_set) ##{'#1', '#3'}

##old 集合和new 集合的差集 (该集合只有old集合中有，是要删除的集合)
delect_set = old_set.symmetric_difference(update_set)
# print(delect_set) ##{'#2'}

## 需要添加的集合
add_set = new_set.symmetric_difference(update_set)
print(add_set) ##{'#4'}

计数器counter
counter是对字典的补充,用于追踪值的出现次数！它具备字典的所有功能，还拥有自己的功能！

import collections
c = collections.Counter('symmetric_difference')
print(c)
Counter({'e': 4, 'c': 2, 'r': 2, 'f': 2, 'm': 2, 'i': 2, 'n': 1, 't': 1, 's': 1, 'y': 1, 'd': 1, '_': 1})

for i in c.elements(): ##打印出原生字符元素
print(i)
r
r
e
e
e
e
d
m
m
t
y
c
c
_
f
f
i
i
n
s
for k,v in c.items(): ##统计字符
print(k,v)
n 1
e 4
c 2
r 2
f 2
t 1
s 1
m 2
i 2
y 1
d 1
_ 1

d = collections.Counter(['hello','piter','alex'])
print(d)
d.update(['hello','jac']) ##统计增加个数！ (update 添加元素)
print(d)
Counter({'hello': 1, 'alex': 1, 'piter': 1})
Counter({'hello': 2, 'jac': 1, 'alex': 1, 'piter': 1})

d = collections.Counter(['hello','piter','alex']) （删除元素）
d.subtract(['hello','aliba'])
print(d)
Counter({'piter': 1, 'alex': 1, 'hello': 0, 'aliba': -1})

有序字典orderedDict

dic = collections.OrderedDict()

dic['k1']='v1'
dic['k2']='v2'
dic['k3']='v3'

print(dic)
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
print(dic.pop('k2')) ##获取对应值
v2
dic.popitem()
print(dic)
OrderedDict([('k1', 'v1'), ('k2', 'v2')])

dic.update({'k1':'kk','k4':'78'}) ##更新字典
print(dic)
OrderedDict([('k1', 'v1'), ('k2', 'v2')])
OrderedDict([('k1', 'kk'), ('k2', 'v2'), ('k4', '78')])

9、默认字典

s1 = "{name} is {age}"
l = ["jima","sa"]

ret = s1.format(name='alex',age='16')

print(ret)
s1 = "{name} is {age}"
l = ["jima","sa"]
d = {'name':'jima','age':19}
# ret = s1.format(name='alex',age='16')
ret = s1.format(**d) ##使用 2 个*号作参数
print(ret)
jima is 19

lambda表达式：
func = lambda a:a+1 ## a为形参
r = func(3) 
print(r)
4

10、可命名元组

import collections
Mytclass = collections.namedtuple('Mytclass',['x','y','z'])
obj = Mytclass(1,3,4)
print(obj.x)
print(obj.y)
print(obj.z)
1
3
4

11、队列

import collections

d = collections.deque()
d.append('1')
d.appendleft('10')
d.appendleft('1')
print(d)

deque(['1', '10', '1'])

c = d.count('1') ##统计 “1” 元素出现次数
print(c)
2

d.extend(['ss','sdw']) ##扩展
deque(['1', '10', '1', 'ss', 'sdw'])


print(d)
d.rotate(2) ##从队列后边取2 个元素放到队列前边
print(d)
deque(['1', '10', '1', 'ss', 'sdw'])
deque(['ss', 'sdw', '1', '10', '1'])

12、单向队列

import queue
q = queue.Queue() ##创建一个单向队列
q.put('hello')
q.put('dw')
print(q.qsize())
2
print(q.get()) ##先进先出
hello

函数：
result =Ture
try :
...
except Exception:
result = False
return result

遇到reture时，函数就结束。retrue以下代码就不会执行了！

函数的默认参数：

def show (a1,a2=777): ##a2 = 777为默认参数
print(a1,a2)

show('s')
s 777
def show (a1,a2=777): ##默认参数放在最后
print(a1,a2)

show('s','aaa')
s aaa

指定参数：
def show(a1,a2):
print(a1,a2)

show (a2=121,a1=777) ##指定参数
777 121

动态参数：

def show(*arg): ##1个* 时，转换为元组
print(arg,type(arg))

show(1) ##(1,) <class 'tuple'>
show(1,2,3,4,55,4) ##(1, 2, 3, 4, 55, 4) <class 'tuple'>

def show(**arg): ##2 个* 时,转换为字典
print(arg,type(arg))
show(n1=1,n2=4) ##{'n1': 1, 'n2': 4} <class 'dict'>

def show(*args,**kwargs): ##组合使用
print(args,type(args))
print(kwargs,type(kwargs))
show(1,2,3,n1=5,n2=11)

(1, 2, 3) <class 'tuple'>
{'n1': 5, 'n2': 11} <class 'dict'>

def show(*args,**kwargs):
print(args,type(args))
print(kwargs,type(kwargs))
l = [11,22,33]
d = {'a':'7','b':'77'}
show(l,d)
([11, 22, 33], {'a': '7', 'b': '77'}) <class 'tuple'>
{} <class 'dict'>

def show(*args,**kwargs):
print(args,type(args))
print(kwargs,type(kwargs))
l = [11,22,33]
d = {'a':'7','b':'77'}
show(*l,**d) ##对应的参数要加对应的*
(11, 22, 33) <class 'tuple'>
{'a': '7', 'b': '77'} <class 'dict'>

使用动态参数实现字符串格式化：

s1 = "{0} is {1}"
l = ["jima","sa"]

ret = s1.format(*l) ##使用1 个*号作参数

print(ret) ##jima is sa
jima is sa