По мере роста сценария вы в конечном итоге передаете одну и ту же группу переменных между функциями, и становится трудно определить, какие данные и какой логике принадлежат. Классы и объекты Python решают эту проблему, объединяя данные и поведение в один блок.

В этом уроке мы шаг за шагом создаем небольшой банковский счет и добавляем каждую идею ООП только тогда, когда она решает проблему. Мы запускали каждый пример на Python 3.13, и показанный результат получен в результате этого запуска. Если вы новичок в этом языке, сначала прочитайте наше Урок по Python для начинающих.

Что такое классы и объекты?

Класс описывает, что представляет собой объект и что он может делать. объект, также называемый экземпляром, — это особый объект, созданный на основе этого описания. «Учетная запись» — это класс, а учетная запись Аши и учетная запись Бена — два объекта.

Вы все время использовали объекты. В Python строки, списки и даже функции являются объектами, поэтому вы можете написать "hello".upper().

Ваш первый урок

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ запускается автоматически всякий раз, когда вы создаете объект, и устанавливает начальное состояние. Внесение в a не коснулось b, потому что у каждого объекта свои данные. Обратите внимание, что этот метод также защищает баланс от неправильного значения. Наше руководство по Обработке исключений Python объясняет raise более подробно.

Что такое сам?

self — это просто объект, над которым работает метод. Когда вы пишете a.deposit(50), Python фактически вызывает Account.deposit(a, 50), передавая объект в качестве первого аргумента. Вот как одно определение метода может обслуживать каждый объект.

Имя self является строгим соглашением, а не ключевым словом, но всегда используйте его. Забыть его в определении метода — самая распространенная ошибка новичков, которая приводит к сбивчивому сообщению о количестве аргументов.

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

Атрибут, установленный непосредственно в теле класса, является общим для всех объектов. Один набор в self принадлежит только этому объекту. В этом примере показано, как ведут себя поисковые запросы:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Последняя строка удивляет людей. Назначение через a не изменило общее значение. Он создал новый атрибут экземпляра в a, который скрывает атрибут класса. Python сначала просматривает объект, затем класс.

Специальные (дандер) методы

Методы с двойным подчеркиванием позволяют вашим объектам работать со встроенными функциями Python. Без них печать аккаунта показывает бесполезный адрес памяти. Добавление двух придает ему читаемую форму:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Наследование

Наследование позволяет новому классу повторно использовать существующий и изменять только то, что отличается. Здесь Savings — это Account с дополнительной настройкой:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() вызывает родительскую версию, поэтому логика установки не повторяется. deposit было унаследовано как есть, а __str__ было переопределено для добавления метки. Используйте наследование только для реальных отношений «есть». Если классу просто что-то нужно, например, автомобилю, которому нужен двигатель, дайте ему этот объект в качестве атрибута. Это называется композицией и обычно более гибко, чем глубокие цепочки наследования.

Полиморфизм

Полиморфизм означает, что разные объекты могут реагировать на один и тот же вызов метода по-своему. Вызывающему коду не обязательно знать точный тип:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Эти два класса даже не имеют общего родителя. Python заботится только о том, чтобы у объекта был метод area — подход, известный как утиная типизация. Добавление Triangle позже не потребует никаких изменений в цикле.

Инкапсуляция и свойства

В Python нет по-настоящему частных атрибутов, вместо этого он опирается на соглашения. Одиночное подчеркивание, как в _price, сообщает другим разработчикам: «Это внутреннее, пожалуйста, не трогайте». Чтобы проверить значения, когда они установлены, используйте свойство, которое снаружи выглядит как простой атрибут:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Это означает, что вы можете начать с простого атрибута и добавить проверку позже, не изменяя код, использующий этот класс. Поэтому не пишите методы get_price() и set_price() по привычке, как это можно сделать в Java. Синтаксис @ здесь представляет собой декоратор, который мы объясняем в Объяснения декораторов Python.

Методы класса и статические методы

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Классы данных

Когда класс в основном содержит данные, писать __init__, __repr__ и __eq__ вручную утомительно. @dataclass генерирует их из аннотаций типов:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Распространенные ошибки

Использование изменяемого атрибута класса

Это классический баг. Список определен в классе, поэтому он используется всеми корзинами:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Создайте его в __init__ с self.items = [], чтобы каждый объект получил свой собственный список.

Другие распространенные ошибки

• Забываем self. Пишите self.balance, а не balance, внутри методов.
• Забывание super().__init__(). Тогда ребенок пропускает атрибуты, установленные родителем.
• Создание огромных классов. Класс, который делает все, сложно тестировать. Разделите это по ответственности.
• Глубокое наследование. Двух уровней обычно достаточно, и композиция зачастую более ясна.
• Не писать тесты. Классы с правилами легко тестировать, как показано в нашем руководстве по pytest с помощью небольшой тележки.

Итоги

Объектно-ориентированный Python сводится к группировке данных с использованием поведения, которое их защищает. Начните с __init__, методов и __str__, затем добавляйте наследование и свойства, когда вы столкнетесь с проблемой, которую они решают. В качестве следующего шага возьмите скрипт, который повсюду передает одни и те же переменные, и превратите их в один небольшой класс.

Часто задаваемые вопросы

Продолжайте учиться