Создание интерактивных меню в Python-ботах: пошаговое руководство

python -m venv venv
source venv/bin/activate # На Windows: venv\Scripts\activate

pip install aiogram==3.0.0b7

my_bot/
├── bot.py # Основной файл бота
├── config.py # Конфигурация (токены, настройки)
├── keyboards.py # Модуль для клавиатур и меню
└── handlers.py # Обработчики сообщений и колбэков

from aiogram import Bot, Dispatcher, types
from aiogram.filters import CommandStart
import asyncio
import logging
from config import BOT_TOKEN

# Настраиваем логирование
logging.basicConfig(level=logging.INFO)

# Инициализируем бота и диспетчер
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher()

# Обработчик команды /start
@dp.message(CommandStart())
async def cmd_start(message: types.Message):
await message.answer(
"Привет! Я бот с интерактивным меню.",
reply_markup=types.ReplyKeyboardRemove()
)

# Запуск бота
async def main():
await dp.start_polling(bot)

if __name__ == "__main__":
asyncio.run(main())

BOT_TOKEN = "ваш_токен_от_BotFather"

from aiogram import types
from aiogram.utils.keyboard import ReplyKeyboardBuilder

def get_main_menu():
builder = ReplyKeyboardBuilder()

# Добавляем кнопки в клавиатуру
builder.row(
types.KeyboardButton(text="📊 Статистика"),
types.KeyboardButton(text="⚙️ Настройки")
)
builder.row(
types.KeyboardButton(text="❓ Помощь"),
types.KeyboardButton(text="👤 Профиль")
)

# Формируем клавиатуру с параметрами
return builder.as_markup(
resize_keyboard=True, # Адаптивный размер
one_time_keyboard=False # Клавиатура не скрывается после нажатия
)

# Использование клавиатуры в обработчике
@dp.message(CommandStart())
async def cmd_start(message: types.Message):
await message.answer(
"Выберите действие:",
reply_markup=get_main_menu()
)

from aiogram import types
from aiogram.utils.keyboard import InlineKeyboardBuilder

def get_products_menu():
builder = InlineKeyboardBuilder()

# Добавляем кнопки с callback_data
builder.row(
types.InlineKeyboardButton(
text="🍕 Пицца", 
callback_data="category:pizza"
),
types.InlineKeyboardButton(
text="🍔 Бургеры", 
callback_data="category:burgers"
)
)
builder.row(
types.InlineKeyboardButton(
text="🥤 Напитки", 
callback_data="category:drinks"
),
types.InlineKeyboardButton(
text="🍰 Десерты", 
callback_data="category:desserts"
)
)
builder.row(
types.InlineKeyboardButton(
text="🔙 Назад", 
callback_data="back:main"
)
)

return builder.as_markup()

def get_grid_menu():
builder = InlineKeyboardBuilder()

# Создаем сетку 3x3 с цифрами
buttons = [
types.InlineKeyboardButton(
text=str(i), 
callback_data=f"number:{i}"
) for i in range(1, 10)
]

# Добавляем кнопки сеткой 3x3
builder.add(*buttons)
builder.adjust(3) # 3 кнопки в строке

return builder.as_markup()

def get_submenu(category_id):
builder = InlineKeyboardBuilder()

# Динамическое создание кнопок на основе категории
if category_id == "pizza":
items = ["Маргарита", "Пепперони", "Гавайская", "Четыре сыра"]
elif category_id == "drinks":
items = ["Кола", "Спрайт", "Сок", "Вода"]
else:
items = ["Товар 1", "Товар 2", "Товар 3"]

# Добавляем кнопки с товарами
for item in items:
builder.row(
types.InlineKeyboardButton(
text=item, 
callback_data=f"product:{category_id}:{item}"
)
)

# Навигационные кнопки
builder.row(
types.InlineKeyboardButton(
text="🔙 Назад к категориям", 
callback_data="back:categories"
),
types.InlineKeyboardButton(
text="🏠 Главное меню", 
callback_data="menu:main"
)
)

return builder.as_markup()

from aiogram import Router, F
from aiogram.types import CallbackQuery

router = Router()

# Обработчик колбэков категорий
@router.callback_query(F.data.startswith("category:"))
async def process_category_selection(callback: CallbackQuery):
# Извлекаем идентификатор категории из callback_data
category_id = callback.data.split(":")[1]

