python初识day4

本节内容：

• 列表生成式，生成器&迭代器
• 装饰器
• 软件目录结构规范

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

---

列表生成式

引子：现在有个需求，[0,1,2,3,4,5,6,7,8,9],要求把列表里的每一个值加一，你该怎么实现？这里有两种方式。

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]

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

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

 基础语法格式：

[exp for iter_var in iterable]

工作过程：

• 迭代iterable中的每个元素；
• 每次迭代都先把结果赋值给iter_var，然后通过exp得到一个新的计算值；
• 最后把所有通过exp得到的计算值以一个新列表的形式返回

#相当于这样的过程：
L = []
for iter_var in iterable:
    L.append(exp)

带过滤功能语法格式： 

[exp for iter_var in iterable if_exp]

工作过程：

• 迭代iterable中的每个元素，每次迭代都先判断if_exp表达式结果为真，如果为真则进行下一步，如果为假则进行下一次迭代；
• 把迭代结果赋值给iter_var，然后通过exp得到一个新的计算值；
• 最后把所有通过exp得到的计算值以一个新列表的形式返回。

#相当于这样的过程：
L = []
for iter_var in iterable:
    if_exp:
        L.append(exp)

循环嵌套语法格式：

[exp for iter_var_A in iterable_A for iter_var_B in iterable_B]

工作过程：

#每迭代iterable_A中的一个元素，就把ierable_B中的所有元素都迭代一遍。
#相当于这样的过程：
L = []
for iter_var_A in iterable_A:
    for iter_var_B in iterable_B:
        L.append(exp)

应用场景：

其实列表生成式也是Python中的一种“语法糖”，也就是说列表生成式应该是Python提供的一种生成列表的简洁形式，应用列表生成式可以快速生成一个新的list。它最主要的应用场景是：根据已存在的可迭代对象推导出一个新的list。

生成器

引子：通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

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

 L = [x * x for x in range(10)]
print(L)

#输出[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

#输出<generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

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

print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
#输出：
0
1
4
9
16
25
36

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

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

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 = n + 1
    return 'done'

 注意赋值语句：

a, b = b, a + b
#相当于
t = (b, a+b)   #t是一个元组
a = t[0]
b = t[1]

但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数：

fib(10)
#输出：
1
1
2
3
5
8
13
21
34
55

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

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

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

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done' 

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

f = fib(6)
print(f)

#输出
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

f = fib(10)
print(f)

print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print("忽略我")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())


#输出
<generator object fib at 0x00000246042E7308>
1
1
2
3
5
忽略我
8
13
21
34

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

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

for n in fib(6):
    print(n)

#输出
1
1
2
3
5
8

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
#输出：
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

关于如何捕获错误，后面的错误处理还会详细讲解。

 迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

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

还有就是generator，包括生成器和带yield的generator function。

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

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

from collections import Iterable
print(isinstance([], Iterable))
print(isinstance({}, Iterable))
print(isinstance((), Iterable))
print(isinstance("bbd", Iterable))
print(isinstance(100, Iterable))


#输出
True
True
True
True
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是永远不可能存储全体自然数的。

小结：

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

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

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

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

 二、装饰器

---

 先介绍背景：一家公司在招聘员工，面试题是：公司有1w个函数，现在老板给的需求是：加一个功能，统计每个函数用的时间？

第一个人A来面试说：

#简单：
#假设原函数func
import time
func()
    start = time.time()
    #原来函数的一堆
    end = time.time()
    print(end - start)
#这不就OK了吗？

但是很不幸A并没有收到offer，于是发了份邮件询问，然鹅公司并没有理他，哈哈哈哈哈。

过了几天A的同学B也想来面试，为了以防万一出同类型题，于是思考了：A这么做是不对的，A不能修改函数内部的代码，不能重构原来的代码。

到了面试，哇哈哈哈哈面试体竟然不改，心想：这是看不起你B大爷吗？本大爷这就用本大爷的妙招虐虐你：

#编一个新函数将原函数当参数传进去只想一下不久ok了吗？
#原函数func

import time
def new(func)
    start = time.time()
    func()
    end = time.time()
    print(start - end)

