Python 데코레이터의 개념과 의미에 대한 심층적인 이해

아마도 데코레이터를 사용해 본 적이 있을 것입니다. 그 사용법은 매우 간단하지만 이해하기 어렵습니다(사실 이해하기도 매우 간단합니다). 데코레이터를 이해하려면 함수형 프로그래밍의 개념, 파이썬 함수의 정의 및 문법을 이해해야 합니다. 비록 데코레이터를 단순하게 만들 수는 없지만 다음 단계를 통해 가장 단순한 것부터 더 깊은 것까지 데코레이터가 무엇인지 이해할 수 있기를 바랍니다. 여러분이 Python에 대한 가장 기본적인 지식을 가지고 있다는 가정 하에, 이 글에서 설명하는 내용은 직장에서 Python을 자주 접하는 사람들에게 큰 도움이 될 수 있습니다. Python의 데코레이터를 단계별로 이해해 보겠습니다.

1. 함수

Python에서 함수는 def 키워드와 함수 이름 및 선택적 매개변수 목록을 사용하여 생성됩니다. return이라는 단어는 반환 값을 지정합니다. 가장 간단한 함수를 만들고 호출해 보겠습니다.

>>> def foo():
...     return 1
>>> foo()
1

함수 본문(Python에서는 여러 줄로 구성된 명령문)은 필수이며 들여쓰기로 표시됩니다. 함수 이름 뒤에 이중 괄호를 추가하여 함수를 호출할 수 있습니다.

2. 범위

파이썬에서는 모든 함수가 범위를 생성합니다. Pythonistas는 함수에 자체 네임스페이스가 있다고 말할 수도 있습니다. 이는 함수 본문에서 변수 이름이 발견되면 Python이 먼저 함수의 네임스페이스를 검색한다는 의미입니다. Python에는 네임스페이스를 볼 수 있는 몇 가지 함수가 포함되어 있습니다. 로컬 범위와 전역 범위의 차이점을 살펴보는 간단한 함수를 작성해 보겠습니다.

>>> a_string = "This is a global variable"
>>> def foo():
...     print locals()
>>> print globals() # doctest: +ELLIPSIS
{..., 'a_strin': 'This ia a global variable'}
>>> foo() # 2
{}

내장 전역 함수는 Python이 알고 있는 모든 변수 이름이 포함된 사전 개체를 반환합니다(명확성을 위해 Python에서 자동으로 생성된 일부 변수는 생략했습니다). #2에서는 함수 내부의 로컬 네임스페이스의 내용을 인쇄하는 foo 함수를 호출했습니다. 보시다시피 foo 함수에는 현재 비어 있는 자체 독립 네임스페이스가 있습니다.

3. 변수 결정 규칙

물론 이것이 함수 내부의 전역 변수에 접근할 수 없다는 의미는 아닙니다. Python의 범위 규칙은 변수를 생성하면 항상 새로운 지역 변수가 생성되지만 변수에 대한 액세스(수정 포함)는 먼저 지역 범위를 검색한 다음 가장 가까운 범위를 따라 일치 항목을 찾는다는 것입니다. 따라서 전역 변수를 인쇄하도록 foo 함수를 수정하면 결과는 우리가 원하는 것과 같습니다:

>>> a_string = "This is global variable"
>>> def foo():
...     print a_string # 1
>>> foo()
This is a global variable

#1에서 Python은 함수에서 지역 변수를 찾았지만 찾지 못했습니다. 전역 변수에 있는 동일한 이름의 변수입니다.

반면에 함수의 전역 변수에 값을 할당하려고 하면 결과는 우리가 원하는 것과 같지 않습니다.

>>> a_string = 'This is a global variable"
>>> def foo():
...     a_string = "test" # 1
...        print locals()
>>> foo()
{'a_string': 'test'}
>>> a_string # 2
'This is a global variable'

