python学习第四天

一、闭包函数

1.1闭包的概念

#如下，外层函数out内定义了inner函数，inner函数在被调用时，
#打印x;首先inner找自己内部是否有x;没有则向上一层找，
#在上一层(out)中存在x,则不会再向上寻找，
#如此形式为闭包
x='全局'
def out():
    x=1
    def inner():
        print(x)
    return inner
out()()

x='全局'
def out(x):
    def inner():
        print(x)
    return inner
out(x=3)()

1.2闭包的意义

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

二、装饰器

2.1装饰器的概念

装饰器是闭包函数的一种应用场景。本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。强调装饰器的原则：1 不修改被装饰对象的源代码 。2 不修改被装饰对象的调用方式 。装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

2.2装饰器的使用

# 无参装饰器
# 场景：有如下函数index，需要在不更改函数代码和其调用方式的前提下，
# 为函数index增加计算其执行时间的功能
# import time
# def index(user):
#     time.sleep(3)
#     print('welcome %s '%user)
# index('tom')
import time
from functools import wraps #该模块用于使被装饰前与被装饰后的函数介绍等信息保持一致

def timmer(func):
    @wraps(func) #使被装饰前与被装饰后的函数介绍等信息保持一致
    def inner(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs) #使被装饰前与被装饰后，函数的返回值保持一致
        stop_time=time.time()
        print('time is [%s]'%(stop_time-start_time))
        return res
    return inner
@timmer #相当于index=timmer(index)
def index(user):
    '''
    print welcome
    :return: ok
    '''
    time.sleep(3)
    print('welcome %s'%user)
    return 'ok'

index('tom')
help(index)

#有参装饰器
#场景：有如下函数index，需要在不更改函数代码和其调用方式的前提下，
# 为函数index增加计算其执行时间的功能
#增加一个用户认证功能，认证根据与参数选择是通过文件提取认证比对信息
# 或通过数据库提取认比对信息
# import time
# def index(user):
#     time.sleep(3)
#     print('welcome %s '%user)
# index('tom')
import time
from functools import wraps #该模块用于使被装饰前与被装饰后的函数介绍等信息保持一致
def auth(dirver): #该层用来给新增加的认证功能传参数，可以满足所有传参数的需求，所以有参装饰器最多三层足够
    def auth2(func):#如果直接在该层传参数，会改变原函数的执行方式
        def inner(*args,**kwargs):
            if dirver=='file':
                user='tom'#从文件中提取用户名和密码的过程省略
                password='123'
            elif dirver=='db':
                user='tom'
                password='123'
            user_name=input('name> ')
            user_password=input('password> ')
            if user_name==user and user_password==password:
                print('login successful')
                func(*args,**kwargs)
        return inner
    return auth2



def timmer(func):
    @wraps(func) #使被装饰前与被装饰后的函数介绍等信息保持一致
    def inner(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs) #使被装饰前与被装饰后，函数的返回值保持一致
        stop_time=time.time()
        print('time is [%s]'%(stop_time-start_time))
        return res
    return inner
@auth('file')
@timmer
def index(user):
    '''
    print welcome
    :return: ok
    '''
    time.sleep(3)
    print('welcome %s'%user)
    return 'ok'

index('tom')
help(index)

2.3装饰器语法

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

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

三、迭代器

3.1迭代器的概念和意义

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

3.1.1、为何要有迭代器？

对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

3.1.2、什么是可迭代对象？

可迭代对象指的是内置有__iter__方法的对象，即obj.iter，如下
'hello'.iter
(1,2,3).iter
[1,2,3].iter
{'a':1}.iter
{'a','b'}.iter
open('a.txt').iter

3.1.3、什么是迭代器对象？

可迭代对象执行obj.iter()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象
迭代器对象执行obj.iter()得到的还是其本身

文件类型是迭代器对象

open('a.txt').__iter__()
open('a.txt').__next__()

3.1.4、注意：

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

3.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
#这么写太丑陋了，需要我们自己捕捉异常，控制next，python这么牛逼，能不能帮我解决呢？能，请看for循环

#基于for循环，我们可以完全不再依赖索引去取值了
dic={'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])

#for循环的工作原理
#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

3.3迭代器的优缺点

优点： - 提供一种统一的、不依赖于索引的迭代方式 - 惰性计算，节省内存
缺点： - 无法获取长度（只有在next完毕才知道到底有几个值） - 一次性的，只能往后走，不能往前退

四、生成器

4.1生成器的概念

只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')

g=func()
print(g) #<generator object func at 0x0000000002184360> 

g.__iter__
g.__next__
#所以生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)

4.2生成器的应用

#场景：模拟range函数
def my_ragne(start,stop,step=1):
    while start < stop:
        yield start
        start+=step

x=my_ragne(1,7)
print(next(x))
print(next(x))

#应用于for循环
for i in my_range(1,7,2):
    print(i)
#
#协程函数
#yield关键字的另外一种使用形式：表达式形式的yield
def menu():
    print('开始点菜')
    food_list=[]
    while True:
        food=yield food_list #先将send的值赋值给food；然后return food_list作为此次执行函数的返回值
        print('您点了：%s'%food)
        food_list.append(food)

g=menu()
g.send(None) #send方法触发一次next，并把其参数传递给yield；#对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g)
g.send('包子')
all=g.send('蒸羊羔')
print(all)

五、三元表达式

#if的单行结构
name=input('姓名>>: ')
res='SB' if name == 'alex' else 'NB'
print(res)

六、列表推导式

#1、示例
egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s' %i)
egg_list=['鸡蛋%s' %i for i in range(10)]

#2、语法
[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、优点：方便，改变了编程习惯，可称之为声明式编程

七、生成器表达式

#1、把列表推导式的[]换成()就是生成器表达式

#2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性
>>> chicken=('鸡蛋%s' %i for i in range(5))
>>> chicken
<generator object <genexpr> at 0x10143f200>
>>> next(chicken)
'鸡蛋0'
>>> list(chicken) #因chicken可迭代，因而可以转成列表
['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4',]

#3、优点：省内存，一次只产生一个值在内存中