📦 Репозиторий занятия 66

"""ВВОДНЫЕ:
Предположим, стоит задача обсчитывать периметр и площадь
для ОЧЕНЬ большого числа геометрических фигур разных размеров.
"""

""" ======================= AREA ============================== """
from collections import namedtuple


def rectangle_area(side1, side2):
    """Calculate the area of a rectangle"""
    return side1 * side2


def square_area(side1):
    """Calculate the area of a square"""
    return side1 ** 2


def right_triangle_area(side1, side2):
    """Calculate the area of a right triangle"""
    return (side1 * side2) / 2


""" ======================= PERIMETR ============================ """


def rectangle_perimeter(side1, side2):
    """Calculate the perimeter of a rectangle"""
    return 2 * (side1 + side2)


def square_perimeter(side1):
    """Calculate the perimeter of a rectangle"""
    return 4 * side1


def right_triangle_perimeter(side1, side2):
    """Calculate the perimeter of a right triangle"""
    hypotenuse = (side1 ** 2 + side2 ** 2) ** 0.5
    return side1 + side2 + hypotenuse


""" ======================= FIGURES ============================ 
Как систематизировать все эти данные, чтобы было удобно
хранить информацию обо всех фигурах?
"""

# ===============  variant 1 =============

Shape = namedtuple('Shape',
                   ["side1", "side2", "area", "perimeter"])

rectangle_3_4 = Shape(3, 4, rectangle_area, rectangle_perimeter)
print(rectangle_3_4.area(3, 4))
print(rectangle_3_4.perimeter(3, 4))


# ===============  variant 2 =============

rectangle_2 = {
    "side1": 3,
    "side2": 4,
    "area": rectangle_area,
    "perimeter": rectangle_perimeter,
}
print(rectangle_2["area"](3, 4))
print(rectangle_2["perimeter"](3, 4))

"""
Поэтому, крайне удобно иметь объект, который:
- не только содержит все присущие ему значения и функции
- но и может "подставить" свои значения в свои функции без лишних "телодвижений".

И этот объект - экземпляр класса (class instance).
"""


class Square:
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

    def perimeter(self):
        return self.side * 4


square = Square(3)
print(square.side)        # 3
print(square.area())      # 9
print(square.perimeter()) # 12

"""
Объект square - квадрат со стороной 3 условных единицы.
Его площадь и его периметр рассчитываются автоматически, поскольку
"подставлять" значения в них НЕ НАДО!
"""

class Shape:
    def area(self):
        pass

    def perimeter(self):
        pass


class Rectangle(Shape):
    """Initialize a Rectangle object with the given side lengths."""
    def __init__(self, side1, side2):
        self.side1 = side1
        self.side2 = side2

    def area(self):
        return self.side1 * self.side2

    def perimeter(self):
        return 2 * (self.side1 + self.side2)


class Square(Shape):
    """Initialize a Square object with the given side length."""
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

    def perimeter(self):
        return 4 * self.side


class RightTriangle(Shape):
    """Initialize a RightTriangle object with the given leg lengths."""
    def __init__(self, side1, side2, hypotenuse=None):
        self.side1 = side1
        self.side2 = side2
        self.hypotenuse = hypotenuse if hypotenuse is not None else (side1 ** 2 + side2 ** 2) ** 0.5

    def area(self):
        return (self.side1 * self.side2) / 2

    def perimeter(self):
        return self.side1 + self.side2 + self.hypotenuse


r1 = Rectangle(3, 4)
print(r1.__dict__)   # {'side1': 3, 'side2': 4}
print(r1.__dir__())  # ['side1', 'side2', '__doc__', 'area', 'perimeter']
print(r1.__doc__)


""" ====================== ПОЛИМОРФИЗМ (УНИФИКАЦИЯ) ======================= """


def print_shape_info(shape: Shape):
    print(f"===== {shape.__class__.__name__} =====")
    print(f"Area: {shape.area()}")
    print(f"Perimeter: {shape.perimeter()}")


shapes = [
    Rectangle(3, 4),
    Square(5),
    RightTriangle(3, 4, 5),
]

