Daten und Methoden in Klassen

Variablen und Funktionen, die innerhalb einer Klasse definiert sind, sind die sogenannten member-variables bzw. member-functions.

Bei der Verwendung, d.h. ausserhalb der Klasse werden sie mittels
objectname.variable oder objectname.function() angesprochen, z.B.
u = ThreeVec(1.,2.,-1.)
v = ThreeVec(0.,2.,1.)
u.x = 7
w = u.Add(v)

Bei der Definition der Member-functions selbst, d.h. innerhalb der Klasse, werden die member-variables bzw. andere member-functions über self angesprochen.

• self ist Schlüsselwort und bezieht sich auf das jeweilige Objekt für das die Methode gerufen wird.

• self muss immer als erster Parameter der member-functions angegeben werden, aber nicht als Argument beim Aufruf, das macht Python implizit. Aufruf:
  v = ThreeVec(0.,2.,1.)
  v.Length()

• Innerhalb der member-function bezieht sich self jetzt auf den ThreeVec v, d.h. v.x == self.x, v.y == self.y, ...
  

  class ThreeVec(object):
      ...
      def Length( self ):
          return math.sqrt( self.x**2 + self.y**2 + self.z**2 )
  

• self spielt ähnliche Rolle wie this in C++/JAVA

Besondere Bedeutung hat __init__ (...) Methode

• Dient zum Anlegen des Objekts, i.d.R. sollten alle verwendeten Member-Variablen hier erzeugt werden. (Aber kein Zwang in Python, Definition/Zugriff kann von überall erfolgen, kein Verstecken der Daten möglich wie in C++/JAVA mit private.)
• Wird implizit gerufen bei Erzeugen eines Objektes der Klasse, d.h.
  v = ThreeVec( 1., 0.5, 2.) entspricht in etwa
  v = ThreeVec(); v.__init__( 1., 0.5, 2.)

Vergleich prozedural vs objektorientiert

Mit den ThreeVecs soweit jetzt diskutiert kann man sehr einfach und effizient Code für Dreier-Vektor Manipulationen schreiben, z.B. Vektoren addieren, mit Skalar multiplizieren, ...
u = ThreeVec(1.,1.,-1.)
v = ThreeVec(2.,0.,3.)
w = u.Add( v.Scale(3.) )
w = u + v * 3. # mit operator-overloading

Wie würde man es ohne Klassen/Objekte lösen ?

Variante 1: Direkt kodieren:

a = [ 1, 1, -1 ];
b = [ 2, 0, 3 ];
c = [0]*3
for i in range(3):
    c[i] = a[i] + 3. * b[i]
#

Variante 2: Entsprechende globale Python Funktionen definieren/verwenden:

def ScaleVector( vin, scale ):
    "Multiply vector elemtns by scalar"
    vout = [0]*len(vin)
    for i in range( len(vin) ) :
        vout[i] = scale*vin[i]
    return vout
#
def AddVector( v1, v2 ):
    "Add two vectors"
    vout = [0]*len(v1)
    for i in range( len(v1) ) :
        vout[i] = v1[i] + v2[i]
    return vout
#
a = [ 1, 1, -1 ];
b = [ 2, 0, 3 ];
c = ScaleVector( b, 3.)
c = AddVector( a, c )

Geht natürlich auch, aber unhandlich, kryptisch, fehleranfällig, ...