Конструктор класса init

class Dog:
    def __init__(self, name, age):
        self.name = name    # У каждой собаки свое имя
        self.age = age      # И свой возраст

# Создаем собаку с именем и возрастом
my_dog = Dog("Napoleon", 3)

Понятие self и его назначение

class Dog:
    def __init__(self, name, age):
        self.name = name   # self.name = имя ЭТОЙ конкретной собаки
        self.age = age
    
    def introduce(self):
        return f"Меня зовут {self.name}, мне {self.age} лет"

# Без self компьютер не поймет, чье имя и возраст показывать

Создание объектов (экземпляров класса)

# Класс — чертеж
class Car:
    def __init__(self, color, brand):
        self.color = color
        self.brand = brand

# Объекты — реальные машины
car1 = Car("red", "Toyota")    # Первая машина
car2 = Car("blue", "BMW")      # Вторая машина
car3 = Car("green", "Audi")    # Третья машина

Атрибуты экземпляра и атрибуты класса

class Dog:
    # Атрибут класса (общий для всех)
    species = "Canis familiaris"
    
    def __init__(self, name):
        # Атрибут экземпляра (уникальный для каждой собаки)
        self.name = name

dog1 = Dog("Бобик")
dog2 = Dog("Шарик")

print(dog1.species)  # Canis familiaris (общий)
print(dog2.species)  # Canis familiaris (общий)
print(dog1.name)     # Бобик (уникальный)
print(dog2.name)     # Шарик (уникальный)

Доступ к атрибутам через точку

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    
    def upgrade_grade(self):
        self.grade += 1

# Создаем студента
student = Student("Анна", 5)

# Чтение атрибутов
print(student.name)   # Анна
print(student.grade)  # 5

# Изменение атрибутов  
student.grade = 6
print(student.grade)  # 6

# Вызов методов
student.upgrade_grade()
print(student.grade)  # 7

Методы экземпляра

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
    
    # Метод экземпляра - работает с конкретным объектом
    def deposit(self, amount):
        self.balance += amount
        return f"Баланс пополнен на {amount}"
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            return f"Снято {amount}"
        return "Недостаточно средств"

# Использование
account = BankAccount(1000)
print(account.deposit(500))  # Баланс пополнен на 500

Методы класса @(@)classmethod

class Dog:
    species = "Canis familiaris"
    total_dogs = 0  # Счетчик всех созданных собак
    
    def __init__(self, name):
        self.name = name
        Dog.total_dogs += 1
    
    @classmethod
    def get_total_dogs(cls):  # cls - ссылка на класс, не на объект!
        return cls.total_dogs
    
    @classmethod
    def change_species(cls, new_species):
        cls.species = new_species

# Использование
dog1 = Dog("Бобик")
dog2 = Dog("Шарик")

print(Dog.get_total_dogs())  # 2 (всего создано собак)
Dog.change_species("Домашняя собака")

Статические методы @(@)staticmethod

class MathHelper:
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def is_even(number):
        return number % 2 == 0

# Использование - не нужно создавать объект!
print(MathHelper.add(5, 3))      # 8
print(MathHelper.is_even(4))     # True

Различия между типами методов

Практическое применение каждого типа

class Car:
    def __init__(self, fuel):
        self.fuel = fuel
    
    def drive(self, distance):
        self.fuel -= distance * 0.1  # Уменьшаем топливо

class User:
    users = []
    
    def __init__(self, name):
        self.name = name
        User.users.append(self)
    
    @classmethod
    def get_user_count(cls):
        return len(cls.users)  # Статистика по всем пользователям

class DateValidator:
    @staticmethod
    def is_valid_date(day, month, year):
        # Проверка без создания объекта
        return 1 <= day <= 31 and 1 <= month <= 12

Понятие инкапсуляции

Публичные атрибуты и методы

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner       # Публичный атрибут
        self.balance = balance   # Публичный атрибут (опасно!)
    
    def show_balance(self):      # Публичный метод
        return f"Баланс: {self.balance}"

account = BankAccount("Иван", 1000)
print(account.balance)  # 1000 - можно прочитать
account.balance = -500  # 😱 Можно изменить на отрицательное!

Защищенные атрибуты (_одиночное подчеркивание)

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self._balance = balance  # Защищенный атрибут
    
    def get_balance(self):
        return self._balance
    
    def _validate_amount(self, amount):  # Защищенный метод
        return amount > 0

account = BankAccount("Иван", 1000)
print(account._balance)  # ❌ Не рекомендуется, но возможно

Приватные атрибуты (__двойное подчеркивание)

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # Приватный атрибут
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    
    def get_balance(self):
        return self.__balance

account = BankAccount("Иван", 1000)
print(account.__balance)  # ❌ Ошибка! AttributeError
print(account.get_balance())  # ✅ 1000 - через метод

Свойства @(@)property

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

temp = Temperature(25)
print(temp.celsius)     # 25 - как атрибут, но это метод!
print(temp.fahrenheit)  # 77.0

Сеттеры и геттеры

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance
    
    @property
    def balance(self):
        return self.__balance
    
    @balance.setter
    def balance(self, value):
        if value >= 0:
            self.__balance = value
        else:
            print("Баланс не может быть отрицательным!")

account = BankAccount(1000)
account.balance = 1500  # ✅ Работает
account.balance = -500  # ❌ "Баланс не может быть отрицательным!"

Базовое наследование классов

class Animal:  # Родительский класс
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        return f"{self.name} ест"
    
    def sleep(self):
        return f"{self.name} спит"

class Dog(Animal):  # Дочерний класс
    def bark(self):
        return f"{self.name} гавкает"

class Cat(Animal):  # Дочерний класс  
    def meow(self):
        return f"{self.name} мяукает"

# Использование
dog = Dog("Бобик")
print(dog.eat())   # ✅ Унаследовано от Animal
print(dog.bark())  # ✅ Собственный метод

cat = Cat("Мурка")
print(cat.sleep()) # ✅ Унаследовано от Animal
print(cat.meow())  # ✅ Собственный метод

Переопределение методов

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        return "Какое-то животное издает звук"

class Dog(Animal):
    def make_sound(self):  # Переопределяем метод
        return "Гав!"

class Cat(Animal):
    def make_sound(self):  # Переопределяем метод
        return "Мяу!"

animals = [Dog("Собака"), Cat("Кошка")]
for animal in animals:
    print(animal.make_sound())
# Вывод:
# Гав!
# Мяу!

Ключевое слово super()

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

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

dog = Dog("Бобик", 3, "Такса")
print(dog.name)   # Бобик (от Animal)
print(dog.age)    # 3 (от Animal) 
print(dog.breed)  # Такса (от Dog)

Множественное наследование

class Flyable:
    def fly(self):
        return "Лечу!"

class Swimmable:
    def swim(self):
        return "Плыву!"

class Duck(Flyable, Swimmable):  # Наследуем от двух классов
    def quack(self):
        return "Кря-кря!"

duck = Duck()
print(duck.fly())   # ✅ От Flyable
print(duck.swim())  # ✅ От Swimmable  
print(duck.quack()) # ✅ Собственный метод

Порядок разрешения методов (MRO)

class A:
    def method(self):
        return "Метод из A"

class B(A):
    def method(self):
        return "Метод из B"

class C(A):
    def method(self):
        return "Метод из C"

class D(B, C):
    pass

print(D.__mro__)  # Показывает порядок поиска методов
# (<class '__main__.D'>, <class '__main__.B'>, 
#  <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

obj = D()
print(obj.method())  # "Метод из B" (ищет в порядке MRO)