day04 迭代器&生成器&装饰器

目录  

1.迭代器

2.生成器

3.推导式

4.匿名函数

5.内置函数

6.递归

7.闭包

8.装饰器

一.迭代器

特点:

    1. 省内存
    2. 只能向前. 不能反复
    3. 惰性机制

让不同的数据类型有相同的遍历方式

迭代器取值方法：

lst = [1,2,3,4]
lst1 = lst.__iter__()
print(next(lst1))
print(lst1.__next__())

判断是不是可迭代对象和迭代器

from collections import Iterator,Iterable
lst = [1,2,3,4]
print(isinstance(lst,Iterable))  可迭代对象
print(isinstance(lst,Iterator))  迭代器

用while循环打印迭代器并异常捕捉

lst = ["黑色星期天","bad feel","滚吧","那就这样吧"]
lst1 = lst.__iter__()
while True:
    try:
        s = lst1.__next__()
        print(s)
    except StopIteration:
        break

dir() 查看我们数据类型可以执行的操作

二.生成器
   生成器本质上也是一个迭代器，特点也是节省空间。通过yield来定义

def func():
   yield
生成器函数  -> 执行的时候. 不会立即把函数全部执行完. 创建一个生成器返回给你

省内存
__next__() 可以拿到数据
send() 可以拿到数据, 可以给生成器传递消息 send会给上一个yield传递参数。

普通打印例子：

def order():
    lst = []
    for i in range(1000):
        lst.append("衣服" + str(i))
    return lst
lst = order()
print(lst)     ps:当数据量多大内存容易出问题

生成器例子：

def order():
    lst = []
    for i in range(100):
        yield "衣服" + str(i)

gen = order()
print(gen.__next__())   ps：要一个值打印一下next即可，惰性机制的特点。

send应用

def func():
    print("韭菜盒子")
    s1 = yield 1
    print("s1=", s1)
    print("沙琪玛")
    s2 = yield 2
    print("s2=", s2)
    print("盒饭")
    s3 = yield 3
    print("s3=", s3)
    print("混沌")
    s4 = yield 4
gen = func()
print(gen.__next__()) # send可以给上一个yield位置传值
ret1 = gen.send("周润发")
ret2 = gen.send("周杰伦")
ret3 = gen.send("周笔畅")
print("===============")
print(ret1)
print(ret2)
print(ret3)    ps:send是给上一个yield传值，不能给最后一个yield传值，否则会报错

三.推导式

列表推导式:
    [结果 for循环 if语句]

例子1：lst = ["python周末班%s" % i for i in range(1, 27) if i%2==0 ]
print(lst)
例子2：把姓张的人检索出来, 放在一个新列表里  startswith

lst = ["欧阳娜娜", "张崔猛", "欧阳难过", "张亚无照", "胡一飞", "胡怎么飞", "张炸辉"]
print([name for name in lst if name.startswith("张")])

例子3：使用列表推导式得到 [1, 4, 9, 16, 25, 36]
print([i*i for i in range(1,7)])

例4在[3,6,9]的基础上推到出[[1,2,3], [4,5,6],[7,8,9]]
print([[i-2,i-1,i] for i in [3,6,9]])

字典推导式:
    {key:value for if}
例1：通过列表推导成字典

lst = ["张三丰", "张无忌", "张翠山"]
print({i:lst[i] for i in range(len(lst))})

集合推导式
    {key for if}

