Python基础4

本节内容

　1.迭代器 & 生成器

　2.装饰器

　3.Json & pickle 数据序列化

　4.软件目录结构规范

 

1、列表生成式, 迭代器 & 生成器

列表生成式

首先, 看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 如今让列表里面的每一个值都加1, 如何实现?

a = [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9]
b = []
for i in a:b.append(i+1)
a = b
>>>>>>>>a的结果:
[1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10]

a = [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9]
for index,i in enumerate(a):
    a[index]+=1
>>>>>>a 的结果为：
[1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10]

a = [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9]
a = map(lambda x:x+1, a)
print(a)
for i in a:
    print(i)
>>>>>>输出：
<map object at 0x0000021EA94291D0>
1
2
3
4
5
6
7
8
8
9
10

还有种写法以下：

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

上面的例子就叫作列表生成.

 

生成器

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

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

 

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

a = [i + 1 for i in range (10)]
>>>>>>>>>>
b = (i + 1 for i in range (10))
print(b)
>>>>>>>>>>输出结果为：
<generator object <genexpr> at 0x0000028FFC57FFC0>

建立a, b的区别仅在于最外层的[] 和(), a是一个list,b是一个generator.

能够直接打印出list a的元素, 那如何打印出生成器generator b里面的元素呢？

若是想要一个个打印出来的话, 能够经过带哦用next()函数来获取下一个返回值：

