第十三节

一，匿名函数

1. 匿名函数 == 一行函数

   lambda == def == 关键字

   • 函数体中存放的是代码

   • 生成器体中存放的也是代码

   • 就是yield导致函数和生成器的结果不统一

   lambda x:x
   # x，可以不写是普通函数的形参，可以不接受参数
   # :后边是返回值，x必须写 是普通函数的函数值 (lambda只能返回一个数据类型)
   print(lambda x:x)
   print((lambda x:x+6)(5))
   ​
   f = lambda x:x+6(5)
   print(f.__name__)# 查看函数名字   lambda
   ​
   f1 = lambda x,y,z,:(x,y,z) # :返回值必须是一个数据类型
   print(f(1,2,3))# 输出一个元组(1,2,3)
   ​
   print([lambda :5][0]())
   print((lambda :5)())
   a = lambda :5
   a()
   # 返回 5  5  
   ​
   lst = [lambda :i for i in range(5)]
   print(lst[1]) # 返回的是索引1的函数内存地址
   print(lst[0]()) #  调用函数，返回值，返回的是i最后一次循环所赋值

   lst = [] # [lambda x:x+1,lambda x:x+1]
   for i in range(2):
       lst.append(lambda x:x+1)
   print(lst[-1](5)) # 输出6， lambda 5:5+1
   ​
   lst = [lambda x:x+1 for i in range(5)] # 同上一个
   print(lst[0](5))# 输出6， lambda 5:5+1 
   ​
   tu = (lambda :i for i in range(3)) # 生成器
   print(next(tu)) # 没调用，就是返回函数地址
   print(next(tu)()) # 记录上一次查看的位置，输出 1 

   # 面试题拆解:
   lst = []　
   for i in range(5):
       def func():
           return i
       lst.append(func) #　lst 里面放了5个func函数的地址
   print(lst[1]) # 输出的是函数地址
   print(lst[1]()) # 调用函数，返回的是i最后一次循环

   def func():
       for i in range(3):  # i = 0 1 2
           def foo():      # foo1  foo2  foo3
               return i
           yield foo       # foo1  foo2  foo3
   g = func()
   print(next(g)())  # foo1 返回的是值
   print(next(g)())  # foo2
   print(next(g))  # foo3 返回的是地址，没有调用
   ------------------------------------------------------
   lst = [lambda :i for i in range(3)] # lst中有三个lambda : i
   print(lst[0]()) # 取的是最后一次i循环的值
   -----------------------------------------------------
   tu = (lambda : i for i in range(3)) # 生成器是把循环的每次值 都存放在一个地址中
   print(next(tu)())
   print(next(tu)())  #  每次都是yield 逐个提取
   print(next(tu)())

   lst = [lambda x:x+5 for i in range(2)]
   # lst = [lambda x:x+5,lambda x:x+5]
   print([i(2) for i in lst]) # x = 2,
   # 返回结果 [7,7]
   # 以下为分解式子
   lst = [] # [lambda x:x+5,lambda x:x+5]
   for i in range(2):
       lst.append(lambda x:x+5)
   new_lst = []
   for i in lst:
       new_lst.append(i(2))
   print(new_lst)
   ---------------------------------------------------
   lst = (lambda x:x+5 for i in range(2))
   print(i(2) for i in lst) # 是一个内存地址
   print([i(2) for i in lst]) # 是列表的两个值，[7，7]
   # 以下是分解
   def func():
       for i in range(2):
           f = lambda x: x + 5
           yield f
   g = func()
   lst = []
   for i in g:
       lst.append(i(2))
   print(lst)

   lst = [lambda x:x*i for i in range(2)]
   print([i(2) for i in lst])  #[2,2]
   # 以下为分解式
   lst = [] # [lambda x:x*i,lambda x:x*i]
   for i in range(2):
       lst.append(lambda x:x*i)
   # print(i)
   new_lst = []
   for em in lst:
       new_lst.append(em(2))
   print(new_lst)

   lst = (lambda x:x*i for i in range(2))# 这是一个生成器
   print([i(2) for i in lst])  #[0,2] # i为0的时候存储一次，i为1的时候存储一次
   #  分解
   def func():
       for i in range(2):
           f = lambda x:x*i
           yield f
   g = func()
   lst = []
   for i in g:
       lst.append(i(2))
   print(lst)

   func = lambda x:[i for i in x]
   print(func('afafasd'))
   # 将字符串转换列表['a', 'f', 'a', 'f', 'a', 's', 'd']
   print(list('afafasd'))

二，内置函数Ⅱ