print({i for i in range(10)}）

    没有元组推导式!!!!!!!

生成器表达式:
    (结果 for if)

gen = (i for i in range(10))
print(gen)
for i in gen:
    print(i)

四.匿名函数

匿名函数语法：

  匿名函：lambda 参数: 返回值   配合内置函数一起使用 不能写太多

      func = lambda x:x*10

  print(func(10))

例1：给函数传递一个参数，返回字符串的长度

lambda args: len(args)

五.内置函数

   repr() 字符串表示形式

   zip() 拉链函数

   sorted() 排序

      例子1：

lst = ["高进", "波多野结衣", "苍老师", "仓木麻衣", "红狗"]
s = sorted(lst,key=lambda s: len(s))
print(s)   ps:首先,打开这个可迭代对象. 然后获取到每一项数据. 把每一项数据传递给函数,根据函数返回的数据进行排序.

例2：按照年龄大小排序

lst = [{"id":1, "name":'alex', "age":18},
{"id":2, "name":'wusir', "age":16},
{"id":3, "name":'taibai', "age":17}]
def func(d):
    return d["age"]
s = sorted(lst,key=func,reverse=True)
print(s)

filter()帅选函数
例1：筛选出大于20的数字

st = [18, 22, 66, 35, 1, 48]
f = filter(lambda n:n>20,st)
for item in f:
    print(item)   ps：返回迭代器, 把可迭代对象中的每一项数据交给前面的函数. 由函数决定该数据是否保留

例2：打印大于或者等于18岁的成年人

lst = [{"id":1, "name":'alex', "age":18},
 {"id":2, "name":'wusir', "age":16},
 {"id":3, "name":'taibai', "age":17}]

s = filter(lambda n:n["age"]>=18,lst)
for i in s:
    print(i)

map() 会根据提供的函数对指定序列做映射

lst = [2,5,3,2,4]
m = map(lambda n:n*n, lst)
for i in m:
    print(i)   ps:python2 里面返回来的是列表，python3返回的是迭代器

六.递归

    特点：实际上就是函数自己调自己，永远不可能超过1000层

    递归死循环

i = 0
def func():
    global i
    i +=i
    print("哈哈" ,i)
    func()
func()

传统的查找方法需要一个个对比很消耗资源

lst = [12,24,53,67,108,267]
n = 798
for i in range(len(lst)):
    if lst[i] == n:
        print("I found it")
else:
    print("didn't find it")

递归用法

def binarySearch(lst, n, left, right):
    if left <=right: # 判断是否已经查找完毕
        mid = (left+right)//2 #  计算中间
        if n > lst[mid]: # 数据比中间大
            left = mid + 1 #  做边界拉倒右边
            # 进入递归
            return binarySearch(lst, n, left, right)
        elif n < lst[mid]:
            right = mid - 1
            return binarySearch(lst, n, left, right)
        else:
            print("找到了")
            return mid
    else:
        print("没找到")
        return -1

lst = [12,24,53,67,108,267]
n = 108
ret = binarySearch(lst, n, 0, len(lst)-1)
print(ret)

二分法，一个最简单的算法，用于查找某个数字

n = 108
lst = [12,24,53,67,108,267]
left = 0
right = len(lst) - 1 # 右边界
while left <= right:
    mid = (left + right)//2
    if n > lst[mid]:
        left = mid+1
    elif n < lst[mid]:
        right = mid-1
    else:
        print("找到了")
        print(mid)
        break
else:
    print("没有")  ps:两头掐尾取中间。

七.闭包

作用：在内层函数中使用外层函数的变量

     1.保护变量

     2.让一个变量常驻内存

定义：

def outer():
    a = 10
    def inner():
        print(a)
    return inner
outer = outer()
outer()
查看函数是不是闭包：

def outer():
    a = 10
    def inner():
        print(a)
    return inner
fn = outer()
ret = fn()
print(fn.__closure__)

八.装饰器

简洁版语法

def func(fn):
    def inner():
        print("hahaha")
        fn()
        print("make a go")
    return inner

@func
def func1():
    print("我要离开地球表面")
func1()

精版

def func(fn):
    def inner(*args,**kwargs):
        print("hahaha")
        ret = fn(*args,**kwargs)
        print("make a go")
        return ret
    return inner

@func
def func1(*args,**kwargs):
    print("我要离开地球表面")
    return "流光幸运刀"
ret = func1("我要流光幸运刀")
print(ret)

ps:上面的装饰器当用户查看自己的函数时就能看出来就闭包。可以通过如下方法来掩饰

from functools import wraps
def waiguai(fn):
    @wraps(fn )
    def inner(*args,**kwargs):
        print("开外挂")
        ret = fn(*args,**kwargs)
        print("结束外挂")
        return ret
    return inner

@waiguai
def dnf(username,password):
    print("starting game")

@waiguai
def king(qq):
    print("王者")

dnf1 = dnf("ivy","wang")
print(dnf1)
king("1327285005")
print(king.__name__)

给装饰器传递参数
例子1：给装饰器传递一个值如果是True问金老板否则直接直接fn()
主要实现原理是先执行@后面的函数然后在执行@，相当于分成两部分来实现。

def outer(flag):
    def decoration(fn):
        def inner(*args,**kwargs):
            if flag:
                print("问问金老板去哪儿好")
                ret = fn(*args,**kwargs)
                print("金老板骗人的")
            else:
                ret = fn(*args, **kwargs)
            return ret
        return inner
    return decoration

@outer(True)
def dating():
    print("约帅哥。。。")
dating()

print("--------华丽丽的分割线------------")
@outer(False)
def travel():
    print("想想去哪儿。。。")
travel()

例子2，日志打印，重要的日志放在一指定的文件下面，不重要的放在默认路径下。

import time

def outer(filename="default.log"):
    def decoration(fn):
        def inner(*args,**kwargs):
            print("打印访问日志" )
            with open(filename,mode="a",encoding="utf-8") as f:
                f.write("在%s 访问了%s \n" % (time.strftime("%Y-%m-%d %H:%M:%S"),fn.__name__))
                ret = fn(*args,**kwargs)
            return fn
        return inner
    return decoration

@outer("func1.log")
def func1():
    print("Hello everyong I am func1")
func1()

@outer()
def func2():
    print("Hello everyone I am func2")
func2()
ps: func1的日志打印到func1.log里面，func2的日志打印到default.log 里面，主要基于装饰器传参定义默认参数来实现的。

多个装饰器装饰一个函数

def decoration1(fn):
    def inner():
        print("before decoration1")
        fn()
        print("after decoration1")
    return inner

def decoration2(fn):
    def inner():
        print("before decoration2")
        fn()
        print("after decoration2")
    return inner

def decoration3(fn):
    def inner():
        print("before decoration3")
        fn()
        print("after decoration3")
    return inner

@decoration1
@decoration2
@decoration3
def func():
    print("hello I am the real funcation")
func()

打印结果

由此可见多个装饰器装饰一个函数的原理，是一层层来实现的，最开始执行的是离函数最近的那个开始的。