- Использование SQLAlchemy для управления транзакциями в базах данных

Привет, на связи Иван! Сегодня поговорим о магии управления транзакциями с помощью SQLAlchemy — универсального инструмента для работы с базами данных в Python.

Что такое транзакция и зачем она нужна?
Представьте, что вы обрабатываете банковский перевод: списываете деньги у одного пользователя и начисляете их другому. Что, если в середине операции отключится свет? Важно, чтобы операция либо завершилась полностью, либо не была выполнена вовсе. Здесь и вступают в игру транзакции!

SQLAlchemy не только помогает строить запросы к базе «на лету», но и позволяет контролировать целостность данных через механизмы управления транзакциями.

### Пример 1: Автоматическое управление транзакциями

Всё просто: используем контекстный менеджер session.begin(). Если внутри блока возникает исключение — все изменения автоматом откатываются.

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, Session

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)

engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)

with Session(engine) as session:
    with session.begin():
        new_user = User(name='Alice')
        session.add(new_user)
    # Закоммитили — пользователь добавлен!

### Пример 2: Ручной контроль — commit и rollback

Иногда нужно больше контроля, например, при сложной логике:

with Session(engine) as session:
    try:
        user1 = User(name='Bob')
        session.add(user1)
        # Какая-то логика, возможно, с ошибкой
        if user1.name == 'Bob':
            raise ValueError("Test error!")
        session.commit()
    except Exception:
        session.rollback()
        print("Транзакция отменена, все изменения откатились.")

### Преимущества

- Надежность: можно быть уверенным, что данные не останутся в «полусыром» состоянии.
- Удобство: Pythonic API и защита от ошибок.
- Гибкость: поддержка разных СУБД (PostgreSQL, SQLite, MySQL и др.).

SQLAlchemy превращает работу с транзакциями во вполне дружелюбное и безопасное занятие. Теперь вы знаете, как избегать неожиданных неприятностей при работе с базами данных на Python. Попробуйте — понравится!

- Как внедрить обработку изображений в веб-приложение на Python

Привет! На связи Иван. Сегодня разберём, как добавить возможность обработки изображений в ваше Python-веб-приложение. Это реальный must-have, если вы хотите, чтобы пользователи могли загружать фото и редактировать их прямо в браузере.

Модули, которые нам пригодятся — это Flask для сервера и легендарный Pillow для обработки изображений. Да, всё проще, чем кажется!

## Установка

Установим нужные библиотеки:

pip install flask pillow

## Базовое приложение, принимающее изображение

Сначала напишем простейший сервер:

from flask import Flask, request, send_file
from PIL import Image
import io

app = Flask(__name__)

@app.route('/upload', methods=['POST'])
def process_image():
    if 'file' not in request.files:
        return "No file uploaded", 400
    img_file = request.files['file']
    img = Image.open(img_file.stream)
    # Применим простую обработку: например, повернём изображение
    img = img.rotate(90, expand=True)
    buf = io.BytesIO()
    img.save(buf, format='JPEG')
    buf.seek(0)
    return send_file(buf, mimetype='image/jpeg')

if __name__ == "__main__":
    app.run(debug=True)

## Как это работает?

1. Пользователь отправляет картинку на /upload через POST-запрос.
2. Сервер открывает изображение с помощью Pillow.
3. Обрабатывает изображение (здесь — поворот на 90 градусов).
4. Возвращает обработанный файл пользователю.

## Немного больше магии

А вот как сделать превью картинки:

img = Image.open(img_file.stream)
img.thumbnail((128, 128))

А если хотите фильтр «чёрно-белое фото» — это одна строчка:

img = img.convert('L')

## Как попробовать?

Можно использовать Postman или curl:

curl -F "file=@your_image.jpg" http://127.0.0.1:5000/upload --output result.jpg

## Краткие советы

- Всегда проверяйте формат изображения!
- Защитите приложение от загрузки слишком больших файлов.
- Pillow поддерживает кучу фильтров и манипуляций: кадрирование, размытие, изменение яркости и многое другое.

Обработка изображений в веб-приложениях на Python — вопрос пары строчек кода. Главное — фантазия и понимание, как устроен ваш стек. Экспериментируйте, и пусть ваше приложение станет стильнее и удобнее!

До встречи,
Иван

- Введение в модуль PyPDF2 для работы с PDF-документами

