Создание Telegram-ботов на Python: полное руководство для начинающих

# Установка virtualenv (если еще не установлен)
pip install virtualenv

# Создание виртуального окружения
python -m venv telegram_bot_env

# Активация окружения
# В Windows:
telegram_bot_env\Scripts\activate
# В Linux/Mac:
source telegram_bot_env/bin/activate

# Для pyTelegramBotAPI
pip install pytelegrambotapi

# Или для python-telegram-bot
pip install python-telegram-bot

# Или для aiogram
pip install aiogram

telegram_bot/
├── config.py # Конфигурационные данные (токен, настройки)
├── bot.py # Основной файл с логикой бота
├── handlers/ # Обработчики сообщений и команд
│ ├── __init__.py
│ ├── common.py
│ └── commands.py
├── utils/ # Вспомогательные функции
│ ├── __init__.py
│ └── helpers.py
└── requirements.txt # Зависимости проекта

# config.py
BOT_TOKEN = 'ваш_токен_от_BotFather'
ADMIN_IDS = [123456789] # ID администраторов бота

# bot.py
import telebot
from config import BOT_TOKEN

# Инициализация бота
bot = telebot.TeleBot(BOT_TOKEN)

# Обработчик команды /start
@bot.message_handler(commands=['start'])
def handle_start(message):
user_name = message.from_user.first_name
bot.reply_to(message, f"Привет, {user_name}! Я эхо-бот. Напиши мне что-нибудь.")

# Обработчик текстовых сообщений
@bot.message_handler(content_types=['text'])
def handle_text(message):
bot.reply_to(message, f"Вы написали: {message.text}")

# Запуск бота
if __name__ == '__main__':
print("Бот запущен...")
bot.polling(none_stop=True)

# bot_ptb.py
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters, ContextTypes
from config import BOT_TOKEN

# Обработчик команды /start
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
user_name = update.effective_user.first_name
await update.message.reply_text(f"Привет, {user_name}! Я эхо-бот. Напиши мне что-нибудь.")

# Обработчик текстовых сообщений
async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
await update.message.reply_text(f"Вы написали: {update.message.text}")

# Настройка и запуск бота
if __name__ == '__main__':
app = ApplicationBuilder().token(BOT_TOKEN).build()

app.add_handler(CommandHandler("start", start))
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

print("Бот запущен...")
app.run_polling()

# Использование встроенной клавиатуры (Telebot)
@bot.message_handler(commands=['menu'])
def handle_menu(message):
markup = telebot.types.ReplyKeyboardMarkup(resize_keyboard=True)
item1 = telebot.types.KeyboardButton('О боте')
item2 = telebot.types.KeyboardButton('Помощь')
markup.add(item1, item2)

bot.send_message(message.chat.id, "Выберите пункт меню:", reply_markup=markup)

# Обработка инлайн-кнопок (Telebot)
@bot.message_handler(commands=['options'])
def handle_options(message):
markup = telebot.types.InlineKeyboardMarkup()
btn1 = telebot.types.InlineKeyboardButton('Вариант 1', callback_data='option1')
btn2 = telebot.types.InlineKeyboardButton('Вариант 2', callback_data='option2')
markup.add(btn1, btn2)

bot.send_message(message.chat.id, "Выберите вариант:", reply_markup=markup)

# Обработчик callback-запросов от инлайн-кнопок
@bot.callback_query_handler(func=lambda call: True)
def handle_callback(call):
if call.data == 'option1':
bot.answer_callback_query(call.id, "Вы выбрали вариант 1")
elif call.data == 'option2':
bot.answer_callback_query(call.id, "Вы выбрали вариант 2")

# Использование FSM (Finite State Machine) в Telebot
from telebot.handler_backends import State, StatesGroup
from telebot.storage import StateMemoryStorage

# Создание бота с поддержкой состояний
state_storage = StateMemoryStorage()
bot = telebot.TeleBot(BOT_TOKEN, state_storage=state_storage)

# Определение состояний
class RegistrationStates(StatesGroup):
waiting_for_name = State()
waiting_for_age = State()

# Старт регистрации
@bot.message_handler(commands=['register'])
def start_registration(message):
bot.set_state(message.from_user.id, RegistrationStates.waiting_for_name, message.chat.id)
bot.send_message(message.chat.id, "Как вас зовут?")

