Python с нуля: чат-боты, веб, парсинг и основы ИИ-агентов

Старт в Python: установка, синтаксис и типы данных

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

Что именно нужно установить

Для комфортной работы достаточно трёх вещей:

Интерпретатор Python (сам язык)

Редактор кода (IDE)

Менеджер пакетов pip (обычно идёт вместе с Python)

!Схема показывает роли Python, pip и редактора в разработке

Установка Python

Windows

Скачайте установщик Python с официальной страницы: Python Downloads

Запустите установщик и обязательно отметьте галочку Add Python to PATH.

Завершите установку.

Проверка в терминале (PowerShell или cmd):

Если команда не находится, чаще всего причина в том, что Python не добавлен в PATH.

macOS

Скачайте установщик с официальной страницы: Python Downloads

Установите Python.

Проверка в терминале:

На macOS часто используется команда python3, потому что python может указывать на системный Python.

Linux

Обычно Python уже установлен. Проверка:

Если Python не установлен, используйте пакетный менеджер вашей системы (например, apt, dnf, pacman).

Редактор кода (IDE)

Подойдут два популярных варианта:

Visual Studio Code (лёгкий, бесплатный, много расширений)

PyCharm Community Edition (мощный IDE для Python)

Для VS Code полезно поставить расширение Python от Microsoft, оно добавляет подсветку, запуск, подсказки и отладчик.

Терминал и команды, которые понадобятся постоянно

python --version или python3 --version — проверить версию Python

python или python3 — запустить интерактивный режим (REPL)

pip --version — проверить pip

pip install <пакет> — установить библиотеку

Официальная справка по установке пакетов: Installing Python Modules

Проект, папка и виртуальное окружение

Зачем нужно виртуальное окружение

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

Создание и активация venv

В папке проекта выполните:

Активация:

Windows (PowerShell):

Windows (cmd):

macOS/Linux:

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

Официальная документация: venv — Creation of virtual environments

Первый запуск: «Hello, world!»

Создайте файл main.py:

Запуск:

Если вы видите текст в терминале — всё готово для дальнейшей работы.

Базовый синтаксис Python

Отступы вместо фигурных скобок

В Python блоки кода определяются отступами. Обычно это 4 пробела.

Пример:

Если сделать неправильный отступ, Python выдаст ошибку. Поэтому важно:

Не смешивать табы и пробелы

Привыкнуть к форматированию (IDE помогает)

Комментарии

Однострочный комментарий начинается с #

Переменные и имена

Переменная создаётся присваиванием:

Правила хорошего стиля:

Писать имена в snake_case: user_name, total_sum

Давать смысловые названия: message_text лучше, чем x

Ввод и вывод

print() выводит текст

input() читает строку из терминала

Важно: input() всегда возвращает тип str (строку), даже если вы ввели число.

Типы данных: основа будущих проектов

Тип данных определяет, что именно хранится в переменной и какие операции доступны.

Проверить тип можно функцией type():

Числа: int и float

int — целые числа: -2, 0, 15

float — числа с дробной частью: 3.14, -0.5

Пример:

Строки: str

Строка — это последовательность символов.

Частые операции:

Конкатенация (склеивание):

Длина строки:

Доступ к символам по индексу (нумерация с 0):

Форматирование строк: f-строки

f-строки — удобный способ вставлять значения переменных в текст.

Это особенно важно для чат-ботов: вы почти всегда будете собирать сообщения из данных.

Логический тип: bool

bool имеет два значения: True и False.

Сравнения возвращают bool:

Пустое значение: None

None означает «значение отсутствует».

Это пригодится, когда функция ещё ничего не вернула или данных пока нет.

Коллекции: хранение множества значений

Список: list

Список — изменяемая коллекция.

Когда пригодится:

Список сообщений

Список ссылок при парсинге

Очередь задач для простого агента

Кортеж: tuple

Кортеж похож на список, но обычно считается неизменяемым.

Словарь: dict

Словарь хранит пары ключ → значение.

Это один из самых важных типов для веба и API, потому что JSON очень похож на словари Python.

Множество: set

set хранит уникальные элементы.

Полезно для:

Удаления повторов

Быстрых проверок «содержится ли элемент»

Изменяемые и неизменяемые типы (важно для ошибок новичков)

В Python некоторые объекты можно менять «на месте», а некоторые — нет.

Обычно неизменяемые: int, float, bool, str, tuple

Обычно изменяемые: list, dict, set

Практический смысл:

Если вы «меняете строку», на самом деле создаётся новая строка.

Если вы передали список в функцию и изменили его, изменения увидят все, кто держит ссылку на этот список.

Мини-пример (наблюдение поведения ссылок):

Приведение типов: когда строка должна стать числом

Так как input() возвращает строку, для чисел нужно преобразование:

Распространённые функции:

int("123") → 123

float("3.14") → 3.14

str(10) → "10"

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

Полезная привычка: читать официальную документацию

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

The Python Tutorial

Built-in Types

Итог

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

Подключать библиотеки через pip и venv

Работать со строками и словарями как с основой сообщений и JSON

Собирать данные в списки и словари (парсинг)

Строить первые сценарии «агента»: состояние, действия, память (простые структуры данных)

Функции, модули и работа с файлами: основа практики

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

Эти три темы — основа для всего, что будет дальше в курсе:

В чат-ботах функции станут обработчиками команд и сообщений.

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

В парсинге функции разложат процесс на шаги (скачать → разобрать → сохранить).

В простых ИИ-агентах функции и модули помогут отделить состояние, действия и память, а файлы — стать самой простой “памятью”.