보시다시피 전역 변수에 액세스할 수 있습니다(심지어 변경되는 경우에도). 변경 가능한 유형)이지만 (기본적으로) 값을 할당할 수 없습니다. 함수 내부 #1에서는 실제로 전역 변수와 동일한 이름을 가진 새 지역 변수를 생성하여 전역 변수를 덮어씁니다. foo 함수 내부의 로컬 네임스페이스를 인쇄하면 이미 항목이 있음을 알 수 있습니다. 함수 외부 #2의 출력에서 ​​변수 a_string의 값이 전혀 변경되지 않았음을 알 수 있습니다.

4. 변수 수명

또한 변수에는 네임스페이스에 "살아 있을" 뿐만 아니라 수명 주기도 있다는 점에 유의하세요. 다음 코드를 고려하십시오.

>>> def foo():
...     x = 1
>>> foo()
>>> print x # 1
Traceback (most recent call last):
...
NameError: name 'x' is not defined

#1의 문제는 범위 지정 규칙 때문일 뿐만 아니라(이것이 NameError의 원인임에도 불구하고) Python 및 기타 여러 언어의 함수 호출 구현으로 인해 발생합니다. 여기서는 변수 x의 값을 얻는 데 사용할 수 있는 구문이 없습니다. 문자 그대로 존재하지 않습니다. foo가 호출될 때마다 해당 네임스페이스는 다시 작성되고 함수가 종료되면 제거됩니다.

5. 함수 매개변수

Python을 사용하면 매개변수를 함수에 전달할 수 있습니다. 매개변수 이름은 함수의 지역 변수가 됩니다.

>>> def foo(x):
...        print locals()
>>> foo(1)
{'x': 1}

Python에는 함수 매개변수를 정의하고 전달하는 다양한 방법이 있습니다. 더 자세한 설명은 함수 정의에 대한 Python 설명서를 참조하세요. 여기서는 단순화된 버전을 보여줍니다. 함수 매개변수는 필수 위치 매개변수이거나 명명된 매개변수일 수 있으며 매개변수의 기본값은 선택사항입니다.

>>> def foo(x, y=0): # 1
...     return x - y
>>> foo(3, 1) # 2
2
>>> foo(3) # 3
3
>>> foo() # 4
Traceback (most recent call last):
...
TypeError: foo() takes at least 1 argument (0 given)
>>> foo(y=1, x=3) # 5
2

#1에서 우리는 위치 매개변수 x와 명명된 매개변수 y를 사용하여 함수를 정의했습니다. 보시다시피, #2에서는 매개변수(번역자 주: 여기에서는 매개변수 y를 나타냄)가 함수 정의에서 명명된 매개변수로 정의된 경우에도 일반 값 전달을 통해 함수를 호출할 수 있습니다. #3에서는 명명된 매개변수에 대한 값을 전달하지 않고도 함수를 호출할 수 있음을 알 수 있습니다. foo 함수가 명명된 매개변수 y에 전달된 값을 받지 못하면 Python은 우리가 선언한 기본값 0을 사용합니다. 기능. 물론, 첫 번째(필수, 위치가 잘 지정된) 매개변수를 놓칠 수 없습니다. #4에서는 이 오류를 예외로 설명합니다.

都很清晰和直接，不是吗？下面变得有点儿让人疑惑——Python也支持函数调用时的命名参数而不只是在函数定义时。请看#5处，这里我们用两个命名参数调用函数，尽管这个函数是以一个命名和一个位置参数来定义的。因为我们的参数有名字，所以我们传递的参数的位置不会产生任何影响。 相反的情形当然也是正确的。我们的函数的一个参数被定义为一个命名参数但是我们通过位置传递参数—— #4处的调用foo(3, 1)将一个3作为第一个参数传递给我们排好序的参数x并将第二个参数（整数1）传递给第二个参数，尽管它被定义为一个命名参数。

Whoo!这就像用很多话来描述一个非常简单的概念：函数的参数可以有名称或者位置。

6、内嵌函数（Nested functions）

Python允许创建嵌套函数，这意味着我们可以在函数内声明函数并且所有的作用域和声明周期规则也同样适用。

>>> def outer():
...     x = 1
...     def inner():
...         print x # 1
...     inner() # 2
...
>>> outer()
1

