Python之路【第2天】

目录

1. set集合
2. 三元运算

3. collections系列

   3.1counter（计数器）
   3.2有序字典 orderedDict/默认字典 defaultdict
   3.3可命名元组(namedtuple)
   3.4双向队列/单项队列

4. 杂记

5. 函数
6. 参数:字符串，元祖，字典传参
7. la mbda表达式

---

对于Python，一切事物都是对象，对象基于类创建

一 set集合

set是一个无序且不重复的元素集合,可以用于制作爬虫
1，访问速度快
2，解决重复问题

 1. def add(self, *args, **kwargs):   #添加
 2. def clear(self, *args, **kwargs):   #移除所有元素
 3. def copy(self, *args, **kwargs):  #复制一个集合
 4. def difference(self, *args, **kwargs): #返回两个或者多个集合的不同集合
 5. def difference_update(self, *args, **kwargs):  #删除当前set中的所有包含在 new set 里的元素
 6. def discard(self, *args, **kwargs):  #移除元素
 7. def intersection(self, *args, **kwargs):  #取交集，新创建一个set
 8. def intersection_update(self, *args, **kwargs): #取交集，修改原来set
 9. def isdisjoint(self, *args, **kwargs):  #如果没有交集，返回true
 10. def issubset(self, *args, **kwargs):  #是否是子集
 11. def issuperset(self, *args, **kwargs):  #是否是父集
 12. def pop(self, *args, **kwargs):  #移除，有返回值
 13. def remove(self, *args, **kwargs):  #移除
 14. def symmetric_difference(self, *args, **kwargs):  #差集，创建新对象
 15. def symmetric_difference_update(self, *args, **kwargs): #差集，改变原来
 16. def union(self, *args, **kwargs):  #并集
 17. update(self, *args, **kwargs):  #更新

创建set集合

s=set()  #初始化集合
s.add("aa")  #添加一个元素
print(s)
s.clear()  #清除集合
print(s)
#结果为：
{'aa'}
set()

返回两个集合的不同元素

s2=set(["aa","bb","cc"])
print(s2)
res=s2.difference(["aa","cc"])  #使用difference
print(res)
res2=s2.difference_update(["aa","cc"])  #difference_update
print(res2)
print(s2)
#结果为：
{'cc', 'bb', 'aa'}
{'bb'}
None    #difference_update 没有返回值
{'bb'}  #删除原来的集合元素，将不同的集合元素更新到原来的集合中
#返回出了两个集合的不同，并且由此可以看出这个是无序集合

练习：寻找差异

# 数据库中原有
#需要删除：？
#需要新建：？
#需要更新：?

old_dict = {
    "#1":{ 'hostname':"c1" },
    "#2":{ 'hostname':"c1" },
    "#3":{ 'hostname':"c1" }
}
# cmdb 新汇报的数据
new_dict = {
    "#1":{ 'hostname':"c1" },
    "#3":{ 'hostname':"c2" },
    "#4":{ 'hostname':"c1" }
}

old=set(old_dict.keys())  #生成集合
new=set(new_dict.keys())  #生成集合
print(old)
print(new)
bet=old.intersection(new)  #取两个集合的交集
print("两个k值集合的交集：",bet)
del_dict=old.symmetric_difference(bet) #旧的集合和得到交集比较得出要删掉的
print("需要删除的k值：",del_dict)
add_dict=new.symmetric_difference(bet) #新的集合和得到的交集比较得出新增的
print("需要增加的k值",add_dict)
print("----------")

for i in bet:  #循环交集集合中的元素
    print(i)
    print(old_dict[i])
    if old_dict[i] ==new_dict[i]:  #如果新旧集合的值相同则无需更新
        print("[%s]无需更新"%i)
    else:     #如果新旧集合的值不同，则需要更新
        print("[%s]有需更新" % i)  
        old_dict[i]=new_dict[i]  #新的集合中有更新的值赋给旧的字典中的键
