كتابك - Kitaboka : تعلم البرمجة وحيل التطوير الرقمي
انضم إلينا

كيفية إنشاء بوت تيليجرام باستخدام Python

8 دقائق للقراءة
كيفية إنشاء بوت تيليجرام باستخدام Python

في السنوات الأخيرة أصبح تيليجرام واحدًا من أكثر التطبيقات استخدامًا في بناء الأدوات الذكية والخدمات الصغيرة التي تعمل تلقائيًا دون تدخل بشري مستمر. والجميل في الأمر أن إنشاء بوت تيليجرام لم يعد شيئًا معقدًا كما كان يظنه كثيرون في البداية. بالعكس، مع Python يمكنك بناء بوت بسيط في وقت قصير جدًا، ثم تطويره لاحقًا إلى مشروع متكامل يقدم خدمات حقيقية للمستخدمين، مثل الرد التلقائي، إرسال الإشعارات، جلب البيانات من APIs، إدارة القنوات والمجموعات، أو حتى تنفيذ أوامر إدارية داخل فريق عمل أو مجتمع رقمي.

إذا كنت تملك فكرة صغيرة وتريد تحويلها إلى أداة عملية، فبوت تيليجرام قد يكون بداية ممتازة. قد يكون البوت مجرد مساعد بسيط يرحب بالمستخدمين، أو قد يتحول إلى واجهة كاملة لخدمة قائمة بذاتها. ما يميز Python في هذا المجال أنه لغة واضحة وسهلة القراءة، وفي نفس الوقت قوية جدًا عندما يتعلق الأمر بالأتمتة والتعامل مع الشبكات والخدمات الخارجية. لذلك ستجد أن كثيرًا من المطورين يختارون Python عندما يريدون إطلاق بوت بسرعة دون الدخول في تعقيدات كبيرة.

في هذا المقال سنبني معًا تصورًا كاملًا عن كيفية إنشاء بوت تيليجرام باستخدام Python من الصفر. لن نكتفي بالشرح النظري، بل سنمر على خطوات عملية جدًا، بدءًا من إنشاء البوت عبر BotFather، ثم تجهيز بيئة Python، ثم كتابة أول كود يعمل، وبعد ذلك سنطوره ليصبح أكثر فائدة ومرونة. وسأحاول أن أكتب بأسلوب قريب من المبتدئ، لكن دون تبسيط مخل، لأن الهدف الحقيقي هو أن تفهم الفكرة وتستطيع تنفيذها بنفسك بثقة.

ما هو بوت تيليجرام؟

البوت في تيليجرام هو حساب آلي لا يديره شخص بشكل مباشر في كل لحظة، بل يعمل وفق تعليمات برمجية أنت تكتبها. هذا البوت يستطيع استقبال الرسائل من المستخدمين والرد عليها، كما يستطيع تنفيذ وظائف كثيرة مثل إرسال صور أو ملفات، مشاركة روابط، قراءة أوامر، أو التفاعل مع المجموعات والقنوات. وقد يبدو الأمر بسيطًا عند النظر إليه من الخارج، لكن الحقيقة أن البوتات أصبحت اليوم جزءًا مهمًا من الكثير من الأنظمة الرقمية، لأنها توفر واجهة سهلة وسريعة للتواصل مع المستخدم.

عندما يرسل شخص رسالة إلى البوت، فإن تيليجرام يمرر هذه الرسالة إلى كود Python الخاص بك، ثم يقوم الكود بمعالجة الرسالة وإرجاع رد مناسب. هذا يعني أن البوت ليس مجرد ردود ثابتة، بل يمكنه أن يكون ذكيًا إلى حد كبير بحسب ما تبنيه أنت. قد يسأل المستخدم عن حالة الطلب، أو عن آخر الأخبار، أو عن أسعار منتج، أو عن محتوى معين، والبوت يرد بناءً على منطق برمجي أنت من تصنعه.

لماذا Python بالذات؟

