Klasy - dziedziczenie

Stronę tą wyświetlono już: 1472 razy

Na stronie Programowanie → Podstawy Pythona → Klasy omawiałem podstawy dotyczące tworzenia klas w Pythonie, nadeszła stosowna ku temu pora, aby zacząć omawiać sam mechanizm dziedziczenia w Pythonie. Zanim jednak uczynię to z najdzikszą rozkoszą, warto poskładać do kupy utworzony na wcześniej przeze mnie wspomnianej stronie kod dwóch klas tam utworzonych:

Listing 1
  1. class Matrix_tr:
  2. def __init__(self, m11 = 1, m12 = 0, m21 = 0, m22 = 1, dx = 0, dy = 0, alpha = None):
  3. if alpha is None: # if alpha angle is set on None value
  4. self.m11 = m11
  5. self.m12 = m12
  6. self.m21 = m21
  7. self.m22 = m22
  8. else: # in other case calculate m11 - m22 using alpha angle
  9. self.m11 = mt.cos(alpha)
  10. self.m12 = -mt.sin(alpha)
  11. self.m21 = - self.m12 # this should be sin of angle alpha
  12. self.m22 = self.m11 # this should be cos of angle alpha
  13. self.dx = dx # this is an offset for x
  14. self.dy = dy # this is an offset for y
  16. def __mul__(self, other): # multiplication operator (*)
  17. if isinstance(other, Point2D): # for object of Point2D class
  18. return Point2D(other.x * self.m11 + other.y * self.m12 + self.dx, other.x * self.m21 + other.y * self.m22 + self.dy)
  19. if isinstance(other, matrix_tr): # for object of matrix_tr class
  20. return matrix_tr(self.m11 * other.m11 + self.m12 * other.m21, self.m11 * other.m12 + self.m12 * other.m22, self.m21 * other.m11 + self.m22 * other.m21, self.m21 * other.m12 + self.m22 * other.m22, self.m11 * other.dx + self.m12 * other.dy + self.dx, self.m21 * other.dx + self.m22 * other.dy + self.dy)
  22. def __str__(self):
  23. return "| M11 = {m.m11:+{l}.5f} M12 = {m.m12:{l}.5f} dx = {m.dx:+{l}.5f} |\n| M21 = {m.m21:+{l}.5f} M22 = {m.m22:+{l}.5f} dy = {m.dy:+{l}.5f} |\n| M31 = {m31:+{l}.5f} M32 = {m32:+{l}.5f} {m33:+{l}.5f} |".format(m = self, l = 10, m31 = 0, m32 = 0, m33 = 1)
  25. class Point2D:
  26. tr = Matrix_tr()
  27. def __init__(self, x = None, y = None):
  28. self.x = float(input("Podaj współrzędną x: ")) if (x is None) else x
  29. self.y = float(input("Podaj współrzędną y: ")) if (y is None) else y
  30. def __del__(self):
  31. pass
  32. def __int__(self):
  33. return int((self.x * self.x + self.y * self.y) ** 0.5)
  34. def __float__(self):
  35. return (self.x * self.x + self.y * self.y) ** 0.5
  36. def __str__(self):
  37. return "Point2D(x={x}, y={y})".format(x = self.x, y = self.y)
  38. def __eq__(self, other):
  39. if isinstance(other, Point2D):
  40. return True if other.x == self.x and other.y == self.y else False
  41. else:
  42. return True if (float(self) == other) else False
  43. def __ne__(self, other):
  44. return not (self == other)
  45. def __lt__(self, other):
  46. return float(self) < float(other)
  47. def __gt__(self, other):
  48. return float(self) > float(other)
  49. def __le__(self, other):
  50. return not (self > other)
  51. def __gt__(self, other):
  52. return not (self < other)
  53. def __add__(self, other):
  54. if isinstance(other, Point2D):
  55. return Point2D(self.x + other.x, self.y + other.y)
  56. else:
  57. return Point2D(self.x + float(other), self.y + float(other))
  58. def __sub__(self, other):
  59. if isinstance(other, Point2D):
  60. return Point2D(self.x - other.x, self.y - other.y)
  61. else:
  62. return Point2D(self.x - float(other), self.y - float(other))
  63. def __mul__(self, other):
  64. if isinstance(other, Point2D):
  65. return self.x * other.x + self.y * other.y
  66. else:
  67. return Point2D(self.x * float(other), self.y * float(other))
  68. def __radd__(self, other):
  69. if isinstance(other, Point2D):
  70. return Point2D(self.x + other.x, self.y + other.y)
  71. else:
  72. return Point2D(self.x + float(other), self.y + float(other))
  73. def __rsub__(self, other):
  74. if isinstance(other, Point2D):
  75. return Point2D(other.x - self.x, other.y - self.y)
  76. else:
  77. return Point2D(float(other) - self.x, float(other) - self.y)
  78. def __rmul__(self, other):
  79. if isinstance(other, Point2D):
  80. return self.x * other.x + self.y * other.y
  81. else:
  82. return Point2D(self.x * float(other), self.y * float(other))
  83. def __iadd__(self, other):
  84. if isinstance(other, Point2D):
  85. self.x += other.x
  86. self.y += other.y
  87. else:
  88. self.x += float(other)
  89. self.y += float(other)
  90. return self
  91. def __isub__(self, other):
  92. if isinstance(other, Point2D):
  93. self.x -= other.x
  94. self.y -= other.y
  95. else:
  96. self.x -= float(other)
  97. self.y -= float(other)
  98. return self
  99. def __imul__(self, other):
  100. self.x *= float(other)
  101. self.y *= float(other)
  102. return self
  103. def __pos__(self):
  104. return Point2D(self.x, self.y)
  105. def __neg__(self):
  106. return Point2D(- self.x, - self.y)
  107. def __abs__(self):
  108. return Point2D(abs(self.x), abs(self.y))
  109. # Metody klasy
  110. def det(self, pt): # calculate determinant of two vectors
  111. if isinstance(pt, Point2D):
  112. return self.x * pt.y - pt.x * self.y
  113. elif instance(pt, tuple):
  114. return self.x * pt[1] - pt[0] * self.y
  115. def draw(self):
  116. print(Point2D.tr * self)

Mechanizm dziedziczenia oraz wywoływanie konstruktora klasy bazowej

Utwórzmy sobie klasę o jakże wymownej nazwie Point3D. Ta klasa będzie dziedziczyła po klasie Point2D w sposób następujący:

Listing 2
  1. class Point3D(Point2D):
  2. def __init__(self, x = None, y = None, z = None):
  3. Point2D.__init__(self, x, y) # constructor of base class
  4. self.z = float(input("Podaj współrzędną z: ")) if z is None else z

Można oczywiście dziedziczyć po wielu obiektach, wystarczy zaraz za nazwą klasy w nawiasie wypisać nazwy klas dziedziczonych oddzielone przecinkiem.

Wywoływanie metod klasy bazowej

Utwórzmy sobie taką oto metodę wewnętrzną klasy Point3D:

Listing 3
  1. def draw(self):
  2. Point2D.draw(self)
  3. print(self)

Jeżeli teraz napiszę taki oto kod:

Listing 4
  1. p3d = Point3D(1,2,3)
  2. p3d.draw()
  3. Point2D.draw(p3d)

W takim przypadku wyświetli się coś takiego:

Point2D(x=1, y=2)
Point3D(x=1, y=2, z=3)
Point2D(x=1, y=2)

Komentarze