# Отвечаем пользователю и обновляем клавиатуру
await callback.message.edit_text(
f"Вы выбрали категорию: {category_id}",
reply_markup=get_submenu(category_id)
)

# Обязательно отвечаем на колбэк, чтобы убрать индикатор загрузки
await callback.answer()

# Обработчик колбэков навигации
@router.callback_query(F.data.startswith("back:"))
async def process_back_button(callback: CallbackQuery):
destination = callback.data.split(":")[1]

if destination == "main":
await callback.message.edit_text(
"Главное меню:",
reply_markup=get_main_menu_inline()
)
elif destination == "categories":
await callback.message.edit_text(
"Выберите категорию:",
reply_markup=get_products_menu()
)

await callback.answer()

from aiogram.filters.callback_data import CallbackData

class ProductCallback(CallbackData, prefix="product"):
category_id: str
product_id: str
action: str = "view" # Действие по умолчанию

# Создание кнопки с использованием фабрики
button = types.InlineKeyboardButton(
text="Пепперони", 
callback_data=ProductCallback(
category_id="pizza",
product_id="pepperoni"
).pack()
)

# Обработчик с использованием фабрики
@router.callback_query(ProductCallback.filter())
async def process_product_action(
callback: CallbackQuery, 
callback_data: ProductCallback
):
# Извлекаем данные из структурированного объекта
category = callback_data.category_id
product = callback_data.product_id
action = callback_data.action

if action == "view":
# Показываем информацию о товаре
await callback.message.edit_text(
f"Товар: {product} из категории {category}\n\n"
f"Здесь будет описание товара...",
reply_markup=get_product_menu(category, product)
)
elif action == "add":
# Добавляем товар в корзину
await callback.answer(f"Товар {product} добавлен в корзину!", show_alert=True)

await callback.answer()

class PaginationCallback(CallbackData, prefix="page"):
action: str # next, prev, current
page: int

def get_paginated_menu(items, page=0, items_per_page=5):
builder = InlineKeyboardBuilder()

# Определяем начальный и конечный индексы для текущей страницы
start_idx = page * items_per_page
end_idx = min(start_idx + items_per_page, len(items))

# Добавляем кнопки для текущих элементов
for item in items[start_idx:end_idx]:
builder.row(
types.InlineKeyboardButton(
text=item, 
callback_data=f"select:{item}"
)
)

# Кнопки навигации
navigation = []

# Кнопка "Назад", если не первая страница
if page > 0:
navigation.append(
types.InlineKeyboardButton(
text="◀️ Назад", 
callback_data=PaginationCallback(
action="prev", 
page=page-1
).pack()
)
)

# Информация о текущей странице
navigation.append(
types.InlineKeyboardButton(
text=f"{page+1}/{(len(items)+items_per_page-1)//items_per_page}", 
callback_data=PaginationCallback(
action="current", 
page=page
).pack()
)
)

# Кнопка "Вперед", если не последняя страница
if end_idx < len(items):
navigation.append(
types.InlineKeyboardButton(
text="Вперед ▶️", 
callback_data=PaginationCallback(
action="next", 
page=page+1
).pack()
)
)

builder.row(*navigation)
return builder.as_markup()

@router.callback_query(PaginationCallback.filter())
async def process_pagination(callback: CallbackQuery, callback_data: PaginationCallback):
# Здесь items должны быть доступны или извлечены из БД/состояния
items = ["Товар 1", "Товар 2", "Товар 3", "Товар 4", "Товар 5", 
"Товар 6", "Товар 7", "Товар 8", "Товар 9", "Товар 10"]

action = callback_data.action
current_page = callback_data.page

if action == "current":
# Просто обновляем сообщение колбэка
await callback.answer(f"Текущая страница: {current_page+1}")
return

# Обновляем меню с новой страницей
await callback.message.edit_reply_markup(
reply_markup=get_paginated_menu(items, page=current_page)
)
await callback.answer()

from aiogram.fsm.state import State, StatesGroup
from aiogram.fsm.context import FSMContext

# Определяем состояния для нашего меню
class MenuStates(StatesGroup):
main = State() # Главное меню
catalog = State() # Каталог товаров
category = State() # Выбранная категория
product = State() # Просмотр товара
cart = State() # Корзина
checkout = State() # Оформление заказа