Привет! С вами Иван, и сегодня мы заглянем под обложку одного из самых популярных форматов для документов — PDF. Если вы думали, что читать, объединять или вырезать страницы из PDF — это удел только офисных программ, то пришло время познакомиться с модулем PyPDF2 в Python!

Что такое PyPDF2?

PyPDF2 — это пакет, который позволяет легко обрабатывать PDF-файлы: читать, извлекать текст, собирать вместе разные документы и даже защищать их паролем. Звучит как магия? Давайте попробуем на практике.

### Чтение PDF: быстро и просто

Допустим, у вас есть файл sample.pdf, и вы хотите вывести его содержимое на экран. Всё элементарно:

import PyPDF2

with open('sample.pdf', 'rb') as file:
    pdf_reader = PyPDF2.PdfReader(file)
    page = pdf_reader.pages[0]
    print(page.extract_text())

Вот и всё! Открыли, прочитали первую страницу, вывели текст. Никаких танцев с бубном.

### Склейка документов: дела объединённые

Хотите объединить несколько PDF-файлов в один? Смотрите, как это делается:

import PyPDF2

merger = PyPDF2.PdfMerger()
for pdf in ['file1.pdf', 'file2.pdf']:
    merger.append(pdf)

with open('merged.pdf', 'wb') as output:
    merger.write(output)

Вуаля! Теперь merged.pdf содержит страницы обоих исходных файлов. Быстро, изящно и удобно.

### Извлечение страниц: никаких лишних листов

Бывает, надо сохранить только несколько нужных страниц. За это отвечает PdfWriter:

import PyPDF2

reader = PyPDF2.PdfReader('big.pdf')
writer = PyPDF2.PdfWriter()
for num in [0, 2]:  # Например, 1-я и 3-я страницы
    writer.add_page(reader.pages[num])

with open('extracted.pdf', 'wb') as out:
    writer.write(out)

Теперь у вас новый PDF только с выбранными страницами!

### Безопасность: ставим пароль

Если хочется оставить секретные заметки только для себя:

import PyPDF2

reader = PyPDF2.PdfReader('open.pdf')
writer = PyPDF2.PdfWriter()
for page in reader.pages:
    writer.add_page(page)
writer.encrypt('StrongPassword!')

with open('protected.pdf', 'wb') as out:
    writer.write(out)

Теперь открыть protected.pdf без пароля не получится.

---

PyPDF2 делает работу с PDF простой и гибкой, как и должно быть в Python. Приложения — на любой вкус: отчеты, автоматизация документов, просто эксперименты. Надеюсь, этот краткий обзор вдохновит вас на новые проекты!

- Сериализация данных с использованием модуля json и pickle

Привет! Я Иван, и сегодня мы окунемся в мир сериализации данных в Python с помощью двух мощных модулей: json и pickle. Если вы когда-нибудь задумывались, как сохранить сложные структуры данных в файл, а позже быстро их восстановить — этот пост для вас.

### Сериализация: зачем это нужно?

Сериализация — это процесс преобразования объектов в поток байтов или строк, чтобы их можно было хранить или передавать. А потом — обратно в объекты с помощью десериализации. В Python из коробки есть два популярных инструмента для этих задач: json и pickle.

---

## Модуль json: стандарт для обмена

json переводит объекты Python в строку в формате JSON и обратно. Это удобно, если ваши данные нужно читать или писать из других языков программирования.

### Пример: сериализация и десериализация словаря

import json

data = {"name": "Alice", "age": 30, "is_active": True, "hobbies": ["music", "python"]}
# Сериализация: запись в строку
json_str = json.dumps(data)
print(json_str)

# Десериализация: из строки обратно в Python-объект
new_data = json.loads(json_str)
print(new_data)

Кроме строк, можно сразу работать с файлами:

with open("data.json", "w") as f:
    json.dump(data, f)

И обратно:

with open("data.json") as f:
    data_from_file = json.load(f)

---

## Модуль pickle: для хранения любых объектов

pickle — это уже магия посерьезней. Он умеет сериализовать почти любые объекты Python (и даже функции), но полученные данные будут не человекочитаемыми и небезопасны для загрузки из неизвестных источников.

### Пример: сериализация класса

import pickle

class User:
    def __init__(self, username):
        self.username = username

user = User('Bob')

# Сохраняем объект в файл
with open("user.pkl", "wb") as f:
    pickle.dump(user, f)

