Erhalten Sie ein Python-Funktionsattribut, ohne die Funktion auszuführen

Question

Ich habe eine GUI, die es dem Benutzer ermöglicht, jede Funktion aus einer bestimmten * .py-Datei auszuführen. Ich möchte, dass einige der Funktionen auf andere Weise ausgeführt werden. Um das zu tun, habe ich versucht, Attribute an die Funktion anzuhängen (Einfache Dinge wie die benötigten Eingaben). Ich fand jedoch, dass die einzige Möglichkeit, diese Attribute zu erhalten, war, den Code zuerst auszuführen.

Gibt es eine Möglichkeit, diese Attribute zu erhalten, ohne den Code auszuführen, oder vielleicht einen eher pythischen Weg, um sich dieser Aufgabe im Allgemeinen zu nähern?

Sehr rudimentäres Beispiel meines Code:

FileA.py

def Beta(x):  
    Beta.input_stype = "Float" 
    y = x + 0.5 

    return y 

def Gamma(x): 
    Gamma.input_stype = "String" 
    y = x + "_blah_blah_blah" 

    return y 

def Delta(x): 
    Delta.input_stype = "String" 
    y = x.index('WhereIsIt') 

    return y 

FileB.py

import FileA 
import inspect 

z = inspect.getmembers(Fiddle2, inspect.isfunction) 

#### User selects the code value here #### 

x = user_selection 

executable = z[x][1] # Pulls the executable code 

if executable.input_stype == "Float" : 
    y = executable(45) 
elif executable.input_stype == "String" : 
    y = executable('Testing_the_WhereIsIt_stuff') 

Answer 1

Do nicht ordnen Sie die Attribute im Funktionskörper:

def Beta(x): 
    y = x + 0.5 
    return y 
Beta.input_stype = "Float" 

Während Sie gerade dabei sind, möchten Sie anstelle der Saiten "Float" und "String" die tatsächlichen float oder str Typen verwenden. Wenn Sie auf Python sind 3 können Sie auch Funktion Anmerkungen verwenden möchten:

def Beta(x: float): 
    y = x + 0.5 
    return y 

Answer 2

Sie das Attribut direkt nach der Definition der Funktion einstellen:

def Beta(x):  
    y = x + 0.5 
    return y 

Beta.input_stype = "Float" 

Answer 3

Sie können auch in der Lage sein, den Code aussehen ein wenig sauberer, und halten Sie die Informationen näher an der Funktionsdefinition, wo die Menschen sind Wahrscheinlicher, wenn Sie Ihren Code lesen, indem Sie einen Dekorateur verwenden. verwendet wie diese werden

def validate_input_type(typ): 
    from functools import wraps 
    def decorator(f): 
     f.input_type = typ 
     @wraps(f) 
     def wrapper(arg): 
      try: 
       assert isinstance(arg, typ) 
      except AssertionError: 
       raise TypeError('{} is not of type {}'.format(arg, typ)) 
      return f(arg) 
     return wrapper 
    return decorator 

um: die

@validate_input_type(float) 
def foo(x): 
    pass 

@validate_input_type(str) 
def bar(x): 
    pass 

Dies schafft die Validierung von der Art des arg zur Laufzeit und setzt INPUT_TYPE auf

def input_stype(typ): 
    def deco(f): 
     f.input_stype = typ 
     return f 
    return deco 

@input_stype('Float') 
def Beta(x): 
    ... 

@input_stype('String') 
def Gamma(x): 
    ... 

Answer 4

Eine weitere Idee, die ich vorschlagen wollte Funktion für Introspektion.

Tests:

foo(1) -> TypeError 
bar(1) -> TypeError 
foo(1.0) -> Ok 
bar('aaa') -> Ok 

foo.input_type -> float 
bar.input_type -> str