Например, для подсчета сложных траекторий объектов:

import numpy as np

def calculate_trajectory(angle_degrees, speed):
    g = 9.8  # ускорение
    angle_radians = np.radians(angle_degrees)
    time = np.linspace(0, 2 * speed * np.sin(angle_radians) / g, num=200)
    x = speed * np.cos(angle_radians) * time
    y = speed * np.sin(angle_radians) * time - 0.5 * g * time**2
    return x, np.maximum(y, 0)

x, y = calculate_trajectory(45, 20)  # угол и скорость
print(x)
print(y)

С numpy легко обрабатывать комплексные числовые модели.

---

### Шаг 3: Стиль и дизайн

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

---

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

Python - универсальная и мощная платформа для создания обучающих программ и симуляций. С помощью библиотек, таких как matplotlib, pygame и numpy, вы можете буквально оживить абстрактные концепции и принести больше ясности людям, изучающим вашу тему. Надеюсь, приведенные примеры вдохновят вас на создание собственных интересных проектов!

Подключение Python-приложений к системам обмена сообщениями (MQTT).

### Подключение Python-приложений к системам обмена сообщениями (MQTT)

Представьте себе мир, где устройства, программы и сервисы ведут активный диалог, мгновенно обмениваясь данными. Этот мир уже существует благодаря технологиям передачи сообщений. Одной из самых популярных и увлекательных технологий, стоящих за этим, является MQTT (Message Queuing Telemetry Transport). Это легковесный протокол, созданный для передачи сообщений между устройствами с минимальными затратами. Если вы хотите подключить своё Python-приложение к такой системе, добро пожаловать в этот краткий гайд!

---

### Что такое MQTT и зачем он нужен?

MQTT — это протокол обмена сообщениями, работающий поверх TCP/IP. Его главное преимущество — лёгкость и оптимизация для работы с ограниченными ресурсами (например, микроконтроллерами). В основе MQTT лежит модель "публикация/подписка". Представьте это как радиовещание: кто-то отправляет сообщения (publisher), другие подписываются на их получение (subscriber), а всю передачу через каналы (topics) управляет центральный сервер — так называемый broker.

Пример применения? Умные дома: лампочка отправляет данные о своём состоянии, а ваш смартфон из другой комнаты подписывается на это событие и переводит вывод сообщения в удобный интерфейс.

---

### Подключаем Python к MQTT

Для работы с MQTT в Python есть замечательная библиотека — Paho MQTT. Она создана специально для взаимодействия с брокерами MQTT.

Перед началом установите библиотеку:

pip install paho-mqtt

---

### Минимальный пример работы с MQTT

Начнём с отправки сообщения к брокеру. Сначала нужно подключиться и отправить данные в определённый канал (topic):

import paho.mqtt.client as mqtt

# Функция обратного вызова при успешном подключении
def on_connect(client, userdata, flags, rc):
    print("Connected with result code:", rc)
    # Подписка на канал (topic)
    client.subscribe("test/topic")

# Функция обратного вызова при получении сообщения
def on_message(client, userdata, msg):
    print(f"Received message: {msg.payload.decode()} on topic: {msg.topic}")

# Создаём MQTT-клиент
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# Подключаемся к брокеру (например, test.mosquitto.org)
client.connect("test.mosquitto.org", 1883, 60)

# Публикуем сообщение
client.publish("test/topic", "Hello, MQTT!")

# Поддерживаем соединение
client.loop_forever()

---

### Что тут происходит?
1. Создание клиента MQTT: Клиент — это наше приложение, которое будет публиковать (отправлять) или подписываться на сообщения.
2. Подключение к брокеру: В данном примере используется публичный брокер Mosquitto (test.mosquitto.org), который можно использовать для тестов без регистрации.
3. Подписка и публикация: Мы подписываемся на канал test/topic, а также публикуем туда сообщение "Hello, MQTT!".
4. Обработчики событий: on_connect и on_message — это функции обратного вызова, которые срабатывают при подключении и при получении сообщения соответственно.

