一、上节课的重点回顾：
1、类名加括号其实就是执行类的__init__方法：
2、int
a.创建方式
n1 = 123 #根据int类创建了一个对象
n2 = int(123) #根据int类创建一个对象，类的实例化就是对象
b.int内部优化
1、n1和n2的内存地址相同
n1 = 123
n2 = n1
2、按理说n1和n2的内存地址应该不同，这是由于python的内部机制的原因，
在-5~257以内的数，按2的方式写，都是指向同一个内存
n1 = 123
n2 = 123
除此之外的数，n1和n2的内存地址是不同的，但是python源码可以改取值范围
n1 = 123123
n2 = 123123
3、id查看对象的内存地址
n1 = 123
i1 = id(n1)
name = "李露"
for i in name:
print(i) #循环打印每个汉字而不是字节
bytes_list = bytes(i, encoding='utf-8') #将汉字转成字节，编码是utf-8
print(bytes_list)
for b in bytes_list:
hex 可以 十进制转16进制 二进制转16进制 结果都是字符串
>>> hex(0b10)
'0x2'
>>> hex(10)
'0xa'
bin 可以十进制转2进制 16进制转2进制 结果都是字符串
>>> bin(10)
'0b1010'
>>> bin(0x2)
'0b10’
int 可以16进制转换十进制 2进制转换十进制
>>> int(0xe)
14
>>> int(0b100)
4
python进制转换
fromkeys(seq,value=None) 解释：
默认不写value的话，所有的值为None
n = dict.fromkeys(['k1', 'k2'], []) #默认逗号后面不给的话，key对应的value都是None n['k1'].append(2) #我们修改逗号后面的空列表元素 打印 所有key的value也会修改
print(n) n['k1'] = 3 # 而单独修改key的value的话，只有 这个key的value改了，而其他的key对应的value都不变
print(n) n = dict.fromkeys() #默认逗号后面不给的话，key对应的value都是None
print(n)
二、集合set：集合是一个无序且不重复的元素集合
s1={1,2,3,1} #定义一个set s1 如果s1={}为空则默认定义一个字典
s2=set([2,5,6]) #定义一个set s2
print(s1) #s1={1,2,3} 自动去除重复的元素
s1.add(5) #s1={1,2,3,5} 添加一个元素
print(s1)
s3=s1.difference(s2) #返回一个s1中存在而不存在于s2的字典s3，s3={1，3}，而s1并没有改变
print(s3)
s1.difference_update(s2) #s1跟新成上面的s3 s1={1，3}
s1.discard(1) #删除元素1，不存在的话不报错 s1={3}
print(s1)
s1.remove(3) #删除元素3，不存在的话报错 s1={}
print(s1)
s1.update([11,2,3]) #跟新s1中的元素，其实是添加 s1={11,2,3}
print(s1)
k=s1.pop() #删除一个元素，并将删除的元素返回给一个变量，无序的，所以并不知道删除谁
s1={1,2,3,4} #这里重新定义了集合s1，s2
s2={3,4,5,6}
r1=s1.intersection(s2) #取交集，并将结果返回给一个新的集合 r1={3，4}
print(r1)
print(s1)
s1.intersection_update(s2) #取交集，并将s1更新为取交集后的结果 s1={3,4}
print(s1)
k1=s1.issubset(s2) #s1是否是s2的的子序列是的话返回True，否则False 这里k1=true
print(k1)
k2=s1.issuperset(s2) #s1是否是s2的父序列 k2=False
k3=s2.isdisjoint(s1) #s1,s2,是否有交集，有的话返回False,没有的话返回True
print(k3)
s1.update([1,2]) #s1={1,2,3,4}
r3=s1.union(s2) #取并集将结果返回给r3 r3={1,2,3,4,5,6}
print(r3)
r2=s1.symmetric_difference(s2) #r2=s1并s2-s1交s2 r2={1,2,5,6}
print(r2)
s1.symmetric_difference_update(s2) #s1更新为 s1并s2 - s1交s2 s1={1,2,5,6}
print(s1)
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set，添加元素 This has no effect if the element is already present.
"""
pass def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. 清楚内容"""
pass def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. 浅拷贝 """
pass def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set. A中存在，B中不存在 (i.e. all elements that are in this set but not the others.)
"""
pass def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. 从当前集合中删除和B中相同的元素"""
pass def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member. If the element is not a member, do nothing. 移除指定元素，不存在不保错
"""
pass def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two sets as a new set. 交集 (i.e. all elements that are in both sets.)
"""
pass def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. 取交集并更更新到A中 """
pass def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. 如果没有交集，返回True，否则返回False"""
pass def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. 是否是子序列"""
pass def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. 是否是父序列"""
pass def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty. 移除元素
"""
pass def remove(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError. 移除指定元素，不存在保错
"""
pass def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set. 对称交集 (i.e. all elements that are in exactly one of the sets.)
"""
pass def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. 对称交集，并更新到a中 """
pass def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set. 并集 (i.e. all elements that are in either set.)
"""
pass def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. 更新 """
pass
set 集合class---官方文档
#!/usr/bin/env python
# _*_ coding:utf-8 _*_ a={1:2,4:5}
b=set(a) b.add(111111)
b.clear()
print(b) n = {11,22,33}
b = {22,66}
c = {11} # n中有的b中没有的赋值给新的变量 打印
new_n = n.difference(b)
print(new_n) #n中有的 b中没有的 更新到n
# n.difference_update(b)
# print(n) # 将迭代的序列加入
n.update("al")
n.update([1,3,4])
print(n) #n存在的b不存在的 b存在n不存在的 组合一起输出
ret=n.symmetric_difference(b)
ret2 = n.symmetric_difference({11,22,33})
print(ret)
print("=========")
# n存在的b不存在的 b存在n不存在的 组合一起 更新到前面的集合
n.symmetric_difference_update(b)
print(n) # 是否是子集 不是返回false 是的话True
ret = n.issubset(c) # n是不是c的子
print(ret)
ret1 = c.issubset(n) # c是不是n的子
print(ret1)
ret2 = n.issuperset(c) # n是不是c的父
print(ret2) # pop discard remove 三个删除的区别 #pop 删除同时可以获取到该值
ret = n.pop() #由于集合是无序的，所以pop删除也是无序的
print(ret)
# discard 删除集合元素，如果元素不存在 返回False 不报错
n.discard(11)
print(n)
#remove 删除集合元素 如果元素不存在 报错
#n.remove(99) z = {11,22,33}
p = {44} z.intersection(p) #取交集并更新到z中
print(z) 集合 练习 #!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo' old_dict = {
"#1":11,
"#2":11,
"#3":11,
}
new_dict = {
"#1":33,
"#4":22,
"#7":100,
}
# b = set(old_dict.keys())
# print(b)
s1 =set()
s2 =set()
for i in old_dict.keys():
s1.add(i)
for n in new_dict:
s2.add(n)
print(s1,s2)
ret1 = s1.difference(s2)
print("for deling ：",ret1)
ret2 = s2.difference(s1)
print("for adding:",ret2)
# ret=s1.intersection(s2)
# print(ret)
for i in s1 :
del old_dict[i] for i in s2:
old_dict[i]=new_dict[i] print(old_dict)
set集合练习
a = set([1,2,3,4])
b = set([3,4,5,6])
a&b:求两个集合的交集--a.intersection(b)
a|b--求两个集合的并集--a.union(b)
a - b--求两个集合的差集--a.difference(b)
a ^ b--求两个集合的对称差集--a.symmetric_difference(b)
a.issubset(b)--a是b的子集
a.isuperset(b)--a是否包含b
交集 >>> a.append(10)
>>> set(a)
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> b =range(6)
>>> a = set(a)
>>> b =set(b)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> b
set([0, 1, 2, 3, 4, 5])
取交集
>>> a & b
set([0, 1, 2, 3, 4, 5])
交集应用场景：比如两个班级都叫alex或者两个班级都是100分的 或者两个班级中都大于多少分的 并集应用
>>> a | b
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) 差集
>>> a - b
set([8, 9, 10, 6, 7]) 对称差集 >>> a - b
set([8, 9, 10, 6, 7])
把两个里面对方都没有的打印出来 A b 差集
a ^ b set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
set([0, 1, 2, 3, 4, 5, 12])
>>> a ^ b
set([6, 7, 8, 9, 10, 11, 12])
a.add集合中添加一项，同样的去重不同样的增加
>>> a.add(0)
>>> a.add(22)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22]) a.update集合添加多项
>>> a.update([23,34,35])
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23]) 添加一个集合到另一个集合
>>> a.update(b)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23])
#b.issubset(a) a.issuperset(b) 测试b中的每一个元素都在a中
>>> len(a) >>> len(b) >>> b in a
False
>>> a in a
False
>>> import tab
>>> b.issubset(a) #测试b中的每一个元素都在a中
True
>>> a.issubset(b)
False
>>> 3 in a
True
>>> b.issuperset(a)
False
>>> a.issuperset(b) #测试b中的每个元素都在a中
True
set集合练习
练习：寻找两个集合的差异
# 数据库中原有
old_dict = {
"#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
"#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
} # cmdb 新汇报的数据
new_dict = {
"#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
"#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
}
#!/usr/bin/env python
# _*_ coding:utf-8 _*_ # 数据库中原有
old_dict = {
"#1":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 },
"#3":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 }
} # cmdb 新汇报的数据
new_dict = {
"#1":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 },
"#4":{ 'hostname':2, 'cpu_count': 2, 'mem_capicity': 80 }
}
# b = set(old_dict.keys())
# print(b)
s1 =set()
s2 =set()
for i in old_dict.keys():
s1.add(i)
for n in new_dict:
s2.add(n) new_jiaoji = s1.intersection(s2)
print(new_jiaoji)
for j in new_jiaoji:
if old_dict[j] != new_dict[j]:
print("need updating: { '%s': %s}"%(j,new_dict[j])) print(s1,s2)
ret1 = s1.difference(s2)
print("for deling ：",ret1)
ret2 = s2.difference(s1)
print("for adding:",ret2)
# ret=s1.intersection(s2)
# print(ret)
for i in s1 :
del old_dict[i] for i in s2:
old_dict[i]=new_dict[i] print(old_dict)
set集合练习题答案 寻找差异
三、三元运算
python的三元运算：
变量名 = 变量1 if 条件判断成立 else 变量2
解释：条件成立 变量名值为变量1 否则为变量2
a=1
b=2
if a<b: #一般条件语句的写法
k=a
else:
k=b c=a if a<b else b #三目运算符的写法
四、深浅拷贝
拷贝意味着对数据重新复制一份，对于拷贝有两种深拷贝，浅拷贝两种拷贝，不同的拷贝有不同的效果。拷贝操作对于基本数据结构需要分两类进行考虑，一类是字符串和数字，另一类是列表、字典等。如果要进行拷贝的操作话，要import copy。
1、数字和字符串
对于数字和字符串而言，深拷贝，浅拷贝没有什么区别，因为对于数字数字和字符串一旦创建便不能被修改，假如对于字符串进行替代操作，只会在内存中重新生产一个字符串，而对于原字符串，并没有改变，基于这点，深拷贝和浅拷贝对于数字和字符串没有什么区别，下面从代码里面说明这一点
import copy
s='abc'
print(s.replace('c','222')) # 打印出 ab222
print(s) # s='abc' s并没有被修改
s1=copy.deepcopy(s)
s2=copy.copy(s) #可以看出下面的值和地址都一样，所以对于字符串和数字，深浅拷贝不一样，数字和字符串一样就不演示了，大家可以去试一下
print(s,id(s2)) # abc 1995006649768
print(s1,id(s2)) # abc 1995006649768
print(s2,id(s2)) # abc 1995006649768
2、字典、列表等数据结构
对于字典、列表等数据结构，深拷贝和浅拷贝有区别，从字面上来说，可以看出深拷贝可以完全拷贝，浅拷贝则没有完全拷贝，下面先从内存地址分别来说明，假设 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}。
浅拷贝在内存中只额外创建第一层数据 深拷贝在内存中将所有的数据重新创建一
2.1、赋值：
赋值，只是创建一个变量，该变量指向原来内存地址，如：
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1
2.2浅拷贝
浅拷贝，在内存中只额外创建第一层数据
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
2.3、深拷贝
深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化） 最底层数据要满足第一条赋值变量的条件
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)
五、函数：函数传参，传的是引用
5.1 函数的定义：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。 注意是返回给函数调用者
5.2函数的参数：函数为什么要设置参数？
5.2.1无参函数
def CPU报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 def 内存报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 while True： if cpu利用率 > 90%:
CPU报警邮件（） if 硬盘使用空间 > 90%:
硬盘报警邮件（） if 内存占用 > 80%:
内存报警邮件（）
无参数实现
5.2.2有参函数
def 发送邮件(邮件内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
发送邮件("CPU报警了。")
if 硬盘使用空间 > 90%:
发送邮件("硬盘报警了。")
if 内存占用 > 80%:
发送邮件("内存报警了。")
有参数实现
5.3函数参数的种类
- 普通参数
- 默认参数
- 动态参数
普通参数
# ######### 定义函数 ######### # name 叫做函数func的形式参数，简称：形参
def func(name):
print name # ######### 执行函数 #########
# 'wupeiqi' 叫做函数func的实际参数，简称：实参
func('wupeiqi')
普通参数
默认参数
def func(name, age = 18):
print "%s:%s" %(name,age)
# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')
注：默认参数需要放在参数列表最后
默认参数
动态参数：
动态参数1：*args 是指可以传入多个参数用逗号隔开
def func(*args):
print args
# 执行方式一
func(11,33,4,4454,5)
# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)
动态参数1
如果 元素参数是一个列表呢？我们把列表传入输出的一个元素是列表，但是我们想把列表的每个元素当一个参数。调用的时候加*
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
a=[1,3,4]
def fuc(*args):
#print(args)
return args
ret=fuc(a)
print(ret) 结果：
C:\Python35\python3.exe E:/py_test/s4/s5.py
([1, 3, 4],) #!/usr/bin/env python
# _*_ coding:utf-8 _*_ a=[1,3,4]
def fuc(*args):
#print(args)
return args
ret=fuc(*a)
print(ret)
C:\Python35\python3.exe E:/py_test/s4/s5.py
(1, 3, 4)
动态参数2：**kwargs 意指可以传入多个元素以key= value key的格式是按照变量名的命名规范为标准的
def func(**kwargs):
print args
# 执行方式一
func(name＝'wupeiqi',age=18)
# 执行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)
动态参数2 ：**kwargs
如果 元素参数是一个字典呢？我们把列表传入输出的一个元素是字典，但是我们想把字典的每个key value当一个参数。调用的时候加** 只加*是key
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
a={"k1":2,"k2":3}
def fuc(**args):
#print(args)
return args
ret=fuc(**a)
print(ret) C:\Python35\python3.exe E:/py_test/s4/s5.py
{'k1': 2, 'k2': 3}
动态参数3：*args **kwargs
def func(*args, **kwargs):
print (args)
print (kwargs)
#!/usr/bin/env python
# _*_ coding:utf-8 _*_ a={"k1":2,"k2":3}
b=[1,2,3]
def fuc(*args,**kwargs):
#print(args)
return args,kwargs
ret=fuc(*b,**a)
print(ret) C:\Python35\python3.exe E:/py_test/s4/s5.py
((1, 2, 3), {'k2': 3, 'k1': 2})
升级篇：邮件发送实例：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_ def email(p,text,subject):
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr ret = True
try: msg = MIMEText(text, 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
msg['To'] = formataddr(["走人",'424662508@qq.com'])
msg['Subject'] = subject server = smtplib.SMTP("smtp.126.com", 25)
server.login("wptawy@126.com", "WW.3945.59")
server.sendmail('wptawy@126.com', [p,], msg.as_string())
server.quit()
except:
ret = False
return ret r1=email("1223995142@qq.com","python test email +===","subject==pyhon")
if r1:
print("发生成功")
else:
print("发送失败")
函数的变量：局部变量----全局变量
局部变量：针对某一个函数的内部的声明
全局变量：针对某一个.py文件，在文件的内部是有效的
age =28 #程序全局变量
def sayHi(name):
age = 29 #函数局部变量
'''this is my first test function'''
print ("hello %s,how are you?,my age is %s!") %(name,age) sayHi('mosson')
print( 'age:',age)
让局部变量有全局变量的作用
更改方法;让局部变全局 global更改局部变全部 不建议使用
#age =28
def sayHi(name):
global age
age = 29
'''this is my first test function'''
print("hello %s,how are you?,my age is %s!") %(name,age)
sayHi('mososn')
print ('age:',age）
作业：
1.普通参数，指定参数，默认参数，动态参数的区别
普通参数传递的个数和顺序要明确，默认参数传递的时候，如果没有给默认参数复制的话，会使用默认值，如果给定了的话，就会使用给定值。动态参数的个数不确定，可以传递任意个参数，这些参数自动组装成一个元组，可以在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去，指定参数传递的是一个明确的类似键值，这些参数自动组装成一个字典，可以先定义一个字典，在前面加上**变成关键字参数传给函数。
2.写函数计算传入的字符串中：数字、字母、空格以及其他的个数
def fun(s):
digitnum, alphanum, sapcenum, othernum=0,0,0,0
for i in s:
if i.isdigit():
digitnum+=1
elif i.isalpha():
alphanum+=1
elif i.isspace():
sapcenum+=1
else:
othernum+=1
return (digitnum,alphanum,sapcenum,othernum)
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5
def fun(s):
ret=False
if isinstance(s,str) or isinstance(s,str) or isinstance(s,tuple):
if len(s)>5:
ret=True
return ret
4.写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容
def fun(s):
ret=False
if isinstance(s, str) or isinstance(s, str) or isinstance(s, tuple):
for i in s:
if i=='':
ret=True
break
return ret