首页 / PYTHON / python 13 内置函数II 匿名函数 闭包

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python 13 内置函数II 匿名函数 闭包，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10289字，纯文字阅读大概需要15分钟。

内容图文

  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. 匿名函数：一句话函数，比较简单的函数。

      python 13 内置函数II 匿名函数 闭包 - 文章图片

      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 匿名函数 闭包全部内容，希望文章能够帮你解决python 13 内置函数II 匿名函数 闭包所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/827549.html

来源：【匿名】