Удаление данных

Удалить конкретную запись можно с помощью метода remove():

db.child("users").child("user_1").remove()

---

### Что дальше?

Используя Pyrebase, вы можете синхронизировать данные в реальном времени. Например, Firebase позволяет настроить прослушивание изменений данных:

def stream_handler(message):
    print("Data changed:", message["data"])

db.child("users").stream(stream_handler)

Теперь любое изменение данных в узле users вызовет указанную функцию и отобразит изменения. Это суперспособ делать интерактивные приложения, синхронизирующие данные между клиентами!

---

### Итог

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

Попробуйте встроить Firebase в свои приложения и насладитесь преимуществами облачной архитектуры!

Основы использования библиотеки pySerial для работы с последовательными портами

Основы использования библиотеки pySerial для работы с последовательными портами

Если вы когда-либо работали с устройствами через последовательные порты, будь то микроконтроллеры, сенсоры, или даже старое оборудование, вы знаете, насколько это важный инструмент. Сегодня я хочу рассказать вам о библиотеке pySerial, которая делает взаимодействие с последовательными портами в Python удобным и простым.

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

---

### Что такое pySerial?
pySerial — это библиотека для работы с последовательными портами на самых популярных операционных системах. Она поддерживает Windows, macOS, Linux и даже платформы вроде Raspberry Pi. Поэтому, если вы работаете с UART через USB или прямым подключением, pySerial станет отличным помощником.

Эта библиотека позволяет вам:
1. Открывать и закрывать последовательные порты.
2. Отправлять данные.
3. Принимать данные.
4. Устанавливать скорость передачи, битность, стоп-биты и прочие параметры.

---

### Установка
Чтобы установить pySerial, просто выполните команду:

pip install pyserial

После установки библиотека готова к использованию. Давайте перейдем к примерам.

---

### Пример 1: Открытие порта и отправка данных
Вот простой старт: откроем порт и отправим на него строку Hello, world!.

import serial

# Настройка порта
port = serial.Serial(port='COM3', baudrate=9600, timeout=1)

# Отправка данных
port.write(b'Hello, world!')

# Закрытие порта
port.close()

Разберем ключевые моменты:
- port='COM3' — указывает, какой порт мы открываем (на Linux/Mac используйте имя вроде /dev/ttyUSB0).
- baudrate=9600 — скорость передачи данных в бодах.
- timeout=1 — задаем время ожидания для операций.

Обратите внимание, что для отправки строки необходимо преобразовать её в байты с помощью b'строка'.

---

### Пример 2: Чтение данных с порта
Теперь предположим, что ваше устройство посылает данные, и нам нужно их прочитать. Это легко сделать:

import serial

# Открываем порт
port = serial.Serial(port='COM3', baudrate=9600, timeout=1)

# Чтение данных
data = port.readline()

# Воспроизводим строки (декодируем из байтов)
print(data.decode('utf-8'))

# Закрываем порт после работы
port.close()

Функция readline() считывает строку, заканчивающуюся символом новой строки (\n), а метод decode('utf-8') преобразует байты обратно в строку.

---

### Пример 3: Сканирование доступных портов
Иногда может потребоваться узнать, какие порты доступны. Например, если вы не уверены, какой порт использовать. pySerial предоставляет простой способ сделать это:

from serial.tools import list_ports

# Получаем список портов
ports = list_ports.comports()

# Выводим каждый порт
for port in ports:
    print(f"Found port: {port.device}")

Результатом будет список доступных последовательных портов, например:

Found port: COM3
Found port: COM4

---

### Полезные замечания
1. Конфигурация параметров: Вы можете тонко настроить параметры порта:

   port = serial.Serial(
       port='COM3',
       baudrate=9600,
       bytesize=serial.EIGHTBITS,
       parity=serial.PARITY_NONE,
       stopbits=serial.STOPBITS_ONE
   )
   

2. Обработка ошибок: Если порт занят или недоступен, pySerial выбросит исключение. Всегда оборачивайте операции в блоки try-except для надежности.
3. Многозадачность: Для постоянного чтения данных с порта полезно использовать потоки или асинхронный код.

Вот пример усовершенствованного чтения:

   import threading

   def read_from_port(ser):
       while True:
           data = ser.readline()
           print(data.decode('utf-8'))

   ser = serial.Serial('COM3', 9600)
   thread = threading.Thread(target=read_from_port, args=(ser,))
   thread.start()
   