# Обработка имени
@bot.message_handler(state=RegistrationStates.waiting_for_name)
def process_name(message):
# Сохранение имени в данных состояния
bot.add_data(message.from_user.id, message.chat.id, name=message.text)

# Переход к следующему состоянию
bot.set_state(message.from_user.id, RegistrationStates.waiting_for_age, message.chat.id)
bot.send_message(message.chat.id, "Сколько вам лет?")

# Обработка возраста
@bot.message_handler(state=RegistrationStates.waiting_for_age)
def process_age(message):
# Получение данных состояния
with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
name = data['name']

# Завершение регистрации
bot.delete_state(message.from_user.id, message.chat.id)
bot.send_message(message.chat.id, f"Регистрация завершена!\nИмя: {name}\nВозраст: {message.text}")

# async_bot.py
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.filters import Command
from config import BOT_TOKEN

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

# Обработчик команды /start
@dp.message(Command("start"))
async def cmd_start(message: types.Message):
await message.answer(f"Привет, {message.from_user.first_name}!")

# Обработчик текстовых сообщений
@dp.message()
async def echo_message(message: types.Message):
# Имитация длительной операции
await asyncio.sleep(1)
await message.answer(f"Вы написали: {message.text}")

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

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

import requests
import json
from telebot import TeleBot
from config import BOT_TOKEN, WEATHER_API_KEY

bot = TeleBot(BOT_TOKEN)

@bot.message_handler(commands=['weather'])
def weather_command(message):
bot.reply_to(message, "Введите название города:")
bot.register_next_step_handler(message, get_weather)

def get_weather(message):
city = message.text
try:
# Запрос к API погоды
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric&lang=ru"
response = requests.get(url)
data = json.loads(response.text)

# Обработка ответа
if response.status_code == 200:
temp = data['main']['temp']
feels_like = data['main']['feels_like']
description = data['weather'][0]['description']

weather_info = f"Погода в {city}:\n"
weather_info += f"🌡 Температура: {temp}°C (ощущается как {feels_like}°C)\n"
weather_info += f"☁️ {description.capitalize()}"

bot.send_message(message.chat.id, weather_info)
else:
bot.send_message(message.chat.id, f"Не могу найти город {city}")

except Exception as e:
bot.send_message(message.chat.id, f"Произошла ошибка: {str(e)}")

import sqlite3
from telebot import TeleBot
from config import BOT_TOKEN

bot = TeleBot(BOT_TOKEN)

# Инициализация базы данных
def init_db():
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username TEXT,
first_name TEXT,
last_name TEXT,
registration_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
conn.commit()
conn.close()

# Сохранение пользователя в БД
def save_user(user):
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
cursor.execute(
"INSERT OR REPLACE INTO users (id, username, first_name, last_name) VALUES (?, ?, ?, ?)",
(user.id, user.username, user.first_name, user.last_name)
)
conn.commit()
conn.close()

@bot.message_handler(commands=['start'])
def start_command(message):
# Сохраняем информацию о пользователе
save_user(message.from_user)
bot.reply_to(message, f"Привет, {message.from_user.first_name}! Твои данные сохранены.")

# Инициализация при запуске
if __name__ == '__main__':
init_db()
bot.polling(none_stop=True)

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
import numpy as np
import telebot
from config import BOT_TOKEN

bot = telebot.TeleBot(BOT_TOKEN)

# Обучающие данные
X_train = [
"Как дела?", "Как настроение?", "Как поживаешь?",
"Который час?", "Сколько времени?", "Какое сейчас время?",
"Расскажи анекдот", "Пошути", "Рассмеши меня"
]
y_train = [
"приветствие", "приветствие", "приветствие",
"время", "время", "время",
"развлечение", "развлечение", "развлечение"
]

# Обучение классификатора
vectorizer = CountVectorizer()
X_vectors = vectorizer.fit_transform(X_train)
classifier = MultinomialNB()
classifier.fit(X_vectors, y_train)

# Обработка сообщений
@bot.message_handler(content_types=['text'])
def handle_message(message):
# Классификация сообщения
text_vector = vectorizer.transform([message.text])
category = classifier.predict(text_vector)[0]

