Python: автоматизация, анализ данных и веб-разработка

Базовый синтаксис и структуры данных

Переход на новый язык программирования всегда начинается с понимания его философии. Для разработчика, уже знакомого с концепциями переменных, циклов и функций, Python предлагает уникальный подход, ориентированный на читаемость и скорость написания кода. Главная мантра языка заложена в так называемом «Дзене Пайтона» (The Zen of Python):

Явное лучше, чем неявное. Простое лучше, чем сложное. Читаемость имеет значение.

Тим Питерс, The Zen of Python

В этой парадигме мы разберем ключевые особенности синтаксиса и встроенные структуры данных, которые станут вашим основным инструментом для автоматизации, веб-разработки и анализа данных.

Анатомия синтаксиса: отступы и типизация

Первое, что бросается в глаза при чтении кода на Python — отсутствие фигурных скобок {} и точек с запятой в конце строк. Язык использует отступы (обычно 4 пробела) для определения блоков кода. Это принуждает разработчиков писать визуально структурированный код.

Вторая важнейшая особенность — строгая динамическая типизация. Тип переменной определяется в момент присваивания значения, а не на этапе компиляции. Однако «строгая» означает, что язык не будет неявно преобразовывать типы там, где это лишено смысла (например, складывать строку и число).

# Пример базового синтаксиса
user_age = 25          # Тип int (целое число)
user_name = "Alice"    # Тип str (строка)
is_active = True       # Тип bool (логический тип)

if user_age >= 18:
    # Этот блок выделен отступом
    print(f"Пользователь {user_name} допущен к системе.")

В Python переменные — это не ячейки памяти, а ссылки (ярлыки), указывающие на объекты. Когда вы пишете x = 10, создается объект числа 10, и на него вешается ярлык x. Это понимание критически важно при работе со сложными структурами данных.

Встроенные структуры данных

Для решения реальных задач — будь то парсинг веб-страниц, обработка JSON-ответов от API или подготовка датасета — вам редко хватит одиночных переменных. Python предлагает четыре мощные встроенные структуры данных.

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

Структура	Синтаксис	Изменяемость	Упорядоченность	Уникальность элементов
Список (List)	`[1, 2, 3]`	Да	Да	Нет (допускаются дубликаты)
Кортеж (Tuple)	`(1, 2, 3)`	Нет	Да	Нет
Словарь (Dictionary)	`{"a": 1}`	Да	Да (с версии 3.7)	Ключи уникальны, значения — нет
Множество (Set)	`{1, 2, 3}`	Да	Нет	Да (только уникальные)

Списки (Lists): универсальный контейнер

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

# Сбор данных о температуре за неделю
temperatures = [22.5, 23.0, 21.5, 24.0]

# Добавление нового значения
temperatures.append(25.1)

# Обращение по индексу (нумерация с нуля)
print(temperatures[0])  # Выведет 22.5

Одной из самых мощных функций списков являются срезы (slices). Они позволяют извлекать части списка с помощью синтаксиса [start:stop:step].

В анализе данных часто требуется оценить объем памяти, занимаемый списком. Базовая формула выглядит так: $M = N \times S$ , где $M$ — общий объем памяти, $N$ — количество элементов в списке, а $S$ — размер одного элемента в байтах. Однако из-за того, что список в Python хранит ссылки на объекты, а не сами объекты, реальное потребление памяти всегда немного выше.

Кортежи (Tuples): защита от изменений

Кортеж похож на список, но он неизменяем (immutable). После создания кортежа вы не можете добавить, удалить или изменить его элементы.

Зачем нужна структура, которую нельзя менять?

Безопасность данных: Если вы передаете конфигурационные данные (например, координаты сервера или учетные данные для базы данных), кортеж гарантирует, что код случайно их не перезапишет.
Производительность: Кортежи занимают меньше памяти и создаются быстрее списков.
Ключи словарей: В отличие от списков, кортежи могут быть ключами в словарях.

# Координаты офиса (широта, долгота)
office_location = (55.7558, 37.6173)
# office_location[0] = 56.0  # Эта строка вызовет ошибку TypeError

Словари (Dictionaries): ключ к веб-разработке

Словарь — это коллекция пар «ключ-значение». Если вы работали с JSON, то словари покажутся вам очень знакомыми. Поиск значения по ключу в словаре происходит практически мгновенно, независимо от размера словаря. В терминах алгоритмической сложности это записывается как $O(1)$ , где $O$ обозначает порядок сложности, а $1$ — константное время выполнения.

