Telegram Bot am Python. E komplette Guide fir e Bot mat Austauschsätz vun Null ze schreiwen

Bots am Telegram si Programmer déi hëllefen de Kontakt mam Publikum z'etabléieren oder Handlungen ze vereinfachen déi virdru manuell gemaach goufen. Dës Programmer si speziell fir d'Messenger Plattform geschriwwen. Bots funktionnéieren op dës Manéier: de Benotzer schéckt e Kommando duerch d'Input Linn, an de System reagéiert mat engem Text oder interaktive Message. Heiansdo imitéiert de Programm souguer d'Aktiounen vun enger realer Persoun - sou e Bot inspiréiert méi Vertrauen tëscht de Clienten.

Et gi verschidden Zorte vu Systemer fir automatesch Hëllef fir Benotzer. E puer Bots kommunizéieren just mat Clienten, anerer liwweren regelméisseg Informatioun. Et ass onméiglech Programmer kloer an Typen opzedeelen - Entwéckler kombinéieren dacks verschidde Funktiounen an engem Bot.

Dir kënnt en einfachen Bot fir Telegram mat interaktiven Elementer a Form vun On-Screen Knäppchen an 9 Schrëtt schreiwen. Loosst eis all eenzel vun hinnen am Detail kucken an e puer Froen beäntweren:

• wéi engem Bot ufänken;
• wéi een eng agebaute Tastatur vun engem oder méi Knäpper registréiert;
• wéi d'Knäppercher fir déi gewënschte Funktiounen ze programméieren;
• wat ass den Inline Modus a wéi een et fir e bestehende Bot opstellt.

Schrëtt 0: Theoretesch Hannergrond iwwer d'Telegram Bots API

Den Haaptinstrument dat benotzt gëtt fir Telegram Bots ze kreéieren ass den HTML Application Programming Interface, oder HTML API. Dëst Element akzeptéiert Besucherfuerderunge a schéckt Äntwerten a Form vun Informatioun. Ready-made Designs vereinfachen d'Aarbecht um Programm. Fir e Bot fir Telegram ze schreiwen, musst Dir dës E-Mailadress benotzen: https://api.telegram.org/bot/METHOD_NAME

Fir de richtege Fonctionnement vum Bot ass och e Token gebraucht - eng Kombinatioun vu Charaktere déi de Programm schützt an den Zougang zu vertrauenswürdege Entwéckler opmaacht. All Token ass eenzegaarteg. De String gëtt dem Bot bei der Schafung zougewisen. Methode kënnen ënnerschiddlech sinn: getUpdates, getChat an anerer. D'Wiel vun der Method hänkt vu wéi engem Algorithmus d'Entwéckler vum Bot erwaarden. Token Beispill:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Bots benotzen GET a POST Ufroen. Method Parameteren mussen dacks ergänzt ginn - zum Beispill, wann d'SendMessage Method soll d'Chat ID an e puer Text schécken. Parameteren fir Methode Verfeinerung kënnen als URL Ufro String mat Applikatioun / x-www-form-urlencoded oder iwwer Application-json passéiert ginn. Dës Methoden sinn net gëeegent fir erofzelueden Fichieren. UTF-8 Kodéierung ass och erfuerderlech. Andeems Dir eng Ufro un d'API schéckt, kënnt Dir d'Resultat am JSON-Format kréien. Kuckt Iech d'Äntwert vum Programm op d'Erfaassung vun Informatioun iwwer d'getME Method:

GET https://api.telegram.org/bot/getMe{ ok: wouer, Resultat: {id: 231757398, first_name: "Austauschrate Bot", Benotzernumm: "exchangetestbot" } }

D'Resultat gëtt kritt wann ok gläicht richteg. Soss gëtt de System e Feeler uginn.

