Создание и настройка сред тестирования для Python проектов.

🔍 Создание и настройка сред тестирования для Python проектов

Если вы только начинаете путешествие по миру Python, рано или поздно столкнётесь с необходимостью тестировать свой код. И вот тут начинается магия: автоматические тесты, виртуальные окружения, покрытие кода — всё это становится неотъемлемой частью любого серьёзного проекта. Сегодня разберём, как создать и настроить удобную и гибкую среду тестирования, с которой приятно работать.

🎯 Начнем с основ: виртуальное окружение

Работаем только в virtual environment. Это спасёт вас от конфликтов зависимостей и превращения системы в «зоопарк» библиотек.

Создаём окружение:

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

Теперь все зависимости будут установлены локально. Отлично!

🧪 Подключаем pytest

Для начала работы с тестами советую использовать pytest. Он лаконичен, мощен и популярен в сообществе. Установим его:

pip install pytest

Создайте файл с тестами test_math_utils.py:

def add(a, b):
    return a + b

def test_add_positive_numbers():
    assert add(2, 3) == 5

def test_add_negative_numbers():
    assert add(-1, -1) == -2

Запуск всех тестов:

pytest

🔥 Бонус: автопоиск файлов с тестами, читаемые отчёты и подсветка ошибок прямо в терминале!

📦 Организация структуры проекта

Хорошая структура проекта помогает тестированию:

my_project/
│
├── src/
│   └── core.py
├── tests/
│   └── test_core.py
├── requirements.txt
└── pytest.ini

В pytest.ini можно настраивать поведение pytest:

[pytest]
testpaths = tests
python_files = test_*.py

📈 Настройка покрытия кода

Хотите знать, сколько строк вашего кода реально покрыто тестами? Добавьте pytest-cov:

pip install pytest-cov
pytest --cov=src tests/

Результат вас удивит: будет показано, какие строки были выполнены, а какие – нет. Это незаменимо для отслеживания «мертвого» кода.

🔧 Прогон тестов перед коммитом

Используйте pre-commit hooks, чтобы тесты автоматически запускались перед отправкой коммитов. Добавим файл .pre-commit-config.yaml:

repos:
  - repo: https://github.com/pre-commit/mirrors-prettier
    rev: v2.3.2
    hooks:
      - id: prettier
  - repo: https://github.com/pre-commit/mirrors-pylint
    rev: v2.13.9
    hooks:
      - id: pylint
  - repo: https://github.com/pre-commit/mirrors-autopep8
    rev: v1.6.0
    hooks:
      - id: autopep8

Устанавливаем и активируем:

pip install pre-commit
pre-commit install

Теперь каждая попытка зафиксировать изменения будет сопровождаться автоматической проверкой формата и, при желании, запуском тестов.

📚 Резюмируем

- Используйте venv для изоляции сред
- pytest – ваш друг в мире тестов
- Настройте pytest.ini под структуру проекта
- Подключайте pytest-cov для анализа покрытия
- Используйте pre-commit для автоматизации проверок

Грамотно выстроенная среда тестирования экономит часы отладки, делает проект масштабируемым и увеличивает ваше доверие к собственному коду. Успехов! 🚀

Как создавать сценарии и оцифровки для интерактивных фильмов на Python.

Название: Сценарий оживает — пишем интерактивные фильмы на Python

Интерактивное кино — это где пользователь чувствует себя режиссёром. Помните Black Mirror: Bandersnatch? Или игры от Telltale? Хочешь такого же эффекта, но на Python? Легко.

В этом посте я расскажу, как создавать интерактивные сценарии, с поддержкой переходов, ветвлений и даже "оцифровки" сюжета — структуру, по которой можно визуализировать сюжет как дерево.

Ключевая идея — представить сценарий в виде графа, где каждая сцена — это узел, а выбор — это ребро. Для начала создадим структуру сцены.

📦 Основной ингредиент: простая модель сцены

class Scene:
    def __init__(self, text, choices):
        self.text = text
        self.choices = choices  # {'choice_text': next_scene_key}