B得意的写完后，面试官摇了摇头就将B的卷子丢进垃圾筐没在里踩过。

B也没有收到offer，不甘心于是问问他的师傅C自己写的有啥毛病没？

C语重心长地说：孩子你还年轻，找找别的出路吧，人家是让你家功能的意思是执行原函数（func），也不改变源码但是可以实现功能，你这么改，本来人家用func现在是不是先写个new在写func才能将功能实现1w条，累死人家程序员了吧.

B死皮赖脸的和师傅修行了一段时间，再次去面试了，面对的还是同样的题，心想：哈哈，师傅在手，天下我有。于是开始写开代码：

#原函数func

import time
def new(func):
    def inner():
        start = time.time()
        func()
        end = time.time()
　　　　　print(end - start)
    return inner

func = new(func)
func()

面试官看着B的答案，又看了一看B哇塞挺漂亮的美女啊，于是若有所思的想了一下说：func这个函数也许有返回值呢？有参数呢？还不止一个参数怎么办？你这么写的话func函数的功能能完全实现吗？

B妹子回去想了想联系了下师傅，写了下面几个方案：

#原函数func
#有返回值
import time
def new(func):
    def inner():
        start = time.time()
        ret = func()
        end = time.time()
　　　print(end - start)
        return ret
    return inner

func = new(func)
ret = func() #这里相当于执行inner函数
print(ret)

#原函数 func(a)

#有返回值
import time
def new(func):
    def inner(a):
        start = time.time()
        ret = func(a)
        end = time.time()
　　　print(end - start)
        return ret
    return inner

func = new(func)
ret = func(a) #这里相当于执行inner函数
print(ret)

#原函数func(a,b)
#有返回值
import time
def new(func):
    def inner(*args,**kwargs):
        start = time.time()
        ret = func(*args,**kwargs)
        end = time.time()
　　　print(end - start)
        return ret
    return inner

func = new(func)
ret = func(a,b) #这里相当于执行inner函数
print(ret)

终于实现了功能，传说中的装饰器函数也完整的写出来了。

师傅说孩子上次的条件咱们说好了哈，别忘了你可是说好要以身相许的，为师现在可要吧看家本领拿出来了哈：用装饰器函数还要写一遍赋值func = new(func)但是用语法糖给被装饰函数函数前一写，这句就也可以省略了，那样是不是就更加高大上了是不是？

def wrapper(func1):    #装饰器函数
    def inner(*args, **kwargs):
        #被装饰之前要干的事
        ret = func1(*args, **kwargs)
        #被装饰之后要干的事
        return ret
    return inner

@wrapper    #语法糖
def func1(a, b):    #原函数
    print(a, b)
    return "cc"


#执行时
ret1 = func1(1, 2)
print(ret1)

 终于low B如愿以偿收到了offer，哈哈哈哈。

但是进公司后对B妹子耿耿于怀的面试官问了问B：你有梦想吗？你想更牛逼吗？晚上加个班我给你说下更牛逼的存在？

对技术痴狂的B终于经受不住诱惑开始了新的学习之路：

现在的需求是：这1w个函数每个函数打印一个话，但是有的是一样的话有的不一样。

B说那就多写一些函数呗，面试官就说，那你怕是在公司里带不了太久，除非我教你，嘻嘻。.......之后，于是开始了教学：装饰器函数其实写一个就够了，装饰器函数也是可以传参数的，根据穿传进去的参数的不同，判断参数进行不一样的操作就就好了。

例子：

还有就是函数如果被两个装饰器调用的话优势怎样的结果呢？

例子：

终于全剧终

三、软件目录结构规范

---

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

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

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文件等，我没有列在这里，因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件，目录该如何组织，可以参考这篇文章：https://jeffknupp.com/blog/2013/08/16/open-sourcing-a-python-project-the-right-way/。

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

关于README的内容

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

它需要说明以下几个事项:

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

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

可以参考Redis源码中Readme：https://github.com/antirez/redis#what-is-redis的写法，这里面简洁但是清晰的描述了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包依赖都装好了。具体格式说明： 点这里：https://pip.readthedocs.io/en/1.1/requirements.html。

关于配置文件的使用方法

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

面试题小分享

---