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

Старт: установка, среда разработки, запуск программ и работа с Git

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

Python и пакеты

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

редактор (IDE)

запуск кода

Git для истории изменений и командной работы

!Общая картина: из чего состоит ежедневная работа над Python-проектом

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

Минимальный набор:

Python 3 (рекомендуется актуальная стабильная версия)

редактор кода (обычно Visual Studio Code или PyCharm)

Git

Полезно (но не обязательно в первый день): аккаунт на GitHub.

Установка Python

Проверяем, установлен ли Python

Откройте терминал:

Windows: PowerShell или Windows Terminal

macOS: Terminal

Linux: любой терминал

И проверьте версии:

На Windows часто используется команда py:

Если версия не выводится или команда не найдена — ставим Python.

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

Скачайте установщик с сайта Python Downloads.

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

Важно: поставьте галочку Add python.exe to PATH.

После установки снова проверьте:

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

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

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

Проверьте версии:

На macOS команда python может указывать на системный Python (или быть недоступной). В учебных проектах обычно безопаснее использовать python3.

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

Python часто уже установлен. Проверьте:

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

Редактор кода (IDE): VS Code или PyCharm

Visual Studio Code

Установите Visual Studio Code.

Поставьте расширение Python от Microsoft (внутри VS Code: Extensions → Python).

Откройте папку проекта через File → Open Folder.

PyCharm

Установите PyCharm Community Edition.

Создайте или откройте проект.

Оба варианта подходят. Важно не то, какая кнопка где находится, а чтобы вы умели:

открыть папку проекта

создать файл .py

запустить код

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

Терминал: базовые команды

Терминал — это место, где вы запускаете Python, устанавливаете пакеты и выполняете команды Git.

Минимум полезных команд:

cd — перейти в папку

dir (Windows) или ls (macOS/Linux) — показать содержимое

mkdir — создать папку

Пример:

Проект на Python: папка, файл, запуск

Создайте папку проекта и файл main.py:

Запуск:

macOS/Linux:

Windows (часто так надёжнее):

Если всё настроено правильно, вы увидите текст в терминале.

Интерактивный режим (REPL)

Иногда удобно быстро проверить выражение или функцию:

macOS/Linux:

Windows:

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

Виртуальное окружение: зачем оно нужно

Виртуальное окружение — это отдельная «коробка» с пакетами Python для конкретного проекта.

Зачем:

разные проекты могут требовать разные версии библиотек

вы не засоряете глобальную установку Python

проще повторить окружение на другом компьютере

Создаём виртуальное окружение

Находясь в папке проекта:

macOS/Linux:

Windows:

Здесь:

-m venv — запускает встроенный модуль создания окружения

.venv — папка, где будет лежать окружение (часто так и называют)

Подробности: venv — Creating virtual environments.

Активируем окружение

macOS/Linux:

Windows (PowerShell):

Windows (cmd):

После активации команды python/pip будут относиться к окружению проекта.

Устанавливаем пакеты через pip

pip — стандартный установщик библиотек Python.

Обновить pip:

Установить библиотеку (пример):

Документация: pip — Installation.

Фиксируем зависимости

Чтобы другой человек (или вы через месяц) смог повторить набор библиотек:

Установка из списка:

Рекомендуемая структура проекта на старте

Простой вариант для учебных задач:

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

requirements.txt — зависимости

.venv/ — виртуальное окружение (эту папку в Git обычно не добавляют)

Позже, когда начнём чат-ботов/веб, структура станет чуть богаче, но принципы останутся.

Git: контроль версий без боли

Git — система контроля версий. Она помогает:

сохранять историю изменений

откатываться к рабочим версиям

вести разработку в ветках

отправлять код на GitHub

Сайт Git: Git.

Установка Git

Установите Git с Git Downloads, затем проверьте:

Создаём репозиторий

Внутри папки проекта:

Это создаст скрытую папку .git/ с историей.

Настраиваем имя и email

Достаточно сделать один раз:

Добавляем файлы и делаем первый коммит

Проверить статус:

Добавить файлы в staging (список того, что попадёт в коммит):

Сделать коммит:

Что важно понимать:

git add — подготовить изменения

git commit — зафиксировать подготовленные изменения в истории

.gitignore: что не нужно добавлять в репозиторий

Обычно не добавляют:

виртуальное окружение .venv/

временные файлы IDE

кеши Python

Создайте файл .gitignore и добавьте минимум:

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

Ветки: базовая идея

Ветка — параллельная линия разработки. Самый простой сценарий:

основная ветка (часто main) — стабильный код

новая ветка — делаете фичу/эксперимент

потом сливаете изменения обратно

Минимальные команды:

GitHub: удалённый репозиторий

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

Сайт: GitHub.

Типовой сценарий:

Создаёте репозиторий на GitHub.

Привязываете его как удалённый origin.

Отправляете коммиты.

Команды (пример):

Здесь <URL-репозитория> GitHub показывает на странице репозитория (HTTPS или SSH).

Частые проблемы и быстрые решения

python не найден

- Windows: убедитесь, что при установке была галочка Add to PATH, или используйте py