قد تسأل نفسك: لماذا أختار Python بدلًا من لغة أخرى؟ الجواب بسيط نسبيًا. Python مناسبة جدًا للمبتدئين، وتملك مكتبات قوية جدًا لبناء البوتات والتعامل مع Telegram API. كما أن شكل الكود فيها واضح ومباشر، وهذا يختصر وقت التعلم. بدل أن تضيع وقتك في تفاصيل معقدة في البداية، يمكنك أن تركز على الفكرة الأساسية: كيف يستقبل البوت الرسائل؟ كيف يرد؟ كيف أضيف الأوامر؟ كيف أتعامل مع البيانات؟

ميزة أخرى مهمة وهي سرعة التجربة. يمكنك كتابة سكربت صغير وتشغيله خلال دقائق، ثم تبدأ في تحسينه. وهذا يجعل عملية التعلم ممتعة، لأنك ترى النتيجة بسرعة. كثير من المبتدئين يفقدون الحماس عندما تكون النتيجة بعيدة جدًا، لكن مع بوت تيليجرام باستخدام Python يمكنك رؤية أول رد من البوت خلال وقت قصير، وهذا يعطيك شعورًا جميلًا بأنك بالفعل تبني شيئًا حيًا.

كيف يعمل بوت تيليجرام من الداخل؟

لفهم البوت بشكل صحيح، من المفيد أن تتصور ما يحدث خلف الكواليس. المستخدم يكتب رسالة في تيليجرام، تيليجرام يرسل هذه الرسالة إلى البوت عبر API، ثم ينتظر البوت أن يقرر ما هو الرد المناسب. البوت يمكن أن يعمل بطريقتين أساسيتين: إما عن طريق polling، حيث يقوم الكود بسؤال تيليجرام باستمرار إن كانت هناك رسائل جديدة، أو عن طريق webhooks، حيث يرسل تيليجرام التحديثات مباشرة إلى رابط على الخادم الذي تستضيف عليه البوت.

في مرحلة التعلم، polling هو الأسهل لأنه لا يتطلب إعداد خادم HTTPS أو إعدادات معقدة. أما في المشاريع الإنتاجية، فغالبًا ما يتم استخدام webhook لأنه أكثر كفاءة في بعض الحالات، وخاصة إذا كنت تريد تقليل استهلاك الموارد أو جعل البوت يعمل داخل بيئة استضافة منظمة. ومع ذلك، سنبدأ هنا بالطريقة الأسهل والأوضح، ثم نلمس طريقة التطوير لاحقًا.

المتطلبات الأساسية قبل البدء

قبل أن تبدأ، ستحتاج إلى:

  • حساب تيليجرام عادي

  • Python مثبتة على جهازك

  • محرر أكواد مثل VS Code

  • اتصال بالإنترنت

  • معرفة بسيطة جدًا بأوامر الطرفية أو Terminal

ولا تقلق إذا لم تكن لديك خبرة كبيرة. المقال مكتوب بحيث يمشي معك خطوة خطوة. الأهم فقط أن تتبع الترتيب، لأن بناء البوت يشبه كثيرًا بناء بيت صغير: لا تبدأ بالسقف قبل أن تضع الأساس.

إنشاء البوت من خلال BotFather

أول خطوة عملية هي أن تحصل على البوت نفسه من تيليجرام. يتم ذلك عبر الحساب الرسمي المعروف باسم BotFather. هو الأداة الرسمية لإنشاء وإدارة البوتات في تيليجرام.

افتح تيليجرام وابحث عن BotFather، ثم ابدأ المحادثة معه، واكتب الأمر:

/newbot

بعد ذلك سيطلب منك اسم البوت، ثم سيطلب اسم المستخدم الخاص به، ويجب أن ينتهي غالبًا بـ bot. مثال:

My Helper Bot
my_helper_bot

إذا كان الاسم متاحًا، سيمنحك BotFather Token خاصًا بالبروت. هذا التوكن بالغ الأهمية، لأنه المفتاح الذي يربط كود Python بحساب البوت. يجب أن تتعامل معه بحذر شديد، لأنه بمثابة كلمة مرور حساسة. لا تشاركه مع أحد، ولا ترفعه إلى GitHub بشكل علني، ولا تضعه داخل أماكن غير آمنة.

