一 上节课拾遗
1 运算符
in
字符串 判断 ： “hello” in "asdasfhelloasdfsadf"
列表元素判断："li" in ['li', 'ok']
字典key判断：key in dic.keys()
2 基本的数据类型
上节拾忆 基本数据类型
字典：
列表一句变字典
li
=
[
11
,
12
,
13
]
dic
=
dict
(
enumerate
(li,
10
))
print
(
11
)
print
(dic)
1、创建
a = {"k1": 123}
a = dict()
li = [11,22,33]
new_dict = dict(enumerate(li))
print(new_dict)
2、字典内部功能
keys() #
values()
items()
pop() get() #获取字典的key对应的value，如果该key不存在，则返回None fromkeys(seq,value=None) # 将有序的seq 作为字典的key，而value则为所有可以的公共值。共享其值
key() 3版本取的时候 要么将字典的key 用list类进行转换 要么for循环放到空列表里面 2 版本 print(dic.keys()) 直接返回 一个列表 
3 版本 print(dic.keys()) 返回的是一个类 
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
set集合，是一个无序且不重复的元素集合
set 集合class
set集合练习
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 }
}
需要删除：？ 需要新建：？ 需要更新：？ 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
set集合练习题答案 寻找差异
三、三元运算符
python 的三元运算
变量名 = 变量1 if 条件判断成立 else 变量2
意指: 条件成立 变量名值为变量1 否则为变量2
name = "eric" if 1 == 1 else "alex"
print("==",name)
lambda 带if条件的三元运算
l1
=
[
11
,
22
,
33
,
44
,
55
]
# for i in l1:
# if i % 2 == 0:
# m = map(lambda x:x+100,[i,])
# l1[l1.index(i)] = list(m)[0]
# print(l1)
k
=
map
(
lambda
x:(x
+
100
)
if
(x
%
2
=
=
0
)
else
x,l1)
print
(
list
(k))
四 深浅拷贝
1 数字和字符串
对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。
import copy # ######### 数字、字符串 ######### n1 = 123 # n1 = "i am alex age 10" print(id(n1)) # ## 赋值 ## n2 = n1 print(id(n2)) # ## 浅拷贝 ## n2 = copy.copy(n1) print(id(n2)) # ## 深拷贝 ## n3 = copy.deepcopy(n1) print(id(n3))
二、其他基本数据类型
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
1、赋值
赋值，只是创建一个变量，该变量指向原来内存地址，如：
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1
2、浅拷贝
浅拷贝，在内存中只额外创建第一层数据
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
3、深拷贝
深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化） 最底层数据要满足第一条赋值变量的条件
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)
五 函数
1、背景
在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：
while True： if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
一看上述代码，if条件语句下的内容可以被提取出来公用，如下：
def 发送邮件(内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
发送邮件('CPU报警')
if 硬盘使用空间 > 90%:
发送邮件('硬盘报警')
if 内存占用 > 80%:
对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
2、定义和使用
1 def 函数名(参数): 2 3 ... 4 函数体 5 ... 6 返回值
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。 注意是返回给函数调用者
2.1 返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
以上要点中，比较重要有参数和返回值：
如下 n5 返回值 返回给其调用者 再返回给上一层调用者。 如果 n4 n3 n2 n1 都不加return 则返回nonedef n5():
return 5
def n4():
return n5()
def n3():
return n4()
def n2():
return n3()
def n1():
return n2()
ret1 = n1()
print(ret1)
1 def 发送短信(): 2 3 发送短信的代码... 4 5 if 发送成功: 6 return True 7 else: 8 return False 9 10 11 while True: 12 13 # 每次执行发送短信函数，都会将返回值自动赋值给result 14 # 之后，可以根据result来写日志，或重发等操作 15 16 result = 发送短信() 17 if result == False: 18 记录日志，短信发送失败...
2.2 、参数
为什么要有参数？
对比：
无参数
View Code
有参数
View Code
2.2.1 函数参数种类
函数的有三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
普通参数
View Code
默认参数
View Code
动态参数1 ： *args 意指可以传入多个元素以逗号分割
View Code
如果 元素参数是一个列表呢？我们把列表传入输出的一个元素是列表，但是我们想把列表的每个元素当一个参数。调用的时候加*
1 #!/usr/bin/env python 2 # _*_ coding:utf-8 _*_ 3 __author__ = 'liujianzuo' 4 a=[1,3,4] 5 def fuc(*args): 6 #print(args) 7 return args 8 ret=fuc(a) 9 print(ret) 10 11 结果： 12 C:\Python35\python3.exe E:/py_test/s4/s5.py 13 ([1, 3, 4],) 14 15 16 17 #!/usr/bin/env python 18 # _*_ coding:utf-8 _*_ 19 __author__ = 'liujianzuo' 20 a=[1,3,4] 21 def fuc(*args): 22 #print(args) 23 return args 24 ret=fuc(*a) 25 print(ret) 26 C:\Python35\python3.exe E:/py_test/s4/s5.py 27 (1, 3, 4)
动态参数2：*args 意指可以传入多个元素以key= value key的格式是按照变量名的命名规范为标准的
View Code
如果 元素参数是一个字典呢？我们把列表传入输出的一个元素是字典，但是我们想把字典的每个key value当一个参数。调用的时候加** 只加*是key
View Code
动态参数3 ： *args **kwargs
View Code
1 #!/usr/bin/env python
2 # _*_ coding:utf-8 _*_
3 __author__ = 'liujianzuo'
4 a={"k1":2,"k2":3}
5 b=[1,2,3]
6 def fuc(*args,**kwargs):
7 #print(args)
8 return args,kwargs
9 ret=fuc(*b,**a)
10 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 _*_
__author__ = 'liujianzuo'
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("发送失败")
函数变量： 局部变量 与全局变量
函数外的变量定义的全局变量，在函数内部修改不了，因为，函数内部需要global一下否则在函数内部只能是局部变量，只是变量名跟全局变量相同而已
全局变量与局部变量区别
liujianzuo@python:~/py_training/seminar6/day3$ cat sayHi1.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('liujianzuo')
print 'age:',age
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 29!
age: 28
注释全局变量
#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('liujianzuo')
print 'age:',age
报错如下
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 29!
age:
Traceback (most recent call last):
File "sayHi1.py", line 9, in
print 'age:',age
NameError: name 'age' is not defined
更改方法;让局部变全局 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('liujianzuo')
print 'age:',age
执行
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 29!
age: 29
注释局部变量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('liujianzuo')
print 'age:',age
执行
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 28!
age: 28
练习题
1、简述普通参数、指定参数、默认参数、动态参数的区别
2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic
=
{
"k1"
:
"v1v1"
,
"k2"
: [
11
,
22
,
33
,
44
]}
PS:字典中的value只能是字符串或列表
8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。
View Code
4
知识点 all（） 函数
all(iterable) 版本：该函数在python2.5版本首次出现，适用于2.5以上版本，包括python3，兼容python3版本。 说明：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；函数等价于：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
# a={"k1":2,"k2":3}
b=[1,2,3,""]
print(all(b))
def dju(args):
if type(args) is str:
if len(b) == 0:
ret = True
return "str have no empty", ret
else:
ret =False
return "str have no empty", ret
elif type(args) is list:
if all(args):
ret=True
return "list have no empty", ret
else:
ret=False
return "list have empty", ret
elif type(args) is tuple:
args=list(args)
if all(args):
ret = True
return "tuple have no empty", ret
else:
ret = False
return "tuple have empty", ret
r1=dju(b)
print(r1)
8
def func(arg1, arg2,time1):
if arg1 == 0:
print
arg1, arg2
arg3 = arg1 + arg2
time1+=1
if time1 == 11:
return arg3
return func(arg2, arg3,time1)
ret=func(0, 1 , 3)
print(ret)
