day4

1. 迭代器&生成器
2. 装饰器
3. Json & pickle 数据序列化
4. 软件目录结构规范
5. 做业:ATM项目开发

.列表生成式，迭代器&生成器

 a = []
 for i in range(10):
 a.append(i)
 print(a)


 a = [ i*10 for i in range(10) ]
 print(a)

如今的需求是吧列表a的每一位都加1

a = [1,2,3,4,5,6]
b = []
for i in a:
 i+=1
 b.append(i)
print(b)
[2, 3, 4, 5, 6, 7]

>>> a = [i+1 for i in range(10)] >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

 

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

b = (i for i in range(10))
print(b)
print(b.__next__())　　0
print(b.__next__())　　1
print(b.__next__())　　2
print(b.__next__())　　3

print(next(b))　　4

print(next(b))　　5

咱们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

固然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象：

>>> g = (x * x for x in range ( 10 ))

>>> for n in g:

...     print (n)

...

0

1

4

9

16

25

36

49

64

81

 

因此，咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误。

generator很是强大。若是推算的算法比较复杂，用相似列表生成式的for循环没法实现的时候，还能够用函数来实现。

好比，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易：

def fib(x):
    a,b,n=1,0,1
 while n < x:
 a,b=b,a+b
 n+=1
 print(b)

fib(10)



1
1
2
3
5
8
13
21
34

仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print(b)改成yield b就能够了：

def fib(x):
    a,b,n=1,0,1
 while n < x:
 a,b=b,a+b
 n+=1
 yield d

f=fib(10)
print(f)


<generator object fib at 0x0058E420>

data = fib(10)
print(data) print(data.__next__())　　1 print(data.__next__())　　1 print("干点别的事")　　　　干点别的事 print(data.__next__())　　2 print(data.__next__())　　3 print(data.__next__())　　5 print(data.__next__())　　8　 print(data.__next__())　　13

在上面fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。

一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

for n in fib(6): ... print(n) ... 1 1 2 3 5 8


可是用循环调用generator时，发现拿不到generator的语句的返回值。若是想要拿到返回值，必须捕获错误，返回值包含在的中：



forreturnStopIterationStopIterationvalue

迭代器

咱们已经知道，能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

可使用isinstance()判断一个对象是不是Iterable对象：

>>> from collections import Iterable

>>> isinstance ([], Iterable)

True

>>> isinstance ({}, Iterable)

True

>>> isinstance ( 'abc' , Iterable)

True

>>> isinstance ((x for x in range ( 10 )), Iterable)

True

>>> isinstance ( 100 , Iterable)

False

 

而生成器不但能够做用于for循环，还能够被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。

*能够被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可使用isinstance()判断一个对象是不是Iterator对象：

 

>>> from collections import Iterator

>>> isinstance ((x for x in range ( 10 )), Iterator)

True

>>> isinstance ([], Iterator)

False

>>> isinstance ({}, Iterator)

False

>>> isinstance ( 'abc' , Iterator)

False

 

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可使用iter()函数：

>>> isinstance ( iter ([]), Iterator)

True

>>> isinstance ( iter ( 'abc' ), Iterator)

True

 

你可能会问，为何list、dict、str等数据类型不是Iterator？

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。

Iterator甚至能够表示一个无限大的数据流，例如全体天然数。而使用list是永远不可能存储全体天然数的。

a = (i for i in range(100000000000000000000))
for i in a:
 print(i)

小结

凡是可做用于for循环的对象都是Iterable类型；

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

Python的for循环本质上就是经过不断调用next()函数实现的，例如：

for x in [ 1 , 2 , 3 , 4 , 5 ]:

     pass

 

it = iter([1, 2, 3, 4, 5])
# 循环: while True: try: # 得到下一个值: x = next(it) except StopIteration: # 遇到StopIteration就退出循环 break

装饰器

 

#装饰器
#不能修改被装饰的函数的源代码
#同时也不能修改这个函数的调用方式
#装饰器彻底透明
#函数即变量，高阶函数，嵌套函数 高阶函数+嵌套函数=》装饰器
import time