for shape in shapes:
    print_shape_info(shape)

class Shape:
    def __init__(self, side1, side2):
        self.side1 = side1
        self.side2 = side2

    def area(self):
        return self.side1 * self.side2

    def perimeter(self):
        return 2 * (self.side1 + self.side2)


class Rectangle(Shape):
    """Initialize a Rectangle object with the given side lengths."""


class Square(Shape):
    """Initialize a Square object with the given side length."""

    def __init__(self, side):
        super().__init__(side, side)


class RightTriangle(Shape):
    """Initialize a RightTriangle object with the given leg lengths."""

    def area(self):
        return super().area() / 2

    def perimeter(self):
        hypotenuse = (self.side1 ** 2 + self.side2 ** 2) ** 0.5
        return self.side1 + self.side2 + hypotenuse


rectangle = Rectangle(3, 4)
print(rectangle.__dict__)   # {'side1': 3, 'side2': 4}
print(rectangle.__dir__())  # ['side1', 'side2', '__doc__', 'area', 'perimeter']
print(rectangle.__doc__)    # Initialize a Rectangle object with the given side lengths.

square = Square(3)
print(square.__dict__)   # {'side1': 3, 'side2': 3}
print(square.area())
print(square.perimeter())

rt = RightTriangle(3,4)
print(rt.area())

### 1. Абстракция

**Абстракция** заключается в выделении общих характеристик объектов  
и создании на их основе обобщённых представлений. 

В нашем примере класс `Shape` представляет абстрактное понятие формы,  
предоставляя общие методы `area` и `perimeter`, которые должны быть реализованы в подклассах.

```
class Shape:
    def area(self):
        pass

    def perimeter(self):
        pass
```

### 2. Инкапсуляция

**Инкапсуляция** подразумевает сокрытие внутренней реализации объектов  
и предоставление доступа к данным только через определённые методы.   

В нашем примере атрибуты `side1` и `side2` класса `Rectangle` являются частными,  
и доступ к ним осуществляется через методы `area` и `perimeter`.

```
class Rectangle(Shape):
    def __init__(self, side1, side2):
        self.side1 = side1
        self.side2 = side2

    def area(self):
        return self.side1 * self.side2

    def perimeter(self):
        return 2 * (self.side1 + self.side2)
```

### 3. Полиморфизм (унификация)

**Полиморфизм** позволяет объектам разных классов обрабатывать вызовы одинаково,  
используя одинаковый интерфейс.  

В нашем примере методы `area` и `perimeter` могут быть вызваны как у объекта класса `Rectangle`,  
так и у любого другого подкласса `Shape`, реализующего эти методы.  

Таким образом, мы можем использовать объекты разных форм через единый интерфейс.

```
def print_shape_info(shape: Shape):
    print(f"Area: {shape.area()}")
    print(f"Perimeter: {shape.perimeter()}")

rectangle = Rectangle(3, 4)
print_shape_info(rectangle)
```

### 4. Наследование

**Наследование** позволяет создавать новые классы на основе существующих,  
…

class Car:
    quantity = 0

    def __init__(self, brand):
        self.brand = brand
        Car.quantity += 1


wv = Car('WV')
print(wv.quantity)  # 1
toyota = Car('Toyota')
print(toyota.quantity)  # 2
print(wv.quantity)      # 2

# Попробуем изменить атрибут класса из экземпляра класса
toyota.quantity = 10
print(toyota.quantity)  # 10

# Попробуем значения атрибутов экземпляров класса
print(wv.__dict__)       # {'brand': 'WV'}
print(toyota.__dict__)   # {'brand': 'Toyota', 'quantity': 10}

# Вывод: мы НЕ изменили атрибут класса quantity
# Мы просто добавили новый атрибут к экземпляру класса toyota
# Который теперь закрывает (экранирует) доступ к атрибуту класса quantity
# из экземпляра класса.
# Но мы можем обойти экранирование, обратившись к классу с помощью метода .__class__
print(toyota.__class__.quantity)  # 2