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. 用戶認證用裝飾器