!Как функции, модули и файлы складываются в структуру проекта

Функции

Зачем нужны функции

Функция — это именованный кусок кода, который можно вызвать много раз. Это помогает:

Убирать повторы.

Делать код читаемым (по имени функции видно намерение).

Локализовать ошибки (проще тестировать маленькие части).

Как объявлять и вызывать

Минимальный пример:

Состав:

def — ключевое слово для объявления функции.

greet — имя.

name — параметр (то, что функция получает на вход).

тело функции — блок с отступом.

Возврат значения: return

print() показывает текст на экране, но не “возвращает” результат программе. Для результата используют return:

Важно:

return завершает выполнение функции.

Если return не указан, функция возвращает None.

Параметры, аргументы и значения по умолчанию

Функции могут иметь значения по умолчанию:

Термины:

параметр — переменная в объявлении (city).

аргумент — конкретное значение при вызове ("Казань").

Именованные аргументы

Именованные аргументы повышают читаемость:

Область видимости: что видно внутри и снаружи

Переменные, созданные внутри функции, обычно не видны снаружи:

Практическое правило для проектов: старайтесь передавать данные в функцию параметрами и возвращать результат через return, а не полагаться на “глобальные” переменные.

Докстроки

Докстрока — это строка в начале функции, которая описывает её назначение:

IDE и инструменты документации умеют показывать докстроки автоматически.

Официальная справка по функциям: The Python Tutorial — Defining Functions

Модули и импорт

Что такое модуль

Модуль — это обычный файл .py. Если у вас есть utils.py, то это модуль utils, и из него можно импортировать функции.

Пример структуры:

utils.py:

main.py:

Варианты импорта

Основные способы:

Импорт конкретных имён:

Импорт модуля целиком:

Импорт с псевдонимом (удобно, когда имя длинное):

Как Python ищет модули

Python сначала проверяет:

Встроенные модули стандартной библиотеки.

Пакеты, установленные в окружение (pip).

Файлы рядом с вашим скриптом и пути из sys.path.

Отсюда частая ошибка новичков: назвать свой файл как модуль стандартной библиотеки.

Пример плохой идеи:

файл json.py в проекте может помешать импортировать стандартный модуль json.

Официальная справка: The Python Tutorial — Modules

__name__ == "__main__": код, который не мешает импорту

Если модуль импортируют, обычно не хотят, чтобы он “сам запускался”. Для этого используют проверку:

Смысл:

Если вы запускаете файл напрямую, условие истинно.

Если файл импортирован, условие ложно.

Это особенно полезно для будущих проектов: модуль содержит функции, а запускной файл (например, main.py) — склеивает всё вместе.

Пакеты: папки с кодом

Когда модулей становится много, их группируют по папкам.

Пример (минимальная идея):

Файл __init__.py делает папку пакетом.

Работа с файлами

Файлы — это самый простой способ сохранить состояние между запусками программы. Например:

история сообщений бота;

настройки (токены, адреса API) — чаще через переменные окружения, но иногда через файл конфигурации;

результаты парсинга;

“память” простого агента.

Пути: относительные и абсолютные

относительный путь считается от текущей рабочей папки.

абсолютный путь начинается от корня диска.

Чтобы меньше ошибаться, часто используют pathlib:

Официальная справка: pathlib — Object-oriented filesystem paths

Чтение и запись текста через open()

Главное правило: открывайте файл через контекстный менеджер with, чтобы файл гарантированно закрылся.

Запись текста:

Чтение всего файла:

Режимы открытия:

"r" — чтение.

"w" — запись (перезапишет файл).

"a" — добавление в конец.

Официальная справка: open() — Built-in Functions

Частая практика: читать построчно

Это удобно для логов и больших файлов:

rstrip() убирает символ перевода строки с конца.

JSON: самый важный формат для API и ботов

В вебе и ботах вы постоянно встречаете JSON. В Python это чаще всего словари (dict) и списки (list).

Запись словаря в JSON-файл:

Чтение JSON-файла:

Параметры:

ensure_ascii=False — чтобы кириллица сохранялась читаемо.

indent=2 — чтобы файл был красиво отформатирован.

Официальная справка: json — JSON encoder and decoder

Ошибки файлов: что может пойти не так

Типовые ситуации:

файла нет (например, вы пытаетесь прочитать ещё не созданный файл);

нет прав доступа;

неверная кодировка.

Минимальная обработка через try/except:

Позже это пригодится в парсинге: сайт может быть недоступен, файл может отсутствовать, данные могут быть “кривыми”, и программа должна вести себя предсказуемо.

Официальная справка по исключениям: Errors and Exceptions

Мини-архитектура для ваших будущих проектов

Чтобы уже сейчас писать код в стиле “как в настоящем проекте”, используйте простую идею:

main.py — точка входа, в ней мало логики.

handlers.py или services.py — функции бизнес-логики.

storage.py — функции чтения/записи (JSON/текст).

Пример мыслительной модели:

обработчик получает данные (строки, словари);

вызывает функции обработки;

сохраняет результат в файл.

Так вы подготовитесь к следующей части курса, где к проекту добавятся внешние библиотеки, HTTP-запросы, парсинг страниц и первые чат-боты.

Итог

Теперь вы умеете:

Писать функции и возвращать результат через return.

Организовывать код по модулям и импортировать нужные части.

Безопасно читать и записывать файлы через with open(...).

Хранить данные в JSON — ключевом формате для API, веба и ботов.

Это “скелет” практики: дальше мы начнём подключать библиотеки, работать с внешними данными и постепенно собирать первые реальные приложения.

