首页 > 编程语言 > 详细

python 13 内置函数II 匿名函数 闭包

时间:2019-05-15 18:46:29      阅读:115      评论:0      收藏:0      [点我收藏+]
  1. 内置函数整理:
  • ***

    • callable:判断一个对象是否可被调用

    • bytes

      s1 = '太白'
      b = s1.encode('utf-8')
      b = bytes(s1,encoding='utf-8')
    • repr:返回一个对象的string形式(原形毕露)

      msg='我叫%s'%(s1)
      msg='我叫%r'%(s1)
    • abs():绝对值

    • sum():加总

      # print(sum(l1))
      # print(sum(l1,100))
    • reversed:返回的是一个反转的迭代器

      l1 = [i for i in range(10)] #l1是一个列表
      列表的方法:l1.reverse()
      reversed方法:
      obj=reversed(l1)
      print(list(obj))
    • zip:拉链方法

      # l1 = [1, 2, 3, 4, 5]
      # tu1 = ('太白', 'b哥', '德刚')
      # s1 = 'abcd'
      obj = zip(l1,tu1,s1)
      用for循环打印或者用list(obj)打印
  • **

    • lambda: lambda a,b: a if a > b else b

    • eval:剥去字符串的外衣运算里面的代码,有返回值。

      s1 = '1 + 3'
      print(eval(s1)) 
      s = '{"name": "alex"}'
      print(eval(s),type(eval(s)))
    • exec : 与eval几乎一样, 代码流。

      # msg = """
      # for i in range(10):
      #     print(i)
      # """
      # # print(msg)
      # # exec(msg)
    • help:帮助

    • bin:将十进制转换成二进制并返回

    • oct:将十进制转化成八进制字符串并返回

    • hex:将十进制转化成十六进制字符串并返回

    • divmod:返回整除的商和余数

      print(divmod(10,3)) #(3, 1)
    • round:保留浮点数的小数位数

      print(round(3.141592653, 2))  # 3.14
    • pow:求xy次幂。(三个参数为xy的结果对z取余)** 返回结果有两种,如果是pow(2,3),返回8,若为pow(2,3,3),返回余数,所以为2

    • ord:输入字符找该字符编码的位置 chr:输入位置数字找出其对应的字符

  • *

    • f
  • 没有*的,不代表不重要

    • hash:哈希值

      # # hash 哈希值
      # # print(hash('fsjkdafsda'))
    • int

    • float:浮点数

      print(type(3.6))
    • complex:复数

      print(complex(1,2))  # (1+2j)
    • all:可迭代对象中,全都是True才是True

    • any:可迭代对象中,有一个True 就是True

    • print:print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)

      # print(1,2,3,4)
      # print(1,2,3,4,sep='&')
      # print(1, end=' ')
      # print(2)
    • list:扑克牌

      list(‘JQKA‘)

    • dict:创建字典的方式

      • dic=dict([(1,‘one‘),(2,‘two‘)])
      • dic=dict(one=1,two=2)
      • dic=dict.fromkeys([1,2,3,],[2])或者 dic=dict.fromkeys((1,2,3),3)
      • 字典的推导式
    • 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)
  • 非常重要*********

    • min max

      • # 以绝对值的方式去最小值
        # l2 = []
        # func = lambda a: abs(a)
        # for i in l1:
        #     l2.append(func(i))
        # print(min(l2))
      • def abss(a):
          return abs(a)
        print(min(l1,key=abss))
      • dic = {'a': 3, 'b': 2, 'c': 1} 求最小值
        def func(args):
          return dic[args]
        print(min(dic,key=func))
        print(min(dic,key=lambda args: dic[args]))
  • 可以加key的:凡是可以加key的:它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中,

    • reversed:返回的是一个反转的迭代器

    • zip:拉链

    • sorted:

      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))  # 返回的是一个列表,默认从低到高
  • 返回的是迭代器

    • reversed

    • 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) # 返回的是迭代器

    • map:列表推导式的循环模式

      l1 = [1, 4, 9, 16, 25]
      ret = map(lambda x: x**2,range(1,6))
      print(list(ret))

  1. 今日内容

    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的对应的元素(元组形式)。

      • 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 提供了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='\n', 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 元

  2. 今日总结

    • 匿名函数。

    • 内置函数。*** 一定要记住,敲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, 内层函数对外层函数非全局变量的引用(使用),就会形成闭包。
      被引用的非全局变量也称作自由变量,这个自由变量会与内层函数产生一个绑定关系,
      自由变量不会再内存中消失。
      闭包的作用:保证数据的安全。
  3. 预习内容:装饰器。

python 13 内置函数II 匿名函数 闭包

原文:https://www.cnblogs.com/miseryGOD/p/10871315.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!