¿Cómo puedo obtener el código fuente de una función de Python?

Supongamos que tengo una función de Python como se define a continuación:

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

Puedo obtener el nombre de la función usando foo.func_name. ¿Cómo puedo obtener programáticamente su código fuente, como escribí anteriormente?

Si la función es de un archivo fuente disponible en el sistema de archivos, entonces inspect.getsource(foo)podría ser de ayuda:

Si foose define como:

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

Entonces:

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

Devoluciones:

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

Pero creo que si la función se compila desde una cadena, secuencia o se importa desde un archivo compilado, entonces no puede recuperar su código fuente.

El módulo de inspección tiene métodos para recuperar el código fuente de los objetos python. Aparentemente, solo funciona si la fuente se encuentra en un archivo. Si tuviera eso, supongo que no necesitaría obtener la fuente del objeto.

dis es tu amigo si el código fuente no está 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

Si está utilizando IPython, entonces debe escribir "foo ??"

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

Aunque generalmente estoy de acuerdo con que inspectes una buena respuesta, no estoy de acuerdo con que no pueda obtener el código fuente de los objetos definidos en el intérprete. Si usa dill.source.getsourcefrom dill, puede obtener la fuente de funciones y lambdas, incluso si se definen de forma interactiva. También puede obtener el código de los métodos y funciones de clase vinculados o no definidos definidos en curry ... sin embargo, es posible que no pueda compilar ese código sin el código del objeto adjunto.

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

>>> 

Para ampliar la respuesta de 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

EDITAR: Como lo señaló @ 0sh, este ejemplo funciona usando ipythonpero no es simple python. Sin embargo, debería estar bien en ambos al importar código de archivos fuente.

Puede usar el inspectmódulo para obtener el código fuente completo para eso. Tienes que usar el getsource()método para eso desde el inspectmódulo. Por ejemplo:

import inspect

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

print(inspect.getsource(get_my_code))

Puede consultar más opciones en el siguiente enlace. recupera tu código de Python

Como esta publicación está marcada como el duplicado de esta otra publicación , respondo aquí para el caso "lambda", aunque el OP no se trata de lambdas.

Entonces, para las funciones lambda que no están definidas en sus propias líneas: además de la respuesta de marko.ristin , es posible que desee usar mini-lambda o SymPy como se sugiere en esta respuesta .

• mini-lambda es más ligero y admite cualquier tipo de operación, pero solo funciona para una sola variable
• SymPyes más pesado pero está mucho más equipado con operaciones matemáticas / de cálculo. En particular, puede simplificar sus expresiones. También admite varias variables en la misma expresión.

Así es como puedes hacerlo 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))

Produce correctamente

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

x ** 2

Consulte la mini-lambda documentación para más detalles. Soy el autor por cierto;)

Tenga en cuenta que las respuestas aceptadas funcionan solo si la lambda se proporciona en una línea separada. Si lo pasa como argumento a una función y desea recuperar el código de lambda como objeto, el problema se vuelve un poco complicado ya que inspectle dará toda la línea.

Por ejemplo, considere un archivo test.py:

import inspect

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

if __name__ == "__main__":
    main()

Ejecutarlo te da (¡cuidado con la sangría!):

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

Para recuperar el código fuente de la lambda, su mejor opción, en mi opinión, es volver a analizar todo el archivo fuente (usando f.__code__.co_filename ) y hacer coincidir el nodo AST lambda por el número de línea y su contexto.

Tuvimos que hacer precisamente eso en nuestro resumen de iconos de la biblioteca de diseño por contrato ya que tuvimos que analizar las funciones lambda que pasamos como argumentos a los decoradores. Es demasiado código para pegar aquí, así que eche un vistazo a la implementación de esta función .

Si está definiendo estrictamente la función usted mismo y es una definición relativamente corta, una solución sin dependencias sería definir la función en una cadena y asignar el eval () de la expresión a su función.

P.ej

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

luego, opcionalmente, para adjuntar el código original a la función:

func.source = funcstring

para resumir :

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

Yo creo que los nombres de variables no se almacenan en archivos pyc / pyd / pyo, por lo que no puede recuperar las líneas de código exacto si usted no tiene los archivos de origen.