التوكن عادة يكون على هذا الشكل:

123456789:AAExampleTokenHere1234567890

هذا ليس توكن حقيقيًا، بل مثال فقط.

تجهيز بيئة Python

بعد أن تحصل على التوكن، ننتقل إلى إعداد المشروع على جهازك. الأفضل دائمًا أن تعمل داخل بيئة افتراضية حتى لا تختلط الحزم بين مشروع وآخر. هذا مفيد جدًا عندما تكبر المشاريع، لأنه يحافظ على النظام ويمنع التعارضات.

أنشئ مجلدًا جديدًا لمشروعك، ثم افتح الطرفية داخله.

إنشاء بيئة افتراضية

على ويندوز:

python -m venv venv

على لينكس أو ماك:

python3 -m venv venv

ثم تفعيل البيئة:

على ويندوز:

venv\Scripts\activate

على لينكس أو ماك:

source venv/bin/activate

عندما تصبح البيئة مفعلة، ستشعر أن العمل صار أكثر تنظيمًا. بعد ذلك سنحتاج إلى تثبيت مكتبة للتعامل مع تيليجرام.

تثبيت المكتبة المناسبة

هناك أكثر من مكتبة شهيرة لبناء بوتات تيليجرام باستخدام Python، لكن من المكتبات المعروفة والسهلة الاستخدام مكتبة python-telegram-bot. هذه المكتبة منظمة جدًا وتناسب المبتدئين والمتوسطين، كما أنها تحتوي على أدوات كثيرة تجعل بناء البوت أسهل.

ثبّت المكتبة بالأمر التالي:

pip install python-telegram-bot

إذا أردت أيضًا استخدام متغيرات البيئة لحماية التوكن لاحقًا، يمكنك تثبيت python-dotenv:

pip install python-dotenv

إنشاء أول بوت بسيط جدًا

لنبدأ بأبسط نسخة ممكنة. الهدف هنا ليس بناء مشروع ضخم من البداية، بل التأكد أن كل شيء يعمل كما ينبغي.

أنشئ ملفًا باسم bot.py، واكتب فيه:

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

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("مرحبًا بك! أنا بوت تيليجرام بسيط مكتوب بـ Python.")

def main():
    app = Application.builder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))

    print("البوت يعمل الآن...")
    app.run_polling()

if __name__ == "__main__":
    main()

هذا الكود هو أول خطوة حقيقية. عند تشغيله، سيبدأ البوت في العمل، وعندما تكتب /start في المحادثة معه، سيرد برسالة ترحيب بسيطة.

شرح الكود

السطر الأول يستورد بعض الكائنات الأساسية من المكتبة.
ثم نضع التوكن في متغير TOKEN.
بعدها نعرف دالة start، وهي دالة غير متزامنة async لأن المكتبة الحديثة تعتمد على الأسلوب الحديث في التعامل مع الأحداث.
داخل هذه الدالة نستخدم reply_text لإرسال رد نصي.
ثم في main ننشئ التطبيق ونربط التوكن، ونضيف معالج الأمر /start.
وأخيرًا نشغل البوت باستخدام run_polling().

في هذه اللحظة قد يبدو الكود صغيرًا جدًا، لكن هذا في الحقيقة هو الهيكل الأساسي الذي ستبني عليه أشياء كثيرة لاحقًا.

تشغيل البوت

بعد حفظ الملف، شغّل:

python bot.py

إذا لم يكن هناك خطأ، فسترى رسالة في الطرفية تشير إلى أن البوت يعمل. بعدها افتح تيليجرام، واذهب إلى البوت الذي أنشأته، واكتب:

/start

إذا ظهرت لك رسالة الرد، فأنت نجحت بالفعل في بناء أول بوت تيليجرام باستخدام Python. وقد يبدو هذا الإنجاز بسيطًا، لكنه في الواقع نقطة بداية ممتازة جدًا.

إضافة أمر جديد للبوت

