Exemple simple. Deux méthodes, l'une appelée depuis une autre:

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

def method_b(arg):
    return some_data

En Python, nous pouvons déclarer defdans un autre def. Donc, si method_best requis et appelé uniquement depuis method_a, dois-je déclarer à l' method_bintérieur method_a? comme ça :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b(arg)

Ou devrais-je éviter de faire ça?

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

Est ce que c'est ce que vous recherchiez? Cela s'appelle une fermeture .

Vous ne gagnez pas vraiment grand-chose en faisant cela, en fait cela ralentit method_acar il définira et recompilera l'autre fonction à chaque fois qu'elle sera appelée. Compte tenu de cela, il serait probablement préférable de simplement préfixer le nom de la fonction avec un trait de soulignement pour indiquer que c'est une méthode privée - c'est-à-dire _method_b.

Je suppose que vous voudrez peut -être faire cela si la définition de la fonction imbriquée variait à chaque fois pour une raison quelconque, mais cela peut indiquer un défaut dans votre conception. Cela dit, il existe une raison valable de le faire pour permettre à la fonction imbriquée d'utiliser des arguments qui ont été passés à la fonction externe mais qui ne leur ont pas été explicitement transmis, ce qui se produit parfois lors de l'écriture de décorateurs de fonction, par exemple. C'est ce qui est montré dans la réponse acceptée bien qu'un décorateur ne soit pas défini ou utilisé.

Mettre à jour:

Voici la preuve que leur imbrication est plus lente (en utilisant Python 3.6.1), bien que certes pas de beaucoup dans ce cas trivial:

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

Remarque J'ai ajouté quelques selfarguments à vos exemples de fonctions pour les rendre plus comme des méthodes réelles (bien que ce method_b2ne soit toujours pas techniquement une méthode de la Testclasse). La fonction imbriquée est également appelée dans cette version, contrairement à la vôtre.

Une fonction à l'intérieur d'une fonction est couramment utilisée pour les fermetures .

