Python常见面试题016. 请实现如下功能|谈谈你对闭包的理解

这篇具有很好参考价值的文章主要介绍了Python常见面试题016. 请实现如下功能|谈谈你对闭包的理解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

016. 请实现如下功能|谈谈你对闭包的理解

摘自<流畅的python> 第七章 函数装饰器和闭包

  • 实现一个函数(可以不是函数)avg,计算不断增加的系列值的平均值,效果如下

    def avg(...):
        pass
    avg(10) =>返回10
    avg(20) =>返回10+20的平均值15
    avg(30) =>返回10+20+30的平均值20
    
  • 跟Python常见面试题015.请实现一个如下功能的函数有点类似,但又不太一样

  • 关键是你需要有个变量来存储历史值

类的实现方式

  • 参考代码

    class Average():
        def __init__(self):
            self.series = []
        def __call__(self, value):
            self.series.append(value)
            return sum(self.series)/len(self.series)
    
    avg = Average()
    print(avg(10))
    print(avg(20))
    print(avg(30))
    
  • avg是个Average的实例

  • avg有个属性series,一开始是个空列表

  • __call__使得avg对象可以像函数一样调用

  • 调用的时候series会保留,因为series只在第一次初始化的时候置为空列表

  • 下面的事情就变得简单了


  • 但有没有其他做法呢?
  • 有的,答案是:闭包

闭包实现

  • 参考代码

    def make_average():
        series = []
        def averager(value):
            series.append(value)
            return sum(series)/len(series)
        return averager
    avg = make_average()
    print(avg(10))
    print(avg(20))
    print(avg(30))
    
  • 仔细对比2个代码,你会发现相似度是极高的

  • 一个是类,一个是函数

  • 类中存储历史值的是self.series,函数中的是series局部变量

  • 类实例能调用是实现了__call__,函数的实现中,avg是make_average()的返回值averager,是个函数名,所以它也能调用

闭包 closure 初识

  • 闭包closure定义:

    • 在一个外函数中定义了一个内函数
    • 内函数里运用了外函数的临时变量
    • 外函数的返回值是内函数的引用
  • 以上面的为例

    def make_average(): # 外函数
        series = [] # 临时变量(局部变量)
        def averager(value): # 内函数
            series.append(value)
            return sum(series)/len(series)
        return averager # 返回内函数的引用
    
  • 下面这些话你可能听的云里雾里的,姑且听一下。

  • series 是 make_averager 函数的局部变量,因为那个函数的定义体中初始化了series:series = []

  • 调用 avg(10) 时,make_averager 函数已经返回了,而它的本地作用域也一去不复返了

  • 在 averager 函数中,series 是自由变量(free variable)。这是一个技术术语,指未在本地作用域中绑定的变量

  • averager 的闭包延伸到那个函数的作用域之外,包含自由变量 series 的绑定

反汇编(dis=Disassembler)

from dis import dis
dis(make_average)
  2           0 BUILD_LIST               0
              2 STORE_DEREF              0 (series)

  3           4 LOAD_CLOSURE             0 (series)
              6 BUILD_TUPLE              1
              8 LOAD_CONST               1 (<code object averager at 0x000002225DD1CBE0, file "<ipython-input-1-a43a8601eedd>", line 3>)
             10 LOAD_CONST               2 ('make_average.<locals>.averager')
             12 MAKE_FUNCTION            8 (closure)
             14 STORE_FAST               0 (averager)

  6          16 LOAD_FAST                0 (averager)
             18 RETURN_VALUE

Disassembly of <code object averager at 0x000002225DD1CBE0, file "<ipython-input-1-a43a8601eedd>", line 3>:
  4           0 LOAD_DEREF               0 (series)
              2 LOAD_METHOD              0 (append)
              4 LOAD_FAST                0 (value)
              6 CALL_METHOD              1
              8 POP_TOP

  5          10 LOAD_GLOBAL              1 (sum)
             12 LOAD_DEREF               0 (series)
             14 CALL_FUNCTION            1
             16 LOAD_GLOBAL              2 (len)
             18 LOAD_DEREF               0 (series)
             20 CALL_FUNCTION            1
             22 BINARY_TRUE_DIVIDE
             24 RETURN_VALUE
  • 读懂上面的,不是人干的事情,不过你依然有可能

    https://docs.python.org/zh-cn/3/library/dis.html#bytecodes
    