الآن بعدما فهمت الفكرة الأساسية، دعنا نضيف أمرًا آخر مثل /help.

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

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("مرحبًا! اكتب /help لمعرفة الأوامر المتاحة.")

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("الأوامر المتاحة:\n/start - بدء البوت\n/help - عرض المساعدة")

def main():
    app = Application.builder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("help", help_command))

    app.run_polling()

if __name__ == "__main__":
    main()

بهذا الشكل أصبح لديك أمران. هذه هي الفكرة الأساسية: كل أمر تضيفه يكون له معالج handler خاص به، وكل معالج ينفذ ردًا محددًا.

التعامل مع الرسائل النصية العادية

أحيانًا لا تريد أن يرد البوت فقط على الأوامر، بل على أي رسالة يكتبها المستخدم. هنا نستخدم MessageHandler.

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

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("أرسل لي أي رسالة، وسأرد عليك.")

async def echo_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_text = update.message.text
    await update.message.reply_text(f"أنت كتبت: {user_text}")

def main():
    app = Application.builder().token(TOKEN).build()

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

    app.run_polling()

if __name__ == "__main__":
    main()

هنا أي نص يرسله المستخدم يتم التقاطه والرد عليه. هذا النمط يسمى أحيانًا بوت echo لأنه يعيد ما يقوله المستخدم. وهو مفيد جدًا في الفهم والاختبار.

جعل البوت أكثر تفاعلية

البوت الجيد لا يكتفي بردود جامدة. يمكنه أن يكون تفاعليًا بطريقة لطيفة. مثلاً، بدلاً من أن يكون الرد مجرد نص، يمكنك أن تجعله يسأل المستخدم سؤالًا ثم ينتظر الرد.

هذا النوع من التفاعل يسمى Conversation Handler، وهو مفيد جدًا في البوتات التي تجمع معلومات من المستخدمين، مثل الاسم أو البريد أو رقم الطلب أو تاريخ الحجز.

مثال بسيط:

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

TOKEN = "ضع_التوكن_هنا"

ASK_NAME = 1

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("مرحبًا! ما اسمك؟")
    return ASK_NAME

async def get_name(update: Update, context: ContextTypes.DEFAULT_TYPE):
    name = update.message.text
    await update.message.reply_text(f"تشرفت بمعرفتك يا {name}!")
    return ConversationHandler.END

async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("تم الإلغاء.")
    return ConversationHandler.END

def main():
    app = Application.builder().token(TOKEN).build()

    conv_handler = ConversationHandler(
        entry_points=[CommandHandler("start", start)],
        states={
            ASK_NAME: [MessageHandler(filters.TEXT & ~filters.COMMAND, get_name)]
        },
        fallbacks=[CommandHandler("cancel", cancel)]
    )

    app.add_handler(conv_handler)
    app.run_polling()

if __name__ == "__main__":
    main()

في هذا المثال يبدأ البوت بسؤال الاسم، ثم ينتظر الرد، ثم يرد بشكل شخصي. هذا النوع من البوتات يعطي إحساسًا حيًا أكثر، ويجعل التفاعل طبيعيًا.

استخدام متغيرات البيئة بدل كتابة التوكن مباشرة

من الأفضل جدًا ألا تكتب التوكن داخل الكود مباشرة، لأن ذلك قد يسبب مشكلة أمنية إذا شاركت المشروع مع غيرك أو رفعته إلى مستودع عام. الحل الأفضل هو استخدام ملف .env.

أنشئ ملفًا باسم .env:

BOT_TOKEN=123456789:AAExampleTokenHere1234567890

ثم استخدمه في الكود:

import os
from dotenv import load_dotenv
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

load_dotenv()
TOKEN = os.getenv("BOT_TOKEN")

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("تم تشغيل البوت بنجاح باستخدام .env")

