python学习Day14 带参装饰器、可迭代对象、迭代器对象、for 迭代器工作原理、枚举对象、生成器及生成表达式

复习

函数的嵌套定义：在函数内部定义另一个函数

闭包：被嵌套的函数
-- 1.外层通过形参给内层函数传参
-- 2.返回内部函数对象---->  延迟执行，

开放封闭原则: 功能可以拓展，但源代码与调用方式都不可以改变

装饰器：装饰器名就是外层函数 @outer

@outer  # fn = outer(fn)

def fn(): pass

今日内容

1.带参装饰器  |  2.wrapper  |  3.可迭代对象 |   4.迭代器对象  |  5.for 迭代器工作原理 |  6.枚举对象 | 7.生成器

1. 带参装饰器 ： 通常，装饰器为被装饰的函数添加新功能，需要外界的参数：可以在 outer外再套一层函数，通过形参给内部传参。

-- outer参数固定一个，就是func
-- inner参数固定同被装饰的函数，也不能添加新参数
 -- 可以借助函数的嵌套定义，外层给内层传参，

2. 系统 functools 的wraps带参装饰器：inner本来是装饰原函数func的，但func还有部分功能inner没有，那就给inner加一个装饰器，把这此功能装到inner函数上，将原函数的部分功能装饰给inner,从面达到对原函数func更好的装饰。（通过改变inner的假指向，本质外界使用的还是inner，但是打印显示的是wraps中原函数的id）

3.  迭代器 ：

    优点：

    -- 、提供了一种通用的不依赖于索引的迭代取值方法

    -- 、同一时刻在内存中只存在一个值，更节省空间 （只有一个iterator内存地址）

    缺点：

     -- 、取值不如按照索引、'key'的方式灵活，（不能取指定的某一个值，而且只能往后取）

     -- 、无法预测迭代器的长度

1）可迭代对象：有__iter__()方法的对象是可迭代对象，调用__iter__()返回的值, 就是一个迭代器对象iterator :除了数字类型，都是可迭代对象。

 

dic = {'x':1, 'y':2, 'z':3}
iter_dic = dic.__iter__()
print(iter_dic.__next__())  # x。/。/。/
print(iter_dic.__next__())  # y
print(iter_dic.__next__())  # z

print(iter_dic.__next__())  # 取空报错：StopIteration ，结束

 

2)  迭代器对象: 迭代取值的工具。一个重复的过程，一个基于上次结果往后取值的过程。

     --、既有__next__(）方法，执行__next__()方法可以不依赖索引取值，（（运行一个__next__()就取到一个值），直到被取空，抛出  “ StopIteration异常 "）

     -- 、又有_iter_方法, 执行 迭代器_iter_方法得到的仍然是迭代器本身.

          (为了与可迭代对象建立一个统一的标准：迭代器协议。如for 循环、max、min、reduce、sorted等，不管是可迭代对象还是迭代器对象，统一都先调用iter方法)

PS: 迭代器对象一定是可迭代的对象，而可迭代的对象却不一定是迭代器对象。如文件对象就是一个可迭代器对象，也是一个迭代器对象

      

dic = {'x':1, 'y':2, 'z':3}
iter_dic = iter(dic)  # dic.__iter__()
while True:
    try:
        print(next(iter_dic))
    except StopIteration:      #捕捉异常
        break                  # x y z

iter_dic.__next__()   #StopIteration #同一个迭代器对象取空后不能再取，

iter_dic = iter(dic)                 #若想再取值，只需重新生成一个迭代器

总结：
   可迭代对象，但凡有_iter_方法的对象都是可迭代的对象。例如：list,dict,tuple,set,f
   迭代器对象：既内置有_iter_方法又内置有_next_方法的对象称之为迭代器对象，例如f
   可迭代对象._iter_() --> 迭代器对象
   迭代器对象._iter_() --> 迭代器本身
   迭代器对象._next_() --> 迭代器的下一个值

4.for循环--本质应该称为迭代器循环

  为何要有for 迭代器循环?

  #1. 先调用in后面那个对象的iter方法，将其变成一个迭代器对象

  #2. 调用next(迭代器)，将得到的返回值赋值给变量名K

  #3. 循环往复直到next(迭代器)抛出异常，for会自动捕捉异常然后结束循环

dic = {'x':1, 'y':2, 'z':3}

for k in dic:

      print(k)

  直接用while True循环：在迭代器对象中通过 __next__() 取值，终究会有取空的时候，取空再取值，报StopIteration异常

for循环就是对while取迭代器对象的封装  

for循环迭代器的工作原理：
 for v in obj: pass
1）获取obj.__iter__()的结果，就是得到要操作的 迭代器对象
2）迭代器对象通过__next__()方法进行取值，依次将当前循环的取值结果赋值给v
3）当取值抛异常，自动处理StopIteration异常，结束循环取值

5. 枚举对象 ：给可迭代器对象及迭代器对象添加迭代索引

    s = 'abc'
    for v in enumerate(s):
              print(v)     # (0 'a') | (1 'b') | (2 'c')

6. 生成器 ：本质上就是一种自定义的迭代器

                    但凡函数内包含yield关键字，调用函数不会执行函数体代码，会得到一个返回值，该返回值就是生成器对象

def func():
    print('first')
    yield 1
    print('second')
    yield 2
    print('third')
    yield 3
    print('fourth')

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

res1 = next(g)   # first  会触发函数的执行，直到碰到一个yield停下来，并将yield后的值当作本次next的结果返回 print(res1)
#print(res1)      # 1

res2 = next(g)   #second
# print(res2)    # 2

res3 = next(g)   # third
#print(res3)      # 3

res4 = next(g)   #fourth  StopIteration
# print(res4)    

例1：自定一个生成器，

def my_range(start, stop, step):
    while start < stop:
        yield start
        start +=step

obj = my_range(1,10, 2)

print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

例1：自定一个生成器，拿来使用

def my_range(start, stop, step=1):
    while start < stop:
        yield start
        start+=step

for i in my_range(1, 10, 2):
    print(i)  # 1，3， 5， 7，9

  了解（*）：yield 的表达式形式的应用： x = yield

def dog(name):
    print('狗哥%s准备吃'% name)
    while True:
        food = yield  #  food = yield = '屎包子'
        print('%s 吃了%s' %(name, food))

g = dog('alex')  

#强调：针对表达式形式的yield的使用，第一步必须让函数暂停到一个yield的位置，才能进行传值操作
#next(g) #张开狗嘴，让生成器先暂停到yield的位置，准备接受外部传进来的值
next(g) # g.send(None)

g.send('屎包子') #两个动作，1.先传给暂停位置yield赋值，2，next（生成器）直到再次碰到一个yield停下来，然后将该yield后的值当做本次next的结果
g.send('菜包子')
g.send('肉包子')

总结 yield：只能在函数内使用
#1.yield提供了一种自定义迭代器的解决方案
#2.yield 可以保存函数的暂停的状态
#3.yield对比return:
   --、相同点：都可以返回值，值的类型与个数都没有限制
   --、不同点：yield可以返回多次值，而return只能返回一次值，函数就结束了

 生成器表达式：

g  = (i **2 for i in range(1, 10) if i > 3)

print(g)    # <generator object <genexpr> at 0x000002313F351D58> 不next就不会有值

print(next(g))  #16

print(next(g))  #25

应用场景：如统计文件的长度（不能读出所有的内容），迭代一个计算一个

with open(...)  as f:

res = sun( len(line)  for line in f  )  #迭代一个加一个,