Wie kann ich den Quellcode einer Python-Funktion erhalten?

Angenommen, ich habe eine Python-Funktion wie unten definiert:

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

Ich kann den Namen der Funktion mit abrufen foo.func_name. Wie kann ich den Quellcode programmgesteuert abrufen, wie ich oben eingegeben habe?

Wenn die Funktion aus einer im Dateisystem verfügbaren Quelldatei stammt, inspect.getsource(foo)kann dies hilfreich sein:

If fooist definiert als:

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

Dann:

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

Kehrt zurück:

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

Ich glaube jedoch, dass Sie den Quellcode nicht abrufen können, wenn die Funktion aus einer Zeichenfolge kompiliert, gestreamt oder aus einer kompilierten Datei importiert wird.

Das Inspect-Modul verfügt über Methoden zum Abrufen von Quellcode aus Python-Objekten. Scheinbar funktioniert es nur, wenn sich die Quelle in einer Datei befindet. Wenn Sie das hätten, müssten Sie wahrscheinlich nicht die Quelle vom Objekt abrufen.

dis ist dein Freund, wenn der Quellcode nicht verfügbar ist:

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

Wenn Sie IPython verwenden, müssen Sie "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

Obwohl ich im Allgemeinen zustimmen würde, dass dies inspecteine gute Antwort ist, würde ich nicht zustimmen, dass Sie den Quellcode der im Interpreter definierten Objekte nicht erhalten können. Wenn Sie dill.source.getsourcevon verwenden dill, können Sie die Quelle von Funktionen und Lambdas abrufen, auch wenn diese interaktiv definiert sind. Es kann auch den Code für gebundene oder ungebundene Klassenmethoden und -funktionen abrufen, die in Currys definiert sind. Möglicherweise können Sie diesen Code jedoch nicht ohne den Code des umschließenden Objekts kompilieren.

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

>>> 

Um die Antwort von runeh zu erweitern:

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

BEARBEITEN: Wie von @ 0sh hervorgehoben, funktioniert dieses Beispiel mit, ipythonaber nicht einfach python. Es sollte jedoch in beiden Fällen in Ordnung sein, wenn Code aus Quelldateien importiert wird.

Sie können das inspectModul verwenden, um den vollständigen Quellcode dafür zu erhalten. Sie müssen dafür die getsource()Methode aus dem inspectModul verwenden. Zum Beispiel:

import inspect

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

print(inspect.getsource(get_my_code))

Weitere Optionen finden Sie unter dem folgenden Link. Rufen Sie Ihren Python-Code ab

Da dieser Beitrag als Duplikat dieses anderen Beitrags markiert ist , antworte ich hier für den Fall "Lambda", obwohl es im OP nicht um Lambdas geht.

Für Lambda-Funktionen, die nicht in eigenen Zeilen definiert sind: Zusätzlich zur Antwort von marko.ristin möchten Sie möglicherweise Mini-Lambda oder SymPy verwenden, wie in dieser Antwort vorgeschlagen .

• mini-lambda ist leichter und unterstützt jede Art von Operation, funktioniert aber nur für eine einzelne Variable
• SymPyist schwerer, aber viel besser mit mathematischen / Kalküloperationen ausgestattet. Insbesondere kann es Ihre Ausdrücke vereinfachen. Es werden auch mehrere Variablen im selben Ausdruck unterstützt.

So können Sie es machen mit 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))

Es gibt richtig nach

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

x ** 2

Einzelheiten finden Sie in der mini-lambda Dokumentation . Ich bin übrigens der Autor;)

Bitte beachten Sie, dass die akzeptierten Antworten nur funktionieren, wenn das Lambda in einer separaten Zeile angegeben wird. Wenn Sie es als Argument an eine Funktion übergeben und den Code des Lambda als Objekt abrufen möchten, wird das Problem etwas schwierig, da inspectSie die gesamte Zeile erhalten.

Betrachten Sie beispielsweise eine Datei test.py:

import inspect

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

if __name__ == "__main__":
    main()

Wenn Sie es ausführen, erhalten Sie (beachten Sie die Einrückung!):

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

Um den Quellcode des Lambda abzurufen, ist es meiner Meinung nach am besten, die gesamte Quelldatei (mithilfe von f.__code__.co_filename) erneut zu analysieren und den Lambda-AST-Knoten anhand der Zeilennummer und seines Kontexts abzugleichen.

Genau das mussten wir in unserer Design-by-Contract-Bibliothek icontract tun, da wir die Lambda-Funktionen analysieren mussten, die wir als Argumente an Dekorateure übergeben. Es ist zu viel Code, um ihn hier einzufügen. Schauen Sie sich also die Implementierung dieser Funktion an .

Wenn Sie die Funktion streng selbst definieren und es sich um eine relativ kurze Definition handelt, besteht eine Lösung ohne Abhängigkeiten darin, die Funktion in einer Zeichenfolge zu definieren und Ihrer Funktion das eval () des Ausdrucks zuzuweisen.

Z.B

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

dann optional, um den Originalcode an die Funktion anzuhängen:

func.source = funcstring

zusammenfassen :

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

Ich glaube, dass Variablennamen nicht in pyc / pyd / pyo-Dateien gespeichert sind, so dass Sie die genauen Codezeilen nicht abrufen können, wenn Sie keine Quelldateien haben.