---

### Заключение
pySerial — это невероятно удобный инструмент, который упрощает взаимодействие с последовательными портами. Будь то проект с Arduino, датчики температуры или промышленный интерфейс — pySerial способен стать вашим универсальным инструментом. Библиотека простая, мощная и активно поддерживается сообществом. Попробуйте её, и вы убедитесь, что работа с последовательными портами в Python — это проще, чем кажется!

Создание аудиовизуальных инсталляций с Python и VVVV

### Создание аудиовизуальных инсталляций с Python и VVVV

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

#### Что такое VVVV?

VVVV — это визуальная среда программирования, созданная для работы в реальном времени с графикой, видео и звуком. Она зарекомендовала себя как мощный и гибкий инструмент в интерактивных инсталляциях. Программирование в VVVV строится на соединении «узлов» линиями, что чем-то напоминает игру с электрическими схемами. Это идеальный выбор для работы с визуализацией, но она недостаточно гибка для более сложных расчетов или предварительной обработки данных. Вот где может пригодиться Python.

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

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

Взаимодействие между Python и VVVV возможно благодаря протоколам, таким как UDP или OSC (Open Sound Control), которые позволяют программам обмениваться данными. Python может генерировать данные в виде чисел, строк, массивов — а VVVV будет использовать их для визуальной интерпретации. Давайте рассмотрим простой пример, где Python и VVVV работают вместе.

#### Пример: Простая звуковая визуализация

Предположим, у нас есть аудиофайл, и мы хотим создать визуализацию, где интенсивность звука влияет на размеры графических объектов в VVVV.

##### Шаг 1: Анализ звука в Python

Для анализа звука используем библиотеку librosa, которая позволяет извлекать полезные аудио-характеристики, например, амплитуду громкости.

import librosa
import socket
import time

audio_path = 'audio.wav'
samples, sample_rate = librosa.load(audio_path)

# Вычисляем амплитуды громкости со сглаживанием
energy = librosa.feature.rms(y=samples)[0]

# Настраиваем передачу данных через UDP
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_address = ("127.0.0.1", 5555)

# Передача данных
for value in energy:
    data = str(value).encode('utf-8')
    sock.sendto(data, server_address)
    time.sleep(0.1)  # Пауза между отправками

Здесь мы извлекаем массив громкости из аудиофайла и передаем значения в VVVV через UDP-протокол.

##### Шаг 2: Получение данных в VVVV

В VVVV мы создаем узел UDP (Network Server), который будет принимать данные от Python. Эти данные мы преобразуем в визуальные эффекты, используя ноды-генераторы.

1. Вставьте UDP (Network Server) и настройте порт 5555.
2. Подключите ноды для преобразования данных (например, Tokenize и AsValue).
3. Используйте значения для управления Scale или Transform параметрами визуальных объектов.

На выходе вы получите графический объект (например, круг), который изменяет размер в зависимости от громкости аудио. Разумеется, это базовый пример, который можно легко расширить.

#### Возможности для творчества

Вот несколько идей, как можно развить эту концепцию:
- Генеративная графика: Используйте данные, полученные Python, для создания сложных узоров и текстур.
- Интерактивность: Подключите Python к датчику, например, микрофону или камере, чтобы зритель влиял на инсталляцию своим присутствием.
- Алгоритмические изображения: Используйте библиотеки, такие как numpy и matplotlib, чтобы генерировать уникальные визуальные данные.

#### Заключение

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

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

Изучение основ рефакторинга кода на Python для повышения его качества

# Изучение основ рефакторинга кода на Python для повышения его качества

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

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

Давайте разберемся, почему рефакторинг важен, и посмотрим на его базовые принципы с примерами на Python.

## Почему стоит заниматься рефакторингом

Вот несколько причин, почему рефакторинг кода так важен:
1. Читаемость — Код, написанный с учетом лучших практик, будет понятен вам и другим разработчикам через месяц, год или даже спустя десятилетие.
2. Уменьшение технического долга — Каждый костыльный обходной путь или нелогичная конструкция увеличивает сложность поддержания проекта.
3. Легкость добавления новых функций — Чистый код проще адаптировать под изменения.
4. Предотвращение багов — Лаконичный и понятный код легче тестировать и отлаживать.