1. • sep ：每一个元素之间分割的方法 默认 " "

     print(1,2,3,sep="|")# 1|2|3

   • end ： print执行完后的结束语句，默认\n

     print(1,2,3,end="")
     print(4,5,6,end="") # 1 2 34 5 6

   • file ： 文件句柄，默认显示到屏幕

     print(1,2,3,4,file=open("test","w",encoding="utf-8"))

   • flush 刷新

   • sum ： 求和，可迭代对象容器,容器的元素必须是数字

     print(sum([1,2,2,1]))
     print(sum([10,20,30,40],100))# 设置初始值

   • abs ： 绝对值

     print(abs(-9))

   • dir ： 查看当前对象的所有方法

     print(dir(str))

   • zip ： 拉链，当长度不一致时选择最短的进行合并

     lst1 = [1,2,3,5]
     lst2=["alex","wusir","元"]
     print(list(zip(lst1,lst2))) # 拉链
     # 面试题:
     print(dict(zip(lst1,lst2)))
     # {1: 'alex', 2: 'wusir', 3: '宝元'}

   • format ： 格式转换

     print(format("alex",">20"))  # 右对齐
     print(format("alex","<20"))  # 左对齐
     print(format("alex","^20"))  # 居中
     # 进制转换:
     # 将十进制转换成二进制  bin
     print(format(12,"b"))
     print(format(12,"08b"))
     ​
     # 将十进制转换成八进制   oct
     print(format(12,"o"))
     print(format(12,"08o"))
     ​
     #　将二进制转换成十进制   digit
     print(format(0b11001,"d"))
     ​
     # 将十进制转换成十六进制   hex
     print(format(17,"x"))
     print(format(17,"08x"))

   • reversed ： 反转

     print(list(reversed("alex")))
     # ['x', 'e', 'l', 'a']
     print(list(reversed([1,2,3,4,5])))
     # [5, 4, 3, 2, 1]

   • filter ： 过滤，1,指定过滤规则(函数名[函数的内存地址]) 2,要过滤的数据

     lst = [1,2,3,4,5,6]
     print(list(filter(lambda x:x>1,lst)))
     # 分解
     def func(a):
         return a>1
     print(list(filter(func,lst)))
     -------------------------------------------------
     # 底层代码
     lst = [1,2,3,4,5,6]
     def f(func,args):
         new_lst = []
         for i in args:
             if func(i):
                 new_lst.append(i)
         return new_lst
     def func(a):
         return a>1
     print(f(func,lst)) # [2,3,4,5,6]
     # fiter写法
     print(list(filter(lambda x:x>2,[1,2,3,4,5])))

     lst = [{'id':1,'name':'alex','age':18},
             {'id':1,'name':'wusir','age':17},
             {'id':1,'name':'taibai','age':16},]
     # 筛选年龄大于16岁的
     print(list(filter(lambda x:x['age']>16,lst)))
     --------------------------------------------------
     def func(a):
         return a>1
     print(list(filter(func,[1,2,3,4,5])))
     print(list(filter(lambda a:a>1,[1,2,3,4,5])))

   • map ： 映射函数（将每个元素都执行了执行的方法）

     print([i*8 for i in [1,2,3,4]])
     #[8, 16, 24, 32]
     -----------------------------------------------------------
     lst = []
     for i in [1,-22,3,4,5,6]:
         lst.append(abs(i))
     lst.sort()
     print(lst)# [1, 3, 4, 5, 6, 22]
     ------------------------------------------------------------
     def map(argv,args):
         lst = []
         num = len(args) if len(args) < len(argv) else len(argv)
         for i in range(num):
             lst.append(argv[i] + args[i])
         return lst
     print(map([1,2,3,4],[3,4,5,6,7,8,9,0]))
     print(list(map(lambda x,y:x+y,[1,2,3,4,5],[33,22,44,55])))
     # [4, 6, 8, 10]

   • sorted ： 排序

     print(sorted([1,2,3,4,5,6],reverse=True))
     print(sorted([1,2,3,4,5,-6],reverse=True,key=abs))
     lst = ["三国演义","红楼梦","铁道游击队","西游记","水浒传","活着"]
     print(sorted(lst,key=len))
     # [6, 5, 4, 3, 2, 1]
     # [-6, 5, 4, 3, 2, 1]
     # ['活着', '红楼梦', '西游记', '水浒传', '三国演义', '铁道游击队']
     -----------------------------------------------------------------
     print(sorted([1,-22,3,4,5,6],key=abs))  # key指定排序规则
     #[1, 3, 4, 5, 6, -22]
     ------------------------------------------------------------------
     lst = [{"age":19},{"age1":20},{"age2":80},{"age3":10}]
     print(sorted(lst,key=lambda x:list(x.values()))) # 值排序
     print(sorted(lst,key=lambda x:list(x.keys()),reverse=True)) # 键排序

   • max ： 最大值

   • min ： 最小值

     print(max(10,12,13,15,16))
     print(max([10,12,13,15,-16],key=abs))
     # 16   -16 

   • reduce ： 累计算

     from functools import reduce

     # 从 functools工具箱中拿来了reduce工具
     from functools import reduce
     def func(x,y):
         return x+y
     print(reduce(func,[1,2,3,4,5]))
     print(reduce(lambda x,y:x+y,[1,2,3,4,5]))
     # 15  15   

三，闭包

1. 什么是闭包？

   在嵌套函数内，使用非本层变量和非全局变量就是闭包

2. 闭包的作用：

   1，保护数据的安全性。2，装饰器

3. __colsure__查看是是否为闭包

4. 函数执行完后，函数体内文件自动销毁

   例一：
   def wrapper():
       a = 1
       def inner():
           print(a)
       return inner
   ret = wrapper() # 闭包
   例二：
   a = 2
   def wrapper():
       def inner():
           print(a)
       return inner
   ret = wrapper() # 不是
   例三：
   def wrapper(a,b):
       def inner():
           print(a)
           print(b)
       inner()
   a = 1
   b = 2
   wrapper(a，b)

5.