HTTP и API: запросы, JSON и интеграции

В прошлых статьях вы настроили Python, разобрались с типами данных, научились писать функции, делить код на модули и сохранять данные в файлы (в том числе в JSON). Теперь сделаем следующий шаг к реальным проектам: научимся получать и отправлять данные по сети через HTTP и работать с API.

Это напрямую связано с целями курса:

В чат-ботах вы будете дергать внешние сервисы (погода, курсы валют, базы знаний).

В парсинге вы будете скачивать страницы и данные.

В веб-разработке вы будете писать свои HTTP-обработчики.

В простых ИИ-агентах вы будете собирать информацию из разных источников и хранить результаты.

!Схема показывает, что клиент отправляет HTTP-запрос, а API возвращает HTTP-ответ

Что такое HTTP

HTTP (HyperText Transfer Protocol) — это набор правил, по которым клиент (например, ваш Python-скрипт) общается с сервером (например, сервисом с данными).

Общение устроено так:

Клиент отправляет запрос.

Сервер возвращает ответ.

Важно: HTTP сам по себе не “про Python”. Это универсальный протокол, поэтому навыки из этой статьи пригодятся везде.

Полезная справка: HTTP overview

Что такое API

API (Application Programming Interface) в контексте веба обычно означает: сервер предоставляет набор URL-адресов (эндпоинтов), на которые можно отправлять HTTP-запросы и получать структурированные ответы.

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

Эндпоинт — конкретный URL, который делает конкретное действие (например, “получить пользователя”).

Интеграция — подключение вашего приложения к внешнему API (вы отправляете запросы и используете ответы).

Из чего состоит HTTP-запрос

Запрос обычно включает:

Метод — что мы хотим сделать.

URL — куда обращаемся.

Заголовки (headers) — служебные данные (например, что мы ждём JSON, или токен доступа).

Тело (body) — данные запроса (чаще нужно для создания/обновления данных).

Методы HTTP

Самые популярные методы:

GET — получить данные.

POST — отправить данные для создания (или запуска действия).

PUT — полностью заменить ресурс.

PATCH — частично обновить ресурс.

DELETE — удалить ресурс.

Справка: HTTP request methods

Статус-коды ответа

Сервер отвечает статус-кодом. Частые варианты:

200 OK — всё хорошо.

201 Created — успешно создано (часто после POST).

400 Bad Request — запрос неправильный (например, не те поля).

401 Unauthorized — нет авторизации (нет токена или он неверный).

403 Forbidden — доступ запрещён (например, токен есть, но прав нет).

404 Not Found — не найдено.

429 Too Many Requests — слишком много запросов (ограничение по частоте).

500 Internal Server Error — ошибка на стороне сервера.

Справка: HTTP response status codes

JSON как основной формат данных

В API чаще всего данные передаются в формате JSON. В Python он напрямую соответствует привычным типам:

| JSON | Python | |---|---| | object | dict | | array | list | | string | str | | number | int или float | | boolean | bool | | null | None |

!Визуально показывает, как JSON превращается в типы Python

JSON в стандартной библиотеке Python: json — JSON encoder and decoder

Как отправлять HTTP-запросы из Python

Есть два пути:

Стандартная библиотека (можно, но код обычно более “низкоуровневый”).

Библиотека requests (самый популярный вариант для обучения и практики).

Мы будем использовать requests, потому что она делает код короче и понятнее.

Документация: Requests: HTTP for Humans

Установка requests

Убедитесь, что вы в виртуальном окружении venv (как в прошлой теме), и выполните:

Первый GET-запрос

Возьмём публичный API GitHub (он не требует ключа для простых запросов):

Базовый адрес: https://api.github.com

Эндпоинт пользователя: /users/{username}

Пример: получим данные пользователя octocat.

Что здесь происходит:

requests.get(...) отправляет GET-запрос.

timeout=10 говорит: “ждать максимум 10 секунд”, иначе считать это ошибкой.

response.status_code содержит статус-код.

response.headers содержит заголовки ответа.

response.text содержит тело ответа как строку.

Как получить JSON как словарь Python

Если сервер реально вернул JSON, удобнее всего использовать response.json().

raise_for_status() полезен в проектах: вместо “тихой” ошибки вы сразу увидите проблему, и сможете обработать её через try/except.

Параметры запроса: query string

Иногда данные передают в URL после ?, например ?page=2&per_page=50. Это называется query parameters.

В requests их правильно передавать через аргумент params.

Пример: запросим репозитории пользователя и ограничим количество результатов (GitHub использует параметр per_page).

Почему так лучше, чем собирать строку руками:

requests сам корректно экранирует значения.

код проще читать.

Заголовки: Content-Type, Accept и Authorization

Заголовки (headers) — это служебные поля запроса/ответа. Три самых практичных:

Accept — “я хочу получить ответ вот в таком формате”.

Content-Type — “я отправляю данные вот в таком формате” (важно для POST/PUT/PATCH).

Authorization — “вот мой токен, пустите меня”.

Справка: HTTP headers

Пример: передать заголовки

POST-запрос и отправка JSON

Когда вы отправляете данные на сервер (например, создаёте запись), обычно используют POST.

В requests удобно отправлять JSON через аргумент json=: библиотека сама:

сериализует словарь Python в JSON,

выставит правильный Content-Type.

Пример ниже показывает форму запроса, но сам URL условный (потому что не у каждого API есть публичный эндпоинт для создания данных без ключа):

Идея, которую важно понять:

payload в Python это dict.

json=payload превращает его в JSON в теле запроса.

сервер читает JSON и выполняет действие.