---

### Расширяем функционал

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

Реализуем простой пример:

import time
import random
import paho.mqtt.client as mqtt

# Функция подключения
def on_connect(client, userdata, flags, rc):
    print("Connected with result code:", rc)
    client.subscribe("sensor/temperature")

# Публикуем данные о температуре каждые 5 секунд
def publish_temperature():
    while True:
        temperature = random.uniform(20.0, 30.0)  # Генерируем случайную температуру
        client.publish("sensor/temperature", f"{temperature:.2f}")
        print(f"Published temperature: {temperature:.2f}")
        time.sleep(5)

client = mqtt.Client()
client.on_connect = on_connect

client.connect("test.mosquitto.org", 1883, 60)

# Запускаем публикацию (не забывайте, что loop_forever() блокирует поток)
publish_temperature()
client.loop_forever()

Теперь наш скрипт будет каждые 5 секунд отправлять случайное значение в канал sensor/temperature.

---

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

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

Независимо от того, планируете ли вы построить умный дом, настроить системы мониторинга или просто хотите научиться чему-то новому — теперь у вас есть всё, чтобы начать! 👍

Использование библиотек на базе C/C++ для оптимизации Python-кода.

Использование библиотек на базе C/C++ для оптимизации Python-кода

Привет, друзья! Сегодня я хочу поговорить об одной из самых мощных возможностей Python, которую часто недооценивают или просто не замечают новички: это интеграция с библиотеками, написанными на C и C++. "Зачем, — спросите вы, — если Python уже и так крут?" Всё просто: Python, несмотря на свою универсальность и простоту, имеет слабые стороны, и одна из них — скорость выполнения кода, особенно в вычислениях с большими объемами данных. Здесь на помощь приходят библиотеки, созданные на базе C/C++. Они эффективно решают задачки, недоступные Python ни по быстродействию, ни по ресурсам.

Не пугайтесь, вам не придётся писать что-то на C или C++. Однако вы научитесь использовать уже готовые решения, которые сделают ваш код в разы быстрее. Рассмотрим всё это на примерах.

### Зачем вообще нужны такие библиотеки?

Суть в том, что Python управляет всем через интерпретатор, а он, в свою очередь, далеко не быстр. Чтобы ускорить процессы, разработчики используют интерфейсы или обёртки для высокопроизводительного кода на C и C++. Эти библиотеки прекрасно интегрируются с Python, сохраняя его удобство. Теперь давайте обсудим несколько популярных библиотек, которые вы можете попробовать.

---

### 1. NumPy: мощь линейной алгебры
NumPy — это библиотека для работы с многомерными массивами и матрицами, написанная на C. Это, по сути, стандарт де-факто для научных вычислений на Python.

Пример:

import numpy as np

# Обычное перемножение массивов в Python
data = [i for i in range(1, 100000)]
result = [x * 2 for x in data]

# А теперь NumPy
data_np = np.array(data)
result_np = data_np * 2

print("With NumPy:", result_np[:5])

Без NumPy вы бы либо ждали дивиденды от медленных циклов, либо писали C-код самостоятельно. С NumPy обработка больших данных становится быстрее в десятки раз.

---

### 2. SciPy: для сложностей посложнее
SciPy логично дополняет NumPy и позволяет решать более сложные задачи: от работы с сигналами и изображениями до численных интегралов и оптимизации. Он тоже базируется на C, что делает его сверхбыстрым.

Пример:

from scipy.integrate import quad

# Интеграл от функции x^2 на интервале [0, 5]
result, _ = quad(lambda x: x**2, 0, 5)

print("Integration result:", result)

Такой код исчисляет интеграл буквально за доли секунды благодаря реализации на C.

---

### 3. Pygame: ускоренная работа с графикой
Если вы разработчик игр, то вы наверняка слышали про Pygame. Эта библиотека использует SDL, написанный на C, чтобы максимально быстро работать с рендерингом графики.