Словари — фундамент веб-разработки на Python. Любой ответ от REST API, конфигурация веб-приложения или запись в NoSQL базе данных (например, MongoDB) легко проецируется на словарь.

# Профиль пользователя из базы данных
user_profile = {
    "username": "johndoe",
    "email": "john@example.com",
    "roles": ["admin", "editor"],  # Значением может быть список
    "is_active": True
}

# Получение значения по ключу
print(user_profile["email"])

# Добавление новой пары ключ-значение
user_profile["last_login"] = "2023-10-25"

Множества (Sets): математика в коде

Множество — это неупорядоченная коллекция уникальных элементов. Множества оптимизированы для быстрых проверок на вхождение и математических операций (пересечение, объединение, разность).

В задачах автоматизации и анализа данных множества незаменимы для очистки данных от дубликатов.

# Список ID пользователей с дубликатами (например, логи посещений)
visitor_ids = [101, 102, 101, 103, 104, 102]

# Превращаем список в множество для удаления дубликатов
unique_visitors = set(visitor_ids)
print(unique_visitors)  # Выведет {101, 102, 103, 104}

# Быстрая проверка на вхождение
if 105 in unique_visitors:
    print("Пользователь найден")

Экосистема Python для ваших целей

Понимание базовых структур данных открывает дверь к использованию мощных сторонних библиотек, которые делают Python лидером в заявленных вами областях.

Для анализа данных и научных вычислений: Библиотека NumPy заменяет стандартные списки на высокопроизводительные массивы, написанные на C. Библиотека Pandas вводит структуру DataFrame (по сути, таблицу), которая под капотом использует словари и массивы для невероятно быстрой обработки миллионов строк.
Для автоматизации: Библиотека Requests позволяет отправлять HTTP-запросы, возвращая ответы, которые легко конвертируются в словари Python. Библиотека BeautifulSoup помогает извлекать данные из HTML, сохраняя их в списки и кортежи.
Для веб-разработки: Фреймворки Django и FastAPI активно используют словари для маршрутизации и валидации данных. FastAPI, в частности, автоматически конвертирует словари Python в JSON-ответы для клиентских приложений.

Практический пример: объединяем знания

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

# 1. Сырые данные (список словарей)
raw_data = [
    {"ip": "192.168.1.1", "status": "active"},
    {"ip": "192.168.1.2", "status": "error"},
    {"ip": "192.168.1.1", "status": "active"}  # Дубликат
]

# 2. Используем множество для хранения уникальных IP (кортежи неизменяемы, поэтому их можно добавить в множество)
unique_servers = set()
clean_data = []

for server in raw_data:
    # Извлекаем значения в виде кортежа
    server_signature = (server["ip"], server["status"])

    # Если такого сервера еще не было, добавляем его
    if server_signature not in unique_servers:
        unique_servers.add(server_signature)
        clean_data.append(server)

print(f"Обработано уникальных серверов: {len(clean_data)}")

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

Работа с файловой системой и автоматизация

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

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

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

Билл Гейтс

Прежде чем писать код, давайте оценим целесообразность автоматизации с помощью простой формулы: $T_{saved} = (N \times t) - T_{script}$ , где $T_{saved}$ — сэкономленное время, $N$ — количество файлов или повторений задачи, $t$ — время на ручную обработку одной единицы, а $T_{script}$ — время, затраченное на написание и отладку кода. Если вам нужно переименовать 5 файлов ( $N=5$ ), быстрее сделать это руками. Но если файлов 5000, а на каждый уходит по 10 секунд, ручная работа займет почти 14 часов. Скрипт на Python пишется за 15 минут и выполняется за 2 секунды.

Навигация по файловой системе: модуль pathlib

Исторически для работы с путями к файлам в Python использовался модуль os.path, который обрабатывал пути просто как строки. Начиная с версии 3.4, стандартом стал модуль pathlib. Он предлагает объектно-ориентированный подход: путь теперь — это не просто текст, а объект, у которого есть полезные методы.

Это решает классическую проблему разных операционных систем: Windows использует обратный слеш \ для разделения папок, а macOS и Linux — прямой /. Модуль pathlib автоматически адаптирует пути под ту систему, на которой запущен код.