Каждая сцена включает текст и возможные выборы. Попробуем построить мини-историю.

story = {
    "start": Scene(
        "Ты просыпаешься в лесу. На севере слышны шаги. На юге видишь свет костра.",
        {
            "Пойти на север": "north_path",
            "Пойти на юг": "campfire"
        }
    ),
    "north_path": Scene(
        "Ты натыкаешься на странного мужчину с топором.",
        {
            "Поздороваться": "talk_man",
            "Спрятаться": "hide"
        }
    ),
    "campfire": Scene(
        "Около костра сидят путешественники. Они машут тебе рукой.",
        {
            "Присоединиться": "join_travelers",
            "Убежать в лес": "run_away"
        }
    ),
    # ...
}

Теперь сделаем функцию, которая будет прогонять пользователя через историю.

def play(story, start_key):
    current_key = start_key
    while current_key in story:
        scene = story[current_key]
        print(f"\n{scene.text}\n")
        for i, choice in enumerate(scene.choices.keys(), 1):
            print(f"{i}. {choice}")
        try:
            index = int(input("Выбери действие: ")) - 1
            choice_text = list(scene.choices.keys())[index]
            current_key = scene.choices[choice_text]
        except (IndexError, ValueError):
            print("Неверный выбор. Попробуй снова.")

И запускаем:

if __name__ == "__main__":
    play(story, "start")

📊 Теперь — оцифровка: дерево выбора

Допустим, ты хочешь отрисовать структуру сюжета. Здесь пригодится модуль graphviz.

Установим его:

pip install graphviz

Теперь можно визуализировать сюжет:

from graphviz import Digraph

def export_story_graph(story, filename="story"):
    dot = Digraph()
    for key, scene in story.items():
        dot.node(key, scene.text[:30] + ("..." if len(scene.text) > 30 else ""))
        for choice_text, next_key in scene.choices.items():
            dot.edge(key, next_key, label=choice_text)
    dot.render(filename, format='png', cleanup=True)

export_story_graph(story)

В результате получим PNG-диаграмму с графом всех сцен. Это удобно, когда сценарий становится большим и запутанным.

🧩 Идеи для расширения:

- Добавить условные переходы в зависимости от состояния игрока (что он уже выбрал ранее).
- Сохранять прохождения.
- Автоматическая генерация HTML/Web-интерфейса.
- Генерация сценария из JSON или YAML — удобно авторам без знаний Python.

🎬 Вывод

На Python легко создать интерактивную историю, точнее — движок для неё. Но самый главный ингредиент — твоя фантазия. Python в этом случае — режиссёрская панель и монтажный отсек одновременно. Такое кино ты нигде не купишь — ты его пишешь сам.

Оптимизация процессов разработки с использованием Makefile и Python.

Python и Makefile: друзья или соседи, которые делают вид, что не знакомы? Большинство начинающих разработчиков вообще не знают, что у них под носом скрыт весьма могущественный инструмент автоматизации — Makefile. Если вы всё ещё вручную запускаете тесты, линтеры, форматтеры, и каждый раз вспоминаете, какой командой деплоится скрипт — пора знакомиться с make.

Makefile — это не пережиток C-прошлого. Его можно отлично использовать в проектах на Python, чтобы стандартизировать и автоматизировать повседневные задачи: запуск тестов, линтинг, форматирование кода, сбор документации, и многое другое. Плюс — он кросс-платформенный и не требует установки дополнительных зависимостей.

Давайте рассмотрим, как можно организовать простой Makefile под типичный проект на Python.

Предположим, у нас в проекте есть следующая структура:

my_project/
├── src/
│   └── main.py
├── tests/
│   └── test_main.py
├── requirements.txt
├── Makefile

Вот базовый вариант Makefile, который выполняет часто повторяющиеся задачи:

.PHONY: install test lint format run

install:
 pip install -r requirements.txt

test:
 pytest tests/

lint:
 flake8 src/ tests/

format:
 black src/ tests/

run:
 python src/main.py

Что здесь происходит?