# Ответ в зависимости от категории
if category == "приветствие":
bot.reply_to(message, "У меня всё отлично! А у вас?")
elif category == "время":
from datetime import datetime
current_time = datetime.now().strftime("%H:%M")
bot.reply_to(message, f"Текущее время: {current_time}")
elif category == "развлечение":
bot.reply_to(message, "Почему программисты путают Хэллоуин и Рождество? Потому что 31 OCT = 25 DEC 😄")
else:
bot.reply_to(message, "Я не понимаю, о чем вы.")

bot.polling()

@bot.message_handler(content_types=['photo'])
def handle_photo(message):
# Получение информации о фото
file_id = message.photo[-1].file_id # Берем последнее (самое большое) фото
file_info = bot.get_file(file_id)
downloaded_file = bot.download_file(file_info.file_path)

# Сохранение фото
with open(f"photos/{file_id}.jpg", 'wb') as new_file:
new_file.write(downloaded_file)

# Отправка ответа
bot.reply_to(message, "Фото получено и сохранено!")

@bot.message_handler(content_types=['document'])
def handle_document(message):
try:
file_id = message.document.file_id
file_info = bot.get_file(file_id)
downloaded_file = bot.download_file(file_info.file_path)

# Сохранение документа с оригинальным именем
file_name = message.document.file_name
with open(f"documents/{file_name}", 'wb') as new_file:
new_file.write(downloaded_file)

bot.reply_to(message, f"Документ '{file_name}' успешно сохранен!")
except Exception as e:
bot.reply_to(message, f"Произошла ошибка при обработке документа: {str(e)}")

from datetime import datetime, timedelta
import threading
import time
import telebot
from telebot import types
from config import BOT_TOKEN

bot = telebot.TeleBot(BOT_TOKEN)

# Словарь для хранения напоминаний: {chat_id: [(time, message), ...]}
reminders = {}

# Команда для создания напоминания
@bot.message_handler(commands=['remind'])
def remind_command(message):
markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
markup.add("30 минут", "1 час")
markup.add("3 часа", "1 день")

msg = bot.send_message(
message.chat.id, 
"Через какое время напомнить?", 
reply_markup=markup
)
bot.register_next_step_handler(msg, process_time_step)

def process_time_step(message):
chat_id = message.chat.id
time_text = message.text.lower()

# Определяем время напоминания
now = datetime.now()
if "минут" in time_text:
remind_time = now + timedelta(minutes=int(time_text.split()[0]))
elif "час" in time_text:
remind_time = now + timedelta(hours=int(time_text.split()[0]))
elif "день" in time_text:
remind_time = now + timedelta(days=1)
else:
# Если не распознали формат, просим ввести заново
msg = bot.send_message(chat_id, "Формат не распознан. Попробуйте еще раз.")
bot.register_next_step_handler(msg, process_time_step)
return

# Запрашиваем текст напоминания
msg = bot.send_message(chat_id, "Что напомнить?")
bot.register_next_step_handler(msg, lambda m: process_reminder_text(m, remind_time))

def process_reminder_text(message, remind_time):
chat_id = message.chat.id
reminder_text = message.text

# Сохраняем напоминание
if chat_id not in reminders:
reminders[chat_id] = []

reminders[chat_id].append((remind_time, reminder_text))

# Сообщаем о создании напоминания
bot.send_message(
chat_id, 
f"Напоминание установлено на {remind_time.strftime('%d.%m.%Y %H:%M')}:\n{reminder_text}"
)

# Функция для проверки и отправки напоминаний
def check_reminders():
while True:
current_time = datetime.now()

# Проверяем все напоминания
for chat_id, user_reminders in list(reminders.items()):
for i, (remind_time, text) in enumerate(user_reminders):
if current_time >= remind_time:
# Отправляем напоминание
bot.send_message(chat_id, f"⏰ НАПОМИНАНИЕ ⏰\n\n{text}")

# Удаляем отправленное напоминание
user_reminders.pop(i)

# Если у пользователя не осталось напоминаний, удаляем запись
if not user_reminders:
reminders.pop(chat_id, None)

break

# Проверяем каждую минуту
time.sleep(60)

# Запускаем проверку напоминаний в отдельном потоке
reminder_thread = threading.Thread(target=check_reminders, daemon=True)
reminder_thread.start()

# Команда для просмотра всех напоминаний
@bot.message_handler(commands=['list'])
def list_reminders(message):
chat_id = message.chat.id

