setattr() debugging in eclipse

[hypnoticum]

Hallo,
ich weiß nicht warum ich beim debuggen mit eclipse das mit setattr() gesetzte attribut 'pony' nicht im Variablenfenster angezeigt bekomme. Die Variable 'self' kann ich beobachten. Ausserdem weiß ich nicht warum ich die Instanz nicht mit {'flip': 1, 'flop': 2} initialisieren kann.

Code: Alles auswählen

pin = {'beep':1, 'blub':2}

class blop(dict):
    def __init__(self):
        self = {'flip': 1, 'flop': 2}

y = blop()
setattr(y, 'pony', pin)

[lunar]

Was bitte soll "self = {'flip': 1, 'flop': 2}" denn bewirken? Ist Dir überhaupt klar, was diese Zeile tatsächlich bewirkt?

[hypnoticum]

Ich wollte eine 'blop'-Instanz mit dem Wert {'flip': 1, 'flop': 2} initialisieren.
Hast du eine Idee warum ich die Attribute im Eclipse-Editor nicht sehen kann, obwohl Sie auf der Kommandozeile ausgegeben werden? Bei Klassen die zB vom Typ 'object' abgeleitet wurden geht es.

[lunar]

So funktioniert Python nicht. Ich frage nochmal: Ist Dir denn überhaupt klar, was diese Zeile tatsächlich bewirkt? Falls nicht, dann lies bitte nochmal das Tutorial, insbesondere den Abschnitt über Klassen und Vererbung.

Von Eclipse habe ich keine Ahnung.

[Leonidas]

Es gibt keine Attribute, da Eclipse das statisch machen muss und Python zu dynamisch ist um statisch alle Attribute einer Klasse bestimmen zu können.

[hypnoticum]

@lunar:
Frag mich bitte nochmal. Ich habe es doch schon geschrieben, was ich mit dieser Zeile anstellen wollte. Oder schreib noch mehr ohne tatsächlich irgendetwas zu erklären.

[Leonidas]

Ok, die Erklärung ist: Du bindest ein Dictionary an den lokalen Namen ``self``.

Und lunar hat nicht gefragt was du damit machen wolltest, sondern ob du weißt was die Zeile die du geschrieben hat *eigentlich* macht. Wir haben alle grob verstanden was du machen willst, aber das was du machen willst macht irgendwie nicht wirklich Sinn.

Wie ich es verstanden habe: Du willst ein Callable wo, wenn man es aufruft ein Dictionary rauskommt, richtig?

Code: Alles auswählen

y = blop()
print blop
{'flip': 1, 'flop': 2}

Also sowas, ja?

[hypnoticum]

Ich will eine Instanz, die durch Parameter repräsentiert wird, welche wiederum in einem Dictionary organisiert sind.
Diese Instanz soll auch die Attribute eines Dictionaries haben, aber um weitere Attribute ergänzt werden, welche wiederum Instanzen der gleichen Klasse sind.
Das ganze wird dann ein Objekt mit dynamisch zuweisbaren Attributen die auch dynamisch wieder abgefragt werden.

Der Ansatz funktionierte auch, nur werden mir die Attribute beim Debugging im Variablenfenster von Eclipse nicht mehr angezeigt, was ich nicht verstehe und was unpraktisch ist.
Die Attribute 'key' und 'pony' kann ich mir aber auf der Konsole mit 'x.key' und 'x.pony' anzeigen lassen.

Code: Alles auswählen

pin = {'beep':1, 'blub':2}

class blop(dict):
    def __init__(self):
        self.key = 'key'
        blopDict = self
        blopDict['flip'] = 1
        blopDict['flop'] = 2
        
class peng(blop):
    def __init__(self):
        blop.__init__(self)
    
x = peng()
setattr(x, 'pony', pin)

Die von mir im Projekt verwendete Klasse sieht so aus:

Code: Alles auswählen

import os

class PyATParam(dict):
    def __init__(self, path, key):    
        self.key = key          
        self.read(path)
        
    def read(self, path):
        if os.path.isfile(path):
            file = open(path, 'r')
        else:  
            file = self.gen_default(path)
        file.seek(0)
        
        try: 
            at_dict = self
            root = []
            for line in file:
                if not line.strip():
                    continue
                elif line [0] == '{':
                    name = line.strip().replace("{", "")
                    at_dict[name] = {}
                    root.append(at_dict)
                    at_dict = at_dict[name]  
                elif line [0] == '}':
                    at_dict = root.pop()  
                elif line[0] != "#":    
                    item = line.split("=") 
                    at_key = item[0].strip()
                    at_dict[at_key] = item[1].strip()
            file.close()

        except:
            PyMsgBox.PopUpMsg().dispConfirm("File /"" + path + "/" does not exist or is corrupted.", "Error", 0)  

    ... (weitere Methoden)

Ich denke ich werde die Verschachtelung nicht mehr über dynamisch als Attribute hinzugefügte Instanzen zu lösen versuchen, sondern die Instanzen auch in dem Dictionary der erzeugenden Instanz einfügen.

[ms4py]

Subclassing mit einem dict machst du besser so:

Code: Alles auswählen

class MyDict(dict):
    def __init__(self):
        dict.__init__(self)
        self.update({'flip': 1, 'flop': 2})

p = MyDict()
print p
p['flup'] = 3
print p

Edit: Oder besser noch so

Code: Alles auswählen

class MyDict(dict):
    def __init__(self):
        dict.__init__(self, {'flip': 1, 'flop': 2})

[BlackJack]

@hypnoticum: Der Debugger von Pydev zeigt nicht alle Objekte/Typen gleich an. Für `dict` -- und damit auch Unterklassen davon -- werden beim Ausklappen nicht die Attribute angezeigt, sondern die Länge und die Schlüssel/Wert-Paare.

[hypnoticum]

@BlackJack:
Ja genau so verhält es sich!
Danke für die Antwort, ich war mir nicht sicher, ob das beschriebene Verhalten 'richtig' ist, oder der 'Fehler' bei mir lag.