(Il y a beaucoup de désaccord sur ce qui fait exactement d' une fermeture une fermeture .)

Voici un exemple utilisant le fichier sum(). Il définit startune fois et l'utilise à partir de là:

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

Utilisé:

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

Fermeture en python intégrée

functools.partial est un exemple de fermeture.

D'après la documentation python , c'est à peu près équivalent à:

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

(Félicitations à @ user225312 ci-dessous pour la réponse. Je trouve cet exemple plus facile à comprendre et j'espère que cela aidera à répondre au commentaire de @ mango.)

En général, non, ne définissez pas les fonctions à l'intérieur des fonctions.

Sauf si vous avez une très bonne raison. Ce que vous ne faites pas.

Pourquoi pas?

• Cela empêche les crochets faciles pour les tests unitaires. Vous faites des tests unitaires, n'est-ce pas?
• De toute façon , cela ne l'obscurcit pas complètement , il est plus sûr de supposer que rien en python ne l'est jamais.
• Utilisez plutôt les directives de style de code automagic standard de Python pour encapsuler les méthodes.
• Vous allez recréer inutilement un objet de fonction pour le code identique chaque fois que vous exécutez la fonction externe .
• Si votre fonction est vraiment aussi simple que cela, vous devriez utiliser une lambdaexpression à la place .

Quelle est vraiment une bonne raison de définir des fonctions à l'intérieur de fonctions?

Quand ce que vous voulez vraiment, c'est une fermeture dingdang .

Il est en fait bien de déclarer une fonction dans une autre. Ceci est particulièrement utile pour créer des décorateurs.

Cependant, en règle générale, si la fonction est complexe (plus de 10 lignes), il peut être préférable de la déclarer au niveau du module.

J'ai trouvé cette question parce que je voulais poser une question pourquoi il y a un impact sur les performances si l'on utilise des fonctions imbriquées. J'ai effectué des tests pour les fonctions suivantes en utilisant Python 3.2.5 sur un ordinateur portable Windows avec un processeur Intel i5-2530M Quad Core 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

J'ai mesuré les 20 fois suivantes, également pour square1, square2 et square5:

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

et a obtenu les résultats suivants

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

square0n'a pas de fonction imbriquée, square1a une fonction imbriquée, square2a deux fonctions imbriquées et square5a cinq fonctions imbriquées. Les fonctions imbriquées sont uniquement déclarées mais pas appelées.

Donc, si vous avez défini 5 fonctions imbriquées dans une fonction que vous n'appelez pas, le temps d'exécution de la fonction est le double de la fonction sans fonction imbriquée. Je pense qu'il faut être prudent lors de l'utilisation de fonctions imbriquées.

Le fichier Python pour l'ensemble du test qui génère cette sortie se trouve sur ideone .

C'est juste un principe sur les API d'exposition.

En utilisant python, c'est une bonne idée d'éviter l'exposition des API dans l'espace (module ou classe), la fonction est un bon endroit d'encapsulation.

Cela pourrait être une bonne idée. quand tu t'assures

1. la fonction interne est UNIQUEMENT utilisée par la fonction externe.
2. La fonction d'initié a un bon nom pour expliquer son but parce que le code parle.
3. le code ne peut pas être compris directement par vos collègues (ou un autre lecteur de code).

Même si, une utilisation abusive de cette technique peut causer des problèmes et implique un défaut de conception.

Juste à partir de mon exp, peut-être mal compris votre question.

Donc, en fin de compte, il s'agit en grande partie de savoir à quel point l'implémentation de python est intelligente ou non, en particulier dans le cas où la fonction interne n'est pas une fermeture mais simplement une aide nécessaire uniquement.

Dans une conception claire et compréhensible, avoir des fonctions uniquement là où elles sont nécessaires et non exposées ailleurs est une bonne conception, qu'elles soient intégrées dans un module, une classe en tant que méthode, ou dans une autre fonction ou méthode. Lorsqu'elles sont bien faites, elles améliorent vraiment la clarté du code.

Et lorsque la fonction interne est une fermeture, cela peut également aider un peu à la clarté, même si cette fonction n'est pas renvoyée par la fonction conteneur pour une utilisation ailleurs.

Je dirais donc que généralement, utilisez-les, mais soyez conscient de l'impact possible sur les performances lorsque vous êtes réellement préoccupé par les performances et ne les supprimez que si vous effectuez un profilage réel qui montre qu'il vaut mieux les supprimer.

Ne faites pas d'optimisation prématurée en utilisant simplement des «fonctions internes BAD» dans tout le code python que vous écrivez. S'il vous plaît.

C'est parfaitement normal de le faire de cette façon, mais à moins que vous n'ayez besoin d'utiliser une fermeture ou de renvoyer la fonction, je mettrais probablement au niveau du module. J'imagine que dans le deuxième exemple de code, vous voulez dire:

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

sinon, some_data sera la fonction.

L'avoir au niveau du module permettra à d'autres fonctions d'utiliser method_b () et si vous utilisez quelque chose comme Sphinx (et autodoc) pour la documentation, cela vous permettra également de documenter method_b.

Vous pouvez également envisager de simplement placer la fonctionnalité dans deux méthodes dans une classe si vous faites quelque chose qui peut être représentable par un objet. Cela contient également de la logique si c'est tout ce que vous recherchez.

Faites quelque chose comme:

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

si vous deviez l'exécuter, some_function()il fonctionnerait alorssome_other_function() et renvoie 42.

EDIT: J'ai initialement déclaré que vous ne devriez pas définir une fonction à l'intérieur d'une autre, mais il a été souligné qu'il est parfois pratique de le faire.

Vous pouvez l'utiliser pour éviter de définir des variables globales. Cela vous donne une alternative aux autres modèles. 3 designs présentant une solution à un problème.

A) Utilisation de fonctions sans globaux

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) Utilisation de fonctions avec des globaux

_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) Utilisation de fonctions dans une autre fonction

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 solution C) permet d'utiliser des variables dans le cadre de la fonction externe sans avoir besoin de les déclarer dans la fonction interne. Peut être utile dans certaines situations.

Fonction In function 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))