python函数--匿名函数,内置函数，闭包

1. 今日内容大纲

         

2. 昨日内容回顾作业讲解

 

3. 今日内容

   1. 匿名函数：一句话函数，比较简单的函数。

      ![1557887115535](C:UsersoldboyAppDataRoamingTypora	ypora-user-images1557887115535.png)

      1. 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.
      2. lambda 是定义匿名函数的关键字，相当于函数的def.
      3. lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。
      4. 返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。
      5. 匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

      课上练习：

      ```
      def func(a,b):
          return a + b
      # 构建匿名函数
      func1 = lambda a,b: a + b
      print(func1(1,2))
      
      ```

      + 接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。

      + ```
        func2 = lambda a: (a[0],a[2])
        print(func2([22,33,44,55]))
        ```

      + 写匿名函数：接收两个int参数，将较大的数据返回。

      + ```
        lambda a,b: a if a > b else b
        ```

   2. 内置函数

      ```python
      # # python 提供了68个内置函数。
      # # 今天讲的这部分大部分了解即可。
      # # eval 剥去字符串的外衣运算里面的代码，有返回值。  **
      # s1 = '1 + 3'
      # # print(s1)
      # # print(eval(s1))  **
      # # s = '{"name": "alex"}'
      # # print(s,type(s))
      # # print(dict(s)) # 不行
      # # print(eval(s),type(eval(s)))
      # # 网络传输的str input 输入的时候,sql注入等等绝对不能使用eval。
      #
      # # exec 与eval几乎一样， 代码流。
      # msg = """
      # for i in range(10):
      #     print(i)
      # """
      # # print(msg)
      # # exec(msg)
      # # hash 哈希值
      # # print(hash('fsjkdafsda'))
      #
      # # help 帮助  **
      # # s1 = 'fjdsls'
      # # print(help(str))
      # # print(help(str.upper))
      # # s1 = 'sfsda'
      # # s1.upper()
      #
      #
      # s1 = 'fdsklfa'
      # # s1()
      # def func():
      #     pass
      # # func
      # # # callable 判断一个对象是否可被调用  ***
      # # print(callable(s1))
      # # print(callable(func))
      
      # int
      # print(int(3.6))
      
      # float
      # print(type(3.6))
      
      # print(complex(1,2))  # (1+2j)
      
      # bin：将十进制转换成二进制并返回。  **
      # print(bin(100))
      # # oct：将十进制转化成八进制字符串并返回。  **
      # print(oct(10))
      # # hex：将十进制转化成十六进制字符串并返回。  **
      # print(hex(10))
      # print(hex(13))
      
      # divmod  **
      # print(divmod(10,3))
      # round：保留浮点数的小数位数  **
      # print(round(3.141592653, 2))  # 3.14
      # pow：求x**y次幂。（三个参数为x**y的结果对z取余）
      # print(pow(2,3))  **
      # print(pow(2,3,3))  #   2**3 % 3
      
      # bytes ***
      s1 = '太白'
      # b = s1.encode('utf-8')
      # print(b)
      # b = bytes(s1,encoding='utf-8')
      # print(b)
      
      # ord:输入字符找该字符编码的位置
      # ascii Unicode
      # print(ord('a'))  #
      # print(ord('中'))  # 20013  Unicode
      # # chr:输入位置数字找出其对应的字符 #  **
      # # print(chr(97))
      # print(chr(20013))  # Unicode
      
      # repr:返回一个对象的string形式（原形毕露）。  ***
      # s1 = '存龙'
      # # # print(s1)
      # # print(repr(s1))
      # # msg = '我叫%s' %(s1)
      # msg = '我叫%r' %(s1)
      # print(msg)
      # all：可迭代对象中，全都是True才是True
      # l1 = [1, 2, '太白', True, [1,2,3], '']
      # print(all(l1))
      # any：可迭代对象中，有一个True 就是True
      # l1 = [ 0, '太白', False, [], '',()]
      # print(any(l1))
      
      # print(self, *args, sep=' ', end='
', file=None)
      # print(1,2,3,4)
      # print(1,2,3,4,sep='&')
      # print(1, end=' ')
      # print(2)
      
      # list
      # l1 = [1,2,3,4]
      # l2 = list()
      # l2 = list('fjfdsklagjsflag')
      # print(l2)
      
      # dict 创建字典的几种方式
      # 直接创建
      # 元组的解构
      # dic = dict([(1,'one'),(2,'two'),(3,'three')])
      # dic = dict(one=1,two=2)
      # print(dic)
      # fromkeys
      # update
      # 字典的推导式
      
      # abs()  ***
      # print(abs(-6))
      
      # sum  ***
      # l1 = [i for i in range(10)]
      # s1 = '12345'
      # print(sum(l1))
      # print(sum(l1,100))
      # print(sum(s1))  # 错误
      
      # reversed  返回的是一个翻转的迭代器  ***
      # l1 = [i for i in range(10)]
      # # l1.reverse()  # 列表的方法
      # # print(l1)
      # l1 = [i for i in range(10)]
      # obj = reversed(l1)
      # print(l1)
      # print(list(obj))
      
      # zip 拉链方法  ***
      # l1 = [1, 2, 3, 4, 5]
      # tu1 = ('太白', 'b哥', '德刚')
      # s1 = 'abcd'
      # obj = zip(l1,tu1,s1)
      # # # print(obj)
      # # for i in obj:
      # #     print(i)
      # print(list(obj))
      # *************  以下方法最最最重要
      # min max
      l1 = [33, 2, 3, 54, 7, -1, -9]
      # print(min(l1))
      # 以绝对值的方式去最小值
      # l2 = []
      # func = lambda a: abs(a)
      # for i in l1:
      #     l2.append(func(i))
      # print(min(l2))
      # def abss(a):
      #     '''
      #     第一次：a = 33  以绝对值取最小值  33
      #     第二次：a = 2  以绝对值取最小值  2
      #     第三次：a = 3  以绝对值取最小值  2
      #     ......
      #     第六次：a = -1   以绝对值取最小值  1
      #
      #     '''
      #     return abs(a)
      # print(min(l1,key=abss))
      # 凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，
      # 以返回值比较大小。
      dic = {'a': 3, 'b': 2, 'c': 1}
      # 求出值最小的键
      # print(min(dic))  # min默认会按照字典的键去比较大小。
      # def func(a):
      #     return dic[a]
      # func = lambda a:dic[a]
      print(min(dic,key=lambda a: dic[a]))
      ```

   3. 闭包：

      整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。

      比如大众推出了一款新车：小白轿车。

      第一天价格为：100000元，平均收盘价：100000元

      第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元

      第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元