Et ginn zwou Weeër fir personaliséiert Messagen a Bots ze kréien. Béid Methode sinn effektiv, awer si passend a verschiddene Fäll. Fir Messagen ze kréien, kënnt Dir manuell eng Ufro mat der getUpdates Method schreiwen - de Programm weist d'Aktualiséierungsdatenarray um Bildschierm. Ufroe musse regelméisseg geschéckt ginn, no der Analyse vun all Array gëtt d'Sendung widderholl. Offset ass e Parameter deen d'Zuel vun de iwwerspréngte records bestëmmt ier en neit Resultat lued fir d'Erscheinung vu gepréiften Objeten ze vermeiden. D'Virdeeler vun der getUpdates Method kommen an d'Spill wann:

• et gëtt kee Wee fir HTTPS ze konfiguréieren;
• komplex Skriptsprooche gi benotzt;
• de Bot-Server ännert sech vun Zäit zu Zäit;
• de Bot ass mat Benotzer gelueden.

Déi zweet Method déi geschriwwe ka ginn fir Benotzer Messagen ze kréien ass setWebhook. Et gëtt eemol benotzt, net néideg permanent nei Ufroen ze schécken. De Webhook schéckt Datenupdates op déi spezifizéiert URL. Dës Method erfuerdert en SSL Zertifika. Webhook wäert an dëse Fäll nëtzlech sinn:

• Web Programméierungssprooche gi benotzt;
• de Bot ass net iwwerlaascht, et ginn net ze vill Benotzer;
• de Server ännert sech net, de Programm bleift laang um selwechte Server.

A weideren Instruktioune benotze mir getUpdates.

Den @BotFather Telegram Service ass entwéckelt fir Chat Bots ze kreéieren. Basis Astellunge ginn och duerch dëse System gesat - BotFather hëlleft Iech eng Beschreiwung ze maachen, eng Profilfoto ze setzen, Ënnerstëtzungsinstrumenter derbäi. Bibliothéiken - Sets vun HTML-Ufroe fir Telegram Bots - sinn um Internet verfügbar, et gi ganz vill vun hinnen. Wann Dir de Beispillprogramm erstellt, gouf pyTelegramBotApi benotzt.

Schrëtt 1: Ëmsetzung vun Austausch Taux Ufroen

Als éischt musst Dir de Code schreiwen deen Ufroen ausféiert. Mir benotze wann Dir d'PrivatBank API schreift, hei drënner ass e Link op et: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Dir musst dës Methoden an Ärem Code benotzen:

• load_exchange - fënnt Austauschraten a weist kodéiert Informatioun;
• get_exchange - weist Daten iwwer eng spezifesch Währung;
• get_exchanges - weist d'Lëscht vun de Währungen no der Probe.

Als Resultat gesäit de Code an der pb.py Datei esou aus:

import re import requests 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) ): fir exc am load_exchange(): wann ccy_key == exc['ccy']: zréck exc return False def get_exchanges(ccy_pattern): Resultat = [] ccy_pattern = re.escape(ccy_pattern) + '.*' fir exc in load_exchange (): wann re.match (ccy_pattern, exc ['ccy'], re.IGNORECASE) ass net Keen: result.append (exc) Retour Resultat

De Programm kann déi folgend Äntwert op déi spezifizéiert Ufroen ausginn:

[ { ccy:"USD", base_ccy:"UAH", kafen:"25.90000", Verkaf:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", kafen:"29.10000", Verkaf:"29.85000 " }, { ccy:"RUR", base_ccy:"UAH", kafen:"0.37800", Verkaf:"0.41800" }, {ccy:"BTC", base_ccy:"USD", kafen:"11220.0384", Verkaf: "12401.0950" ]

Schrëtt 2: Erstellt en Telegram Bot mat @BotFather

Dir kënnt e Programm erstellen fir Messagen ze kréien an op hinnen ze reagéieren mam @BotFather Service. Gitt op seng Telegram Säit a gitt de / newbot Kommando. Instruktiounen erschéngen am Chat, no deem Dir als éischt den Numm vum Bot opschreiwe musst, an dann seng Adress. Wann de Bot Kont erstallt gëtt, erschéngt e Begréissungsmessage mat engem Token um Bildschierm. Fir weider Konfiguratioun benotzt dës Kommandoen:

• /setdescription - Beschreiwung;
• /setabouttext - Informatioun iwwer den neie Bot;
• /setuserpic - Profilfoto;
• /setinline - Inline Modus;
• /setcommands - Beschreiwung vun de Kommandoen.

Am leschte Konfiguratiounsschrëtt beschreiwen mir /help an /exchange. Wann all d'Schrëtt ofgeschloss sinn, ass et Zäit fir op d'Kodéierung ze goen.

Schrëtt 3: De Bot opsetzen a starten

Loosst eis eng config.py Datei erstellen. An et musst Dir den eenzegaartege Botcode an d'Zäitzone spezifizéieren an där de Programm Informatioun fënnt.

TOKEN = '' # ersetzen mam Token vun Ärem BotTIMEZONE = 'Europa/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

Als nächst erstelle mir eng aner Datei mat dem Import vun der virdru geschriwwener pb.py, Bibliothéiken an aner noutwendeg Komponenten. Déi fehlend Bibliothéike ginn aus dem Package Management System (Pip) installéiert.

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

Loosst eis den Inhalt vu pyTelegramBotApi benotzen fir e Bot ze kreéieren. Mir schécken de kritt Token mam folgende Code:

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

Den none_stop-Parameter garantéiert datt d'Ufroe konstant geschéckt ginn. D'Operatioun vum Parameter gëtt net vu Methodfehler beaflosst.

Schrëtt 4: Schreift den /start Command Handler

Wann all déi vireg Schrëtt richteg gemaach ginn, huet de Bot ugefaang ze schaffen. De Programm generéiert regelméisseg Ufroe well et d'getUpdates Method benotzt. Virun der Linn mam none_stop Element brauche mir e Stéck Code deen den /start Kommando veraarbecht:

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Greetings! exchange.n' + 'Fir Hëllef ze kréien, dréckt op /help.')

RџSЂRё commands=['Start'] gläich wéi True start_command genannt gëtt. Den Inhalt vum Message geet dohinner. Als nächst musst Dir d'Sendfunktioun implementéieren_message a Relatioun zu engem bestëmmte Message.

Schrëtt 5: Erstellt e /help Command Handler

De Kommando /help kann als Knäppchen ëmgesat ginn. Andeems Dir op et klickt, gëtt de Benotzer op den Telegram Kont vum Entwéckler geholl. Gitt de Knäppchen en Numm, wéi "Fro den Entwéckler". Setzt den reply_markup-Parameter, deen de Benotzer op e Link ëmgeleet, fir d'Send_message-Methode. Loosst eis am Code de Parameter schreiwen deen d'Tastatur erstellt (InlineKeyboardMarkup). Dir braucht nëmmen ee Knäppchen (InlineKeyboardButton).

De leschte Kommando Handler Code gesäit esou 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) Fir eng Lëscht mat verfügbare Währungen ze kréien, dréckt op /exchange.n' + '2) Klickt op d'Währung an där Dir interesséiert sidd.n' + '3) Dir kritt e Message mat Informatioun iwwer d'Quell an d'Zilwährungen, ' + 'Kaafs- a Verkafsraten.n' + '4) Klickt op "Update" fir déi aktuell Informatioun iwwer d'Ufro ze kréien. ' + 'De Bot wäert och den Ënnerscheed tëscht dem viregten an aktuellen Wechselkurs weisen.n' + '5) De Bot ënnerstëtzt inline. Typ @ an all Chat an den éischte Buschtawen vun enger Währung.', reply_markup=Tastatur )

Code Aktioun am Telegram Chat:

Schrëtt 6: Füügt den /exchange Command Handler

Dëse Schrëtt ass néideg fir Knäppercher mat Symboler vu verfügbare Währungen am Chat ze weisen. Eng On-Screen Keyboard mat Optiounen hëlleft Iech Feeler ze vermeiden. PrivatBank gëtt Informatiounen iwwert de ruble, Dollar an Euro. D'InlineKeyboardButton Optioun funktionnéiert esou:

1. De Benotzer klickt op de Knäppchen mat der gewënschter Bezeechnung.
2. getUpdates kritt en Callback (CallbackQuery).
3. Et gëtt bekannt wéi d'Tastatur dréckt - Informatioun iwwer de gedréckte Knäppchen gëtt iwwerdroen.

