Методы экземпляра
Самые распространенные методы:
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
👍3👏2🔥1👌1
Методы класса @(@)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("Домашняя собака")
👍4🔥1👏1🤩1
Статические методы @(@)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
👍5🔥1👏1
Различия между типами методов
Методы экземпляра (обычные методы):
· Создаются БЕЗ декораторов
· Первый параметр ВСЕГДА self - это ссылка на конкретный объект
· Имеют доступ ко всем атрибутам и методам объекта
· Могут изменять состояние объекта
· Вызываются только через объект (не через класс)
Методы класса (@(@)classmethod):
· Создаются с декоратором @(@)classmethod
· Первый параметр ВСЕГДА cls - это ссылка на сам класс
· НЕ имеют доступа к атрибутам конкретного объекта
· Могут изменять атрибуты класса (общие для всех объектов)
· Вызываются как через класс, так и через объект
Статические методы (@(@)staticmethod):
· Создаются с декоратором @(@)staticmethod
· НЕТ специального первого параметра
· НЕ имеют доступа ни к объекту, ни к классу
· Это просто функции, которые живут внутри класса для удобства
· Вызываются как через класс, так и через объект
👍4🔥1😁1🤩1
Практическое применение каждого типа
Методы экземпляра — для действий объекта:
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
👍5🔥1😁1
Публичные атрибуты и методы
Доступны отовсюду:
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 # 😱 Можно изменить на отрицательное!
👍5😁1🤩1
Защищенные атрибуты (_одиночное подчеркивание)
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) # ❌ Не рекомендуется, но возможно
👍4🤔3😁1
Приватные атрибуты (__двойное подчеркивание)
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 - через метод
👍5🔥1👌1
Свойства @(@)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
👍3😁2🔥1👌1
Сеттеры и геттеры
Контроль при установке значений:
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 # ❌ "Баланс не может быть отрицательным!"
👍3🔥1👏1👌1
Базовое наследование классов
Простыми словами:
Создание нового класса на основе существующего. Новый класс получает все свойства и методы родителя.
Пример из жизни:
· Родитель: Животное (есть, спать)
· Ребенок: Собака (все то же + лаять)
· Ребенок: Кошка (все то же + мяукать)
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()) # ✅ Собственный метод
👍4🔥1😎1
Переопределение методов
Изменение поведения унаследованного метода:
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())
# Вывод:
# Гав!
# Мяу!
🔥3👍1🤩1👌1
Ключевое слово 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)
👍3🔥1👏1😁1
Множественное наследование
Наследование от нескольких классов:
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()) # ✅ Собственный метод
👍3👏2🔥1😁1
Порядок разрешения методов (MRO)
Python ищет методы в определенном порядке:
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)
👏3👍1🔥1🤩1
Абстрактные базовые классы
Классы, которые нельзя создать напрямую:
from abc import ABC, abstractmethod
class Shape(ABC): # Абстрактный класс
@abstractmethod
def area(self):
pass # Дочерние классы ДОЛЖНЫ реализовать этот метод
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self): # ✅ Обязательная реализация
return self.width * self.height
def perimeter(self): # ✅ Обязательная реализация
return 2 * (self.width + self.height)
# shape = Shape() # ❌ Ошибка! Нельзя создать абстрактный класс
rect = Rectangle(5, 3) # ✅ Можно создать
print(rect.area()) # 15
👍3🔥1👏1😁1
Понятие полиморфизма
Полиморфизм — это возможность объектов разных классов выполнять одно и то же действие, но каждый по-своему. Простыми словами: "Одна команда — много разных реализаций".
Жизненная аналогия:
Представьте, что вы говорите разным людям "нарисуйте круг":
· Художник нарисует красками на холсте
· Ребенок нарисует карандашом в тетради
· Программист создаст круг в графическом редакторе
Все выполнили одну команду, но разными способами!
Полиморфизм позволяет писать более гибкий и универсальный код. Мы можем работать с разными объектами одинаковым образом, не зная их точного типа.
# Без полиморфизма - нужно знать тип каждого объекта
def make_sound(animal):
if isinstance(animal, Dog):
return "Гав!"
elif isinstance(animal, Cat):
return "Мяу!"
elif isinstance(animal, Cow):
return "Муу!"
# С полиморфизмом - просто вызываем метод
def make_sound(animal):
return animal.speak() # Каждый объект сам знает, как "говорить"
👍3👏2🔥1👌1
Перегрузка методов
Перегрузка методов — это возможность создавать несколько методов с одинаковым именем, но разными параметрами. В Python настоящей перегрузки нет, но мы можем эмулировать её.
Как это работает в Python:
Python не поддерживает перегрузку методов как в Java или C++, но мы можем использовать значения по умолчанию и проверки типов:
class Calculator:
def add(self, a, b, c=None):
if c is None:
# Вариант для двух чисел
return a + b
else:
# Вариант для трех чисел
return a + b + c
# Использование
calc = Calculator()
print(calc.add(2, 3)) # 5 - сложение двух чисел
print(calc.add(2, 3, 4)) # 9 - сложение трех чисел
👍5✍1👌1
Переопределение методов
Переопределение методов — это когда дочерний класс изменяет поведение метода, унаследованного от родительского класса. Метод имеет то же имя, но другую реализацию.
Простая аналогия:
Представьте класс "Транспортное средство" с методом "двигаться":
· Машина двигается по дороге
· Лодка двигается по воде
· Самолет двигается по воздуху
Все они "двигаются", но по-разному!
class Transport:
def move(self):
return "Транспорт движется"
class Car(Transport):
def move(self): # Переопределяем метод
return "Машина едет по дороге"
class Boat(Transport):
def move(self): # Переопределяем метод
return "Лодка плывет по воде"
class Airplane(Transport):
def move(self): # Переопределяем метод
return "Самолет летит по воздуху"
# Демонстрация полиморфизма
transports = [Car(), Boat(), Airplane()]
for transport in transports:
print(transport.move())
# Вывод:
# Машина едет по дороге
# Лодка плывет по воде
# Самолет летит по воздуху
🔥3⚡1👍1😁1