簡単な例。2つのメソッド、1つは別のメソッドから呼び出されます。

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(arg)

それとも私はこれを避けるべきですか？

>>> 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

これはあなたが探していたものですか？それはクロージャーと呼ばれます。

これを実行しても、それほど多くのことは得られません。実際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クラスのメソッドではありません）。また、ネストされた関数は実際にはそのバージョンでは呼び出されません。

関数内の関数は、一般的にクロージャに使用されます。

（がある競合の多くは、上で正確に何を作る閉鎖閉鎖。）

組み込みのを使用した例を次に示し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 docsから、それはおおよそ次と同等です：

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を称賛してください。この例はわかりやすいと思います。うまくいけば、@ mangoのコメントへの回答にも役立ちます。）

一般的に、いいえ、関数内で関数を定義しないでください。

本当に正当な理由がない限り。あなたはそうしません。

何故なの？

• ユニットテストの簡単なフックを防ぎます。あなたはユニットテストですよね？
• とにかく実際にそれを完全に難読化するわけではありません。これまでのpythonには何もないと仮定した方が安全です。
• 代わりに、標準のPython automagicコードスタイルガイドラインを使用してメソッドをカプセル化します。
• 外側の関数を実行するたびに、同じコードの関数オブジェクトを不必要に再作成することになります。
• 関数が本当に単純な場合は、lambda代わりに式を使用する必要があります。

関数内で関数を定義する本当に良い理由は何ですか？

何をすると、実際にしたいことはdingdangのある閉鎖。

ある関数を別の関数の内部で宣言することは実際には問題ありません。これは、デコレータの作成に特に役立ちます。

ただし、経験則として、関数が複雑な場合（10行を超える場合）、モジュールレベルで宣言することをお勧めします。

私がこの質問を見つけたのは、ネストされた関数を使用するとパフォーマンスに影響が出る理由を質問したかったからです。クワッドコア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入れ子関数がなく、square11つの入れ子関数があり、square22つの入れ子関数があり、square55つの入れ子関数があります。ネストされた関数は宣言されるだけで、呼び出されません。

したがって、呼び出さない関数で5つのネストされた関数を定義した場合、関数の実行時間は、ネストされた関数がない場合の2倍になります。入れ子関数を使用する場合は注意が必要です。

この出力を生成するテスト全体のPythonファイルは、ideoneにあります。

これは、公開APIに関する原則にすぎません。

Pythonを使用して、外部空間（モジュールまたはクラス）でAPIを公開しないようにすることをお勧めします。関数はカプセル化に適した場所です。

それは良い考えかもしれません。確認すると

1. 内部関数は外部関数でのみ使用されます。
2. インサイダー関数は、コードが語るので、その目的を説明するのに良い名前を持っています。
3. コードは、同僚（または他のコードリーダー）が直接理解することはできません。

とはいえ、この悪用は問題を引き起こす可能性があり、設計上の欠陥を意味します。

ちょうど私の経験から、多分あなたの質問を誤解しています。

したがって、最終的には、特に内部関数がクロージャーではなく、単に関数内でヘルパーのみが必要な場合は、Python実装がどれほど賢いかについての問題です。

モジュール、メソッドとしてのクラス、または別の関数やメソッドの内部に埋め込まれるかどうかに関係なく、必要な場所にのみ関数があり、他の場所に公開されていない、きれいに理解できるデザインでは、優れたデザインです。うまくやると、コードの明快さが本当に向上します。

そして、内部関数がクロージャーである場合、その関数が他の場所で使用するために包含関数から返されない場合でも、明確さをかなり助けることができます。

したがって、一般的にはそれらを使用すると言いますが、実際にパフォーマンスに懸念がある場合はパフォーマンスヒットの可能性があることに注意し、削除するのが最も良いことを示す実際のプロファイリングを行う場合にのみ削除してください。

作成するすべてのPythonコード全体で「内部関数BAD」を使用するだけでは、時期尚早の最適化を行わないでください。お願いします。

その方法でそれを行うのはまったく問題ありませんが、クロージャーを使用したり、関数を返す必要がない限り、おそらくモジュールレベルに配置します。私はあなたが意味する2番目のコード例を想像します：

...
some_data = method_b() # not some_data = method_b

それ以外の場合は、some_dataが関数になります。

モジュールレベルで使用すると、他の関数でmethod_b（）を使用できるようになり、ドキュメントにSphinx（およびautodoc）などを使用している場合は、method_bもドキュメント化できます。

また、オブジェクトで表現できるものを実行する場合は、機能をクラスの2つのメソッドに配置することを検討することもできます。それがあなたが探しているすべてであるならば、これはロジックもうまく含みます。

次のようなことをしてください：

def some_function():
    return some_other_function()
def some_other_function():
    return 42 

実行するsome_function()としたら実行されますsome_other_function()て42を返します。

編集：私は最初にあなたが別の中で関数を定義するべきではないと述べましたが、これを時々行うことが実用的であることが指摘されました。

これを使用して、グローバル変数の定義を回避できます。これにより、他の設計の代替案が得られます。問題の解決策を提示する3つの設計。

A）グローバルなしの関数の使用

def calculate_salary(employee, list_with_all_employees):
    x = _calculate_tax(list_with_all_employees)

    # some other calculations done to x
    pass

    y = # something 

    return y

def _calculate_tax(list_with_all_employees):
    return 1.23456 # return something

B）グローバルで関数を使用する

_list_with_all_employees = None

def calculate_salary(employee, list_with_all_employees):

    global _list_with_all_employees
    _list_with_all_employees = list_with_all_employees

    x = _calculate_tax()

    # some other calculations done to x
    pass

    y = # something

    return y

def _calculate_tax():
    return 1.23456 # return something based on the _list_with_all_employees var

C）別の関数内で関数を使用する

def calculate_salary(employee, list_with_all_employees):

    def _calculate_tax():
        return 1.23456 # return something based on the list_with_a--Lemployees var

    x = _calculate_tax()

    # some other calculations done to x
    pass
    y = # something 

    return y

ソリューションC）では、内部関数で変数を宣言する必要なく、外部関数のスコープで変数を使用できます。状況によっては役立つ場合があります。

関数python関数

def Greater(a,b):
    if a>b:
        return a
    return b

def Greater_new(a,b,c,d):
    return Greater(Greater(a,b),Greater(c,d))

print("Greater Number is :-",Greater_new(212,33,11,999))