Diciamo che a function Aè richiesto solo da function B, A dovrebbe essere definito all'interno di B?

Semplice esempio. Due metodi, uno chiamato da un altro:

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

def method_b(arg):
    return some_data

In Python possiamo dichiarare defdentro un altro def. Quindi, se method_bè richiesto e chiamato solo da method_a, devo dichiarare method_ball'interno method_a? come questo :

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

    some_data = method_b(arg)

O dovrei evitare di farlo?

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

È questo quello che stavi cercando? Si chiama chiusura .

Non guadagni davvero molto in questo modo, infatti rallenta method_aperché definirà e ricompilerà l'altra funzione ogni volta che viene chiamata. Detto questo, probabilmente sarebbe meglio anteporre al nome della funzione un carattere di sottolineatura per indicare che si tratta di un metodo privato, ad es _method_b.

Suppongo che potresti volerlo fare se la definizione della funzione annidata variava ogni volta per qualche motivo, ma ciò potrebbe indicare un difetto nel tuo design. Detto questo, non v'è un motivo valido per fare questo per consentire la funzione annidata di usare argomenti che sono stati passati alla funzione di esterno, ma non esplicitamente trasferito su di loro, che a volte si verifica quando si scrive decoratori di funzione, per esempio. È ciò che viene mostrato nella risposta accettata sebbene un decoratore non venga definito o utilizzato.

Aggiornare:

Ecco la prova che annidarli è più lento (usando Python 3.6.1), anche se certamente non di molto in questo caso banale:

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

Nota ho aggiunto alcuni selfargomenti alle tue funzioni di esempio per renderle più simili a metodi reali (sebbene method_b2non sia ancora tecnicamente un metodo della Testclasse). Anche la funzione annidata viene effettivamente chiamata in quella versione, a differenza della tua.

Una funzione all'interno di una funzione è comunemente usata per le chiusure .

(Ci sono molte controversie su ciò che rende esattamente una chiusura una chiusura .)

Ecco un esempio utilizzando il built-in sum(). Definisce startuna volta e lo utilizza da quel momento in poi:

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

In uso:

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

Chiusura in pitone incorporata

functools.partial è un esempio di chiusura.

Dalla documentazione di Python , è più o meno equivalente a:

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

(Complimenti a @ user225312 di seguito per la risposta. Trovo questo esempio più facile da capire e, si spera, aiuterà a rispondere al commento di @ mango.)

Generalmente no, non definire funzioni all'interno di funzioni.

A meno che tu non abbia davvero una buona ragione. Quale non lo fai.

Perchè no?

• Impedisce facili ganci per test unitari. Stai testando l'unità, vero?
• In realtà non lo offusca completamente comunque , è più sicuro presumere che nulla in Python lo sia mai.
• Usa invece le linee guida dello stile del codice automagic Python standard per incapsulare i metodi.
• Sarete inutilmente ricreando un oggetto funzione per il codice identico ogni volta che si esegue la funzione esterna .
• Se la tua funzione è davvero così semplice, dovresti invece usare lambdaun'espressione .

Qual è davvero un buon motivo per definire le funzioni all'interno delle funzioni?

Quando quello che vuoi veramente è una chiusura dingdang .

In realtà va bene dichiarare una funzione all'interno di un'altra. Questo è particolarmente utile per creare decoratori.

Tuttavia, come regola pratica, se la funzione è complessa (più di 10 righe) potrebbe essere un'idea migliore dichiararla a livello di modulo.

Ho trovato questa domanda perché volevo porre una domanda sul perché c'è un impatto sulle prestazioni se si utilizzano funzioni annidate. Ho eseguito test per le seguenti funzioni utilizzando Python 3.2.5 su un notebook Windows con un processore Intel i5-2530M Quad Core da 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

Ho misurato le seguenti 20 volte, anche per quadrato1, quadrato2 e quadrato5:

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

e ha ottenuto i seguenti risultati

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

square0non ha una funzione nidificata, square1ha una funzione nidificata, square2ha due funzioni nidificate e square5ha cinque funzioni nidificate. Le funzioni annidate vengono solo dichiarate ma non chiamate.

Quindi, se hai definito 5 funzioni annidate in una funzione che non chiami, il tempo di esecuzione della funzione è il doppio di quello della funzione senza una funzione annidata. Penso che dovrebbe essere cauto quando si utilizzano funzioni annidate.

Il file Python per l'intero test che genera questo output può essere trovato su ideone .

È solo un principio sulle API di esposizione.

Usando python, è una buona idea evitare l'API di esposizione nello spazio (modulo o classe), la funzione è un buon luogo di incapsulamento.

Potrebbe essere una buona idea. quando ti assicuri

1. la funzione interna viene utilizzata SOLO dalla funzione esterna.
2. la funzione insider ha un buon nome per spiegare il suo scopo perché il codice parla.
3. il codice non può essere compreso direttamente dai tuoi colleghi (o da altri lettori di codici).

Anche se, abusare di questa tecnica può causare problemi e implica un difetto di progettazione.

Solo dalla mia esperienza, forse fraintendo la tua domanda.

Quindi, alla fine, è in gran parte una questione su quanto sia intelligente o meno l'implementazione di Python, in particolare nel caso in cui la funzione interna non sia una chiusura ma semplicemente un aiuto in funzione necessario.

In un design pulito e comprensibile avere funzioni solo dove sono necessarie e non esposte altrove è un buon design sia che siano incorporate in un modulo, una classe come metodo o all'interno di un'altra funzione o metodo. Se fatti bene, migliorano davvero la chiarezza del codice.

E quando la funzione interna è una chiusura, questo può anche aiutare con chiarezza un po 'anche se quella funzione non viene restituita dalla funzione contenitore per essere utilizzata altrove.

Quindi direi che generalmente li usi ma sii consapevole del possibile impatto sulle prestazioni quando sei effettivamente preoccupato per le prestazioni e rimuovili solo se esegui una profilazione effettiva che mostra che è meglio rimuoverli.

Non ottimizzate prematuramente usando solo "funzioni interne BAD" in tutto il codice Python che scrivete. Per favore.

È perfettamente OK farlo in questo modo, ma a meno che non sia necessario utilizzare una chiusura o restituire la funzione, probabilmente metterei a livello di modulo. Immagino che nel secondo esempio di codice intendi:

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

in caso contrario, some_data sarà la funzione.

Averlo a livello di modulo consentirà ad altre funzioni di usare method_b () e se stai usando qualcosa come Sphinx (e autodoc) per la documentazione, ti permetterà di documentare anche method_b.

Potresti anche considerare di mettere la funzionalità in due metodi in una classe se stai facendo qualcosa che può essere rappresentabile da un oggetto. Questo contiene bene anche la logica se è tutto ciò che stai cercando.

Fai qualcosa come:

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

se si dovesse eseguire some_function(), verrà eseguito some_other_function()e restituirà 42.

EDIT: inizialmente ho affermato che non dovresti definire una funzione all'interno di un'altra, ma è stato sottolineato che a volte è pratico farlo.

Puoi usarlo per evitare di definire variabili globali. Questo ti offre un'alternativa per altri design. 3 progetti che presentano una soluzione a un problema.

A) Utilizzo di funzioni senza 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) Utilizzo di funzioni con globali

_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) Utilizzo di funzioni all'interno di un'altra funzione

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

La soluzione C) consente di utilizzare le variabili nell'ambito della funzione esterna senza la necessità di dichiararle nella funzione interna. Potrebbe essere utile in alcune situazioni.

Funzione Nella funzione 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))