- install — установка зависимостей проекта.
- test — запуск ваших тестов, например, с помощью pytest.
- lint — проверка стиля кода с помощью flake8.
- format — автоматическое форматирование при помощи black.
- run — запуск основного скрипта проекта.

Допустим, вы хотите быстро проверить код перед коммитом. Одной командой вы можете прогнать форматтер, линтер и тесты:

make format lint test

А если проект сложнее? Например, у вас разные настройки для dev и prod окружений. Тогда Makefile спасает и здесь:

run-dev:
 ENV=development python src/main.py

run-prod:
 ENV=production python src/main.py

Или хотите максимально упростить работу в команде? Добавьте цель init:

init: install format lint test

Теперь новому участнику команды достаточно одной команды make init, и он получит всё необходимое для старта.

Особенность Makefile в его декларативности. Вы просто пишете, что хотите сделать, а make разруливает зависимости и порядок выполнения. Даже если вы профи в bash-скриптах, Makefile удобно читается и отлично документирует процессы.

В завершение — если вы думаете, что Makefile — это только для бэкенда или devops-разработчиков, вы удивитесь, как хорошо он встраивается даже в ML-проекты, автоматизируя запуск моделей, сбор данных, преобразования и т.д.

Автоматизация = скорость + надежность. С Makefile вы тратите меньше времени на рутину, и больше — на собственно код. А Python и Makefile — невероятно гармоничная пара, когда нужно наладить процесс, но не хочется городить сложные системы сборки.

Проектирование высоконагруженных систем на базе Python.

Проектирование высоконагруженных систем на базе Python: мифы и реальность

Когда речь заходит о высоконагруженных системах, Python обычно воспринимается с опаской. “Медленный”, “интерпретируемый”, “не подходит для продакшена” — и это лишь малая часть мифов. Но на деле — Python способен справляться с серьёзными нагрузками, если использовать его правильно. Давайте разберёмся, на что он действительно способен и какие инструменты пригодятся.

🐍 Лёгкие, но мощные: FastAPI и Uvicorn

Для создания высокопроизводительного backend-сервиса важно выбрать правильный веб-фреймворк. Flask — хорош, но для серьёзных задач лучше использовать FastAPI. Он построен на Starlette и использует типизацию, что упрощает отладку и повышает читаемость кода.

Пример минимального, но асинхронного API:

from fastapi import FastAPI

app = FastAPI()

@app.get("/ping")
async def ping():
    return {"message": "pong"}

Запуск через Uvicorn:

uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4

Uvicorn — это ASGI-сервер, который обрабатывает запросы асинхронно и масштабируется за счёт запуска нескольких воркеров.

⚙️ Асинхронность = масштабируемость

Python не любит многопоточность из-за GIL (Global Interpreter Lock), но с асинхронным кодом справляется отлично. Используйте asyncio, чтобы обрабатывать тысячи соединений одновременно, например, когда пишите WebSocket-сервер или микросервис, который часто обращается к внешним API.

Пример с aiohttp:

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'https://example.com')
        print(html)

asyncio.run(main())

🧵 Background-задачи и воркеры: Celery, RQ

Если ваш сервис выполняет тяжёлые задачи (например, генерация отчёта или отправка email), лучше выносить их из основного потока. Для этого используют Celery или RQ. Эти библиотеки работают с очередями (Redis, RabbitMQ) и позволяют обрабатывать задачи в фоне.

Пример задачи на Celery:

from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def add(a, b):
    return a + b

Основной сервис отдаёт задачу в очередь, рабочие процессы Celery её исполняют — и ваш API не блокируется.

📦 Кэш как спасение: Redis и Memcached

Часто повторяющиеся вычисления можно кэшировать. Например, если запрос к БД занимает 300 мс, а вы получаете одинаковые данные каждую минуту — кэш устранит задержку. Варианты:

- Redis (популярный, кроссплатформенный, даёт TTL, pub/sub и даже persistent-режим)
- Memcached (чуть быстрее по памяти, но без поддержки сложных типов данных)

Пример с redis-py:

import redis

cache = redis.Redis(host='localhost', port=6379, db=0)

