blocks|key|1428389|text|局部方法背后的思想类似于局部变量:不要污染更大的名称空间。显然，这种好处是有限的，因为大多数语言都不直接提供这样的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1428390|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The idea behind local methods is similar to local variables: don't pollute the larger name space. Obviously the benefits are limited since most languages don't also provide such functionality directly.

blocks|key|1428418|text|你确定代码是这样的吗？这样做的正常原因是创建一个带有内置参数的partial+-a函数。调用外部函数会返回一个不需要参数的可调用函数，因此可以在不可能传递参数的地方存储和使用。但是，您发布的代码不会这样做-它会立即调用函数并返回结果，而不是可调用函数。发布您看到的实际代码可能会很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1428419|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Are you sure the code was exactly like this? The normal reason for doing something like this is for creating a partial - a function with baked-in parameters. Calling the outer function returns a callable that needs no parameters, and so therefore can be stored and used somewhere it is impossible to pass parameters. However, the code you've posted won't do that - it calls the function immediately and returns the result, rather than the callable. It might be useful to post the actual code you saw.

blocks|key|1428477|text|除了函数生成器，内部函数的创建几乎就是函数生成器的定义，我创建嵌套函数的原因是为了提高可读性。如果我有一个仅由外部函数调用的小函数，那么我会内联定义，这样您就不必跳过来确定该函数正在做什么。如果以后需要重用函数，我总是可以将内部方法移到封装方法之外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1428478|玩具示例：|1428479|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()|code-block|syntax|javascript|1428480|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Aside from function generators, where internal function creation is almost the definition of a function generator, the reason I create nested functions is to improve readability. If I have a tiny function that will only be invoked by the outer function, then I inline the definition so you don't have to skip around to determine what that function is doing. I can always move the inner method outside of the encapsulating method if I find a need to reuse the function at a later date.

Toy example:

<pre><code>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()
</code></pre>

blocks|key|1428519|text|使用内部方法的一个潜在好处是，它允许您使用外部方法局部变量，而无需将它们作为参数传递。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1428520|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)|code-block|syntax|javascript|1428521|可以像下面这样写，可以说读起来更好|1428522|def+save(item,+resultBuffer):

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

++helper(item.description)
++helper(item.size)
++helper(item.type)|1428523|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

One potential benefit of using inner methods is that it allows you to use outer method local variables without passing them as arguments.

<pre><code>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)
</code></pre>

can be written as follows, which arguably reads better

<pre><code>def save(item, resultBuffer):

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

 helper(item.description)
 helper(item.size)
 helper(item.type)
</code></pre>

What benefit or implications could we get with Python code like this:

<pre><code>class some_class(parent_class):
 def doOp(self, x, y):
 def add(x, y):
 return x + y
 return add(x, y)
</code></pre>

I found this in an open-source project, doing something useful inside the nested function, but doing absolutely nothing outside it except calling it. (The actual code can be found <a href="http://bazaar.launchpad.net/~openerp/openobject-server/trunk/annotate/1861/bin/report/render/rml2pdf/trml2pdf.py#L685" rel="noreferrer">here</a>.) Why might someone code it like this? Is there some benefit or side effect for writing the code inside the nested function rather than in the outer, normal function?

Nested Function in Python

Python

使用这样的Python代码，我们可以获得什么好处或暗示：class some_class(parent_class):    def doOp(self, x, y):        def add(x, y):            return x + y        return add(x, y)我在一个开源...

问Python中的嵌套函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的嵌套函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的嵌套函数
EN