def main():
    app = Application.builder().token(TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.run_polling()

if __name__ == "__main__":
    main()

هذا الأسلوب أكثر احترافية، ويُفضل استخدامه من البداية حتى تكتسب عادة جيدة في كتابة المشاريع.

إرسال أزرار داخل البوت

أحيانًا يكون من الجميل أن تعطي المستخدم أزرارًا بدل أن تطلب منه كتابة الأوامر يدويًا. هذا يجعل التجربة أبسط، خاصة إذا كان المستخدم غير معتاد على البوتات.

يمكنك استخدام ReplyKeyboardMarkup:

from telegram import Update, ReplyKeyboardMarkup
from telegram.ext import Application, CommandHandler, ContextTypes

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        ["من نحن", "الخدمات"],
        ["تواصل معنا"]
    ]
    reply_markup = ReplyKeyboardMarkup(keyboard, resize_keyboard=True)
    await update.message.reply_text("اختر من القائمة:", reply_markup=reply_markup)

def main():
    app = Application.builder().token(TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.run_polling()

if __name__ == "__main__":
    main()

ثم يمكنك قراءة الرسالة التي يختارها المستخدم والرد عليها وفقًا للزر الذي ضغط عليه.

الرد على الأزرار Inline Keyboard

هناك نوع آخر أجمل في بعض الحالات، وهو الأزرار المضمنة Inline Keyboard، والتي تظهر تحت الرسالة نفسها.

from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, CallbackQueryHandler, ContextTypes

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("نعم", callback_data="yes")],
        [InlineKeyboardButton("لا", callback_data="no")]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text("هل تريد المتابعة؟", reply_markup=reply_markup)

async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()

    if query.data == "yes":
        await query.edit_message_text("رائع! لقد اخترت نعم.")
    else:
        await query.edit_message_text("حسنًا، تم اختيار لا.")

def main():
    app = Application.builder().token(TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CallbackQueryHandler(button_handler))
    app.run_polling()

if __name__ == "__main__":
    main()

هذا الأسلوب يعطي تجربة أكثر احترافية، خصوصًا في البوتات التي تحتوي على قوائم واختيارات كثيرة.

إرسال الصور والملفات

لا يقتصر البوت على النص فقط. يمكنك أن تجعله يرسل صورًا أو ملفات أو حتى أصواتًا.

إرسال صورة

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

TOKEN = "ضع_التوكن_هنا"

async def photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_photo(photo="https://example.com/image.jpg", caption="هذه صورة مرسلة من البوت")

def main():
    app = Application.builder().token(TOKEN).build()
    app.add_handler(CommandHandler("photo", photo))
    app.run_polling()

if __name__ == "__main__":
    main()

إرسال ملف محلي

async def document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    with open("file.pdf", "rb") as f:
        await update.message.reply_document(document=f)

هذه الخصائص تجعل البوت قادرًا على أن يكون مركز توزيع محتوى صغير، وليس مجرد صندوق ردود.

ربط البوت مع API خارجي

هنا تبدأ مرحلة مهمة جدًا، لأن البوت يصبح أكثر ذكاءً وفائدة. بدل أن يرد برسائل ثابتة فقط، يمكنك أن تجعله يجلب معلومات من مصدر خارجي، مثل حالة الطقس، أو أخبار، أو أسعار العملات، أو بيانات من قاعدة بيانات، أو أي خدمة توفر API.

مثال بسيط على جلب البيانات باستخدام requests:

pip install requests

ثم:

import requests
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

TOKEN = "ضع_التوكن_هنا"

async def weather(update: Update, context: ContextTypes.DEFAULT_TYPE):
    city = "Casablanca"
    url = f"https://api.example.com/weather?city={city}"

    response = requests.get(url)
    data = response.json()

    temperature = data["temperature"]
    await update.message.reply_text(f"درجة الحرارة في {city} هي {temperature}°C")

def main():
    app = Application.builder().token(TOKEN).build()
    app.add_handler(CommandHandler("weather", weather))
    app.run_polling()

if __name__ == "__main__":
    main()

طبعًا هذا المثال توضيحي، لكن الفكرة هي نفسها: البوت يصبح بوابة لبيانات حقيقية.

مثال عملي: بوت بسيط لإدارة المهام

لنأخذ مثالًا أقرب إلى الاستخدام الواقعي. تخيل أن لديك فريقًا صغيرًا أو حتى تنظيمًا شخصيًا، وتريد بوتًا يسجل المهام.