from pathlib import Path

# Создаем объект пути к текущей рабочей директории
current_dir = Path.cwd()
print(f"Мы находимся в: {current_dir}")

# Формируем путь к новой папке (используем оператор / для объединения)
reports_dir = current_dir / "data" / "reports"

# Создаем папку.
# parents=True создаст промежуточные папки (data), если их нет.
# exist_ok=True предотвратит ошибку, если папка уже существует.
reports_dir.mkdir(parents=True, exist_ok=True)

# Проверяем, существует ли файл
target_file = reports_dir / "summary.txt"
if not target_file.exists():
    print("Файл отчета пока не создан.")

Чтение и запись файлов: контекстные менеджеры

Чтобы прочитать или записать данные в файл, его нужно сначала открыть с помощью встроенной функции open(). Эта функция принимает путь к файлу и режим работы (mode):

r (read) — чтение (по умолчанию).
w (write) — запись (создает новый файл или полностью перезаписывает существующий).
a (append) — добавление (дописывает данные в конец файла).

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

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

# Запись в файл с использованием контекстного менеджера
file_path = Path("example.txt")

with open(file_path, "w", encoding="utf-8") as file:
    file.write("Первая строка отчета.\n")
    file.write("Вторая строка отчета.\n")
# Как только блок кода с отступом заканчивается,
# Python автоматически закрывает файл.

# Чтение из файла
with open(file_path, "r", encoding="utf-8") as file:
    content = file.read()
    print(content)

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

Высокоуровневые операции: модуль shutil

Если pathlib отлично справляется с путями и созданием папок, то для перемещения, копирования и удаления целых деревьев каталогов нужен модуль shutil (shell utilities).

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

Для поиска файлов по шаблону (например, «найти все файлы, заканчивающиеся на .pdf») мы будем использовать метод rglob() из модуля pathlib.

import shutil
from pathlib import Path

# Папка с хаосом файлов
downloads = Path("downloads_folder")

# Находим все PDF-файлы в папке и ее подпапках
for pdf_file in downloads.rglob("*.pdf"):
    # Создаем папку для документов
    doc_folder = downloads / "Documents"
    doc_folder.mkdir(exist_ok=True)

    # Формируем путь назначения
    destination = doc_folder / pdf_file.name

    # Перемещаем файл
    shutil.move(str(pdf_file), str(destination))
    print(f"Файл {pdf_file.name} перемещен в Documents")

Структурированные данные: работа с JSON

В реальных проектах — будь то анализ данных или веб-разработка — вы редко будете работать с простым неструктурированным текстом. Чаще всего данные передаются в формате JSON (JavaScript Object Notation).

JSON — это текстовый формат обмена данными, который визуально почти идентичен словарям и спискам в Python. Любой ответ от современного веб-сервиса (например, запрос погоды или курсов валют через API) приходит в виде JSON.

Процесс перевода объектов Python (словарей, списков) в строку JSON для сохранения в файл называется сериализацией. Обратный процесс — чтение из файла и превращение в объекты Python — десериализацией.

Для этого используется встроенный модуль json.

import json

# Наши данные (словарь Python)
server_config = {
    "host": "192.168.1.10",
    "port": 8080,
    "active_services": ["database", "web_server"],
    "is_running": True
}

# Сериализация: сохраняем словарь в JSON-файл
config_path = Path("config.json")
with open(config_path, "w", encoding="utf-8") as f:
    # json.dump записывает данные прямо в открытый файл
    # indent=4 делает файл читаемым для человека (добавляет отступы)
    json.dump(server_config, f, indent=4)

# Десериализация: читаем JSON-файл обратно в словарь Python
with open(config_path, "r", encoding="utf-8") as f:
    loaded_config = json.load(f)

print(loaded_config["active_services"])  # Выведет: ['database', 'web_server']

Обратите внимание на разницу между методами: json.dump() записывает данные в файл, а json.dumps() (с буквой s на конце, от слова string) превращает словарь в строку JSON внутри оперативной памяти, не сохраняя на диск.

Практический пример: анализатор логов

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

import json
from pathlib import Path

# 1. Имитируем сырые данные (обычно мы бы читали их из файла)
raw_logs = [
    "INFO: User logged in",
    "ERROR: Database connection failed",
    "INFO: Data exported",
    "ERROR: Timeout occurred",
    "ERROR: Database connection failed"
]