def timmer(func):
 def wrapper(*args,**kwargs):
 start_time = time.time()
 func()
 stop_time = time.time()
 print('the func run time is %s'%(stop_time-start_time))
 return wrapper

@timmer
def test1():
 time.sleep(3)
 print('in the test1')

test1()

函数即变量，高阶函数，嵌套函数  高阶函数+嵌套函数=》装饰器
def test() 在内存中存入函数体 :pass test = '函数体' test(),先声明再调用
高阶函数 知足 把一个函数名当作实参传给另一个函数 (在不修改源函数的状况下为其添加功能) 返回值中包含函数名(不修改函数的调用方式)
lambda x:x*3 函数体而已 没有函数名，在内存中会被回收
装饰器
不能修改被装饰的函数的源代码
同时也不能修改这个函数的调用方式
装饰器彻底透明

返回值中包含函数名(不修改函数的调用方式)
 import time
 def bar():
 time.sleep(3)
 print('in the bar')

 def test2(func):
 print(func)
 return func

 # print(test2(bar))
 t=test2(bar)
 t()
 bar=test2(bar)
 bar()

 def foo():
 print('in the foo')
 def bar():#函数即变量，因此在函数里面定义的函数就是局部变量
 print('in the bar')
 bar()

 foo()

 def grandfa():
 x=1
 def father():
 x=2
 def son():
 x=3
 print(x)
 son()
 father()
 grandfa()



import time

def timer(func):
 def deco(*args):
 start_time = time.time()
 func(args)
 stop_time = time.time()
 print('run time is %s'%(stop_time-start_time))
 return deco

@timer#test1=timer(test1) 而且返回deco的内存空间地址，而且经过test1（）执行
def test1():
 time.sleep(3)
 print('in the test1')
@timer
def test2(name):
 time.sleep(3)
 print('in the test2',name)

#test1 = timer(test1)
#test1()#deco() return deco的内存地址，时间+func()=test1()
test2('ronghui')




装饰器终极版

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:rh

import time

user,passwd = 'alex','abc123'
def auth(auth_type):
 print('auth:',auth_type)
 def out_wrapper(func):
 print('out_wrapper:',func)
 def wrapper(*args, **kwargs):
 if auth_type == 'local':
 username = input('username:').strip()
 password = input('password:').strip()
 if user == username and passwd == password:
 print("\033[32;1mUser has passed authentication\033[0m")
 # func(*args,**kwargs) #没有返回结果
 res = func(*args, **kwargs)
 print("--------------after authentication")
 return res #返回home的return
 else:
 exit("\033[31;1mInvalid username or password\033[0m")
 elif auth_type == 'ldap':
 print("laozi bu hui ldap!")

 return wrapper # 返回func()的内存地址给
 return out_wrapper

def index():
 print('welcome to index page')

@auth(auth_type='local')#home = wrapper()
def home():
 print('welcome to home page')
 return "from home"

@auth(auth_type='ldap')
def bbs():
 print('welcome to bbs page')


index()
#home()#至关于调用wrapper
print(home())#wrapper()
bbs()

3.Json & pickle 数据序列化

参考 http://www.cnblogs.com/alex3714/articles/5161349.html

 

　　

4.软件目录结构规范

为何要设计好目录结构?

"设计项目目录结构"，就和"代码编码风格"同样，属于我的风格问题。对于这种风格上的规范，一直都存在两种态度:

1. 一类同窗认为，这种我的风格问题"可有可无"。理由是能让程序work就好，风格问题根本不是问题。
2. 另外一类同窗认为，规范化能更好的控制程序结构，让程序具备更高的可读性。

我是比较偏向于后者的，由于我是前一类同窗思想行为下的直接受害者。我曾经维护过一个很是很差读的项目，其实现的逻辑并不复杂，可是却耗费了我很是长的时间去理解它想表达的意思。今后我我的对于提升项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，咱们设计一个层次清晰的目录结构，就是为了达到如下两点:

1. 可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪一个，测试目录在哪儿，配置文件在哪儿等等。从而很是快速的了解这个项目。
2. 可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪一个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增长，项目结构不会混乱，仍然可以组织良好。

因此，我认为，保持一个层次清晰的目录结构是有必要的。更况且组织一个良好的工程目录，实际上是一件很简单的事儿。

目录组织方式

关于如何组织一个较好的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/: 存放项目的一些可执行文件，固然你能够起名script/之类的也行。
2. foo/: 存放项目的全部源代码。(1) 源代码中的全部模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。
3. docs/: 存放一些文档。
4. setup.py: 安装、部署、打包的脚本。
5. requirements.txt: 存放软件依赖的外部Python包列表。
6. README: 项目说明文件。

除此以外，有一些方案给出了更加多的内容。好比LICENSE.txt,ChangeLog.txt文件等，我没有列在这里，由于这些东西主要是项目开源的时候须要用到。若是你想写一个开源软件，目录该如何组织，能够参考这篇文章。

下面，再简单讲一下我对这些目录的理解和我的要求吧。

关于README的内容

这个我以为是每一个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。

它须要说明如下几个事项:

1. 软件定位，软件的基本功能。
2. 运行代码的方法: 安装环境、启动命令等。
3. 简要的使用说明。
4. 代码目录结构说明，更详细点能够说明软件的基本原理。
5. 常见问题说明。

我以为有以上几点是比较好的一个README。在软件开发初期，因为开发过程当中以上内容可能不明确或者发生变化，并非必定要在一开始就将全部信息都补全。可是在项目完结的时候，是须要撰写这样的一个文档的。

能够参考Redis源码中Readme的写法，这里面简洁可是清晰的描述了Redis功能和源码结构。

关于requirements.txt和setup.py

setup.py

通常来讲，用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式广泛应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，一个项目必定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。

这个我是踩过坑的。

我刚开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，遇到过如下问题:

1. 安装环境时常常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
2. Python包的版本依赖问题，有时候咱们程序中使用的是一个版本的Python包，可是官方的已是最新的包了，经过手动安装就可能装错了。
3. 若是依赖的包不少的话，一个一个安装这些依赖是很费时的事情。
4. 新同窗开始写项目的时候，将程序跑起来很是麻烦，由于可能常常忘了要怎么安装各类依赖。

setup.py能够将这些事情自动化起来，提升效率、减小出错的几率。"复杂的东西自动化，能自动化的东西必定要自动化。"是一个很是好的习惯。

setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点。学习技术的方式就是看他人是怎么用的，能够参考一下Python的一个Web框架，flask是如何写的: setup.py

固然，简单点本身写个安装脚本（deploy.sh）替代setup.py也何尝不可。

requirements.txt

这个文件存在的目的是:

1. 方便开发者维护软件的包依赖。将开发过程当中新增的包添加进这个列表中，避免在setup.py安装依赖时漏掉软件包。
2. 方便读者明确项目使用了哪些Python包。

这个文件的格式是每一行包含一个包依赖的说明，一般是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就能够简单的经过 pip install -r requirements.txt来把全部Python包依赖都装好了。具体格式说明： 点这里。

 

关于配置文件的使用方法

注意，在上面的目录结构中，没有将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之类的。

 

5.本节做业

做业需求：

模拟实现一个ATM + 购物商城程序

1. 额度 15000或自定义
2. 实现购物商城，买东西加入 购物车，调用信用卡接口结帐
3. 能够提现，手续费5%
4. 每个月22号出帐单，每个月10号为还款日，过时未还，按欠款总额 万分之5 每日计息
5. 支持多帐户登陆
6. 支持帐户间转帐
7. 记录每个月平常消费流水
8. 提供还款接口
9. ATM记录操做日志 
10. 提供管理接口，包括添加帐户、用户额度，冻结帐户等。。。
11. 用户认证用装饰器