/ 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, 'Klickt op d'Währung vun der Wiel:', reply_markup=Tastatur )

D'Resultat vum Code am Telegram:

Schrëtt 7: Schreiwen engem Handler fir déi gebaut-an Keyboard Knäppercher

De Paket pyTelegramBot Api enthält d'Dekoratorfunktioun @bot.callback_query_handler. Dëse Bestanddeel ass entwéckelt fir den Callback an eng Funktioun ze iwwersetzen - d'API wéckelt a kreéiert den Uruff nei. Et gëtt esou geschriwwe:

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

Loosst eis och d'get_ex_callback Method schreiwen:

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

Et gëtt eng aner nëtzlech Method - answer_callback_query. Et hëlleft d'Laascht ze läschen tëscht dem Knäppchen drécken an d'Resultat um Bildschierm ze weisen. Dir kënnt e Message un send_exchange_query schécken andeems Dir e puer Währungscode a Message passéiert. Loosst eis send_exchange_result schreiwen:

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), reply_markup=get_update_keyboard(ex_code) ), parse_mode='HTML')

Wärend de Chatbot d'Resultat vun der Ufro vun der Bank kritt API, de Visiteur gesäit d'Inscriptioun "e Message tippen". Et gesäit aus wéi wann eng richteg Persoun äntwert. Fir esou en Indikator um Bildschierm ze weisen, musst Dir Inputstatuslinnen derbäisetzen. Als nächst wäerte mir get_exchange benotzen - mat senger Hëllef kritt de Programm d'Währungsbezeechnung (Rubelen, Euro oder Dollar). send_message benotzt zousätzlech Methoden: serialize_ex konvertéiert d'Währung an en anert Format, an get_update_keyboard setzt Softkeys op déi Informatioun aktualiséieren an Währungsmarktdaten an aner Chats schécken.

Loosst eis de Code fir get_update_keyboard schreiwen. Zwee Knäppercher mussen ernimmt ginn - t an e Stand fir Typ an Austausch. D'Switch_inline_query Element fir den Share Knäppchen ass néideg fir datt de Benotzer aus verschiddene Chats ka wielen. De Visiteur wäert fäheg sinn ze wielen, wien den aktuellen Wechselkurs vum Dollar, Rubel oder Euro ze schécken.

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'])) zréck Tastatur

Heiansdo musst Dir kucken wéi vill den Wechselkurs an enger kuerzer Zäit geännert huet. Loosst eis zwou Methoden fir den Update Knäppchen schreiwen fir datt d'Benotzer Coursen am Verglach kënne gesinn.

Den Ënnerscheed tëscht den Austauschsätz gëtt un de Serializer iwwer den Diff-Parameter weidergeleet.

Déi verschriwwene Methoden funktionnéieren nëmmen nodeems d'Daten aktualiséiert ginn, si beaflossen net den éischte Display vum Cours.

def serialize_ex(ex_json, diff=Keng): result = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Buy: ' + ex_json['buy'] if diff: result += ' ' + serialize_exchange_diff(diff['buy_diff']) + 'n' + 'Verkafen: ' + 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">)' Retour Resultat

Stellt Iech vir datt de Besucher den Dollarkurs wësse wollt. Hei ass wat geschitt wann Dir USD an der Noriicht auswielt:

Schrëtt 8: Implementéiere vum Update Button Handler

Loosst eis de Code fir Handlungsaktiounen mam Update Knäppchen schreiwen an den iq_callback_method Deel derbäi addéieren. Wann Programmartikele mam Get Parameter ufänken, musst Dir get_ex_callback schreiwen. An anere Situatiounen parse mir JSON a probéieren de Schlëssel t ze kréien.

@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) ausser ValueError: pass

Wann t entsprécht u, musst Dir e Programm fir d'edit_message_callback Method schreiwen. Loosst eis dëse Prozess Schrëtt fir Schrëtt ofbriechen:

1. Eroflueden aktuell Informatiounen iwwert den Zoustand vun der Währung Maart (exchange_now = pb.get_exchange(Daten['c']).

2. Schreift en neie Message duerch e Serializer mat Diff.
3. Eng Ënnerschrëft derbäisetzen (get_edited_signature).

Wann den initialen Message net ännert, rufft d'Edit_message_text Method un.

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() wann query.message: bot.edit_message_text( text, query.message.chat.id, query.message.message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='line_HTML'query.inlifmessage ) ) : bot.edit_message_text( text, inline_message_id=query.inline_message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Loosst eis d'get_ex_from_iq_data Method schreiwen fir JSON ze analyséieren:

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

Dir braucht e puer méi Methoden: zum Beispill get_exchange_diff, déi al an nei Informatioun iwwer d'Käschte vun de Währungen liest an den Ënnerscheed weist.

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

Déi lescht, get_edited_signature, weist d'Zäit wou de Cours fir d'lescht aktualiséiert gouf.

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

Als Resultat gesäit d'aktualiséiert Noriicht vum Bot mat engem stabilen Wechselkurs esou aus:

Wann de Kurs ännert, ginn d'Ënnerscheeder tëscht de Wäerter an der Noriicht ugewisen wéinst de verschriwwene Parameteren.

Schrëtt 9: Embedded Modus Ëmsetzung

Den agebaute Modus ass néideg fir séier Informatioun vum Programm an all Chat ze schécken - elo musst Dir kee Bot an d'Gespréich als Participant addéieren. Wann en Telegram Benotzer e Bot-Numm mat engem @-Zeeche virun agitt, sollten d'Konversiounsoptiounen iwwer der Inputlinn erscheinen. Wann Dir op ee vun den Elementer klickt, schéckt de Bot e Message un d'Gespréich mat de Resultater a Knäppercher fir d'Aktualiséierung an d'Verschécken vun Daten. Den Numm vum Sender enthält den Iwwerschrëft "via ".

InlineQuery gëtt op query_text iwwer d'Bibliothéik weidergeleet. De Code benotzt d'answer_line Funktioun fir d'Sichresultater als eng Array vun Daten an den inline_query_id Element ze recuperéieren. Mir benotzen get_exchanges sou datt de Bot op Ufro verschidde Währungen fënnt.

@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)) )

Mir passéieren eng ganz Rëtsch vun Donnéeën un get_iq_articles fir Objekter vun InlineQueryResultArticle duerch dës Method zréckzekommen.

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'), reply_markup=get_update_keyboard(exc), description='Convert' + exc['base_ccy'] + ' -> ' + exc['ccy'], thumb_height=1)) Retour Resultat

Elo, wann Dir schreift @ an e Raum an der Linn, d'Sichresultater erschéngen um Bildschierm - Optiounen fir an dräi verfügbare Währungen ëmzewandelen.

D'Benotzer kënnen d'Resultater filteren andeems se déi gewënscht Währung aginn.

Nodeems Dir op déi gewënscht Währung aus der Lëscht klickt, kritt de Chat dee selwechte Message, dee Bot Benotzer kréien. Dir kënnt och den Update Knäppchen benotzen. D'Bild hei ënnen weist den aktualiséierten Message, deen iwwer de Bot geschéckt gëtt:

Konklusioun

Elo wësst Dir wéi Dir e Bot fir Telegram erstellt. Dir kënnt nëtzlech Tools fir Äre Programm addéieren: Knäppercher fir d'Aktualiséierung an d'Schécken vum Resultat un aner Benotzer vum Messenger an en agebaute Modus deen Iech erlaabt d'Funktioune vum Bot ausserhalb vum Chat mat him ze benotzen. Baséierend op dëser Instruktioun kënnt Dir all einfache Bot mat anere Funktiounen erstellen - net nëmmen deen, deen d'Tariffer weist. Gitt net Angscht ze experimentéieren mat Bibliothéiken, APIen a Code fir en automatiséierten Assistent ze kreéieren deen mat Clienten op Telegram chatt an d'Verbindung vun interesséierte Leit mat der Firma stäerkt.