Авторизация: API-ключи и токены

Многие API требуют авторизацию. Чаще всего это один из вариантов:

API key — “ключ приложения”.

Bearer token — “токен доступа”, который кладут в заголовок Authorization.

Справка по заголовку: Authorization header

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

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

Если token равен None, значит переменная окружения не установлена. Это нормальная ситуация: ваш код должен уметь понятным образом сообщить об этом.

Ошибки сети и предсказуемое поведение

Интеграции почти всегда ломаются по внешним причинам: интернет пропал, сервис временно недоступен, сервер отвечает медленно. Поэтому в практике важно:

ставить timeout,

обрабатывать исключения,

проверять статус-коды.

Пример обработки:

requests.RequestException это базовый класс для большинства ошибок requests, поэтому он удобен как “последний уровень защиты”.

Мини-интеграция: получить данные из API и сохранить в JSON-файл

Свяжем эту тему с предыдущей статьёй (файлы и JSON) и сделаем полезный шаблон: запрос → проверка → сохранение результата.

Что важно в этом примере:

Функция fetch_github_user отвечает только за HTTP и возвращает dict.

Функция save_json отвечает только за сохранение.

main() “склеивает” шаги в сценарий.

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

Ограничения API: лимиты, пагинация, политика использования

Когда вы работаете с реальными API, часто встречаются правила:

Rate limit — ограничение на количество запросов за период.

Пагинация — данные приходят страницами (например, по 30 элементов).

Требования к User-Agent — некоторые сервисы ожидают, что вы укажете, кто вы.

По GitHub API можно начать с официальной документации: GitHub REST API documentation

Практический вывод: если API неожиданно начал отвечать ошибками, первым делом смотрите:

статус-код,

текст ошибки в ответе,

документацию по лимитам и параметрам.

Итог

Теперь вы понимаете и умеете:

Объяснить, что такое HTTP-запрос и HTTP-ответ.

Различать методы GET/POST и статус-коды.

Получать JSON-ответ и превращать его в dict и list.

Передавать query-параметры и заголовки.

Делать простые интеграции: запросить данные и сохранить в JSON-файл.

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

Парсинг сайтов: HTML, BeautifulSoup и основы Scrapy

Парсинг (web scraping) — это получение данных с веб-страниц и преобразование их в удобный для программы вид: списки, словари, таблицы, JSON-файлы.

Эта тема логично продолжает предыдущие статьи курса:

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

В статье про HTTP и API вы научились отправлять запросы и обрабатывать ответы.

Теперь мы объединяем это в практический конвейер: скачать HTML → разобрать HTML → извлечь данные → сохранить.

!Конвейер парсинга от запроса до сохранения данных

Что такое HTML и почему его нужно разбирать

HTML — это текст, который описывает структуру страницы: заголовки, блоки, ссылки, таблицы. Браузер рисует страницу, читая HTML и связанные ресурсы.

Важно понимать две идеи:

HTML — это не данные в чистом виде, а разметка.

Для парсинга нужно найти нужные элементы по признакам: тегам, классам, атрибутам, расположению.

Полезные справки:

MDN: Введение в HTML

MDN: Основы CSS-селекторов

Этичность и правила: robots.txt, нагрузка и условия использования

Перед тем как парсить сайт, думайте не только о коде.

Проверьте правила сайта

1. Часто ограничения описаны в условиях использования. 2. Также есть файл robots.txt по адресу вида https://example.com/robots.txt.

Не создавайте нагрузку

1. Делайте паузы между запросами. 2. Используйте кэширование (сохраняйте уже скачанные страницы в файлы).

Идентифицируйте запросы

1. Указывайте User-Agent.

Уважайте приватность

1. Не собирайте персональные данные без законных оснований.

Справка про robots.txt:

Google: спецификация robots.txt

Базовая архитектура парсера

Хорошая привычка из предыдущих тем: разделять ответственность.

Модуль network или функция fetch_html(url) отвечает только за скачивание.

Модуль parse или функция parse_items(html) отвечает только за извлечение данных.

Модуль storage или функция save_json(data, path) отвечает только за сохранение.

Такой стиль пригодится и дальше:

в чат-ботах это станет обработчиками и сервисами;

в вебе это станет слоями приложения;

в ИИ-агентах это станет шагами наблюдение → обработка → действие → память.

Получаем HTML: requests и базовая защита от ошибок

Для скачивания страниц обычно достаточно requests.

Что важно:

timeout защищает от зависания.

raise_for_status() превращает ответы 4xx/5xx в исключения.

User-Agent уменьшает шанс, что сайт сразу заблокирует запрос.

Разбор HTML с BeautifulSoup

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

Документация:

Beautiful Soup Documentation

Установка

Иногда полезен ускоренный парсер lxml:

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

Термины:

soup — объект, представляющий страницу как дерево.

find("title") — найти первый тег <title>.

get_text(strip=True) — получить текст без лишних пробелов.

!Как HTML превращается в дерево элементов для поиска

Поиск элементов: find, find_all и атрибуты

Частые задачи:

найти карточки товара;

внутри карточки взять название, цену, ссылку;

собрать список словарей.

Пример типового шаблона:

Полезные приёмы:

tag.get("attr") безопаснее, чем tag["attr"], потому что вернёт None, если атрибута нет.

find_all(...) возвращает список найденных элементов.

CSS-селекторы через select

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

Здесь:

.product-card означает элементы с классом product-card.

.product-card .title означает элементы с классом title внутри .product-card.

Относительные ссылки и склейка URL

На сайтах часто встречаются ссылки вида /catalog/item1, а не полный URL.

