feat: add encapsulation & inheritance pages

Author: qqracha

docs/python/encapsulation.md

@@ -1 +1,65 @@
-coming soon...
+## Определение
+!!! info ""
+    **Инкапсуляция** (Encapsulation) — это принцип ООП, заключающийся в упаковке данных и методов для работы с ними внутри единого объекта с ограничением прямого доступа к его состоянию. Принцип **Чёрного ящика**.
+
+## Для чего?
+<span class="badge">Инкапсуляция</span> создаёт границы вокруг объекта. Она скрывает внутреннее устройство и позволяет объекту самому контролировать допустимые изменения своего состояния.
+
+Во внешнем коде важно **что** делает объект, а не **как именно** он это делает.
+
+## Принцип чёрного ящика
+
+Инкапсуляцию превращает объект в <span class="badge">Black Box</span> (чёрный ящик), защищая его внутренности:
+
+- Скрытие реализации — извне доступен только публичный интерфейс объекта.
+- Контроль состояния — объект сам валидирует данные, прежде чем изменить свои атрибуты.
+- Независимость кода — внутреннюю логику можно переписать, не меняя код, который использует этот класс.
+
+Извне взаимодейстие с объектом происходит через инструменты управления, не видя его внутреннего устройства.
+
+## Инкапсуляция в Python
+
+В отличие от языков с жёстким доступом, Python использует систему соглашений и декораторы:
+
+- <span class="badge">_protected</span> — соглашение «только для внутреннего пользования», доступ сохраняется.
+- <span class="badge">__private</span> — механизм искажения имен (Name Mangling) для защиты от случайной перезаписи.
+- <span class="badge">@property</span> — способ превратить методы в атрибуты, добавляя логику доступа без изменения интерфейса.
+
+| Формат        | Название                | Суть                     | Доступ снаружи
+| ------------- | ----------------------- | ------------------------ | -------------------------
+| `name`        | Публичный               | Обычный атрибут          | Разрешён
+| `_protected`  | Защищённый (Protected)  | Соглашение "не трогать"  | Можно, но не рекомендуется
+| `__private`   | Приватный (Private)     | Name Mangling            | Только через <span class="badge">_Class__name</span>
+
+Через свойства `@property` можно выдавать «красивый» атрибут, пряча внутри проверки и логику.
+
+## Пример
+```python
+    class Robot:
+        def __init__(self, model: str):
+            self.model = model            # Публичный формат
+            self._status = "active"       # Защищённый формат
+            self.__core_id = "RX-99"      # Приватный формат
+
+    bot = Robot("Wall-E")
+
+    print(bot.model)           # Работает без ограничений
+
+    print(bot._status)         # Работает, но висит соглашение "не трогать"
+
+    print(bot.__core_id)       # Классический принт выдаст ошибку AttributeError
+    print(bot._Robot__core_id) # Доступ через искажённое имя, приватный формат
+
+```
+
+## Ключевые мысли
+- Инкапсуляция снижает зависимость между модулями, разделяя внешние методы управления и скрытую внутреннюю логику.
+- Объект выступает гарантом собственной стабильности, блокируя попытки внешнего кода установить некорректные или конфликтующие данные.
+- Такой подход позволяет полностью переписывать внутреннее устройство класса без риска сломать программы, которые уже его используют.
+
+## Сопутствующие темы
+- [Object-Oriented Programming](./OOP.md){:.link-accent}
+- [Inheritance](./inheritance.md){:.link-accent}  
+- [Polymorphism](./polymorphism.md){:.link-accent}  
+- [Abstraction](./abstraction.md){:.link-accent}
+  

docs/python/inheritance.md