Теперь перейдем от теории к практике. Верх рефакторинга — это использование простых, но мощных подходов. Покажем несколько приемов.

---

### 1. Упрощение условий
Многословные конструкции if-elif-else могут быть реорганизованы, чтобы повысить их читаемость.

До рефакторинга:

def evaluate_score(score):
    if score >= 90:
        return "Excellent"
    elif score >= 75:
        return "Good"
    elif score >= 50:
        return "Average"
    else:
        return "Poor"

После рефакторинга:

def evaluate_score(score):
    if score >= 90: return "Excellent"
    if score >= 75: return "Good"
    if score >= 50: return "Average"
    return "Poor"

Простое удаление лишнего elif делает код более лаконичным и все равно сохраняет его логику.

---

### 2. Избавление от дублирования кода
Дублирование — враг разработчика. Оно приводит к путанице и увеличивает затраты на сопровождение.

До рефакторинга:

def calculate_area_rectangle(width, height):
    return width * height

def calculate_area_square(side):
    return side * side

После рефакторинга:

def calculate_area(shape, **dimensions):
    if shape == "rectangle":
        return dimensions['width'] * dimensions['height']
    if shape == "square":
        return dimensions['side'] ** 2

Теперь мы можем добавить новые фигуры в одну функцию без копирования кода.

---

### 3. Разделение задач
Если функция начинает раздуваться до огромных размеров, это знак, что её пора разбить на более мелкие части.

До рефакторинга:

def process_user_data(data):
    for user in data:
        name = user["name"].capitalize()
        print(f"Processing user: {name}")
        user['id'] = generate_unique_id(user)
        save_user_to_db(user)

После рефакторинга:

def capitalize_name(name):
    return name.capitalize()

def process_user(user):
    user["name"] = capitalize_name(user["name"])
    user["id"] = generate_unique_id(user)
    save_user_to_db(user)

def process_user_data(data):
    for user in data:
        print(f"Processing user: {user['name']}")
        process_user(user)

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

---

### 4.

Использование встроенных функций и модулей Python
Иногда мы создаем решения «с нуля», даже когда Python предоставляет готовые инструменты.

До рефакторинга:

numbers = [1, 2, 3, 4, 5]
squared = []
for num in numbers:
    squared.append(num ** 2)

После рефакторинга:

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))

Или, еще лучше:

squared = [x ** 2 for x in numbers]

Генераторы списков делают код не только короче, но и более читаемым.

---

### 5. Сделайте код самодокументируемым
Если ваши переменные, функции и классы названы понятно, кода без комментариев станет больше читаемым.

Плохое название:

def calc(a, b):
    return a / b

Хорошее название:

def calculate_ratio(numerator, denominator):
    return numerator / denominator

Называйте вещи своими именами, и вашему будущему «я» (как и коллегам) будет проще разобраться.

---

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

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

Обработка и анализ данных с использованием библиотеки xarray

💡 "Обработка и анализ данных с использованием библиотеки xarray"

Если вы когда-нибудь сталкивались с многомерными данными в формате NetCDF, HDF5 или Grib, то, скорее всего, вам не раз приходилось морщиться, разбираясь в массивах, индексах и измерениях. NumPy — мощный инструмент, но когда дело доходит до обработки реальных научных данных с координатами, метаданными и измерениями вроде времени, высоты, широты и долготы, руки сразу тянутся за чем-то более удобным. Знакомьтесь, xarray — библиотека, созданная словно специально для этого случая.

Xarray — это библиотека для работы с многомерными метками массивов. По своей сути, она расширяет возможности NumPy-ndarray, добавляя к ним координаты, имена измерений и удобную навигацию по данным. Она вдохновлена архитектурой pandas, но ориентируется на данные с большим количеством измерений: климатические модели, спутниковые наблюдения, сложные временные ряды и многое другое.

Основные структуры данных — это DataArray и Dataset.

🧩 DataArray — это аналог Series или одного массива NumPy, но с координатами и метаинформацией.
📦 Dataset — это коллекция связанных DataArray, грубо говоря — как DataFrame в pandas, но для многомерных данных.

Рассмотрим на примере:

import xarray as xr
import numpy as np

times = np.arange('2022-01', '2022-04', dtype='datetime64M')
locations = 'Moscow', 'London', 'New York'

