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

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

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

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

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

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

Это просто принцип в отношении API-интерфейсов экспозиции.

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

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

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

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

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

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

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

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

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

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

Вы можете использовать его, чтобы избежать определения глобальных переменных. Это дает вам альтернативу другим дизайнам. 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

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

_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) позволяет использовать переменные в области внешней функции без необходимости объявлять их во внутренней функции. Может быть полезно в некоторых ситуациях.

Сделайте что-нибудь вроде:

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

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

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

Функция в функции 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))