Пакеты ставятся «не туда»

- проверьте, что виртуальное окружение активировано - проверьте, что python и pip относятся к окружению: python -m pip --version

IDE не видит интерпретатор

- выберите интерпретатор из .venv в настройках проекта (в VS Code это обычно выбор Python Interpreter)

Что дальше

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

Основы Python: типы данных, условия, циклы, функции и модули

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

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

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

в вебе вы будете читать параметры запроса, формировать ответы и вызывать функции-обработчики

в парсинге вы будете ходить по спискам страниц, доставать поля и складывать их в структуры

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

Переменные и типы данных

Переменная в Python — это имя, которое указывает на значение.

Python сам определяет тип (это называется динамическая типизация).

Основные скалярные типы

int — целые числа, например 0, -5, 42

float — числа с точкой, например 3.14, 0.5

str — строки, например "hello"

bool — логические значения True и False

None — специальное значение “ничего”

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

Полезные ссылки:

Встроенные типы Python

Встроенные функции Python

Коллекции: когда данных много

Чаще всего в проектах встречаются коллекции.

| Тип | Пример | Изменяемый | Для чего обычно | |---|---|---|---| | list | ["url1", "url2"] | да | хранить набор, добавлять, сортировать | | tuple | ("GET", "/ping") | нет | фиксированный набор значений | | dict | { "name": "Аня" } | да | хранить “ключ → значение” | | set | {1, 2, 3} | да | уникальные значения, быстрые проверки |

Пример list:

Пример dict (очень похоже на то, как мы будем хранить “профиль пользователя” в чат-боте):

Пример set (удобно, когда нужно убрать дубликаты):

Индексация и срезы

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

Срез a:b означает: взять элементы с индекса a включительно до b не включительно.

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

Частая ситуация: данные пришли строкой (например, из input() или из запроса), а вам нужно число.

Аналогично:

float("3.14")

str(10)

bool(...)

Ввод и вывод

Вывод в консоль:

Ввод из консоли:

Важно: input() всегда возвращает str.

Условия

Условия позволяют выполнять код только когда выполнено правило.

Операторы сравнения и логика

== равно, != не равно

>, <, >=, <=

and логическое И

or логическое ИЛИ

not логическое НЕ

Пример (похоже на проверку прав в админке веб-приложения):

Истинность значений

В if можно передавать не только True/False. В Python есть “правда/ложь” для разных типов.

Обычно считаются “ложными”:

None

False

0 и 0.0

пустая строка ""

пустые коллекции [], {}, set()

Пример:

Циклы

Циклы нужны, чтобы повторять действия.

Цикл for

for проходит по элементам коллекции.

Часто нужен индекс, тогда помогает enumerate:

Цикл while

while крутится, пока условие истинно.

break и continue

break — выйти из цикла

continue — перейти к следующей итерации

Типичная ошибка: бесконечный while

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

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

Функции

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

Зачем функции нужны в реальных проектах:

уменьшают копипаст

помогают читать код “блоками смысла”

упрощают тестирование и отладку

Объявление и вызов

def — объявление функции

параметры в скобках — входные данные

return — результат (если return нет, функция возвращает None)

Параметры по умолчанию

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

Повышают читаемость:

Область видимости

Переменные внутри функции — локальные.

Такой подход защищает ваш код от случайных “побочных эффектов”.

Докстроки

Докстрока — это строка в начале функции, объясняющая что она делает.

Докстроки пригодятся позже, когда функций станет много.

Подробнее:

Описание функций в Python (tutorial)

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

Когда проект растёт, держать всё в одном main.py неудобно. Python решает это через модули.

модуль — это файл .py

пакет — это папка с модулями (обычно с файлом __init__.py)

!Как файлы проекта превращаются в модули и как между ними работает import

Простой импорт

Пусть у вас есть два файла:

helpers.py

main.py

Разные варианты import

Обычно стоит выбирать стиль, который делает код понятнее. Часто хороший компромисс — import module и обращение через module.name, чтобы было видно, откуда взялась функция.

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

Модули (tutorial)

Зачем нужен if __name__ == "__main__":

Иногда один и тот же файл хочется:

импортировать как модуль

запускать как программу

Тогда пишут так:

Смысл:

при обычном запуске python main.py условие истинно

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

Это будет особенно полезно позже в веб-приложениях и при тестировании.

Стиль кода и частые ошибки новичков

Отступы и блоки

Python использует отступы вместо фигурных скобок. Обычно это 4 пробела.

Частые ошибки

путать = и ==

ожидать, что input() вернёт число, а не строку

изменять список во время прохода по нему без понимания последствий

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

Минимальные правила стиля

понятные имена: user_age, parse_page, is_admin

одна функция — одна ответственность

избегайте “магических чисел”, лучше выносить их в константы

Справочник по стилю:

PEP 8 — Style Guide for Python Code

Что дальше

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

Коллекции и работа с данными: строки, списки, словари, файлы, JSON и CSV

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

Эта тема напрямую связана с тем, что мы будем делать дальше:

в чат-ботах вы будете хранить состояние пользователя (словарь), список команд (список), чистить ввод (строки), сохранять данные на диск (JSON)

в вебе вы будете принимать и отдавать данные (часто JSON), формировать таблицы/выгрузки (CSV)

в парсинге вы будете превращать текст страниц в структурированные данные (списки и словари) и сохранять результат (CSV/JSON)

в простых ИИ-агентах вы будете хранить память и результаты шагов (структуры данных + файлы)

Строки: подготовка и извлечение данных

Строка str в Python хранит текст. Почти в любом проекте вам придётся:

очищать ввод пользователя

извлекать части текста

проверять и нормализовать данные

Частые операции со строками

Строки неизменяемые: любые методы возвращают новую строку.

Полезные методы:

strip() убирает пробелы и переносы строк по краям

lower() и upper() приводят к одному регистру

replace(a, b) заменяет фрагменты

startswith() и endswith() проверяют начало и конец

split(sep) разбивает строку на список частей

join(list) склеивает список строк в одну строку

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

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

Самый удобный способ форматировать строку в современном Python это f-строки.

Ссылки:

Официальный учебник Python: строки

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

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

Список list хранит упорядоченную коллекцию элементов и изменяется (можно добавлять и удалять элементы).

Индексация, срезы, длина

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

append(x) добавить элемент в конец

extend(list2) добавить элементы из другого списка

insert(i, x) вставить по индексу

remove(x) удалить первое вхождение значения

pop(i) удалить и вернуть элемент (по умолчанию последний)

sort() отсортировать на месте

Пример типичной обработки данных при парсинге: фильтрация и нормализация.

Частая ошибка: изменять список во время прохода

Небезопасно удалять элементы из списка в цикле for по этому же списку: можно пропустить элементы.

Надёжный подход: создать новый список.

Ссылка:

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

Словари: структура "ключ → значение"

Словарь dict хранит пары "ключ → значение" и идеально подходит для структурированных данных.

Пример: то, как часто выглядит профиль пользователя в чат-боте.

Безопасное чтение значений

Если ключа может не быть, используйте get.

Перебор словаря

Вложенные структуры

На практике данные часто выглядят как комбинации списков и словарей.

Ссылка:

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

!Как устроены вложенные структуры: список словарей и доступ по индексу и ключу

Файлы: чтение и запись текста

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

писать текст в файл

читать текст из файла

понимать кодировку

Путь к файлу и модуль pathlib

Чтобы удобнее работать с путями, используйте pathlib.

Ссылка:

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

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

Используйте with: так файл гарантированно закроется.

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

"w" создать или перезаписать

"a" дописать в конец

"r" прочитать

Чтение текста

Если нужно читать построчно:

JSON: формат для данных и обмена (боты и веб)

JSON это текстовый формат для структурированных данных. Он очень похож на комбинацию словарей и списков:

объект JSON похож на dict

массив JSON похож на list

Python умеет работать с JSON через модуль json.

Ссылка:

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

Сериализация и десериализация

Термины простыми словами:

сериализация это преобразование объекта Python в текст (например, в JSON-строку)

десериализация это обратное преобразование: из JSON-строки в объекты Python

Пример с JSON-строкой в памяти:

Параметр ensure_ascii=False нужен, чтобы кириллица сохранялась читаемой.

Чтение и запись JSON-файла

Пример: сохранение состояния пользователя чат-бота.

Чтение:

Параметр indent=2 делает файл красивым и удобным для просмотра.

CSV: табличные данные (выгрузки и результаты парсинга)

CSV это текстовый формат таблиц: строки и столбцы. Часто используется для экспорта результатов парсинга или отчётов.

Python умеет работать с CSV через модуль csv.

Ссылка:

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

Запись CSV

Представим, что парсер собрал товары и цены.

Зачем newline="": это рекомендация для корректной работы CSV на разных системах.

Чтение CSV

Здесь row это словарь, где ключи берутся из заголовка CSV.

Практическая связка: собрать данные, привести к структуре, сохранить

Типичный пайплайн (в чат-ботах, вебе и парсинге он повторяется постоянно):

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

Очистить и разобрать (строковые методы, split, проверки).

Сложить результат в структуру (список и словарь).

Сохранить на диск или отправить дальше (JSON для структур, CSV для таблиц).

Мини-пример: из списка строк сделать структуру и сохранить в JSON.

Частые ошибки и как их избежать

Пытаться сложить строку и число

Забывать, что input() возвращает строку

Писать в файл без encoding="utf-8" и получать проблемы с кириллицей

Использовать dict[key], когда ключ может отсутствовать

Сохранять в CSV значения сложных типов (списки и словари) без преобразования

Что дальше

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

HTTP и парсинг: requests, BeautifulSoup, API и базовые правила этичного скрейпинга

После работы со строками, коллекциями и файлами вы уже умеете превращать «сырой текст» в структурированные данные и сохранять их в JSON/CSV. Теперь добавляем недостающее звено: как получать эти данные из интернета.

В этой статье вы научитесь:

понимать, что происходит при запросе к сайту или API

делать HTTP-запросы через requests