data = xr.DataArray(
np.random.rand(3, 3),
coords={'time': times, 'city': locations},
dims='time', 'city'
)

print(data)

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

🧪 Теперь давайте проведем анализ данных. Предположим, что массив содержит температуру, и мы хотим узнать среднюю температуру по каждому городу:

meantemp = data.mean(dim='time')
print(meantemp)

Или посчитаем, в каком месяце была максимальная температура для каждого города:

maxtemp = data.idxmax(dim='time')
print(maxtemp)

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

Подробнее — загрузка из NetCDF:

ds = xr.opendataset('airtemperature.nc')
print(ds)

Теперь вы можете исследовать содержимое, проникать в измерения, строить графики, фильтровать значения:

ds.sel(time='2022-01-15', method='nearest')
ds'air'.mean(dim='lat', 'lon').plot()

И, конечно, совместимость с pandas и NumPy — бесшовная. DataArray легко превращается в DataFrame при необходимости:

df = data.todataframe().resetindex()
print(df.head())

Xarray активно используется в метеорологии, океанологии и науках о Земле, но он может пригодиться и в работе с машинным обучением, и просто с временными рядами. Если ваши данные превышают два измерения — забудьте про громоздкие NumPy-аксессоры. Xarray — это ваш новый лучший друг.

✨ Итоги:

- Удобная работа с многомерными данными с именованными координатами.
- Поддержка времени и стандарта CF (важно для научных данных).
- Отличная интеграция с dask (для "ленивой" параллельной обработки).
- Поддержка чтения и записи современных форматов: NetCDF, Zarr, HDF5.

Если в pandas вы чувствовали себя Шерлоком, то в xarray вы — уже профессор в Лондоне с доступом к спутниковым данным. Попробуйте — и удивитесь, насколько сложные штуки можно делать просто, прозрачно и pythonic.

Введение в работу с протоколом WebRTC на Python

Привет! Сегодня поговорим о технологии, которая лежит в основе видеозвонков, конференц-связи и P2P-коммуникаций в браузере — о WebRTC. Но не спеши закрывать вкладку: мы разберёмся, как управлять этим «веб-монстром» с помощью Python. Да, ты не ослышался — WebRTC и Python вполне могут подружиться!

Что такое WebRTC?

WebRTC (Web Real-Time Communication) — это открытый протокол и набор API, позволяющих браузерам, мобильным и десктопным приложениям обмениваться аудио, видео и данными в реальном времени без необходимости в сторонних плагинах. Всё безопасно, peer-to-peer и максимально быстро.

Python сам по себе не может напрямую управлять WebRTC-соединениями в браузере (всё-таки WebRTC — это технология клиентская), но есть замечательная библиотека, которая позволяет Python участвовать в процессе как полноценному участнику медиасессий. Встречайте: aiortc!

aiortc — это чистая реализация WebRTC и ORTC на Python с поддержкой asyncio. С её помощью можно написать своего собственного WebRTC-пира, сервер для видеочатов, обработчик видео из браузера и многое другое.

Что умеет aiortc:

- Принимать и отправлять аудио/видео
- Работать с data channel’ами
- Поддерживает SDP, ICE и STUN
- Совместим с браузерами вроде Chrome и Firefox

Минимальный пример: обмен видеопотоком между браузером и Python-сервером

Установим:

pip install aiortc opencv-python

Теперь пишем Python-сервер, который получает видео с браузера и отображает (или записывает) его через OpenCV:

from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
import cv2
import asyncio
import json
from aiohttp import web

pc = RTCPeerConnection()

@pc.on("track")
def ontrack(track):
if track.kind == "video":
@track.on("frame")
async def onframe(frame):
img = frame.tondarray(format="bgr24")
cv2.imshow("Received Video", img)
cv2.waitKey(1)

async def offer(request):
params = await request.json()
offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
await pc.setRemoteDescription(offer)
answer = await pc.createAnswer()
await pc.setLocalDescription(answer)

