Einfaches Beispiel. Zwei Methoden, eine von einer anderen aufgerufen:

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

def method_b(arg):
    return some_data

In Python können wir defin einem anderen deklarieren def. Also, wenn method_bes für nur erforderlich ist und von dort angerufen wird method_a, sollte ich es method_binnen deklarieren method_a? so was :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

Oder sollte ich das vermeiden?

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

Ist es das, wonach du gesucht hast? Es heißt eine Schließung .

Auf diese Weise gewinnen Sie nicht wirklich viel. Tatsächlich wird es langsamer method_a, da die andere Funktion bei jedem Aufruf definiert und neu kompiliert wird. Angesichts dessen wäre es wahrscheinlich besser, dem Funktionsnamen nur einen Unterstrich voranzustellen, um anzuzeigen, dass es sich um eine private Methode handelt - d _method_b. H.

Ich nehme an, Sie möchten dies möglicherweise tun, wenn die Definition der verschachtelten Funktion aus irgendeinem Grund jedes Mal geändert wird. Dies kann jedoch auf einen Fehler in Ihrem Design hinweisen. Es gibt jedoch einen triftigen Grund, dies zu tun, damit die verschachtelte Funktion Argumente verwenden kann, die an die äußere Funktion übergeben, aber nicht explizit an sie weitergegeben wurden. Dies tritt beispielsweise manchmal beim Schreiben von Funktionsdekoratoren auf. Es ist das, was in der akzeptierten Antwort gezeigt wird, obwohl ein Dekorateur nicht definiert oder verwendet wird.

Aktualisieren:

Hier ist der Beweis, dass das Verschachteln langsamer ist (mit Python 3.6.1), obwohl dies in diesem trivialen Fall zugegebenermaßen nicht viel ist:

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

Hinweis: Ich selfhabe Ihren Beispielfunktionen einige Argumente hinzugefügt , um sie eher wie echte Methoden zu gestalten (obwohl method_b2dies technisch immer noch keine Methode der TestKlasse ist). Auch die verschachtelte Funktion wird in dieser Version im Gegensatz zu Ihrer tatsächlich aufgerufen.

Eine Funktion innerhalb einer Funktion wird üblicherweise für Verschlüsse verwendet .

(Es gibt eine Menge Streit über was genau macht einen Verschluss einen Verschluss .)

Hier ist ein Beispiel mit dem eingebauten sum(). Es definiert starteinmal und verwendet es von da an:

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

In Benutzung:

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

Eingebauter Python-Verschluss

functools.partial ist ein Beispiel für eine Schließung.

In den Python-Dokumenten entspricht dies in etwa:

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

(Ein großes Lob an @ user225312 unten für die Antwort. Ich finde dieses Beispiel einfacher herauszufinden und werde hoffentlich helfen, den Kommentar von @ mango zu beantworten.)

Nein, definieren Sie im Allgemeinen keine Funktionen innerhalb von Funktionen.

Es sei denn, Sie haben einen wirklich guten Grund. Was du nicht tust.

Warum nicht?

• Es verhindert einfache Haken für Unit-Tests. Sie testen Einheiten, nicht wahr?
• Es verschleiert es sowieso nicht vollständig , es ist sicherer anzunehmen, dass nichts in Python jemals ist.
• Verwenden Sie stattdessen Standardrichtlinien für den automatischen Python-Codestil, um Methoden zu kapseln.
• Sie werden jedes Mal, wenn Sie die äußere Funktion ausführen , unnötig ein Funktionsobjekt für den identischen Code neu erstellen .
• Wenn Ihre Funktion wirklich so einfach ist, sollten Sie stattdessen einen lambdaAusdruck verwenden .

Was ist ein wirklich guter Grund, Funktionen innerhalb von Funktionen zu definieren?

Wenn Sie tatsächlich einen Dingdang- Verschluss wollen .

Es ist eigentlich in Ordnung, eine Funktion in einer anderen zu deklarieren. Dies ist besonders nützlich, um Dekorateure zu erstellen.

Als Faustregel gilt jedoch, dass es bei einer komplexen Funktion (mehr als 10 Zeilen) möglicherweise besser ist, sie auf Modulebene zu deklarieren.

Ich habe diese Frage gefunden, weil ich eine Frage stellen wollte, warum es Auswirkungen auf die Leistung gibt, wenn verschachtelte Funktionen verwendet werden. Ich habe Tests für die folgenden Funktionen mit Python 3.2.5 auf einem Windows-Notebook mit einem Quad Core 2,5-GHz-Intel i5-2530M-Prozessor durchgeführt

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

Ich habe die folgenden 20 Male gemessen, auch für Quadrat1, Quadrat2 und Quadrat5:

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

und bekam die folgenden Ergebnisse

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