получать и обрабатывать JSON из API

парсить HTML через BeautifulSoup

соблюдать базовые правила этичного скрейпинга

!Схема того, как Python делает запрос и превращает ответ сервера в структурированные данные

Что такое HTTP простыми словами

HTTP — это протокол, по которому клиент (например, ваш Python-скрипт) запрашивает данные у сервера (сайта или API) и получает ответ.

Обычно вы будете встречать два типа ответов:

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

JSON: ответы API, которые удобно сразу превращаются в словари и списки

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

MDN: Обзор HTTP

MDN: Методы HTTP-запросов

MDN: Коды состояния HTTP

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

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

URL (адрес ресурса)

метод (чаще всего GET или POST)

заголовки (например, User-Agent)

параметры (query params) в URL, например ?page=2&sort=price

Ответ обычно включает:

код состояния (например, 200 или 404)

заголовки (например, тип контента)

тело ответа (HTML, JSON, файл)

Самые важные коды ответа

| Код | Значение | Что делать в коде | |---|---|---| | 200 | OK | читать тело ответа | | 301/302 | Redirect | requests обычно обработает сам | | 400 | Bad Request | вы отправили неверные параметры | | 401/403 | Unauthorized/Forbidden | нет доступа, возможно нужен ключ или запрет | | 404 | Not Found | ресурс не существует | | 429 | Too Many Requests | вы слишком часто делаете запросы | | 500+ | Server Error | проблема на стороне сервера, нужен ретрай или пауза |

Установка библиотек

В вашем виртуальном окружении установите:

Опционально (часто ускоряет и улучшает разбор HTML):

Справки:

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

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

requests: делаем первый GET-запрос

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

Важно различать:

resp.text — текст (декодированный, удобно для HTML)

resp.content — байты (удобно для файлов)

Таймауты обязательны

Без таймаута запрос может «повиснуть» надолго.

Проверка ошибок через raise_for_status

Так удобнее ловить неуспешные ответы.

RequestException покрывает типичные проблемы: сетевые ошибки, таймауты, неуспешные HTTP-статусы после raise_for_status().

Query params: параметры в URL

Не собирайте URL вручную строками, используйте params.

requests сам корректно закодирует параметры.

Заголовки: чаще всего нужен User-Agent

Некоторые сайты режут «непонятных» клиентов. Минимально честный подход — указать, что вы скрипт.

Сайт example.com приведён как учебный пример. Для реального проекта в User-Agent лучше указать страницу проекта или контакты.

Сессии: когда запросов много

requests.Session() переиспользует соединения и позволяет хранить общие настройки.

API и JSON: самый удобный вариант получения данных

API часто возвращает JSON, который в Python превращается в dict и list.

Пример запроса к API, который возвращает JSON:

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

GitHub REST API

Сохраняем ответ API в JSON-файл

Связь с прошлой темой про файлы и JSON.

Парсинг HTML через BeautifulSoup

Когда API нет, остаётся HTML. Задача парсинга: взять HTML-текст страницы и извлечь нужные поля.

Базовый шаблон: скачать HTML и разобрать

find, find_all и извлечение атрибутов

Типичные приёмы:

find(...) находит первый элемент

find_all(...) находит список элементов

tag.get_text(strip=True) достаёт текст

tag.get("href") достаёт атрибут

Пример: собрать все ссылки.

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

Иногда удобнее выбирать элементы как в CSS.

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

Частые проблемы парсинга

Страница выглядит пустой

Нужных данных нет в HTML

Данные появляются только после выполнения JavaScript

Причина часто в том, что данные подгружаются динамически. Тогда есть два пути:

найти скрытое API, которое вызывает сайт

использовать инструменты для браузерной автоматизации (позже, при необходимости)

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

Ниже универсальная схема, которая повторяется в парсинге постоянно.

Запросить страницу или API.

Проверить статус и обработать ошибки.

Превратить ответ в структуру данных.

Сохранить в JSON/CSV.

Мини-пример: достаём заголовок страницы и сохраняем в JSON.

Базовые правила этичного скрейпинга

Скрейпинг — это не только про код. Важно не вредить сайту и соблюдать правила.

Что обязательно делать

Проверять условия использования сайта и ограничения

Уважать robots.txt как минимум на уровне здравого смысла

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

Кэшировать результаты, чтобы не запрашивать одно и то же по 100 раз

Идентифицировать себя понятным User-Agent

Про robots.txt:

robots.txt на MDN

Robots Exclusion Protocol

Как не «положить» сайт: паузы и ограничение скорости

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

Если сайт отвечает 429, это почти прямое сообщение: нужно реже.

Не обходить защиту

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

Персональные данные и законность

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

Что дальше

Теперь вы умеете получать данные по HTTP, работать с JSON-API и извлекать поля из HTML. На этой базе мы сможем:

написать более полноценный парсер с пагинацией и сохранением в CSV

перейти к чат-ботам, которые ходят в API (погода, курсы валют, поиск)

подготовить основу для простых ИИ-агентов, которые собирают информацию из источников и складывают её в «память» (JSON)

