Python для начинающих

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

Привет! Сегодня мы поговорим о нейронных сетях — технологии, которая лежит в основе голосовых помощников, систем рекомендаций и даже генераторов картинок. А ещё рассмотрим, как превратить обученную модель в переносимый формат 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 в свой инструментарий. До встречи в следующих постах!

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

📸 Распознавание лиц с DeepFace: просто как селфи Привет! Сегодня мы нырнем в одну из самых захватывающих тем в мире Python — распознавание лиц. Сложно представить, но ещё недавно даже базовая идентификация человека по изображению была задачей уровня искусственного интеллекта. Сегодня это можно сделать в пару строчек кода, благодаря библиотеке DeepFace. Что такое DeepFace? DeepFace — это высокоуровневая обёртка над мощными фреймворками компьютерного зрения: TensorFlow, Keras, PyTorch, OpenCV. Она позволяет с минимальными усилиями проводить: - сравнение лиц, - верификацию и идентификацию пользователей, - определение возраста, пола, эмоций и даже расы. Установка Первым делом установим библиотеку: pip install deepface Также убедитесь, что у вас стоит OpenCV: pip install opencv-python Пример 1: Сравнение двух лиц Допустим, у нас есть две фотографии — хотим понять, на одном ли человеке они сделаны: from deepface import DeepFace result = DeepFace.verify(img1path = "person1.jpg", img2path = "person2.jpg") print("Are they the same person? ", result"verified") Функция verify возвращает словарь с метаданными, но нам интересен ключ "verified", который даст True или False. Пример 2: Анализ лица Можно не только узнать, кто на фото, но и понять, радуется человек или грустит, сколько ему лет и т.п.: from deepface import DeepFace analysis = DeepFace.analyze(imgpath = "portrait.jpg", actions = ["age", "gender", "emotion"]) print(f"Age: {analysis['age']}") print(f"Gender: {analysis['gender']}") print(f"Emotion: {analysis['dominantemotion']}") Все работает «из коробки» — никакой ручной обработки изображений не требуется. Под капотом DeepFace использует несколько моделей для распознавания лиц. По умолчанию применяется VGG-Face, но можно выбрать и другие: Facenet, OpenFace, Dlib, ArcFace и DeepID. Выбор модели зависит от вашей задачи: точность, скорость, размер модели. Пример 3: Распознание лица из набора Хотим найти фото определенного человека среди кучи изображений. Используем функцию find: from deepface import DeepFace results = DeepFace.find(imgpath = "target.jpg", dbpath = "facesdb/") for match in results[0]["identity"]: print("Match found:", match) "facesdb/" — это папка, где лежат известные лица. DeepFace сам сравнивает нужное фото со всеми изображениями из базы и возвращает совпадения. Подойдет ли это для продакшена? DeepFace больше ориентирован на исследовательские или учебные задачи. Но его легко встроить в демонстрационные веб-приложения (например, на Flask) или в Telegram-ботов. Однако для серьезной коммерческой системы лучше оценить производительность и подумать об использовании специализированных сервисов (Face++ или Amazon Rekognition). ⚡ Итого Библиотека DeepFace — отличный способ мгновенно погрузиться в компьютерное зрение без головной боли. Она позволяет: - узнать, одинаковые ли лица на фото, - построить простейшее приложение с авторизацией по лицу, - анализировать эмоции и возраст пользователя. Минимум кода — максимум возможностей. Самое то для python-разработчика, который хочет быстро начать работать с компьютерным зрением — и получать от этого удовольствие. До встречи в следующем посте!

Создание приложений для распознавания лиц с библиоthекой DeepFace

Создание приложений для распознавания лиц с библиоthекой DeepFace

Привет! Сегодня поговорим о технологии, которая лежит в основе видеозвонков, конференц-связи и 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. А пока — экспериментируй!

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

💡 "Обработка и анализ данных с использованием библиотеки 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.

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

Использование встроенных функций и модулей 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. Попробуйте применить приемы из этой статьи к вашему проекту, и, возможно, код, который вы считали неплохим, внезапно станет блестящим!

# Изучение основ рефакторинга кода на 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 и 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 и VVVV

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

   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 — это проще, чем кажется!

Основы использования библиотеки 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. Многозадачность: Для постоянного чтения данных с порта полезно использовать потоки или асинхронный код.

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

Удаление данных Удалить конкретную запись можно с помощью метода 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 в свои приложения и насладитесь преимуществами облачной архитектуры!