Come posso ottenere il codice sorgente di una funzione Python?

Supponiamo che io abbia una funzione Python come definita di seguito:

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

Posso ottenere il nome della funzione utilizzando foo.func_name. Come posso ottenere a livello di codice il suo codice sorgente, come ho digitato sopra?

Se la funzione proviene da un file sorgente disponibile sul filesystem, inspect.getsource(foo)potrebbe essere di aiuto:

Se fooè definito come:

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

Poi:

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

Ritorna:

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

Ma credo che se la funzione viene compilata da una stringa, flusso o importata da un file compilato, non è possibile recuperare il suo codice sorgente.

Il modulo inspect ha metodi per recuperare il codice sorgente dagli oggetti Python. Apparentemente funziona solo se l'origine si trova in un file. Se lo avessi immaginato non avresti bisogno di ottenere la fonte dall'oggetto.

dis è tuo amico se il codice sorgente non è disponibile:

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

Se si utilizza IPython, è necessario digitare "pippo ??"

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

Anche se generalmente sono d'accordo che inspectsia una buona risposta, non sono d'accordo sul fatto che non è possibile ottenere il codice sorgente degli oggetti definito nell'interprete. Se lo usi dill.source.getsourceda dill, puoi ottenere la fonte di funzioni e lambda, anche se sono definite in modo interattivo. Può anche ottenere il codice per metodi e funzioni di classe associati o non definiti definiti nei curry ... tuttavia, potresti non essere in grado di compilare quel codice senza il codice dell'oggetto che lo racchiude.

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

>>> 

Per espandere la risposta di runeh:

>>> def foo(a):
...    x = 2
...    return x + a

>>> import inspect

>>> inspect.getsource(foo)
u'def foo(a):\n    x = 2\n    return x + a\n'

print inspect.getsource(foo)
def foo(a):
   x = 2
   return x + a

EDIT: Come sottolineato da @ 0sh questo esempio funziona usando ipythonma non in modo chiaro python. Dovrebbe andare bene in entrambi, tuttavia, quando si importa il codice dai file di origine.

È possibile utilizzare il inspectmodulo per ottenere il codice sorgente completo per quello. Devi usare il getsource()metodo per questo dal inspectmodulo. Per esempio:

import inspect

def get_my_code():
    x = "abcd"
    return x

print(inspect.getsource(get_my_code))

Puoi dare un'occhiata a più opzioni sul link qui sotto. recuperare il codice Python

Poiché questo post è contrassegnato come duplicato di questo altro post , rispondo qui per il caso "lambda", sebbene il PO non riguardi lambdas.

Quindi, per le funzioni lambda che non sono definite nelle loro stesse linee: oltre alla risposta di marko.ristin , potresti voler usare mini-lambda o usare SymPy come suggerito in questa risposta .

• mini-lambda è più leggero e supporta qualsiasi tipo di operazione, ma funziona solo per una singola variabile
• SymPyè più pesante ma molto più dotato di operazioni matematiche / di calcolo. In particolare può semplificare le tue espressioni. Supporta anche diverse variabili nella stessa espressione.

Ecco come puoi farlo usando mini-lambda:

from mini_lambda import x, is_mini_lambda_expr
import inspect

def get_source_code_str(f):
    if is_mini_lambda_expr(f):
        return f.to_string()
    else:
        return inspect.getsource(f)

# test it

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

print(get_source_code_str(foo))
print(get_source_code_str(x ** 2))

Si cede correttamente

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

x ** 2

Vedere la mini-lambda documentazione per i dettagli. Sono l'autore tra l'altro;)

Tieni presente che le risposte accettate funzionano solo se il lambda viene fornito su una riga separata. Se lo passi come argomento a una funzione e desideri recuperare il codice del lambda come oggetto, il problema diventa un po 'complicato poiché inspectti darà l'intera riga.

Ad esempio, considera un file test.py:

import inspect

def main():
    x, f = 3, lambda a: a + 1
    print(inspect.getsource(f))

if __name__ == "__main__":
    main()

Eseguirlo ti dà (attenzione l'indentazione!):

    x, f = 3, lambda a: a + 1

Per recuperare il codice sorgente di lambda, la mia scommessa migliore, secondo me, è di analizzare nuovamente l'intero file sorgente (usando f.__code__.co_filename) e abbinare il nodo lambda AST per il numero di riga e il suo contesto.

Abbiamo dovuto fare esattamente questo nella nostra icona della biblioteca design-by-contract poiché abbiamo dovuto analizzare le funzioni lambda che passiamo come argomenti ai decoratori. È troppo codice da incollare qui, quindi dai un'occhiata all'implementazione di questa funzione .

Se stai definendo rigorosamente la funzione da solo ed è una definizione relativamente breve, una soluzione senza dipendenze sarebbe quella di definire la funzione in una stringa e assegnare l'eval () dell'espressione alla tua funzione.

Per esempio

funcstring = 'lambda x: x> 5'
func = eval(funcstring)

quindi facoltativamente per allegare il codice originale alla funzione:

func.source = funcstring

riassumere :

import inspect
print( "".join(inspect.getsourcelines(foo)[0]))

Io credo che i nomi delle variabili non vengono memorizzati in pyc / PYD / Pyo file, in modo non è possibile recuperare le righe di codice esatto, se non si dispone di file di origine.