Что такое состояние в Python?

Что такое состояние в Python?

Состояние (state) — это набор значений всех атрибутов объекта в определённый момент времени. Состояние описывает текущие характеристики объекта и может изменяться при выполнении методов.

Основная идея

Каждый объект имеет свое состояние — текущие значения его полей (атрибутов):

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # Атрибут (часть состояния)
        self.balance = balance      # Атрибут (часть состояния)
    
    def deposit(self, amount):
        self.balance += amount      # Изменяем состояние

account = BankAccount("Alice", 1000)
print(account.balance)  # 1000 — текущее состояние

account.deposit(500)
print(account.balance)  # 1500 — новое состояние

Состояние vs Поведение

Состояние — данные (атрибуты) Поведение — методы (действия)

class Car:
    # СОСТОЯНИЕ — текущие значения
    def __init__(self, brand, speed=0):
        self.brand = brand          # Состояние: марка
        self.speed = speed          # Состояние: скорость
        self.is_running = False     # Состояние: включена ли
    
    # ПОВЕДЕНИЕ — методы
    def start(self):
        self.is_running = True      # Изменение состояния
    
    def accelerate(self):
        if self.is_running:
            self.speed += 10        # Изменение состояния
    
    def stop(self):
        self.is_running = False     # Изменение состояния
        self.speed = 0              # Изменение состояния

car = Car("Toyota")

# Состояние: скорость = 0, не включена
print(f"Speed: {car.speed}, Running: {car.is_running}")  # 0, False

car.start()  # Поведение
car.accelerate()  # Поведение

# Состояние изменилось
print(f"Speed: {car.speed}, Running: {car.is_running}")  # 10, True

Типы состояний

1. Неизменяемое состояние (Immutable)

Объект не меняет своё состояние после создания:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self._hash = hash((x, y))
    
    def __hash__(self):
        return self._hash
    
    # Нет методов, которые меняют x или y
    def move(self, dx, dy):
        return Point(self.x + dx, self.y + dy)  # Возвращает новый объект

p1 = Point(1, 2)
p2 = p1.move(3, 4)
# p1 остался с состоянием (1, 2)
# p2 имеет новое состояние (4, 6)

2. Изменяемое состояние (Mutable)

Объект может менять своё состояние через методы:

class List:
    def __init__(self, items):
        self.items = list(items)
    
    def add(self, item):
        self.items.append(item)  # Меняем состояние
    
    def remove(self, item):
        self.items.remove(item)  # Меняем состояние

my_list = List([1, 2, 3])
print(my_list.items)  # [1, 2, 3]

my_list.add(4)
print(my_list.items)  # [1, 2, 3, 4] — состояние изменилось

Жизненный цикл состояния

Состояние объекта проходит через несколько этапов:

class Order:
    def __init__(self, order_id):
        self.order_id = order_id
        self.status = "created"         # Начальное состояние
        self.items = []
        self.total = 0
    
    def add_item(self, item, price):
        if self.status != "created":
            raise Exception("Cannot add items to confirmed order")
        self.items.append((item, price))
        self.total += price
        # Состояние изменилось
    
    def confirm(self):
        self.status = "confirmed"       # Переход состояния
    
    def ship(self):
        self.status = "shipped"         # Переход состояния
    
    def deliver(self):
        self.status = "delivered"       # Финальное состояние

order = Order("ORD-001")
# Состояние: created, items=[], total=0

order.add_item("Book", 20)
# Состояние: created, items=[('Book', 20)], total=20

order.confirm()
# Состояние: confirmed

order.ship()
# Состояние: shipped

order.deliver()
# Состояние: delivered

Паттерн State (управление состоянием)

Для сложных объектов используется State паттерн:

from abc import ABC, abstractmethod

# Абстрактное состояние
class OrderState(ABC):
    @abstractmethod
    def add_item(self, order, item):
        pass
    
    @abstractmethod
    def confirm(self, order):
        pass

# Конкретные состояния
class CreatedState(OrderState):
    def add_item(self, order, item):
        print(f"Adding {item}")
        order.items.append(item)
    
    def confirm(self, order):
        order.state = ConfirmedState()
        print("Order confirmed")

class ConfirmedState(OrderState):
    def add_item(self, order, item):
        raise Exception("Cannot add items to confirmed order")
    
    def confirm(self, order):
        raise Exception("Order already confirmed")

class Order:
    def __init__(self):
        self.state = CreatedState()  # Начальное состояние
        self.items = []
    
    def add_item(self, item):
        self.state.add_item(self, item)  # Делегируем состоянию
    
    def confirm(self):
        self.state.confirm(self)  # Делегируем состоянию

