Python基础4

本节内容

　1.迭代器 & 生成器

　2.装饰器

　3.Json & pickle 数据序列化

　4.软件目录结构规范

 

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

列表生成式

首先, 看列表[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

 

二、装饰器

模拟一种情况，假如现在你手上的网站现在有以下几个模块

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("----大陆专区----")

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

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

· 开放：对扩展开放

这时候我们可以利用高阶函数，把一个函数当作一个参数传给另外一个函数。这样只需要写一个认证方法，每次调用需要验证的时候直接把功能的函数名当作参数传给需要验证的模块，就可以实现功能了。

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

user_status = False


def login(func):
    _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()#只要验证通过就会调用相应的功能模块


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


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


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


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

home()
login(america)
login(dalu)

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

改变了调用方式！现在所有需要认证的模块都需要重新调用你的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函数

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

下面贴上所有的代码：

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

user_status = False


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

    def inner(*args, **kwargs):  # 再定义一层函数
        _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)  # 只要验证通过就会调用相应的功能模块

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


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


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


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


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


japan('3p')

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

 

第二天，经理又提出了新的需求，需要允许用户选择用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()

 

 

三、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}

 

四、软件目录结构规范

为什么要设计好结构目录？

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

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