classe __init__ (non istanza __init__)

Question

Ecco un esempio molto semplice di quello che sto cercando di muoversi:

class Test(object): 
    some_dict = {Test: True} 

Il problema è che non riesco a fare riferimento alla prova mentre è ancora in fase di definizione

Normalmente, vorrei solo fare questo:

class Test(object): 
    some_dict = {} 
    def __init__(self): 
     if self.__class__.some_dict == {}: 
      self.__class__.some_dict = {Test: True} 

Ma non ho mai creato un'istanza di questa classe. In realtà è solo un contenitore per contenere un gruppo di funzioni e dati correlati (ho alcune di queste classi e faccio riferimento a loro, quindi è è necessario per Test per essere la sua classe)

Quindi il mio la domanda è, come potrei fare riferimento a Test mentre è in fase di definizione, o c'è qualcosa di simile a __init__ che viene chiamato non appena viene definita la classe? Se possibile, voglio che self.some_dict = {Test: True} rimanga all'interno della definizione della classe. Questo è l'unico modo che conosco come fare questo finora:

class Test(object): 
    @classmethod 
    def class_init(cls): 
     cls.some_dict = {Test: True} 
Test.class_init() 

Answer 1

La classe in effetti non esiste mentre viene definita. Il modo in cui l'istruzione class funziona è che il corpo dell'istruzione viene eseguito, come blocco di codice, in uno spazio dei nomi separato. Alla fine dell'esecuzione, tale spazio dei nomi viene passato al metaclasse (come type) e il metaclasse crea la classe utilizzando lo spazio dei nomi come spazio attributi.

Dalla descrizione, è non suono necessario per Test per essere una classe. Sembra che dovrebbe essere un modulo . some_dict è un globale - anche se si tratta di un attributo di classe, c'è solo un attributo di questo tipo nel tuo programma, quindi non è migliore di avere un globale - e qualsiasi metodo di classe che hai nella classe può essere solo funzioni.

Se si vuole veramente che sia una classe, avete tre opzioni: impostare il dict dopo aver definito la classe:

class Test: 
    some_dict = {} 
Test.some_dict[Test] = True 

utilizzare una classe decoratrice (in Python 2.6 o successiva):

def set_some_dict(cls): 
    cls.some_dict[cls] = True 

@set_some_dict 
class Test: 
    some_dict = {} 

Oppure utilizzare un metaclasse:

class SomeDictSetterType(type): 
    def __init__(self, name, bases, attrs): 
     self.some_dict[self] = True 
     super(SomeDictSetterType, self).__init__(name, bases, attrs) 

class Test(object): 
    __metaclass__ = SomeDictSetterType 
    some_dict = {} 

Answer 2

si potrebbe aggiungere l'attributo some_dict dopo la definizione della classe principale.

class Test(object): 
    pass 
Test.some_dict = {Test: True} 

Answer 3

È possibile anche utilizzare un metaclasse (una funzione qui, ma ci sono altri modi) :

def Meta(name, bases, ns): 
    klass = type(name, bases, ns) 
    setattr(klass, 'some_dict', { klass: True }) 
    return klass 

class Test(object): 
    __metaclass__ = Meta 

print Test.some_dict 

Answer 4

Il primo esempio di Thomas è molto buono, ma ecco un modo più pitonico di fare la stessa cosa.

class Test: 
    x = {} 
    @classmethod 
    def init(cls): 
     # do whatever setup you need here 
     cls.x[cls] = True 
Test.init() 

Answer 5

Ho cercato di utilizzare le classi in questo modo, in passato, e diventa brutto abbastanza rapidamente (per esempio, tutti i metodi dovranno essere metodi di classe o di metodi statici, e probabilmente rendersi conto alla fine che vuoi definire determinati metodi speciali, per i quali dovrai iniziare ad usare metaclassi).Potrebbe rendere le cose molto più semplici se si usano solo istanze di classe - non ci sono davvero aspetti negativi.

A (strano-looking) alternativa a ciò che altri hanno suggerito: si potrebbe usare __new__:

class Test(object): 
    def __new__(cls): 
     cls.some_dict = {cls: True} 

Test() 

si potrebbe anche avere __new__ restituire un riferimento alla classe e utilizzare un decoratore di chiamarlo:

def instantiate(cls): 
    return cls() 

@instantiate 
class Test(object): 
    def __new__(cls): 
     cls.some_dict = {cls: True} 
     return cls