code属性

  • 怎么样不云里雾里呢

  • 查看avg.__code__属性

    [_ for _ in dir(avg.__code__) if _[:2]=='co']
    
    ['co_argcount',
     'co_cellvars',
     'co_code',
     'co_consts',
     'co_filename',
     'co_firstlineno',
     'co_flags',
     'co_freevars',
     'co_kwonlyargcount',
     'co_lnotab',
     'co_name',
     'co_names',
     'co_nlocals',
     'co_posonlyargcount',
     'co_stacksize',
     'co_varnames']
    
  • 官方解释

    属性 描述
    co_argcount 参数数量(不包括仅关键字参数、* 或 ** 参数)
    co_code 原始编译字节码的字符串
    co_cellvars 单元变量名称的元组(通过包含作用域引用)
    co_consts 字节码中使用的常量元组
    co_filename 创建此代码对象的文件的名称
    co_firstlineno 第一行在Python源码的行号
    co_flags CO_* 标志的位图,详见 此处
    co_lnotab 编码的行号到字节码索引的映射
    co_freevars 自由变量的名字组成的元组(通过函数闭包引用)
    co_posonlyargcount 仅限位置参数的数量
    co_kwonlyargcount 仅限关键字参数的数量(不包括 ** 参数)
    co_name 定义此代码对象的名称
    co_names 局部变量名称的元组
    co_nlocals 局部变量的数量
    co_stacksize 需要虚拟机堆栈空间
    co_varnames 参数名和局部变量的元组
  • 通过__code__分析

    def make_average(): 
        series = []
        def averager(value): 
            series.append(value)
            total = sum(series)
            return total/len(series)
        return averager 
    avg = make_average()
    avg.__code__.co_varnames  # 参数名和局部变量的元组
    # ('value', 'total')  # value是参数,total是局部变量名
    avg.__code__.co_freevars 
    # ('series',) # 自由变量的名字组成的元组(通过函数闭包引用)
    
    
    
    
    
  • 结合avg.__closure__

    avg.__closure__
    # (<cell at 0x000002225FA4DC70: list object at 0x000002225EE35600>,)
    # 这是个cell对象,list对象
    len(avg.__closure__) # 1
    avg.__closure__[0].cell_contents # [] 因为你还没调用
    avg(10)
    avg(20)
    avg(30)
    avg.__closure__[0].cell_contents # [10, 20, 30] 保存着真正的值
    
    
    
  • 闭包是一种函数,它会保留定义函数时存在的自由变量的绑定,这样调用函数时,虽然定义作用域不可用了,但是仍能使用那些绑定。

  • 只有嵌套在其他函数中的函数才可能需要处理不在全局作用域中的外部变量

nolocal 声明

  • 前面的make_averager 函数的方法效率不高

  • 因为我们把所有值存储在历史数列中,然后在每次调用 averager 时使用 sum 求和

  • 更好的实现方式是,只存储目前的总值和元素个数,然后使用这两个数计算均值

  • 所以你可能这样实现

    def make_average(): 
        total = 0
        length = 0
        def averager(value): 
            total = total + value
            length = length + 1
            return total/length
        return averager 
    avg = make_average()
    
    
  • 执行avg(10)的时候你就会报错

    UnboundLocalError                         Traceback (most recent call last)
    <ipython-input-11-ace390caaa2e> in <module>
    ----> 1 avg(10)
    
    <ipython-input-9-eaa25222e808> in averager(value)
          4     def averager(value):
          5         # nonlocal total,length
    ----> 6         total = total + value
          7         length = length + 1
          8         return total/length
    
    UnboundLocalError: local variable 'total' referenced before assignment
    
  • 这个问题你应该看到过,在前面的面试题002中看到过这样的错误

  • 关键的错误是在于

    total = total + value
    length = length + 1
    
  • 这样的赋值会把total和length都变成局部变量

    from dis import dis
    dis(make_average)
    
      2           0 LOAD_CONST               1 (0)
                  2 STORE_FAST               0 (total)
    
      3           4 LOAD_CONST               1 (0)
                  6 STORE_FAST               1 (length)
    
      4           8 LOAD_CONST               2 (<code object averager at 0x0000026A8ED0E660, file "<ipython-input-12-12a610cc685c>", line 4>)
                 10 LOAD_CONST               3 ('make_average.<locals>.averager')
                 12 MAKE_FUNCTION            0
                 14 STORE_FAST               2 (averager)
    
      8          16 LOAD_FAST                2 (averager)
                 18 RETURN_VALUE
    
    Disassembly of <code object averager at 0x0000026A8ED0E660, file "<ipython-input-12-12a610cc685c>", line 4>:
      5           0 LOAD_FAST                1 (total)
                  2 LOAD_FAST                0 (value)
                  4 BINARY_ADD
                  6 STORE_FAST               1 (total)
    
      6           8 LOAD_FAST                2 (length)
                 10 LOAD_CONST               1 (1)
                 12 BINARY_ADD
                 14 STORE_FAST               2 (length)
    
      7          16 LOAD_FAST                1 (total) #此处 LOAD_FAST 加载局部变量
                 18 LOAD_FAST                2 (length)
                 20 BINARY_TRUE_DIVIDE
                 22 RETURN_VALUE
    
  • 是对数字、字符串、元组等不可变类型来说,只能读取,不能更新。如果尝试重新绑定,例如 count = count + 1,其实会隐式创建局部变量 count。这样,count 就不是自由变量了,因此不会保存在闭包中

  • 为了解决这个问题,Python 3 引入了 nonlocal 声明。它的作用是把变量标记为自由变量,即使在函数中为变量赋予新值了,也会变成自由变量。如果为 nonlocal 声明的变量赋予新值,闭包中保存的绑定会更新。

  • 解决的代码文章来源地址https://www.toymoban.com/news/detail-409664.html

    def make_average(): 
        total = 0
        length = 0
        def averager(value):
            nonlocal total,length
            total = total + value
            length = length + 1
            return total/length
        return averager 
    avg = make_average()
    # 你就可以avg(10)这样了~
    

