【python自动化第四篇：python入门进阶】

【python自动化第四篇：python入门进阶】

目录：

1. 装饰器
2. 迭代器&生成器
3. json&pickle实现数据的序列化
4. 软件目录结构规范

一、装饰器

　　装饰器的本质是函数，起目的就是用来为其它函数增加附加功能

　　原则：不能修改被装饰函数的源代码；被装饰函数的调用方式不能改变  ，简而言之就是转时其对于函数就是透明的，对被装饰的函数是没有影响的。

　　实现装饰器的知识储备：函数即变量；高阶函数；嵌套函数；最终高阶函数加上嵌套函数就构成了装饰器，函数也就是一种变量

　　知识点介绍：

　　　　函数即变量

　　　　高阶函数：

　　　　　　　　a.把一个函数名仿作实参传给另外一个函数（不修改装饰函数源代码的情况下为其添加功能）

1 2 3 4 5 6 7 8 9 10 11

import time def test1(func):     start_time = time.time()     func()     stop_time = time.time()     print("toyal %s"%(stop_time-start_time)) def bar():     time.sleep(3)     print("in the  bar!!")   test1(bar)                                             #其中，test1相当于是一个装饰器，但不完全是。test1(bar)

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

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/env python # -*- coding:utf-8 -*- import time def test1(func):     print(func)     return func def bar():     time.sleep(3)     print("in the  bar!!")   bar = test1(bar) bar()

　　　　　　嵌套函数：

1 2 3 4 5 6 7 8 9

#!/usr/bin/env python # -*- coding:utf-8 -*- #函数的嵌套 def foo():     print("hello World")     def bar():         print('in the bar!!')      bar() foo()

　　　　然后就是装饰器了：说白了装饰器就是高阶函数和嵌套函数的结合

　　　　装饰器的一个栗子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import time ##装饰器部分 def timer(func):     def deco():         start_time = time.time()         #return func()         func()         stop_time = time.time()         print("total is %s:"%(stop_time-start_time))     return deco @timer    #调用装饰器 ##test1和test2函数相当于是源代码，然而一直没改变原代码而是显得功能添加，这就是装饰器达成的效果 def test1():     time.sleep(1)     print('test1') @timer    #装饰器外城函数名 def test2():     time.sleep(2)     print("test2") test1() test2()

　　

　　要是传入了参数，就利用参数组修改：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
def timer(func):
    def deco(*args):                                  #如果带了参数组，下面源代码中的参数传递就可以被调用了
        start_time = time.time()
        func(*args)
        stop_time = time.time()
        print("total is %s"%(stop_time-start_time))
    return deco
@timer
def test1():
    time.sleep(0.1)
    print("heheheheh")
@timer
def test2(name):
    time.sleep(1)
    print("test2",name)
test1()
test2("wanghui")

 

 

 

2、生成器&迭代器

 Python 基础 内置函数 迭代器与生成器

今天就来介绍一下内置函数和迭代器 、生成器相关的知识

一、内置函数：就是Python为我们提供的直接可以使用的函数。

简单介绍几个自己认为比较重要的
1.#1.eval函数：（可以把文件中每行中的数据类型提取出来（之前是字符串类型））
a = "{'a':23,'b':43,'book':'english'}"
print(eval(a))

2.#2.hash(可以hash的数据类型是不可变数据类型)
a = 'alex'
b = hash(a)
print(b)

3.#zip 函数(组成一一对应的元组)（如果外面不加一个lis那没得到的就是一个zip对象）
print(list(zip(('a','b','c'),(1,2,3))))
print(list(zip(('a','b','c'),(1,2,3,4))))
print(list(zip(('a','b','c','d'),(1,2,3))))

p = {'name':'alex','age':23,'gender':'male'}
print(list(zip(p.keys(),p.values())))
输出结果为：
[('a', 1), ('b', 2), ('c', 3)]
[('a', 1), ('b', 2), ('c', 3)]
[('a', 1), ('b', 2), ('c', 3)]
[('name', 'alex'), ('age', 23), ('gender', 'male')]

# #max 和 min 函数
# l = [
#     (5,'e'),
#     (2,'b'),
#     (3,'c'),
#     (6,'d')
# ]
#
# print(list(max(l)))
# #max 函数的两点说明：
# #1.max处理的是可以迭代的对象，相当于for循环取出每个元素进行比较，不同数据类型之间不可以比较
# #2.每个元素之间的比较是从每个元素的第一个位置依次比较，如果此位置可以区分出大小，后面就不需要比较了，直接得出这两个元素的大小
#
#
# #sorted函数的使用(都是按照从小到大的顺序进行排列)
#
# name_dict ={
#     'yuanhao':80,
#     'alex':99,
#     'wupeiqi':700
# }
# print(sorted(name_dict))
# print(sorted(name_dict,key = lambda key:name_dict[key]))
#