# 2. Обрабатываем данные
error_counts = {}

for line in raw_logs:
    if line.startswith("ERROR:"):
        # Очищаем строку от префикса
        error_msg = line.replace("ERROR: ", "").strip()

        # Подсчитываем ошибки с помощью словаря
        if error_msg in error_counts:
            error_counts[error_msg] += 1
        else:
            error_counts[error_msg] = 1

# 3. Формируем структуру отчета
report = {
    "total_errors": sum(error_counts.values()),
    "error_details": error_counts
}

# 4. Сохраняем результат в файл
report_path = Path("error_report.json")
with open(report_path, "w", encoding="utf-8") as f:
    json.dump(report, f, indent=4, ensure_ascii=False)

print("Отчет успешно сгенерирован!")

В этом скрипте мы применили строковые методы для очистки данных, словари для агрегации (подсчета уникальных значений), контекстный менеджер with для безопасной работы с файловой системой и модуль json для структурированного сохранения результатов. Это базовый, но абсолютно реальный пайплайн (pipeline), который используется в задачах автоматизации и подготовки данных для аналитики.

Введение в NumPy и Pandas

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

Стандартные списки и циклы Python, которые мы изучили ранее, отлично подходят для базовых задач. Однако при обработке огромных массивов чисел они становятся слишком медленными и потребляют много оперативной памяти. Для решения этой проблемы в мире Python существуют две фундаментальные библиотеки: NumPy и Pandas. Они превращают язык в мощнейший инструмент для научных вычислений и анализа данных.

NumPy: математический двигатель Python

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

Главное отличие массива NumPy от стандартного списка Python заключается в том, как они хранятся в оперативной памяти компьютера. Список Python может содержать разные типы данных (числа, строки, словари одновременно), поэтому для каждого элемента система хранит дополнительную служебную информацию. Массив NumPy содержит данные строго одного типа (например, только целые числа). Это позволяет хранить их в памяти плотно, друг за другом, что ускоряет обработку в десятки и сотни раз.

Ключевая концепция NumPy — векторизация. Это способность применять математические операции сразу ко всему массиву данных без использования явных циклов for.

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

import numpy as np

# Цены товаров и количество проданных единиц
prices = np.array([150, 300, 450, 1000])
quantities = np.array([2, 5, 1, 3])

# Векторизованная операция: умножаем массивы напрямую
# Вычисляем выручку (Revenue = Price × Quantity)
revenues = prices * quantities

print(revenues)
# Вывод: [ 300 1500  450 3000]

В этом примере мы не писали цикл для перебора каждого элемента. NumPy сделал это за нас на уровне быстрого языка C, на котором написана сама библиотека.

Pandas: табличный процессор для аналитики

Если NumPy — это мощный двигатель, то Pandas (Panel Data) — это удобный салон автомобиля с приборной панелью. Эта библиотека построена поверх NumPy, но предназначена для работы со структурированными табличными данными.

По сути, Pandas — это Excel на максимальных настройках. Он позволяет загружать данные из файлов (CSV, Excel, SQL-баз), фильтровать их, группировать, находить аномалии и заполнять пропуски с помощью пары строк элегантного кода.

Вся магия Pandas строится на двух базовых структурах данных:

Series (Серия) — это одномерный массив данных. Представьте себе одну колонку в таблице. В отличие от обычного списка, у каждого элемента в Series есть явный индекс (метка), по которому к нему можно обратиться. Индексом могут быть не только порядковые номера, но и даты или текстовые названия.
DataFrame (Датафрейм) — это двумерная таблица, состоящая из строк и колонок. Технически, DataFrame — это словарь, где ключами выступают названия колонок, а значениями — объекты Series одинаковой длины.

Давайте создадим DataFrame, используя знания о словарях из первой статьи нашего курса.

import pandas as pd

# Создаем словарь с данными о пользователях
data = {
    "name": ["Анна", "Иван", "Мария", "Петр"],
    "age": [28, 34, 29, 42],
    "city": ["Москва", "Казань", "Москва", "Сочи"],
    "purchases": [15, 3, 24, 8]
}

# Преобразуем словарь в DataFrame
df = pd.DataFrame(data)

print(df)

Вывод этой программы будет выглядеть как аккуратная таблица, где слева автоматически добавится колонка с индексами (от 0 до 3).

