生成器 迭代器，装饰器 ，软件开发规范

一、生成器

     1、列表生成式

          有列表data=[1,2,3,4],要求将列表data里面的数据均加1：

　　　  除了循环，可以用列表生成式一行写出替代多行的循环

data=[1,2,3,4]
data=[i+1 for i in data]
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）通过（）生成生成器

data=[1,2,3]
gen1=[i+1 for i in data]# gen1为一个列表生成式
gen2=(i+1 for i in data)#gen2为一个生成器
print(gen1)# 打印列表生成式  会输出一个列表：[2, 3, 4]
print(gen2)# 直接打印生成器  可以看到这时候只是生成了一个对象 ，还未进行运算：<generator object <genexpr> at 0x0000000001157048>

            既然不能直接打印生成器，那么如何取得生成器生成的参数呢？

            两种方法：1、gen._next_()/next(gen)       2、for 循环

print(gen2.__next__())#输出2
print(next(gen2))#输出3

for i in gen2:
    print(i)#输出 4，如果没有上面两次调用，则for循环调用生成器得的结果就是：2,3,4

　　  （2）函数中加入yield关键字

               例子：斐波那契数列  除了第一个数和第二个数外，其他数都是前两个数的和  1,1,2,3,5,8,13,21,34..........，要求打印该数列的前8个数

def fbq(max):
    n,a,b=0,0,1
    while n<max:
        print(b)
        a,b=b,a+b
        n=n+1
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()

x=0
def foo():
    x=1
    def fo():
        x=2
        def f():
            x=3
            print(x)
        f()
    fo()
foo()
#输出结果为3     作用于只能从里往外找

　　  1、不带参数的装饰器：

　　　原有test1和test2两个函数，现在需要需要新增一个计算每个函数运行时间的功能（已经写好新增功能的函数为timmer）

import time
def timmer(func):#高阶函数
    start_time=time.time()
    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')

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（）的时候，函数就不会往下执行了，那么有没有完美的解决方案呢？.....................嵌套函数，即在新功能函数外面再套一层函数

import time
#在之前新加功能函数的外面套一层函数
 def timmer2(func):
      def timmer():
          start_time=time.time()
          func()         #不需要再用return
          end_time=time.time()
          print('函数%s运行的时间为：%s'%(func,(end_time-start_time)))
      return timmer   #返回timmer函数的内存地址
  
 def test1():
     time.sleep(1)
    print('in the test1')
 def test2():
     time.sleep(2)
     print('in the test2')
 test2 =timmer2(test2)
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')

@timmer2
def test2(name,age): #test为带参函数 
print(name,age) test2('宋晓楠',18)

　　 3、小练习：

　　　　需求:现在有一个网站，一个页面为一个函数

　　　　　　　　def index():
    　　　　　　　　print('___首页____')
　　　　　　　　def home():
    　　　　　　　　print('____用户中心____')
　　　　　　　　def bbs()
    　　　　　　　　print('____发帖页面____')
　　 现在需要在 用户中心页面和发帖页面增加登录功能

def auth(func):
    def login():
        name='songxiaonan'
        pwd='123'
        Name=input('请输入用户名：')
        Pwd=input('密码:')
        if Name==name and Pwd==pwd:
            func()
        else:
            print('用户名或密码错误............')
    return login


def index():
    print('___首页____')
@auth
def home():
    print('____用户中心____')
def bbs():
    print('____发帖页面____')

home()

四、json&pickle的序列化

　　如果有一个字典dict，需要将这个字典写入一个新文件，则必须将字典转为字符串才可以写入
　 序列化：将一个内存对象转为字符串，即序列化

   反序列化：将字符串转回为对应的内存对象，及反序列化

data={
    'name':'宋晓楠',
    'age':22
}
f=open('file','w',encoding='utf-8')
data=str(data)  #写入一个新文件的内容必须为字符串或者二进制，所以将一个内存对象写入硬盘，必须先转为字符串或者二进制
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': 'u5b8bu6653u6960', '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:UserssongxiaonanPycharmProjectsday05_learn
#C:UserssongxiaonanPycharmProjects
#E:pythonpython35.zip
#E:pythonDLLs
#E:pythonlib
#E:python
#E:pythonlibsite-packages

import sys,os
print(__file__)#答应当前文件的相对路径
print(os.path.dirname(__file__))#去掉路径中的文件名
print(os.path.dirname(os.path.dirname(__file__)))#再去掉一层
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    程序依赖的第三方包   
|-- README

readme：
　　1、软件基本功能
　　2、运行代码的方法：安装环境，启动命令等
　　3、使用说明
　　4、代码目录结构说明，也可以说明软件的基本原理
　　5、常见问题说明