def get_data():
    cached = cache.get("key")
    if cached:
        return cached
    # expensive operation
    result = "expensive_result"
    cache.setex("key", 60, result)
    return result

🧠 Мониторинг и профилирование

Знать узкие места в коде — половина успеха.

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

- cProfile для анализа производительности
- prometheus_client для метрик
- Grafana + Prometheus для визуализации
- Sentry для отслеживания ошибок и задержек

Пример сбора метрик:

from prometheus_client import start_http_server, Summary
import time
import random

REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')

@REQUEST_TIME.time()
def process_request():
    time.sleep(random.random())

if __name__ == '__main__':
    start_http_server(8001)
    while True:
        process_request()

🌐 Масштабирование и развертывание

Когда одна машина уже не тянет, разделяйте:

- API и воркеры — разные контейнеры
- Чтение/запись в БД — через реплики
- Сервис — в k8s или Docker Swarm
- Балансировка — Nginx, HAProxy

Python отлично вписывается в микросервисную инфраструктуру.

💡 Вывод

Python не предназначен быть “голым железом”, как C++, но в грамотных руках — это отличный инструмент для высоконагруженных API, фоновых систем и даже realtime-сервисов. Используйте асинхронность, кэш, очереди, мониторинг — и Python не подведёт.

Создание игр с защитой от читов на Python и PyMunk.

🎮 Python-геймдев и античиты: магия PyMunk под капотом

Вы когда-нибудь задумывались, как в двухмерных играх работают физика и защита от несанкционированного вмешательства? Большинство новичков, погружающихся в разработку игр на Python, в какой-то момент сталкиваются с тем, что их проект слишком легко "взламывается". Давайте разберёмся, как использовать библиотеку PyMunk не только для реалистичной физики, но и в качестве инструмента для защиты вашего игрового мира от читеров.

🛠 Что такое PyMunk

PyMunk — это высокоуровневая обертка над физическим движком Chipmunk2D. Он позволяет просто и понятно внедрять физику в 2D-игры. Но что важнее — PyMunk сам управляет логикой движения объектов, силами и столкновениями. Это значит, что любые попытки напрямую “подкрутить” данные через память или простую модификацию кода станут неэффективны.

🚫 Почему читеры обходят обычную физику

Когда вы пишете игру на Python "на коленке", например:

player.x += 5

Злоумышленнику достаточно изменить значение player.x в отладчике, и его персонаж «телепортируется». Однако если движение объекта вычисляется исключительно в физическом мире движка, вмешательство становится затруднительным.

🧠 PyMunk как физическая истина

Рассмотрим пример, где персонаж управляется через силы, а не напрямую координатами.

import pymunk
import pymunk.pygame_util
import pygame

pygame.init()
screen = pygame.display.set_mode((600, 400))
clock = pygame.time.Clock()
space = pymunk.Space()
space.gravity = (0, 900)

def create_player(space):
    body = pymunk.Body(1, pymunk.moment_for_circle(1, 0, 25))
    body.position = 100, 100
    shape = pymunk.Circle(body, 25)
    shape.elasticity = 0.5
    space.add(body, shape)
    return body

player_body = create_player(space)
draw_options = pymunk.pygame_util.DrawOptions(screen)

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        player_body.apply_force_at_local_point((-1500, 0), (0, 0))
    if keys[pygame.K_RIGHT]:
        player_body.apply_force_at_local_point((1500, 0), (0, 0))
    
    screen.fill((255, 255, 255))
    space.step(1/60)
    space.debug_draw(draw_options)
    pygame.display.flip()
    clock.tick(60)

pygame.quit()

Здесь управление персонажем идёт через applyforceatlocalpoint. Координаты тела нельзя "просто так" изменить — сила и масса диктуют движение. Модифицировать player_body.position вручную — бесполезно: на следующем кадре PyMunk всё пересчитает обратно по физике.

🛡 Античит как побочный бонус

Эта архитектура имеет важное преимущество: вы отделяете “визуал” от “реальности”. Даже если кто-то перехватывает ввод или пытается симулировать нажатие клавиш, он не может точно контролировать координаты игрока. А если добавить проверку состояния тел (например, не прыгнул ли игрок без касания земли), можно отловить и навесить флаг “подозрительного поведения”.