order = Order()
order.add_item("Book")
order.confirm()
order.add_item("Pen")  # Exception!

Сохранение и восстановление состояния

1. Сериализация состояния

import json

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.preferences = {"theme": "dark"}
    
    def save_state(self):
        """Сохранить состояние в JSON"""
        return json.dumps(self.__dict__)
    
    @staticmethod
    def load_state(json_str):
        """Восстановить состояние из JSON"""
        data = json.loads(json_str)
        user = User(data['name'], data['email'])
        user.preferences = data['preferences']
        return user

user = User("Alice", "alice@example.com")
state = user.save_state()
print(state)
# {"name": "Alice", "email": "alice@example.com", "preferences": {"theme": "dark"}}

loaded_user = User.load_state(state)
print(loaded_user.name)  # Alice

2. Snapshotpattern (снимок состояния)

class GameCharacter:
    def __init__(self, name, health):
        self.name = name
        self.health = health
        self.level = 1
        self.inventory = []
    
    def take_damage(self, amount):
        self.health -= amount
    
    def level_up(self):
        self.level += 1
        self.health += 50
    
    def save_snapshot(self):
        """Создать снимок состояния"""
        return {
            'name': self.name,
            'health': self.health,
            'level': self.level,
            'inventory': self.inventory.copy()
        }
    
    def load_snapshot(self, snapshot):
        """Восстановить из снимка"""
        self.health = snapshot['health']
        self.level = snapshot['level']
        self.inventory = snapshot['inventory'].copy()

char = GameCharacter("Hero", 100)
char.level_up()
snapshot = char.save_snapshot()

char.take_damage(50)
print(f"Health: {char.health}")  # 100

char.load_snapshot(snapshot)
print(f"Health: {char.health}")  # 150

Состояние и Thread Safety

Когда несколько потоков обращаются к состоянию объекта, нужна синхронизация:

import threading

class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()  # Для защиты состояния
    
    def increment(self):
        with self.lock:  # Критическая секция
            self.count += 1  # Изменение состояния безопасно
    
    def get_count(self):
        with self.lock:
            return self.count  # Чтение состояния безопасно

counter = Counter()

# Несколько потоков могут безопасно менять состояние
for i in range(100):
    t = threading.Thread(target=counter.increment)
    t.start()

Context Managers для управления состоянием

class DatabaseConnection:
    def __init__(self, host):
        self.host = host
        self.connected = False
        self.transactions = []
    
    def __enter__(self):
        # Состояние: подключение установлено
        print(f"Connecting to {self.host}")
        self.connected = True
        self.transactions = []
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        # Состояние: подключение закрыто
        print(f"Closing connection to {self.host}")
        self.connected = False
        self.transactions.clear()

with DatabaseConnection("localhost") as db:
    print(f"Connected: {db.connected}")  # True
    # Здесь мы работаем с состоянием БД

print(f"Connected: {db.connected}")  # False

Лучшие практики управления состоянием

✅ Делай:

• Инициализируй состояние в __init__
• Используй property для валидации
• Документируй допустимые состояния
• Тестируй переходы состояния
• Используй Type Hints

❌ Не делай:

• Не меняй состояние незаметно
• Не создавай недопустимые состояния
• Не забывай о thread safety
• Не смешивай бизнес-логику с управлением состоянием

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

class BankAccount:
    def __init__(self, owner: str, balance: float):
        self._owner = owner
        self._balance = balance
        self._transactions = []
    
    @property
    def balance(self) -> float:
        """Получить текущее состояние (баланс)"""
        return self._balance
    
    def deposit(self, amount: float) -> None:
        """Изменить состояние: добавить деньги"""
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self._balance += amount
        self._transactions.append(('deposit', amount))
    
    def withdraw(self, amount: float) -> None:
        """Изменить состояние: снять деньги"""
        if amount <= 0:
            raise ValueError("Amount must be positive")
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        self._balance -= amount
        self._transactions.append(('withdraw', amount))

account = BankAccount("Alice", 1000)
account.deposit(500)    # Состояние: 1500
account.withdraw(200)   # Состояние: 1300
print(account.balance)  # 1300

Заключение

Состояние — это:

• Набор значений всех атрибутов объекта
• Текущие характеристики объекта
• Результат всех операций, выполненных над объектом
• Критически важный аспект дизайна класса

Правильное управление состоянием — это основа надёжного и предсказуемого программного обеспечения.