到了这里,关于Python常见面试题016. 请实现如下功能|谈谈你对闭包的理解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 谈谈你对倒排索引的理解

    谈谈你对倒排索引的理解 在聊倒排索引之前,我们需要先了解一下‘索引’概念。 什么是索引呢? 索引是为了加速对表中数据行的检索而创建的一种分散的存储结构 。 通俗的来讲索引好比就是 新华字段中拼音的首字母还有偏旁 ,根据拼音的首字母和偏旁能很快的查找到你

    2024年02月07日
    浏览(36)
  • 【面经】谈谈你对FastDFS的了解

    2024年02月06日
    浏览(39)
  • 谈谈你对 Spring AOP 的理解

    Java面试目录 谈谈你对 Spring AOP 的理解 Spring AOP是面向切面编程,通过代理模式来实现。 我们将与业务逻辑无关,同时又需要在业务执行前后调用的逻辑封装起来,利用代理来进行统一调度。可以减少系统的重复代码,降低耦合度,增加可维护性。使用场景包括:事务处理,

    2024年01月22日
    浏览(45)
  • 让我们谈谈你对 ThreadLocal 的理解

    从 JDK1.2 开始,ThreadLocal 是一个被用来存储线程本地变量的类。在 ThreadLocal 中的变量在线程之间是独立的。当多个线程访问 ThreadLocal 中的变量,它们事实上访问的是自己当前线程在内存中的变量,这能确保这些变量是线程安全的。 我们通常使用 ThreadLocal 解决线程中的变量冲

    2023年04月16日
    浏览(38)
  • 【面试题】谈谈你对IOC和AOP的理解

    IoC(Inverse of Control:控制反转)是一种设计思想,就是将 原本在程序中手动创建对象的控制权,交由Spring框架来管理 。IOC思想是基于IOC容器来完成的,IOC容器底层就是对象工厂(BeanFactory接口)。IOC的原理是基于xml解析、工厂设计模式、反射来实现的。 IoC 容器实际上就是个

    2024年02月05日
    浏览(76)
  • 1、什么是面向对象?谈谈你对面向对象的理解

    对比面向过程,是两种不同的处理问题的角度 面向过程更注重事情的每一个步骤及顺序,面向对象更注重事情有哪些参与者(对象)、及各自需要做什么 比如 : 洗衣机洗衣服 面向过程会将任务拆解成一系列的步骤(函数),1、打开洗衣机 …2、放衣服…3、放洗衣粉…4、清洗…

    2024年02月13日
    浏览(41)
  • 【面试八股文】每日一题:谈谈你对异常的理解

    每日一题-Java核心-谈谈你对异常的理解【面试八股文】   异常是程序在运行过程中出现的错误或不正常的情况。当程序执行过程中遇到无法处理的错误或者不符合预期的情况,就会抛出异常。异常可以分为两种类型: 受检异常 和 非受检异常 。    受检异常 是指在程序

    2024年02月13日
    浏览(52)
  • 【面试八股文】每日一题:谈谈你对线程的理解

    每日一题-Java核心-谈谈你对线程的理解【面试八股文】   Java线程是Java程序中的执行单元。一个Java程序可以同时运行多个线程,每个线程可以独立执行不同的任务。线程的执行是并发的,即多个线程可以同时执行。   Java中的线程有如下的特点 轻量级:线程的创建和销毁

    2024年02月12日
    浏览(43)
  • java常见面试题:什么是迭代器模式(Iterator Pattern)?如何实现迭代器模式?

    迭代器模式(Iterator Pattern)是设计模式中的一种,它提供了一种顺序访问一个聚合对象(如列表、集合等)中各个元素的方法,而又不需要暴露该对象的内部表示。使用迭代器模式,可以方便地遍历一个聚合对象的所有元素,而不需要了解该对象的底层结构。 迭代器模式主

    2024年01月18日
    浏览(54)
  • 分布式 - 谈谈你对分布式的理解,为什么引入分布式?

    不啰嗦,我们直接开始! 真正了解分布式系统的概念,日后工作中具有分布式系统设计思想。 能否在设计中对系统稳定性方面考虑周全。 能构建高 QPS 健壮的系统架构。 问题分析: 各种分布式框架层出不穷,Spring Cloud,阿里的 Dubbo,无论使用哪一个,原理都相同,考察下基

    2024年02月15日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包