• 内置函数 匿名函数 闭包 13


    1. 匿名函数:一句话函数,比较简单的函数。

      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的对应的元素(元组形式)。
      func = lambda a : (a[0],a[2])
      print(func([222,333,666,6666]))
      
      写匿名函数:接收两个int参数,将较大的数据返回。
      lambda a,b : a if a > b else b
      
    2. 内置函数

      # # 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(16))
      # print(hex(13))
      
      divmod **
      print(divmod(10,3))
      round 保留浮点数的小数位数 **
      print(round(3.1416592),2)#3.14
      pow 求 x**y次幂 (三个参数为x**y的结果对z 取余) **
      print(pow(2,3))
      print(pow(2,3,3)) # 2**3 %3
      
      bytes ***
      s1 = 'holting'
      b = encoding='utf-8'
      print(b)
      b = bytes(s1,encoding='utf-8')
      print(b)
      
      ord 输入字符找该字符编码的位置
      ascii unicode
      print(ord('a'))
      print('中')# 2013 Unicode
      chr 输入位置数字找出对应的字符 **
      print(chr(97))
      print(chr(20013)) #Unicode
      
      repr 返回一个对象的string形式(原形毕露)***
      s1 = 'holting'
      print(s1)
      print(repr(s1))
      # # msg = '我叫%s' %(s1)
      # msg = '我叫%r' %(s1)
      # print(msg)
      all 可迭代对象中,全都是Ture 才是Ture
      l1 = [1, 2, '太白', True, [1,2,3], '']
      print(all(l1))
      any 可迭代对象中,有一个Ture就是Ture
      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 = dic(one = 1,two=2)
      print(dic)
      formkeys
      update
      字典推导式
      
      abs()***
      print(abs(-1))
      
      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]))
      
      max pass
      
      
      # sorted  加key
      # l1 = [22, 33, 1, 2, 8, 7,6,5]
      # l2 = sorted(l1)
      # print(l1)
      # print(l2)
      
      l2 = [('大壮', 76), ('雪飞', 70), ('纳钦', 94), ('张珵', 98), ('b哥',96)]
      # print(sorted(l2))
      # print(sorted(l2,key= lambda x:x[1]))  # 返回的是一个列表,默认从低到高
      # print(sorted(l2,key= lambda x:x[1],reverse=True))  # 返回的是一个列表,默认从低到高
      
      
      # filter 列表推导式的筛选模式
      # l1 = [2, 3, 4, 1, 6, 7, 8]
      # print([i for i in l1 if i > 3])  # 返回的是列表
      # ret = filter(lambda x: x > 3,l1)  # 返回的是迭代器
      # print(ret)
      # print(list(ret))
      
      # map  列表推导式的循环模式
      # l1 = [1, 4, 9, 16, 25]
      # print([i**2 for i in range(1,6)])  # 返回的是列表
      # ret = map(lambda x: x**2,range(1,6))  # 返回的是迭代器
      # print(ret)
      # print(list(ret))
      
      # reduce
      from functools import reduce
      def func(x,y):
          '''
          第一次:x  y  : 11  2     x + y =     记录: 13
          第二次:x = 13   y  = 3    x +  y =   记录: 16
          第三次  x = 16   y = 4 .......
          '''
          return x + y
      
      l = reduce(func,[11,2,3,4])
      print(l)
      
      1. 闭包:

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

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

        第一天价格为:100000元,平均收盘价:100000元

        第二天价格为:110000元,平均收盘价:(100000 + 110000)/2 元

        第三天价格为:120000元,平均收盘价:(100000 + 110000 + 120000)/3 元

      # 封闭的东西: 保证数据的安全。
      
      # 方案一:
      # 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)
      
  • 相关阅读:
    window.open的火狐、谷歌兼容写法
    一个分数怎样约分?想知道的速度了。。。
    这是第二道题内容要求写一个银行的ATM系统 这个浪费了好长时间 ,遇到了许多问题,不过都解决了,上程序
    两个有理数相加(要求输入时以分数形式,输出时也以分数形式)
    linux centos 7.5下 源码编译安装 lua环境
    SecureCRT 6.7 vim高亮
    C#第一章笔记
    HTML5考试错题
    第九章博客
    第八章博客
  • 原文地址:https://www.cnblogs.com/zhaoxinblog/p/13236784.html
Copyright © 2020-2023  润新知