Практический сценарий: фильтрация и вычисления

В реальных проектах данные редко вводят вручную. Обычно их загружают из файлов. В прошлой статье мы использовали встроенную функцию open(), но для таблиц у Pandas есть готовый метод pd.read_csv().

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

import pandas as pd

# Имитация загрузки данных из файла
# df = pd.read_csv("transactions.csv")

# Метод .head() показывает первые 5 строк таблицы
print("Первые строки данных:")
print(df.head())

# Метод .describe() автоматически считает среднее, минимум, максимум
# и квартили для всех числовых колонок
print("\nСтатистика по числовым данным:")
print(df.describe())

# Фильтрация данных
# Найдем всех пользователей из Москвы, которые сделали больше 10 покупок
# Используем побитовый оператор & для логического "И"
active_moscow_users = df[(df["city"] == "Москва") & (df["purchases"] > 10)]

print("\nАктивные пользователи из Москвы:")
print(active_moscow_users)

Обратите внимание на синтаксис фильтрации: df[условие]. Внутри квадратных скобок мы передаем логическое выражение. Pandas проверяет каждую строку: если условие выполняется (возвращает True), строка остается в итоговой таблице.

Векторизация позволяет легко создавать новые колонки на основе математических формул. Например, при расчете конверсии интернет-магазина используется формула:

CR = \frac{Orders}{Visitors} \times 100

Где $CR$ — коэффициент конверсии в процентах, $Orders$ — количество заказов, а $Visitors$ — количество уникальных посетителей. С помощью Pandas вы можете вычислить этот показатель для тысяч рекламных кампаний одновременно одной строкой кода: df['CR'] = (df['Orders'] / df['Visitors']) * 100.

Обработка пропущенных значений

В реальном мире данные часто бывают "грязными". Например, при сборе анкет кто-то мог не указать свой возраст или произошел сбой датчика. В Pandas такие пустоты обозначаются как NaN (Not a Number).

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

Очистка и подготовка данных занимает до 80% времени работы аналитика. Построение сложных моделей машинного обучения — лишь верхушка айсберга.

Harvard Business Review

У нас есть два основных пути работы с пропусками:

Удалить строки с пустыми значениями с помощью метода .dropna(). Это подходит, если пропусков мало и потеря данных не критична.
Заполнить пропуски логичным значением с помощью .fillna(). Например, заменить пустой возраст на медианный возраст всех остальных пользователей.

import numpy as np

# Добавим пользователя с неизвестным возрастом (np.nan)
messy_data = pd.DataFrame({
    "name": ["Олег", "Елена", "Виктор"],
    "age": [25, np.nan, 30]
})

# Заполняем пропуск средним значением по колонке
mean_age = messy_data["age"].mean()
clean_data = messy_data.fillna({"age": mean_age})

print(clean_data)

Группировка и агрегация данных

Один из самых частых запросов в анализе данных — это сегментация. Например, мы хотим узнать не просто общую выручку, а выручку в разрезе каждого города. В базах данных для этого используется оператор GROUP BY, и в Pandas есть его точный аналог — метод .groupby().

Процесс группировки состоит из трех шагов, которые часто называют принципом Split-Apply-Combine (Разделение-Применение-Объединение):

Таблица разделяется на части по уникальным значениям выбранной колонки (например, по городам).
К каждой части применяется математическая функция (сумма, среднее, подсчет количества).
Результаты объединяются в новую сводную таблицу.

# Набор данных о продажах
sales_data = pd.DataFrame({
    "city": ["Москва", "Казань", "Москва", "Сочи", "Казань", "Сочи"],
    "category": ["Электроника", "Одежда", "Одежда", "Электроника", "Электроника", "Одежда"],
    "revenue": [50000, 15000, 25000, 40000, 35000, 12000]
})

# Группируем по городу и считаем суммарную выручку
city_revenue = sales_data.groupby("city")["revenue"].sum()

print("Выручка по городам:")
print(city_revenue)

В этом примере мы сгруппировали данные по колонке city, затем выбрали колонку revenue и применили к ней функцию .sum(). Всего одна строка кода заменила сложный алгоритм с созданием вложенных словарей и циклов, который потребовался бы в чистом Python.

Использование NumPy и Pandas кардинально меняет подход к программированию. Вместо того чтобы писать длинные инструкции о том, как перебрать каждый элемент (императивный подход), вы просто указываете, что хотите получить в итоге (декларативный подход). Это экономит время разработчика и вычислительные ресурсы компьютера, открывая дорогу к серьезному анализу данных.