>>> a = (x * x for x in range(10))
>>> next(a)
0
>>> next(a)
1
>>> next(a)
4
>>> next(a)
9
>>> next(a)
16
>>> next(a)
25
>>> next(a)
36
>>> next(a)
49
>>> next(a)
64
>>> next(a)
81
>>> next(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator保存的实际上是算法,每次的调用next(a), 就计算出a的下一个值, 知道计算到最后一个元素, 没有更多的元素时, 抛出StopIteration的报错。

固然, 如上的不断调用实在是太尴尬了, 正确的方法是使用for循环,由于generator也是可迭代对象：

>>> a = (x * x for x in range(10))
>>> for i in a:
...     print(i)
...
0
1
4
9
16
25
36
49
64
81

建立一个生成器后, 通常不会调用next, 而是用for循环来迭代它, 而且不须要关心StopIteration的错误。

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

好比，著名的斐波拉契数列，除了第一个和第二个数外，任意一个数都是前2个数的和：

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

斐波拉契数列用列表生成式写不出来, 可是用函数是能够解决的：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max :
        print(b)
        a, b = b, a + b
        n += 1
    return 'done'

fib(10)
>>>>>>>
1
1
2
3
5
8
13
21
34
55

注意上面的 a, b = b, a + b

并非想象中的：

a = b
b = a+b

而是至关于：

t = (b, a + b)# t是一个tuple
a = t[0]
b = t[1]

但没必要显示的写出临时变量t就能够赋值。

能够看出, fib函数其实是定义了斐波拉契的推算规则, 从而获得后续元素, 跟generator的逻辑很类似。

其实上面的函数跟generator仅一步之遥。只须要把print(b)改为yield(b)就能够转化了。

def fib(max):
    n, a, b = 0, 0, 1

    while n < max:
        yield b
        a, b = b, a + b
        n +=1
    return 'done'
f = fib(5)
print(f)

输出结果：<generator object fib at 0x01D87180>

generator跟函数的运行流程不同。韩式是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成生成器后经过next()调用，遇到yield语句返回，再次执行从上次返回的yield语句继续执行。

f = fib(5)
print(f)
print(f.__next__())
print(f.__next__())
print("作点其余的事")
print(f.__next__())
print(f.__next__())

<generator object fib at 0x00A27180>
1
1
作点其余的事
2
3

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

其实，一样的， 函数改成generator后，咱们也能够用for循环来迭代而不是next调用。

f = fib(5)
for i in f:
    print(i)

1
1
2
3
5

调用for循环后，会发现没法获得函数返回值，若是想拿到它，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

f = fib(5)
while True:
    try:
        x = next(f)
        print('F:',x)
    except StopIteration as e:
        print("Generator return value:", e.value)
        break

结果：
F: 1
F: 1
F: 2
F: 3
F: 5
Generator return value: done

 还可经过yield实如今单线程的状况下实现并发运算的效果　　

#!/user/bin/env python
# -*- coding: utf-8 -*-

import time


def consumer(name):
    print("%s准备吃包子啦!" % name)
    while True:
        baozi =  yield
        print("包子[%s]来了，被[%s]吃了!"%(baozi, name))


def producer():
    c1 = consumer('Dandy')
    c2 = consumer('Claire')
    c1.__next__()
    c2.__next__()
    print(' 师傅开始准备作包子啦！')
    for i in range(10):
        time.sleep(1)
        print('作了一个包子，分2半。')
        c1.send(i)
        c2.send(i)

producer()

Dandy准备吃包子啦!
Claire准备吃包子啦!
 师傅开始准备作包子啦！
作了一个包子，分2半。
包子[0]来了，被[Dandy]吃了!
包子[0]来了，被[Claire]吃了!
作了一个包子，分2半。
包子[1]来了，被[Dandy]吃了!
包子[1]来了，被[Claire]吃了!
作了一个包子，分2半。
包子[2]来了，被[Dandy]吃了!
包子[2]来了，被[Claire]吃了!
作了一个包子，分2半。
包子[3]来了，被[Dandy]吃了!
包子[3]来了，被[Claire]吃了!　

 

迭代器　　

咱们已经知道，能够直接做用于for销魂还得额数据类型有如下几种：一类是集合数据类型，入list, list, 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

 生成器都是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等却永远不可能存储总体的天然数。

小结

凡是可做用于for循环的对象都是Iterable类型(可迭代对象);

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

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

Python 的for循环其实本质上能够说，就是一个不断的调用next()函数的过程，例如

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

 彻底等价于：

# 首先得到Iterator对象
it = iter([1, 2, 3, 4])
#循环
while True:
    try:
        #获取下一个值：
        x = next(it)
    except StopIteration:
        #遇到StopIteration就退出循环
        break

 

2、装饰器

模拟一种状况，假如如今你手上的网站如今有如下几个模块

def home():
    print("---首页----")
 
def america():
    print("----欧美专区----")
 
def japan():
    print("----日韩专区----")
 
def dalu():
    print("----大陆专区----")

如今须要对这几个受欢迎的版块进行改版，好比大陆跟日韩专区须要收费，拿到这个需求后，先要让其进行用户认证，认证经过后再盘点是否是VIP，付费会员就能够观看。需求其实很简单，由于须要对多个板块进行认证，就须要写一个独立而且通用的模块，而后每一个版块调用它。

#!/user/bin/env python
# -*- coding: utf-8 -*-

user_status = False


def login():
    _username = 'dandy'  # 伪装是DB抓取的用户信息
    _password = 'password.1'
    global user_status

    if user_status == False:
        username = input("user:")
        password = input("password:")

        if username == _username and password == _password:
            print("Welcome login...")
            user_status = True
        else:
            print("Wrong username or password !")
    else:
        print("用户已登录，验证经过...")


def home():
    print("---首页----")


def america():
    print("----欧美专区----")


def japan():
    login()#验证
    print("----日韩专区----")


def dalu():
    login()#验证
    print("----大陆专区----")

 这时候你可能信心满满的去提交审核，没想到几分钟就被打回来。虽然代码是实现了功能，可是须要加认证在各个模块代码，这直接违反了软件开发的一个原则“开放-封闭”，简单来讲，就是规定了已经实现的功能代码不容许被修改，但能够扩展，即：

· 封闭：已实现的功能代码

· 开放：对扩展开放

这时候咱们能够利用高阶函数，把一个函数看成一个参数传给另一个函数。这样只须要写一个认证方法，每次调用须要验证的时候直接把功能的函数名看成参数传给须要验证的模块，就能够实现功能了。

 1 #!/user/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 user_status = False
 5 
 6 
 7 def login(func):
 8     _username = 'dandy'  # 伪装是DB抓取的用户信息
 9     _password = 'password.1'
10     global user_status
11 
12     if user_status == False:
13         username = input("user:")
14         password = input("password:")
15 
16         if username == _username and password == _password:
17             print("Welcome login...")
18             user_status = True
19         else:
20             print("Wrong username or password !")
21 
22     if user_status == True:
23         func()#只要验证经过就会调用相应的功能模块
24 
25 
26 def home():
27     print("---首页----")
28 
29 
30 def america():
31     print("----欧美专区----")
32 
33 
34 def japan():
35     # login()#验证
36     print("----日韩专区----")
37 
38 
39 def dalu():
40     # login()#验证
41     print("----大陆专区----")
42 
43 home()
44 login(america)
45 login(dalu)

View Code

很开心，美滋滋。终于实现了老板的要求，不改变原功能代码的前提下，给功能加上验证。可是这时候经理看到后发现你又犯了大忌，什么大忌？

改变了调用方式！如今全部须要认证的模块都须要从新调用你的login()方法并把本身的函数名传给你，别人以前可不是这么调用的，若是有100个模块这样调用是否是100个模块都要更改调用方式，可能模块跟方法是分开封装的，怎么去找那些模块呢？

如今让咱们提起来一个学过的知识：匿名函数（lambda）

def plus(n):
    return n+2
 
plus2 = lambda x:x+2

上面的2种写法是否是表明一样的意思？

给 lambda x:x+2 取了个名字叫plus2 ， 是否是至关于def plus2(x)

给函数赋值变量名就像def func_name 是同样的效果，以下面的plus(n)函数，你调用时能够用plus名，还能够再起个其余名字，如

calc = plus
 
calc(n)

以前的验证登录的代码：

home()
login(japan)
login(dalu)

之因此改变了调用方式，是由于用户每次调用时须要执行login(参数), 能够稍微改一下。

home()
japan= login(japan)
dalu = login(dalu)

这样调用dalu的时候，其实至关于调用了login(dalu)，经过login里面的验证后自动调用dalu的功能。

那就应该这样写

home()
japan= login(japan)#这里其实替换了japan函数
dalu= login(dalu)

#那用户调用时依然写
japan()

可是，问题在于内部已经有func(), japan= login(japan) 还没等用户调用，你就会内部执行这句的时候显把america执行了。应该是用户调用的时候再调用啊？

这里咱们又能够用到嵌套函数，想实现一开始写 japan= login(japan) 不触发你函数的执行只须要在login里面再定义一层函数，第一次调用 japan= login(japan)值调用到外层的login，这个login虽然会执行可是不会触发认证，由于认证的全部的代码都被封装在login里层的新定义的函数里， login只返回了里层的函数名，这样再执行japan()时，就会调用里层的函数。

可能你们也有点晕了，直接上代码：

def login(func):  # 把要执行的模块从这里传进来

    def inner():  # 再定义一层函数
        _username = 'dandy'  # 伪装是DB抓取的用户信息
        _password = 'password.1'
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("password:")

            if username == _username and password == _password:
                print("Welcome login...")
                user_status = True
            else:
                print("Wrong username or password !")

        if user_status == True:
            func()  # 只要验证经过就会调用相应的功能模块

    return inner  # 用户调用login的时候就会返回inner的内存地址，下次调用加上()才会执行inner函数

按照python对于装饰器的定义，咱们这时候能够把这个代码去掉：

japan= login(japan) #你在这里至关于把japan这个函数替换了

只须要在须要装饰的函数上面加上下面的代码：

 

def home():
    print("---首页----")


def america():
    print("----欧美专区----")


@login
def japan():
    # login()#验证
    print("----日韩专区----")


@login
def dalu():
    # login()#验证
    print("----大陆专区----")

效果同样。太棒了。

 

你开心的看着这一串代码，忽然又想试试能不能传参给版块：

@login
def japan():
    # login()#验证
    print("----日韩专区----")
japan("3p")

结果发现报错了。难道这个装饰器不能传参数么？

固然！若是不能传参数，还介绍了干吗

def login(func):  # 把要执行的模块从这里传进来

    def inner(arg1):  # 再定义一层函数
        _username = 'dandy'  # 伪装是DB抓取的用户信息
        _password = 'password.1'
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("password:")

            if username == _username and password == _password:
                print("Welcome login...")
                user_status = True
            else:
                print("Wrong username or password !")

        if user_status == True:
            func(arg1)  # 只要验证经过就会调用相应的功能模块

        return inner  # 用户调用login的时候就会返回inner的内存地址，下次调用加上()才会执行inner函数

咱们给inner函数加了个arg1参数func的地方也加了个arg1，这样调用会传到相应的版块。

再试一次呢？

def login(func):  # 把要执行的模块从这里传进来

    def inner(arg1):  # 再定义一层函数
        _username = 'dandy'  # 伪装是DB抓取的用户信息
        _password = 'password.1'
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("password:")

            if username == _username and password == _password:
                print("Welcome login...")
                user_status = True
            else:
                print("Wrong username or password !")

        if user_status == True:
            func(arg1)  # 只要验证经过就会调用相应的功能模块

    return inner  # 用户调用login的时候就会返回inner的内存地址，下次调用加上()才会执行inner函数

就这样咱们完成了装饰器与参数的调用。。。神奇吧。

下面贴上全部的代码：

 1 #!/user/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 user_status = False
 5 
 6 
 7 def login(func):  # 把要执行的模块从这里传进来
 8 
 9     def inner(*args, **kwargs):  # 再定义一层函数
10         _username = 'dandy'  # 伪装是DB抓取的用户信息
11         _password = 'password.1'
12         global user_status
13 
14         if user_status == False:
15             username = input("user:")
16             password = input("password:")
17 
18             if username == _username and password == _password:
19                 print("Welcome login...")
20                 user_status = True
21             else:
22                 print("Wrong username or password !")
23 
24         if user_status == True:
25             func(*args, **kwargs)  # 只要验证经过就会调用相应的功能模块
26 
27     return inner  # 用户调用login的时候就会返回inner的内存地址，下次调用加上()才会执行inner函数
28 
29 
30 def home():
31     print("---首页----")
32 
33 
34 def america():
35     print("----欧美专区----")
36 
37 
38 @login
39 def japan(style):
40     # login()#验证
41     print("----日韩专区----")
42 
43 
44 @login
45 def dalu():
46     # login()#验证
47     print("----大陆专区----")
48 
49 
50 japan('3p')

View Code

你很开心的带着代码去提交给经理。经理侃了也很满意。

 

次日，经理又提出了新的需求，须要容许用户选择用qq\weixin\weibo 认证。这时候对于你来讲一切就没那么难了。

#!/user/bin/env python
# -*- coding: utf-8 -*-

user_status = False


def login(auth_type):  # 把要执行的模块从这里传进来
    def auth(func):
        def inner(*args, **kwargs):  # 再定义一层函数
            if auth_type == 'qq':
                _username = 'dandy'  # 伪装是DB抓取的用户信息
                _password = 'password.1'
                global user_status

                if user_status == False:
                    username = input("user:")
                    password = input("password:")

                    if username == _username and password == _password:
                        print("Welcome login...")
                        user_status = True
                    else:
                        print("Wrong username or password !")

                if user_status == True:
                    func(*args, **kwargs)  # 只要验证经过就会调用相应的功能模块
            else:
                print('wrong qq auth.')
        return inner  # 用户调用login的时候就会返回inner的内存地址，下次调用加上()才会执行inner函数
    return auth


def home():
    print("---首页----")


def america():
    print("----欧美专区----")


@login('qq')
def japan(style):
    # login()#验证
    print("----日韩专区----")


@login('weixin')
def dalu():
    # login()#验证
    print("----大陆专区----")


japan('3p')
dalu()

View Code

 

 

3、Json & Pickle 数据序列化

用于序列化的两个模块

· Json，用于字符串 和python数据类型间的转换

· Pickle，用于python特有类型和python的数据类型间的转换

Json模块提供了四个功能：dumps、dump、loads、load

Pickle模块提供了四个功能：dumps、dump、loads、load

其实Python对于Json所写的封装功能已经很完美了，基本没什么好讲的了上代码吧：

#!/user/bin/env python
# -*- coding: utf-8 -*-
import json

dict_new = {'name': 'dandy',
            'age': 22,
            'salary': 30000
            }

with open("view2", 'w', encoding='utf-8') as fs:
    json.dump(dict_new, fs)#写入文件

咱们看下文件

而后

with open('view2', 'r', encoding='utf-8') as fs:
    dict_new = json.load(fs)
print(dict_new)

结果为：
{'name': 'dandy', 'age': 22, 'salary': 30000}

Pickle会加字符串转换成二进制：

import pickle

dict_new = {'name': 'dandy',
            'age': 22,
            'salary': 30000
            }
p_str = pickle.dumps(dict_new,)
print(p_str)
结果为一串二进制数：
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00dandyq\x02X\x03\x00\x00\x00ageq\x03K\x16X\x06\x00\x00\x00salaryq\x04M0uu.'

#写入文件二进制
with open('view3','bw')as fp:
    pickle.dump(dict_new, fp)

#读取文件
with open('view3','br')as fp:
    dict_new = pickle.load(fp)
print(dict_new)

结果：
{'name': 'dandy', 'age': 22, 'salary': 30000}

 

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之类的。

 

 

示例代码 https://github.com/triaquae/py3_training/tree/master/atm　

简易流程图：https://www.processon.com/view/link/589eb841e4b0999184934329