Правильно склеивать такие ссылки через urllib.parse.urljoin.

Документация:

urllib.parse — URL parsing

Практический мини-проект: спарсить страницу и сохранить результат в JSON

Ниже пример, который объединяет темы HTTP, парсинга и файлов.

Что здесь важно с точки зрения инженерного подхода:

Вы можете тестировать parse_articles отдельно, подставляя сохранённый HTML из файла.

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

Типичные проблемы парсинга и как их решать

Динамический контент

Если данные подгружаются JavaScript-ом, в HTML-ответе их может не быть.

Признаки:

В браузере вы видите список товаров, а в скачанном HTML их нет.

В HTML есть пустой контейнер, а данные приходят отдельным запросом.

Что делать:

Откройте инструменты разработчика в браузере, вкладку Network.

Найдите запрос, который возвращает данные (часто это JSON).

Парсите не HTML, а этот API-запрос.

Этот подход напрямую использует знания из статьи про HTTP и API.

Нестабильная вёрстка

Классы и структура могут меняться.

Практичные рекомендации:

Старайтесь искать элементы по устойчивым признакам: смысловым атрибутам, структуре, ссылкам.

Делайте проверки на None, чтобы парсер не падал из-за одной карточки.

Логируйте проблемные места: сохраняйте HTML страницы в файл при ошибке.

Кодировка

requests обычно корректно определяет кодировку, но бывают исключения.

Если видите “кракозябры”, попробуйте:

Когда BeautifulSoup уже недостаточно

BeautifulSoup отлично подходит для:

одного сайта;

небольшого количества страниц;

простых правил извлечения.

Но если нужно:

проходить по многим страницам;

планировать обход (очередь ссылок);

автоматически соблюдать задержки;

работать с повторными попытками;

вести статистику и пайплайны сохранения,

то удобнее использовать фреймворк Scrapy.

Основы Scrapy: идея фреймворка

Scrapy — это фреймворк для построения пауков (spiders), которые обходят сайты и извлекают данные.

Документация:

Scrapy Documentation

Ключевые понятия Scrapy

Spider — класс, который описывает, с каких URL начинать и как извлекать данные.

Request — запрос на страницу.

Response — ответ со страницей.

Item — структура данных результата (часто словарь).

Pipeline — шаг обработки результата (например, запись в файл).

Главное отличие от простого скрипта на requests:

Scrapy сам управляет очередью запросов и обработкой ответов.

Scrapy рассчитан на большое количество страниц.

Как выглядит минимальный Spider

Пример показывает форму и идеи. Сайт используйте тот, который разрешает парсинг.

Что здесь происходит:

start_urls — точки входа.

parse — метод, который Scrapy вызовет на каждый ответ.

response.css("title::text").get() — взять текст тега title.

yield возвращает результат, который Scrapy соберёт и передаст дальше.

Чем selectors в Scrapy отличаются от BeautifulSoup

В BeautifulSoup вы работаете с soup.find(...) и soup.select(...).

В Scrapy вы чаще используете response.css(...) или response.xpath(...).

Оба подхода базируются на одной идее: выбор элементов по структуре страницы, но Scrapy добавляет масштабируемый обход.

Итог

Вы научились собирать базовый парсер как проект:

скачивать HTML через requests и аккуратно обрабатывать ошибки;

разбирать HTML с BeautifulSoup и извлекать данные через find_all и CSS-селекторы;

нормализовать ссылки через urljoin;

сохранять результаты в JSON и строить код из функций и модулей;

понимать, когда стоит перейти на Scrapy, и как выглядит минимальный паук.

Эти навыки напрямую лягут в практику курса:

парсинг как источник данных для чат-ботов;

сбор данных как “сенсоры” для простых ИИ-агентов;

подготовка данных для веб-приложений и интеграций.

Чат-боты: Telegram-бот на Python и обработка команд

Чат-боты — один из самых быстрых способов превратить знания Python в реальный проект. В этой статье вы соберёте Telegram-бота, научитесь обрабатывать команды и обычные сообщения, а также подключите внешнее API (как в прошлой теме про HTTP) и добавите простую “память” через JSON-файл (как в теме про файлы).

Как устроены Telegram-боты

Telegram-бот — это программа, которая получает обновления (сообщения, команды, нажатия кнопок) и отправляет ответы через Telegram Bot API.

Ключевые термины:

Bot API — HTTP API Telegram для ботов.

Update — входящее событие (сообщение, команда и т.д.).

Handler — функция-обработчик, которая реагирует на определённый тип update.

Polling — бот сам регулярно спрашивает Telegram: “есть ли новые сообщения?”.

Webhook — Telegram сам отправляет события на ваш сервер.

Мы начнём с polling, потому что он проще и не требует сервера.

!Схема потока сообщений в Telegram-боте

Полезные официальные ссылки:

Telegram Bot API

BotFather

Создаём бота в Telegram через BotFather

Откройте BotFather в Telegram.

Отправьте команду \newbot.

Задайте имя бота (отображаемое) и username (должен оканчиваться на bot, например my_course_helper_bot).

BotFather выдаст токен вида 123456:ABC-DEF....

Токен — это ключ доступа. Его нельзя публиковать и коммитить в GitHub.

Подготовка проекта

Создайте папку проекта, например telegram_bot.

Создайте и активируйте виртуальное окружение (как в прошлых статьях).

Установите библиотеку для Telegram.

В этой статье используем pyTelegramBotAPI (она же telebot) как один из самых простых вариантов для старта.

pytelegrambotapi — работа с Telegram.

