Un metodo di classe che si comporta diversamente quando viene chiamato come metodo di istanza?

Question

Mi chiedo se sia possibile creare un metodo che si comporta in modo diverso quando viene chiamato come metodo di classe rispetto a quando viene chiamato come metodo di istanza.

Ad esempio, come progetto di miglioramento delle capacità, sto scrivendo una classe Matrix (sì, so che ci sono classi matrix perfettamente buone già disponibili). Ho creato un metodo di classe per questo chiamato identity che restituisce una matrice di identità di una dimensione specificata.

Ora, quando viene richiamata l'istanza di Matrix, sembra logico che la dimensione non debba essere specificata; dovrebbe restituire una matrice di identità della stessa dimensione di Matrix chiamata.

In altre parole, mi piacerebbe definire un metodo che può determinare se è stato chiamato tramite un'istanza e, in tal caso, accedere agli attributi di quell'istanza. Sfortunatamente, anche dopo aver esplorato la documentazione e alcune ricerche su Google, non ho trovato nulla che suggerisca che ciò sia possibile. Qualcuno lo sa diversamente?

Edit:

Wow! Chiaramente, non sono ancora abbastanza abituato alle funzioni di prima classe. Ecco cosa ho ottenuto - grazie a Unknown per aver fornito la chiave!

class Foo(object): 
    def __init__(self, bar): 
     self.baz = bar 
     self.bar = MethodType(lambda self: self.__class__.bar(self.baz), self, self.__class__) 

    @classmethod 
    def bar(cls, baz): 
     return 5 * baz 

Foo.bar(3) # returns 15 

foo = Foo(7) 
foo.bar() # returns 35 

Edit 2:

Solo una breve nota - questa tecnica (e la maggior parte di quelli presentati qui di seguito) non funziona su classi che definiscono __slots__, in quanto non è possibile riassegnare il metodo.

Answer 1

Gli hack di Python discutibilmente utili sono il mio forte.

from types import * 

class Foo(object): 
    def __init__(self): 
     self.bar = methodize(bar, self) 
     self.baz = 999 

    @classmethod 
    def bar(cls, baz): 
     return 2 * baz 


def methodize(func, instance): 
    return MethodType(func, instance, instance.__class__) 

def bar(self): 
    return 4*self.baz 


>>> Foo.bar(5) 
10 
>>> a=Foo() 
>>> a.bar() 
3996 

Answer 2

Penso che il problema più grande è che si sta sovraccaricando il nome "bar" sulla classe "Foo", qualcosa che Python non consente. La seconda definizione di "bar" contiene la prima definizione di "barra".

Prova a pensare a nomi univoci per il tuo metodo classmethod e istanza. Ad esempio

@classmethod 
def create(cls, baz): 
    ... 

def rubber_stamp(self): 
    ... 

Answer 3

[modificato: uso attributo da una risposta più diretta; vedere il commento utili dai John Fouhy]

È possibile utilizzare un descrittore di fare ciò che si vuole:

class cls_or_inst_method(object): 
    def __init__(self, class_method, instance_method): 
     self.class_method = class_method 
     self.instance_method = instance_method 

    def __get__(self, obj, objtype): 
     if obj is None: 
      return self.class_method 
     else: 
      return lambda: self.instance_method(obj) 

def my_class_method(baz): 
    return baz + 1 

def my_instance_method(self): 
    return self.baz * 2 

class Foo(object): 
    baz = 10 
    bar = cls_or_inst_method(my_class_method, my_instance_method) 

Utilizzando quanto sopra:

>>> print Foo.bar(5) 
6 
>>> my_foo = Foo() 
>>> print my_foo.bar() 
20 

Answer 4

@Unknown Qual è la differenza tra le di e this:

class Foo(object): 

    def _bar(self, baz): 
     print "_bar, baz:", baz 

    def __init__(self, bar): 
     self.bar = self._bar 
     self.baz = bar 

    @classmethod 
    def bar(cls, baz): 
     print "bar, baz:", baz 

In [1]: import foo 

In [2]: f = foo.Foo(42) 

In [3]: f.bar(1) 
_bar, baz: 1 

In [4]: foo.Foo.bar(1) 
bar, baz: 1 

In [5]: f.__class__.bar(1) 
bar, baz: 1 

Answer 5

È possibile riassegnare il metodo di identità in init con funzione lambda breve:

class Matrix(object): 
    def __init__(self): 
     self.identity = lambda s=self:s.__class__.identity(s) 

     #...whatever initialization code you have... 
     self.size = 10   

    @classmethod 
    def identity(self, other): 
     #...always do you matrix calculations on 'other', not 'self'... 
     return other.size 


m = Matrix() 
print m.identity() 
print Matrix.identity(m) 

Se non hai familiarità con lambda, si crea una funzione anonima. È raramente necessario, ma può rendere il tuo codice più conciso. La riga lambda sopra potrebbe essere riscritta:

def identity(self): 
     self.__class__.indentity(self) 
    self.identity = identity