python学习 生成器/迭代器/闭包/装饰器

'''生成器:为了减少内存占用，创建一个计算方法，只有在调用时才会执行'''
#列表生成式：
a=[i*2 for i in range(10)]
print(a) #打印结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#创建生成器方法一：
b=(i*2 for i in range(10))
print(b)  #打印结果：<generator object <genexpr> at 0x00000231523E2B88>
print(next(b)) #打印结果：0
print(next(b)) #打印结果：2
print(next(b)) #打印结果：4

#创建生成器方法二 yield ：
#斐波那契数列指的是这样一个数列1、1、2、3、5、8、13、21、34、……这个数列从第3项开始，每一项都等于前两项之和
def fib():
    a,b=0,1
    for i in range(5):
        # print(b) #打印结果：1、1、2、3、5
        yield b
        a,b=b,a+b

#创建了一个生成器对象
a=fib()
#调用方法一：
print(a)  #打印结果：<generator object fib at 0x0000025E91382B88>
print(next(a))   #打印结果：1
print(next(a))   #打印结果：1
print(next(a))   #打印结果：2
print(next(a))   #打印结果：3
print(next(a))   #打印结果：5

#调用方法二：
for i in a:
    print(i)

#调用方法三：
for i in range(5):
    # print(next(a)) #等价于print(a.__next__())
    print(a.__next__())

#生成器-send传一个值
def test():
    i=0
    while i<5:
        num=yield i
        print(num)
        i+=1

a=test()
print(a.__next__())     #打印结果：0
print(a.send('hehe'))  #打印结果：hehe 1
print(a.__next__())     #打印结果：None 2
print(a.send('a'))  #打印结果：a 3
print(a.__next__())     #打印结果：None 4

def test1():
    i=0
    while i<5:
        if i==0:
            temp=yield i
            print(temp)
        else:
            yield i
        i+=1

a=test1()
print(a.send(None))  #打印结果：0
print(a.send('hh'))  #打印结果：hh 1
print(a.__next__())  #打印结果：2
print(a.__next__())  #打印结果：3

#使用yield完成多任务 ---相当于协程
def a1():
    while True:
        print('---1---')
        yield None

def a2():
    while True:
        print('---2---')
        yield None

a1=a1()
a2=a2()
while True:
    a1.__next__()
    a2.__next__()

 

'''迭代器'''
#迭代是访问集合元素的一种方法。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问为止。迭代器只能往前不会后退

#可迭代对象(Iterable)-有[],{},(),str,字典，列表生成式/器，这些可以直接作用于for循环的对象统称为可迭代对象
#判断是否是可迭代对象
from collections.abc import Iterable
print(isinstance([],Iterable))  #True
print(isinstance((i for i in range(5)),Iterable)) #True
print(isinstance((),Iterable))  #True
print(isinstance({},Iterable))  #True
print(isinstance('',Iterable))  #True
print(isinstance(10,Iterable))  #False

'''可迭代器(Iterator)-可以被next()函数调用并不断返回下一个值的对象成为迭代器
生成器一定是迭代器，但迭代器不一定是生成器'''
# #判断是否是迭代器
from collections.abc import Iterator
print(isinstance((i for i in range(5)),Iterator))  #生成器 True
print(isinstance([i for i in range(5)],Iterator))  #False
print(isinstance([],Iterator))  #False
print(isinstance((),Iterator))  #False
print(isinstance({},Iterator))  #False
print(isinstance('',Iterator))  #False
print(isinstance(10,Iterator))  #False

#创建迭代器-iter()函数
#生成器都是Iterator对象，但[],{},(),str,字典虽然是Iterable，却不是Iterator。
#把[],{},(),str,字典等Iterable变成Iterator(),可以使用iter()函数
a=[1,2,3,4,5]
b=iter(a)
print(b) #<list_iterator object at 0x00000157D19B66A0>
print(b.__next__())  #打印结果 1
print(b.__next__())  #打印结果 2

 

'''闭包'''
def test(num):
    print(num)
    #在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
    def test_in(number_in):
        print(number_in)
        return num+number_in
    #其实这里返回的就是闭包的结果
    print('hhhhh')
    return test_in

a=test(100)  #打印结果  100 hhhhh
print(a(10))  #打印结果  10 110
print(a(20))  #打印结果  20 120

#闭包的实际应用--简化代码调用方式，传参少了
def test(a,b):
    def test_in(x):
        print(x*a,b)
    return test_in

line1=test(1,1)
line1(0) #打印结果 0 1

line2=test(1,2)
line2(2)  #打印结果 2 2

 