#结果为：
{'#3', '#1', '#2'}
{'#4', '#3', '#1'}
两个k值集合的交集： {'#3', '#1'}
需要删除的k值： {'#2'}
需要增加的k值 {'#4'}
----------
#3
{'hostname': 'c1'}
[#3]有需更新
#1
{'hostname': 'c1'}
[#1]无需更新       

三元运算（三目运算）

#如果0不等于False 则 将2赋值给 result
result=2  if 0!=False else 3
print(0!=False)  #0不等于False，是真还是假？
print (result)
#结果为
False
3

collections系列

1 counter（计数器）

import collections
#统计个字母的出现次数
obj=collections.Counter('abcdeabcdabcaba')
print(obj)
res=obj.most_common(4) #返回一个排名前4的列表
print(res)
for k,v in obj.items():  #打印出元素对
    print(k,v)
#for k in obj.elements():  #打印出各元素
#   print(k)
#结果为：
Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
[('a', 5), ('b', 4), ('c', 3), ('d', 2)]
a 5
b 4
c 3
d 2
e 1

将统计出来的排名前4的字母生成列表

import collections  #导入collections类库
obj=collections.Counter('abcdeabcdabcabacccc')
list1=[]  #创建一个空的列表
print(obj)
res=obj.most_common(4)  #排名前4位的键值对
print(res)
print(res[0][0])  #取出排名前4的中的下标为0的键值元素对，元素对中的下标也为0
for index in range(4):  #定义索引
        list1.append(res[index][0])
print ("排名前4字母列表：",list1)
#结果为：
Counter({'c': 7, 'a': 5, 'b': 4, 'd': 2, 'e': 1})
[('c', 7), ('a', 5), ('b', 4), ('d', 2)]
c
排名前4字母列表： ['c', 'a', 'b', 'd']

相加减

import collections #导入类库
obj=collections.Counter(["11","22","22"])  #统计各元素的个数
print(obj)
obj.update(["aa","11","11"])  #更新上述的列表
print(obj)
obj.subtract(["aa","11"])  #减去元素
print(obj)
#结果为：
Counter({'22': 2, '11': 1})
Counter({'11': 3, '22': 2, 'aa': 1})
Counter({'11': 2, '22': 2, 'aa': 0})

2 有序字典
orderedDict 是对字典类型的补充，它记住了字典元素的添加顺序

import  collections  #导入类库
dic=collections.OrderedDict()  #创建有序字典
dic["k1"]="v1"
dic["k2"]="v2"
dic["k3"]="v3"
print(dic)
#结果为：
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])

3 默认字典（defaultdict）

from collections import defaultdict  #导入类库
list1=[11,22,33,44,55,66,77,88,99]
dic=defaultdict(list)  #创建默认字典
for i in list1:  #将列表中的元素循环赋值给i
    if i<=66:
        dic["k1"]+=[i]  #将列表i 添加到字典
       # dic["k1"].append(i)  #这样写也可以
    else:
        dic["k2"]+=[i]
print(dic)
#结果为：
defaultdict(<class 'list'>, {'k1': [11, 22, 33, 44, 55, 66], 'k2': [77, 88, 99]})

4 可命名元组(namedtuple)

import collections  #导入类库
mytupleclass=collections.namedtuple("mytupleclass",["x","y","z"])   #构造方法
obj=mytupleclass(11,22,33)   #赋值
print(obj.x)  #打印第一值
#结果为：
11

5 双向队列
一个线程安全的双向队列

