Comment puis-je obtenir le code source d'une fonction Python ?

Question

Supposons que j'ai une fonction Python telle que définie ci-dessous :

def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

Je peux obtenir le nom de la fonction en utilisant foo.func_name . Comment puis-je obtenir par programme son code source, comme je l'ai tapé ci-dessus ?

Answer 1

Si la fonction provient d'un fichier source disponible sur le système de fichiers, alors inspect.getsource(foo) pourrait vous aider :

Si foo est défini comme suit :

def foo(arg1,arg2):         
    #do something with args 
    a = arg1 + arg2         
    return a  

Ensuite :

import inspect
lines = inspect.getsource(foo)
print(lines)

Les retours :

def foo(arg1,arg2):         
    #do something with args 
    a = arg1 + arg2         
    return a                

Mais je crois que si la fonction est compilée à partir d'une chaîne, d'un flux ou importée d'un fichier compilé, alors vous ne pouvez pas récupérer son code source.

Answer 2

El inspecter le module possède des méthodes pour récupérer le code source des objets python. Apparemment, cela ne fonctionne que si la source est située dans un fichier. Si c'était le cas, je suppose que vous n'auriez pas besoin de récupérer la source à partir de l'objet.

---

Les tests suivants inspect.getsource(foo) en utilisant Python 3.6 :

import inspect

def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

source_foo = inspect.getsource(foo)  # foo is normal function
print(source_foo)

source_max = inspect.getsource(max)  # max is a built-in function
print(source_max)

Cette première impression :

def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

Puis échoue sur inspect.getsource(max) avec l'erreur suivante :

TypeError: <built-in function max> is not a module, class, method, function, traceback, frame, or code object

Answer 3

Il suffit d'utiliser foo?? o ??foo .

Si vous utilisez IPython, alors vous devez taper foo?? o ??foo pour voir le code source complet. Pour voir uniquement la docstring de la fonction, utilisez foo? o ?foo . Cela fonctionne également dans le carnet Jupyter.

In [19]: foo??
Signature: foo(arg1, arg2)
Source:
def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

File:      ~/Desktop/<ipython-input-18-3174e3126506>
Type:      function

Answer 4

dis est votre ami si le code source n'est pas disponible :

>>> import dis
>>> def foo(arg1,arg2):
...     #do something with args
...     a = arg1 + arg2
...     return a
...
>>> dis.dis(foo)
  3           0 LOAD_FAST                0 (arg1)
              3 LOAD_FAST                1 (arg2)
              6 BINARY_ADD
              7 STORE_FAST               2 (a)

  4          10 LOAD_FAST                2 (a)
             13 RETURN_VALUE

Answer 5

Bien que je sois généralement d'accord pour dire que inspect est une bonne réponse, je ne suis pas d'accord pour dire que vous ne pouvez pas obtenir le code source des objets définis dans l'interpréteur. Si vous utilisez dill.source.getsource de dill vous pouvez obtenir la source des fonctions et des lambdas, même si elles sont définies de manière interactive. Il peut également obtenir le code des méthodes et des fonctions de classes liées ou non liées définies dans des curries... cependant, il se peut que vous ne puissiez pas compiler ce code sans le code de l'objet englobant.

>>> from dill.source import getsource
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> squared = lambda x:x**2
>>> 
>>> print getsource(add)
def add(x,y):
  return x+y

>>> print getsource(squared)
squared = lambda x:x**2

>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x*x+x
... 
>>> f = Foo()
>>> 
>>> print getsource(f.bar)
def bar(self, x):
    return x*x+x

>>>