# Загружаем объект обратно
with open("user.pkl", "rb") as f:
    loaded_user = pickle.load(f)
print(loaded_user.username)

---

## json или pickle: что выбрать?

- json: для обмена между разными языками и системами, когда важна читаемость.
- pickle: для хранения сложных структур Python, когда безопасность не критична.

Используйте правильный инструмент — и ваши данные всегда будут под рукой!

До встречи в следующих постах!
— Иван

- Использование doctest для тестирования документации и кода

Привет! С вами Иван, и сегодня мы рассмотрим один из самых недооценённых инструментов стандартной библиотеки Python — модуль doctest. Даже если вы только начали своё знакомство с языком, вы наверняка уже сталкивались с примерами кода прямо в документации функций. Так вот, doctest умеет запускать такие примеры и проверять, всё ли работает именно так, как написано!

Зачем это нужно?
Во-первых, тесты прямо в строках документации помогают другим разработчикам понять, как на самом деле использовать вашу функцию. Во-вторых, если вы со временем поменяете реализацию, doctest сразу заметит, если что-то стало работать иначе.

## Как это работает

Допустим, у нас есть вот такая функция:

def multiply(a, b):
    """
    Multiply two numbers.

    Example:
    >>> multiply(2, 3)
    6
    >>> multiply(-1, 5)
    -5
    """
    return a * b

Вот и всё! Мы вписали примеры прямо в docstring. Теперь проверяем их командой в консоли:

python -m doctest my_module.py

Если всё хорошо, doctest молча промолчит, но как только что-то идёт не так — покажет на ошибку.

## А если ситуация сложней?

Даже нестандартные случаи можно покрыть doctest’ом, например:

def divide(a, b):
    """
    Divide a by b.

    >>> divide(6, 2)
    3.0
    >>> divide(5, 0)
    Traceback (most recent call last):
        ...
    ZeroDivisionError: division by zero
    """
    return a / b

Появилась ошибка? Просто пропишите её в docstring, уточняя только последние строки traceback — doctest это поймёт.

## Автоматизация

Можно запускать тесты не только через консоль. Например, так:

if __name__ == "__main__":
    import doctest
    doctest.testmod()

Теперь doctest сам проверит все функции при запуске скрипта.

## Итоги

doctest — быстрый способ держать документацию и рабочий код в актуальном состоянии. Особенно удобен на этапе написания простых функций и модулей. Не забывайте про этот инструмент, и ваш код будет не только функциональным, но и понятным для всех!

До встречи в следующих постах — будем исследовать Python дальше!

- Как создавать интерактивные потоковые приложения с Streamlit

Привет, друзья! На связи Иван, и сегодня у нас настоящая находка для тех, кто хочет оживить свои Python-проекты — мы поговорим о Streamlit.

Streamlit — это библиотека, которая позволяет создавать интерактивные веб-приложения на Python буквально за считанные минуты. Не нужны ни знания фронтенда, ни написание HTML/CSS. Всё, что нужно — ваш привычный Python-код. А приложения можно запускать локально или выкладывать в интернет!

Минималистичный Hello World

Начнём с самого простого примера. Создадим страницу, которая выводит “Hello, Streamlit!”:

import streamlit as st

st.title("Hello, Streamlit!")
st.write("Это наше первое интерактивное приложение!")

Сохрани файл, например, как app.py и запусти:

streamlit run app.py

Откроется браузер — и вуаля! У тебя уже есть полноценное приложение.

Добавляем интерактивность

Теперь добавим немного динамики. Представьте, что вы хотите построить график синуса — пользователь сам выбирает диапазон для оси X.

import streamlit as st
import numpy as np
import matplotlib.pyplot as plt

st.title("График синуса")
x_start = st.slider("Начало диапазона", 0, 10, 0)
x_end = st.slider("Конец диапазона", 1, 20, 10)

x = np.linspace(x_start, x_end, 100)
y = np.sin(x)

fig, ax = plt.subplots()
ax.plot(x, y)
st.pyplot(fig)

Слайдеры позволяют моментально менять диапазон без перезагрузки страницы — всё происходит мгновенно!

Загрузка и обработка данных

Streamlit отлично справляется с загрузкой файлов и мгновенной обработкой данных. Например, вот способ быстро посмотреть содержимое csv-файла:

import streamlit as st
import pandas as pd

st.title("Загрузка данных")
uploaded_file = st.file_uploader("Выберите CSV-файл")

if uploaded_file is not None:
    df = pd.read_csv(uploaded_file)
    st.write("Первые 5 строк данных:")
    st.write(df.head())

Вывод

Streamlit — инструмент, который буквально стирает границы между анализом данных и созданием готовых инструментов для пользователей. Всё максимально просто: реагируем на действия пользователя, визуализируем данные, загружаем таблицы — и всё это без боли и лишних сложностей. Попробуйте добавить Streamlit в свой инструментарий, и ваши проекты заиграют новыми красками!

- Введение в asyncio и его применение для ввода-вывода

Привет, я Иван, и сегодня мы заглянем за кулисы магического модуля Python — asyncio. Представьте, что вы пишете программу, которая скачивает десятки файлов или постоянно получает сообщения с сервера. Если подходить к задаче привычно, ваш скрипт будет то и дело “замораживаться”, ведь стандартный ввод-вывод в Python синхронен — выполняется строго по очереди.

А теперь представьте: ваши задачи будто цирковые акробаты — работают параллельно, не мешая друг другу, и без лишних пауз. Вот тут на сцену и выходит asyncio!

## Немного теории: что такое asyncio и зачем он нужен

asyncio — это стандартный модуль Python, который позволяет писать асинхронный код. В отличие от потоков и процессов, асинхронность (или кооперативная многозадачность) позволяет выполнять множество ввода-вывода задач одновременно внутри одного потока. Все это управляется так называемым “циклом событий” (event loop). Каждая задача сообщает: “я жду, можешь обработать что-нибудь еще!”.

## Пример 1: Асинхронная задержка

Посмотрим на простой пример: одновременное ожидание с помощью asyncio.sleep().

import asyncio

async def print_after_delay(text, delay):
    await asyncio.sleep(delay)
    print(text)

async def main():
    await asyncio.gather(
        print_after_delay("Hello", 2),
        print_after_delay("World!", 1)
    )

asyncio.run(main())

Выполнение "Hello" и "World!" не блокирует основной поток: оба задания стартуют, но результат появляется раньше для того, где задержка меньше.

## Пример 2: Асинхронный HTTP-запрос

Асинхронность особенно полезна для сетевых операций. Используем вместе с популярной библиотекой aiohttp:

import asyncio
import aiohttp

async def fetch_status(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(f"{url}: {response.status}")

async def main():
    urls = [
        "https://python.org",
        "https://google.com",
        "https://example.com"
    ]
    tasks = [fetch_status(url) for url in urls]
    await asyncio.gather(*tasks)

asyncio.run(main())

Здесь три запроса отправляются параллельно — экономия времени налицо!

## Подводим итоги

Ввод-вывод — частая причина “тормозов” скриптов. Asyncio позволяет эффективно запускать множество таких операций, не занимая поток ожиданием. Это мощный инструмент для современного Python — попробуйте, и ваша программа заиграет новыми красками!

- Работа с различными форматами данных: от CSV до YAML

Привет! Я Иван, и сегодня мы поговорим про работу с форматом данных в Python — от знакомого CSV до YAML. Почему это важно? Почти все программы сегодня обмениваются данными, и понимание этих форматов существенно облегчает жизнь начинающему программисту.

### Парсим CSV как профи

CSV (Comma-Separated Values) встречается повсюду: от баз данных до выгрузок из «1С». Встроенный модуль csv позволяет работать с этими файлами удобно и быстро.

import csv

with open('data.csv', mode='r', newline='') as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row['name'], row['age'])

В этом примере DictReader возвращает строки как словари: row['name'] – и все готово!

### JSON: Дружим с вебом

JSON — король обмена данными в интернете. В Python взаимодействие с ним интуитивно понятно:

import json

data = {'name': 'Ivan', 'active': True}
with open('data.json', 'w') as file:
    json.dump(data, file)

with open('data.json', 'r') as file:
    output = json.load(file)
print(output['name'])

Чтение и запись почти не отличаются – используем json.dump и json.load.

### XML: Для любителей тегов

XML кажется устаревшим, но до сих пор встречается. Тут поможет xml.etree.ElementTree:

import xml.etree.ElementTree as ET

tree = ET.parse('data.xml')
root = tree.getroot()
for user in root.findall('user'):
    print(user.find('login').text)

