La definizione di __getattr__ e __getitem__ su una funzione non ha effetto

Question

Disclaimer Questo è solo un esercizio di meta-programmazione, non ha uno scopo pratico .

Ho assegnato __getitem__ e __getattr__ metodi su un oggetto funzione, ma v'è alcun effetto ...

def foo(): 
    print "foo!" 

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

test di integrità che siamo in grado di assegnare proprietà a una funzione:

>>> foo.baz 
'baz' 

Neat. Che ne dici dei "getter magici"?

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

È possibile avere un "getter magico" su un oggetto funzione?

Answer 1

No! Assegnazione __getitem__ a un'istanza non funziona su qualsiasi tipo di oggetto:

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

E non è possibile definire __getattr__ al tipo di funzione built-in:

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

E non è possibile sottoclasse 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

AHA! Utilizzare __call__, e avvolgere la funzione 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

Almeno su classi di nuovo stile (che sono l'unico tipo in Python 3 e il tipo che si dovrebbe usare in Python 2), Python guarda solo per i metodi di magia sulla classe (e sui suoi antenati), mai sull'istanza. Docs here.

E ovviamente non è possibile modificare il tipo di funzione o derivarne. Come hai notato, tuttavia, qualsiasi classe con un metodo __call__() crea istanze chiamabili, quindi questo è il modo per farlo.