سننشئ بوتًا بسيطًا يدعم:

  • إضافة مهمة

  • عرض المهام

  • حذف مهمة

الكود

from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes
import os
from dotenv import load_dotenv

load_dotenv()
TOKEN = os.getenv("BOT_TOKEN")

tasks = []

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    message = (
        "مرحبًا بك في بوت المهام.\n\n"
        "الأوامر المتاحة:\n"
        "/addtask <task> - إضافة مهمة\n"
        "/listtasks - عرض المهام\n"
        "/cleartasks - حذف كل المهام"
    )
    await update.message.reply_text(message)

async def addtask(update: Update, context: ContextTypes.DEFAULT_TYPE):
    task_text = " ".join(context.args)

    if not task_text:
        await update.message.reply_text("اكتب المهمة بعد الأمر، مثل:\n/addtask شراء الخبز")
        return

    tasks.append(task_text)
    await update.message.reply_text(f"تمت إضافة المهمة: {task_text}")

async def listtasks(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if not tasks:
        await update.message.reply_text("لا توجد مهام حاليًا.")
        return

    message = "قائمة المهام:\n"
    for i, task in enumerate(tasks, start=1):
        message += f"{i}. {task}\n"

    await update.message.reply_text(message)

async def cleartasks(update: Update, context: ContextTypes.DEFAULT_TYPE):
    tasks.clear()
    await update.message.reply_text("تم حذف جميع المهام.")

def main():
    app = Application.builder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("addtask", addtask))
    app.add_handler(CommandHandler("listtasks", listtasks))
    app.add_handler(CommandHandler("cleartasks", cleartasks))

    print("Bot is running...")
    app.run_polling()

if __name__ == "__main__":
    main()

ماذا يفعل هذا البوت؟

هذا البوت يستخدم قائمة بسيطة في الذاكرة لتخزين المهام. وعندما تضيف مهمة، يتم حفظها في المتغير tasks. وعند طلب العرض، يتم إظهار القائمة، وعند الحذف يتم مسحها.

ورغم أنه بسيط، فهو يعلمك فكرة مهمة جدًا: البوت ليس فقط ردودًا، بل يمكن أن يكون أداة تنظيم حقيقية. وفي مشروع أكبر، يمكنك ربط هذه القائمة بقاعدة بيانات حتى لا تضيع المهام عند إعادة تشغيل البوت.

استخدام قاعدة بيانات

عندما يبدأ المشروع في النمو، لن يكون من المناسب حفظ المعلومات داخل متغيرات عادية فقط، لأن كل شيء سيضيع عند إيقاف التطبيق. هنا تأتي أهمية قواعد البيانات مثل SQLite أو PostgreSQL أو MySQL.

مثال بسيط جدًا مع SQLite

import sqlite3

conn = sqlite3.connect("bot.db")
cursor = conn.cursor()

cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_name TEXT NOT NULL
)
""")

conn.commit()
conn.close()

بعد ذلك يمكنك إدخال مستخدم أو قراءة بياناته وربطها مع رسائل البوت. هذا يفتح الباب أمام مشاريع أكبر بكثير، مثل حفظ الاشتراكات، أو تتبع الطلبات، أو تخزين إعدادات المستخدمين.

معالجة الأخطاء بشكل ذكي

من المهم جدًا ألا ينهار البوت بسبب خطأ صغير. قد يرسل المستخدم رسالة غريبة، أو قد يفشل API خارجي، أو قد تكون هناك مشكلة في الاتصال. لذلك من الأفضل دائمًا أن تضع معالجة أخطاء مناسبة.

async def safe_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        text = update.message.text
        await update.message.reply_text(f"استلمت الرسالة: {text}")
    except Exception as e:
        await update.message.reply_text("حدث خطأ غير متوقع.")
        print(f"Error: {e}")

في المشاريع الجدية، معالجة الأخطاء جزء أساسي من الاحتراف، لأن المستخدم لا يهتم كثيرًا بما حدث داخليًا، بل يهتم فقط بأن الخدمة تعمل بشكل مستقر.

أفضل الممارسات عند بناء بوت تيليجرام

هناك مجموعة من الأمور التي تجعل مشروعك أفضل وأكثر نظافة وراحة في التطوير.
أولها أن تفصل المنطق عن العرض قدر الإمكان. لا تضع كل شيء في ملف واحد إذا بدأ المشروع يكبر. من الأفضل تقسيم الأكواد إلى ملفات: ملف للأوامر، ملف للإعدادات، ملف للوظائف المساعدة، وملف رئيسي للتشغيل.

وثانيها أن تحفظ التوكنات والمفاتيح السرية في متغيرات البيئة.
وثالثها أن تكتب رسائل واضحة للمستخدم. أحيانًا يكون الرد اللطيف والواضح أهم من الرد الذكي.
ورابعها أن تختبر البوت كثيرًا قبل نشره، لأن بعض الأخطاء الصغيرة لا تظهر إلا عند التفاعل الحقيقي.
وخامسها أن تراعي تجربة المستخدم. البوت الجيد ليس فقط الذي يعمل، بل الذي يفهمه المستخدم من أول مرة تقريبًا.

كيف تنشر البوت على الإنترنت؟

بعد أن يتأكد كل شيء محليًا، ستحتاج غالبًا إلى تشغيل البوت على خادم دائم إذا كنت تريد أن يعمل 24/7. هناك عدة طرق شائعة، مثل:

  • VPS

  • خوادم سحابية

  • خدمات استضافة تطبيقات Python

  • Docker في بيئة احترافية

في مرحلة البداية قد تشغله على جهازك المحلي فقط، لكن عندما تصبح جاهزًا للإطلاق، فكر في النشر على خادم دائم حتى لا يتوقف كلما أغلقت جهازك.

هل أستخدم polling أم webhook؟

هذا سؤال مهم.
إذا كنت مبتدئًا، ابدأ بـ polling لأنه أسهل بكثير.
إذا كنت تبني مشروعًا أكبر أو تريد أداءً أفضل في بيئة إنتاجية مناسبة، فقد يكون webhook خيارًا جيدًا.

Polling مريح في التطوير، أما webhook فهو أكثر قربًا من البنية الاحترافية في كثير من الحالات. لا تحتاج أن تقلق كثيرًا من هذه النقطة في البداية. المهم أن تفهم الفكرة وتبني أول نسخة تعمل.

أفكار مشاريع يمكنك تنفيذها بعد هذا المقال

بعد أن تتعلم الأساسيات، تستطيع بناء أفكار كثيرة جدًا، مثل:

  • بوت لتلقي رسائل العملاء

  • بوت للأوامر الإدارية في مجموعة

  • بوت لأرشفة الرسائل المهمة

  • بوت يرسل تذكيرات يومية

  • بوت يعرض الأخبار

  • بوت يقدم خدمة أسئلة وأجوبة

  • بوت يربط المستخدم بقاعدة بيانات

  • بوت يعرض بيانات متجر أو طلبات

  • بوت محتوى تعليمي أو إخباري

  • بوت لتنظيم المهام الشخصية

كل فكرة من هذه الأفكار يمكن أن تتحول إلى مشروع كامل إذا بنيتها بتدرج وصبر.

أخطاء شائعة عند المبتدئين

كثير من المبتدئين يقعون في نفس الأخطاء تقريبًا. منهم من ينسى إضافة المعالج المناسب، فيتساءل لماذا لا يرد البوت. ومنهم من يضع التوكن بشكل خاطئ. ومنهم من لا يفعل البيئة الافتراضية ثم يختلط عليه الأمر بعد ذلك. وهناك من ينسى أن بعض الدوال في المكتبات الحديثة تحتاج إلى async و await. وهناك أيضًا من يكتب ردودًا طويلة جدًا بدون اختبار، ثم يكتشف أن التنسيق في تيليجرام يحتاج عناية خاصة.

والحقيقة أن هذه الأخطاء طبيعية جدًا. لا يوجد مبرمج يبدأ خبيرًا. المهم أن تتعامل معها بهدوء، وأن تختبر كل جزء على حدة. إذا لم يعمل أمر /start، جرّب فقط هذا الأمر وحده. إذا عمل ثم أضفت شيئًا جديدًا وتوقف، فالمشكلة غالبًا في الإضافة الأخيرة. هذه طريقة تفكير عملية توفر عليك الكثير من الوقت.

مثال متقدم قليلًا: بوت يرحب بالمستخدمين ويعرض قائمة أوامر

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

TOKEN = "ضع_التوكن_هنا"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    welcome = (
        "مرحبًا بك 👋\n\n"
        "أنا بوت تجريبي مكتوب بـ Python.\n"
        "استخدم /help لمعرفة الأوامر المتاحة."
    )
    await update.message.reply_text(welcome)

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    help_text = (
        "الأوامر:\n"
        "/start - بدء البوت\n"
        "/help - عرض المساعدة\n"
        "/about - معلومات عن البوت"
    )
    await update.message.reply_text(help_text)

async def about(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("هذا بوت بسيط للتجربة والتعلم.")

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = update.message.text
    await update.message.reply_text(f"وصلني منك: {text}")

def main():
    app = Application.builder().token(TOKEN).build()

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

    print("البوت يعمل...")
    app.run_polling()

if __name__ == "__main__":
    main()

هذا المثال يجمع بين الأوامر والرد على الرسائل العادية، وهو قريب جدًا من الشكل الذي تبدأ به معظم البوتات الصغيرة.

كيف تجعل البوت أفضل من مجرد نموذج تعليمي؟

إذا أردت أن يتحول البوت من مجرد تجربة إلى مشروع حقيقي، ففكر في ثلاث نقاط: القيمة، البساطة، والاعتمادية.
القيمة تعني أن البوت يحل مشكلة حقيقية أو يوفر وقتًا.
والبساطة تعني أن المستخدم يفهمه بسرعة.
والاعتمادية تعني أنه لا يتعطل بسهولة ولا ينسى البيانات ولا ينهار بسبب خطأ صغير.

كثير من المشاريع تبدأ بحماس كبير ثم تفشل لأنها معقدة أكثر من اللازم. لا تجعل هذا يحدث معك. ابدأ بشيء صغير جدًا، ثم أضف خصائص تدريجيًا. ربما اليوم بوت يرد، وغدًا بوت يجمع بيانات، وبعدها بوت يتعامل مع قاعدة بيانات، وبعدها بوت ينفذ مهام تلقائية. بهذا الشكل ستشعر أن المشروع ينمو معك، لا ضدك.

خلاصة ما تعلمناه

في هذا المقال تعرفنا على فكرة بوت تيليجرام، ولماذا Python خيار ممتاز لبنائه، وكيف نحصل على التوكن عبر BotFather، وكيف نجهز بيئة العمل، وكيف نكتب أول بوت بسيط، ثم كيف نضيف أوامر ورسائل وأزرارًا وتفاعلًا أفضل. كما رأينا كيف يمكن ربط البوت مع APIs، وكيف نفكر في التخزين والمعالجة والأخطاء والنشر.

والأهم من كل ذلك أن الصورة لم تعد غامضة. بوت تيليجرام ليس شيئًا سحريًا أو معقدًا، بل هو تطبيق صغير يستقبل رسائل ويُصدر ردودًا، ويمكنك أن تبنيه وتطوره بالخطوات. ومع Python ستجد أن الطريق أسهل مما توقعت.

ربما أول بوت تكتبه اليوم سيكون بسيطًا جدًا، لكنه قد يكون الشرارة الأولى لمشروع كبير لاحقًا. وهذه هي متعة البرمجة فعلًا: تبدأ من سطر صغير، ثم تكتشف أن السطور الصغيرة يمكن أن تصنع أدوات مفيدة جدًا في الحياة اليومية.

#بوت تيليجرام بايثون #إنشاء بوت تيليجرام #Telegram Bot Python #شرح بوت تيليجرام #Python Telegram Bot #تعلم Python #برمجة بوت تيليجرام #python-telegram-bot