Code: Alles auswählen
In [32]: class A(object):
....: def __init__(self):
....: self.__spam = 42
....:
In [33]: a = A()
In [34]: a._A__spam
Out[34]: 42OK, danke für die Aufklärung. Mit war klar, dass der Doppelunterstrich eine Namensersetzung macht. Mir war nur nicht klar, dass man den per Konvention trotzdem lieber den einfachen Unterstrich nimmt.BlackJack hat geschrieben:h auch nicht oft, weil Mehrfachvererbung halt auch so seine Tücken hat.
Per Konvention bedeutet *ein* führender Unterstrich "Achtung, Implementierungsdetail! Verwenden auf eigene Gefahr!".
Nein und nein. Es ist wird einfach die Methode anders benannt, das ist alles. Sowas kannst du dir auch selbst schreiben, wenn der Interpreter das nicht bereits machen würde.barfoos hat geschrieben:Frisst der Doppelstrich denn viel Rechenleistung, oder wird das beim Kompilieren geregelt?
Was meinst du mit Compilezeit?barfoos hat geschrieben: Mein Problem ist wahrscheinlich, dass ich aus der Java-Welt komme. Gerade der Fakt, dass ich zur Compilezeit kaum erkennen kann, welche Attribute durch Vererbung/Mehrfachvererbung bereits existieren, hat mich dazu bewogen recht üppig von den doppelten Unterstrichen gebraucht zu machen, um nicht versehentlich ein Attribut doppelt zu belegen.
Code: Alles auswählen
>>> class Foobar:
... foo = 1.0
...
>>> class Barfoo(Foobar):
... bar = 2.0
...
>>> f = Foobar()
>>> dir(f)
['__doc__', '__module__', 'foo']
>>> b = Barfoo()
>>> dir(b)
['__doc__', '__module__', 'bar', 'foo']
>>>Äh, mal naiv geraten: Die Zeit, in der ein Quellcode kompiliert wird? Jaja, iIch weiß, ist irgendwie weit hergeholt, aber vielleicht hab ich ja heute Glück im Raten ...Fabian Kochem hat geschrieben:Was meinst du mit Compilezeit?barfoos hat geschrieben: Mein Problem ist wahrscheinlich, dass ich aus der Java-Welt komme. Gerade der Fakt, dass ich zur Compilezeit kaum erkennen kann, welche Attribute durch Vererbung/Mehrfachvererbung bereits existieren, hat mich dazu bewogen recht üppig von den doppelten Unterstrichen gebraucht zu machen, um nicht versehentlich ein Attribut doppelt zu belegen.
Das Forum ist ja auch kein Python, sondern diese andre Sprache mit dem P ... dieses schreckliche .. ihr wisst schonpcos hat geschrieben: Und das ist einem Forum zu einer Sprache, die auf magic features pfeift!
"Praktisch" ist Geschmackssache. In meinem Fall war es so, dass es zwei Optionen gibt. Einerseits das Öffnen einer bestehenden Projektdatei und andererseits das neu Anlegen einer Projektdatei und darauffolgendes Öffnen.BlackJack hat geschrieben:@Flo668: Ich möchte noch einmal nachfragen, was denn so superpraktisch am überladen ist? In den meisten Fällen, die ich zum Beispiel aus Java kenne, kann man das in Python mit "default" Argumenten lösen.
Und da Du andere OO-Sprachen erwähnst: In Python gibt es kein "private" und Deine vielen doppelten Unterstriche riechen nach Missbrauch dieses Mechanismus. Wenn Du "private" Attribute haben möchtest, reicht ein einzelner führender Unterstrich um dies zu kennzeichnen.
Das Buch von Galileo Computing etwa? Das Buch ist eigentlich "Java ist auch eine Insel" nur mit Python-Syntax. Nicht empfehlenswert.Flo668 hat geschrieben:Was das mit den Strichen angeht, so habe ich nur das getan, was mir in meinem Python Lehrbuch erklärt wurde. Dort stand, dass der doppelte Unterstrich privaten Klassenattributen entsprechen würde.
Dieses Feature hast du in Python auch, indem du einen `_` vor die Variable setzt, womit du definierst, dass es nicht zum öffentlichen Interface der Klasse gehört. Letztendlich ist das so wie in Java auch, nur dass du dort die Reflection-API brauchst um dich an private Attribute ranzumachen, wärend du in Python einen ``_`` schreibst. Und es ist manchmal doch nützlich private Attribute zu modifizieren.Flo668 hat geschrieben:Warum man bei der Konstruktion von Python auf dieses Feature dann doch verzichtet hat, wüsste ich mal gerne. Ich erinnere mich da an Informatikvorlesungen wo lang, breit und ausführlich dieses Design als eines der Herausstellungsmerkmale Objektorientierter Sprechen zelebriert wurde.
- In Python gibt es keine privaten Variablen oder Methoden.
- Konvention: Attribute, auf die nicht von aussen zugegriffen werden sollte, beginnen mit einem Unterstrich: _foo.
- Um Namenskonflikte zu vermeiden: Namen der Form __foo werden durch _klassenname__foo ersetzt:
Code: Alles auswählen
class Spam: __eggs = 3Code: Alles auswählen
>>> dir(Spam) >>> ['_Spam__eggs', '__doc__', '__module__']
Nein Addison Wesley, "Peter Walerowski: Python- Grundlagen und Praxis" auf S. 116Leonidas hat geschrieben: Das Buch von Galileo Computing etwa? Das Buch ist eigentlich "Java ist auch eine Insel" nur mit Python-Syntax. Nicht empfehlenswert.
Code: Alles auswählen
def Project(object):
def __init__(self, filename, create_new=False):
passCode: Alles auswählen
class Parrot(object):
def __init__(self, spam, eggs=42):
self.spam = spam
self.eggs = eggs
@classmethod
def load(cls, filename):
# Daten laden.
return cls(spam, eggs)
def save(self, filename):
# Daten speichern.Was ja per se auch nicht verwerflich ist, immerhin möchte man ja vielleicht auch mal private Methoden unittesten. Wohl aus diesem Grund funktioniert der Weg über Reflection meines Wissens auch in .NET.Leonidas hat geschrieben:Letztendlich ist das so wie in Java auch, nur dass du dort die Reflection-API brauchst um dich an private Attribute ranzumachen.
Ja, sicher. Wirft dem Programmierer aber IMHO mehr Steine in den Weg als nötig. Im Vergleich scheint "Nutze die Reflection-API" vs. "Schreibe ein ``_`` vor den Namen" als eine eher umständliche Art das selbe zu erreichen aus. Was ich damit sagen will: beide Methoden sing gleichwertig, jedoch ist die Methode einen Bodenstrich vor den Namen zu schrieben schlichtweg unkomplizierter.lunar hat geschrieben:Was ja per se auch nicht verwerflich ist, immerhin möchte man ja vielleicht auch mal private Methoden unittesten. Wohl aus diesem Grund funktioniert der Weg über Reflection meines Wissens auch in .NET.Leonidas hat geschrieben:Letztendlich ist das so wie in Java auch, nur dass du dort die Reflection-API brauchst um dich an private Attribute ranzumachen.
Code: Alles auswählen
def _getText(nodelist):
# usf.
def _printData(self):
for ce in self._list:
print 'NEUES ELEMENT \n'
n = ce.uri
print self._getText(n)
Code: Alles auswählen
self._getText(n)Code: Alles auswählen
MeineKlasse._getText(self, n)