目录  

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,Iterablelst = [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 lstlst = 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 4gen = 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 = 0def func():    global i    i +=i    print("哈哈" ,i)    func()func()

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

lst = [12,24,53,67,108,267]n = 798for 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 = 108ret = binarySearch(lst, n, 0, len(lst)-1)print(ret)

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

n = 108lst = [12,24,53,67,108,267]left = 0right = 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)        breakelse:    print("没有")  ps:两头掐尾取中间。

七.闭包

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

1.保护变量

2.让一个变量常驻内存

定义：

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

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

八.装饰器

简洁版语法

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

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

精版

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

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

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

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

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

@waiguaidef 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@decoration3def func():    print("hello I am the real funcation")func()

打印结果

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