Элементы ищутся с помощью методов find и findall. Для небольших проектов чаще всего этого достаточно.

### YAML: Человечно и читаемо

YAML любят в мире DevOps и настройки сервисов за его читаемость. Для работы с YAML понадобится сторонний модуль PyYAML:

import yaml

data = {'project': 'Blog', 'contributors': ['Ivan', 'Alice']}
with open('config.yaml', 'w') as file:
    yaml.dump(data, file)

with open('config.yaml') as file:
    output = yaml.safe_load(file)
print(output['contributors'])

Здесь читаем и пишем почти так же просто, как с JSON.

---

Совет дня: умение “пилотировать” разные форматы данных — универсальный навык. Эти модули и простые паттерны чтения/записи пригодятся и для автоматизации, и для реальных проектов. Пройди этот путь — и данные больше не будут для тебя “черным ящиком”!

В Flask для разделения header и footer можно использовать шаблонизатор Jinja2. Вот как это организовать:

## Базовая структура проекта

myapp/
├── app.py
├── static/
│   ├── css/
│   │   ├── base.css
│   │   ├── home.css
│   │   └── about.css
│   └── js/
│       ├── base.js
│       ├── home.js
│       └── about.js
└── templates/
    ├── base.html
    ├── header.html
    ├── footer.html
    ├── home.html
    └── about.html

## 1. Базовый шаблон (base.html)

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Мой сайт{% endblock %}</title>
    
    <!-- Базовые CSS -->
    <link rel="stylesheet" href="{{ url_for('static', filename='css/base.css') }}">
    
    <!-- Блок для дополнительных CSS -->
    {% block css %}{% endblock %}
</head>
<body>
    <!-- Подключаем header -->
    {% include 'header.html' %}
    
    <!-- Основное содержимое -->
    <main>
        {% block content %}{% endblock %}
    </main>
    
    <!-- Подключаем footer -->
    {% include 'footer.html' %}
    
    <!-- Базовые JS -->
    <script src="{{ url_for('static', filename='js/base.js') }}"></script>
    
    <!-- Блок для дополнительных JS -->
    {% block js %}{% endblock %}
</body>
</html>

## 2. Header (header.html)

<header>
    <nav>
        <ul>
            <li><a href="{{ url_for('home') }}">Главная</a></li>
            <li><a href="{{ url_for('about') }}">О нас</a></li>
        </ul>
    </nav>
</header>

## 3. Footer (footer.html)

<footer>
    <p>&copy; 2024 Мой сайт. Все права защищены.</p>
</footer>

## 4. Страницы с уникальными CSS/JS

home.html:

{% extends "base.html" %}

{% block title %}Главная страница{% endblock %}

{% block css %}
    <link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}">
{% endblock %}

{% block content %}
    <h1>Добро пожаловать на главную страницу!</h1>
    <p>Это содержимое главной страницы.</p>
{% endblock %}

{% block js %}
    <script src="{{ url_for('static', filename='js/home.js') }}"></script>
{% endblock %}

about.html:

{% extends "base.html" %}

{% block title %}О нас{% endblock %}

{% block css %}
    <link rel="stylesheet" href="{{ url_for('static', filename='css/about.css') }}">
    <!-- Можно добавить несколько CSS -->
    <link rel="stylesheet" href="{{ url_for('static', filename='css/special.css') }}">
{% endblock %}

{% block content %}
    <h1>О нашей компании</h1>
    <p>Информация о компании...</p>
{% endblock %}

{% block js %}
    <script src="{{ url_for('static', filename='js/about.js') }}"></script>
    <!-- Можно добавить несколько JS -->
    <script src="{{ url_for('static', filename='js/analytics.js') }}"></script>
{% endblock %}

## 5. Flask приложение (app.py)

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('home.html')

@app.route('/about')
def about():
    return render_template('about.html')

if __name__ == '__main__':
    app.run(debug=True)

## 6. Пример CSS файлов

base.css:

* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

body {
    font-family: Arial, sans-serif;
    line-height: 1.6;
}

home.css:

/* Стили только для главной страницы */
.hero {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    color: white;
    padding: 100px 0;
    text-align: center;
}

about.css:

/* Стили только для страницы "О нас" */
.about-section {
    padding: 50px 0;
    background-color: #f8f9fa;
}

## Дополнительные возможности

