Вкладена функція в Python

Яку користь чи наслідки ми могли б отримати з кодом Python, як це:

class some_class(parent_class):
    def doOp(self, x, y):
        def add(x, y):
            return x + y
        return add(x, y)

Я знайшов це у проекті з відкритим кодом, виконуючи щось корисне всередині вкладеної функції, але не роблячи абсолютно нічого за її межами, окрім виклику. (Фактичний код можна знайти тут .) Чому хтось може кодувати його так? Чи є якась перевага або побічний ефект від написання коду всередині вкладеної функції, а не зовнішньої, звичайної функції?

Зазвичай ви робите це, щоб зробити закриття :

def make_adder(x):
    def add(y):
        return x + y
    return add

plus5 = make_adder(5)
print(plus5(12))  # prints 17

Внутрішні функції можуть отримувати доступ до змінних із області, що охоплює (у цьому випадку локальної змінної x). Якщо ви не отримуєте доступ до будь-яких змінних із охоплюючої області, це насправді просто звичайні функції з іншою сферою.

Окрім генераторів функцій, де створення внутрішніх функцій є майже визначенням генератора функцій, я створюю вкладені функції для покращення читабельності. Якщо у мене є крихітна функція, яка буде викликана лише зовнішньою функцією, тоді я вбудовую визначення, щоб вам не потрібно було пропускати, щоб визначити, що ця функція робить. Я завжди можу перемістити внутрішній метод за межі методу інкапсуляції, якщо виявлю необхідність повторного використання функції пізніше.

Приклад іграшки:

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

Однією з потенційних переваг використання внутрішніх методів є те, що це дозволяє використовувати локальні змінні зовнішнього методу, не передаючи їх як аргументи.

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)

можна написати так, що, мабуть, читається краще

def save(item, resultBuffer):

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

  helper(item.description)
  helper(item.size)
  helper(item.type)

Я не можу уявити жодної вагомої причини для такого коду.

Можливо, в старих версіях, як і в інших операційних програмах, була причина для внутрішньої функції.

Наприклад, це має трохи більше сенсу:

class some_class(parent_class):
    def doOp(self, op, x, y):
        def add(x, y):
            return x + y
        def sub(x,y):
            return x - y
        return locals()[op](x,y)

some_class().doOp('add', 1,2)

але тоді внутрішня функція повинна бути ("приватним") методом класу:

class some_class(object):
    def _add(self, x, y):
        return x + y
    def doOp(self, x, y):
        return self._add(x,y)

Ідея локальних методів подібна до локальних змінних: не забруднюйте більший простір імен. Очевидно, що переваги обмежені, оскільки більшість мов також не надають таких функцій безпосередньо.

Ви впевнені, що код був саме таким? Звичайна причина робити щось подібне полягає у створенні часткової - функції із запеченими параметрами. Виклик зовнішньої функції повертає виклик, який не потребує параметрів, і тому його можна зберігати та використовувати десь неможливо передавати параметри. Однак код, який ви опублікували, цього не зробить - він негайно викликає функцію і повертає результат, а не викличний. Може бути корисно опублікувати фактичний код, який ви бачили.