Кроме того, движения можно валидировать сервером (если игра сетевого типа) именно на уровне физических параметров: сила, ускорение, импульс. Сравнить два вектора легче, чем разбираться, почему игрок внезапно оказался в стене.

🔒 Финальные советы

- Никогда не давайте игроку прямого доступа к координатам тел.
- Используйте физику, а не “магические” перемещения.
- Логируйте входящие силы и действия — на редкость полезно в отладке и аналитике.
- PyMunk отлично сочетается с серверной проверкой, если решите двигаться к многопользовательским играм.

Итог: PyMunk — это не просто реалистичные прыжки и катящиеся шарики. Это база для создания устойчивой системы геймплея, где поведение игроков подчиняется законам физики, а не желаниям хакера. Если ищете способ сделать игру устойчивее к взлому — используйте физику как истину.

Использование Apache Storm для обработки потоков данных с Python.

Использование Apache Storm для обработки потоков данных с Python.

🔄 Обработка потоков данных с Python и Apache Storm: первая встреча

Всем привет! Сегодня поговорим о чем-то по-настоящему живом — потоковых данных. Представьте Twitter-ленту, клики пользователей на сайте или датчики в IoT — всё это нескончаемые потоки событий. Для их реального времени обработки часто используют Apache Storm. Он мощный, масштабируемый и работает под лозунгом: “боевой зубастый молниеносный фермер потоков”.

Но у Storm есть коварная особенность — родной язык для написания логики обработки данных в нём это Java. К счастью, есть библиотека streamparse — она позволяет писать topologies на Python и запускать их в Apache Storm. Сегодня покажу, как это работает.

📦 Установка

Для начала убедитесь, что у вас установлен Apache Storm (версии 1.x). Далее установим streamparse:

pip install streamparse

Создаём проект:

sparse quickstart storm_example
cd storm_example

Внутри проекта — готовая структура: папки для Spout и Bolt’ов, настройки, зависимости.

🌪 Что такое Spout и Bolt?

Spout — источник данных. Получает события "снаружи": из файла, очереди или API.

Bolt — обрабатывает данные. Например, парсит JSON, считает статистику, отправляет в БД.

⚡ Пример: считаем слова в потоке

Создадим Spout, который выдаёт предложения:

from streamparse import Spout
import random

class SentenceSpout(Spout):
    def initialize(self, stormconf, context):
        self.sentences = ["hello world", "python storm integration", "stream processing rocks"]

    def next_tuple(self):
        sentence = random.choice(self.sentences)
        self.emit([sentence])

Теперь Bolt, который разбивает предложения на слова:

from streamparse import Bolt

class SplitSentenceBolt(Bolt):
    def process(self, tup):
        sentence = tup.values[0]
        for word in sentence.split():
            self.emit([word])

И ещё один Bolt, который считает слова:

from streamparse import Bolt
from collections import defaultdict

class WordCountBolt(Bolt):
    def initialize(self, conf, ctx):
        self.counts = defaultdict(int)

    def process(self, tup):
        word = tup.values[0]
        self.counts[word] += 1
        self.log(f"{word}: {self.counts[word]}")

🛠 Запускаем локально

Добавим в файл topologies/wordcount.py описание топологии:

from streamparse import Grouping, Topology
from bolts.word_count import WordCountBolt
from bolts.split_sentence import SplitSentenceBolt
from spouts.sentence import SentenceSpout

class WordCountTopology(Topology):
    sentence_spout = SentenceSpout.spec()
    splitter_bolt = SplitSentenceBolt.spec(inputs=[sentence_spout])
    counter_bolt = WordCountBolt.spec(inputs=[splitter_bolt], par=2)

Теперь можно запустить локально:

sparse run

Вы увидите, как Apache Storm обрабатывает поток: предложения → слова → счётчики.

🎯 Зачем это нужно?

Apache Storm — не просто блажь ради распределённости. Он умеет:

