Оптимизация процессов разработки с использованием 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 всё становится доступным. Увидимся в следующем посте ✌️

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

Создание приложений управления освещением с использованием Raspberry Pi и Python.

Привет! Сегодня в нашем блоге — прикладная магия Python, а именно: управление освещением с помощью Raspberry Pi. Это не просто теоретическое упражнение, это настоящий шаг в мир умного дома. Готовы превратить свою лампочку в IoT-устройство? Погнали!

🛠 Что понадобится?

- Raspberry Pi (подойдет даже Zero W)
- Светодиод или реле (если хотите управлять настоящими лампами)
- Резистор на 220 Ом (если светодиод)
- Несколько проводов и макетная плата
- Немного терпения и Python

Подключим светодиод к GPIO-контакту, например, к пину 17. Не забудьте резистор между GPIO и анодом диода, чтобы не сжечь вывод.

Теперь к коду.

📦 Используем библиотеку gpiozero — она значительно упрощает работу с GPIO.

Простейшая версия программы для включения лампочки выглядит так:

from gpiozero import LED
from time import sleep

led = LED(17)

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

Это базовая моргалка, идеальная для проверки подключения.

⚡ А теперь сделаем чуть умнее: управление светом по времени суток. Например, включать освещение после заката.

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

Установка:

pip install astral

Пример:

from gpiozero import LED
from time import sleep
from datetime import datetime
from astral import LocationInfo
from astral.sun import sun

led = LED(17)
city = LocationInfo("Moscow", "Russia", "Europe/Moscow", 55.7558, 37.6173)

def is_dark():
    s = sun(city.observer, date=datetime.now().date())
    now = datetime.now(city.timezone)
    return now < s['sunrise'] or now > s['sunset']

while True:
    if is_dark():
        led.on()
    else:
        led.off()
    sleep(60)

Теперь лампа сама включается вечером и выключается утром — как у настоящих хайтек-грибов 🍄

🎛 Хотите больше интерактива? Подключите веб-интерфейс или контролируйте свет через Telegram-бота. А можно добавить датчик движения — и получить "умный" ночник.

💡 В чем польза?

- Изучаете работу с GPIO
- Используете сторонние модули Python (gpiozero, astral)
- Получаете практическое понимание реального применения Python в IoT

На этом всё! Пусть ваш код будет светлым — во всех смыслах этого слова :)

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

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