Klasy
Definicję klasy zaczynamy od słowa kluczowego class, a następnie podajemy nazwę klasy, zazwyczaj zaczynając od wielkiej litery. Jeżeli klasa po czymś dziedziczy, to podajemy to wewnątrz nawiasów okrągłych po nazwie klasy.
Klasa abstrakcyjna
Aby zdefiniować klasę abstrakcyjną, której obiektu nie możemy utworzyć, ale możemy ją wykorzystywać w dziedziczeniu, skorzystamy z klasy bazowej ABC z modułu abc. Z tego samego modułu przydatny będzie także dekorator abstractmethod za pomocą którego możemy oznaczyć wybraną metodę klasy abstrakcyjnej jako abstrakcyjną, która musi zostać zaimplementowana w klasie pochodnej.
| from abc import ABC, abstractmethod
class Figure(ABC):
"""Klasa abstrakcyjna reprezentująca figurę.
Aby utworzyć klasę abstrakcyjną, dziedziczymy po specjalnej klasie ABC, którą należy zaimportować z pakietu abc.
"""
@abstractmethod
def area(self) -> float:
"""Metoda obliczająca pole figury.
Metoda abstrakcyjna.
Metody abstrakcyjne oznaczamy za pomocą dekoratora @abstractmethod z pakietu abc.
Muszą zostać przeciążone w klasie potomnej.
"""
pass
@abstractmethod
def perimeter(self) -> float:
"""Metoda obliczająca obwód figury.
Metoda abstrakcyjna.
"""
pass
if __name__ = "__main__":
figure = Figure() # BŁĄD! Nie możemy tworzyć obiektu klasy abstrakcyjnej
|
Dziedziczenie
Standardowe klasy powinny mieć zdefiniowany własny konstruktor/inicjalizator: metodę __init__.
Do każdej metody w klasie przekazujemy jako pierwszy parametr self, który jest odniesieniem do obiektu klasy, na której pracujemy (podobnie jak this w niektórych językach).
| from random import randint
from math import pi, sin, radians
class Quad(Figure):
"""Klasa reprezentująca czworokąt.
Dziedziczy po klasie Figure.
"""
def __init__(self, side1: float, side2: float, side3: float, side4: float, diagonal1: float, diagonal2: float, angle: float):
"""Konstruktor klasy.
Argumenty:
side1, side2, side3, side4 - długości boków
diagonal1, diagonal2 - długości przekątnych
alpha - kąt pomiędzy przekątnymi
"""
# Zmienne zaczynające się od pojedyńczego znaku podłogi traktowane są umownie jako protected.
self._sides = [side1, side2, side3, side4]
# Zmienne zaczynające się od podwójnego znaku podłogi traktowane są umownie jako prywatne.
self.__d1 = diagonal1
self.__d2 = diagonal2
self.__angle = angle
def area(self) -> float:
"""Metoda obliczająca pole czworokąta na podstawie długości przekątnych i kąta alpha pomiędzy nimi.
Metoda publiczna, dziedziczona przez potomków
"""
return (self.__d1 * self.__d2 * sin(radians(self.__angle))) / 2
def perimeter(self) -> float:
"""Metoda obliczająca obwód figury jako sumę długości boków.
Metoda publiczna, dziedziczona przez potomków.
"""
return sum(self._sides)
|
Atrybuty klasy
Zmienne wewnątrz klasy, których nazwa zaczyna się od podwójnego znaku podłogi, uznajemy za prywatne. Zmienne te nie mogą być użyte na zewnątrz klasy.
Pozostałe zmienne są generalnie publiczne, chociaż te, których nazwa zaczyna się od pojedyńczego znaku podłogi uznajemy za protected, tzn. dostępne tylko w klasach pochodnych.
Aby mieć kontrolę nad dostępem do zmiennych w obiekcie, możemy skorzystać z dekoratorów property oraz setter odpowiednio do tworzenia atrybutów do odczytu i zapisu.
| class Rectangle(Quad):
"""Klasa reprezentująca prostokąt.
Dziedziczy po klasie Quad reprezentującej czworokąt, jako że prostokąt jest czworokątem.
"""
def __init__(self, height: float, width: float):
"""Konstruktor klasy.
Jako że klasa Rectangle dziedziczy po klasie Quad wymagane jest wywołanie konstruktora klasy rodzica.
Wykonujemy to pisząc super().__init__(argumenty).
Argumenty:
height - wysokość prostokąta
width - szerokość prostokąta
"""
super().__init__(height, width, height, width, 0, 0, 0)
@property
def height(self) -> float:
"""Wysokość prostokąta. Getter.
Atrybut klasy do odczytu. Działa podobnie jak getter z Javy.
"""
return self._sides[0]
@height.setter
def height(self, value: float):
"""Wysokość prostokąta. Setter.
Atrybut klasy do zapisu. Działa podobnie jak setter z Javy.
"""
self._sides[0] = value
self._sides[2] = value
@property
def width(self) -> float:
"""Szerokość prostokąta. Getter."""
return self._sides[1]
@width.setter
def width(self, value: float):
"""Szerokość prostokąta. Setter."""
self._sides[1] = value
self._sides[3] = value
def area(self) -> float:
"""Metoda obliczająca pole prostokąta przemnażając wysokość i szerokość."""
return self.width * self.height
|
| class Square(Rectangle):
"""Klasa reprezentująca kwadrat.
Dziedziczy po klasie Rectangle reprezentującej prostokąt, jako że kwadrat jest prostokątem.
"""
def __init__(self, size: float):
"""Konstruktor klasy.
Jako że klasa Square dziedziczy po klasie Rectangle wymagane jest wywołanie konstruktora klasy rodzica.
Wykonujemy to pisząc super().__init__(argumenty).
Argumenty:
size - długość boku
"""
super().__init__(size, size)
class Ellipse(Figure):
"""Klasa reprezentująca elipsę.
Dziedziczy po klasie Figure.
"""
def __init__(self, radius1: float, radius2: float):
"""
Konstruktor klasy.
Jako że klasa Ellipse dziedziczy po klasie abstrakcyjnej Figure, nie wywołujemy konstruktora klasy rodzica.
Argumenty:
radius1 - pierwszy promień elipsy
radius2 - drugi promień elipsy
"""
self._radius1 = radius1
self._radius2 = radius2
def area(self):
"""Metoda obliczająca pole elipsy. Nie została zaimplementowana."""
raise NotImplemented
def perimeter(self):
"""Metoda obliczająca obwód elipsy. Nie została zaimplementowana."""
raise NotImplemented
class Circle(Ellipse):
"""Klasa reprezentująca koło.
Dziedziczy po klasie Ellipse reprezentującej elipsę, jako że koło jest też elipsą.
"""
def __init__(self, radius: float):
"""Konstruktor klasy.
Jako że klasa Circle dziedziczy po klasie Ellipse wymagane jest wywołanie konstruktora klasy rodzica.
Wykonujemy to pisząc super().__init__(argumenty).
Argumenty:
radius - promień koła
"""
super().__init__(radius, radius)
@classmethod
def one(cls):
"""Metoda klasowa tworząca koło o promieniu 1.
Taki sposób pozwala na utworzenie dodatkowych "konstruktorów".
"""
return cls(1)
@property
def radius(self):
"""Promień koła. Getter.
Wartość tylko do odczytu, nie ma metody setter.
"""
return self._radius1
def area(self) -> float:
"""Metoda obliczająca pole koła."""
return pi * (self.radius ** 2)
def perimeter(self) -> float:
"""Metoda obliczająca obwód koła."""
return 2 * pi * self.radius
if __name__ == "__main__":
# figure = Figure() - Błąd, nie możemy utworzyć obiektu klasy z abstrakcyjnymi metodami
quad = Quad(1, 2, 3, 4, 5, 6, 30)
rectangle = Rectangle(1, 2)
square = Square(1)
ellipse = Ellipse(1, 2)
circle = Circle(5)
quad.__d1 = 10 # Działa, ale nie jest poprawne, __d1 jest prywatne
print(f"quad.__d1 = {quad.__d1}") # Działa, ale nie jest poprawne, __d1 jest prywatne
quad._sides[0] = 10 # Działa, ale nie jest poprawne, _sides jest protected
print(f"quad._sides[0] = {quad._sides[0]}") # Działa, ale nie jest poprawne, _sides jest protected
rectangle.width = 10 # Działa
print(f"rectangle.width = {rectangle.width}") # Działa
# circle.radius = 10 # Nie działa, nie ma settera
print(f"circle.radius = {circle.radius}") # Działa
circle_one = Circle.one() # Wywołanie metody klasowej
print(f"kwadrat jest figurą: {isinstance(square, Figure)}")
print(f"kwadrat jest czworokątem: {isinstance(square, Quad)}")
print(f"kwadrat jest prostokątem: {isinstance(square, Rectangle)}")
print(f"kwadrat jest kwadratem: {isinstance(square, Square)}")
print(f"kwadrat jest elipsą: {isinstance(square, Ellipse)}")
print(f"kwadrat jest kołem: {isinstance(square, Circle)}")
print(f"kwadrat jest typu: {type(square)}")
selection = randint(1, 5)
figure = None
if selection == 1:
figure = Quad(1, 2, 3, 4, 6, 7, 30)
elif selection == 2:
figure = Rectangle(1, 2)
elif selection == 3:
figure = Square(1)
elif selection == 4:
figure = Ellipse(1, 2)
elif selection == 5:
figure = Circle(1)
print(f"Wylosowana figura jest typu: {type(figure)}")
if isinstance(figure, Rectangle):
# Sprawdzamy, czy figure jest prostokątem, a jeśli tak, to wypisujemy jego wysokość.
# Przy takim podejściu środowisko będzie podpowiadać metody dostępne w klasie Rectangle i traktować figure jako Rectangle.
print(f"Wysokość: {figure.height}")
|