requests — пригодится для интеграций с внешними API.

Документация библиотеки:

pyTelegramBotAPI (GitHub)

Безопасно храним токен: переменная окружения

Не пишите токен прямо в коде. Вместо этого храните его в переменной окружения.

Примеры установки:

Windows PowerShell:

macOS/Linux (для текущей сессии терминала):

В коде токен читается через os.getenv.

Минимальный бот: команда /start и “эхо”

Создайте файл main.py:

Запуск:

Что здесь важно:

@bot.message_handler(commands=[...]) — обработчик команд.

@bot.message_handler(content_types=["text"]) — обработчик обычного текста.

infinity_polling(...) — бесконечный цикл, который получает updates.

Как проектировать обработчики: идея “роутинга”

С практической точки зрения команды и сообщения — это разные входы в вашу программу.

Удобная модель для новичка:

Команды делают конкретное действие: показать справку, запустить сценарий, запросить данные.

Текстовые сообщения обрабатываются либо как “эхо”, либо как часть сценария (например, бот задаёт вопрос, пользователь отвечает).

Чтобы не превращать main.py в “простыню”, лучше заранее разделять код по модулям.

Структура проекта “как в реальной практике”

Сделаем минимальную структуру, где:

main.py — точка входа.

handlers.py — обработчики команд и сообщений.

services.py — работа с внешними API.

storage.py — чтение/запись JSON.

Пример структуры:

storage.py: простая “память” в JSON

Сохраним последние сообщения пользователя. Это будет полезно позже, когда вы начнёте делать простые ИИ-агенты с памятью.

services.py: интеграция с внешним API (погода)

Возьмём сервис Open-Meteo (у него есть публичная документация и часто не нужен ключ для базовых запросов).

Документация:

Open-Meteo API Docs

Нам нужны два шага:

Найти координаты города через geocoding.

Получить текущую температуру по координатам.

handlers.py: команды и логика ответов

main.py: склейка проекта

Что вы получили в итоге:

Отдельные обработчики команд.

Интеграцию с внешним API через requests.

Хранение простого состояния в JSON.

Структуру проекта, которая масштабируется.

Polling и webhook: когда что нужно

Polling подходит, когда вы учитесь и запускаете бота “на своём компьютере”.

Webhook нужен, когда бот должен работать всегда и у вас есть сервер с публичным адресом (обычно вместе с HTTPS).

На уровне курса важно понять принцип: входящие события должны попадать в ваш код либо через опрос (polling), либо через доставку на сервер (webhook).

Типичные ошибки и как их диагностировать

Бот молчит и не отвечает:

- проверьте, что токен правильный; - проверьте, что скрипт реально запущен и не завершился с ошибкой; - попробуйте написать боту /start ещё раз.

Ошибки сети при запросе к API:

- используйте timeout (как в примерах); - оборачивайте интеграции в try/except и отвечайте пользователю понятным текстом.

Код разрастается:

- выносите сетевые запросы в services.py; - выносите JSON-хранилище в storage.py.

Итог

Теперь вы умеете:

Создать Telegram-бота через BotFather и подключить токен безопасно.

Запустить бота в режиме polling.

Обрабатывать команды и текстовые сообщения через handlers.

Делать интеграции с внешними API через requests.

Хранить простую “память” в JSON и проектировать код по модулям.

Дальше эти навыки легко расширяются: кнопки, сценарии диалога, больше интеграций, а затем — связка с парсингом и основами ИИ-агентов (наблюдение → действие → память).

Веб-разработка: Flask/FastAPI, маршруты и база данных

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

Практический смысл для курса:

Чат-бот может стать клиентом вашего веб-сервиса.

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

Простые ИИ-агенты часто состоят из HTTP-интерфейса, хранилища (БД) и набора действий.

!Общая картина того, как запрос проходит через маршруты, логику и базу данных

Что такое веб-приложение на Python

Веб-приложение в минимальном виде делает две вещи:

Принимает HTTP-запросы на определённые адреса.

Возвращает HTTP-ответы с данными (часто JSON) и статус-кодами.

Основной термин этой статьи:

Маршрут (route) — правило вида метод + путь, например GET /notes.

Flask и FastAPI: что выбрать

И Flask, и FastAPI позволяют написать веб-сервер на Python. Для старта важнее понять общие идеи: маршруты, запросы, ответы и работа с базой данных.

| Критерий | Flask | FastAPI | |---|---|---| | Стиль | Минималистичный, очень гибкий | Современный API-подход, много “из коробки” | | Типичный формат ответа | HTML или JSON | JSON и API по умолчанию | | Валидация данных | Обычно вручную или через расширения | Обычно автоматически через модели | | Документация API | Нужно подключать отдельно | Есть автоматически (/docs) |

В этой статье основной пример будет на FastAPI, потому что он хорошо подходит для API (а значит, напрямую связан с темами про HTTP, JSON, ботов и интеграции). В конце вы увидите, как выглядит аналогичный маршрут во Flask.

Официальные ссылки:

Документация Flask

Документация FastAPI

Подготовка окружения и установка зависимостей

Создайте проект, активируйте venv (как вы делали ранее) и установите зависимости:

fastapi — библиотека для описания маршрутов и логики.

uvicorn — сервер, который запускает ваше приложение.

Первое веб-приложение на FastAPI

Создайте файл main.py:

Запуск сервера:

После запуска:

Откройте http://127.0.0.1:8000/ в браузере.

Вы увидите JSON-ответ.

Полезная особенность FastAPI:

http://127.0.0.1:8000/docs — интерактивная документация, где можно нажимать кнопки и вызывать ваши маршруты.

