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

首页 > 代码库 > 生成器迭代器，装饰器，软件开发规范

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

2024-08-19 23:58:08 226人阅读

一、生成器

1、列表生成式

有列表data=http://www.mamicode.com/[1,2,3,4],要求将列表data里面的数据均加1：

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

1 data=http://www.mamicode.com/[1,2,3,4]
2 data=http://www.mamicode.com/[i+1 for i in data]
3 print(data)

生成式中也可以写三元运算

#需求：列表中小于3的都*2，大于等于3的+1
data=http://www.mamicode.com/[i*2 if i<3 else i+1 for i in data]

　　　列表生成式，是python内置的一种直接生成list的表达式，可以直接生成一个列表，但是受内存限制，容量有限，如果生成的数据量很大，但是使用到的寥寥无几，那么其他数据占用的控件就会浪费，那么有没有节省控件的方法呢？。。。。。。。生成器 generator

　　2.生成器generator

生成器生成的方式有两种，一种是将列表生成式的‘[]’改为‘()’，一种是听过在函数中加入yield关键字

生成器和列表生成式的区别：列表生成式在生成的时候就已经计算出了参数的一个列表，而生成器被调用的时候，才会去生成参数

（1）通过（）生成生成器

1 data=http://www.mamicode.com/[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=http://www.mamicode.com/[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‘)

@timmer2
def 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=http://www.mamicode.com/{
2     ‘name‘:‘宋晓楠‘,
3     ‘age‘:22
4 }
5 f=open(‘file‘,‘w‘,encoding=‘utf-8‘)
6 data=http://www.mamicode.com/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=http://www.mamicode.com/{
    ‘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=http://www.mamicode.com/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    程序依赖的第三方包   
|-- README


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

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

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 生成器 迭代器，装饰器 ，软件开发规范

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

看完仍有疑问？有类似问题直接问程序猿

首页 > 代码库 > 生成器迭代器，装饰器，软件开发规范

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