Python的平凡之路（4）

一、迭代器&生成器

生成器定义：

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制称为生成器。

特点：

1 生成器只有在调用时才能生成相应的数据。

2 只有一个__next__（）方法

3 生成器表达式的语法和列表解析一样，只不过生成器表达式是被()括起来的，而不是[]

4 生成器是一种特殊的迭代器，内部支持了生成器协议，不需要明确定义__iter__()和next()方法

5 生成器通过生成器函数产生，生成器函数可以通过常规的def语句来定义，但是不用return返回，而是用yield一次返回一个结果。

 

列表生成式

譬如：

( i*2 for i in range(10))

等同于

a = [ ]

for i in range(10):

     a.append(i*2)

     print(i)

 

迭代器定义：

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

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

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

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

可以使用isinstance()判断一个对象是否是Utterable对象。

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

特点：

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

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

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

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

Python的for循环本质上就是通过不断调用next()函数实现的

3 举例：

Python的for循环本质上就是通过不断调用next()函数实现的， 对于可迭代对象，for语句可以通过iter()方法获取迭代器，并且通过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

 

生成器.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#这1亿个数并没有真正生成,调用的时候才生成。
b = (i*2 for i in range(100))
#b.__next__()) 的含义

for i in b:
    print(i)

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        #print(b)
        yield b #返回了函数的中断状态
        a, b = b, a + b
        n = n + 1
    return 'done'
print(fib(100))
f = fib(100)
print(f.__next__())
print("===========")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)

        break

 

迭代器.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
from collections import Iterable
#判断是不是可迭代对象
print(isinstance('abc',Iterable))
print(isinstance('[1,2,3]',Iterable))
print(isinstance('{"server":"192.168.1.10"}',Iterable))
print(isinstance((x for x in range(10)), Iterable))
print(isinstance(100,Iterable))
print("")
print("")
from collections import Iterator
#判断是不是迭代器对象
print(isinstance('abc',Iterator))
print(isinstance('[1,2,3]',Iterator))
print(isinstance('{"server":"192.168.1.10"}',Iterator))
#生成器肯定是迭代器
print(isinstance((x for x in range(10)), Iterator))

print(isinstance(100,Iterator))

 

 

二、装饰器

定义：

装饰器本质是函数，用来装饰其他函数，为其他函数添加函数功能

原则：

1 不能修改被装饰的函数的源代码

2 不能修改被装饰的函数的调用方式

实现装饰器知识储备：

1 函数即“变量"

2 高阶函数

 a 把一个函数当做实参传给另外一个函数(不修改源代码情况下添加功能）

 b 返回值中包含函数名(不修改函数的调用方式）

3 嵌套函数

举例：

qt.py

#!/usr/bin/env python
#Author is wspikh

# -*- coding: encoding -*-

def foo():
    print("in the foo")
    def bar():
     print("in the bar")
    bar()
foo()

4 高阶函数+嵌套函数=》装饰器

gj.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
import time
def bar():
    time.sleep(4)
    print('in the bar')
def test1(func):
    #print(func)
    start_time = time.time()
    func() #run bar
    stop_time = time.time()
    print("the fund run time is %s" %(start_time-stop_time))
#不能写成test1(bar()),因为bar()代表函数返回值

test1(bar)

 

装饰器.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
import time
#嵌套函数和高阶函数的融合
def timer(func):
    def deco():
        start_time=time.time()
        #return func()
        func()
        stop_time=time.time()

        print("the func run time is %s" %(start_time-stop_time))

    return deco #返回值中包含函数名(不修改函数的调用方式）//？

@timer #语法堂 test1=timer(test1)之所以还是用test1做变量是因为装饰器不改变被装饰函数的调用方式,
def test1():
    time.sleep(3)
    print("in the test1")

@timer #语法堂 test2=timer(test2)
def test2():
    time.sleep(3)
    print("in the test2")

test1()
test2()

 

 

三、Json & pickle 数据序列化

定义：

我们把变量从内存中变成可存储或传输的过程称之为序列化。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

特点：

1 序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上，在python中提供了两个模块可进行序列化。分别是pickle和json。

2 pickle是python中独有的序列化模块，所谓独有，就是指不能和其他编程语言的序列化进行交互,因为pickle将数据对象转化为bytes。pickle模块提供了四个功能：dumps、dump、loads、load。dumps和dump都是进行序列化，而loads和load则是反序列化。

3 如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

4 json中的方法和pickle中差不多，也是dumps，dump，loads，load。使用上也没有什么区别,区别在于，json中的序列化后格式为字符。

5 dumps将所传入的变量的值序列化为一个bytes，然后，就可以将这个bytes写入磁盘或者进行传输。dump则更加一步到位，在dump中可以传入两个参数，一个为需要序列化的变量，另一个为需要写入的文件。loads当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用loads方法反序列化出对象，也可以直接用load方法直接反序列化一个文件。

举例：

序列化和反序列化.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#import json
import pickle

def sayhi(name):
    print("hello",name)

sayhi("alex")

info = {
'age':22,
'name':'alex',
'func':sayhi
}
f = open("json.txt","wb")
#f.write(str(info))
f.write(pickle.dumps(info))

f.close()

#反序列化
f = open("json.txt","rb")
data = pickle.loads(f.read())
print(data)

f.close()

 

 

四、软件目录结构规范

目的：

软件目录层次清晰，可读性强。

举例：

假设你的项目名为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: 项目说明文件。