高级测试面试题及答案Python函数式编程，Python入门

(1)闭包是携带自由变量的函数，即使创建闭包的外部函数的生命周期结束了，闭包所引用的自由变量仍会存在。

(2)闭包在运行可以有多个实例。

(3)尽量不要在闭包中引用循环变量，或者后续会发生变化的变量。

6 装饰器

---

我们知道，在 Python 中，我们可以像使用变量一样使用函数：

(1)函数可以被赋值给其他变量

(2)函数可以被删除

(3)可以在函数里面再定义函数

(4)函数可以作为参数传递给另外一个函数

(5)函数可以作为另一个函数的返回

简而言之，函数就是一个对象。

6.1 对一个简单的函数进行装饰

为了更好地理解装饰器，我们先从一个简单的例子开始，假设有下面的函数：

1. def hello ():

2.          return ‘hello world’

现在我们想增强 hello() 函数的功能，希望给返回加上 HTML 标签，比如 hello

world ，但是有一个要求，不改变原来 hello() 函数的定义。这里当然有很多种方法，下面

给出一种跟本文相关的方法：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return “” + func () + “”

4.          return wrapped

在上面的代码中，我们定义了一个函数 makeitalic ，该函数有一个参数 func ，它是一个函

数；在 makeitalic 函数里面我们又定义了一个内部函数 wrapped ，并将该函数作为返回。

现在，我们就可以不改变 hello() 函数的定义，给返回加上 HTML 标签了：

1. >>> hello = makeitalic ( hello ) # 将 hello 函数传给 makeitalic

2. >>> hello ()

3. ‘hello world’

在上面，我们将 hello 函数传给 makeitalic ，再将返回赋给 hello ，此时调用

hello() 就得到了我们想要的结果。

不过要注意的是，由于我们将 makeitalic 的返回赋给了 hello ，此时 hello() 函数仍

然存在，但是它的函数名不再是 hello 了，而是 wrapped ，正是 makeitalic 返回函数的名

称，可以验证一下：

1. >>> hello . __name__

2. ‘wrapped’

对于这个小瑕疵，后文将会给出解决方法。

现在，我们梳理一下上面的例子，为了增强原函数 hello 的功能，我们定义了一个函数，它接收

原函数作为参数，并返回一个新的函数，完整的代码如下：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return “” + func () + “”

4.         return wrapped

6. def hello ():

7.          return ‘hello world’

9. hello = makeitalic ( hello )

事实上， makeitalic 就是一个装饰器（ decorator ），它『装饰』了函数 hello ，并返回一

个函数，将其赋给 hello 。

一般情况下，我们使用装饰器提供的 @ 语法糖（ Syntactic Sugar ），来简化上面的写法：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return “” + func () + “”

4.          return wrapped

6. @makeitalic

7. def hello ():

