Prosty przykład. Dwie metody, jedna wywoływana z drugiej:

def method_a(arg):
    some_data = method_b(arg)

def method_b(arg):
    return some_data

W Pythonie możemy zadeklarować defwewnątrz innego def. Więc jeśli method_bjest to wymagane i wywoływane tylko z method_a, czy powinienem zadeklarować w method_bśrodku method_a? lubię to :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

Czy powinienem tego unikać?

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

Czy tego szukałeś? Nazywa się to zamknięciem .

Tak naprawdę niewiele zyskujesz, robiąc to, w rzeczywistości spowalnia to method_a, ponieważ definiuje i rekompiluje inną funkcję za każdym razem, gdy jest wywoływana. Biorąc to pod uwagę, prawdopodobnie lepiej byłoby po prostu poprzedzić nazwę funkcji podkreśleniem, aby wskazać, że jest to metoda prywatna - tj _method_b.

Przypuszczam, że może chcesz to zrobić, jeśli definicja funkcji zagnieżdżonej za zmieniać za każdym razem z jakiegoś powodu, ale może wskazywać na błąd w projekcie. Powiedział, że jest ważny powód, aby to zrobić, aby umożliwić funkcja zagnieżdżona używać argumentów, które zostały przekazane do funkcji zewnętrznej, ale nie wprost na nich przerzucone, który czasami pojawia się podczas pisania dekoratorów funkcyjnych, na przykład. To właśnie jest pokazane w zaakceptowanej odpowiedzi, mimo że dekorator nie jest definiowany ani używany.

Aktualizacja:

Oto dowód na to, że zagnieżdżanie ich jest wolniejsze (przy użyciu Pythona 3.6.1), chociaż w tym trywialnym przypadku nie za dużo:

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

Uwaga Dodałem kilka selfargumentów do twoich przykładowych funkcji, aby uczynić je bardziej podobnymi do prawdziwych metod (chociaż method_b2nadal nie jest technicznie metodą Testklasy). Również funkcja zagnieżdżona jest faktycznie wywoływana w tej wersji, w przeciwieństwie do twojej.

Funkcja wewnątrz funkcji jest powszechnie używana do domknięć .

(Istnieje wiele sporów co do tego, co dokładnie sprawia , że zamknięcie jest zamknięciem ).

Oto przykład użycia wbudowanego sum(). Definiuje startraz i używa go odtąd:

def sum_partial(start):
    def sum_start(iterable):
        return sum(iterable, start)
    return sum_start

W użyciu:

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

Wbudowane zamknięcie w języku Python

functools.partial jest przykładem zamknięcia.

Z dokumentacji Pythona jest to mniej więcej odpowiednik:

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

(Uznanie dla @ user225312 poniżej za odpowiedź. Uważam, że ten przykład jest łatwiejszy do zrozumienia i mam nadzieję, że pomogę odpowiedzieć na komentarz @ mango.)

Generalnie nie, nie definiuj funkcji wewnątrz funkcji.

Chyba że masz naprawdę dobry powód. Czego nie robisz.

Dlaczego nie?

• Zapobiega łatwym hakom do testów jednostkowych. Robisz testy jednostkowe, prawda?
• W rzeczywistości i tak nie zaciemnia go całkowicie , bezpieczniej jest założyć, że w Pythonie nic nie jest.
• Zamiast tego użyj standardowych wskazówek dotyczących stylu automagicznego kodu Pythona, aby hermetyzować metody.
• Będziesz niepotrzebnie odtwarzał obiekt funkcji dla identycznego kodu za każdym razem, gdy uruchomisz funkcję zewnętrzną .
• Jeśli twoja funkcja jest naprawdę taka prosta, powinieneś lambdazamiast tego użyć wyrażenia .

Jaki jest naprawdę dobry powód, aby definiować funkcje wewnątrz funkcji?

Kiedy to, czego naprawdę chcesz, to zamknięcie dingdang .

Właściwie dobrze jest zadeklarować jedną funkcję wewnątrz innej. Jest to szczególnie przydatne przy tworzeniu dekoratorów.

Jednak z reguły, jeśli funkcja jest złożona (więcej niż 10 linii), lepszym pomysłem może być zadeklarowanie jej na poziomie modułu.

Znalazłem to pytanie, ponieważ chciałem zadać pytanie, dlaczego użycie funkcji zagnieżdżonych ma wpływ na wydajność. Przeprowadziłem testy następujących funkcji przy użyciu Pythona 3.2.5 na notebooku z systemem Windows z czterordzeniowym procesorem Intel i5-2530M 2,5 GHz

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

Zmierzyłem następujące 20 razy, również dla kwadratu1, kwadratu2 i kwadratu5:

s=0
for i in range(10**6):
    s+=square0(i)

i otrzymałem następujące wyniki

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

square0nie ma funkcji zagnieżdżonej, square1ma jedną funkcję zagnieżdżoną, square2ma dwie funkcje zagnieżdżone i square5ma pięć funkcji zagnieżdżonych. Zagnieżdżone funkcje są tylko deklarowane, ale nie są wywoływane.

Więc jeśli zdefiniowałeś 5 zagnieżdżonych funkcji w funkcji, której nie wywołujesz, to czas wykonania funkcji jest dwukrotnie dłuższy niż funkcji bez funkcji zagnieżdżonej. Myślę, że należy zachować ostrożność podczas korzystania z funkcji zagnieżdżonych.

Plik Pythona dla całego testu, który generuje te dane wyjściowe, można znaleźć pod adresem ideone .

To tylko zasada dotycząca interfejsów API ekspozycji.

Używając Pythona, dobrym pomysłem jest unikanie ekspozycji API w przestrzeni kosmicznej (moduł lub klasa), funkcja jest dobrym miejscem do hermetyzacji.

To mógłby być dobry pomysł. kiedy zapewniasz

1. Funkcja wewnętrzna jest używana TYLKO przez funkcję zewnętrzną.
2. Funkcja insider ma dobrą nazwę, aby wyjaśnić jej cel, ponieważ kod mówi.
3. kod nie może bezpośrednio zrozumieć twoich współpracowników (lub innego czytnika kodów).

Mimo to, nadużywanie tej techniki może powodować problemy i sugeruje wadę projektową.

Tylko z mojego doświadczenia, może źle zrozumiałem twoje pytanie.

W końcu jest to w dużej mierze pytanie o to, jak inteligentna jest implementacja Pythona, szczególnie w przypadku, gdy funkcja wewnętrzna nie jest zamknięciem, ale po prostu potrzebnym pomocnikiem w funkcji.

W czystym, zrozumiałym projekcie, w którym funkcje są tylko tam, gdzie są potrzebne i nie są ujawniane gdzie indziej, jest dobrym projektem, niezależnie od tego, czy są one osadzone w module, klasie jako metodzie, czy w innej funkcji lub metodzie. Dobrze wykonane naprawdę poprawiają przejrzystość kodu.

A kiedy funkcja wewnętrzna jest zamknięciem, które również może pomóc w przejrzystości, nawet jeśli ta funkcja nie jest zwracana z funkcji zawierającej do użycia w innym miejscu.

Powiedziałbym więc, że generalnie używaj ich, ale pamiętaj o możliwym spadku wydajności, gdy faktycznie martwisz się o wydajność, i usuwaj je tylko wtedy, gdy wykonasz faktyczne profilowanie, które pokazuje, że najlepiej je usunąć.

Nie wykonuj przedwczesnej optymalizacji, używając po prostu „ZŁE funkcje wewnętrzne” w całym kodzie Pythona, który piszesz. Proszę.

Robienie tego w ten sposób jest całkowicie w porządku, ale chyba że musisz użyć zamknięcia lub zwrócić funkcji, prawdopodobnie umieściłbym to na poziomie modułu. Wyobrażam sobie, że w drugim przykładzie kodu masz na myśli:

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

w przeciwnym razie some_data będzie funkcją.

Posiadanie go na poziomie modułu pozwoli innym funkcjom używać method_b (), a jeśli używasz czegoś takiego jak Sphinx (i autodoc) do dokumentacji, pozwoli ci to również udokumentować method_b.

Możesz również rozważyć umieszczenie funkcji w dwóch metodach w klasie, jeśli robisz coś, co może być reprezentowane przez obiekt. Zawiera również logikę, jeśli to wszystko, czego szukasz.

Zrób coś takiego:

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

jeśli miałbyś uruchomić, some_function()to uruchomi się some_other_function()i zwróci 42.

EDYCJA: Początkowo stwierdziłem, że nie powinno się definiować funkcji wewnątrz innej, ale wskazano, że czasami jest to praktyczne.

Możesz go użyć, aby uniknąć definiowania zmiennych globalnych. Daje to alternatywę dla innych projektów. 3 projekty przedstawiające rozwiązanie problemu.

A) Używanie funkcji bez globali

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) Używanie funkcji z globalnymi

_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) Używanie funkcji wewnątrz innej funkcji

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

Rozwiązanie C) pozwala na użycie zmiennych w zakresie funkcji zewnętrznej bez konieczności deklarowania ich w funkcji wewnętrznej. Może się przydać w niektórych sytuacjach.

Funkcja W funkcji 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))