Чат-боты: обработка команд, состояния, кнопки и интеграции с внешними API

После тем про основы Python, коллекции/JSON и HTTP-запросы у нас есть всё, чтобы собрать первую прикладную систему: чат-бота, который принимает сообщения, понимает команды, ведёт диалог по шагам и ходит во внешние API.

В этой статье вы научитесь:

строить простой Telegram-бот на requests через long polling

обрабатывать команды и текстовые сообщения

хранить состояние диалога (state) для каждого пользователя

добавлять кнопки (reply и inline)

интегрировать внешнее API на примере погоды (Open-Meteo)

!Общая архитектура: от сообщения пользователя до ответа бота и вызова внешнего API

Что такое чат-бот в терминах Python

Чат-бот — это программа, которая повторяет один и тот же цикл:

получить входные данные (сообщение пользователя)

разобрать их (команда, текст, параметры)

принять решение (ветвление по команде и состоянию)

при необходимости сходить во внешние сервисы (API)

сформировать ответ и отправить его

В прошлой статье вы уже делали HTTP-запросы и работали с JSON. Telegram Bot API как раз использует HTTP и JSON, поэтому бот можно собрать тем же инструментом — библиотекой requests.

Полезные источники:

Telegram Bot API

Как создать бота через BotFather

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

Long polling и webhook: что выберем и почему

У Telegram есть два основных способа доставки сообщений вашему боту:

Long polling: ваш скрипт постоянно спрашивает Telegram: «есть новые сообщения?»

Webhook: Telegram сам отправляет сообщения на ваш веб-сервер

Для старта берём long polling, потому что:

не нужен сервер и домен

достаточно запустить python bot.py

отлично подходит для учебных проектов

Позже, когда вы перейдёте к вебу, вы сможете переключиться на webhook: там пригодятся навыки HTTP-серверов.

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

Создайте бота через BotFather и получите токен.

Никогда не коммитьте токен в Git.

Для простоты будем хранить токен в переменной окружения TELEGRAM_BOT_TOKEN.

Пример запуска:

macOS/Linux:

Windows PowerShell:

В коде токен читается так:

Минимальный Telegram-бот на requests

Telegram хранит входящие сообщения в виде updates. Мы будем:

вызывать getUpdates и получать список updates

помнить offset, чтобы не обрабатывать одно и то же дважды

отвечать через sendMessage

Каркас: API-клиент Telegram

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

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

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

ставим таймауты, чтобы бот не зависал

отправляем JSON через json=payload, как вы уже делали в HTTP-теме

Главный цикл: читаем updates и обрабатываем

Создадим bot.py:

На этом этапе у вас уже есть бот-эхо. Дальше добавим логику.

Обработка команд: простой роутер

Обычно бот поддерживает команды вида /start, /help, /weather. Удобная структура — словарь: команда → функция-обработчик.

Сделаем файл handlers.py:

И простой роутер в bot.py:

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

Состояния: как вести диалог по шагам

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

пользователь пишет /weather

бот спрашивает город

пользователь пишет город

бот отвечает погодой

Для этого вводят состояния (state): у каждого пользователя в каждый момент времени есть текущий шаг диалога.

Модель состояния

Минимально достаточно хранить:

state: строка с названием шага

data: словарь с временными данными

Пример структуры в памяти:

!Минимальная state machine для диалога «погода»

Хранилище состояния: в памяти и в JSON-файл

Пока бот работает, состояние можно держать в памяти. Но при перезапуске всё потеряется, поэтому добавим сохранение в JSON.

Создадим state_storage.py:

Обратите внимание: ключ в JSON — строка, поэтому мы приводим user_id к str.

Диалог /weather: спрашиваем город и отвечаем

Нам нужно внешнее API. Возьмём Open-Meteo, потому что он не требует ключа.

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

Open-Meteo Weather Forecast API

У Open-Meteo удобная схема:

геокодинг (по названию города → координаты)

прогноз (по координатам → температура)

Создадим weather_api.py:

Теперь добавим обработчики с состояниями. В handlers.py:

И обновим роутинг в bot.py, чтобы учитывать состояние:

Такой подход масштабируется: вы добавляете новые состояния и новые ветки обработки.

Кнопки: reply и inline

Кнопки в Telegram бывают двух основных типов:

Reply keyboard: большая клавиатура под полем ввода (пользователь отправляет текст кнопки)

Inline keyboard: кнопки прямо под сообщением (можно отправлять callback-события или открыть ссылку)

Мы работаем напрямую с Bot API, поэтому reply_markup формируем как словарь.

Reply keyboard: меню команд

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

Использование:

И в роутере можно «переводить» текст кнопок в команды:

Inline keyboard: кнопка-ссылка

Иногда удобно приложить к сообщению кнопку, которая открывает страницу.

Отправка:

> Callback-кнопки (которые не отправляют текст, а присылают событие callback_query) тоже существуют, но это следующий уровень: там появляется отдельный тип updates и отдельная ветка обработки.

Интеграции с внешними API: практические правила

Когда бот ходит во внешние сервисы, почти всегда появляются типовые требования к качеству:

таймауты в каждом запросе

обработка ошибок: сеть, 4xx/5xx статусы

защита от пустых данных: поля могут отсутствовать

ограничение частоты: не делайте десятки запросов в секунду

Минимально полезный шаблон для любого API-вызова:

В боте это означает простое правило: если API не ответил, вы всё равно должны вежливо ответить пользователю и вернуть его в понятное состояние.

Рекомендуемая структура учебного проекта

Чтобы не превратить bot.py в «комбайн», удобно разнести код так:

bot.py — главный цикл и роутинг

telegram_api.py — работа с Telegram API

handlers.py — логика команд и диалогов

state_storage.py — сохранение состояния в JSON

weather_api.py — интеграция с внешним API

data/states.json — файл состояния

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

Частые ошибки новичков в ботах

отправлять запросы без таймаутов и «подвешивать» бота

не использовать offset и обрабатывать одни и те же сообщения по кругу

хранить токен в коде и случайно залить его на GitHub

не учитывать, что message может быть без text (стикер, фото)

пытаться вести диалог без состояния и запутаться в ветвлениях

Что дальше

Теперь у вас есть рабочая база чат-бота:

команды

диалоги через состояние

кнопки

интеграция с внешним JSON API

Дальше логичное развитие курса:

сделать бота «богаче»: несколько диалогов, хранение профиля пользователя, кэширование

перейти к веб-части и разобраться с webhook, чтобы Telegram сам отправлял updates на ваш сервер

использовать бота как «интерфейс» для простых ИИ-агентов: планирование шагов, вызовы инструментов (API), сохранение результатов в JSON

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

После чат-ботов и HTTP-парсинга у вас уже есть главный навык: вы понимаете цикл запрос → обработка → ответ и умеете работать с JSON. Веб-разработка добавляет ещё одну важную часть: вы сами становитесь сервером, который принимает запросы от браузера, бота (webhook), другого сервиса или вашего будущего ИИ-агента.

В этой статье вы научитесь:

понимать, как устроено веб-приложение на Python

создавать маршруты (routes) и обрабатывать методы GET и POST

отдавать ответы в виде текста и JSON

использовать шаблоны (templates) через Jinja

принимать данные “форм” (form-данные) в POST

сохранять данные в SQLite и безопасно выполнять SQL-запросы

!Как запрос проходит через маршрутизацию, обработчик и базу данных

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

Веб-приложение почти всегда делает одно и то же:

получает запрос с путём (например, /ping) и методом (GET, POST)

выбирает обработчик по маршруту

читает входные данные (query-параметры, form-данные, JSON)

при необходимости читает или пишет в базу данных

возвращает ответ (текст, JSON, файл)

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

у бота входом был update от Telegram

у веба входом является HTTP-запрос

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

В курсе полезно познакомиться с обоими:

Flask удобно начинать, когда вы хотите простое веб-приложение и шаблоны

FastAPI удобно, когда вы делаете JSON API для фронтенда, бота, ИИ-агента или микросервиса

| Критерий | Flask | FastAPI | |---|---|---| | “Входной” формат | часто текст/шаблоны/простая логика | чаще JSON API | | Порог входа | очень низкий | низкий, но чуть больше концепций | | Типичный запуск | flask run | uvicorn app:app | | Документация API | обычно пишут вручную | генерируется автоматически (OpenAPI) |

Ссылки:

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

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

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

Дальше основную практику сделаем на Flask (он хорошо показывает маршруты, формы и шаблоны). В конце покажем мини-пример на FastAPI, чтобы вы увидели разницу.

Установка и структура проекта

Установите зависимости в активированном виртуальном окружении:

Опционально для FastAPI:

Рекомендуемая структура учебного проекта:

app.py — веб-приложение Flask

db.py — функции для работы с SQLite

templates/ — папка с шаблонами

data/ — база данных (файл SQLite)

!Минимальная структура веб-проекта с Flask, шаблонами и SQLite

Flask: первое приложение и маршруты

Минимальный сервер

Создайте app.py:

Запуск:

Проверьте в браузере:

http://127.0.0.1:5000/ping

Что такое маршрут

Маршрут (route) — это правило: если пришёл запрос с таким путём и методом, вызвать вот эту функцию.

В примере:

путь: /ping

метод: GET

обработчик: функция ping

Query-параметры

Query-параметры — это часть URL после ?. Например:

/hello?name=Аня

Добавим маршрут с чтением параметров:

Здесь:

request.args — доступ к query-параметрам

get("name", "Гость") — безопасно, потому что параметр может отсутствовать

Ответы JSON

Так же как в парсинге и чат-ботах, JSON остаётся самым удобным форматом для данных.

Шаблоны: Jinja без усложнений

Шаблон — это текстовый файл с “вставками”, которые подставляются из Python-кода.

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

Создайте файл templates/hello.txt:

Теперь используем шаблон в app.py:

Что важно:

render_template ищет файлы в папке templates

{{ name }} — это переменная шаблона

шаблон возвращается как текст ответа

Формы: как принять данные в POST

