内置函数 匿名函数 闭包 13

Posted zhaoxinblog

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了内置函数 匿名函数 闭包 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)
    

以上是关于内置函数 匿名函数 闭包 13的主要内容,如果未能解决你的问题,请参考以下文章

内置函数补充匿名函数及闭包

学习13.内容# 1.内置函数二 # 2.闭包

内置函数,匿名函数与闭包

Python之路day13-内置函数_lambda_闭包

Python-内置函数1匿名函数闭包

javascript 匿名函数及闭包----转载