Telegram-Bot in Python. Eine vollständige Anleitung zum Schreiben eines Bots mit Wechselkursen von Grund auf neu

Bots in Telegram sind Programme, die dabei helfen, den Kontakt zum Publikum herzustellen oder Aktionen zu vereinfachen, die bisher manuell durchgeführt werden mussten. Diese Programme sind speziell für die Messenger-Plattform geschrieben. Bots funktionieren auf diese Weise: Der Benutzer sendet einen Befehl über die Eingabezeile und das System antwortet mit einem Text oder einer interaktiven Nachricht. Manchmal ahmt das Programm sogar die Handlungen einer realen Person nach – ein solcher Bot weckt mehr Vertrauen bei den Kunden.

Es gibt verschiedene Arten von Systemen zur automatischen Unterstützung von Benutzern. Manche Bots kommunizieren nur mit Kunden, andere liefern regelmäßig Informationen. Eine eindeutige Einteilung von Programmen in Typen ist nicht möglich – Entwickler vereinen oft mehrere Funktionen in einem Bot.

In 9 Schritten können Sie einen einfachen Bot für Telegram mit interaktiven Elementen in Form von On-Screen-Buttons schreiben. Schauen wir uns jeden von ihnen im Detail an und beantworten ein paar Fragen:

• wie man einen Bot startet;
• wie man eine eingebaute Tastatur von einer oder mehreren Tasten registriert;
• wie man die Tasten für die gewünschten Funktionen programmiert;
• Was ist der Inline-Modus und wie wird er für einen vorhandenen Bot eingerichtet?

Schritt 0: Theoretischer Hintergrund zur Telegram Bots API

Das Hauptwerkzeug zum Erstellen von Telegram-Bots ist die HTML-Anwendungsprogrammierschnittstelle oder HTML-API. Dieses Element nimmt Besucheranfragen entgegen und sendet Antworten in Form von Informationen. Vorgefertigte Designs vereinfachen die Arbeit am Programm. Um einen Bot für Telegram zu schreiben, müssen Sie diese E-Mail-Adresse verwenden: https://api.telegram.org/bot/METHODE_NAME

Für das korrekte Funktionieren des Bots wird außerdem ein Token benötigt – eine Zeichenkombination, die das Programm schützt und vertrauenswürdigen Entwicklern den Zugriff darauf öffnet. Jeder Token ist einzigartig. Die Zeichenfolge wird dem Bot bei der Erstellung zugewiesen. Methoden können unterschiedlich sein: getUpdates, getChat und andere. Die Wahl der Methode hängt davon ab, welchen Algorithmus die Entwickler vom Bot erwarten. Token-Beispiel:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Bots verwenden GET- und POST-Anforderungen. Methodenparameter müssen oft ergänzt werden – zum Beispiel, wenn die sendMessage-Methode die Chat-ID und etwas Text senden soll. Parameter für die Methodenverfeinerung können als URL-Abfragezeichenfolge mit application/x-www-form-urlencoded oder über application-json übergeben werden. Diese Methoden eignen sich nicht zum Herunterladen von Dateien. UTF-8-Codierung ist ebenfalls erforderlich. Indem Sie eine Anfrage an die API senden, können Sie das Ergebnis im JSON-Format erhalten. Sehen Sie sich die Antwort des Programms auf das Abrufen von Informationen über die getME-Methode an:

ERHALTEN Sie https://api.telegram.org/bot/getMe{ ok: true, result: { id: 231757398, first_name: "Exchange Rate Bot", username: "exchangetestbot" } }

Das Ergebnis wird erhalten, wenn ok ist gleich was immer dies auch sein sollte.. Andernfalls zeigt das System einen Fehler an.

Es gibt zwei Möglichkeiten, benutzerdefinierte Nachrichten in Bots zu erhalten. Beide Methoden sind effektiv, aber in verschiedenen Fällen geeignet. Um Nachrichten zu erhalten, können Sie manuell eine Anfrage mit der getUpdates-Methode schreiben – das Programm zeigt das Update-Daten-Array auf dem Bildschirm an. Anfragen müssen regelmäßig gesendet werden, nach Analyse jedes Arrays wird das Senden wiederholt. Offset ist ein Parameter, der die Anzahl der übersprungenen Datensätze bestimmt, bevor ein neues Ergebnis geladen wird, um das erneute Erscheinen von markierten Objekten zu vermeiden. Die Vorteile der getUpdates-Methode kommen zum Tragen, wenn:

• es gibt keine Möglichkeit, HTTPS zu konfigurieren;
• komplexe Skriptsprachen werden verwendet;
• der Bot-Server ändert sich von Zeit zu Zeit;
• Der Bot ist mit Benutzern geladen.

Die zweite Methode, die zum Empfangen von Benutzernachrichten geschrieben werden kann, ist setWebhook. Es wird einmal verwendet, es müssen nicht ständig neue Anfragen gesendet werden. Der Webhook sendet Datenaktualisierungen an die angegebene URL. Diese Methode erfordert ein SSL-Zertifikat. Webhook ist in diesen Fällen nützlich:

• Web-Programmiersprachen werden verwendet;
• der Bot ist nicht überlastet, es gibt nicht zu viele Benutzer;
• der Server ändert sich nicht, das Programm bleibt lange auf dem gleichen Server.

In weiteren Anweisungen verwenden wir getUpdates.

Der @BotFather Telegram-Dienst wurde entwickelt, um Chatbots zu erstellen. Über dieses System werden auch grundlegende Einstellungen vorgenommen – BotFather hilft Ihnen dabei, eine Beschreibung zu erstellen, ein Profilfoto hinzuzufügen und Support-Tools hinzuzufügen. Bibliotheken – Sätze von HTML-Anfragen für Telegram-Bots – sind im Internet verfügbar, es gibt ziemlich viele davon. Bei der Erstellung des Beispielprogramms wurde pyTelegramBotApi verwendet.

Schritt 1: Implementieren von Wechselkursanfragen

Zuerst müssen Sie den Code schreiben, der Abfragen durchführt. Wir werden beim Schreiben der PrivatBank-API verwenden, unten ist ein Link dazu: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Sie müssen diese Methoden in Ihrem Code verwenden:

• load_exchange – findet Wechselkurse und zeigt verschlüsselte Informationen an;
• get_exchange – zeigt Daten zu einer bestimmten Währung an;
• get_exchanges – zeigt die Auflistung der Währungen gemäß dem Muster.

Als Ergebnis sieht der Code in der Datei pb.py wie folgt aus:

import re import reviews import json URL = 'https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5' def load_exchange(): return json.loads(requests.get(URL).text) def get_exchange(ccy_key ): for exc in load_exchange(): if ccy_key == exc['ccy']: return exc return False def get_exchanges(ccy_pattern): result = [] ccy_pattern = re.escape(ccy_pattern) + '.*' for exc in load_exchange(): wenn re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) nicht None ist: result.append(exc) gibt Ergebnis zurück

Das Programm kann auf die angegebenen Anforderungen die folgende Antwort ausgeben:

[ { ccy:"USD", base_ccy:"UAH", buy:"25.90000", sale:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", buy:"29.10000", sale:"29.85000 " }, { ccy:"RUR", base_ccy:"UAH", Kauf:"0.37800", Verkauf:"0.41800" }, { ccy:"BTC", base_ccy:"USD", Kauf:"11220.0384", Verkauf: "12401.0950" } ]

Schritt 2: Erstellen Sie einen Telegramm-Bot mit @BotFather

Mit dem @BotFather-Dienst können Sie ein Programm erstellen, um Nachrichten zu empfangen und darauf zu antworten. Gehen Sie zu seiner Telegrammseite und geben Sie den Befehl /newbot ein. Im Chat erscheinen Anweisungen, nach denen Sie zuerst den Namen des Bots und dann seine Adresse aufschreiben müssen. Wenn das Bot-Konto erstellt wird, erscheint eine Willkommensnachricht mit einem Token auf dem Bildschirm. Verwenden Sie zur weiteren Konfiguration diese Befehle:

• /setdescription – Beschreibung;
• /setabouttext – Informationen über den neuen Bot;
• /setuserpic – Profilfoto;
• /setinline – Inline-Modus;
• /setcommands – Beschreibung der Befehle.

Im letzten Konfigurationsschritt beschreiben wir /help und /exchange. Wenn alle Schritte abgeschlossen sind, ist es an der Zeit, mit dem Codieren fortzufahren.

Schritt 3: Einrichten und Starten des Bots

Lassen Sie uns eine config.py-Datei erstellen. Darin müssen Sie den eindeutigen Bot-Code und die Zeitzone angeben, in der das Programm Informationen findet.

TOKEN = '' # durch das Token Ihres Bots ersetzenTIMEZONE = 'Europa/Kiew' TIMEZONE_COMMON_NAME = 'Kiew'

Als nächstes erstellen wir eine weitere Datei mit dem Import der zuvor geschriebenen pb.py, Bibliotheken und anderen notwendigen Komponenten. Die fehlenden Bibliotheken werden aus dem Paketverwaltungssystem (pip) installiert.

import telebotimport configimport pbimport datetimeimport pytzimport jsonimport traceback P_TIMEZONE = pytz.timezone(config.TIMEZONE) TIMEZONE_COMMON_NAME = config.TIMEZONE_COMMON_NAME

Lassen Sie uns den Inhalt von pyTelegramBotApi verwenden, um einen Bot zu erstellen. Wir senden den erhaltenen Token mit folgendem Code:

bot = telebot.TeleBot(config.TOKEN) bot.polling(none_stop=True)

Der Parameter none_stop stellt sicher, dass ständig Anfragen gesendet werden. Der Betrieb des Parameters wird durch Methodenfehler nicht beeinträchtigt.

Schritt 4: Schreiben Sie den /start Command Handler

Wenn alle vorherigen Schritte korrekt ausgeführt wurden, hat der Bot seine Arbeit aufgenommen. Das Programm generiert regelmäßig Anfragen, da es die Methode getUpdates verwendet. Vor der Zeile mit dem none_stop-Element benötigen wir ein Stück Code, das den /start-Befehl verarbeitet:

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Grüße! Ich kann Ihnen Wechselkurse anzeigen.n' + 'Um die Wechselkurse zu erhalten, drücken Sie / exchange.n' + 'Um Hilfe zu erhalten, drücken Sie /help.' )

RџSЂRЂ Befehle=['Start'] gleich True start_command wird aufgerufen. Der Inhalt der Nachricht wird dort abgelegt. Als nächstes müssen Sie die Sendefunktion implementieren_Botschaft in Bezug auf eine bestimmte Nachricht.

Schritt 5: Erstellen Sie einen /help-Befehlshandler

Der Befehl /help kann als Schaltfläche implementiert werden. Durch Anklicken gelangt der Nutzer zum Telegram-Konto des Entwicklers. Geben Sie der Schaltfläche einen Namen, z. B. „Fragen Sie den Entwickler“. Legen Sie für die Methode send_message den Parameter respond_markup fest, der den Benutzer auf einen Link umleitet. Lassen Sie uns den Parameter in den Code schreiben, der die Tastatur erstellt (InlineKeyboardMarkup). Sie benötigen nur eine Schaltfläche (InlineKeyboardButton).

Der endgültige Befehlshandlercode sieht folgendermaßen aus:

@bot.message_handler(commands=['help']) def help_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Ask the developer', url='ваша ссылка на профиль' ) ) bot.send_message( message.chat.id, '1) Um eine Liste der verfügbaren Währungen zu erhalten, drücken Sie /exchange.n' + '2) Klicken Sie auf die Währung, an der Sie interessiert sind.n' + '3) Sie erhält eine Nachricht mit Informationen zur Quell- und Zielwährung, ' + 'Ankaufskurse und Verkaufskurse.n' + '4) Klicken Sie auf „Aktualisieren“, um die aktuellen Informationen zur Anfrage zu erhalten. ' + 'Der Bot zeigt auch die Differenz zwischen dem vorherigen und dem aktuellen Wechselkurs an.' + '5) Der Bot unterstützt Inline. Typ @ in jedem Chat und die Anfangsbuchstaben einer Währung.', answer_markup=keyboard )

