一、生成器
1、列表生成式
有列表data=[1,2,3,4],要求将列表data里面的数据均加1：
除了循环，可以用列表生成式一行写出替代多行的循环
1 data=[1,2,3,4] 2 data=[i+1 for i in data] 3 print(data)
生成式中也可以写三元运算
#需求：列表中小于3的都*2，大于等于3的+1 data=[i*2 if i<3 else i+1 for i in data]
列表生成式，是python内置的一种直接生成list的表达式，可以直接生成一个列表，但是受内存限制，容量有限，如果生成的数据量很大，但是使用到的寥寥无几，那么其他数据占用的控件就会浪费，那么有没有节省控件的方法呢？。。。。。。。生成器 generator
2.生成器generator
生成器生成的方式有两种，一种是将列表生成式的‘[]’改为‘()’，一种是听过在函数中加入yield关键字
生成器和列表生成式的区别：列表生成式在生成的时候就已经计算出了参数的一个列表，而生成器被调用的时候，才会去生成参数
（1）通过（）生成生成器
1 data=[1,2,3] 2 gen1=[i+1 for i in data]# gen1为一个列表生成式 3 gen2=(i+1 for i in data)#gen2为一个生成器 4 print(gen1)# 打印列表生成式 会输出一个列表：[2, 3, 4] 5 print(gen2)# 直接打印生成器 可以看到这时候只是生成了一个对象 ，还未进行运算：<generator object <genexpr> at 0x0000000001157048>
既然不能直接打印生成器，那么如何取得生成器生成的参数呢？
两种方法：1、gen._next_()/next(gen) 2、for 循环
1 print(gen2.__next__())#输出2 2 print(next(gen2))#输出3 3 4 for i in gen2: 5 print(i)#输出 4，如果没有上面两次调用，则for循环调用生成器得的结果就是：2,3,4
（2）函数中加入yield关键字
例子：斐波那契数列 除了第一个数和第二个数外，其他数都是前两个数的和 1,1,2,3,5,8,13,21,34..........，要求打印该数列的前8个数
1 def fbq(max): 2 n,a,b=0,0,1 3 while n<max: 4 print(b) 5 a,b=b,a+b 6 n=n+1 7 fbq(8)
现在将上面的函数变为一个生成器：
def fbq(max):
n,a,b=0,0,1
while n<max:
yield b
a,b=b,a+b
n=n+1
f=fbq(8)
print(f)
print(f.__next__())
for i in f:
print(i)
程序执行到yiled的时候，就会暂停，再次调用生成器函数的时候便会在上次暂停的位置，继续往下执行。即yield保存了程序的中间状态
在单线程下，生成器还可以模拟并行运算：
def conumer(name):
print(‘%s准备吃包子‘%name)
while True:
baozi=yield #注意：此处yield无参数
print(‘包子%s做好了，%s开始吃包子‘%(baozi,name))
def producer(name):
c=conumer(‘A‘)
c2=conumer(‘B‘)
c.__next__()
c2.__next__()
print(‘_____________________‘)
for i in range(3):
c.send(i) #给yield传参数
c2.send(i)
producer(‘songxiaonna‘)
A准备吃包子 B准备吃包子 _____________________ 包子0做好了，A开始吃包子 包子0做好了，B开始吃包子 包子1做好了，A开始吃包子 包子1做好了，B开始吃包子 包子2做好了，A开始吃包子 包子2做好了，B开始吃包子
二、迭代器
可直接进行for循环的数据类型： 列表 元组 集合 字符串，还有生成器，统称为可迭代对象。
判断对象时候可以迭代：isinstance
from collections import Iterable #导入模块 print(isinstance([],Iterable)) # 返回true
生成器不仅可以通过for循环，还可以用next调用，可以被next函数调用，并不断返回下一个值的对象，统称为迭代器 iteratior
定义一个迭代器：iter
data=[1,2,3] data=iter(data) print(data) # data:<list_iterator object at 0x0000000000565CC0> print(next(data))# 1
迭代器的对象，表示的是一个数据流，我们不知道数据流的长度，迭代器的计算是惰性运算，按需运算，但是列表等可迭代对象是长度，提前就已经知道列表中的数据，所以列表、 元组、 集合、 字符串不是迭代器
三、装饰器
装饰器的本事就是函数，其功能是为其他函数添加附加功能，实现之前函数没有的功能
假如，当前有10个函数，需要再这10个函数每个函数增加一个记录日志的功能，可以另外定义一个函数logger(),然后每个函数去调用这个函数.......
以上的方法可以解决问题，但是如果是线上程序，那么修改程序源代码会带来很大的风险。所以为程序的新添加一个功能，需要遵循两个原则：
1、不修改被装饰函数的源代码
2、不修改被装饰函数的调用方式
装饰器对于被装饰函数是完全透明的
高阶函数+嵌套函数=>装饰器
（1）函数即‘变量’
def foo():
print(‘in the foo ‘)
bar()
foo()
def bar():
print(‘in the bar‘)
#输出会报错：应为执行foo（）的时候，bar函数还没有定义，正确的代用可以更改为：
def foo():
print(‘in the foo ‘)
bar()
def bar():
print(‘in the bar‘)
foo()
或者将bar函数写在 foo前面
定义bar函数就相当于将bar函数体复制子给bar变量名。 只要在调用之前，函数已经存在，就可已被调用
（2）高阶函数
满足下面两个条件之一就是高阶函数
1、把一个函数名当做实参传给另外一个函数
def bar():
print(‘in the bar‘)
def test1(func):
func()
test1(bar)
2、返回值中包含函数名
def test2(func):
return func()
test2(bar)
（3）嵌套函数
在一个函数的函数体内，用def再声明一个函数
def foo():
def bar(): #该函数只在foo函数中生效 局部变量
print(‘in the bar‘)
bar()
foo()
1 x=0 2 def foo(): 3 x=1 4 def fo(): 5 x=2 6 def f(): 7 x=3 8 print(x) 9 f() 10 fo() 11 foo() 12 #输出结果为3 作用于只能从里往外找
1、不带参数的装饰器：
原有test1和test2两个函数，现在需要需要新增一个计算每个函数运行时间的功能（已经写好新增功能的函数为timmer）
1 import time 2 def timmer(func):#高阶函数 3 start_time=time.time() 4 func() 5 end_time=time.time() 6 print(‘函数%s运行的时间为：%s‘%(func,(end_time-start_time))) 7 8 def test1(): 9 time.sleep(1) 10 print(‘in the test1‘) 11 def test2(): 12 time.sleep(2) 13 print(‘in the test2‘) 14 15 timmer(test2)#计算test2函数的运行时间，将函数test2当做实参传入到timmer中
新增了timmer功能，但是改变了之前函数test2的调用方法......
不想改变函数的调用方式，可以将test2函数替换，test2=timmer（test2），前提是timmer函数中要返回test2的内存对象，要将func()改为 return func，如下：
import time
def timmer(func):
start_time=time.time()
return func #之前这块的代码： func （）
end_time=time.time()
print(‘函数%s运行的时间为：%s‘%(func,(end_time-start_time)))
def test1():
time.sleep(1)
print(‘in the test1‘)
def test2():
time.sleep(2)
print(‘in the test2‘)
test2 = timmer(test2)#注意：将timmer（test2）赋值给test2的时候就已经在调用timmer函数了
test2()
还是不可行，因为调用到return（）的时候，函数就不会往下执行了，那么有没有完美的解决方案呢？.....................嵌套函数，即在新功能函数外面再套一层函数
1 import time 2 #在之前新加功能函数的外面套一层函数 3 def timmer2(func): 4 def timmer(): 5 start_time=time.time() 6 func() #不需要再用return 7 end_time=time.time() 8 print(‘函数%s运行的时间为：%s‘%(func,(end_time-start_time))) 9 return timmer #返回timmer函数的内存地址 10 11 def test1(): 12 time.sleep(1) 13 print(‘in the test1‘) 14 def test2(): 15 time.sleep(2) 16 print(‘in the test2‘) 17 test2 =timmer2(test2) 18 test2()
有一种更为直观的书写方法，将 test2 =timmer2(test2) 用@+函数名的方式替换掉，如下： 在需要加新功能的功能函数前面加上 @+新功能函数名
import time
def timmer2(func):
def timmer():
start_time=time.time()
func()
end_time=time.time()
print(‘函数%s运行的时间为：%s‘%(func,(end_time-start_time)))
return timmer
@timmer2 # 相当于test2 =timmer2(test2)
def test1():
time.sleep(1)
print(‘in the test1‘)
def test2():
time.sleep(2)
print(‘in the test2‘)
test1()
2、带参数的装饰器：
只需要再timmer函数加上*args和**kwarg即可
import time
def timmer2(func):
def timmer(*args,**kwargs): #给timmer加上非固定参数
start_time=time.time()
func(*args,**kwargs) #。。。加上非固定参数
end_time=time.time()
print(‘函数%s运行的时间为：%s‘%(func,(end_time-start_time)))
return timmer
@timmer2
def test1():
time.sleep(1)
print(‘in the test1‘)
@timmer2def test2(name,age): #test为带参函数 print(name,age) test2(‘宋晓楠‘,18)
3、小练习：
需求:现在有一个网站，一个页面为一个函数
def index(): print(‘___首页____‘) def home(): print(‘____用户中心____‘) def bbs() print(‘____发帖页面____‘) 现在需要在 用户中心页面和发帖页面增加登录功能
1 def auth(func): 2 def login(): 3 name=‘songxiaonan‘ 4 pwd=‘123‘ 5 Name=input(‘请输入用户名：‘) 6 Pwd=input(‘密码:‘) 7 if Name==name and Pwd==pwd: 8 func() 9 else: 10 print(‘用户名或密码错误............‘) 11 return login 12 13 14 def index(): 15 print(‘___首页____‘) 16 @auth 17 def home(): 18 print(‘____用户中心____‘) 19 def bbs(): 20 print(‘____发帖页面____‘) 21 22 home()
四、json&pickle的序列化
如果有一个字典dict，需要将这个字典写入一个新文件，则必须将字典转为字符串才可以写入 序列化：将一个内存对象转为字符串，即序列化 反序列化：将字符串转回为对应的内存对象，及反序列化
1 data={
2 ‘name‘:‘宋晓楠‘,
3 ‘age‘:22
4 }
5 f=open(‘file‘,‘w‘,encoding=‘utf-8‘)
6 data=str(data) #写入一个新文件的内容必须为字符串或者二进制，所以将一个内存对象写入硬盘，必须先转为字符串或者二进制
7 f.write(data)
(1)json 模块
1、序列化 ①json.dumps(data)
#json序列化 json.dumps(data)
import json
data={
‘name‘:‘宋晓楠‘,
‘age‘:22
}
f=open(‘file‘,‘wb‘,encoding=‘utf-8‘)
data=str(data)
data_json=json.dumps(data)
print(data_json) #输出："{‘name‘: ‘\u5b8b\u6653\u6960‘, ‘age‘: 22}"
f.write(data_json)
②json.dump(a,f) 序列化文件之后，直接将序列化的内容写入到文件f中
data={
‘name‘:‘宋晓楠‘,
‘age‘:22
}
f=open(‘file‘,‘wb‘,encoding=‘utf-8‘)
json.dump(data,f) # ==f.wirte(json.dumps(data))
2、反序列化 ①json.loads(data_json)
data_loads=json.loads(data_json) #输出结果 将已经被转为字符串的字典 又转为字典
②json.load(f)
f=open(‘file‘,‘rb‘,encoding=‘utf-8‘) data=json.load(f) #=data=json.loads(f.read()) print(data)
注意：json支持所有语言，但是json只支持简单的数据类型的序列化，不支持复杂的数据类型，比如：函数
(2)pickle
pickle只支持python语言，但是可以支持复数据类型之间的转换
pickle的用法和json的用法完全一样
如何dumps或者load是多次？ no！写程序时dumps一次 loads一次，要么就dump多个文件就ok了
五、模块
（1）导入自己写的模块
不在同一个脚本中，想共享同一个代码，可以将功能代码转为模块
①import auth 注意：不需要加.py ②调用auth里面的login方法: auth.login ③导入auth模块中的login,hehe方法: from auth import login,hehe ④导入自己写的模块的时候，如果模块和当前文件不在同一个目录下，则：from 模块所在目录 import login (2)模块路径
#查看python搜索模块的路径集 sys.path
import sys
print(sys.path)#输出一个列表
#输出：
for i in sys.path:
print(i)
#输出：
#C:/Users/songxiaonan/PycharmProjects/day05_learn
#C:\Users\songxiaonan\PycharmProjects\day05_learn
#C:\Users\songxiaonan\PycharmProjects
#E:\python\python35.zip
#E:\python\DLLs
#E:\python\lib
#E:\python
#E:\python\lib\site-packages
1 import sys,os 2 print(__file__)#答应当前文件的相对路径 3 print(os.path.dirname(__file__))#去掉路径中的文件名 4 print(os.path.dirname(os.path.dirname(__file__)))#再去掉一层 5 print(os.path.abspath(os.path.dirname(os.path.dirname(__file__))))#相对路径变为绝对路径
进度条：
import sys,time
for i in range(10):
sys.stdout.write(‘*‘)
sys.stdout.flush()
time.sleep(0.3)
六、软件开发目录结构规范
Foo/
|-- bin/
| |-- foo #启动脚本
|
|-- foo/ 软件代码目录
| |-- tests/ 测试脚本目录
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py 程序主入口
|
|-- docs/ 文档
| |-- conf.py
| |-- abc.rst
|
|-- setup.py 安装脚本
|-- requirements.txt 程序依赖的第三方包
|-- READMEreadme： 1、软件基本功能 2、运行代码的方法：安装环境，启动命令等 3、使用说明 4、代码目录结构说明，也可以说明软件的基本原理 5、常见问题说明