Пример:

import pygame

pygame.init()
screen = pygame.display.set_mode((400, 300))

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

    screen.fill((0, 0, 0))
    pygame.display.flip()

pygame.quit()

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

---

### 4. Pybind11 и Cython: пишем немного на C
Если готовые решения вас не устраивают, то вы можете ускорить свой код самостоятельно. Pybind11 и Cython позволяют интегрировать код C/C++ непосредственно в Python. Например, критически важные функции могут быть написаны на C/C++, а остальной же код сохраняет пайтоновскую читабельность.

Пример с Cython (псевдокод для понимания):

# пример ключевого участка
# компилируем и вставляем в Python
cdef int add(int a, int b):
    return a + b

Это гибко и удобно, особенно если вы пишете что-то вычислительно затратное.

---

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

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

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

Как говорится, Python + C = 🔥! 🚀

Работа с распределенными системами: Введение в Dask и система координат.

# Работа с распределенными системами: Введение в Dask и система координат

Представьте, что вы пытаетесь выстроить огромный дом из кирпичей в одиночку. Груда материалов перед вами бесконечна, а сроки сжимаются. Но что, если вы позовете команду строителей, каждый из которых возьмет по небольшой кучке кирпичей и начнет работать вместе с вами? Именно так работает Dask — библиотека Python, которая помогает распределять работу между несколькими "строителями", чтобы задачи выполнялись быстрее и эффективнее.

Сегодня мы разберем, чем хорош Dask, почему он нужен в современном программировании, а также рассмотрим небольшие примеры его применения.

---

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

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

Основные преимущества Dask:
- Масштабируемость. Используйте Dask на локальном компьютере или распределите нагрузки на кластер.
- Совместимость. Он хорошо интегрируется с популярными библиотеками Python, такими как NumPy, pandas или scikit-learn.
- Ленивая загрузка. Dask не выполняет вычисления, пока это не потребуется, оптимизируя использование ресурсов.

---

## Где это используется?

Dask нашел применение во многих областях: больших данных, машинном обучении, аналитике и даже обработке изображений. Допустим, у вас есть миллионы строк в CSV-файле, которые pandas обработать не может из-за ограничения оперативной памяти. С Dask вы можете не беспокоиться — он «бережно» загружает данные частями и позволяет вам работать с массивами, которые превышают объем оперативной памяти.

---

## Пример 1: Обработка больших данных с Dask DataFrame

Если вы работаете с pandas, то работа с Dask будет интуитивно понятна, потому что API у них похожи. Рассмотрим пример:

import dask.dataframe as dd

# Читаем большой CSV-файл
df = dd.read_csv('large_dataset.csv')

# Фильтруем данные
filtered_df = df[df['value'] > 1000]

# Считаем среднее значение в столбце
mean_value = filtered_df['value'].mean().compute()

print(f"Среднее значение: {mean_value}")

Что здесь происходит?
1. dd.read_csv загружает файл частями, не перегружая оперативную память.
2. Методы, такие как mean, работают лениво, то есть вычисления не происходят до вызова .compute(). Это позволяет оптимизировать процесс.

---

## Пример 2: Распределенные массивы с Dask Array

Dask Array — это аналог NumPy, но для больших многомерных массивов. Представьте, что вы хотите вычислить сумму всех элементов гигантского массива. В NumPy это может съесть всю оперативную память, но Dask легко справится:

import dask.array as da

# Создаем большой массив, распределенный по частям
big_array = da.random.random((10000, 10000), chunks=(1000, 1000))

# Считаем сумму элементов
array_sum = big_array.sum().compute()

print(f"Сумма элементов: {array_sum}")

Ключевая особенность здесь — параметр chunks=(1000, 1000). Он разбивает массив на части, которые можно обрабатывать параллельно.

---

## Система координат Dask

