mechanicalStore hat geschrieben:
Warum `=` für Zuweisungen ungewöhnlich sein soll, erschließt sich mir nicht.
Ich meinte das so; "gewohnt" ist man eigentlich: Typ Var = new Typ(). Ungewohnt finde ich Var = Typ(). Eigentlich handelt es sich in dem Fall ja mehr um eine Typdeklaration als um eine Zuweisung. Klar ist, dass new zusätzliche Tipparbeit ist.
Vielleicht fangen wir mal etwas weiter unten an: In Python ist alles ein Objekt. '1' ist genau so ein Objekt wie 'myClass' oder 'my_function'. Manche Objekte haben eine '.__call__()' Methode. Diese Objekte kann man mit '()' aufrufen. Besonders häufig findet man das bei Funktionsobjekten.
Klassen sind auch Objekte. Sie haben eine '__new__' und optional auch eine '__init__' Methode. 'obj = MyClass.__new__(MyClass)' erzeugt ein Instanz von 'MyClass' mit einem leeren Zustand und gibt das zurück. Der Zustand von Objekten wird übrigens in einem '__dict__' Attribut als Dictionary gespeichert. 'obj.__init__(...)' tut dann etwas mit diesem frisch erzeugten Objekt und füllt den Zustand mit sinnvollen Startwerten. Die Kombination aus __new__ und __init__ könnte man als Konstruktor bezeichnen.
Um beides muss man sich aber in der Regeln nicht kümmern, da Klassen-Objekte auch eine __call__() Methode implementieren, also aufrufbar sind. Wird ein Klassen-Objekt aufgerufen (obj = MyClass(a,b,c)) wird erst mit 'inst = MyClass.__new__(MyClass)' eine neue Instanz erzeugt und anschließend "inst.__init__(a,b,c)" aus geführt. inst wird dann zurück gegeben.
Beim definieren von Klassen sollte man von __new__ übrigens die Finger lassen, es sei denn man möchte Singletions oder andere exotische Konstrukte erzeugen und weiß, was man da tut. __init__ ist das, was die meisten unter Konstruktor verstehen.
Wenn man das verstanden hat, macht 'obj = MyClass(parameter)' hoffentlich Sinn.
mechanicalStore hat geschrieben:
Innere (nicht statische) Klassen sind kein Problem
Sicherlich kann man aus der inneren auf die Attribute der umschliessenden Klasse zugreifen, da alles public ist. Kann es dabei zu Namenskollisionen kommen?
Hä?
Ich bin mir nicht ganz sicher, was du meinst, aber folgendes funktioniert:
Code: Alles auswählen
>>> class A(object):
... def printxy(self):
... x = 'xa'
... y = 'ya'
... class B(object):
... def printxy(self):
... y = 'yb'
... print x, y
... b = B()
... b.printxy()
...
>>> a = A()
>>> a.printxy()
xa yb
Und natürlich überschreibt ein lokal definiertes 'y' das y, das im umgebenden Block definiert wurde.
Bezeichner werden immer in folgender Reihenfolge gesucht:
1) Im Namensraum des aktuellen Blocks.
2) In den Namensräumen aller Blöcke, die zum Zeitpunkt der Definition des aktuellen Blocks auf dem Stack waren. Wichtig: NICHT die Namensräume der aufrufenden Umgebung, es sei denn, aufrufende und definierende Umgebung sind identisch (wie im Beispiel)!
3) Im globalen Namensraum.
mechanicalStore hat geschrieben:
In Python gibt es dieses Problem nicht, da Funktionen ein Datentypen erster Ordnung sind
Was genau ist mit erster Ordnung gemeint?
Man unterscheidet Funktionen erster Ordnung und Funktionen höherer Ordnung. Bei Funktionen höherer Ordnung sind Funktionen selbst Werte. Dies erlaubt es insbesondere, Funktionen als Ergebnisse oder Argumente anderer Funktionen zu verwenden.
http://de.wikipedia.org/wiki/Funktional ... er_Ordnung
So gesehen war SMAs Aussage glaube ich falsch. In Python sind Funktionen alle höherer Ordnung, da Funktionen selbst Objekte und damit Werte sind.