if chat_id not in reminders or not reminders[chat_id]:
bot.send_message(chat_id, "У вас нет активных напоминаний.")
return

# Формируем список напоминаний
response = "Ваши напоминания:\n\n"
for i, (remind_time, text) in enumerate(reminders[chat_id], 1):
response += f"{i}. {remind_time.strftime('%d.%m.%Y %H:%M')} – {text}\n"

bot.send_message(chat_id, response)

# Запускаем бота
if __name__ == '__main__':
bot.polling(none_stop=True)

import requests
import telebot
from telebot import types
from config import BOT_TOKEN, EXCHANGE_API_KEY

bot = telebot.TeleBot(BOT_TOKEN)

# Получение списка доступных валют
@bot.message_handler(commands=['currencies'])
def currencies_command(message):
try:
response = requests.get(f"https://api.exchangerate-api.com/v4/latest/USD")
data = response.json()
rates = data['rates']

currencies_list = "Доступные валюты:\n\n"
for currency in sorted(rates.keys()):
currencies_list += f"• {currency}\n"

bot.send_message(message.chat.id, currencies_list)
except Exception as e:
bot.send_message(message.chat.id, f"Ошибка при получении списка валют: {str(e)}")

# Команда для конвертации
@bot.message_handler(commands=['convert'])
def convert_command(message):
msg = bot.send_message(message.chat.id, "Введите сумму для конвертации (например, 100 USD to EUR)")
bot.register_next_step_handler(msg, process_conversion)

def process_conversion(message):
try:
# Парсим ввод пользователя
parts = message.text.upper().split()

if len(parts) != 4 or parts[2].lower() != "to":
raise ValueError("Неверный формат. Используйте: 100 USD to EUR")

amount = float(parts[0])
from_currency = parts[1]
to_currency = parts[3]

# Получаем курсы валют
response = requests.get(f"https://api.exchangerate-api.com/v4/latest/{from_currency}")
data = response.json()

if 'rates' not in data:
raise ValueError(f"Не удалось получить курс для {from_currency}")

if to_currency not in data['rates']:
raise ValueError(f"Не удалось найти валюту {to_currency}")

# Выполняем конвертацию
rate = data['rates'][to_currency]
converted_amount = amount * rate

# Форматируем ответ
result = f"{amount} {from_currency} = {converted_amount:.2f} {to_currency}\n"
result += f"Курс: 1 {from_currency} = {rate:.4f} {to_currency}"

bot.send_message(message.chat.id, result)

except ValueError as ve:
bot.send_message(message.chat.id, f"Ошибка: {str(ve)}")
except Exception as e:
bot.send_message(message.chat.id, f"Произошла ошибка: {str(e)}")

# Инлайн-клавиатура с популярными валютами
@bot.message_handler(commands=['start', 'help'])
def start_command(message):
markup = types.InlineKeyboardMarkup(row_width=2)

# Кнопки популярных валютных пар
btn1 = types.InlineKeyboardButton("USD → EUR", callback_data="convert_USD_EUR")
btn2 = types.InlineKeyboardButton("EUR → USD", callback_data="convert_EUR_USD")
btn3 = types.InlineKeyboardButton("USD → GBP", callback_data="convert_USD_GBP")
btn4 = types.InlineKeyboardButton("GBP → USD", callback_data="convert_GBP_USD")

markup.add(btn1, btn2, btn3, btn4)

bot.send_message(
message.chat.id, 
"Привет! Я бот для конвертации валют. Используйте команду /convert или выберите популярную валютную пару:",
reply_markup=markup
)

# Обработчик нажатий на инлайн-кнопки
@bot.callback_query_handler(func=lambda call: call.data.startswith("convert_"))
def callback_converter(call):
_, from_currency, to_currency = call.data.split("_")

markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
markup.add("10", "50", "100", "500", "1000")

msg = bot.send_message(
call.message.chat.id, 
f"Введите сумму в {from_currency} для конвертации в {to_currency}:",
reply_markup=markup
)

bot.register_next_step_handler(
msg, 
lambda m: convert_specific_currencies(m, from_currency, to_currency)
)

def convert_specific_currencies(message, from_currency, to_currency):
try:
amount = float(message.text)

# Получаем курс и конвертируем
response = requests.get(f"https://api.exchangerate-api.com/v4/latest/{from_currency}")
data = response.json()
rate = data['rates'][to_currency]
converted_amount = amount * rate