Когда вы работаете с Dask, вам важно понимать, как задачи распределяются. Представьте это как систему координат: у вас есть множество задач (точек), и каждая из них может выполняться на разных узлах вашего кластера (координатах). Dask создает граф задач (task graph), где каждая точка зависит от ранее выполненных задач.

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

Чтобы визуализировать граф задач, можно использовать встроенные инструменты:

from dask import delayed
import dask
from dask.visualize import visualize

@delayed
def task1(x):
    return x + 1

@delayed
def task2(x):
    return x * 2

@delayed
def task3(x, y):
    return x + y

# Создаем граф задач
x = task1(5)
y = task2(10)
z = task3(x, y)

# Визуализируем граф
visualize(z, filename='task_graph')

---

## Почему стоит использовать Dask?

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

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

Разработка геоинформационных систем (ГИС) приложений с Folium.

Геоинформационные системы (ГИС) - это мощный инструмент для анализа, визуализации и управления данными, связанными с географическими объектами. От создания интерактивных карт до нанесения сложных пространственных данных - ГИС-приложения находят применение в самых разных областях, от логистики до экологии. Но как начать с этим работать в Python? Ответ прост: модуль Folium.

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

Folium - это библиотека Python, которая облегчает процесс создания интерактивных карт, выстраивая на них визуализацию данных. Секрет её простоты заключается в том, что под капотом Folium использует популярную JS-библиотеку Leaflet.js, что позволяет объединить мощь Python и удобство работы с картами в вебе. При этом вам не нужно писать JavaScript-код: всё, что требуется, можно сделать на Python.

### Установка

Для начала работы с Folium установите его через pip:

pip install folium

Теперь приступаем к практике.

### Пример 1. Создание простой карты

Начнём с того, чтобы создать базовую карту и сохранить её в HTML-файл:

import folium

# Создаем карту с центром в конкретной точке
base_map = folium.Map(location=[37.7749, -122.4194], zoom_start=13)

# Сохраняем карту в HTML-файл
base_map.save("simple_map.html")

Параметр location задаёт координаты центра карты (широта, долгота), а zoom_start - уровень масштаба. Когда вы откроете файл simple_map.html в браузере, вы увидите карту с центром в Сан-Франциско.

### Пример 2. Добавление маркеров и информации

Маркеры - это важная часть любого ГИС-приложения. Допустим, вы хотите отметить пару точек на карте:

# Создаем карту
map_with_markers = folium.Map(location=[37.7749, -122.4194], zoom_start=13)

# Добавляем маркеры
folium.Marker([37.7749, -122.4194], tooltip="San Francisco").add_to(map_with_markers)
folium.Marker([37.7849, -122.4094], tooltip="Another Point", popup="Custom Info Here").add_to(map_with_markers)

# Сохраняем карту
map_with_markers.save("map_with_markers.html")

Параметр tooltip добавляет всплывающую подсказку, которая видна при наведении на маркер, а popup создаёт окно с подробной информацией, которое открывается при клике.

### Пример 3. Визуализация данных

Folium позволяет визуализировать данные, например, наличие Wi-Fi точек, распределение населения по районам или уровень загрязнения воздуха. Вот пример создания кругов (circle markers), представляющих тепловые точки:

# Создаем карту
data_map = folium.Map(location=[37.7749, -122.4194], zoom_start=12)

# Данные для визуализации
locations = [
    {"coords": [37.779, -122.419], "value": 50},
    {"coords": [37.769, -122.429], "value": 80},
    {"coords": [37.759, -122.439], "value": 30}
]

# Добавляем круги с размерами, соответствующими значениям
for loc in locations:
    folium.CircleMarker(
        location=loc["coords"],
        radius=loc["value"] / 10,  # Радиус пропорционален значению
        color="blue",
        fill=True,
        fill_color="blue"
    ).add_to(data_map)

# Сохраняем карту
data_map.save("data_map.html")

В реальных анализах такие данные вы будете брать из файлов или API, а не прописывать вручную.

### Почему Folium?

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