- обрабатывать миллионы событий в секунду;
- масштабироваться по серверам;
- обеспечивать отказоустойчивость.

А с помощью streamparse вы сохраняете привычный Python, не углубляясь в джунгли Java.

📌 Вывод

Apache Storm и streamparse позволяют собирать мощные системы потоковой обработки на Python. Это отличный шаг, если вы работаете с реальным временем: логи, метрики, события. Да, он требует установки Java и самого Storm, но в обмен вы получаете надёжный и быстрый фреймворк.

Следующий раз разберём, как подключать Kafka и обрабатывать поток реальных сообщений. А пока — пусть молнии потекут по Python-контактам! ⚡🐍

— Иван.

Создание виртуальных агентов с использованием библиотеки SIMBA.

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

SIMBA (Simple Intelligent Multiagent-Based Architecture) — это легковесный инструмент на Python для моделирования поведения агентов в симулированной среде. Проще говоря, он позволяет вам создавать умных ботов, которые могут принимать решения, взаимодействовать с окружением и друг с другом.

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

Начнем с простого примера: допустим, у нас есть мир, где несколько агентов ищут еду. Каждый агент может видеть окружение, двигаться и принимать решения.

Установка SIMBA:

pip install simba-agents

Теперь создаем базового агента:

from simba.agents import BaseAgent

class ForagerAgent(BaseAgent):
    def __init__(self, name):
        super().__init__(name)
        self.energy = 10

    def decide(self, perception):
        if 'food' in perception:
            return 'eat'
        return 'move_randomly'

    def act(self, action):
        if action == 'eat':
            self.energy += 5
        elif action == 'move_randomly':
            self.energy -= 1

В этом примере у каждого агента есть "энергия". Он смотрит на мир, решает, что делать (если рядом еда — ест, иначе — двигается случайно), и выполняет действие.

Теперь создаем простую среду:

from simba.environment import GridWorld

env = GridWorld(width=10, height=10)
agent = ForagerAgent("Alex")
env.add_agent(agent, position=(5, 5))
env.add_object('food', position=(6, 5))

Запускаем симуляцию:

for _ in range(10):
    perception = env.get_perception(agent)
    action = agent.decide(perception)
    agent.act(action)
    env.step()

Вуаля! У нас есть первый виртуальный агент. Конечно, это ещё не уровень GTA или The Sims, но вы уже можете создавать более сложные поведения: задания, эмоции, даже память!

SIMBA поддерживает и более продвинутые вещи — коммуникацию между агентами, настройку целей и ограничений, сценарии с многими участниками. Всё это можно комбинировать, чтобы строить обучающиеся модели, игровые NPC, симуляции толпы и многое другое.

Почему стоит попробовать?

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

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

В следующий раз придумаем что-то более масштабное — например, колонию роботов на Марсе 😉

На этом всё, с вами был Иван. Программируйте интересно!

Интеграция инженерных моделей в Python-приложения.

Интеграция инженерных моделей в Python-приложения: от сырой формулы до готового сервиса

Когда инженеры говорят про "модель", они чаще всего имеют в виду набор уравнений или алгоритм, описывающий поведение системы. Численное моделирование, теплообмен, механика, электрика, химия — практически любая физическая дисциплина опирается на такие модели. А если нужно сделать из них что-то полезное? Например, веб-сервис расчёта теплообмена для проектировщиков? Здесь в игру вступает Python.

Основной плюс Python в этой задаче — богатство библиотек. Инженеры описывают модель на бумаге, а Python даёт возможность быстро превратить её в работающий код. Сегодня мы посмотрим, как можно встроить инженерную модель в реальное приложение — с минимальными усилиями и максимальной пользой.

Допустим, у нас есть простая модель расчёта теплопередачи через стену:

q = U A (Tinside - Toutside)

Где:
- U — коэффициент теплопередачи (Вт/м²·K),
- A — площадь стены (м²),
- Tinside и Toutside — температуры внутри и снаружи (°C).

Первым делом оформим это в отдельную функцию:

def heat_transfer(U, A, T_inside, T_outside):
    return U * A * (T_inside - T_outside)