Маршруты: путь, параметры и query-параметры

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

Параметр пути — это часть URL, которая меняется.

Примеры:

GET /hello/ira вернёт приветствие для ira.

GET /hello/oleg вернёт приветствие для oleg.

Query-параметры

Query-параметры передаются после ?, как вы уже видели в теме про HTTP и API.

Пример:

GET /search?q=python&limit=5.

HTTP-статусы и ошибки

Как и в клиентских запросах через requests, на сервере важно возвращать корректные статус-коды.

200 — успех.

404 — не найдено.

400 — неверный запрос.

Справочник по статус-кодам:

HTTP response status codes

Пример ошибки через HTTPException:

Данные запроса: JSON-тело (POST) и модели

Когда клиент отправляет данные (например, создаёт заметку), чаще всего используется POST и JSON-тело.

В FastAPI удобно описывать структуру JSON через модель.

Что важно понять:

Клиент присылает JSON.

FastAPI превращает его в объект NoteCreate.

Если нужного поля нет или тип не совпадает, FastAPI вернёт ошибку автоматически.

Документация моделей:

Pydantic documentation

Мини-архитектура проекта: как не превратить код в один файл

Из прошлых тем у вас уже есть полезная привычка: делить код на модули. Для веб-проекта это так же важно.

Минимальная структура:

main.py — точка входа и создание приложения.

routes.py — маршруты.

services.py — бизнес-логика.

db.py — работа с базой данных.

Пример структуры:

База данных: зачем она нужна и почему начнём с SQLite

Файлы JSON полезны как простая “память”, но база данных удобнее, когда:

данных становится много;

нужно искать и фильтровать;

важна надёжность записи;

доступ к данным идёт из разных частей проекта.

Для обучения отлично подходит SQLite:

это файл на диске;

не нужен отдельный сервер;

работает из стандартной библиотеки Python.

Официальная справка:

SQLite

sqlite3 — DB-API 2.0 interface for SQLite databases

Реализация хранилища заметок на SQLite

Сделаем простое API для заметок:

POST /notes — создать заметку.

GET /notes — получить список заметок.

db.py: подключение и функции для базы

Идеи из предыдущих тем, которые здесь используются:

pathlib для путей.

with ... as ... для безопасного закрытия ресурсов.

функции как “контракты”: отдельно база, отдельно веб-логика.

routes.py: маршруты API

main.py: сборка приложения

Запуск:

Проверьте через http://127.0.0.1:8000/docs:

Создайте заметку через POST /notes.

Получите список через GET /notes.

Как это связано с парсингом и чат-ботами

Это один из самых полезных “склеивающих” сценариев для курса:

Парсер (из темы про BeautifulSoup) собирает данные и сохраняет их в SQLite.

Веб-приложение показывает эти данные пользователю как API.

Telegram-бот делает запрос к вашему API через requests и показывает результат в чате.

Так вы получаете маленькую экосистему из нескольких компонентов, которые общаются по HTTP.

Как выглядел бы аналогичный маршрут во Flask

Flask тоже умеет отдавать JSON. Пример минимального маршрута:

Если вы уже чувствуете себя уверенно, вы можете повторить мини-проект с заметками на Flask. Концепции останутся теми же: маршрут, JSON, база.

Итог

Теперь вы понимаете основу веб-разработки на Python:

что веб-приложение принимает HTTP-запросы и возвращает HTTP-ответы;

что маршрут определяется методом и путём;

как передавать параметры через путь и через query string;

как принимать JSON-тело запроса и валидировать структуру;

как подключить простую базу данных SQLite и построить минимальный CRUD-сценарий;

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

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

Основы ИИ-агентов: LLM API, инструменты и простая оркестрация

В прошлых темах вы научились:

Отправлять HTTP-запросы и работать с JSON

Парсить HTML (BeautifulSoup)

Делать Telegram-бота как интерфейс

Писать веб-API на FastAPI и хранить данные в SQLite

Теперь соберём это в одну картину и разберёмся с ИИ-агентами: как подключать LLM по API, как давать модели инструменты (ваши функции на Python) и как сделать простую оркестрацию — цикл, в котором модель решает, что делать дальше.

!Общая схема ИИ-агента: Python управляет циклом, LLM предлагает шаги, инструменты выполняют действия, память хранит состояние

Что такое ИИ-агент

ИИ-агент в учебном и практическом смысле — это программа, которая:

Получает задачу (обычно текстом)

Может вызывать действия во внешнем мире (инструменты, API, базы, файлы)

Использует результат действий, чтобы продолжать работу

Возвращает итоговый ответ

Важная мысль: агент — это не только модель. Модель (LLM) умеет генерировать текст и рассуждать, но инструменты, память, сетевые запросы, парсинг и бизнес-логика — это ваш Python-код.

Базовые термины

LLM (Large Language Model) — языковая модель, которая генерирует текст и может следовать инструкциям

LLM API — веб-интерфейс (HTTP), через который вы отправляете запросы к модели и получаете ответы

Промпт — входная инструкция/контекст для модели

Сообщения роли — способ задавать контекст диалога: обычно system, user, assistant

Инструмент (tool) — функция/сервис, который агент может вызвать

Оркестрация — код, который управляет порядком шагов (когда спросить модель, когда вызвать инструмент, когда остановиться)

Память — место, где агент хранит состояние: файл JSON, SQLite, ваш веб-сервис

LLM как API: почему это похоже на темы про HTTP

LLM-сервисы обычно работают так же, как любой другой API:

Вы делаете HTTP-запрос (часто POST)