内置函数的补充：

1.对数据的进制转化
a = hex(12)#10转16
b = bin(12) #10转 2
c = oct(12) #10 转8
print(a)
print(b)
print(c)

#输出结果为：
0xc
0b1100
0o14

2.数字转字母，字母转数字
a = ord('A')
b = chr(99)
print(a,b)
输出结果：65 c

3.divmod 取余函数（用在做网页的文章分页）
c = divmod(10,3)
print(c)
输出结果：(3, 1)  #3余数为1

4.求次方函数
d = pow(2,3)
e = pow(2,3,4)
print(d,e) #d:2的3次方；e:2的3次方对4取余

5.reversed函数取翻转

6.round（） #四舍五入函数

二、迭代器协议与生成器

    1.迭代器协议：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

    2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

    3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

三、Python中强大的for 循环机制  

    for循环的本质：循环所有对象，全都是使用迭代器协议。

    很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字         典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，我他妈的为什么定义一个列表l=[1,2,3,4]没有l.next()方法，打脸么。

    (字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象

    然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代

    

#2.for循环内部实现的机制

l = [1,2,3,4]

for i in l:#（i_1 = l._iter__() / i_l.__next__()）
    print(i)

iter_l = l.__iter__()#遵循迭代器协议，生成可以迭代的对象
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())

#通过while循环实现遍历列表
l = [1,3,5]
index = 0
while index <len(l):
    print(l[index])
    index +=1

#集合中使用迭代器
s = {1,2,3}
iter_s = s.__iter__()
print(iter_s)
print(iter_s.__next__())
print(iter_s.__next__())
print(iter_s.__next__())

#字典中使用迭代器
d = {'alex':44,'egon':56}
iter_d = d.__iter__()#默认迭代的是key值
print(iter_d.__next__())
print(iter_d.__next__())

#文件中使用迭代器
with open('test','r+') as f:

    iter_f = f.__iter__()
    print(iter_f.__next__(),end = '')#通过end参数解决了不是以默认的方式换行的问题
    print(iter_f.__next__(),end = '')
    print(iter_f.__next__(),end = '')

#文件关闭后对文件的操作就会报错
f=open('test','r')
iter_f = f.__iter__()
print(iter_f.__next__())
#f.close()
print(iter_f.__next__())

