Python i obiektowość

Język Python ma swoje własne podejście do obiektowości. Znajdziemy w nim rozwiązania niespotykane w innych językach, jak np. lista __slots__. Inne zaś, jak na przykład znane z języka C++ czy JAVA przeciążanie operatorów, rozwiązuje się w magiczny sposób.

Lista __slots__

Od wersji 3.3 Pythona w każdej klasie można stworzyć listę __slots__. Lista ta definiuje, jakie pola może mieć dana klasa. Próba stworzenia pola o innej nazwie nie powiedzie się:

class Vec3:

    # __slots__ = [ 'x','y','z']

    def __init__(self, x,y,z):
        self.x = x
        self.y = y
        self.z = z

if __name__ == "__main__" :
    v1 = Vec3(1.2, 3.4, 2.6)
    v1.c = "blue"
    print(v1.c)

Funkcje specjalne

Każdy obiekt w Pythonie ma zdefiniowane pewne funkcje niejako “z definicji”. Nazwy tych funkcji zaczynają i kończą się na __ (magic functions) i mają specjalne znaczenie. Zerknijmy na taki przykład:

x = 5
print(x)

v = Vec3(1.2, 3.9, 3.4)
print(v)

Dlaczego wydruk obiektu Vec3 wygląda mało przekonująco? Aby wyglądał inaczej, trzeba przedefiniować funkcję __str__()

class Vec3:

    def __init__(self, x,y,z):
        self.x = x
        self.y = y
        self.z = z

    def __str__(self) :
    	return "%.3f,%.3f,%.3f" % (self.x, self.y, self.z)
    
if __name__ == "__main__" :
    v1 = Vec3(1.2, 3.4, 2.6)
    print(v1)

Inną ciekawą możliwością jest przedefiniowanie operatorów matematycznych, takich jak +, * czy +=. Umożliwia to “naturalny” zapis opercji matematycznych na zdefiniowanych przez siebie obiektach, jak np. poniżej na liczbach zespolonych:

class Complex:

    __slots__ = [ '__re','__im']

    def __init__(self, re,im):
        self.__re = re
        self.__im = im
    
    def __str__(self) :
        return "%f + %fi" % (self.__re, self.__im)

    def __iadd__(self,c2) :
        
        if isinstance(c2, Complex) : # the interesting case when c2 is complex
            self.__re += c2.__re
            self.__im += c2.__im
        else :
            self.__re += c2 # the case when c2 is just a real value
        return self

if __name__ == "__main__" :
    c1 = Complex(1.2, 3.0)
    c2 = Complex(0.8, -2.0)
    c1 += c2
    print(c1)

Kolejnym operatorem wartym uwagi jest operator wywołania (call operator). Jego nadpisanie umożliwia wykorzystanie obiektu w dokładnie ten sposób jak funkcja.

class FunctionLike:
    def __call__(self, a):
        print("I got called with %r!" % (a))

fn = FunctionLike()
fn(10)

Przykładów zastosowania jest mnóstwo; weźmy chociażby pole siłowe dynamiki molekularnej:

from Vec3 import Vec3

class LJ:

    __slots__ = ['__vi', '__vj', '__epsilon4','__sigma2']

    def __init__(self,v_i, v_j, **params) :
        self.__vi = v_i
        self.__vj = v_j
        self.__epsilon4 = params["epsilon"] * 4
        self.__sigma2 = params["sigma"] * params["sigma"]

    def __call__(self):
        d2 = self.__sigma2 / self.__vi.distance_square_to(self.__vj)
        d6 = d2*d2*d2
        d12 = d6*d6

        return self.__epsilon4 * (d12 - d6)

v_1 = Vec3(0,0,0)
v_2 = Vec3(8,1,0)
en = LJ(v_1, v_2, epsilon = 0.04, sigma = 3.4)

for i in range(0,100) :
    v_1.x = v_1.x + 0.1
    print(v_1.distance_to(v_2), en())

Metody i pola statyczne

Funkcje (i pola) statyczne istnieją nawet wtedy, kiedy nie utworzono ani jednego obiektu danej klasy. Jeżeli jednak obiekt już jest, to mają do niego pełen dostęp - jako pełnoprawny członek klasy. Zauważ, że składowe statyczne również mogą być prywatne lub publiczne.

• w JAVA są konieczne: nie ma innej możliwości zdefiniowania funkcji

• w Pythonie, C++ : ułatwiają organizację kodu.

Statyczne pole klasy w Pythonie implementujemy następująco:

class StaticR :

    r = 50
    __slots__ = [ 'x', 'y' ] 
    def __init__(self,x,y) :
        self.x = x
        self.y = y
    
    @staticmethod
    def scale_by(factor) :
        StaticR.r *= factor

c1 = StaticR(1,2)
c2 = StaticR(3,4)
#c1.r = 20      # This line should fail !!!
print(c2.r)
print(StaticR.r)
StaticR.scale_by(1.2)
print(c1.r)

Zamiast podsumowania

from math import sqrt

class Vec3:

    __slots__ = [ '__x','__y','__z']
  
    def __init__(self,*args) :
      
      if args is None or len(args) == 0:
        self.__x, self.__y, self.__z = 0.0, 0.0, 0.0 # Default constructor
      elif len(args) == 3 :                # support for Vec3(1.2,3.8,0.1)
        self.__x, self.__y, self.__z = args[0], args[1], args[2]
      elif len(args) == 1 :            
        if isinstance(args[0], Vec3) :   # support for Vec3(v)
          self.__x, self.__y, self.__z = args[0].__x, args[0].__y, args[0].__z
        elif isinstance(args[0], list) : # support for Vec3( [1.2,3.8,0.1] )
          self.__x, self.__y, self.__z = args[0][0], args[0][1], args[0][2]
        else :                           # support for Vec3(0)
          self.__x, self.__y, self.__z = args[0], args[0], args[0]
    
    @property
    def x(self) : return self.__x

    @property
    def y(self) : return self.__y

    @property
    def z(self) : return self.__z

    @x.setter
    def x(self,x) : self.__x = x

    @y.setter
    def y(self,y) : self.__y = y

    @z.setter
    def z(self,z) : self.__z = z

    def __str__(self) :
        return "%.3f, %.3f, %.3f" % (self.__x, self.__y, self.__z)

    def distance_square_to(self, vj):
        d2 = (self.__x - vj.__x) * (self.__x - vj.__x)
        d2 += (self.__y - vj.__y) * (self.__y - vj.__y)
        return d2 + (self.__z - vj.__z) * (self.__z - vj.__z)

    def distance_to(self, vj):
        return sqrt(self.distance_square_to(vj))

    def __isub__(self, v):
        self.x -= v.x
        self.y -= v.y
        self.z -= v.z
        return self

    def __iadd__(self, v):
        self.x += v.x
        self.y += v.y
        self.z += v.z
        return self

    def __add__(self, rhs):
        v = Vec3(self)
        v += rhs
        return v

    def __sub__(self, rhs):
        v = Vec3(self)
        v -= rhs
        return v

    def __imul__(self, rhs):
        self.x *= rhs
        self.y *= rhs
        self.z *= rhs
        return self


if __name__ == "__main__" :
    v0 = Vec3()
    v1 = Vec3(1.2, 3.4, 2.6)
    v1.z = 8.2
    print(v1.x)
    print(v1.y)
    print(v1)
    v2 = Vec3(-1.2, 0.4, 3.0)
    print(v1 - v2)