### Передача данных в шаблоны

@app.route('/')
def home():
    return render_template('home.html', 
                         page_title="Главная",
                         user="Иван")

### Условное подключение CSS/JS

{% block css %}
    {% if request.endpoint == 'home' %}
        <link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}">
    {% elif request.endpoint == 'about' %}
        <link rel="stylesheet" href="{{ url_for('static', filename='css/about.css') }}">
    {% endif %}
{% endblock %}

### Макросы для повторяющихся элементов

Создайте macros.html:

{% macro render_nav_item(endpoint, text) %}
    <li class="{% if request.endpoint == endpoint %}active{% endif %}">
        <a href="{{ url_for(endpoint) }}">{{ text }}</a>
    </li>
{% endmacro %}

И используйте в header:

{% from "macros.html" import render_nav_item %}

<nav>
    <ul>
        {{ render_nav_item('home', 'Главная') }}
        {{ render_nav_item('about', 'О нас') }}
    </ul>
</nav>

Такой подход позволяет легко поддерживать код, изменять общие элементы в одном месте и добавлять уникальные стили и скрипты для каждой страницы.

- Как использовать свою библиотеку для тестирования Hypothesis

Привет! Это Иван, и сегодня я хочу рассказать тебе про не совсем обычную штуку: как использовать свою библиотеку вместе с Hypothesis. Если ты когда-нибудь писал собственные функции или модули и задумался, “а как их тестировать по-настоящему?”, Hypothesis как раз даст мощный boost для твоих питонячьих тестов.

## Немного про Hypothesis

Hypothesis — это библиотека для property-based тестирования на Python. В отличие от классических юнит-тестов, она генерирует сотни разных входных данных, чтобы “поймать” неожиданные ошибки в твоем коде.

Окей, допустим, у тебя есть свой модуль — например, библиотека для работы с матрицами mymatrix.py:

# mymatrix.py
def add_matrices(a, b):
    return [[x + y for x, y in zip(row_a, row_b)]
            for row_a, row_b in zip(a, b)]

А теперь самое интересное! Давай протестируем его с помощью Hypothesis.

## Подключаем Hypothesis

Сначала установи Hypothesis, если ты этого еще не сделал:

pip install hypothesis

Теперь, создадим файл тестов:

# test_mymatrix.py
from mymatrix import add_matrices
from hypothesis import given
from hypothesis.strategies import lists, integers

@given(
    lists(lists(integers(), min_size=2, max_size=2), min_size=2, max_size=2),
    lists(lists(integers(), min_size=2, max_size=2), min_size=2, max_size=2)
)
def test_add_matrices(matrix_a, matrix_b):
    if len(matrix_a) != len(matrix_b):
        return  # Разные размеры не складываем
    for row_a, row_b in zip(matrix_a, matrix_b):
        if len(row_a) != len(row_b):
            return  # Разная длина строк — тоже пропускаем
    result = add_matrices(matrix_a, matrix_b)
    for i in range(len(matrix_a)):
        for j in range(len(matrix_a[i])):
            assert result[i][j] == matrix_a[i][j] + matrix_b[i][j]

Что здесь происходит? Hypothesis автоматически создает пары матриц 2x2 с целыми числами. Мы проверяем размеры — Hypothesis иногда “подкидывает” данные, которые не соответствуют нашим ожиданиям. Для таких случаев — делаем ранний return.

Это гораздо мощнее вручную написанных тестов:

- Ты не упустишь экзотические случаи, которые не пришли бы в голову!
- Если твоя функция выйдет за границы или возникнет исключение, Hypothesis все расскажет и покажет минимальный пример.

## А если своя библиотека сложная?

Ты можешь создать свои собственные стратегии генерации данных для любых сложных структур! Например, если твои объекты — это словари с обязательными и необязательными полями, Hypothesis вполне справится.

from hypothesis.strategies import composite

@composite
def custom_matrices(draw):
    base = lists(integers(), min_size=3, max_size=3)
    return [draw(base) for _ in range(3)]

Используй свою стратегию вместо стандартной, и все готово для сложных кейсов!

---

С Hypothesis твоя библиотека получит настоящий краш-тест. Я использую его во всех своих проектах — и всегда нахожу неожиданные “сюрпризы” в коде!

Пусть твои тесты работают не на количество, а на качество. Удачи и до встречи — с вами был Иван!