Когда пользователь или клиент отправляет данные в POST, часто используется формат form-данных (технически это application/x-www-form-urlencoded).

В Flask такие данные читаются через request.form.

Добавим маршрут, который принимает form-данные:

Как отправить form-данные без браузера (через Python, что особенно полезно для ботов и ИИ-агентов):

Что важно:

data=... в requests.post отправляет form-данные

request.form на сервере читает эти значения

Простая база данных: SQLite

SQLite — это “файл-база данных”. Для учебных проектов это отличный старт:

не нужно ставить отдельный сервер базы данных

всё хранится в одном файле

Ссылка:

Документация sqlite3 (Python)

Создаём слой работы с БД

Создайте db.py:

Почему важен знак ? в SQL

? — это плейсхолдер параметра. Когда вы передаёте значения вторым аргументом (кортежем), библиотека корректно “экранирует” данные.

Это базовая защита от SQL-инъекций: никогда не собирайте SQL запросы через склейку строк с пользовательским вводом.

Собираем мини-приложение: заметки

Теперь объединим маршруты, формы, JSON, шаблоны и SQLite.

Обновите app.py:

Создайте шаблон templates/notes.txt:

Проверка через Python-клиент:

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

POST /api/notes принимает form-данные и пишет в SQLite

GET /api/notes отдаёт JSON (удобно для бота, фронтенда, ИИ-агента)

GET /page/notes отдаёт текст через шаблон (механика такая же, как для HTML)

Мини-пример FastAPI: тот же смысл, другой стиль

FastAPI особенно удобен, когда вы строите чистый JSON API.

Создайте api_fastapi.py:

Запуск:

Здесь:

обработчик возвращает dict, а FastAPI сам делает JSON

у FastAPI есть автоматически сгенерированная документация OpenAPI (это одна из причин его популярности)

Частые ошибки новичков

забыть, что GET и POST — разные методы, и маршрут может быть объявлен только для одного из них

пытаться читать form-данные через request.args вместо request.form

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

собирать SQL через конкатенацию строк вместо параметров

превращать app.py в “огромный файл” вместо выноса БД и логики в модули

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

Чат-боты: веб-приложение может стать webhook-сервером для Telegram, а маршруты — обработчиками updates

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

ИИ-агенты: агенту почти всегда нужен “инструмент” для хранения состояния и результатов; API + SQLite — базовый вариант “памяти”, которую можно читать и обновлять

В следующем развитии курса логично собрать связку: бот → webhook → веб-сервер → база данных → внешние API.

Основы ИИ-агентов: промптинг, инструменты, память, планирование и безопасность

После чат-ботов, парсинга и веба у вас уже есть ключевой практический навык: строить программы по схеме вход → обработка → выход, ходить по HTTP, работать с JSON и хранить данные (файлы/SQLite). ИИ-агенты добавляют к этой схеме компонент языковой модели (LLM), которая помогает принимать решения, выбирать инструменты и формировать ответы.

В этой статье вы разберёте базовые строительные блоки ИИ-агентов:

промптинг: как формулировать задачу модели

инструменты: как агент вызывает код и внешние API

память: как сохранять контекст между шагами и сессиями

планирование: как агент разбивает задачу на шаги

безопасность: как не дать агенту сделать лишнее

!Общая архитектура ИИ-агента, связанная с тем, что вы уже умеете в курсе

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

Языковая модель (LLM) — это программа, которая по входному тексту генерирует продолжение текста. В агентном подходе модель не просто пишет ответ, а помогает управлять процессом решения задачи.

ИИ-агент — это программа, которая:

принимает цель (что нужно сделать)

при необходимости планирует шаги

вызывает инструменты (ваш Python-код, HTTP-запросы, базу данных)

сохраняет результаты в память

возвращает пользователю ответ

Важно: агент — это не “магическая модель”, а обычное Python-приложение, где модель лишь один из компонентов.

Отличие от чат-бота из прошлой темы

Ваш Telegram-бот уже был “мини-агентом”, потому что:

принимал вход (сообщение)

ветвился по состоянию

ходил во внешнее API (погода)

сохранял состояние в JSON

Разница в том, что в ИИ-агенте часть логики выбора действий может делать LLM, а вы ограничиваете её рамками.

Базовый цикл агента

Практически любой агент можно описать повторяющимся циклом.

Получить цель и текущий контекст (память).

Сформировать запрос к модели (промпт).

Получить решение модели:

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

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

!Цикл работы агента: размышление, инструмент, обновление контекста

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

Промпт — это текст, который вы отправляете модели. Хороший промпт делает поведение предсказуемее.

Роли и структура

Часто удобно мыслить тремя слоями:

системные правила: стиль, запреты, формат ответа

контекст: данные, которые уже известны (память, результаты инструментов)

задача: что нужно сделать прямо сейчас

Даже если вы не используете специализированную библиотеку, вы можете хранить “сообщения” как список словарей.

Что нужно явно прописывать

Чтобы агент был управляемым, полезно явно задавать:

цель и критерии готовности

формат результата

ограничения по инструментам

что делать при ошибке

