Что такое объектно-ориентированное программирование?

# Без ООП (процедурный подход)
color = "red"
brand = "Toyota"
speed = 0

def drive(car_speed):
    return car_speed + 10

def stop(car_speed):
    return 0

# С ООП
class Car:
    def __init__(self, color, brand):
        self.color = color
        self.brand = brand
        self.speed = 0
    
    def drive(self, acceleration):
        self.speed += acceleration
    
    def stop(self):
        self.speed = 0

Основные концепции ООП

Преимущества использования ООП

# Без ООП — много повторяющегося кода
car1_color = "red"
car1_brand = "Toyota"
car1_speed = 0

car2_color = "blue" 
car2_brand = "BMW"
car2_speed = 0

# С ООП — чисто и понятно
car1 = Car("red", "Toyota")
car2 = Car("blue", "BMW")

Классы и объекты — основные понятия

# Класс — чертеж собаки
class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
    
    def bark(self):
        return "Гав!"

# Объекты — реальные собаки
my_dog = Dog("Бобик", "Такса")     # Первая собака
friends_dog = Dog("Шарик", "Овчарка") # Вторая собака

print(my_dog.name)     # Бобик
print(friends_dog.bark()) # Гав!

Примеры ООП в реальных проектах

# Пользователь на сайте
class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.is_logged_in = False
    
    def login(self):
        self.is_logged_in = True
    
    def logout(self):
        self.is_logged_in = False

# Персонаж игры
class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health
    
    def attack(self, enemy):
        enemy.health -= 10
    
    def heal(self):
        self.health += 5

# Банковский счет
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
    
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
        else:
            print("Недостаточно средств!")

Создание первого класса в Python

class Dog:
    pass  # pass означает "пока ничего не делай"

class Dog:
    # Атрибут класса (общий для всех собак)
    species = "Canis familiaris"
    
    def bark(self):
        return "Гав-гав!"

Конструктор класса 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