# Обработчик перехода в главное меню
@router.message(Command("menu"))
@router.callback_query(F.data == "menu:main")
async def show_main_menu(event: Union[Message, CallbackQuery], state: FSMContext):
# Устанавливаем состояние
await state.set_state(MenuStates.main)

# Сохраняем дополнительные данные в состоянии
await state.update_data(last_visited=datetime.now().isoformat())

# Отправляем меню в зависимости от типа события
if isinstance(event, CallbackQuery):
await event.message.edit_text(
"🏠 Главное меню",
reply_markup=get_main_menu_inline()
)
await event.answer()
else: # Message
await event.answer(
"🏠 Главное меню",
reply_markup=get_main_menu_inline()
)

# Обработчик выбора категории
@router.callback_query(MenuStates.main, F.data.startswith("category:"))
async def show_category(callback: CallbackQuery, state: FSMContext):
category_id = callback.data.split(":")[1]

# Устанавливаем состояние категории
await state.set_state(MenuStates.category)

# Сохраняем данные категории в состоянии
await state.update_data(current_category=category_id)

# Загружаем продукты для категории (здесь могла бы быть загрузка из БД)
products = get_products_for_category(category_id)

await callback.message.edit_text(
f"Категория: {category_id.capitalize()}\n"
f"Доступно товаров: {len(products)}",
reply_markup=get_category_menu(category_id, products)
)
await callback.answer()

class MenuDispatcher:
def __init__(self):
self.menus = {}
self.default_menu = None

def register_menu(self, menu_id, get_content_func, get_markup_func):
"""Регистрирует новое меню"""
self.menus[menu_id] = {
'get_content': get_content_func,
'get_markup': get_markup_func
}

def set_default(self, menu_id):
"""Устанавливает меню по умолчанию"""
if menu_id in self.menus:
self.default_menu = menu_id

async def show_menu(self, menu_id, event, state=None, **kwargs):
"""Показывает указанное меню"""
if menu_id not in self.menus:
if self.default_menu:
menu_id = self.default_menu
else:
raise ValueError(f"Menu {menu_id} not found and no default menu set")

menu = self.menus[menu_id]
content = await menu['get_content'](**kwargs)
markup = await menu['get_markup'](**kwargs)

# Сохраняем текущее меню в состоянии, если оно предоставлено
if state:
await state.update_data(current_menu=menu_id, menu_params=kwargs)

# Показываем меню в зависимости от типа события
if isinstance(event, CallbackQuery):
await event.message.edit_text(content, reply_markup=markup)
await event.answer()
else: # Message
await event.answer(content, reply_markup=markup)

return menu_id

# Использование диспетчера меню
menu_dispatcher = MenuDispatcher()

# Регистрация меню
menu_dispatcher.register_menu(
'main',
lambda **kw: "🏠 Главное меню",
lambda **kw: get_main_menu_inline()
)

menu_dispatcher.register_menu(
'category',
lambda category_id, **kw: f"Категория: {category_id.capitalize()}",
lambda category_id, **kw: get_category_menu(category_id)
)

menu_dispatcher.set_default('main')

# Обработчик для использования диспетчера
@router.callback_query(F.data.startswith("menu:"))
async def process_menu_navigation(callback: CallbackQuery, state: FSMContext):
menu_id = callback.data.split(":")[1]

# Извлекаем параметры из callback_data или состояния
params = {}
if len(callback.data.split(":")) > 2:
# Парсим дополнительные параметры из callback_data
params_str = callback.data.split(":", 2)[2]
for param in params_str.split(","):
if "=" in param:
key, value = param.split("=")
params[key] = value

# Если параметров нет в callback_data, пробуем взять из состояния
if not params:
data = await state.get_data()
params = data.get("menu_params", {})

# Показываем меню через диспетчер
await menu_dispatcher.show_menu(menu_id, callback, state, **params)

async def track_menu_navigation(user_id, from_menu, to_menu, context=None):
"""Записывает переход между меню для аналитики"""
logging.info(f"Navigation: {user_id} moved from {from_menu} to {to_menu}")

# Здесь может быть код для записи в БД или отправки в аналитическую систему

# Пример структуры события навигации
navigation_event = {
"user_id": user_id,
"timestamp": datetime.now().isoformat(),
"from_menu": from_menu,
"to_menu": to_menu,
"context": context or {},
"session_id": generate_session_id(user_id)
}

# Сохранение события (например, в MongoDB)
# await navigation_collection.insert_one(navigation_event)