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

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.

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

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

FastAPI — это современный веб-фреймворк для создания API на Python. Разработчики влюбляются в него благодаря невероятной простоте и скорости, ведь название говорит само за себя — "быстрый API". FastAPI построен на основе Starlette и Pydantic, что делает его не только молниеносным, но и надежным.

Сегодня я расскажу вам основные шаги для создания микросервисов с помощью FastAPI. А вишенкой на торте станут примеры, которые вы сможете за пару минут адаптировать под свои нужды.

---

### Почему именно FastAPI?
FastAPI был создан для того, чтобы сделать разработку серверной части проще и удобнее. Основные преимущества:
- Скорость работы: Фреймворк использует асинхронное программирование на базе asyncio, что делает его на порядок быстрее многих аналогов.
- Автоматизированная документация: Swagger UI и ReDoc генерируются автоматически. Это значит, что вы получаете интерфейс для тестирования вашего API прямо "из коробки".
- Поддержка аннотаций типов: Хотите меньше ошибок? FastAPI позволяет эффективно использовать типизацию Python, что помогает выявлять проблемы на раннем этапе.

Теперь перейдем от теории к практике.

---

### Создаем серверное приложение: ваш первый API

Для начала убедимся, что у вас установлен FastAPI и Uvicorn (ASGI-сервер, который используется для запуска приложения). Установить их можно с помощью pip:

pip install fastapi uvicorn

Теперь создадим файл main.py с простым примером:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Welcome to FastAPI!"}

@app.get("/items/{item_id}")
def read_item(item_id: int, detail: bool = False):
    return {"item_id": item_id, "detail": detail}

Что здесь происходит:
1. Создаем объект FastAPI. Это наш "движок", который будет управлять запросами и возвращать ответы.
2. Определяем два эндпоинта (или маршрута).
- / возвращает приветствие.
- /items/{item_id} принимает item_id как параметр пути и параметр запроса detail.

Запустить сервер можно командой:

uvicorn main:app --reload

После этого перейдите на http://127.0.0.1:8000/docs. Вы увидите автоматически созданную интерактивную документацию в стиле Swagger UI!

---

### Работаем с POST-запросами

А как насчет обработки новых данных? Например, добавления информации в базу данных? Для этого используется метод POST.

Давайте расширим наш сервер:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str | None = None

@app.post("/items/")
def create_item(item: Item):
    return {"name": item.name, "price": item.price, "description": item.description}

Теперь, заходя в /docs, вы увидите форму, где можно отправить данные в формате JSON. Удобно протестировать и убедиться, что сервер работает так, как нужно.

---

### Асинхронность — сила FastAPI

FastAPI поддерживает асинхронные функции (корутины) буквально "из коробки". Это значит, что вы можете, например, обращаться к базе данных без блокировки приложения.

Попробуем добавить асинхронный эндпоинт:

import asyncio

@app.get("/wait/")
async def wait_for_response():
    await asyncio.sleep(3)
    return {"message": "Thanks for waiting!"}

Когда вы зайдете на этот маршрут, сервер "задумается" на три секунды, а затем вернет ответ. Это полезно для выполнения длительных операций.

---

### Пара слов о безопасности

FastAPI предоставляет инструменты для безопасной разработки.

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

Пример добавления простой авторизации:

from fastapi import HTTPException, Depends

def verify_token(token: str):
    if token != "secret":
        raise HTTPException(status_code=401, detail="Invalid token")

@app.get("/secure/", dependencies=[Depends(verify_token)])
def secure_data():
    return {"message": "You have access!"}

Теперь доступ к /secure/ будет возможен только при передаче верного токена в заголовке запроса.

---

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

Основы работы с базами NoSQL: использование MongoDB с Python.