Como posso obter o código fonte de uma função Python?

Suponha que eu tenha uma função Python conforme definida abaixo:

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

Eu posso obter o nome da função usando foo.func_name. Como obtenho programaticamente seu código fonte, conforme digitei acima?

Se a função for de um arquivo de origem disponível no sistema de arquivos, inspect.getsource(foo)poderá ser útil :

Se fooé definido como:

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

Então:

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

Devoluções:

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

Mas acredito que, se a função for compilada a partir de uma string, fluxo ou importada de um arquivo compilado, você não poderá recuperar seu código-fonte.

O módulo inspecionar possui métodos para recuperar o código-fonte de objetos python. Aparentemente, só funciona se a fonte estiver localizada em um arquivo. Se você tivesse isso, acho que não precisaria obter a fonte do objeto.

dis é seu amigo se o código fonte não estiver disponível:

>>> 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 você estiver usando IPython, precisará digitar "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

Embora eu concorde geralmente que essa inspecté uma boa resposta, discordo que você não pode obter o código fonte dos objetos definidos no intérprete. Se você usar dill.source.getsourcefrom dill, poderá obter a fonte de funções e lambdas, mesmo se elas estiverem definidas interativamente. Ele também pode obter o código de métodos e funções de classe vinculados ou não definidos definidos em curries ... no entanto, talvez você não consiga compilar esse código sem o código do objeto que o encerra.

>>> 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 expandir a resposta 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

EDIT: Como apontado por @ 0sh, este exemplo funciona usando, ipythonmas não é simples python. No entanto, deve ser bom para ambos quando importar código de arquivos de origem.

Você pode usar o inspectmódulo para obter o código fonte completo para isso. Você precisa usar o getsource()método para isso no inspectmódulo. Por exemplo:

import inspect

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

print(inspect.getsource(get_my_code))

Você pode conferir mais opções no link abaixo. recuperar seu código python

Como este post está marcado como duplicado deste outro post , respondo aqui pelo caso "lambda", embora o OP não seja sobre lambdas.

Portanto, para funções lambda que não são definidas em suas próprias linhas: além da resposta de marko.ristin , você pode usar o mini-lambda ou o SymPy, conforme sugerido nesta resposta .

• mini-lambda é mais leve e suporta qualquer tipo de operação, mas funciona apenas para uma única variável
• SymPyé mais pesado, mas muito mais equipado com operações matemáticas / de cálculo. Em particular, pode simplificar suas expressões. Ele também suporta várias variáveis ​​na mesma expressão.

Aqui está como você pode fazer isso 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))

Produz corretamente

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

x ** 2

Consulte a mini-lambda documentação para obter detalhes. Eu sou o autor, a propósito;)

Lembre-se de que as respostas aceitas funcionam apenas se o lambda for fornecido em uma linha separada. Se você o passar como argumento para uma função e desejar recuperar o código do lambda como objeto, o problema será um pouco complicado, pois inspectfornecerá toda a linha.

Por exemplo, considere um arquivo test.py:

import inspect

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

if __name__ == "__main__":
    main()

A execução dá a você (preste atenção à indentação!):

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

Para recuperar o código fonte do lambda, sua melhor aposta, na minha opinião, é analisar novamente o arquivo fonte inteiro (usando f.__code__.co_filename) e corresponder o nó AST lambda pelo número da linha e seu contexto.

Tivemos que fazer exatamente isso em nosso contrato de icon -library por contrato de design, pois tivemos que analisar as funções lambda que passamos como argumentos para os decoradores. É muito código para colar aqui, então dê uma olhada na implementação desta função .

Se você mesmo estiver definindo estritamente a função e for uma definição relativamente curta, uma solução sem dependências seria definir a função em uma string e atribuir o eval () da expressão à sua função.

Por exemplo

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

opcionalmente, para anexar o código original à função:

func.source = funcstring

para resumir:

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

Eu acredito que os nomes de variáveis não são armazenados na PYC / PYD / pyo arquivos, para que você não pode recuperar as linhas de código exato, se você não tem arquivos de origem.