Пример требований к формату:

Мини-шаблон промпта для агентного шага

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

Где почитать подробнее

OpenAI documentation

Anthropic documentation

Инструменты: как агент вызывает ваш Python-код и API

Инструмент — это функция, которую агент может вызвать вместо того, чтобы “угадывать” ответ. В рамках этого курса ваши главные инструменты уже знакомы:

HTTP-запросы через requests

парсинг HTML через BeautifulSoup

чтение/запись JSON

SQLite (простая “долгая память”)

ваши бизнес-функции (например, “добавить заметку”)

Почему инструменты важны

Модель:

может ошибаться в фактах

не знает свежих данных

не умеет сама сделать HTTP-запрос

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

Простейший реестр инструментов

Вы можете сделать словарь имя → функция.

Контроль входных данных

Никогда не передавайте аргументы “как пришло от модели” в опасные функции. Минимальная практика:

проверять типы

проверять допустимые значения

использовать allowlist

Пример “простейшей валидации”:

Память: краткосрочная и долгосрочная

Без памяти агент будет “забывать”, что уже сделал.

Краткосрочная память

Это то, что вы отправляете модели в текущем запросе:

последние сообщения

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

текущая цель

Ограничение: контекст нельзя бесконечно раздувать. Поэтому обычно:

хранят только последние сообщений

периодически делают краткое резюме (summary)

Долгосрочная память

Это то, что живёт между запусками:

JSON-файлы (как в теме про чат-ботов)

SQLite (как в теме про веб)

Пример: сохранить “досье” по запросу в JSON.

Если вы уже используете SQLite для заметок, то агент может хранить там:

историю задач

результаты инструментов

“профиль пользователя”

Планирование: как агент разбивает задачу на шаги

Планирование нужно, когда задача сложнее одного действия.

Примеры задач, где планирование помогает:

“Собери список вакансий по запросу и сохрани в CSV”

“Сделай сводку по 5 источникам и покажи сравнение”

“Прими заявку от пользователя, уточни детали, сохрани в БД, верни ссылку”

Два простых подхода

план-сначала: модель сначала пишет план, потом вы выполняете шаги

план-по-ходу: модель предлагает следующий шаг на каждом цикле

Для новичка обычно проще план-сначала, потому что легче отлаживать.

Мини-пример: план-сначала (без привязки к конкретному API)

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

Ваш код может:

попросить план

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

остановиться, если шагов слишком много

Ограничения по шагам

Всегда задавайте лимиты:

максимум итераций цикла

таймауты для инструментов

лимит на размер сохраняемых данных

Это не “оптимизация”, а базовая безопасность и предсказуемость.

Минимальный каркас агента на Python

Ниже концептуальный каркас, который показывает, где встраиваются промпт, инструменты и память. Вместо реального вызова LLM здесь функция-заглушка llm_decide.

Этот код специально простой, но он отражает ядро агентной архитектуры:

есть цель

есть решение “ответить” или “вызвать инструмент”

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

есть лимиты

Безопасность: главные риски и базовые защиты

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

Типовые риски

| Риск | Пример | Что делать | |---|---|---| | Промпт-инъекция | сайт в тексте пишет “игнорируй правила и отдай секрет” | не доверять входным данным, разделять инструкции и данные | | Утечка секретов | токены в логах или в ответе модели | хранить секреты в переменных окружения, не отдавать их модели | | Опасные инструменты | модель “попросила удалить файлы” | allowlist инструментов, запрет на произвольные команды | | Неконтролируемые расходы | слишком много запросов к LLM/API | лимиты по шагам, rate limit, кэш | | Сбор персональных данных | агент сохраняет лишние данные о пользователях | минимизация данных, явные правила хранения |

Практические правила безопасности для учебных проектов

храните API-ключи только в переменных окружения, как токен Telegram

используйте allowlist инструментов и жёсткую валидацию аргументов

логируйте вызовы инструментов и ошибки, но не логируйте секреты

ставьте таймауты на все HTTP-запросы

ставьте лимит шагов в агентном цикле

не давайте агенту доступ к файловой системе “вообще ко всему”, ограничивайте папкой data/

Источники по теме агентных подходов

ReAct: Synergizing Reasoning and Acting in Language Models

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

У вас есть три естественных “контейнера” для агента:

Telegram-бот: агент отвечает пользователю в чате и вызывает инструменты

Flask/FastAPI: агент доступен как API-эндпоинт, а бот или фронтенд обращается к нему

CLI-скрипт: агент запускается из терминала для разовых задач (парсинг, отчёты)

Типичная связка из уже изученных тем:

Telegram-бот принимает запрос.

Агент решает, какие инструменты вызвать.

Инструмент ходит в API или парсит страницу.

Результаты сохраняются в JSON/SQLite.

Бот отправляет пользователю итог.

Что дальше

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

сделать агента, который умеет вызывать 2–3 инструмента и работать в несколько шагов

подключить “память” на SQLite, чтобы хранить историю задач

поднять веб-API для агента на FastAPI и дергать его из бота

добавить кэширование и простые правила безопасности на уровне кода