Маршрутизация и API в веб-фреймворках

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

Основой взаимодействия в современном интернете является API (Application Programming Interface — программный интерфейс приложения). Это набор правил, по которым одна программа общается с другой. Если пользовательский интерфейс (кнопки, окна, меню) создается для людей, то API создается для машин.

Как работает API: аналогия с рестораном

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

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

API — это контракт между поставщиком информации и ее потребителем. Он строго регламентирует, какие запросы можно отправлять и в каком формате придет ответ.

Хабр

Общение между клиентом и сервером чаще всего происходит по протоколу HTTP. Чтобы сервер понимал, что именно мы от него хотим, используются специальные методы (глаголы) HTTP-запросов:

Метод HTTP	Действие в базе данных	Пример из жизни (API интернет-магазина)
GET	Чтение	Получить список доступных товаров
POST	Создание	Добавить новый товар в корзину
PUT	Обновление	Изменить адрес доставки в профиле
DELETE	Удаление	Удалить товар из корзины

Ответ от сервера обычно возвращается в формате JSON, с которым мы уже работали во второй статье курса. Технически, для Python это выглядит как обычный словарь.

Что такое маршрутизация?

Когда сервер получает HTTP-запрос, ему нужно понять, какой именно кусок кода должен этот запрос обработать. Процесс сопоставления входящего URL-адреса с конкретной функцией в программе называется маршрутизацией (routing).

Представьте себе коммутатор на старой телефонной станции. Входящий звонок поступает на главный пульт, и телефонистка (маршрутизатор) соединяет вас с нужным отделом в зависимости от того, кого вы просите позвать.

Если пользователь обращается по адресу mysite.com/users, маршрутизатор запускает функцию, которая достает из базы данных список пользователей. Если запрос идет на mysite.com/products, запускается функция поиска товаров.

Создание первого API с помощью FastAPI

В экосистеме Python существует множество веб-фреймворков. Исторически популярными были Django (мощный, но тяжеловесный) и Flask (минималистичный). Однако в последние годы стандартом индустрии для создания API стал FastAPI.

FastAPI — это современный, быстрый и невероятно удобный фреймворк. Его главное преимущество заключается в том, что он активно использует встроенные в Python подсказки типов (type hints), что позволяет автоматически проверять данные на ошибки и генерировать документацию.

Давайте напишем простейшее веб-приложение. Для этого потребуется установить библиотеку (обычно это делается через команду pip install fastapi uvicorn).

from fastapi import FastAPI

# Создаем главный экземпляр приложения
app = FastAPI()

# Декоратор маршрутизатора: связываем URL "/" с функцией ниже
@app.get("/")
def read_root():
    return {"message": "Добро пожаловать в наше первое API!"}

@app.get("/status")
def check_status():
    return {"status": "ok", "active_users": 150}

В этом коде символ @ обозначает декоратор. Декораторы в Python — это способ изменить или расширить поведение функции, не меняя ее внутренний код. В данном случае @app.get("/status") говорит фреймворку: «Если кто-то отправит GET-запрос на адрес /status, запусти функцию check_status и верни ее результат клиенту».

Динамическая маршрутизация и параметры пути

Часто нам нужно получить не весь список данных, а информацию о конкретном объекте. Например, профиль пользователя с идентификатором 42. Создавать отдельный маршрут для каждого пользователя (/users/1, /users/2 и так далее) невозможно.

Здесь на помощь приходят параметры пути. Мы можем указать маршрутизатору, что часть URL-адреса является переменной, которую нужно передать внутрь функции.

from fastapi import FastAPI

app = FastAPI()

# Имитация базы данных пользователей
fake_users_db = {
    1: {"name": "Анна", "role": "admin"},
    2: {"name": "Иван", "role": "user"}
}

# В фигурных скобках указываем имя переменной
@app.get("/users/{user_id}")
def get_user(user_id: int):
    # FastAPI автоматически преобразует user_id из строки в целое число (int)
    if user_id in fake_users_db:
        return fake_users_db[user_id]
    return {"error": "Пользователь не найден"}

