Python: @staticmethod con @property

Question

voglio

Stats.singleton.twitter_count += 1 

e ho pensato che avrei potuto fare

class Stats: 
    singleton_object = None 

    @property 
    @staticmethod 
    def singleton(): 
     if Stats.singleton_object: 
      return Stats.singleton_object 
     Stats.singleton_object = Stats() 
     return Stats.singleton() 

Ma viene generata un'eccezione:

>>> Stats.singleton.a = "b" 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'property' object has only read-only attributes (assign to .a) 

Answer 1

Singletons sono inutili in python.

class A: 
    class_var = object() 

# two objects 
a, b = A(), A() 

# same var everywhere 
assert a.class_var is b.class_var is A.class_var 

di Python int s sono differente da semplici object s, quindi non è sempre così semplice. Ma per i tuoi scopi, questo sembra essere abbastanza:

class Stats: 
    twitter_count = 0 

Stats.twitter_count +=1 
Stats.twitter_count +=1 
assert Stats.twitter_count == 2 

Answer 2

metodi statici non lo fanno ha senso in Python. Questo perché non fanno nulla che i metodi di classe non possano fare, e sono metodi di classe molto più facili da estendere in futuro (quando i metodi di classi multiple si usano l'un l'altro ecc.).

Quello che ti serve è semplicemente una proprietà del metodo di classe.

Ho una proprietà del metodo di classe dal mio codice qui. E 'solo di sola lettura, che era tutto il necessario (in modo che il resto è un esercizio per il lettore):

class ClassProperty (property): 
    """Subclass property to make classmethod properties possible""" 
    def __get__(self, cls, owner): 
     return self.fget.__get__(None, owner)() 

# how I would use it 
class Stats: 
    singleton_object = None 
    @ClassProperty 
    @classmethod 
    def singleton(cls): 
     if cls.singleton_object is None: 
      cls.singleton_object = cls() 
     return cls.singleton_object 

Answer 3

Utente kaizer.se era su qualcosa per quanto riguarda la domanda originale. Presi un ulteriore passo avanti in termini di semplicità, in modo che ora richiede solo un singolo decoratore:

class classproperty(property): 
    def __get__(self, cls, owner): 
     return classmethod(self.fget).__get__(None, owner)() 

utilizzati:

class Stats: 
    _current_instance = None 

    @classproperty 
    def singleton(cls): 
     if cls._current_instance is None: 
      cls._current_instance = Stats() 
     return cls._current_instance 

Come indicato, questo modo di creare un singoletto non è un buon design pattern; se ciò deve essere fatto, una fabbrica di metaclassi è un modo molto migliore per farlo. Ero solo eccitato per la prospettiva di una proprietà di classe, quindi, eccolo.

Answer 4

seguito con quello che ha scritto KyleAlanHale:

suo esempio grandi opere, fino a quando si cerca di fare:

Stats.singleton = 5 

Questo non vi darà un errore, sovrascriverà la funzione, in modo che quando si digita prossima

single = Stats.singleton 
print single 

otterrete

5 

Penso che tu stia meglio usando la risposta di Kyle senza la decorazione @classproperties.