Code-Aktion im Telegramm-Chat:

Schritt 6: Hinzufügen des /exchange-Befehlshandlers

Dieser Schritt wird benötigt, um Schaltflächen mit Symbolen verfügbarer Währungen im Chat anzuzeigen. Eine Bildschirmtastatur mit Optionen hilft Ihnen, Fehler zu vermeiden. PrivatBank bietet Informationen zu Rubel, Dollar und Euro. Die Option InlineKeyboardButton funktioniert wie folgt:

1. Der Benutzer klickt auf die Schaltfläche mit der gewünschten Bezeichnung.
2. getUpdates empfängt einen Callback (CallbackQuery).
3. Es wird bekannt, wie mit dem Drücken der Tastatur umgegangen wird – Informationen über die gedrückte Taste werden übermittelt.

/Exchange-Handler-Code:

@bot.message_handler(commands=['exchange']) def exchange_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton('USD', callback_data='get-USD') ) keyboard.row( telebot.types.InlineKeyboardButton('EUR', callback_data='get-EUR'), telebot.types.InlineKeyboardButton('RUR', callback_data='get-RUR') ) bot.send_message( message.chat .id, 'Klicken Sie auf die Währung Ihrer Wahl:', answer_markup=keyboard )

Das Ergebnis des Codes in Telegram:

Schritt 7: Schreiben eines Handlers für die integrierten Tastaturtasten

Das pyTelegramBot-Api-Paket enthält die Decorator-Funktion @bot.callback_query_handler. Diese Komponente wurde entwickelt, um den Rückruf in eine Funktion zu übersetzen – die API entpackt den Aufruf und erstellt ihn neu. Es wird so geschrieben:

@bot.callback_query_handler(func=lambda call: True) def iq_callback(query): data = query.data if data.startswith('get-'): get_ex_callback(query)

Schreiben wir auch die Methode get_ex_callback:

def get_ex_callback(query): bot.answer_callback_query(query.id) send_exchange_result(query.message, query.data[4:])

Es gibt noch eine weitere nützliche Methode – answer_callback_query. Es hilft, die Last zwischen dem Drücken der Taste und der Anzeige des Ergebnisses auf dem Bildschirm zu entfernen. Sie können eine Nachricht an send_exchange_query senden, indem Sie einen Währungscode und eine Nachricht übergeben. Schreiben wir send_exchange_result:

def send_exchange_result(message, ex_code): bot.send_chat_action(message.chat.id, 'typing') ex = pb.get_exchange(ex_code) bot.send_message( message.chat.id, serialize_ex(ex), respond_markup=get_update_keyboard(ex ), parse_mode='HTML' )

Während der Chatbot das Ergebnis der Anfrage von der Bank erhält API, sieht der Besucher die Aufschrift „Eine Nachricht eingeben“. Es sieht so aus, als ob eine echte Person antwortet. Um einen solchen Indikator auf dem Bildschirm anzuzeigen, müssen Sie Eingabestatuszeilen hinzufügen. Als nächstes verwenden wir get_exchange – mit seiner Hilfe erhält das Programm die Währungsbezeichnung (Rubel, Euro oder Dollar). send_message verwendet zusätzliche Methoden: serialize_ex konvertiert die Währung in ein anderes Format und get_update_keyboard richtet Softkeys ein, die Informationen aktualisieren und Währungsmarktdaten an andere Chats senden.

Lassen Sie uns den Code für get_update_keyboard schreiben. Zwei Schaltflächen müssen erwähnt werden – t und e stehen für Typ und Austausch. Das switch_inline_query-Element für den Share-Button wird benötigt, damit der Benutzer aus mehreren Chats auswählen kann. Der Besucher kann wählen, an wen er den aktuellen Wechselkurs von Dollar, Rubel oder Euro senden möchte.