8.         ` return ‘hello world’

像上面的情况，可以动态修改函数（或类）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的 hello ）为参数，并返回一个包装后的函数（比如上面的 wrapped ）给被装饰函数（hello ）。

6.2 装饰器的使用形式

装饰器的一般使用形式如下：

1. @decorator

2.          def func ():

3. pass

等价于下面的形式：

1. def func ():

2.          pass

3. func = decorator ( func )

装饰器可以定义多个，离函数定义最近的装饰器先被调用，比如：

1. @decorator_one

2. @decorator_two

3. def func ():

4.          pass

等价于：

1. def func ():

2.          pass

4. func = decorator_one ( decorator_two ( func ))

装饰器还可以带参数，比如：

1. @decorator ( arg1 , arg2 )

2. def func ():

3.          pass

等价于：

1. def func ():

2.          pass

4. func = decorator ( arg1 , arg2 )( func )

下面我们再看一些具体的例子，以加深对它的理解。

6.3 对带参数的函数进行装饰

前面的例子中，被装饰的函数 hello() 是没有带参数的，我们看看被装饰函数带参数的情况。对

前面例子中的 hello() 函数进行改写，使其带参数，如下：

1. def makeitalic ( func ):

2.          def wrapped (* args , ** kwargs ):

3.                  ret = func (* args , ** kwargs )

4.                 return ‘’ + ret + ‘’

5.          return wrapped

7. @makeitalic

8. def hello ( name ):

9. return ‘hello %s’ % name

11. @makeitalic

12. def hello2 ( name1 , name2 ):

13. return ‘hello %s, %s’ % ( name1 , name2 )

由于函数 hello 带参数，因此内嵌包装函数 wrapped 也做了一点改变：

内嵌包装函数的参数传给了 func ，即被装饰函数，也就是说内嵌包装函数的参数跟被装饰函数

的参数对应，这里使用了 (*args, **kwargs) ，是为了适应可变参数。

看看使用：

1. >>> hello ( ‘python’ )

2. ‘hello python’

3. >>> hello2 ( ‘python’ , ‘java’ )

4. ‘hello python, java’

6.4 带参数的装饰器

上面的例子，我们增强了函数 hello 的功能，给它的返回加上了标签 … ，现在，我

们想改用标签 … 或

…

。是不是要像前面一样，再定义一个类似

makeitalic 的装饰器呢？其实，我们可以定义一个函数，将标签作为参数，返回一个装饰器，比

如：

1. def wrap_in_tag ( tag ):

2.          def decorator ( func ):

3.                  def wrapped (* args , ** kwargs ):

4.                          ret = func (* args , ** kwargs )

5.                  return ‘<’ + tag + ‘>’ + ret + ‘</’ + tag + ‘>’

6.          return wrapped

8. return decorator

现在，我们可以根据需要生成想要的装饰器了：

1. makebold = wrap_in_tag ( ‘b’ ) # 根据 ‘b’ 返回 makebold 生成器

3. @makebold

4. def hello ( name ):

5.         return ‘hello %s’ % name

7. >>> hello ( ‘world’ )

8. ‘hello world’

上面的形式也可以写得更加简洁：

1. @wrap_in_tag ( ‘b’ )

2. def hello ( name ):

3.          return ‘hello %s’ % name

这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。

6.5 多个装饰器

现在，让我们来看看多个装饰器的例子，为了简单起见，下面的例子就不使用带参数的装饰器。

1. def makebold ( func ):

2.          def wrapped ():

3.                  return ‘’ + func () + ‘’

5.         return wrapped

7. def makeitalic ( func ):

8.          def wrapped ():

9.                  return ‘’ + func () + ‘’

11.         return wrapped

13. @makebold

14. @makeitalic

15. def hello ():

16. return ‘hello world’

上面定义了两个装饰器，对 hello 进行装饰，上面的最后几行代码相当于：

1. def hello ():

2.          return ‘hello world’

4. hello = makebold ( makeitalic ( hello ))

调用函数 hello ：

1. >>> hello ()

2. ‘hello world’

6.6 基于类的装饰器

前面的装饰器都是一个函数，其实也可以基于类定义装饰器，看下面的例子：

1. class Bold ( object ):

2.          def __init__ ( self , func ):

3.                  self . func = func

5.          def __call__ ( self , * args , ** kwargs ):

6.                  return ‘’ + self . func (* args , ** kwargs ) + ‘’

8. @Bold

9. def hello ( name ):

10.         return ‘hello %s’ % name

12. >>> hello ( ‘world’ )

13. ‘hello world’

可以看到，类 Bold 有两个方法：

__init__() ：它接收一个函数作为参数，也就是被装饰的函数

__call__() ：让类对象可调用，就像函数调用一样，在调用被装饰函数时被调用

还可以让类装饰器带参数：

1. class Tag ( object ):

2.         def __init__ ( self , tag ):

3.                 self . tag = tag

5.          def __call__ ( self , func ):

6.                  def wrapped (* args , ** kwargs ):

7.                         return “<{tag}>{res}</{tag}>” . format (

8.                                 res = func (* args , ** kwargs ), tag = self . tag

9.                                 )

10.                 return wrapped

12. @Tag ( ‘b’ )

13. def hello ( name ):

14.         return ‘hello %s’ % name

需要注意的是，如果类装饰器有参数，则 __init__ 接收参数，而 __call__ 接收 func 。

6.7 装饰器的副作用

前面提到，使用装饰器有一个瑕疵，就是被装饰的函数，它的函数名称已经不是原来的名称了，回到最开始的例子：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return “” + func () + “”

4.          return wrapped

6. @makeitalic

7. def hello ():

8.          return ‘hello world’

函数 hello 被 makeitalic 装饰后，它的函数名称已经改变了：

1. >>> hello . __name__

2. ‘wrapped’

为了消除这样的副作用， Python 中的 functools 包提供了一个 wraps 的装饰器：

1. from functools import wraps

3. def makeitalic ( func ):

4.          @wraps ( func ) # 加上 wraps 装饰器

5.          def wrapped ():

6.                  return “” + func () + “”

7.         return wrapped

9. @makeitalic

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

hon常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算