@@ -1 +1,72 @@
-coming soon...
+Определение
+
+!!! info ""
+    **Наследование** (Inheritance) — это принцип ООП, позволяющий создать новый класс на основе уже существующего. Дочерний класс заимствует атрибуты и методы родительского, дополняя или переопределяя их.
+
+## Для чего?
+
+<span class="badge">Наследование</span> систематизирует код, позволяя выстраивать иерархии от общих понятий к более узким. Оно избавляет от ручного копирования функций, формируя базовую логику в одном месте для всех "потомков".
+
+Этот механизм закрепляет принцип <span class="badge">is-a</span> («является»), при котором любой подкласс по умолчанию считается полноценным представителем своего родительского типа.
+
+## Механизмы наследования
+
+Наследование делает классы гибкими и расширяемыми:
+
+- <span class="badge">Переиспользование кода</span> — базовый функционал пишется один раз в родительском классе.
+- <span class="badge">Расширение (Extending)</span> — дочерний класс добавляет свои уникальные методы и данные.
+- <span class="badge">Переопределение (Overriding)</span> — дочерний класс может изменить поведение метода родителя.
+
+С помощью функции super() дочерний класс может вызвать оригинальную версию метода из родительского класса.
+
+​В Python поддерживается как одиночное, так и множественное наследование:
+
+- <span class="badge">Single Inheritance</span> — классическое наследование от одного предка.
+- <span class="badge">Multiple Inheritance</span> — возможность наследоваться от нескольких классов сразу.
+- <span class="badge">MRO</span> — Method Resolution Order, порядок, в котором Python ищет методы в иерархии предков.
+
+| Понятие  | Суть                                              | Инструмент              |
+| -------- | ------------------------------------------------- | ------------------------|
+| Parent   | Базовый класс (суперкласс), от которого наследуют | BaseClass               |
+| Child    | Производный класс (подкласс), который наследует   | class Child(BaseClass): |
+| super()  | Прокси-объект для доступа к методам родителя	   | super().method()        |
+
+Посмотреть порядок поиска методов в сложном дереве наследования можно через атрибут ClassName.__mro__.
+## Пример
+
+``` python
+    class Device:
+        def __init__(self, brand: str):
+            self.brand = brand
+        
+        def turn_on(self):
+            print(f"{self.brand} включён")
+
+    class Smartphone(Device):  # Наследование от Device
+        def __init__(self, brand: str, model: str):
+            # Вызов конструктора родителя через super()
+            super().__init__(brand)
+            self.model = model
+            
+        def turn_on(self):
+            # Переопределение метода с сохранением базовой логики
+            super().turn_on()
+            print(f"Загрузка системы {self.model}...")
+
+    phone = Smartphone("Apple", "iPhone 15")
+    phone.turn_on()
+    # Вывод:
+    # Apple включён
+    # Загрузка системы iPhone 15...
+```
+
+## Ключевые мысли
+- Наследование позволяет создавать специализированные классы без повторного написания базовой логики.
+- Использование super() критически важно для корректной инициализации всех уровней иерархии, особенно при множественном наследовании.
+- Избыточное наследование может сделать код запутанным; иногда лучше использовать композицию (вложение объектов).
+
+## Теги
+- [Object-Oriented Programming](./OOP.md){:.link-accent}
+- [Encapsulation](./encapsulation.md){:.link-accent}  
+- [Polymorphism](./polymorphism.md){:.link-accent}  
+- [Abstraction](./abstraction.md){:.link-accent}

mkdocs.yml

@@ -28,6 +28,7 @@ plugins:
   - search
 
 markdown_extensions:
+  - tables
   - admonition
   - attr_list
   - pymdownx.highlight

notes/encapsulation.py

@@ -1,32 +1,50 @@
-class Router:
-    # Инициализируем параметры объекта: name и specs.
-    # self — ссылка на конкретный объект этого класса.
-    def __init__(self, name, specs):
-        self.__name = name        # Приватные атрибуты
-        self.__specs = specs
+# class Router:
+#     # Инициализируем параметры объекта: name и specs.
+#     # self — ссылка на конкретный объект этого класса.
+#     def __init__(self, name, specs):
+#         self.__name = name        # Приватные атрибуты
+#         self.__specs = specs
 
-    # Приватные методы
-    def __model(self):
-        return f"Router model: {self.__name}"
+#     # Приватные методы
+#     def __model(self):
+#         return f"Router model: {self.__name}"
 
-    def __speed(self):
-        return f"Router speed: {self.__specs}"
+#     def __speed(self):
+#         return f"Router speed: {self.__specs}"
 
-    # Публичный метод для вывода полной информации
-    def hard_specs(self):
-        return f"{self.__model()}\n{self.__speed()}"
+#     # Публичный метод для вывода полной информации
+#     def hard_specs(self):
+#         return f"{self.__model()}\n{self.__speed()}"
 
-    # __ str__ - магический метод, который показывает, как объект класса будет представлен в виде строки 
-    # (например, как ниже после инициализации класса и дальнейшего принта) 
-    def __str__(self):
-        return f"Router: {self.__name}\nSpecs: {self.__specs}"
+#     # __ str__ - магический метод, который показывает, как объект класса будет представлен в виде строки 
+#     # (например, как ниже после инициализации класса и дальнейшего принта) 
+#     def __str__(self):
+#         return f"Router: {self.__name}\nSpecs: {self.__specs}"
 
 
-r = Router("TP-Link", "1 tb/s")
+# r = Router("TP-Link", "1 tb/s")
 
-print(f"__str__ output:\n{r}\n----------------------------") # без __str__ будет: <__main__.router object at 0x74d4076c6780>
+# print(f"__str__ output:\n{r}\n----------------------------") # без __str__ будет: <__main__.router object at 0x74d4076c6780>
 
-# Прямой вызов приватного метода вызовет ошибку 
-# r.__model()  # AttributeError
+# # Прямой вызов приватного метода вызовет ошибку 
+# # r.__model()  # AttributeError
 
-print(f"Encapsulation (via public method):\n{r.hard_specs()}\n")
+# print(f"Encapsulation (via public method):\n{r.hard_specs()}\n")
+
+class Robot:
+    def __init__(self, model: str):
+        self.model = model            # Публичный: модель робота
+        self._status = "active"       # Защищённый: текущее состояние
+        self.__core_id = "RX-99"      # Приватный: серийный номер ядра
+
+bot = Robot("Wall-E")
+
+# 1. Публичный доступ
+print(bot.model)          # Wall-E (Работает без ограничений)
+
+# 2. Защищённый (по соглашению)
+print(bot._status)        # active (Работает, но IDE может выдать предупреждение)
+
+# 3. Приватный (Name Mangling)
+# print(bot.__core_id)    # Ошибка! AttributeError
+print(bot._Robot__core_id) # RX-99 (Доступ через искажённое имя)