Python(五)-生成器、迭代器、装饰器、程序目录规范
目录：
1、生成器
2、迭代器
3、装饰器
4、软件目录结构规范
第1章 生成器、迭代器、装饰器
1.1 列表生成式
现在有个需求，看列表［0，1，2，3，4，5，6，7，8，9］，需求要求把列表里的每个值加1，你怎么实现？
实例1:
#!/usr/bin/env python a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] b=[] for i in a: b.append(i+1) a=b print(a) 结果： [1, 2, 3, 4, 5, 6, 7, 8, 9，10]
实例2:
#!/usr/bin/env python a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a = map(lambda x:x+1,a) for i in a: print(i) 结果： 1 2 3 4 5 6 7 8 9 10
实例3:
#!/usr/bin/env python a=[i+1 for i in range(10)] print(a) 结果： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 注意：实例3就是列表生成式。
1.2 生成器
通过列表生成式，我们可以直接创建一个列表，但是受到内存限制，列表容量肯定式有限的,而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间，在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法，第一种方法很简单，只要把一个列表生成式的［］改成()，就创建了一个generator：
例如：
#列表生成式 print([ i*2 for i in range(10) ]) #使代码更简介 #生成器 print( i*2 for i in range(10) ) 结果： [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] <generator object <genexpr> at 0x101384830> 注意：生成器打印出来是一个内存地址，只能使用__next__方法进行一个一个调用。
1.2.1 生成器小结
1、直邮在调用时才会生成相应数据
2、使用__next__方法进行取下一个值，在2.7里面时next()
3、它只保留一个值，只记住当前一个值，也不可以跳着取值。
1.2.2 使用函数生成生成器（斐波那契算法）
#斐波那契算法：算法为前面的两个数相加得出第三个数，一次类推。 def fib(max): n, a, b = 0, 0, 1 while n < max: yield b #有这个方法就会将打印出来的b，编程生成器的方式，因此，此函数就成为了生成器,想把谁返回到外面就用yield #yield终端函数的状态，然后使用next调用就会回到函数 a,b=b,a+b n=n+1 return 'done' #返回值，是为了后续抓去错误时使用。 # #抓取报错信息 g=fib(6) #将斐波那契的函数返回值付值给g变量 while True: try: #尝试语法 x = next(g) #使用next方法调用此函数，next同等与__next__ print('g:',x) #打印返回值 except StopIteration as e: #使用except 语法抓去报错StopIteration，付值给e，抓去到报错进行返回一个值，这个返回值就是函数的return的值 #为什么要抓去报错呢？因为我们不知道生成器有多长，等死循环到最后没值的时候，那么程序就会报错，所以需要抓去到， #进行指定返回值。 print('生成器返回值为：',e.value) #打印生成器的返回值 break #抓到错误后，推出循环
小结：
1、yield特性：可以停止函数，将函数停止在右yield这一状态，进行跳出函数，执行此函数后面的逻辑，等在使用next方法调用时，就回到此函数，进行执行函数下面的内容。
1.2.3 使用yield特性进行单线程并发
import time def chibaozi(name): #定义个一个函数 print('%s 准备吃包子！' %name) #打印谁来吃包子 while True: #来一个循环 baozi = yield #付值是为来后面使用send方法进行传值 print('包子%s来了，被%s吃了'%(baozi,name)) #打印一下，为了显示返回到这个yield时执行下面的内容 def shengchan(name): #在定义一个函数 c = chibaozi('A') #调用上面的函数，进行付值，在这里是将函数变成生成器的过程 c2 = chibaozi('B') c.__next__() #在这里同时调用两次，在这里调用一次，是为了调用第一次，为了打印yield前面的逻辑内容 c2.__next__()#同上面的next也是一样。 print('老子开始吃包子了！') #打印开始 for i in range(10):#循环十次 time.sleep(1) #睡眠1秒 print('做了2个包子')#打印做的包子 c.send(i) c2.send(i) #调用并传入值 shengchan('chenxin') #进行调用生产函数
注意：这种单线程并发又叫做协程，比线程单位还小的一个单位。
1.3 迭代器
1.3.1 迭代器说明
我们知道，可以直接作用于for循环的数据类型有以下几种
一类是集合数据类型：如list、tuple、dict、set、str等
一类是generator，包括生成器和带yield等generator function
1.3.2 判断是否为可迭代对象
这些可以直接作用于for循环的对象统称为可迭代对象:iterable。
可以使用isinstance()判断一个对象是否iterable对象：
from collections import Iterable print(isinstance([], Iterable)) #判断列表是不是可迭代对象 print(isinstance({}, Iterable))#判断字典是不是可迭代对象 print(isinstance('abc', Iterable))#判断字符串是不是可迭代对象 print(isinstance((x for x in range(10)), Iterable))#判断生成器是不是可迭代对象 print(isinstance(100, Iterable))#判断数字是不是可迭代对象 结果： True True True True False
1.3.3 判断是否为迭代器
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
＊＊可以被next函数条用并不断返回下一个值的对象称为迭代器：iterator
可以使用isinstance()判断一个对象是否是iterator对象：
#判断是不是迭代器 from collections import Iterator print(isinstance((x for x in range(10)), Iterator)) print(isinstance([], Iterator)) print(isinstance({}, Iterator)) print(isinstance('abc', Iterator)) 结果： True False False False 生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
1.3.4 使用iter方法生成迭代器
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
print(isinstance(iter([]), Iterator)) print(isinstance(iter('abc'), Iterator)) #结果 True True
你可能会问，为什么list、dict、str等数据类型不是Iterator?
这是因为Python等Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误，可以把这个数据流看做时一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算时惰性的，只有在需要返回下一个数据时才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数，而实用list是永远不可能存储全体自然数的。
1.3.5 小结：
1、凡是可作用于for循环的对象都是Iterable类型。
2、凡是可作用next函数的对象都是Iterator类型，他们表示一个惰性计算的序列。
3、集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
4、python的for循环本质上就是通过不断调用next函数实现的。例如：
for x in [1,2,3,4,5]: pass 实际上完全等价于： # 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) except StopIteration: # 遇到StopIteration就退出循环 break
1.4 装饰器
1.4.1 定义
装饰器是由两种不同的函数类型组成的，分别是高阶函数与嵌套函数组成。
1、高阶函数：
a) 第一规则，修改了被装饰的函数的调用方法
import time def bar(): time.sleep(2) print('我是bar函数') def test1(func): start_time = time.time() func() stop_time = time.time() print('我是func运行的时间%s'%(stop_time-start_time)) test1(bar) 结果： 我是bar函数 我是func运行的时间2.0051779747009277
b) 第二规则：给装饰器添加一个返回值，
#高阶函数(第二个规则) import time def bar(): time.sleep(2) print('我是bar函数') def test2(func): print(func) return func bar=test2(bar) bar() 结果： <function bar at 0x10137ad08> 我是bar函数 2、嵌套函数 def foo(): print('in the foo') def bar(): print('in the bar') bar() foo() 结果： in the foo in the bar
3、装饰器，高阶函数+嵌套函数
import time def timer(func): #timer(test1) func=test1 def deco(*args,**kwargs): #可以支持传入任意多个参数 start_time = time.time() func(*args,**kwargs) #此func事timer的参数传进来的，就是被装饰的函数的内存地址，func=test1 stop_time = time.time() print('func的运行时间%s'%(stop_time-start_time)) return deco #这个return返回deco的执行结果，也就是test1的执行结果 @timer #test1=timer(test1) #装饰下面的test1 def test1(): time.sleep(2) print('in the test1') test1() 结果： in the test1 func的运行时间2.0028600692749023
1.4.2 统一认证接口（高潮版）
目前只有被装饰的函数可以传参数
import time user,passwd='chenxin','123' def auth(func):#func=被装饰的函数的内存地址 def wrapper(*args, **kwargs): username = input('username:').strip() password = input('password:').strip() if user == username and passwd == password: print('authentication') res = func(*args, **kwargs) # 调用被装饰函数 else: exit('cuowu') return wrapper def index(): print('welcome to index page') @auth def home(): print('welcome to home page') @auth def bbs(): print('welcome to bbs page') home() bbs() 结果： username:chenxin password:123 authentication welcome to home page username:chenxin password:123 authentication welcome to bbs page
1.4.3 统一认证接口（超级赛亚人高潮版）
目前被装饰器的也可以传参数，装饰器本身也可以传参数，需求是auth有不同的认证地方和方式，例如：home只认证本地，而bbs认证数据库的用户名密码等。
import time user,passwd = 'cx','abc123' def auth(auth_type): print('auth func:',auth_type) def outer_wrapper(func): def wrapper(*args, **kwargs): print('wrapper func args :', *args,**kwargs) if auth_type == 'local': username = input('Username:').strip() password = input('Password:').strip() if user == username and passwd == password: print('认证通过！！！') return func(*args, **kwargs) else: exit('认证失败！！') elif auth_type == 'ldap': print('不会ldap！！') return wrapper return outer_wrapper def index(): print('welcome to index page') @auth(auth_type="local") def home(): print('welcome to home page') return 'from home' @auth(auth_type="ldap") def bbs(): print('welcome to bbs page') index() home() bbs() 结果： auth func: local auth func: ldap welcome to index page wrapper func args : Username:cx Password:abc123 认证通过！！！ welcome to home page wrapper func args : 不会ldap！！
第2章 软件目录结构规范
为什么要设计好目录结构？
“设计项目目录结构”，就和“代码编码风格”一样，属于个人风格问题。对于这种风格的规范，一直都存在两种态度，
1、一类认为，这种个人风格问题“无关紧要”。理由是能让城乡work就好，风格问题根本不是问题。
2、另一类认为，规范化能更好的控制程序结构，让程序具有更高的可读性。
我是比较偏向后者，
"项目目录结构"其实也是属于"可读性和可维护性"的范畴，我们设计一个层次清晰的目录结构，就是为了达到以下两点:
1、可读性高：不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪，配置文件在哪等等，从而非常快速的了解这个项目。
2、可维护性高：定义好组织规则后，维护者就能很明确的知道，新增的哪个文件和代码应该放在什么目录下，这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好。
所以，我认为保持一个层次清晰的目录结构是有必要的，更何况组织一个良好的工程目录，其实是一件很容易的事。
2.1 目录组织方式
关于如何组织一个较好的Python工程目录结构，已经有一些得到了共识的目录结构，在Stackoverflow的这个问题上，能看到大家对Python目录结构的讨论。
这里面说的已经很好了，我也不打算重新造轮子举例各种不同的方式，这里我说一下我的理解和体会。
假如你的项目名为foo，我比较建议的最方便快捷目录结构这样就足够了：
Foo/ |-- bin/ | |-- foo | |-- foo/ | |-- tests/ | | |-- __init__.py | | |-- test_main.py | | | |-- __init__.py | |-- main.py | |-- docs/ | |-- conf.py | |-- abc.rst | |-- setup.py |-- requirements.txt |-- README
简要解释一下：
1、bin：存放项目的一些可执行文件，当然你可以起名scripts之类的也可行。
2、foo：存放项目的所有源代码。
a)源代码中的所有模块、包都应该放在此目录，不要置于顶层目录
b)其子目录tests存放单元测试代码
c)程序的入口最好命名为main.py
3、docs：存放一下文档
4、setup.py：安装、部署、打包脚本。
5、requirements.txt：存放软件依赖的外部Python包列表。
6、README：项目说明文件
除此之外，有一些方案给出了更加多的内容，比如LICENSE.txt，Changelog.txt等文件，我没有列在这里，因为这些东西主要是项目开源的时候需要用到，如果你想写一个开源软件，目录该如何组织，可参考
2.1.1 关于README内容
这个我觉得是每个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。
它需要说明一下几个事项：
1、软件定位，软件基本功能。
2、运行代码的方法：安装环境、启动命令等。
3、简要的使用说明
4、代码目录结构说明，更详细点可以说明软件的基本原理。
5、常见问题说明
以上几点是比较好的一个README，在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一个要在一开始就有信息都补全，但在项目完结的时候，是需要撰写这样的一个文档的，
可以参考Redis源码中Readme的写法，这里面简洁但是清晰的描述了Redis功能和源码结构。
2.1.2 关于requirements.txt和setup.py
setup.py
一般来说，用setup.py来管理代码的打包、安装、部署问题，业界标准的写法是用Python流行打包工具setuptools来管理这些事情，这种方式普遍应用于开源项目中，不过这里的核心思想不是用来标准化的工具来解决这些问题，而是说，一个项目一定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
我们开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，，遇过一下问题。
1、安装环境时经常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
2、Python包的版本依赖问题，有时候我们程序中使用一个版本的Python包，但是官方的已经是最新的包了，通过手动安装就可能安装错了。
3、如果依赖的包很多的话，一个一个安装这些依赖是很费时的事情。
4、新同学开始写项目的时候，将程序跑起来非常麻烦，因为可能经常忘了要怎么安装各种依赖。
Setup.py可以将这些事情自动化起来，提高效率、减少出错的概率，“复杂的东西自动化，能自动化的东西一定要自动化”，是一个非常好的习惯。
Setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点，学习技术的方式就是看他人是怎么用的，可以参考一下Python的一个web框架，flash是如何写的：setup.py，当然，简单点自己写个安装脚本（depliy.sh）替代setup.py也未尝不可。
requirements.txt
这个文件存在的目的是：
1、方便开发者维护软件的包依赖，将开发过程中新增的包添加进这个目录中，避免在setup.py安装依赖时漏掉软件包。
2、方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明，通常是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就可以简单的通过pip install –r requirements.txt来把所有Python包依赖都装好了。
2.1.3 关于配置文件的使用方法
注意，在上面的目录结构中，没有将conf.py放在源代码目录下，而是放在docs目录下。
很多项目对配置问的使用方法是：
1、配置文件写在一个或多个Python文件中，比如此处的conf.py
2、项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。
这种做法不是很好：
1、这让单元测试变的困难（因为模块内部依赖了外部的配置）
2、另一方面配置文件作为用户控制程序的接口，应当可以由用户自由指定该文件的路径。
3、程序组件可复用性太差，因为这种贯穿所有模块的代码硬编程方式，使得大部分模块都依赖conf.py这个文件，
所以为认为配置的使用，更好的方式为：
1、模块的配置都是可以灵活配置的，不受外部配置文件的影响。
2、程序的配置也是可以灵活控制的。
能够佐证这个思想的是，用过nginx和MySQL的都知道，nginx、MySQL这些程序都可以自由指定用户配置。
所以，不应该在代码中直接import conf来使用配置文件，上面目录结构中的conf.py，是给出的一个配置样例，不是在写死在程序中直接引用的配置文件，可以通过main.py启动参数指定配置路径的方式来让程序读取配置内容，当然，这里的conf.py你可以换个类似的名字，比如，settings.py，或者你可以使用其他格式的内容来编写配置文件，比如settings.yaml之类的。
