学习python第四天

一、闭包

二、装饰器

三、迭代器

四、生成器

五、函数面相过程

六、三元表达式

七、序列化

一、闭包

什么是闭包：

返回的函数对象，不仅仅是函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包过的作用域

应用领域：延迟计算（原来我们是传参，现在我们是包起来）

from urllib.request import urlopen

def index(url):
　　def get():
　　　　return urlopen(url).read()
　　return get
baidu=index('http://www.baidu.com')
print(baidu().decode('utf-8'))

二、装饰器

什么是装饰器：

装饰器他人的器具，本身同样是函数的形式，被装饰者，同样是函数的形式

装饰器的原则：

1.不修改被装饰对象的源代码

2.不修改被装饰对象的调用方式

1）无参装饰器

import time
def timel(func):   #设置参数便于出入index函数
    def webapper(*args,**kwargs):#设置接收所有多余的参数
        start_time=time.time()
        res=func(*args,**kwargs)设置res为调用函数的返回值
        stop_time=time.time()
        print("stop time %s" % (start_time-stop_time))
        return res 返回res
    return webapper 返回值设置
@timel #@timel=  index=timel(index) 整下方必须是被装饰体
def index():
    time.sleep(3)
    print('from index')

index() 在不改变源代码和调用方式的情况下调用变量

2）有参装饰器

def auto(driver='file'): #装饰器中自带参数driver
    def auto2(func): 
        def webapper(*args,**kwargs):
            name=input('name:')
            passwd=input('passwd:')
            if driver == 'file':
                if name == 'sunjingguo' and passwd == '123':
                    print('login ok')
                    res=func(*args,**kwargs) #这里的*，**替代了foo函数中的name，没有的话会报错，确保foo函数从inprint中调取name的值
                    return res
            elif driver == 'ldap':
                print('mysql')
        return webapper
    return auto2
@auto()#参数中自带默认值，可以不填写参数
def foo(name):
    print(name)
foo('sunjingguo')

3）装饰器语法

被装饰函数的正上方，单独一行
@deco1
@deco2
@deco3
def foo():
pass

foo=deco1(deco2(deco3(foo)))

练习题：

编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
注意：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式

def auto(func):
    def webapp(*args,**kwargs):
        file='userinfo.txt'
        name=input('user name: ')
        passwd=input('passwd: ')
        with open('userinfo.txt',encoding='utf-8') as read_f:
            dic=eval(read_f.read()) #eval函数时间字符串转化为列表，字典，元组。前提是字符串是相同格式存储方式
        if name in dic and passwd == dic[name]:
            print('login ok')
            res=func(*args)
            return res
    return webapp
@auto
def index():
    print('index')
@auto
def home(name):
    print('welcome %s to home' %name)
home('sunjingguo')#设定函数时，添加了形参，所以调用时也需要添加参数

阿道夫

三、迭代器

迭代器的概念：

迭代是个重复的过程，每次重复及时一次迭代，并且每次迭代的结果都是下次迭代的初始值

迭代器使用的场景：

针对序列类型：字符串，列表，元组取值时我们可以通过下标值来获取相应的值，但对字典，集合，文件这些无序的类型，就没有什么办法了，只能通过迭代器来获取相关的值了。

什么是可迭代对象：

可迭代对象是指内置有_iter_方法的对象，即“hello”._iter_

字符串，元组，列表，字典，文件都属于可迭代对象

什么是迭代对象：

可迭代对象执行‘hello’._iter_方法后得到的结果就是迭代对象

迭代对象具有内置_iter_和_next_方法的，就是迭代对象

注意：

迭代对象一定是可迭代对象，可迭代对象不一定是迭代对象

2）迭代器对象的使用

dic={'a':1,'b':2,'c':3}
iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身
iter_dic.__iter__() is iter_dic #True

print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
# print(iter_dic.__next__()) #抛出异常StopIteration，或者说结束标志

#有了迭代器，我们就可以不依赖索引迭代取值了
iter_dic=dic.__iter__()
while 1:
　　try:     #定义捕捉异常
　　　　k=next(iter_dic)
　　　　print(dic[k])
　　except StopIteration:     #指定捕捉到异常后的操作
　　　　break

for 循环的原理与上述问题类似;

先执行dic._iter_()方法将可迭代对象变成迭代对象，后执行next(iter_dic)将得到的值附给循环变量，执行循环体。重复上述操作，直到try捕捉到stoplteration后为止，结束循环。

3）迭代器的优缺点：

优点：

提供了一种统一的，不依赖与索引的迭代方式

逐条赋值，节省内存空间

缺点：

无法获取长度（只有在next完毕后才知道对象有几个值）

每次循环，只能依次循环不能回退

四、生成器

什么是生成器：

只要函数内部包括yield关键字，那么执行函数的结果就是生成器，并且不会执行函数内部代码，生成器包含迭代器的特性，所以生成器就是迭代器所以生成器取值的方式与迭代器相同。

 练习：

1、自定义函数模拟range(1,7,2)

def my_range(start,stop,step):
    while start < stop:
        yield start 
        start+=step
res=my_range(1,9,2)
print(next(res))
print(next(res))
print(next(res))

2、模拟管道，实现功能:tail -f access.log | grep '404'

import time
def tail(filepath):  #设置函数
    with open(filepath,'rb') as read_f: #以RB的方式打开文件
        read_f.seek(0,2) #将鼠标移到文件最后，0表示移动多少位，2，表示从文件结尾开始（0表示从文件开头开始，1，表示从当前位置开始，2，表示从文件末尾开始）
        while True:
            line=read_f.readline() #line等于每行的内容，现在line的形式是字节的形式
            if line: #如果line中有值
                yield line  #将line的值返回
            else:
                time.sleep(0.2)
def grep(pattern,lines):
    for line in lines:
        line=line.decode('utf-8')
        if pattern in line:
            yield line
for line in grep('404',tail('access.log')): #订制循环将上述函数传值
    print(line,end='')

3)yield关键字传值

def eater(name):
    print('%s 准备开始吃饭啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)
        
g=eater('egon')
g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g) 第一步初始化参数，否则会有相应的错误提示
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.close() 传值结束，关闭

总结yield

1.可以将函数做成迭代器

2.对比return，可以返回多次值，可以保存函数的运行状态

 五、函数面相过程

#1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序

#2、定义
面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么

基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

#3、优点：复杂的问题流程化，进而简单化

#4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身

#5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd

#6、举例
流水线1：
用户输入用户名、密码--->用户验证--->欢迎界面

流水线2：
用户输入sql--->sql解析--->执行功能

六、三元表达式

name=input('name')
res='NB' if name == 'sunjingguo' else 'SB' #三元表达式只针对简单的if判断形势，正确的值放在表达式的左侧，其余条件放在右侧
print(res)

egg_list=['egg%s' %i for i in range(10)]

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
类似于
res=[]
for item1 in iterable1:
if condition1:
for item2 in iterable2:
if condition2
...
for itemN in iterableN:
if conditionN:
res.append(expression)

#3、优点：方便，改变了编程习惯，可称之为声明式编程