这看起来稍显复杂，但其行为仍相当直接，易于理解。考虑一下在#1处发生了什么——Python寻找一个名为x的local变量，失败了，然后在最邻近的外层作用域里搜寻，这个作用域是另一个函数！变量x是函数outer的local变量，但是和前文提到的一样，inner函数拥有对外层作用域的访问权限（最起码有读和修改的权限）。在#2处我们调用了inner函数。请记住inner也只是一个变量名，它也遵从Python的变量查找规则——Python首先在outer的作用域里查找之，找到了一个名为inner的local变量。

7、函数是一等公民（Functions are first class objects in Python）

在Python中，这是一个常识，函数是和其它任何东西一样的对象。呃，函数包含变量，它不是那么的特殊！

>>> issubclass(int, object) # all objects in Python inherit from a common baseclass
True
>>> def foo():
...     pass
>>> foo.__class__ # 1>>> issubclass(foo.__class__, object)
True

你也许从没想到过函数也有属性，但是在Python中，和其它任何东西一样，函数是对象。（如果你发觉这令你感到困惑，请等一下，知道你了解到在Python中像其它任何东西一样，class也是对象！）也许正是因为这一点使Python多少有点“学术”的意味——在Python中像其它任何值一样只是常规的值而已。这意味着你可以将函数作为参数传递给函数或者在函数中将函数作为返回值返回！如果你从未考虑过这种事情请考虑下如下的合法Python代码：

>>> def add(x, y):
...     return x + y
>>> def sub(x, y):
...     return x - y
>>> def apply(func, x, y): # 1
...     return func(x, y) # 2
>>> apply(add, 2, 1) # 3
3
>>> apply(sub, 2, 1)
1

这个例子对你来说可能也不是太奇怪——add和sub是标准的Python函数，它们都接受两个值并返回一个计算了的结果。在#1处你可以看到变量接受一个函数就像其它任何普通的变量。在#2处我们调用传入apply的函数——在Python里双括号是调用操作符，并且调用变量名包含的值。在#3处你可以看出在Python中将函数当做值进行传递并没有任何特殊语法——函数名就像任何其它变量一样只是变量标签。

你之前可能见过这种行为——Python将函数作为参数经常见于像通过为key参数提供一个函数来自定义sorted内建函数等操作中。但是，将函数作为返回值返回会怎样呢？请考虑：

>>> def outer():
...     def inner():
...         print "Inside inner"
...     return inner # 1
...
>>> foo = outer() #2
>>> foo # doctest:+ELLIPSIS
<function inner at 0x...>
>>> foo()
Inside inner

这乍看起来有点奇怪。在#1处我返回了变量inner，它碰巧是一个函数标签。这里没有特殊语法——我们的函数返回了inner函数（调用outer()函数并不产生可见的执行）。还记得变量的生命周期吗？每当outer函数被调用时inner函数就会重新被定义一次，但是如果inner函数不被(outer)返回那么当超出outer的作用域后，inner将不复存在了。

在#2处我们可以获取到返回值，它是我们的inner函数，它被存储于一个新的变量foo。我们可以看到，如果我们计算foo，它真的包含inner函数，我们可以通过使用调用运算符（双括号，还记得吗？）来调用它。这看起来可能有点怪异，但是到目前为止没有什么难以理解，不是么？挺住，因为接下来的东西将会很怪异。

8、闭包（Closures）

让我们不从定义而是从另一个代码示例开始。如果我们将上一个例子稍加修改会怎样呢？

>>> def outer():
...     x = 1
...     def inner():
...         print x # 1
...     return inner
>>> foo = outer()
>>> foo.func_closure # doctest: +ELLIPSIS
(<cell at 0x...: int object at 0x...>,)

从上一个例子中我们看到inner是一个由outer返回的函数，存储于一个名为foo的变量，我们可以通过foo()调用它。但是它能运行吗？让我们先来考虑一下作用域规则。

一切都依照Python的作用域规则而运行——x是outer函数了一个local变量。当inner在#1处打印x时，Python在inner中寻找一个local变量，没有找到；然后它在外层作用域即outer函数中寻找并找到了它。

