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

### 1. Создание атрибута класса `general` и атрибута экземпляра класса

* **Атрибут класса** создаётся ВНЕ `__init__()`
* **Атрибут экземпляра класса** создаётся ВНУТРИ `__init__()`

```python
class A:
    general = 100   # атрибут класса

    def __init__(self, x):
        self.x = x   # атрибут экземпляра


a1 = A(5)
a2 = A(10)
```

### 2. Где "виден" каждый из атрибутов?

* **Атрибут класса** виден и в класса, и в каждом экземпляре класса
* **Атрибут экземпляра класса** виден ИСКЛЮЧИТЕЛЬНО внутри ТОЛЬКО этого экземпляра

```python
# class attribute
print(a1.general)  # 100
print(a2.general)  # 100
print(A.general)   # 100

# instance attribute
print(a1.x)  # 5
print(a2.x)  # 10
```

---

### 3. Как изменить атрибут класса `general`?

* 3.1. Через имя класса:

```python
A.general = 500


print(a1.general)  # 500
print(a2.general)  # 500
```

* 3.2. Через экземпляр класса с помощью метода `__class__`:

```python
a1.__class__.general = 777

print(a1.general)  # 777
print(a2.general)  # 777
```

### 4. Что будет, если написать `a1.general = ...`

Вот важная ловушка:
* это НЕ меняет атрибут класса.
…

## Что такое `__dict__`?

`__dict__` — это магический атрибут, возвращающий словарь, 
в котором объект хранит свои атрибуты.

Пример:

```python
from pprint import pprint

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

p = Person("Alice", 30)

# ------ Для экземпляра класса: -------
print(p.__dict__)

# {'name': 'Alice', 'age': 30}


# ------  Для самого класса: -------
pprint(Person.__dict__)

# mappingproxy({'__dict__': <attribute '__dict__' of 'Person' objects>,
#               '__doc__': None,
#               '__init__': <function Person.__init__ at 0x7fe1cd16a2a0>,
#               '__module__': '__main__',
#               '__weakref__': <attribute '__weakref__' of 'Person' objects>})
```

---

## Для чего используется `__dict__`?

### 1. Инспекция атрибутов

Удобно для отладки:

```python
print(vars(p))
```

`vars(p)` = `p.__dict__`.

---

### 2. Динамическое изменение атрибутов

```python
p.__dict__['age'] = 31
print(p.age)  # 31
```

## Что такое `@classmethod`?

`@classmethod` — это декоратор, который превращает метод класса в «метод класса», а не объекта.

Главное отличие от обычного метода:
* **первым аргументом получает сам класс** (`cls`), а не объект (`self`).

То есть метод может работать с атрибутами и состоянием **класса**, а не конкретного экземпляра.

---

## Пример: `population` — счётчик созданных экземпляров класса `Person`.

```python
class Person:
    population = 0

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

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

    
print(Person.get_population())  # 0
p = Person('Anna')
print(Person.get_population())  # 1
```

---

## Когда необходимо использовать `@classmethod`?

### 1. Когда нужно создать альтернативный конструктор

Наиболее чАстая причина использования.

```python
from datetime import datetime, date

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

    @classmethod
    def from_birthday(cls, name: str, birth_date: datetime):
        """Создание объекта Person по дате рождения (datetime)"""
        today = date.today()
        birthday = birth_date.date()   # Берём только дату

        age = today.year - birthday.year
        if (today.month, today.day) < (birthday.month, birthday.day):
            age -= 1

        return cls(name, age)

    def __repr__(self):
…

### Что такое `@staticmethod`?

`@staticmethod` — это декоратор в Python, который превращает метод класса  
в обычную функцию, помещённую внутрь класса.   

Такой метод:

* не получает `self` (экземпляр)
* не получает `cls` (сам класс)
* не может изменять состояние объекта или класса
* используется для вспомогательных функций, логически связанных с классом, но не зависящих от него

---

#### Пример

```python
from datetime import datetime, timedelta

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

    @staticmethod
    def get_10_days_before_now():
        """Получить дату на 10 дней меньше текущей"""
        return datetime.now().date() - timedelta(days=10)


p = Person("Ivan", 25)

# Методы можно вызвать и с помощью класса, и с помощью экземпляра
print(Person.get_10_days_before_now())
print(p.get_10_days_before_now())
```


---

## Зачем нужен `@staticmethod`?

Используется, когда:

* метод логически относится к классу, но не работает с его атрибутами
* нужно сгруппировать функции внутри класса для удобства

---

## Отличия от других типов методов

| Тип метода      | Получает | Доступ к        | Когда использовать   |
| --------------- | -------- | --------------- | -------------------- |
| `@staticmethod` | —        | нет             | утилитные функции    |
| `@classmethod`  | `cls`    | атрибуты класса | фабрики, настройки   |
| обычный метод   | `self`   | объект          | работа с экземпляром |

Методы `__str__` и `__repr__` — это специальные (магические) методы в Python,  
которые определяют, как объект представляется в виде строки.

### `__repr__(self)`

**Назначение:** выдать однозначное, точное строковое представление объекта, предназначенное для **разработчиков**.

* Должен возвращать строку, которая по возможности может быть использована для воссоздания объекта (идеал, но не обязательно).
* Используется функцией `repr(obj)` и когда объект выводится в интерактивной консоли.
* Если `__str__` отсутствует, `print(obj)` тоже будет использовать `__repr__`.

**Пример:**

```python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"


x = Point(1, 2)
print(x)

# Point(x=1, y=2)
```

### `__str__(self)`

**Назначение:** выдать красивое, удобочитаемое строковое представление для **пользователя**.

* Используется функцией `str(obj)` и командой `print(obj)`.
* Можно сделать более дружелюбным и неформальным, чем `__repr__`.

**Пример:**

```python
class Point:
    def __str__(self):
        return f"({self.x}, {this.y})"
```

### Взаимодействие

Если у класса **нет** `__str__`, Python использует `__repr__`.
Если у класса есть оба метода:

* `print(obj)` → `__str__`
* `obj` в интерпретаторе → `__repr__`

### Пример класса с обоими методами

```python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

…

## Два способа вызова метода

У нас есть класс `A`:
* с атрибутом `name`
* и методом `method()`

```python
class A:
    def __init__(self, name):
        self.name = name
        
    def method(self):
        print("Вызван method() у объекта", self)
```

---

### 1. Вызов через объект (стандартный)

```python
a = A()
a.method()
```

**Что происходит на самом деле?**

Когда мы вызываем `a.method()`, интерпретатор автоматически:

1. ищет метод `method` в классе `A`,
2. обнаруживает, что это **метод экземпляра класса A**, ожидающий первый параметр `self`,
3. **подставляет объект `a` в качестве первого аргумента**.

То есть:

```
a.method()  →  A.method(a)
```

Таким образом, `a.method()` — это просто синтаксический сахар.

В реальности выполняется:

### 2. Вызов метода через класс

```python
A.method(a)
```

Здесь мы вручную вызываете функцию `method`, описанную внутри класса `A`,
и в качестве аргумента явно передаём `self`, в качестве экземпляра класса.

То есть здесь нет автоматической подстановки — всё делается вручную.

Таким образом, об способа `a.method()` и `A.method(a)` — одно и то же действие.  
Разница — только в форме записи.

---

### Резюме

…