Обратите внимание на запись user_id: int. Если клиент попытается запросить адрес /users/hello, FastAPI автоматически отклонит запрос и вернет понятную ошибку, сообщив, что ожидалось число, а не текст. В старых фреймворках, таких как Flask, разработчикам приходилось писать этот код проверки вручную.

Масштабирование: использование нескольких маршрутизаторов

Пока в нашем приложении три-четыре функции, их удобно держать в одном файле main.py. Но реальные проекты быстро разрастаются. У вас могут появиться десятки маршрутов для работы с пользователями, товарами, оплатой и аналитикой. Если оставить всё в одном файле, он превратится в нечитаемую «простыню» кода на тысячи строк.

Для решения этой проблемы применяется модульный подход. Мы разбиваем логику на разные файлы, используя класс APIRouter.

Представьте, что FastAPI() — это главный распределительный щит здания, а APIRouter() — это локальные щитки на каждом этаже. Главный щит просто делегирует управление локальным.

Давайте создадим отдельный файл для работы с пользователями — routers/users.py:

from fastapi import APIRouter

# Создаем локальный маршрутизатор
# prefix позволяет не писать /users в каждой функции
router = APIRouter(prefix="/users", tags=["Пользователи"])

@router.get("/")
def get_all_users():
    return ["Анна", "Иван", "Мария"]

@router.get("/{user_id}")
def get_single_user(user_id: int):
    return {"user_id": user_id, "status": "active"}

Теперь в нашем главном файле main.py мы можем подключить этот модуль одной строкой:

from fastapi import FastAPI
from routers import users  # Импортируем наш файл с маршрутами

app = FastAPI()

# Подключаем локальный маршрутизатор к главному приложению
app.include_router(users.router)

@app.get("/")
def root():
    return {"message": "Главная страница API"}

Благодаря методу app.include_router(), все маршруты из файла users.py теперь доступны в нашем приложении. Запрос к /users/ вернет список имен, а запрос к /users/5 вернет статус конкретного пользователя.

Такой подход дает несколько критически важных преимуществ:

Изоляция логики: код, отвечающий за пользователей, не смешивается с кодом корзины товаров.
Командная работа: разные программисты могут параллельно работать над разными файлами-маршрутизаторами, не мешая друг другу.
Легкость тестирования: небольшие изолированные модули гораздо проще проверять на наличие ошибок.

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

Пошаговая сборка практического проекта

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

В реальном мире разработчики редко пишут код ради самого кода. Чаще всего цель состоит в создании пайплайна (pipeline — конвейер данных) — автоматизированной системы, которая самостоятельно собирает информацию, обрабатывает её и предоставляет пользователю в удобном виде.

Концепция: умный мониторинг цен

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

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

Сбор данных: скрипт скачивает страницу интернет-магазина и извлекает названия товаров и их цены.
Анализ: данные загружаются в таблицу, очищаются от мусора, после чего вычисляется средняя рыночная стоимость.
Хранение: результаты сохраняются в структурированный файл.
Доставка: веб-сервер открывает доступ к найденным скидкам через API.

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

Шаг 1: Сбор сырых данных (Веб-скрейпинг)

Процесс автоматического извлечения информации с веб-страниц называется веб-скрейпингом (web scraping). Когда вы открываете сайт в браузере, сервер присылает HTML-код, который браузер превращает в красивую картинку. Наш скрипт будет притворяться браузером, скачивать этот HTML-код и искать в нем нужные текстовые блоки.

Для этого в Python используются две популярные библиотеки: Requests (для отправки HTTP-запросов) и BeautifulSoup (для поиска данных внутри HTML).

Качество данных — основа любого аналитического проекта. Если на этапе сбора вы получите «грязную» информацию с ошибками, все последующие вычисления будут бесполезны.

Хабр

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

import random

def scrape_laptops():
    # Имитация веб-скрейпинга: получение сырых данных с сайта
    raw_data = [
        {"title": "Ноутбук Pro 15", "price": "120 000 руб."},
        {"title": "Ноутбук Pro 15 (царапина)", "price": "85 000 руб."},
        {"title": "Ноутбук Pro 15", "price": "118 500 руб."},
        {"title": "Чехол для Ноутбук Pro 15", "price": "2 000 руб."},
        {"title": "Ноутбук Pro 15", "price": "125 000 руб."}
    ]
    return raw_data

Обратите внимание на проблему: в наших данных есть чехол (который не является ноутбуком) и цены записаны как строки с текстом «руб.». В таком виде анализировать их математически невозможно.