'''装饰器'''
#-----装饰器原理-----
def w1(func):
    def inner():
        print('---正在验证权限---')
        func()
    return inner

def f1():
    print('--f1--')

def f2():
    print('--f2')

# a=w1(f1)
# a()
# b=w1(f2)
# b()

f1()
f1=w1(f1)  #这里相当于重新定义了f1()函数
f1()

#----装饰器运用----
def w1(func):
    def inner():
        print('---正在验证权限---')
        func()
    return inner

@w1    #等价于f1=w1(f1)
def f1():
    print('--f1--')

@w1    #等价于f2=w1(f2)
def f2():
    print('--f2')

f1()
f2()

#------两个装饰器-----
def testa(fn):
    def linea():
        print('--1--')
        return '<b>'+fn()+'<b>'
    return linea

def testb(fn):
    def lineb():
        print('--2--')
        return '<i>'+fn()+'<i>'
    return lineb

#只有python解释器执行到了这个代码，那么就会自动的进行装饰，而不是等到调用的时候才装饰
@testa
@testb   #当有多个装饰器时，是从下再往上装的。但是执行顺序还是从上往下的
def fn():
    print('--3--')
    return 'hello world'

#在调用fn之前，已经进行装饰了
res=fn()
print(res)

####打印结果：
# --1--
# --2--
# --3--
# <b><i>hello world<i><b>

#-----装饰器对有参数的函数进行装饰----
def func(functionName):
    print('func')
    def func_in(*args,**kwargs):
        functionName(*args,**kwargs)
    return func_in

@func
def test1(a,b):
    print('test1,{}-{}'.format(a,b))

@func
def test2(a,b,c):
    print('test2,{}-{}-{}'.format(a,b,c))

test1(1,2)
test2(3,4,5)

# ####打印结果：
# func
# func
# test1,1-2
# test2,3-4-5

#------------装饰器对带有返回值的函数进行装饰--------------
def fun(functionName):
    def func_in():
        aa=functionName() #保存返回来的hh
        return aa  #把hh返回到函数的调用
    return func_in

@fun
def test():
    print('test')
    return 'hh'

a=test()
print('result-{}'.format(a))

#------------通用装饰器--------------
def fun(functionName):
    def func_in(*args,**kwargs):
        print('日志打印')
        aa=functionName(*args,**kwargs)
        return aa
    return func_in

@fun
def test():
    print('test')
    return 'hh'

@fun
def test1():
    print('test1')

@fun
def test2(aa):
    print('test2-{}'.format(aa))

a=test()
print('result-{}'.format(a))
test1()
test2('aaa')

#------------带有参数的装饰器--------------
#带有参数的装饰器，能够起到在运行时，有不同的功能
def fun_arg(a1):
    def fun(functionName):
        def func_in(*args,**kwargs):
            print('日志打印:{}'.format(a1))
            if a1=='哈哈':
                functionName(*args,**kwargs)
                functionName(*args,**kwargs)
            else:
                functionName(*args, **kwargs)
        return func_in
    return fun

#1、先执行fun_arg('哈哈')函数，这个函数return的结果是fun这个函数的引用
#2、@func
#3、使用@func对test1进行装饰
@fun_arg('哈哈')
def test1():
    print('test1')

@fun_arg('嘻嘻')
def test2():
    print('test2')

test1()
test2()

 

#------------通用装饰器--------------
import functools
def fun(functionName):
    @functools.wraps(functionName)   ## 保证被装饰的函数对象的__name__不变
    def func_in(*args,**kwargs):
        print('日志打印')
        aa=functionName(*args,**kwargs)
        return aa
    return func_in

@fun
def a():
    print('test')
    return 'hh'

@fun
def a1():
    print('test1')

@fun
def a2(aa):
    print('test2-{}'.format(aa))

a=a()
print(a1.__name__)  #不加@functools.wraps(functionName)，打印结果是func_in。加了后，打印结果是a1
# print('result-{}'.format(a))
# a1()
# a2('aaa')

 

#__call__()方法返回的是一个函数的引用
class Test():
    def __init__(self):
        print('hhh')

    def __call__(self, *args, **kwargs):
        print('aaaa')

a=Test()
a() #__call__()方法起的作用

#类装饰器
class Test():
    def __init__(self,fun):
        print('hhh')
        fun()
        self.__fun=fun

    def __call__(self, *args, **kwargs):
        print('aaaa')
        self.__fun()

@Test
def test():
    print('--test--')

test()

#打印结果
# hhh
# --test--
# aaaa
# --test--