Criando Bots Telegram Python — 2025 | Python Brasil

# No terminal:
# pip install python-telegram-bot

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

# Token do seu bot (nunca compartilhe ou publique)
TOKEN = "SEU_TOKEN_AQUI"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Responde ao comando /start."""
    nome = update.effective_user.first_name
    await update.message.reply_text(
        f"Olá, {nome}! Bem-vindo ao bot.\n\n"
        "Comandos disponíveis:\n"
        "/ajuda - Lista de comandos\n"
        "/sobre - Informações sobre o bot"
    )

async def ajuda(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Responde ao comando /ajuda."""
    texto = (
        "Comandos disponíveis:\n\n"
        "/start - Iniciar o bot\n"
        "/ajuda - Mostrar esta mensagem\n"
        "/sobre - Sobre o bot\n"
        "/cotacao - Cotação do dólar\n"
        "/clima [cidade] - Previsão do tempo"
    )
    await update.message.reply_text(texto)

async def sobre(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Responde ao comando /sobre."""
    await update.message.reply_text(
        "Bot criado com Python e python-telegram-bot.\n"
        "Versão: 1.0.0"
    )

def main():
    """Função principal que inicia o bot."""
    app = Application.builder().token(TOKEN).build()

    # Registrando handlers de comandos
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("ajuda", ajuda))
    app.add_handler(CommandHandler("sobre", sobre))

    print("Bot iniciado. Pressione Ctrl+C para parar.")
    app.run_polling()

if __name__ == "__main__":
    main()

async def responder_mensagem(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Processa mensagens de texto normais."""
    texto = update.message.text.lower()

    respostas = {
        "olá": "Olá! Como posso ajudar?",
        "oi": "Oi! Tudo bem? Use /ajuda para ver os comandos.",
        "obrigado": "De nada! Estou sempre por aqui.",
        "tchau": "Até mais! Volte quando precisar.",
    }

    for chave, resposta in respostas.items():
        if chave in texto:
            await update.message.reply_text(resposta)
            return

    await update.message.reply_text(
        "Não entendi sua mensagem. Use /ajuda para ver os comandos disponíveis."
    )

# Adicione este handler na função main(), depois dos CommandHandlers:
# app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, responder_mensagem))

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Exibe um menu com botões interativos."""
    teclado = [
        [
            InlineKeyboardButton("Cotação Dólar", callback_data="cotacao_dolar"),
            InlineKeyboardButton("Cotação Euro", callback_data="cotacao_euro"),
        ],
        [
            InlineKeyboardButton("Clima SP", callback_data="clima_sp"),
            InlineKeyboardButton("Clima RJ", callback_data="clima_rj"),
        ],
        [
            InlineKeyboardButton("Ajuda", callback_data="ajuda"),
        ]
    ]

    reply_markup = InlineKeyboardMarkup(teclado)
    await update.message.reply_text("Escolha uma opção:", reply_markup=reply_markup)

async def botao_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Processa cliques nos botões inline."""
    query = update.callback_query
    await query.answer()

    opcoes = {
        "cotacao_dolar": "Dólar: R$ 5,12 (exemplo)",
        "cotacao_euro": "Euro: R$ 5,58 (exemplo)",
        "clima_sp": "São Paulo: 24°C, parcialmente nublado (exemplo)",
        "clima_rj": "Rio de Janeiro: 31°C, ensolarado (exemplo)",
        "ajuda": "Use /ajuda para ver todos os comandos.",
    }

    resposta = opcoes.get(query.data, "Opção não reconhecida.")
    await query.edit_message_text(text=resposta)

# Na função main():
# app.add_handler(CommandHandler("menu", menu))
# app.add_handler(CallbackQueryHandler(botao_callback))

import aiohttp

async def buscar_cep(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Consulta informações de um CEP usando a API ViaCEP."""
    if not context.args:
        await update.message.reply_text("Use: /cep 01310100")
        return

    cep = context.args[0].replace("-", "")

    if len(cep) != 8 or not cep.isdigit():
        await update.message.reply_text("CEP inválido. Use 8 dígitos.")
        return

    url = f"https://viacep.com.br/ws/{cep}/json/"

    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resposta:
            if resposta.status == 200:
                dados = await resposta.json()
                if "erro" in dados:
                    await update.message.reply_text("CEP não encontrado.")
                    return

                texto = (
                    f"CEP: {dados['cep']}\n"
                    f"Logradouro: {dados.get('logradouro', 'N/A')}\n"
                    f"Bairro: {dados.get('bairro', 'N/A')}\n"
                    f"Cidade: {dados['localidade']}\n"
                    f"Estado: {dados['uf']}"
                )
                await update.message.reply_text(texto)
            else:
                await update.message.reply_text("Erro ao consultar o CEP.")

# Na função main():
# app.add_handler(CommandHandler("cep", buscar_cep))

async def salvar_nota(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Salva uma nota para o usuário."""
    if not context.args:
        await update.message.reply_text("Use: /nota Texto da sua nota")
        return

    nota = " ".join(context.args)

    if "notas" not in context.user_data:
        context.user_data["notas"] = []

    context.user_data["notas"].append(nota)
    total = len(context.user_data["notas"])
    await update.message.reply_text(f"Nota salva. Você tem {total} nota(s).")

async def listar_notas(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Lista as notas do usuário."""
    notas = context.user_data.get("notas", [])

    if not notas:
        await update.message.reply_text("Você não tem nenhuma nota salva.")
        return

    texto = "Suas notas:\n\n"
    for i, nota in enumerate(notas, 1):
        texto += f"{i}. {nota}\n"

    await update.message.reply_text(texto)

import logging

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO
)

async def erro_handler(update, context):
    """Trata erros globais do bot."""
    logging.error(f"Erro: {context.error}")
    if update and update.message:
        await update.message.reply_text("Ocorreu um erro. Tente novamente mais tarde.")

# Na função main():
# app.add_error_handler(erro_handler)