如果只有功能B需要功能A应该在B内定义A？

Question

简单的例子.两种方法,一种叫另一种方法:

def method_a(arg):
    some_data = method_b(arg)

def method_b(arg):
    return some_data

在Python中,我们可以def在另一个内部声明def.因此,如果method_b需要并且仅从中调用method_a,我应该method_b在内部声明method_a吗？像这样 :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b

或者我应该避免这样做？

Answer 1

>>> def sum(x, y):
...     def do_it():
...             return x + y
...     return do_it
... 
>>> a = sum(1, 3)
>>> a
<function do_it at 0xb772b304>
>>> a()
4

这是你在找什么？它被称为闭包.

Answer 2

通过这样做你并没有真正获得太多收益,实际上它会变慢method_a,因为它会在每次调用时定义并重新编译其他函数.鉴于此,最好只在函数名前加上下划线来表示它是一个私有方法 - 即_method_b.

我想你可能想要这样做,如果嵌套函数的定义每次因某种原因而变化,但这可能表明你的设计存在缺陷.这就是说,有是一个有效的理由这样做,允许嵌套函数使用传递给外部函数,但没有明确传递给他们,这写函数装饰器时,例如有时会发生争论.虽然没有定义或使用装饰器,但它是在接受的答案中显示的内容.

更新:

这里证明嵌套它们的速度较慢(使用Python 3.6.1),尽管在这个简单的案例中并不是很多:

setup = """
class Test(object):
    def separate(self, arg):
        some_data = self._method_b(arg)

    def _method_b(self, arg):
        return arg+1

    def nested(self, arg):

        def method_b2(self, arg):
            return arg+1

        some_data = method_b2(self, arg)

obj = Test()
"""
from timeit import Timer
print(min(Timer(stmt='obj.separate(42)', setup=setup).repeat()))  # -> 0.24479823284461724
print(min(Timer(stmt='obj.nested(42)', setup=setup).repeat()))    # -> 0.26553459700452575

注意我self在你的示例函数中添加了一些参数,使它们更像真实的方法(尽管method_b2在技​​术上仍然不是Test类的方法).此外,嵌套函数实际上是在该版本中调用的,与您的版本不同.

Answer 3

函数内部的函数通常用于闭包.

(有一个很大的竞争比究竟是什么使一个封闭的封闭.)

这是使用内置的示例sum().它定义start一次并从那时起使用它:

def sum_partial(start):
    def sum_start(iterable):
        return sum(iterable, start)
    return sum_start

正在使用:

>>> sum_with_1 = sum_partial(1)
>>> sum_with_3 = sum_partial(3)
>>> 
>>> sum_with_1
<function sum_start at 0x7f3726e70b90>
>>> sum_with_3
<function sum_start at 0x7f3726e70c08>
>>> sum_with_1((1,2,3))
7
>>> sum_with_3((1,2,3))
9

内置python封口

functools.partial 是一个闭包的例子.

从python文档中,它大致相当于:

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

(请到下面的@ user225312获得答案.我觉得这个例子比较容易理解,希望有助于回答@芒果的评论.)

Answer 4

通常,不,不要在函数内定义函数.

除非你有一个很好的理由.你没有.

为什么不？

• 它可以防止容易挂钩进行单元测试.你是单元测试,不是吗？
• 它实际上并没有完全混淆它,在python中没有任何东西是更安全的.
• 使用标准的Python自动代码样式指南来封装方法.
• 每次运行外部函数时,您将不必要地为相同的代码重新创建一个函数对象.
• 如果你的函数非常简单,那么你应该使用lambda表达式.

在函数内定义函数的真正原因是什么？

当你真正想要的是一个dingdang 闭合.

Answer 5

在另一个函数中声明一个函数实际上很好.这对创建装饰器特别有用.

但是,根据经验,如果函数很复杂(超过10行),最好在模块级别声明它.

Answer 6

我发现了这个问题,因为我想提出一个问题,即如果使用嵌套函数会导致性能影响.我在带有四核2.5 GHz Intel i5-2530M处理器的Windows笔记本上使用Python 3.2.5运行了以下功能的测试

def square0(x):
    return x*x

def square1(x):
    def dummy(y):
        return y*y
    return x*x

def square2(x):
    def dummy1(y):
        return y*y
    def dummy2(y):
        return y*y
    return x*x

def square5(x):
    def dummy1(y):
        return y*y
    def dummy2(y):
        return y*y
    def dummy3(y):
        return y*y
    def dummy4(y):
        return y*y
    def dummy5(y):
        return y*y
    return x*x

我测量了以下20次,也用于square1,square2和square5:

s=0
for i in range(10**6):
    s+=square0(i)

并得到以下结果

>>> 
m = mean, s = standard deviation, m0 = mean of first testcase
[m-3s,m+3s] is a 0.997 confidence interval if normal distributed

square? m     s       m/m0  [m-3s ,m+3s ]
square0 0.387 0.01515 1.000 [0.342,0.433]
square1 0.460 0.01422 1.188 [0.417,0.503]
square2 0.552 0.01803 1.425 [0.498,0.606]
square5 0.766 0.01654 1.979 [0.717,0.816]
>>> 

square0没有嵌套函数,square1有一个嵌套函数,square2有两个嵌套函数,square5有五个嵌套函数.嵌套函数仅被声明但未被调用.

因此,如果您在未调用的函数中定义了5个嵌套函数,则函数的执行时间是没有嵌套函数的函数的两倍.我认为在使用嵌套函数时应该谨慎.

可以在ideone中找到生成此输出的整个测试的Python文件.

Answer 7

这只是关于暴露 API 的一个原则。

使用python，最好避免暴露API在外部空间（模块或类），函数是一个很好的封装地方。

这可能是个好主意。当你确保

1. 内部函数仅由外部函数使用。
2. insider 函数有一个很好的名称来解释其目的，因为代码会说话。
3. 您的同事（或其他代码阅读器）无法直接理解代码。

尽管如此，滥用这种技术可能会导致问题并暗示设计缺陷。

仅从我的经验来看，也许误解了你的问题。

Answer 8

所以最终这主要是一个关于 python 实现有多智能的问题，特别是在内部函数不是闭包而只是一个函数中需要的助手的情况下。

在干净易懂的设计中，函数只在需要的地方使用而不在其他地方暴露是好的设计，无论它们是嵌入到模块中，作为方法的类，还是在另一个函数或方法中。如果做得好，它们确实会提高代码的清晰度。

当内部函数是一个闭包时，即使该函数没有从包含函数中返回以在其他地方使用，它也可以帮助清晰一些。

所以我会说通常会使用它们，但是当您真正关心性能时要注意可能的性能下降，并且只有在您进行实际分析表明它们最好被删除时才删除它们。

不要在您编写的所有 Python 代码中仅使用“内部函数 BAD”进行过早优化。请。