return web.Response(
contenttype="application/json",
text=json.dumps(
{"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}
),
)

app = web.Application()
app.router.addpost("/offer", offer)

web.runapp(app, port=8080)

На стороне браузера можно использовать стандартный WebRTC API для отправки видео (обычно через getUserMedia, RTCPeerConnection и fetch).

Что важно: aiortc — это не сервер-сигнализации. Он не занимается организацией "встреч" между пользователями. Этим должен заниматься отдельный механизм — WebSocket или HTTP обмен сообщениями (как в примере выше).

Зачем нужен Python в WebRTC?

- Обработка видео в реальном времени (например, нейросетями)
- Получение видеопотока от клиента и передача его другому клиенту
- Логирование, хранение или трансляция через другие каналы
- Строительство полной медиа-платформы

Тем, кто работает с системами видеонаблюдения, ML/AI в потоковом видео или хочет написать Telegram-бота, принимающего живое видео с браузера, aiortc открывает массу возможностей.

WebRTC на Python — это не просто "можно", это "нужно", когда ты хочешь контролировать всё на серверной стороне и не ограничиваться браузерной логикой. aiortc даёт тебе мощный инструмент, чтобы творить магию реального времени на Python-стеке.

В следующей статье — сделаем свой минимальный видеочат с Python и WebRTC. А пока — экспериментируй!

Основы работы с нейронными сетями и их развертывания с ONNX

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

Что такое нейронная сеть?

Грубо говоря, нейронная сеть — это алгоритм, вдохновлённый работой мозга. Она получает входные данные, обрабатывает их через слои искусственных нейронов и выдаёт результат. Например, можно скормить ей изображение кошки, и она скажет: "Это кошка". Главное — сначала научить её это делать.

Создадим простую модель классификации изображений с помощью PyTorch. Для начала установим нужные библиотеки:

pip install torch torchvision onnx onnxruntime

Допустим, у нас есть модель, распознающая рукописные цифры (как в MNIST). Пример:

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
def init(self):
super(SimpleNet, self).init()
self.fc1 = nn.Linear(28 28, 128)
self.fc2 = nn.Linear(128, 10)

def forward(self, x):
x = x.view(-1, 28 28)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x

model = SimpleNet()
dummyinput = torch.randn(1, 1, 28, 28)

Теперь самое интересное — экспорт модели в формат ONNX:

torch.onnx.export(
model,
dummyinput,
"simplenet.onnx",
inputnames=['input'],
outputnames='output',
dynamicaxes={'input': {0: 'batchsize'}, 'output': {0: 'batchsize'}},
opsetversion=11
)

Файл simplenet.onnx теперь можно загружать практически куда угодно: в C++, в браузер через WebAssembly, или, скажем, в мобильное приложение.

А как запустить модель ONNX? Используем библиотеку onnxruntime:

import onnxruntime as ort
import numpy as np

session = ort.InferenceSession("simplenet.onnx")
inputdata = np.random.rand(1, 1, 28, 28).astype(np.float32)
preds = session.run(None, {"input": inputdata})
print("Prediction:", np.argmax(preds0))

Вуаля — мы запустили нейросеть без PyTorch! Быстро, кроссплатформенно и с минимальными зависимостями.

Зачем нужен ONNX?

- Универсальность: перенос обученной модели между фреймворками (PyTorch → TensorFlow, например).
- Лёгкость развёртывания: можно запускать модели на сервере, в мобильных или web-приложениях.
- Оптимизация: многие среды умеют оптимизировать ONNX-модели — например, ускорять инференс на CPU или GPU.

Советы напоследок

- Следите за версией opset при экспорте — разные движки могут поддерживать разные спецификации.
- Если модель не экспортируется напрямую, сначала упростите архитектуру или проверьте поддержку нестандартных слоёв.
- ONNX можно визуализировать через Netron (https://netron.app/) — отличный инструмент для отладки моделей.

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

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

Как написать HTTP сервер с использованием модуля http.server

Привет, друзья! Сегодня мы нырнём в удивительно простой, но мощный модуль стандартной библиотеки Python — http.server. С его помощью можно всего в несколько строк кода поднять настоящий HTTP-сервер. Без сторонних зависимостей, фреймворков или танцев с бубном.

Зачем это нужно? Например, для локальной отладки веб-приложений, быстрой раздачи файлов с вашей машины, тестирования API или даже написания простейшего backend'а. Итак, приступим!

Минимальный HTTP-сервер за 10 секунд

Внимание, магия! Вот базовый пример:

from http.server import SimpleHTTPRequestHandler, HTTPServer

server_address = ('', 8000)
httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
print("Server running on http://localhost:8000")
httpd.serve_forever()

Сохрани файл как simpleserver.py, запусти, и зайди в браузере на http://localhost:8000. Ты увидишь содержимое текущей директории — по сути, это файловый сервер “из коробки”.

Обратите внимание:

- Пустая строка в serveraddress означает, что сервер слушает все IP адреса.
- Port 8000 — дефолтный, можно выбрать любой другой.

А что если захотим свой ответ, а не просто отдавать файлы?

Создадим собственный обработчик:

from http.server import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-Type', 'text/html')
        self.end_headers()
        message = "<h1>Hello, Python HTTP Server!</h1>"
        self.wfile.write(message.encode('utf-8'))

server_address = ('', 8080)
httpd = HTTPServer(server_address, MyHandler)
print("Custom server running on http://localhost:8080")
httpd.serve_forever()

Теперь при любом GET-запросе сервер вернёт простую HTML-страничку. Всё управляется методом doGET. Можно переопределить и другие: doPOST, doPUT, doDELETE.

Парсим путь и параметры

Допустим, мы хотим разные ответы в зависимости от URL. Используем модуль urllib:

from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        parsed_url = urlparse(self.path)
        path = parsed_url.path
        query = parse_qs(parsed_url.query)

        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()

        if path == '/hello':
            name = query.get('name', ['stranger'])[0]
            response = f"Hello, {name}!"
        else:
            response = "Unknown path."

        self.wfile.write(response.encode('utf-8'))

server_address = ('', 9000)
httpd = HTTPServer(server_address, MyHandler)
print("Query-enabled server running on http://localhost:9000")
httpd.serve_forever()

Попробуйте перейти на http://localhost:9000/hello?name=Alice — сервер ответит: Hello, Alice!

Нюансы и ограничения

- http.server идеально подходит для простых задач, но не заменит полноценный фреймворк вроде Flask или FastAPI.
- Он однопоточный — один запрос за раз. Не подходит для продакшена.
- Без HTTPS — только HTTP.

Зато:

- Не требует установки — есть в любом Python.
- Отличен для отладки, обучения и мини-экспериментов.

Вывод

http.server — как швейцарский нож для любого Python-разработчика. Минимум кода — максимум пользы. Иногда лучшая магия — это простота.

До встречи в следующем посте!

Работа с генетическими алгоритмами в Python: библиотека DEAP

Привет! Сегодня поговорим о теме, которая звучит так, будто была взята из научной фантастики, но на деле имеет массу практического применения — генетические алгоритмы. Если ты когда-нибудь задумывался, как можно применять принципы естественного отбора для решения задач оптимизации — читай дальше. Мы познакомимся с удивительной библиотекой DEAP (Distributed Evolutionary Algorithms in Python), которая делает работу с эволюционными алгоритмами на Python простой и вдохновляющей.

Зачем вообще нужны генетические алгоритмы? Представь, что тебе нужно найти оптимальное решение в огромном пространстве возможных вариантов — классический перебор займёт вечность. Генетические алгоритмы работают по-другому: они "эволюционируют" популяцию решений, отбирая лучших "индивидов", скрещивая их и мутируя. Этот подход широко используется в инженерии, дизайне нейросетей, игровой индустрии и даже в экономике.

Теперь к практике. Устанавливаем DEAP:

pip install deap

Допустим, мы хотим найти максимум функции:

f(x) = x sin(x), где x от 0 до 10

Вот пример минимального рабочего кода на DEAP:

from deap import base, creator, tools, algorithms
import random
import math

# Создаем типы для нашей задачи
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()

# Гене — это просто одно число
toolbox.register("attr_float", random.uniform, 0, 10)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, 1)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

# Целевая функция
def evaluate(individual):
x = individual[0]
return x math.sin(x),

toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)

# Запуск эволюции
def run():
population = toolbox.population(n=50)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("max", max)
stats.register("avg", lambda x: sum(x)/len(x))

population, log = algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, stats=stats, verbose=False)

best = tools.selBest(population, 1)0
print(f"Best individual: x = {best0:.3f}, f(x) = {evaluate(best)0:.3f}")

run()

Что здесь происходит:
- Мы создаем индивидуумов — списки, содержащие одно число (значение x).
- Определяем функцию приспособленности evaluate.
- Используем стандартные операторы скрещивания (cxBlend) и мутации (mutGaussian).
- Запускаем эволюцию и находим наилучшее решение после 40 поколений.

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

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

До встречи в следующем посте!