def get_update_keyboard(ex): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton( 'Update', callback_data=json.dumps({ 't': 'u', 'e': { ' b': ex['buy'], 's': ex['sale'], 'c': ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Share', switch_inline_query=ex['ccy']) ) Tastatur zurückgeben

Manchmal müssen Sie sehen, wie stark sich der Wechselkurs in kurzer Zeit geändert hat. Lassen Sie uns zwei Methoden für die Schaltfläche Aktualisieren schreiben, damit Benutzer Kurse im Vergleich sehen können.

Die Differenz zwischen den Wechselkursen wird über den diff-Parameter an den Serializer übergeben.

Die vorgeschriebenen Methoden funktionieren nur, nachdem die Daten aktualisiert wurden, sie haben keinen Einfluss auf die erste Anzeige des Kurses.

def serialize_ex(ex_json, diff=None): result = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Buy: ' + ex_json['buy'] if diff: result += ' ' + serialize_exchange_diff(diff['buy_diff']) + 'n' + 'Sell: ' + ex_json['sale'] + ' ' + serialize_exchange_diff(diff['sale_diff']) + 'n' else: result += 'nSell: ' + ex_json['sale'] + 'n' return result def serialize_exchange_diff(diff): result = '' if diff > 0: result = '(' + str(diff) + ' " src="https://sworg/images/core/emoji/2.3/svg/2197.svg">" src="https://sworg/images /core/emoji/72x72/2197.png">" src="https://sworg/images/core/emoji/72x72/2197.png">)' elif diff < 0: result = '(' + str( diff)[1:] + ' " src="https://sworg/images/core/emoji/2.3/svg/2198.svg">" src="https://sworg/images/core/emoji/72x72 /2198.png">" src="https://sworg/images/core/emoji/72x72/2198.png">)' Rückgabeergebnis

Stellen Sie sich vor, der Besucher wollte den Dollarkurs wissen. Folgendes passiert, wenn Sie in der Nachricht USD auswählen:

Schritt 8: Implementieren des Aktualisierungsschaltflächen-Handlers

Lassen Sie uns den Code für die Behandlung von Aktionen mit der Schaltfläche „Aktualisieren“ schreiben und den Teil „iq_callback_method“ hinzufügen. Wenn Programmpunkte mit dem get-Parameter beginnen, müssen Sie get_ex_callback schreiben. In anderen Situationen analysieren wir JSON und versuchen, den Schlüssel t zu erhalten.

@bot.callback_query_handler(func=lambda call: True) def iq_callback(query): data = query.data if data.startswith('get-'): get_ex_callback(query) else: try: if json.loads(data)[ 't'] == 'u': edit_message_callback(query) außer ValueError: pass

Wenn t gleich u ist, müssen Sie ein Programm für die Methode edit_message_callback schreiben. Lassen Sie uns diesen Prozess Schritt für Schritt aufschlüsseln:

1. Herunterladen aktueller Informationen über den Zustand des Devisenmarktes (exchange_now = pb.get_exchange(data['c']).

2. Schreiben einer neuen Nachricht über einen Serializer mit diff.
3. Signatur hinzufügen (get_edited_signature).

Wenn sich die ursprüngliche Nachricht nicht ändert, rufen Sie die Methode edit_message_text auf.

def edit_message_callback(query): data = json.loads(query.data)['e'] exchange_now = pb.get_exchange(data['c']) text = serialize_ex( exchange_now, get_exchange_diff( get_ex_from_iq_data(data), exchange_now ) ) + 'n' + get_edited_signature() if query.message: bot.edit_message_text( text, query.message.chat.id, query.message.message_id, respond_markup=get_update_keyboard(exchange_now), parse_mode='HTML' ) elif query.inline_message_id : bot.edit_message_text( text, inline_message_id=query.inline_message_id, respond_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Lassen Sie uns die Methode get_ex_from_iq_data schreiben, um JSON zu analysieren:

def get_ex_from_iq_data(exc_json): return { 'Kauf': exc_json['b'], 'sale': exc_json['s'] }

Sie benötigen noch einige Methoden: zum Beispiel get_exchange_diff, das die alten und neuen Informationen über die Kosten von Währungen liest und die Differenz anzeigt.

def get_exchange_diff(last, now): return { 'sale_diff': float("%.6f" % (float(now['sale']) - float(last['sale']))), 'buy_diff': float ("%.6f" % (float(now['buy']) - float(last['buy']))) }

Die letzte, get_edited_signature, zeigt die Zeit an, zu der der Kurs zuletzt aktualisiert wurde.

def get_edited_signature(): return 'Aktualisiert ' + str(datetime.datetime.now(P_TIMEZONE).strftime('%H:%M:%S')) + ' (' + TIMEZONE_COMMON_NAME + ')'

Als Ergebnis sieht die aktualisierte Nachricht des Bots mit einem stabilen Wechselkurs wie folgt aus:

Bei Kurswechsel werden die Unterschiede zwischen den Werten aufgrund der vorgegebenen Parameter in der Meldung angezeigt.

Schritt 9: Implementierung des eingebetteten Modus

Der integrierte Modus wird benötigt, um schnell Informationen aus dem Programm an einen beliebigen Chat zu senden – jetzt müssen Sie als Teilnehmer keinen Bot mehr zum Gespräch hinzufügen. Wenn ein Telegram-Benutzer einen Bot-Namen mit einem @-Zeichen davor eingibt, sollten Konvertierungsoptionen über der Eingabezeile erscheinen. Wenn Sie auf eines der Elemente klicken, sendet der Bot eine Nachricht an die Konversation mit den Ergebnissen und Schaltflächen zum Aktualisieren und Senden von Daten. Der Name des Absenders enthält die Überschrift „via ".

InlineQuery wird über die Bibliothek an query_text übergeben. Der Code verwendet die answer_line-Funktion, um die Suchergebnisse als Datenarray und das inline_query_id-Element abzurufen. Wir verwenden get_exchanges, damit der Bot auf Anfrage mehrere Währungen findet.

@bot.inline_handler(func=lambda query: True) def query_text(inline_query): bot.answer_inline_query( inline_query.id, get_iq_articles(pb.get_exchanges(inline_query.query)) )

Wir übergeben ein Array von Daten an get_iq_articles, um Objekte von InlineQueryResultArticle über diese Methode zurückzugeben.

def get_iq_articles(exchanges): result = [] for exc in exchanges: result.append( telebot.types.InlineQueryResultArticle( id=exc['ccy'], title=exc['ccy'], input_message_content=telebot.types.InputTextMessageContent ( serialize_ex(exc), parse_mode='HTML' ), answer_markup=get_update_keyboard(exc), description='Convert ' + exc['base_ccy'] + ' -> ' + exc['ccy'], thumb_height=1 ) ) Ergebnis zurückgeben

Wenn du jetzt @ schreibst und einem Leerzeichen in der Zeile erscheinen die Suchergebnisse auf dem Bildschirm – Optionen zur Umrechnung in drei verfügbare Währungen.

Benutzer können die Ergebnisse filtern, indem sie die gewünschte Währung eingeben.

Nach einem Klick auf die gewünschte Währung aus der Liste erhält der Chat die gleiche Nachricht, die Bot-Benutzer erhalten. Sie können auch die Schaltfläche Aktualisieren verwenden. Das folgende Bild zeigt die aktualisierte Nachricht, die über den Bot gesendet wurde:

Zusammenfassung

Jetzt wissen Sie, wie Sie einen Bot für Telegram erstellen. Sie können Ihrem Programm nützliche Tools hinzufügen: Schaltflächen zum Aktualisieren und Senden des Ergebnisses an andere Benutzer des Messengers und einen integrierten Modus, mit dem Sie die Funktionen des Bots außerhalb des Chats damit nutzen können. Basierend auf dieser Anleitung können Sie jeden einfachen Bot mit anderen Funktionen erstellen – nicht nur den, der Wechselkurse anzeigt. Scheuen Sie sich nicht, mit Bibliotheken, APIs und Code zu experimentieren, um einen automatisierten Assistenten zu erstellen, der mit Kunden auf Telegram chattet und die Verbindung interessierter Personen zum Unternehmen stärkt.