Теперь представим, что мы хотим предоставить к этой модели простой API-доступ — например, чтобы инженер мог подставить свои значения и получить результат через браузер. Для этого воспользуемся FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class HeatRequest(BaseModel):
    U: float
    A: float
    T_inside: float
    T_outside: float

@app.post("/calculate_heat/")
def calculate_heat(data: HeatRequest):
    q = heat_transfer(data.U, data.A, data.T_inside, data.T_outside)
    return {"heat_loss": q}

Запускается это всё одной командой:

uvicorn main:app --reload

И вот у нас есть полноценный API, который принимает параметры инженерной модели и возвращает результат.

Далее по вкусу:
- можно добавить сохранение в базе (SQLAlchemy),
- логгирование и валидацию (Pydantic, logging),
- построение графиков (matplotlib, plotly)
- даже экспорт в Excel (openpyxl)

Если модель сложнее и реализована в специализированных пакетах вроде SciPy, pyomo (оптимизационные задачи) или sympy (символьная математика) — всё равно можно завернуть её в API на FastAPI, Flask или даже прямую CLI-утилиту.

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

Заключение? Простая инженерная формула может стать основой для серьёзного приложения, если завернуть её во что-то, что удобно использовать. И Python — прекрасный инструмент для такого превращения.

Настройка и использование приложений для анализа медицинских изображений.

🔥 Медицинские изображения и Python: сила технологий в ваших руках

Привет! Это Иван. Сегодня мы перенесемся в мир медицины — не для постановки диагноза, а чтобы посмотреть, как Python помогает врачам и исследователям анализировать медицинские снимки. Нет, это не искусственный интеллект, заменяющий докторов, а реальные инструменты, которые извлекают информацию из снимков МРТ, КТ и рентгена — быстро и эффективно.

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

- pydicom — работа с DICOM-файлами (медицинский стандарт хранения изображений),
- matplotlib и opencv-python — визуализация и первичная обработка,
- numpy — численные операции,
- scikit-image — продвинутые методы обработки изображений.

📦 Установка:

pip install pydicom opencv-python matplotlib numpy scikit-image

👌 Взгляд на DICOM

Медицинские изображения обычно хранятся в формате DICOM. Давайте откроем одно такое изображение и визуализируем его.

import pydicom
import matplotlib.pyplot as plt

dicom_file = pydicom.dcmread("example.dcm")
image_data = dicom_file.pixel_array

plt.imshow(image_data, cmap="gray")
plt.title("Original DICOM Image")
plt.axis("off")
plt.show()

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

✂️ Немного обработки

Теперь применим фильтр контуров, чтобы выделить аномалии или границы органов.

import cv2
import numpy as np

# Преобразуем данные в формат uint8 (от 0 до 255)
image_uint8 = cv2.convertScaleAbs(image_data)

# Применяем оператор Canny
edges = cv2.Canny(image_uint8, threshold1=50, threshold2=150)

plt.imshow(edges, cmap='gray')
plt.title("Edges Detected")
plt.axis("off")
plt.show()

Такой простой инструмент может быстро подсветить интересующие области радиологу или разработчику ИИ.

🔬 Сегментация

Предположим, нужно выделить определённую область — например, легкие на снимке грудной клетки. Хотите магии? Давайте поработаем с порогами.

from skimage import filters

threshold = filters.threshold_otsu(image_uint8)
binary_mask = image_uint8 > threshold

plt.imshow(binary_mask, cmap='gray')
plt.title("Otsu Segmentation")
plt.axis("off")
plt.show()

Алгоритм Отсу — это способ найти “разумный” порог разделения. В результате получаем бинарное изображение, где нужная область выделяется автоматически.

🙌 Что дальше?

Дальше можно добавлять нейросеть, делать 3D-реконструкции, сохранять результаты в виде отчётов... Но самое важное: инструменты уже в ваших руках. Даже базовая визуализация может помочь исследователю сократить время анализа, а врачу — сфокусироваться на главном.

Не бойтесь сложных тем — с Python всё становится доступным. Увидимся в следующем посте ✌️

— Иван, программист.