zugriff auf class-variable aus superklasse

[Dill]

tja, wie macht man das?
(siehe exception unten)

danke schonmal

Code: Alles auswählen

class Multiton( object ):
    __instances = {}
    def __new__( cls, key ):
        if not key in cls.__instances:
            cls.__instances[key] = object.__new__(cls, key)
        return cls.__instances[key]
    def __init__(self, key):
        self.key = key
    
    @classmethod
    def debug_instances(cls):
        for k, v in cls.__instances.items():
            print v
    



class MultitonErbe( Multiton ):
    
    #(...)
    
    @classmethod
    def sth_useful(cls):
        for k, v in cls.__instances.items():
            print v

>>> Multiton.debug_instances()
funktioniert!
>>> MultitonErbe.debug_instances()
funktioniert!
>>> MultitonErbe.sth_useful()
(...)
AttributeError: type object 'MultitonErbe' has no attribute '_MultitonErbe__instances'

[Leonidas]

Die einfachste Lösung: auf Name-Mangling verzichten und aus den ``__instances`` einfach ``_instances`` oder gar nur ``instances`` zu machen.

[EyDu]

Code: Alles auswählen

class MultitonErbe( Multiton ): 
    
    #(...) 
    
    @classmethod 
    def sth_useful(): 
        for k, v in Multiton .__instances.items(): 
            print v 

[Dill]

instances sollte schon private sein.

EyDu, mit deiner lösung arbeitet sth_useful() auf den instanzen aller klassen die von multiton erben, das darf nicht.

[Leonidas]

instances sollte schon private sein.

Private gibt es in Python nicht, so ein Mechanismus ist nicht eingebaut. Es gibt nur Name-Mangling oder gar nichts.

[Dill]

Der Sinn des name mangling bei klassenvariablen ist der schutz der variable.
Und das möchte ich tun.

Wenn du es so genau nimmst, gibt es in Java auch keine privaten variablen (afaik kann man über reflection an die privaten variablen kommen) und in C++ geht das mit sicherheit auch ... wie auch immer ...

[BlackJack]

Der Sinn des "name mangeling" ist *nicht* Zugriffsschutz, sondern dass der Name in Subklassen wiederverwendet werden kann, ohne das Kollisionen entstehen. Genau das willst Du ja offensichtlich nicht, also nimm keine zwei Unterstriche.

[Dill]

hmm gut zu wissen ... da hab ich wohl was falsch verstanden

...naja also kein wunder, dass das nicht geht

[Dill]

Hi,


habe jetzt also den doppelten underscore in einen einfachen geändert.
Jetzt gibt aber MultitonErbe.sth_useful() auch die instanzen von
Dummy(Multiton) aus.
Was mache ich falsch?

(ich möchte nicht explizit in sth_useful() testen ob _instances.item() instanz von MutlitonErbe ist.)

Code: Alles auswählen

class Multiton( object ):
    _instances = {}
    def __new__( cls, key ):
        if not key in cls._instances:
            cls.__instances[key] = object.__new__(cls, key)
        return cls._instances[key]
    def __init__(self, key):
        self.key = key
   
    @classmethod
    def debug_instances(cls):
        for k, v in cls._instances.items():
            print v
   

class Dummy( Multiton ):
    pass


class MultitonErbe( Multiton ):
   
    #(...)
   
    @classmethod
    def sth_useful(cls):
        for k, v in cls._instances.items():
            print v 

[BlackJack]

Da schlägt die ganz normale Vererbung zu, die Unterklassen erben `_instances` von `Multiton`. Du kannst das Attribut einfach bei Bedarf erzeugen:

Code: Alles auswählen

class Multiton( object ): 
    # _instances = {} 
    def __new__(cls, key):
        if not hasattr(cls, '_instances'):
            cls._instances = dict()
        if key not in cls._instances:
            cls._instances[key] = object.__new__(cls, key)
        return cls._instances[key]