但是自此处从变量生命周期的角度来看又会如何呢？变量x是函数outer的local变量，这意味着只有当outer函数运行时它才存在。只有当outer返回后我们才能调用inner，因此依照我们关于Python如何运作的模型来看，在我们调用inner的时候x已经不复存在了，那么某个运行时错误可能会出现。

事实与我们的预想并不一致，返回的inner函数的确正常运行。Python支持一种称为闭包(function closures)的特性，这意味着定义于非全局作用域的inner函数在定义时记得它们的外层作用域长什么样。这可以通过查看inner函数的func_closure属性来查看，它包含了外层作用域里的变量。

请记住，每次当outer函数被调用时inner函数都被重新定义一次。目前x的值没有改变，因此我们得到的每个inner函数和其它的inner函数拥有相同的行为，但是如果我们将它做出一点改变呢？

>>> def outer(x):
...     def inner():
...         print x # 1
...        return inner
>>> print1 = outer(1)
>>> print2 = outer(2)
>>> print1()
1
>>> print2()
2

从这个例子中你可以看到closures——函数记住他们的外层作用域的事实——可以用来构建本质上有一个硬编码参数的自定义函数。我们没有将数字1或者2传递给我们的inner函数但是构建了能"记住"其应该打印数字的自定义版本。

closures就是一个强有力的技术——你甚至想到在某些方面它有点类似于面向对象技术：outer是inner的构造函数，x扮演着一个类似私有成员变量的角色。它的作用有很多，如果你熟悉Python的sorted函数的key参数，你可能已经写过一个lambda函数通过第二项而不是第一项来排序一些列list。也许你现在可以写一个itemgetter函数，它接收一个用于检索的索引并返回一个函数，这个函数适合传递给key参数。

但是让我们不要用闭包做任何噩梦般的事情！相反，让我们重新从头开始来写一个decorator!

9、装饰器（Decorators）

一个decorator只是一个带有一个函数作为参数并返回一个替换函数的闭包。我们将从简单的开始一直到写出有用的decorators。

>>> def outer(some_func):
...        def inner():
...            print "before some_func"
...            ret = some_func() # 1
...            return ret + 1
...        return inner
>>> def foo():
...        return 1
>>> decorated = outer(foo) # 2
>>> decorated()
before some_func
2

请仔细看我们的decorator实例。我们定义了一个接受单个参数some_func的名为outer的函数。在outer内部我们定义了一个名为inner的嵌套函数。inner函数打印一个字符串然后调用some_func，在#1处缓存它的返回值。some_func的值可能在每次outer被调用时不同，但是无论它是什么我们都将调用它。最终，inner返回some_func的返回值加1，并且我们可以看到，当我们调用存储于#2处decorated里的返回函数时我们得到了输出的文本和一个返回值2而不是我们期望的调用foo产生的原始值1.

我们可以说decorated变量是foo的一个“装饰”版本——由foo加上一些东西构成。实际上，如果我们写了一个有用的decorator，我们可能想用装饰后的版本来替换foo，从而可以得到foo的“增添某些东西”的版本。我们可以不用学习任何新语法而做到这一点——重新将包含我们函数的变量进行赋值：

>>> foo = outer(foo)
>>> foo # doctest: +ELLIPSIS
<function inner at 0x...>

现在任何对foo()的调用都不会得到原始的foo，而是会得到我们经过装饰的版本！领悟到了一些decorator的思想吗？

10、装饰器的语法糖--@符号（The @ symbol applies a decorator to a function）

Python 2.4通过在函数定义前添加一个@符号实现对函数的包装。在上面的代码示例中，我们用一个包装了的函数来替换包含函数的变量来实现了包装。

>>> add = wrapper(add)

这一模式任何时候都可以用来包装任何函数，但是如果们定义了一个函数，我们可以用@符号像下面示例那样包装它：

>>> @wrapper
... def add(a, b):
...     return Coordinate(a.x + b.x, a.y + b.y)

