python基础之迭代器、生成器、装饰器（二）

迭代器

• 介绍

• 迭代是访问集合元素的一种方式。而迭代器是一个可以记住遍历位置的对象。迭代器的创建对象可以是字符串、列表或元组
• 迭代器从第一个访问到最后一个元素结束，且访问时只能往前不能后退。
• 迭代其基本方法：iter() 、next()

• 迭代器的创建与遍历

# next()输出
 		list=[1, 2, 3,4]
 		it = iter(list) # 创建迭代器对象
 		print（next(it))
 # for 循坏遍历
       for x in it:
       print(x, end="")
       

• 类迭代器

• 将一个类作为迭代器要使用__iter__()：返回一个特殊的迭代对象。
• 此对象实现__next__()方法并通过stopiteration（防止出现无限循环）异常表示迭代完成。

class fun：
   def __iter__(self):
      self.l = 20
      return self
   def __next__(self):
      if self.l <= 1:
	      x = self.l
	      self.l -= 1
	      return x
      else:
          raise StopIteration
 my = fun()
 myiter = iter(my)
 for x in myiter:
 	print(x)

生成器

• 生成器需要使用yield的函数才能被称之为generator，而它可以迭代的关键就是拥有一个next（）方法
• 但是区别于普通函数，生成器是一个返回的迭代器的函数，所以在每次运行是遇到yield时会暂停并保存当前记录的信息，返回yield的值， 在下一次执行next()方法时，从当前位置继续运行。

• 生成器的创建

• 1.0 创建一个类似列表生成式的方式
  g = (x*x for x in range(10))
• 2.0 函数中包含yield关键字

def yield_test(n):
    for i in range(n):
        yield call(i)
        print(i)
def call(i):
	return i*3
for i in yield_test(5):
	print(i, ",")

装饰器

闭包

• 闭包是函数式编程的重要语法结构，也是一种代码组织结构，提高了代码的可重复性实用性。
• 假如在一个内嵌函数中，对一个外部函数内的变量(局部）进行引用，那么该内嵌函数就是闭包

• 特点

• 必须有一个内嵌的函数
• 内嵌函数必须引用外部函数中的局部变量（此变量不可改写， 而且再外部函数生命周期结束之后，该变量依然存在，因为它被内嵌函数引用了， 没有被回收）
• 外部函数的返回值必须是内嵌函数

def func(name):					# 外部函数，name 局部变量（要被内嵌函数引用的变量）
 - def In_func(age):			# 内嵌函数
 	  print(name, age)			# 引用
   return In_func				# 返回内嵌函数
   

装饰器

• python中的装饰器就是实现了设计模式中的装饰器模式。
• 即在不想改变函数本身的代码的情况下，进行动态的增加该函数相关的功能。
• 装饰器可以装饰多个函数；一个函数可悲多个装饰器装饰，只不过遵循就近原则。
• 写装饰器的时候,不管装饰 功能 有参数 没有参 还是其他的参数 全部定义两个形参:*args,**kwargs

• 装饰多个函数

def outer(func):  # 1.形参 接受 原有功能函数名
    # print("外部函数")
    def inner():
        print("扩展功能.....")
        func()   # 2.再次调用原有功能
    return inner  # 3.必须将内部函数
    
@outer   # ====>  show=outer(show)
def show():
    print("功能1")
@outer  # show2=outer(show2)
def show2():
    print("功能2")
show()
show2()

• 装饰带参数的函数

def outer(func):
    def inner(*args,**kwargs): #
        print("扩展的功能")
        func(*args,**kwargs)
    return inner

@outer
def test1():
    print("功能1")
@outer
def test2(a):
    print(f"功能2传入的数据是{a}")
@outer
def test3(b=10):
    print(f"功能2传入的数据是{b}")

test1()
test2(10)
test3()
test3(20)
test3(b=50)

• 装饰器传参

• 装饰器传参不再是只有两层嵌套函数，一定是三层嵌套函数才可以起作用

 def big(a):
    def outer(func):
        print(f"func的是{func}")
        print("外部函数执行")

        def inner(*args, **kwargs):
            print("扩展功能....")
            func(*args, **kwargs)
        return inner
    return outer

@big(10)   
def test():
    print("功能1")

• 多层装饰器（就近原则）

 - def outer(func):  #2. func=普通功能函数
    print("装饰器1外部函数的执行")  # 3.打印装饰器1...
    def inner():                    # 4.装饰器1的内部函数定义
        print("扩展功能1")
        func()     # 重点:func绑定了普通功能函数

    return inner                # 5.返回装饰器1的内部函数定义
    
def outer2(func):  # 8.func = 装饰器1的内部函数定义
    print("装饰器2外部函数的执行")  # 9.打印装饰器2...
    def inner():                  # 10.定义装饰器2 的内部函数
        print("扩展功能2")
        func()    # 重点:func 绑定 装饰器1的内部函数定义

    return inner     # 11.反回 装饰器2 的内部函数

@outer2   # 7.test=outer(test:装饰器1的内部函数定义)  12.test = 装饰器2 的内部函数
@outer   #1. =====>test=outer(普通功能函数)  6.test = 装饰器1的内部函数定义
def test():
    print("普通功能")


test()   # test()=====>装饰器2 的内部函数()

• 类装饰器

• 在Python中，如果想把一个类实例编程一个可调用的对象（所有的函数都是可调用对象），只需要是用魔术方法__call__()就行。而且它可以用来改变实例的内部成员的值
• 与它相对的，init()函数的意义等同于类的构造器（同理，del()等同于类的析构函数）。因此，init()方法的作用是创建一个类的实例。

 class Test(object):
    def __init__(self, func):
        self.func = func

    def __call__(self):
        print("这里是装饰器添加的功能.....")
        return self.func()
@Test  
def get_str():
    return "haha"

print(get_str())