Отправляете JSON с параметрами: модель, сообщения, настройки

Получаете JSON-ответ с текстом и метаданными

Поэтому всё, что вы изучали в теме про HTTP (requests, JSON, обработка ошибок, timeout) напрямую применяется здесь.

Безопасность ключей: только переменные окружения

Почти все LLM API требуют ключ.

Правило курса:

Не храните ключ в коде

Читайте его через os.getenv(...)

Это та же практика, что вы использовали для токена Telegram-бота.

Пример: минимальный вызов LLM через официальный SDK (OpenAI)

Ниже пример формы работы через SDK. Перед запуском установите библиотеку и задайте ключ.

Ссылки на документацию:

Документация OpenAI API

Python SDK OpenAI

Установка:

Переменная окружения:

OPENAI_API_KEY

Код:

Что важно понять в этом примере:

Вы передаёте сообщения, а не одну строку

Роль system задаёт общий стиль и правила

Роль user содержит задачу пользователя

temperature управляет вариативностью: меньше — более предсказуемо

Ограничения и качество: контекст и проверяемость

При работе с LLM есть две практические особенности.

Контекст не бесконечный

Модель не “помнит всё” бесконечно. У любой модели есть ограничение на объём входных данных. Поэтому:

Делайте ответы короче, если это возможно

Не отправляйте в модель лишний текст

Длинные данные храните отдельно (файл, БД) и передавайте только нужные фрагменты

LLM может ошибаться

Модель может:

Придумать факты

Неправильно интерпретировать запрос

Дать нестрогое решение

Вывод: если нужна точность, давайте агенту инструменты, которые получают проверяемые данные (ваш API, база, парсер, расчёты в Python), и заставляйте модель опираться на результаты инструментов.

Инструменты: как “дать агенту руки”

Инструмент — это обычная функция Python, которая делает полезное действие:

запрос к вашему FastAPI

чтение из SQLite

парсинг HTML

вычисления

В этой статье мы сделаем простой набор инструментов и научим агента выбирать: отвечать сразу или вызвать инструмент.

Набор инструментов для учебного агента

Мы используем то, что уже изучали в курсе:

fetch_url(url) — скачать страницу через requests

parse_title(html) — достать <title> через BeautifulSoup

calc(expression) — безопасное вычисление простых выражений

Установка для парсинга (если ещё не ставили):

Requests

Beautiful Soup

Код инструментов:

Почему калькулятор не должен быть eval(...):

eval может выполнить произвольный код

агент — это программа, которая получает текст извне

Ограниченный разбор через ast делает инструмент безопаснее для обучения.

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

Разные LLM-провайдеры по-разному реализуют function calling / tools. Чтобы не привязываться к конкретному API, можно начать с простого протокола:

Вы просите модель отвечать строго JSON-объектом

В JSON модель либо возвращает финальный ответ, либо просит вызвать инструмент

Формат решения:

Если нужен инструмент:

- { "action": "tool", "tool_name": "fetch_url", "args": {"url": "..."} }

Если ответ готов:

- { "action": "final", "answer": "..." }

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

Простая оркестрация: цикл "модель → инструмент → модель"

Ниже минимальный оркестратор. Он:

Формирует инструкции для модели

Парсит JSON-решение

Если модель просит инструмент — вызывает его

Возвращает результат инструмента обратно в модель

Останавливается, когда модель вернула final

Что вы здесь тренируете как разработчик:

Вы задаёте контракт между моделью и кодом (формат JSON)

Вы контролируете “внешний мир” (инструменты и их ограничения)

Вы ограничиваете количество шагов, чтобы агент не зациклился

Как связать агента с темами курса

Telegram-бот как интерфейс агента

Ваш Telegram-бот из прошлой темы может быть тонкой оболочкой:

Получает сообщение пользователя

Передаёт текст в agent_answer(...)

Отправляет результат обратно

Так вы превращаете “скрипт с агентом” в реальное приложение.

FastAPI как набор инструментов

Ваше веб-приложение (например, заметки на SQLite) можно превратить в инструмент агента:

get_notes(limit)

create_note(text)

Технически это просто requests к http://127.0.0.1:8000/... (то есть повторение темы про HTTP).

Парсинг как инструмент добычи данных

Сценарий, который часто встречается в “полезных” агентах:

fetch_url скачивает страницу

parse_* извлекает нужные данные (заголовок, ссылки, таблицу)

модель формирует итоговое резюме

Это и есть практическая связка: модель думает, Python добывает данные.

Память агента: минимальный, но полезный вариант

Для старта достаточно памяти на JSON или SQLite.

Простой подход:

Сохранять историю задач и ответов

Сохранять результаты инструментов (или ссылки на файлы)

Это повторяет тему “работа с файлами”, только теперь это память для агента.

Если вы делаете много записей и нужен поиск, используйте SQLite (как в теме про веб и БД).

Типичные ошибки новичков в агентах

Слишком много логики в промпте: лучше переносить логику в Python и инструменты

Нет ограничений по шагам: агент может зациклиться

Нет таймаутов и обработки ошибок у инструментов: сеть падает, сайты недоступны

Слепое доверие модели: важные данные нужно получать инструментами и проверять

Итог

Теперь у вас есть базовая модель того, как строятся ИИ-агенты на Python:

LLM подключается как обычный API и возвращает структурированный ответ

Инструменты — это ваши функции (HTTP, парсинг, БД), которые делают работу проверяемой

Оркестрация — это цикл, в котором Python управляет шагами и остановкой

Память — это файлы JSON или SQLite, которые сохраняют состояние между запусками

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