Таким образом, независимо от ваших целей - будь то построение приложения для мониторинга инфраструктуры или просто создание красивой интерактивной карты - Folium станет вашим надёжным союзником.

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

Как использовать библиотеки AR/VR для создания образовательных приложений.

# Как использовать Python и библиотеки AR/VR для образовательных приложений

Augmented Reality (AR) и Virtual Reality (VR) – это не просто тренд, а мощный инструмент, который меняет подход к обучению. Представьте: вместо скучных учебников дети изучают анатомию, рассматривая виртуальную модель человеческого сердца, или исследуют Солнечную систему, буквально прогуливаясь среди планет. С помощью Python и ряда специализированных библиотек разработка таких приложений становится реальной даже для начинающих.

В этой статье я расскажу, как использовать Python в связке с популярными AR/VR библиотеками для создания образовательных проектов и покажу, что для таких разработок не нужно быть профессионалом.

---

## Азы AR/VR разработок

Для начала разберёмся: AR накладывает виртуальные объекты на реальный мир (через камеру на телефоне или очки AR), а VR переносит пользователя в полностью виртуальное пространство (используя VR-шлемы). Python здесь становится связующим звеном, благодаря гибкости и обилию библиотек.

Для работы с AR/VR нам пригодятся:
1. OpenCV – для захвата изображения с камеры.
2. unity3d-unity-python – библиотека для интеграции Python с Unity (основным инструментом для VR/AR разработки).
3. PyOpenGL – для работы с графикой в 3D-пространстве.

---

## Пример 1. Создаём "живую" молекулу с Vuforia + Python

Один из самых популярных инструментов для AR – это Vuforia, которая используется в Unity для добавления AR-опыта. В паре с Python можно создать интерактивные модели из учебника химии.

import cv2
import numpy as np