"""
# import  collections  #导入类库
# d=collections.deque(["1","10"])
"""
from collections import  deque  #这个也是导入指定类库
d=deque(["1","10"])  #创建一个队列
print(d)
d.extend(["2"])  #扩展改队列
print(d)
d.extendleft(["aa"])  #从左边拓展队列
print(d)
#结果为：
deque(['1', '10'])
deque(['1', '10', '2'])
deque(['aa', '1', '10', '2']

可以用的操作队列方法

1. append(self, *args, **kwargs): #在右边增加队列
2. appendleft(self, *args, **kwargs):
3. clear(self, *args, **kwargs): # 清空队列
4. count(self, value): #统计元素个数
5. pop(self, *args, **kwargs): # 移除某些元素，有返回值
6. popleft(self, *args, **kwargs):
7. remove(self, value): # 移除某些元素
8. reverse(self)： #反转列表
9. rotate(self, *args, **kwargs): #将队列向右移动几步

既然有双向队列，也有单项队列（先进先出 FIFO ）

import queue #导入类库
q=queue.Queue()  #创建一个单向队列
q.put("11") #增加一个元素
q.put("22")
print(q.qsize())  #统计长度
print(q.get()) #先进先出原则，只取一个
print(q.get()) #再取一个
#结果为：
2
11
22

杂记

1. 深浅拷贝

import copy  #导入类库
a=123
b=123
c=copy.copy(a)  #对a进行浅拷贝
d=copy.deepcopy(a)  #对a进行深拷贝
print("a的id值：",id(a))
print("b的id值：",id(b))
print("c的id值：",id(c))
print("d的id值：",id(d))
#结果为：
a的id值： 1987687328
b的id值： 1987687328
c的id值： 1987687328
d的id值： 1987687328
#结论：对应字符串来说深浅拷贝内存值都相同

对应列表，元祖，字典

import  copy  #导入类库
n1={"k1":"v1","k2":"v2","k3":["aa","bb"]}
n2=n1  #将n1的值赋给n2
n3=copy.copy(n1)  #将n1的值浅拷贝给n3
n4=copy.deepcopy(n1)  #将n1的值深拷贝给n4
print("n1的id值：",id(n1))
print("n2的id值：",id(n2))
print("n3的id值：",id(n3))
print("n4的id值：",id(n4))
print("内层k3的值对比：")
print("id(n1['k3']):",id(n1['k3']))
print("浅拷贝id(n3['k3']):",id(n3['k3']))
print("深拷贝id(n4['k3']):",id(n4['k3']))
#结果为：
n1的id值： 2065998431144
n2的id值： 2065998431144
n3的id值： 2065998431216   #id(n1)!=id(n3)
n4的id值： 2066001050432   #id(n1)!=id(n4)
内层k3的值对比：
id(n1['k3']): 1722978421128
浅拷贝id(n3['k3']): 1722978421128
深拷贝id(n4['k3']): 1722978422088
#结论：
1浅拷贝只拷贝最外面一层 
2深拷贝，在内存中将所有数据重新创建一份（排除最后字符串层）

需求，原来有100台机器，新增100台，都需要参数设置，原来的cpu为80， 复制cpu等参数， 要求新增的cpu为50。 需要怎么处理？

import  copy  #导入类库
#定义一个字典
dic={
    "cpu":[80],
    "mem":[80],
    "disk":[80]
}
#定义一个跟dic一样的字典
dic2={
    "cpu":[80],
    "mem":[80],
    "disk":[80]
}
print("dic before:",dic)
print("dic2 before:",dic2)
print("------------")
new_dic=copy.copy(dic)  #对dic进行浅拷贝
new_dic["cpu"][0]=50  #对新的字典的cpu下标为0进行赋值
print("new_dic:",new_dic)
print("dic after:",dic)
print("------------")
new_dic2=copy.deepcopy(dic2) #对dic2进行深拷贝
new_dic2["cpu"][0]=50  #对新的字典的cpu下标为0进行赋值
print("new_dic2:",new_dic2)
print("dic2 after:",dic2)
#结果为：
dic before: {'cpu': [80], 'mem': [80], 'disk': [80]}
dic2 before: {'cpu': [80], 'mem': [80], 'disk': [80]}
------------
new_dic: {'cpu': [50], 'mem': [80], 'disk': [80]}
dic after: {'cpu': [50], 'mem': [80], 'disk': [80]}
------------
new_dic2: {'cpu': [50], 'mem': [80], 'disk': [80]}
dic2 after: {'cpu': [80], 'mem': [80], 'disk': [80]}
#结论：进行浅拷贝，原始字典键值页会改变。 进行深拷贝，原始的字典键值不改变。

函数

def mail(): #定义一个函数
    return 123
while True:
    if "cpu">90% :
        mail()  #执行mail方法
    if "mem">90% :
        mail()
f=mail #将mail函数的地址赋给f
f() #加括号可以调用mail函数

#发邮件，使用函数，这个会引起邮件系统异常
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail ():
    ret=123
    try:
        msg = MIMEText('邮件内容' , 'plain','uft-8')
        msg["From"]=formataddr(["name","qwer12347070@sina.com"])
        msg["To"]=formataddr(["name2","578887914@qq.com"])
        msg["Subject"]="主题"

        server=smtplib.SMTP("smtp.sina.com",25)
        server.login("qwer12347070@sina.com","邮箱密码")
        server.sendmail("qwer12347070@sina.com",["578887914@qq.com",],msg.as_string())
        server.quit()
    except Exception:
        ret=456
    return ret

print(mail())

return 阻断

def show(name):  #name为形参
    print("a")
    print(name)
    return 11  #阻断，不会打印b
    print("b")
ret=show( "cc")    #cc为实参，调用上面的函数
print(ret)  
#结果为：
a
cc
11

默认参数

def show (a1,a2=99):
    print (a1,a2)
show(11,66)  #如果有赋值则显示值，如果没有则显示默认值
#结果为：
11 66

指定参数

def show(a1,a2):
    print(a1,a2)
show(a2=11,a1=66)
#结果为：
66 11

元祖类无限传参

def show(*arg):  #传递多个参数，形成一个元祖
    print(arg,type(arg))
show(1,2,3)
#结果为：
(1, 2, 3) <class 'tuple'>

字典类无限传参

def show(**arg):  #传递多个参数组，形成一个字典
    print(arg,type(arg))
show(n1=11,n2=22,n3=33)
#结果为：
{'n1': 11, 'n2': 22, 'n3': 33} <class 'dict'>

元祖，字典联合接受参数

def show(*arg,**kwargs):
    print(arg)
    print(kwargs)
show(22,33,n1=33,n2=66)
#结果为：
(22, 33)
{'n1': 33, 'n2': 66}
#ps：注意元祖元素放前，字典的放后

格式化

s1="{0} is {1}"
ret=s1.format("a","b")
l=["c","d"]  #利用列表传参
ret2=s1.format(*l)  
print(ret)
print(ret2)
#结果为：
a is b
c is d

利用字典传参

s1="{name} is {name2}"
ret=s1.format(name="aa",name2="bb")
d={"name":"cc","name2":"dd"}  #利用字典传参
ret2=s1.format(**d)
print(ret)
print(ret2)
#结果为：
aa is bb
cc is dd

lambda表达式

def show(a):
    b=a+1
    return b
ret=show(4)
print(ret)
#lambda表达式适用简单函数
show2=lambda a:a+1 #将a+1的值赋给a
ret2=show2(4)
print(ret2)
#列表中的数都加100
li=[11,22,33]
new=map(lambda x:x+100,li)
l=list(new) #创建列表
print(l)
#结果为：
5
5
[111, 122, 133]

内置函数

bin(10) 转化为2进制
p=bytes(“xx”,encoding=”utf-8”)
callable() #可以被执行
ord(“a”) >>97 #将字符转化为数字
chr(99) >>”c” #将数字转化为字母
random.randint(1,99) #产生一个随机数
eval(“6*8”) #得出积
hex(100) #转化为16进制
oct(80) #转化为8进制
max() #取大的
min() #取小的
round(x） #四舍五入
sum([x,y]) #求和

将字符串转化为字典

import json
s='{"k1":"v1"}'   #看起来像字典，实际不是，因为有引号
print(s)
dic=json.loads(s)
print(type(s))
print(type(dic))
#结果为:
{"k1":"v1"}
<class 'str'>
<class 'dict'>