'''

四、生成器   

    可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象 

    生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

    1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

    2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

    为何使用生成器之生成器的优点

   Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

   生成器小结：

   1.是可迭代对象

   2.实现了延迟计算,省内存啊

   3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！

    

 1 def test():
 2     yield 1
 3     yield 2
 4     yield 3
 5 g=test()#写完此句才是生成器对象
 6 print('来自函数',g)#来自函数 <generator object test at 0x02170CC0>
 7 # print(g.__next__())#生成器内部有next方法，直接调用就ok
 8 # print(g.__next__())
 9 # print(g.__next__())
10 
11 #三元表达式
12 name='alex'
13 name='linhaifeng'
14 res='SB' if name == 'alex' else '帅哥'
15 print(res)
16 
17 #列表解析
18 #通过for循环的形式实现原理
19 egg_list=[]
20 for i in range(10):
21     egg_list.append('鸡蛋%s' %i)
22 print(egg_list)
23 #列表解析的表达形式
24 l=['鸡蛋%s' %i for i in range(10)]#%后面相当于一个要传给前面的一个参数
25 l1=['鸡蛋%s' %i for i in range(10) if i > 5 ] #列表解析中的三元表达式形式
26 # # l1=['鸡蛋%s' %i for i in range(10) if i > 5 else i] #没有四元表达式
27 # l2=['鸡蛋%s' %i for i in range(10) if i < 5] #没有四元表达式
28 
29 print(l)
30 print(l1)
31 # print(l2)
32 
33 #生成器表达式
34 laomuji=('鸡蛋%s' %i for i in range(10)) #生成器表达式，就是把列表解析中的[]换成（）
35 print(laomuji)
36 print(laomuji.__next__())
37 print(laomuji.__next__())
38 print(next(laomuji))
39 print(next(laomuji))
40 print(next(laomuji))
41 print(next(laomuji))
42 print(next(laomuji))
43 print(next(laomuji))
44 print(next(laomuji))
45 print(next(laomuji))
46 # print(next(laomuji)) 报错： StopIteration
47 
48 '''
49 '''
50 #生成器函数
51 import time
52 def test():
53     print('开始生孩子啦。。。。。。')
54     print('开始生孩子啦。。。。。。')
55     print('开始生孩子啦。。。。。。')
56     yield '我' #yield 相当于return 作用就是做返回值用
57     time.sleep(3)
58     print('开始生儿子啦')
59     yield '儿子'
60 
61     time.sleep(3)
62     print('开始生孙子啦')
63     yield '孙子'
64 
65 
66 res=test()#执行此句只是在定义一个生成器对象
67 print(res)#<generator object test at 0x00700D20>
68 print(res.__next__()) #test()
69 print(res.__next__()) #test()
70 print(res.__next__()) #test()

实现生产者和消费者模型的例子：

#实例：实现生产者消费者模型
#通过生成器实现协程并行运算
import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield 1 #yield 的第二个作用就是接受send传过来的参数赋值给包子变量

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    print( c.__next__())
    print(c2.__next__())
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)#send 函数实现了向yield函数传递参数的作用
        c2.send(i)

producer("alex")

生成器中send（）方法的应用

#send 参数的实例演示
#yield 相当于return 控制的是函数的返回值
#x = yield  的另外一个特性就是接受send传过来的值并且把值付给x

def test():
    print('开始啦')
    first = yield 1 #return 1 first = None
    print('第一次',first)
    yield 2
    print('第二次')

t = test()
res = t.__next__()# -->next()
print(res) #res取得是yield的返回值

t.send(None)

计算结果为：
开始啦
1
第一次 None

生成器总结：

综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结

• 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
• 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
• 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行

优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

优点二：生成器还能有效提高代码可读性

 

 

 

3、 json&pickle实现数据的序列化

         json 与pickle 是一种序列化的数据格式，在学json与pickle 之前呢，我们是接触过eval 函数的，这个函数是干嘛用的呢？其实这个函数就是提取字符串中的数据类型的。刚学会的时候感觉好牛逼，but,eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

#---转换类型

d={"name":"yuan"}

s=str(d)

print(type(s))

d2=eval(s)

print(d2[1])

with open("test") as f:

    for i in f :

        if type(eval(i.strip()))==dict:
            print(eval(i.strip())[1])
            

 

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

    现在就先介绍一下牛逼的json：

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

    这几天都是把数据存入和取出文本文件，用json类型的“字符串”进行操作，在这个过程中出现过很多的错误，今天就对我之前跳过的坑做一次总结吧！

先看一下json在文本文件中的使用情况：

#----------------------------序列化
import json

dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>

data=json.dumps(dic)
print("type",type(data))#<class 'str'>
print("data",data)


f=open('序列化对象','w')
f.write(data)  #-------------------等价于json.dump(dic,f)
f.close()


#-----------------------------反序列化<br>
import json
f=open('序列化对象')
new_data=json.loads(f.read())#  等价于data=json.load(f)

print(type(new_data))

看起来操作很简单吧，没错他就会给你这种假象，然后你自己操作一下就掉坑里去了！看起来没啥问题是吧，那我就给你找个问题你看看哈

 

def oo():
    with open('new_hello','r') as f:
        #for i in f:
            data = json.loads(f.read())
            # print(data)
            # ret.append(data)
            return data

res = oo()
print(res)

1.从上面的代码你就会看出我是一次性把文件中的内容加载在内存中，然后就loads打印了，这个当然会报错了，json是一行行取数据的，你这样操纵的话，后面一行就会覆盖前面的一行，这样一定会出问题的呀！so,你该如何做就不用我多说了吧，只能循环遍历输出了，这是解决这一问题的办法之一，

在使用json中要注意的问题：

import json
#dct="{'1':111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}

dct='{"1":"111"}'
print(json.loads(dct))

#conclusion:
#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化对象_pickle','rb')
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 
 
print(data['age'])

    Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

最后呢，也对json进行一下总结：

Json简介：Json，全名 JavaScript Object Notation，是一种轻量级的数据交换格式。Json最广泛的应用是作为AJAX中web服务器和客户端的通讯的数据格式。

Encode过程，是把python对象转换成json对象的一个过程，常用的两个函数是dumps和dump函数。两个函数的唯一区别就是dump把python对象转换成json对象生成一个fp的文件流，而dumps则是生成了一个字符串：

Decode过程，是把json对象转换成python对象的一个过程，常用的两个函数是loads和load函数。区别跟dump和dumps是一样的。