square0hat keine verschachtelte Funktion, square1hat eine verschachtelte Funktion, square2hat zwei verschachtelte Funktionen und square5hat fünf verschachtelte Funktionen. Die verschachtelten Funktionen werden nur deklariert, aber nicht aufgerufen.

Wenn Sie also 5 verschachtelte Funktionen in einer Funktion definiert haben, die Sie nicht aufrufen, beträgt die Ausführungszeit der Funktion das Doppelte der Funktion ohne verschachtelte Funktion. Ich denke, sollte vorsichtig sein, wenn verschachtelte Funktionen verwendet werden.

Die Python-Datei für den gesamten Test, der diese Ausgabe generiert, befindet sich unter ideone .

Es ist nur ein Prinzip über Expositions-APIs.

Bei Verwendung von Python ist es eine gute Idee, die Expositions-API im Weltraum (Modul oder Klasse) zu vermeiden. Die Funktion ist ein guter Kapselungsort.

Es könnte eine gute Idee sein. wenn Sie sicherstellen

1. Die innere Funktion wird NUR von der äußeren Funktion verwendet.
2. Insider-Funktion hat einen guten Namen, um ihren Zweck zu erklären, weil der Code spricht.
3. Code kann von Ihren Kollegen (oder anderen Codelesern) nicht direkt verstanden werden.

Auch wenn Missbrauch dieser Technik Probleme verursachen kann und einen Konstruktionsfehler impliziert.

Nur aus meiner Erfahrung, Vielleicht missverstehen Sie Ihre Frage.

Am Ende geht es also hauptsächlich darum, wie intelligent die Python-Implementierung ist oder nicht, insbesondere wenn die innere Funktion kein Abschluss ist, sondern lediglich ein Helfer, der nur für die Funktion benötigt wird.

In einem sauberen, verständlichen Design ist es ein gutes Design, Funktionen nur dort zu haben, wo sie benötigt werden und nicht an anderer Stelle verfügbar gemacht werden, unabhängig davon, ob sie in ein Modul, eine Klasse als Methode oder in eine andere Funktion oder Methode eingebettet sind. Wenn sie gut gemacht sind, verbessern sie wirklich die Klarheit des Codes.

Und wenn die innere Funktion ein Verschluss ist, der auch bei der Klarheit einiges helfen kann, selbst wenn diese Funktion nicht aus der enthaltenen Funktion zur anderweitigen Verwendung zurückgegeben wird.

Daher würde ich sagen, dass Sie sie im Allgemeinen verwenden, sich jedoch des möglichen Leistungseinbruchs bewusst sind, wenn Sie tatsächlich über die Leistung besorgt sind, und sie nur entfernen, wenn Sie eine tatsächliche Profilerstellung durchführen, die zeigt, dass sie am besten entfernt werden können.

Führen Sie keine vorzeitige Optimierung durch, indem Sie nur "innere Funktionen BAD" für den gesamten von Ihnen geschriebenen Python-Code verwenden. Bitte.

Es ist vollkommen in Ordnung, dies so zu tun, aber es sei denn, Sie müssen einen Abschluss verwenden oder die Funktion zurückgeben, die ich wahrscheinlich in die Modulebene eingefügt habe. Ich stelle mir im zweiten Codebeispiel vor, Sie meinen:

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

Andernfalls ist some_data die Funktion.

Wenn Sie es auf Modulebene haben, können andere Funktionen method_b () verwenden. Wenn Sie etwas wie Sphinx (und Autodoc) für die Dokumentation verwenden, können Sie auch method_b dokumentieren.

Möglicherweise möchten Sie auch die Funktionalität in zwei Methoden in einer Klasse einfügen, wenn Sie etwas tun, das von einem Objekt dargestellt werden kann. Dies enthält auch Logik, wenn das alles ist, wonach Sie suchen.

Mach so etwas wie:

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

Wenn Sie ausführen some_function()würden, würde es ausgeführt some_other_function()und 42 zurückgeben.

EDIT: Ich habe ursprünglich gesagt, dass Sie eine Funktion nicht innerhalb einer anderen definieren sollten, aber es wurde darauf hingewiesen, dass es manchmal praktisch ist, dies zu tun.

Sie können es verwenden, um die Definition globaler Variablen zu vermeiden. Dies gibt Ihnen eine Alternative für andere Designs. 3 Entwürfe, die eine Lösung für ein Problem darstellen.

A) Verwenden von Funktionen ohne Globale

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) Verwenden von Funktionen mit Globalen

_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) Verwenden von Funktionen innerhalb einer anderen Funktion

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

Lösung C) ermöglicht die Verwendung von Variablen im Bereich der äußeren Funktion, ohne dass diese in der inneren Funktion deklariert werden müssen. Könnte in einigen Situationen nützlich sein.

Funktion In Funktion 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))