Простой пример Два метода, один вызывается из другого:

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 это примерно эквивалентно:

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 для автоматической инкапсуляции методов.
• Вы будете без необходимости воссоздавать функциональный объект для идентичного кода каждый раз, когда запускаете внешнюю функцию .
• Если ваша функция действительно так проста, вы должны lambdaвместо этого использовать выражение .

Что является действительно хорошей причиной для определения функций внутри функций?

Когда то, что вы действительно хотите, это закрытие дингданга .

На самом деле нормально объявить одну функцию внутри другой. Это особенно полезно при создании декораторов.

Однако, как правило, если функция сложная (более 10 строк), лучше объявить ее на уровне модуля.

Я нашел этот вопрос, потому что хотел задать вопрос, почему это влияет на производительность, если кто-то использует вложенные функции. Я выполнил тесты для следующих функций, используя Python 3.2.5 на ноутбуке Windows с процессором Intel i5-2530M Quad Core 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 вложенных функций в функции, которую вы не вызываете, тогда время выполнения функции будет вдвое больше функции без вложенной функции. Я думаю, следует соблюдать осторожность при использовании вложенных функций.

Файл Python для всего теста, который генерирует этот вывод, можно найти в ideone .

Это просто принцип работы API-интерфейсов.

Используя python, рекомендуется избегать использования API в космическом пространстве (модуле или классе), функция является хорошим местом инкапсуляции.

Это может быть хорошей идеей. когда вы обеспечите

1. внутренняя функция используется ТОЛЬКО внешней функцией.
2. Инсайдерская функция имеет хорошее имя, чтобы объяснить ее назначение, потому что код говорит.
3. код не может напрямую понять ваши коллеги (или другие читатели кода).

Несмотря на то, что злоупотребление этой техникой может вызвать проблемы и подразумевает недостаток дизайна.

Просто из моего опыта, Может быть, неправильно понял ваш вопрос.

Таким образом, в конце концов, это в основном вопрос о том, насколько умна реализация Python или нет, особенно в случае, когда внутренняя функция не является замыканием, а просто функцией, необходимой только для помощника.

В чистом понятном дизайне, имеющем функции только там, где они необходимы и не раскрыты где-либо еще, хороший дизайн, независимо от того, встроены они в модуль, в класс как метод или внутри другой функции или метода. Когда все сделано хорошо, они действительно улучшают ясность кода.

И когда внутренняя функция является замыканием, это также может немного помочь с ясностью, даже если эта функция не возвращается из содержащей функции для использования в другом месте.

Поэтому я бы сказал, что в общем случае используйте их, но помните о возможном падении производительности, когда вы действительно обеспокоены производительностью, и удаляйте их только в том случае, если вы выполняете фактическое профилирование, которое показывает, что их лучше удалить.

Не делайте преждевременной оптимизации, просто используя «внутренние функции BAD» во всем написанном вами коде Python. Пожалуйста.

Это нормально, но если вам не нужно использовать замыкание или возвращать функцию, которую я, вероятно, поместил бы на уровне модуля. Я представляю, что во втором примере кода вы имеете в виду:

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

в противном случае some_data будет функцией.

Наличие этого на уровне модуля позволит другим функциям использовать method_b (), и если вы используете что-то вроде Sphinx (и autodoc) для документации, это также позволит вам документировать method_b.

Вы также можете рассмотреть возможность размещения функциональности в двух методах в классе, если вы делаете что-то, что может быть представлено объектом. Это также содержит логику, если это все, что вы ищете.

Сделать что-то вроде:

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

если бы вы запустили, some_function()он запустился бы some_other_function()и вернул 42.

РЕДАКТИРОВАТЬ: Я первоначально заявил, что вы не должны определять функцию внутри другого, но было отмечено, что это иногда целесообразно делать.

Вы можете использовать его, чтобы избежать определения глобальных переменных. Это дает вам альтернативу для других конструкций. 3 дизайна, представляющих решение проблемы.

А) Использование функций без глобалов

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

Б) Использование функций с глобальными

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