Какие методы бывают идемпотентными в Python?

Идемпотентные методы в Python

Идемпотентность — свойство операции, при котором применение её несколько раз даёт тот же результат, что и применение один раз: f(f(x)) = f(x).

HTTP методы

GET (идемпотентный)

import requests

# Можно вызывать неограниченное количество раз
response = requests.get('https://api.example.com/users/1')
response2 = requests.get('https://api.example.com/users/1')
# Результат всегда одинаков

# Реализация на FastAPI
from fastapi import FastAPI

app = FastAPI()

@app.get('/users/{user_id}')
def get_user(user_id: int):
    # Идемпотентно — всегда возвращает одного пользователя
    return {'id': user_id, 'name': 'John'}

DELETE (идемпотентный)

# Первый вызов удаляет пользователя
response = requests.delete('https://api.example.com/users/1')  # 200 OK

# Второй вызов тоже успешен (но пользователя уже нет)
response = requests.delete('https://api.example.com/users/1')  # 204 No Content

# Оба вызова имеют одинаковый эффект — пользователь удалён

# Правильная реализация
@app.delete('/users/{user_id}')
def delete_user(user_id: int):
    user = db.query(User).filter(User.id == user_id).first()
    if user:
        db.delete(user)
        db.commit()
    return {'status': 'deleted'}  # Возвращаем одинаково в обоих случаях

PUT (идемпотентный)

# Перезапись полностью
response = requests.put('https://api.example.com/users/1', json={
    'name': 'John',
    'email': 'john@example.com'
})

# Повторный вызов имеет тот же эффект
response = requests.put('https://api.example.com/users/1', json={
    'name': 'John',
    'email': 'john@example.com'
})
# Пользователь с теми же данными

# Реализация
@app.put('/users/{user_id}')
def update_user(user_id: int, data: UserSchema):
    user = db.query(User).filter(User.id == user_id).first()
    for field, value in data.dict().items():
        setattr(user, field, value)
    db.commit()
    return user

POST (НЕ идемпотентный)

# Каждый вызов создаёт новую запись
response = requests.post('https://api.example.com/users', json={
    'name': 'John'
})
# Создан пользователь #1

response = requests.post('https://api.example.com/users', json={
    'name': 'John'
})
# Создан пользователь #2 (дублирование!)

@app.post('/users')
def create_user(data: UserSchema):
    user = User(**data.dict())
    db.add(user)
    db.commit()
    return user

PATCH (может быть идемпотентным)

# Идемпотентный PATCH (замена поля)
response = requests.patch('https://api.example.com/users/1', json={
    'status': 'active'
})
# Повторный вызов имеет тот же эффект — статус active

# НЕ идемпотентный PATCH (инкремент)
response = requests.patch('https://api.example.com/users/1', json={
    'age': '+1'  # Инкремент!
})
# Первый вызов: age = 30
# Второй вызов: age = 31
# Третий вызов: age = 32 (разные результаты!)

Идемпотентность в методах объектов

Идемпотентные методы

# 1. sorted() — всегда возвращает отсортированный список
data = [3, 1, 2]
result1 = sorted(data)
result2 = sorted(result1)  # [1, 2, 3]
# result1 == result2

# 2. list.sort() — сортирует на месте
data = [3, 1, 2]
data.sort()  # [1, 2, 3]
data.sort()  # [1, 2, 3] — одинаковый результат

# 3. dict.update() с полной перезаписью
data = {'a': 1}
data.update({'a': 1, 'b': 2})  # {'a': 1, 'b': 2}
data.update({'a': 1, 'b': 2})  # {'a': 1, 'b': 2} — то же самое

# 4. str.upper() / str.lower()
text = 'Hello'
result1 = text.upper()  # 'HELLO'
result2 = result1.upper()  # 'HELLO' — одинаковы

# 5. set.add() для существующего элемента
s = {1, 2}
s.add(2)  # {1, 2}
s.add(2)  # {1, 2} — идемпотентно

# 6. Path.mkdir() с exist_ok=True
from pathlib import Path
path = Path('/tmp/mydir')
path.mkdir(exist_ok=True)  # Создана или существует
path.mkdir(exist_ok=True)  # Снова идемпотентно

НЕ идемпотентные методы

# 1. list.append() — изменяет размер
data = [1]
data.append(2)  # [1, 2]
data.append(2)  # [1, 2, 2] — разные результаты!

# 2. dict.pop() — удаляет ключ
data = {'a': 1}
data.pop('a')  # 1, data = {}
data.pop('a')  # KeyError! — разные результаты

# 3. time.time() — каждый раз новое значение
import time
t1 = time.time()  # 1234567890.123
t2 = time.time()  # 1234567891.456 — разные!

# 4. random.randint() — случайное число
import random
r1 = random.randint(1, 10)
r2 = random.randint(1, 10)  # Вероятно разные

# 5. file.read() с перемещением позиции
with open('file.txt') as f:
    content1 = f.read()  # Весь файл
    content2 = f.read()  # Пусто! (EOF)

Идемпотентность в лямбда-выражениях

# Идемпотентное преобразование
f = lambda x: x * 2
f(f(3))  # = 12 (НЕ идемпотентно!)

# Идемпотентный фильтр
def is_even(x):
    return x % 2 == 0

is_even(is_even(4))  # ошибка типа — 4 это int, bool не имеет %

# Правильный пример идемпотентности:
f = lambda x: x if x == x else x  # Всегда True для чисел
f(f(5)) == f(5)  # True

Практический пример: Idempotency Key

from uuid import uuid4
from fastapi import FastAPI, Header
from typing import Optional

app = FastAPI()

# Хранилище обработанных запросов
processed_requests = {}

@app.post('/payment')
def process_payment(
    amount: float,
    idempotency_key: Optional[str] = Header(None)
):
    if idempotency_key in processed_requests:
        # Вернуть кэшированный результат
        return processed_requests[idempotency_key]
    
    # Обработать платёж
    result = {
        'status': 'success',
        'transaction_id': str(uuid4()),
        'amount': amount
    }
    
    # Кэшировать результат
    processed_requests[idempotency_key] = result
    return result

# Использование:
# curl -X POST http://localhost:8000/payment #   -H "Idempotency-Key: my-unique-key" #   -d '{"amount": 100}'

Таблица идемпотентности для стандартных операций

Метод/Операция      | Идемпотентна? | Примечание
--------------------|---------------|-----------------------------------
GET                 | Да            | Только чтение
DELETE              | Да            | Повторное удаление идемпотентно
PUT                 | Да            | Полная замена
POST                | Нет           | Создаёт новые ресурсы
PATCH               | Может быть    | Зависит от реализации
sorted()            | Да            | Сортировка уже отсортированного
dict.update()       | Да            | С полной перезаписью
list.append()       | Нет           | Каждый вызов добавляет элемент
file.write()        | Нет           | Зависит от режима открытия
random.randint()    | Нет           | Случайные значения

Советы для идемпотентности

• Используй абсолютные значения вместо инкрементов
• Проверяй наличие перед созданием (exists_ok, if not exists)
• Кэшируй результаты по Idempotency Key
• Логируй обработку для отладки дублей
• Используй UUID для уникальности
• Тестируй двойными вызовами

Вывод: идемпотентность критична для распределённых систем и API. Правильное применение предотвращает дублирование и обеспечивает надёжность.