4. 今日总结

   + 匿名函数。

   + 内置函数。`***` 一定要记住，敲3遍以上。  `**` 尽量记住，2遍。

   + 闭包：

     ```
     # 封闭的东西： 保证数据的安全。
     
     # 方案一：
     # l1 = []  # 全局变量 数据不安全
     # li = []
     # def make_averager(new_value):
     #     l1.append(new_value)
     #     total = sum(l1)
     #     averager = total/len(l1)
     #     return averager
     # print(make_averager(100000))
     # print(make_averager(110000))
     # # 很多代码.....
     # l1.append(666)
     # print(make_averager(120000))
     # print(make_averager(90000))
     
     # 方案二： 数据安全，l1不能是全局变量。
     # 每次执行的时候，l1列表都会重新赋值成[]
     # li = []
     # def make_averager(new_value):
     #     l1 = []
     #     l1.append(new_value)
     #     total = sum(l1)
     #     averager = total/len(l1)
     #     return averager
     # print(make_averager(100000))
     # print(make_averager(110000))
     # # 很多代码.....
     # print(make_averager(120000))
     # print(make_averager(90000))
     
     # 方案三： 闭包
     
     #
     def make_averager():
         l1 = []
         def averager(new_value):
             l1.append(new_value)
             print(l1)
             total = sum(l1)
             return total/len(l1)
         return averager
     
     # avg = make_averager()  # averager
     # print(avg(100000))
     # print(avg(110000))
     # print(avg(120000))
     # print(avg(190000))
     
     # def func():
     #     return 666
     #
     # ret = func()
     # print(globals())
     
     # 闭包： 多用于面试题： 什么是闭包？ 闭包有什么作用。
     # 1，闭包只能存在嵌套函数中。
     # 2， 内层函数对外层函数非全局变量的引用（使用），就会形成闭包。
     # 被引用的非全局变量也称作自由变量，这个自由变量会与内层函数产生一个绑定关系，
     # 自由变量不会再内存中消失。
     # 闭包的作用：保证数据的安全。
     
     # 如何判断一个嵌套函数是不是闭包
     
     # 1，闭包只能存在嵌套函数中。
     # 2， 内层函数对外层函数非全局变量的引用（使用），就会形成闭包。
     # 例一：
     # 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)
     #     return inner
     # a = 2
     # b = 3
     # ret = wrapper(a,b)
     # print(ret.__code__.co_freevars)  # ('a', 'b')
     # 如何代码判断闭包？
     
     def make_averager():
         l1 = []
         def averager(new_value):
             l1.append(new_value)
             print(l1)
             total = sum(l1)
             return total/len(l1)
         return averager
     
     avg = make_averager()  # averager
     print(avg.__code__.co_freevars)
     ```

     

     ```
     闭包： 多用于面试题： 什么是闭包？ 闭包有什么作用。
     1，闭包只能存在嵌套函数中。
     2， 内层函数对外层函数非全局变量的引用（使用），就会形成闭包。
     被引用的非全局变量也称作自由变量，这个自由变量会与内层函数产生一个绑定关系，
     自由变量不会再内存中消失。
     闭包的作用：保证数据的安全。
     ```

1. 匿名函数：一句话函数。 多于内置函数，列表推导式结合。

2. 内置函数： *** 加key的。min，max，sorted，map，reduce，filter

3. 闭包：

1. 内层函数对外层函数非全局变量的使用。
2. 一定要存在嵌套函数中。
3. 作用：保证数据安全。自由变量不会再内存中消失，而且全局还引用不到。