result = f"{amount} {from_currency} = {converted_amount:.2f} {to_currency}\n"
result += f"Курс: 1 {from_currency} = {rate:.4f} {to_currency}"

bot.send_message(message.chat.id, result)

except Exception as e:
bot.send_message(message.chat.id, f"Ошибка при конвертации: {str(e)}")

# Запускаем бота
if __name__ == '__main__':
bot.polling(none_stop=True)

from telebot import TeleBot, types
from config import BOT_TOKEN

bot = TeleBot(BOT_TOKEN)

# Создание клавиатуры главного меню
def create_main_menu():
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
btn1 = types.KeyboardButton("📘 Услуги")
btn2 = types.KeyboardButton("ℹ️ О нас")
btn3 = types.KeyboardButton("📞 Контакты")
markup.add(btn1, btn2, btn3)
return markup

# Создание клавиатуры меню услуг
def create_services_menu():
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
btn1 = types.KeyboardButton("💻 Разработка сайтов")
btn2 = types.KeyboardButton("📱 Мобильные приложения")
btn3 = types.KeyboardButton("🤖 Боты для Telegram")
btn4 = types.KeyboardButton("⬅️ Назад в главное меню")
markup.add(btn1, btn2)
markup.add(btn3)
markup.add(btn4)
return markup

# Обработчик команды /start
@bot.message_handler(commands=['start'])
def start_handler(message):
bot.send_message(
message.chat.id, 
"Добро пожаловать! Выберите раздел меню:",
reply_markup=create_main_menu()
)

# Обработчик текстовых сообщений для навигации по меню
@bot.message_handler(content_types=['text'])
def text_handler(message):
text = message.text.strip()

# Обработка главного меню
if text == "📘 Услуги":
bot.send_message(
message.chat.id,
"Выберите интересующую услугу:",
reply_markup=create_services_menu()
)
elif text == "ℹ️ О нас":
bot.send_message(
message.chat.id,
"Мы компания с 10-летним опытом разработки программного обеспечения...",
reply_markup=create_main_menu()
)
elif text == "📞 Контакты":
bot.send_message(
message.chat.id,
"Телефон: +7 (XXX) XXX-XX-XX\nEmail: example@example.com\nСайт: example.com",
reply_markup=create_main_menu()
)

# Обработка меню услуг
elif text == "💻 Разработка сайтов":
bot.send_message(
message.chat.id,
"Мы создаем современные сайты с адаптивным дизайном...",
reply_markup=create_services_menu()
)
elif text == "📱 Мобильные приложения":
bot.send_message(
message.chat.id,
"Разработка нативных приложений для iOS и Android...",
reply_markup=create_services_menu()
)
elif text == "🤖 Боты для Telegram":
bot.send_message(
message.chat.id,
"Профессиональная разработка телеграм ботов на Python для бизнеса и личных нужд...",
reply_markup=create_services_menu()
)
elif text == "⬅️ Назад в главное меню":
bot.send_message(
message.chat.id,
"Вы в главном меню. Выберите раздел:",
reply_markup=create_main_menu()
)

# Запуск бота
if __name__ == '__main__':
bot.polling(none_stop=True)

import logging
import telebot
from config import BOT_TOKEN

# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
filename='bot.log'
)

logger = logging.getLogger(__name__)

bot = telebot.TeleBot(BOT_TOKEN)

@bot.message_handler(commands=['start'])
def start_command(message):
user = message.from_user
logger.info(f"Пользователь {user.id} ({user.username}) запустил бота")
bot.reply_to(message, "Привет! Бот запущен.")

@bot.message_handler(content_types=['text'])
def handle_message(message):
try:
# Логирование входящих сообщений
logger.info(f"Получено сообщение от {message.from_user.id}: {message.text}")

# Обработка сообщения
response = f"Вы написали: {message.text}"
bot.send_message(message.chat.id, response)

except Exception as e:
# Логирование ошибок
logger.error(f"Ошибка при обработке сообщения: {str(e)}")
bot.send_message(message.chat.id, "Произошла ошибка при обработке сообщения.")

# Запуск бота
if __name__ == '__main__':
try:
logger.info("Бот запущен")
bot.polling(none_stop=True)
except Exception as e:
logger.critical(f"Критическая ошибка: {str(e)}")