def display_molecule(image_path, marker_path):
    image = cv2.imread(image_path)
    marker = cv2.imread(marker_path, 0)

    orb = cv2.ORB_create()
    keypoints_image, descriptors_image = orb.detectAndCompute(image, None)
    keypoints_marker, descriptors_marker = orb.detectAndCompute(marker, None)

    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    matches = bf.match(descriptors_marker, descriptors_image)
    matches = sorted(matches, key=lambda x: x.distance)

    matched_image = cv2.drawMatches(marker, keypoints_marker, image, keypoints_image, matches[:10], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
    cv2.imshow("Molecule AR Projection", matched_image)
    cv2.waitKey(0)

Этот код на Python использует OpenCV для привязки изображения молекулы к маркеру (например, распечатанному QR-коду). В реальном приложении вместо cv2.imshow вы могли бы выводить 3D-модель, используя Unity.

---

## Пример 2. Погружаемся в Солнечную систему с PyOpenVR

Для VR приложений можно использовать библиотеку PyOpenVR, которая работает с популярными шлемами, такими как HTC Vive или Oculus Rift. Например, давайте создадим образовательное приложение, где пользователь оказывается в центре системы планет.

import openvr
import time

def move_in_solar_system():
    vr = openvr.init(openvr.VRApplication_Scene)

    try:
        while True:
            pose = vr.VRCompositor().waitGetPoses()
            hmd_pose = pose[0][openvr.TrackedDevicePose_t.mDeviceToAbsoluteTracking]
            print("User Headset Position:", hmd_pose)
            time.sleep(0.1)
    finally:
        openvr.shutdown()

Этот код отслеживает положение шлема пользователя. Разумеется, для отображения 3D-моделей потребуется интеграция этой логики с Unity или другой графической платформой.

---

## Потенциал AR/VR в образовании

AR/VR позволяет делать обучение не только интересным, но и эффективным. Вместо того чтобы представлять себе абстрактные концепции, школьники могут взаимодействовать с ними в виртуальной среде.

Это особенно полезно, например:
- На уроках истории – для изучения исторических сражений через 3D-воссоздание событий.
- В медицине – для безопасной практики сложных операций.
- В химии или физике – для симуляций, которые невозможно провести в реальности.

---

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

Создание образовательных приложений в AR и VR с использованием Python – это не миф, а вполне достижимая цель. Освоив OpenCV, PyOpenVR и связку Python + Unity, вы можете разрабатывать свои проекты, которые будут вдохновлять и улучшать процесс обучения.

Секрет успеха прост: начните с малого. Тестируйте идеи, пробуйте разные библиотеки и постепенно погружайтесь в этот увлекательный мир. Возможно, именно вашему проекту будет суждено стать будущим образовательных технологий!

Основы разработки социальных сетей и чат-приложений с Python.

Основы разработки социальных сетей и чат-приложений с Python

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

---

### Основные компоненты социальной сети

Любая социальная сеть состоит из трёх ключевых компонентов:
1. База данных – для хранения пользовательских данных (профили, посты, комментарии и т.д.).
2. Серверная часть – для обработки запросов и управления данными.
3. Клиентская часть – интерфейс, с которым взаимодействует пользователь (создание постов, отправка сообщений и т.д.).

Разберём базовую структуру на Python.

#### 1. Хранение данных
Для начала мы можем использовать SQLite – простую встроенную базу данных, которую предоставляет Python. Например, создадим таблицу для хранения постов:

import sqlite3

# Создаем подключение к базе данных
conn = sqlite3.connect("social_network.db")

# Создаем таблицу для постов
conn.execute('''
CREATE TABLE IF NOT EXISTS posts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user TEXT NOT NULL,
    content TEXT NOT NULL
)
''')
conn.commit()
conn.close()

#### 2. Обработка запросов (сервер)
Теперь создадим сервер, который будет обрабатывать запросы. Для этого отлично подойдёт библиотека Flask:

from flask import Flask, request, jsonify
import sqlite3

app = Flask(__name__)

@app.route("/add_post", methods=["POST"])
def add_post():
    data = request.get_json()
    user = data["user"]
    content = data["content"]

    conn = sqlite3.connect("social_network.db")
    conn.execute("INSERT INTO posts (user, content) VALUES (?, ?)", (user, content))
    conn.commit()
    conn.close()

    return jsonify({"message": "Post added successfully"}), 201

@app.route("/get_posts", methods=["GET"])
def get_posts():
    conn = sqlite3.connect("social_network.db")
    cursor = conn.execute("SELECT user, content FROM posts")
    posts = [{"user": row[0], "content": row[1]} for row in cursor.fetchall()]
    conn.close()

    return jsonify(posts)

Этот код представляет небольшой сервер с двумя эндпоинтами: добавления постов (/add_post) и получения всех постов (/get_posts).

#### 3. Общение в реальном времени (чат)
Для чата нам нужно что-то более динамичное. Здесь пригодится WebSocket. Библиотека websockets позволит создать базовый сервер, обрабатывающий сообщения в реальном времени.

import asyncio
import websockets

clients = set()

async def handler(websocket, path):
    clients.add(websocket)
    try:
        async for message in websocket:
            # Рассылаем сообщение всем клиентам
            await asyncio.wait([client.send(message) for client in clients])
    finally:
        clients.remove(websocket)

start_server = websockets.serve(handler, "localhost", 6789)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

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

#### 4. Тестирование чата
Для тестирования можно использовать обычный браузер или библиотеку websockets:

import asyncio
import websockets

async def send_message():
    uri = "ws://localhost:6789"
    async with websockets.connect(uri) as websocket:
        while True:
            msg = input("Enter message: ")
            await websocket.send(msg)
            response = await websocket.recv()
            print(f"Received: {response}")

asyncio.run(send_message())

---

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

Мы только прикоснулись к основам.

В реальном приложении используются более сложные вещи: ORM для работы с базами данных (например, SQLAlchemy), асинхронные фреймворки (FastAPI), авторизация пользователей (OAuth) и масштабирование через облачные сервисы.

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

Создание серверных приложений с использованием FastAPI.

Создание серверных приложений с использованием FastAPI.