Die Definition von __getattr__ und __getitem__ für eine Funktion hat keine Auswirkungen

Question

Disclaimer Dies ist nur eine Übung in Meta-Programmierung, es hat keine praktische Zweck.

ich zugewiesen habe __getitem__ und __getattr__ Methoden auf einem Funktionsobjekt, aber es keine Wirkung ...

def foo(): 
    print "foo!" 

foo.__getitem__ = lambda name: name 
foo.__getattr__ = lambda name: name 
foo.baz = 'baz' 

Sanity prüfen, ob wir können Eigenschaften zuweisen zu einer Funktion:

>>> foo.baz 
'baz' 

Ordentlich. Wie wäre es mit den "Magischen Gettern"?

>>> foo.bar 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'function' object has no attribute 'bar' 

>>> foo['foo'] 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'function' object is not subscriptable 

>>> getattr(foo, 'bar') 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'function' object has no attribute 'bar' 

Ist es möglich, ein "Magic Getter" auf einem Funktionsobjekt zu haben?

Answer 1

Nein! Zuweisen von __getitem__ zu einer Instanz nicht auf funktioniert jede Objekttyp:

>>> class A(object): 
... pass 
... 
>>> a = A() 
>>> a.__getattr__ = lambda name: name 
>>> a.foo 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'A' object has no attribute 'foo' 

Und Sie nicht __getattr__ auf der integrierten Funktion Typ definieren:

>>> import types 
>>> types.FunctionType.__getitem__ = lambda name: name 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: can't set attributes of built-in/extension type 'function' 

Und können Sie keine Unterklasse types.FunctionType:

>>> import types 
>>> class F(types.FunctionType): 
... pass 
... 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: Error when calling the metaclass bases 
type 'function' is not an acceptable base type 

Answer 2

AHHA! Verwenden Sie __call__, und wickeln Sie die Funktion in F()

class F(object): 
    def __init__(self, fn): 
     self.__dict__['fn'] = fn 

    def __call__(self, *args, **kwargs): 
     return self.fn(*args, **kwargs) 

    def __getitem__(self, name): 
     return name 

    def __getattr__(self, name): 
     return name 

>>> foo = F(foo) 
>>> f.bar 
'bar' 
>>> f['foo'] 
'foo' 
>>> foo() 
foo! 

Answer 3

Mindestens auf neue Stil-Klassen (die die einzige Art in Python 3 und die Art sind, sollten Sie in Python 2 verwendet werden), Python sucht nur nach magischen Methoden auf der Klasse (und ihren Vorfahren), niemals auf der Instanz. Docs here.

Und natürlich können Sie den Funktionstyp nicht ändern oder davon ableiten. Wie Sie jedoch herausgefunden haben, macht jede Klasse mit einer __call__() Methode aufrufbare Instanzen, also ist dies der richtige Weg.