请注意，这种方式和用wrapper函数的返回值来替换原始变量并没有任何不同，Python只是增添了一些语法糖(syntactic sugar)让它看起来更明显一点。

11、*args and **kwargs

我们已经写了一个有用的decorator，但是它是硬编码的，它只适用于特定种类的函数——带有两个参数的函数。我们函数内部的checker函数接受了两个参数，然后继续将参数闭包里的函数。如果我们想要一个能包装任何类型函数的decorator呢？让我们实现一个在不改变被包装函数的前提下对每一次被包装函数的调用增添一次计数的包装器。这意味着这个decorator需要接受所有待包装的任何函数并将传递给它的任何参数传递给被包装的函数来调用它（被包装的函数）。

这种情况很常见，所以Python为这一特性提供了语法支持。请确保阅读Python Tutorial以了解更多，但是在函数定义时使用*运算符意味着任何传递给函数的额外位置参数最终以一个*作为前导。因此：

>>> def one(*args):
...     print args # 1
>>> one()
()
>>> one(1, 2, 3)
(1, 2, 3)
>>> def two(x, y, *args): # 2
...     print x, y, args
>>> two('a', 'b', 'c')
a b ('c')

第一个函数one只是简单的将任何（如果有）传递给它的位置参数打印出来。正如你在#1处见到的，在函数内部我们只是引用了args变量——*args只是表明在函数定义中位置参数应该保存在变量args中。Python也允许我们指定一些变量并捕获到任何在args变量里的其它参数，正如#2处所示。

*运算符也可以用于函数调用中，这时它也有着类似的意义。在调用一个函数时带有一个以*为前导的变量作为参数表示这个变量内容需要被解析然后用作位置参数。再一次以实例来说明：

>>> def add(x, y):
...     return x + y
>>> lst = [1, 2]
>>> add(lst[0], lst[1]) # 1
3
>>> add(*lst) # 2
3

#1处的代码抽取出了和#2处相同的参数——在#2处Python为我们自动解析了参数，我们也可以像在#1处一样自己解析出来。这看起来不错，*args既表示当调用函数是从一个iterable抽取位置参数，也表示当定义一个函数是接受任何额外的位置变量。

当我们引入**时，事情变得更加复杂点，与*表示iterables和位置参数一样，**表示dictionaries & key/value对。很简单，不是么？

>>> def foo(**kwargs):
...     print kwargs
>>> foo()
{}
>>> foo(x=1, y=2)
{'y': 2, 'x': 1}

当我们定义一个函数时我们可以用**kwargs表明所有未捕获的keyword变量应该被存储在一个名为kwargs的字典中。前面的例子中的args和本例中的kwargs都不是Python语法的一部分，但是在函数定义时使用这两个作为变量名时一种惯例。就像一样，我们可以在函数调用时使用\*。

>>> dct = {'x': 1, 'y': 2}
>>> def bar(x, y):
...     rturn x + y
>>> bar(**dct)
3

12、更通用的装饰器（More generic decorators）

用我们掌握的新“武器”我们可以写一个decorator用来“记录”函数的参数。为了简单起见，我们将其打印在stdout上：

>>> def logger(func):
...     def inner(*args, **kwargs): # 1
...     print "Arguments were: %s, %s" % (args, kwargs)
...     return func(*args, **kwargs) # 2
... return inner

注意到在#1处inner函数带有任意数量的任何类型的参数，然后在#2处将它们传递到被包装的函数中。这允许我们包装或者装饰任何函数。

>>> @logger
... def foo1(x, y=1):
...     return x * y
>>> @logger
... def foo2():
...     return 2
>>> foo1(5, 4)
Arguments were: (5, 4), {}
20
>>> foo1(1)
Arguments were: (1,), {}
1
>>> foo2()
Arguments were: (),{}
2

对函数的调用会产生一个"logging"输出行，也会输出一个如我们期望的函数返回值。

如果你一直跟到了最后一个实例，祝贺你，你已经理解了decorators了！

위 내용은 Python 데코레이터의 개념과 의미에 대한 심층적인 이해의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!