Python 中的嵌套函数

Question

使用这样的 Python 代码我们可以得到什么好处或含义：

class some_class(parent_class):
    def doOp(self, x, y):
        def add(x, y):
            return x + y
        return add(x, y)

我在一个开源项目中发现了这一点，在嵌套函数内部做了一些有用的事情，但除了调用它之外，在外部绝对不做任何事情。 （实际代码可以找到这里。）为什么有人会这样编码？在嵌套函数内部而不是在外部普通函数中编写代码是否有一些好处或副作用？

Answer 1

通常，您这样做是为了创建闭包：

def make_adder(x):
    def add(y):
        return x + y
    return add

plus5 = make_adder(5)
print(plus5(12))  # prints 17

内部函数可以访问封闭范围内的变量（在本例中为局部变量x）。如果您没有从封闭范围访问任何变量，那么它们实际上只是具有不同范围的普通函数。

Answer 2

除了函数生成器之外，内部函数的创建几乎就是函数生成器的定义，我创建嵌套函数的原因是为了提高可读性。如果我有一个仅由外部函数调用的小函数，那么我会内联该定义，这样您就不必跳过来确定该函数正在做什么。如果我发现以后需要重用该函数，我总是可以将内部方法移到封装方法之外。

玩具示例：

import sys

def Foo():
    def e(s):
        sys.stderr.write('ERROR: ')
        sys.stderr.write(s)
        sys.stderr.write('\n')
    e('I regret to inform you')
    e('that a shameful thing has happened.')
    e('Thus, I must issue this desultory message')
    e('across numerous lines.')
Foo()

Answer 3

使用内部方法的一个潜在好处是，它允许您使用外部方法局部变量，而无需将它们作为参数传递。

def helper(feature, resultBuffer):
  resultBuffer.print(feature)
  resultBuffer.printLine()
  resultBuffer.flush()

def save(item, resultBuffer):

  helper(item.description, resultBuffer)
  helper(item.size, resultBuffer)
  helper(item.type, resultBuffer)

可以写成如下，可以说读起来更好

def save(item, resultBuffer):

  def helper(feature):
    resultBuffer.print(feature)
    resultBuffer.printLine()
    resultBuffer.flush()

  helper(item.description)
  helper(item.size)
  helper(item.type)

Answer 4

我无法想象这样的代码有什么好的理由。

也许旧版本中的内部功能是有原因的，就像其他操作一样。

例如，这使得稍微更有意义：

class some_class(parent_class):
    def doOp(self, op, x, y):
        def add(x, y):
            return x + y
        def sub(x,y):
            return x - y
        return locals()[op](x,y)

some_class().doOp('add', 1,2)

但是内部函数应该是（“私有”）类方法：

class some_class(object):
    def _add(self, x, y):
        return x + y
    def doOp(self, x, y):
        return self._add(x,y)

Answer 5

本地方法背后的想法与本地变量类似：不要污染更大的名称空间。显然，好处是有限的，因为大多数语言也不直接提供此类功能。

Answer 6

你确定代码是这样的吗？做这样的事情的正常原因是创建一个部分 - 一个带有内置参数的函数。调用外部函数会返回一个不需要参数的可调用对象，因此可以在无法传递参数的地方存储和使用。但是，您发布的代码不会执行此操作 - 它立即调用该函数并返回结果，而不是可调用的。发布您看到的实际代码可能会很有用。

Answer 7

在Python中，您可以使用嵌套函数来创建装饰器，例如@decorator。 *我的回答 解释了有关装饰器的更多信息。

我创建了 multiply_by_5() 来将其用作 sum() 的装饰器，如下所示：

# (4 + 6) x 5 = 50

def multiply_by_5(func):
    def core(*args, **kwargs):
        result = func(*args, **kwargs)
        return result * 5
    return core

@multiply_by_5 # Here
def sum(num1, num2):
    return num1 + num2

result = sum(4, 6)
print(result)

输出：

50

下面的代码是不使用装饰器的情况：

# (4 + 6) x 5 = 50

# ...

# @multiply_by_5
def sum(num1, num2):
    return num1 + num2

f1 = multiply_by_5(sum) # Here
result = f1(4, 6)
print(result)

或者：

# (4 + 6) x 5 = 50

# ...

# @multiply_by_5
def sum(num1, num2):
    return num1 + num2

result = multiply_by_5(sum)(4, 6) # Here
print(result)

输出:

50