Шаг 2: Очистка и анализ данных с Pandas

Здесь в игру вступает Pandas, с которым мы работали в третьей статье. Нам нужно преобразовать сырые словари в удобный DataFrame, отфильтровать лишнее и привести числа к правильному типу данных.

import pandas as pd

def analyze_data(raw_data):
    # 1. Создаем DataFrame
    df = pd.DataFrame(raw_data)

    # 2. Очистка цен: убираем пробелы и слово "руб.", превращаем в числа
    df['price'] = df['price'].str.replace(' руб.', '')
    df['price'] = df['price'].str.replace(' ', '')
    df['price'] = pd.to_numeric(df['price'])

    # 3. Фильтрация: убираем аксессуары (чехлы)
    df = df[~df['title'].str.contains('Чехол')]

    # 4. Вычисляем среднюю цену на рынке
    avg_price = df['price'].mean()

    return df, avg_price

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

Выгода рассчитывается по формуле: $B = \frac{P_{avg} - P_{current}}{P_{avg}} \times 100$

Где $B$ — это выгода в процентах, $P_{avg}$ — средняя рыночная цена, а $P_{current}$ — цена конкретного товара. Если средняя цена 120 000, а мы нашли за 85 000, то выгода составит около 29%.

Добавим этот расчет в нашу функцию:

    # Продолжение функции analyze_data
    df['discount_percent'] = ((avg_price - df['price']) / avg_price) * 100
    df['discount_percent'] = df['discount_percent'].round(1)

    # Оставляем только те товары, где скидка больше 10%
    good_deals = df[df['discount_percent'] > 10]

    # Преобразуем обратно в список словарей для сохранения
    return good_deals.to_dict(orient='records')

Шаг 3: Сохранение результатов

Как мы обсуждали во второй статье, данные нужно надежно сохранять. Если наш скрипт упадет из-за отключения интернета, мы не должны потерять уже найденные скидки. Используем контекстный менеджер with и модуль json.

import json

def save_deals(deals, filename="best_deals.json"):
    # Безопасное открытие файла для записи
    with open(filename, "w", encoding="utf-8") as file:
        json.dump(deals, file, ensure_ascii=False, indent=4)

Параметр ensure_ascii=False гарантирует, что русские буквы сохранятся корректно, а не превратятся в нечитаемые символы (юникод-последовательности). indent=4 делает файл визуально понятным для человека.

Шаг 4: Создание веб-интерфейса через API

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

Создадим файл server.py:

from fastapi import FastAPI
import json
import os

app = FastAPI()

@app.get("/api/deals")
def get_best_deals():
    # Проверяем, существует ли файл
    if not os.path.exists("best_deals.json"):
        return {"error": "Данные еще не собраны"}

    # Читаем данные из файла и отдаем пользователю
    with open("best_deals.json", "r", encoding="utf-8") as file:
        deals = json.load(file)

    return {
        "status": "success",
        "total_deals": len(deals),
        "deals": deals
    }

Теперь при переходе по адресу http://localhost:8000/api/deals мы получим готовый JSON-ответ со списком самых выгодных ноутбуков. Этот адрес можно подключить к Telegram-боту, мобильному приложению или просто просматривать в браузере.

Шаг 5: Оркестрация (Сборка воедино)

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

Создадим файл main.py, который объединит всё вместе:

import time
from datetime import datetime

def run_pipeline():
    print(f"[{datetime.now()}] Запуск конвейера данных...")

    # 1. Сбор
    raw_data = scrape_laptops()

    # 2. Анализ
    deals = analyze_data(raw_data)

    # 3. Сохранение
    save_deals(deals)

    print(f"[{datetime.now()}] Найдено выгодных предложений: {len(deals)}")

if __name__ == "__main__":
    # Бесконечный цикл, который запускает проверку каждый час
    while True:
        run_pipeline()
        # Засыпаем на 3600 секунд (1 час)
        time.sleep(3600)

Ручной подход	Автоматизированный пайплайн
Требует ежедневного внимания и кликов	Работает автономно 24/7
Высокий риск пропустить выгодную цену	Мгновенно фиксирует изменения
Сложно анализировать сотни позиций	Pandas обрабатывает миллионы строк за секунды
Данные остаются только в голове или Excel	Данные доступны через API любому приложению

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

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