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

## 4 столпа (кита, основы) ООП

### 1. Инкапсуляция (Encapsulation)

**Смысл:** 
1. Скрытие внутренней реализации объекта и 
2. предоставление доступа к данным через методы.

```python
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # приватный атрибут

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500
# print(account.__balance)    # Ошибка! Доступ запрещён
```

> Здесь баланс скрыт, и доступ к нему идёт только через методы класса.

---

### 2. Абстракция (Abstraction)

**Смысл:** 
* Отделение сути объекта от деталей реализации. 
* Мы работаем с объектом через его интерфейс, не заботясь о его внутренней "кухне".

```python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2
    

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

…

### 1. Что такое `super()`

`super()` — это встроенная функция, которая позволяет 
* обратиться к родительскому классу из класса наследника
* и вызвать его (родителя) методы.

Функция `super()` полезна, когда:

* Нужно расширить поведение родительского метода, а не полностью его заменять.
* Есть **множественное наследование**, и порядок вызова методов (`MRO`) важен.

---

### 2. Пример "жёсткого" базового наследования (неправильно!)

```python
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} издает звук")

class Dog(Animal):
    def __init__(self, name, breed):
        Animal.__init__(self, name)  # вызов конструктора родителя
        self.breed = breed

    def speak(self):
        Animal.speak(self)  # вызов метода speak родителя
        print(f"{self.name} говорит: Гав!")
```

---

### 3. Пример "гибкого" базового наследования (правильный)

```python
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} издает звук")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # вызов конструктора родителя
        self.breed = breed

    def speak(self):
        super().speak()  # вызов метода speak родителя
        print(f"{self.name} говорит: Гав!")

dog = Dog("Шарик", "Дворняжка")
dog.speak()

# Шарик издает звук
# Шарик говорит: Гав!
```
…

### 1. `isinstance(obj, classinfo)`

**Назначение:** 
* Проверяет, является ли объект `obj` 
  * экземпляром класса `classinfo` 
  * или его подклассов.

**Синтаксис:**

```python
isinstance(obj, classinfo)
```

* `obj` — объект, который проверяем.
* `classinfo` — класс или тюпл классов.

**Примеры:**

```python
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(isinstance(dog, Dog))      # True — это экземпляр Dog
print(isinstance(dog, Animal))   # True — Dog наследует Animal
print(isinstance(dog, int))      # False — это не число

# Можно проверять несколько классов сразу
print(isinstance(dog, (int, Animal, str)))  # True, так как dog — Animal
```

**Особенность**: проверка работает **по всей иерархии наследования**.

---

### 2. `issubclass(class, classinfo)`

**Назначение:** Проверяет, является ли класс `class` **подклассом** `classinfo`.

**Синтаксис:**

```python
issubclass(class, classinfo)
```

* `class` — проверяемый класс.
* `classinfo` — класс или тюпл классов.

**Примеры:**

```python
class Animal:
    pass

class Dog(Animal):
    pass
…

### Функция `hasattr`

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

---

#### Синтаксис

```python
hasattr(object, name)
```

* `object` — объект, у которого проверяется наличие атрибута.
* `name` — имя атрибута в виде строки.

**Возвращает:**

* `True`, если атрибут существует.
* `False`, если атрибута нет.

---

#### Пример

```python
class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, my name is {self.name}")

p = Person("Alice")

# Проверяем существование атрибутов
print(hasattr(p, "name"))   # True
print(hasattr(p, "age"))    # False
print(hasattr(p, "greet"))  # True
```

---

#### Особенности

1. Работает не только с атрибутами, но и с методами, т.к. методы в Python тоже являются атрибутами объекта (в широком смысле).
2. Полезна при наследовании, чтобы избежать ошибки `AttributeError` (при вызове несуществующего атрибута)
3. Очень полезна при **динамической работе с объектами**, когда заранее неизвестны все атрибуты.

### Почему Student не считает свои объекты?

```python
class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        self.__class__.population += 1

    @classmethod
    def get_population(cls):
        return cls.population


class Student(Person):
    pass


p1 = Person("John")
p2 = Person("Mary") 
s1 = Student("Peter")
print(Student.population)   # 3
```

Мы наследовали в классе Student все атрибуты и методы класса Person.

Тем не менее у Student `population` работает "неправильно":
* почему-то сосчитал и свои объекты, и объекта класса-родителя.

1. Неужели атрибуты класса не передаются по наследству (в отличие от методов)?
   * (Или же здесь какая-то иная причина?)

2. Как изменить код, чтобы атрибут класса Student `population` заработал-таки правильно?

### Почему Student не считает свои объекты?

```python
class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        self.__class__.population += 1

    @classmethod
    def get_population(cls):
        return cls.population


class Student(Person):
    pass


p1 = Person("John")
print(id(Student.population) == id(Person.population))
print("Student: ", Student.population, "Person", Person.population)

p2 = Person("Mary")
print(id(Student.population) == id(Person.population))
print("Student: ", Student.population, "Person", Person.population)

s1 = Student("Peter")
print(id(Student.population) == id(Person.population))
print("Student: ", Student.population, "Person", Person.population)


# True
# Student:  1 Person 1
# True
# Student:  2 Person 2
# False
# Student:  3 Person 2
```

## Пояснения

Атрибуты классов не копируются при наследовании.  
Они ищутся через MRO (цепочку наследования).  

Пока у дочернего класса `Student` нет собственного атрибута `population`,   
обращение к `Student.population` находит атрибут в родительском классе `Person`.

Но как только создаётся первый экземпляр дочернего класса, операция присваивания 
```python
self.__class__.population += 1
``` 
тут же создаёт новый атрибут класса `population` именно в дочернем классе `Student`.