Telegrami robot Pythonis. Täielik juhend roboti kirjutamiseks vahetuskurssidega nullist

Telegrami robotid on programmid, mis aitavad luua kontakti vaatajaskonnaga või lihtsustavad toiminguid, mida varem tuli teha käsitsi. Need programmid on kirjutatud spetsiaalselt Messengeri platvormi jaoks. Botid töötavad nii: kasutaja saadab sisestusrea kaudu käsu ja süsteem vastab teksti- või interaktiivse sõnumiga. Mõnikord imiteerib programm isegi reaalse inimese tegevust – selline bot äratab klientides suuremat usaldust.

Kasutajate automaatseks abistamiseks on mitut tüüpi süsteeme. Mõned robotid lihtsalt suhtlevad klientidega, teised annavad regulaarselt teavet. Programme on võimatu selgelt tüüpideks jagada – arendajad ühendavad sageli mitu funktsiooni ühes robotis.

Saate 9 sammuga kirjutada Telegrami jaoks lihtsa roboti, millel on interaktiivsed elemendid ekraaninuppude kujul. Vaatame neid kõiki üksikasjalikult ja vastame mõnele küsimusele:

• kuidas robotit käivitada;
• kuidas registreerida sisseehitatud klaviatuur ühest või mitmest nupust;
• kuidas programmeerida nuppe soovitud funktsioonide jaoks;
• mis on tekstisisene režiim ja kuidas seda olemasoleva roboti jaoks seadistada.

Samm 0: teoreetiline taust Telegrami robotite API kohta

Peamine tööriist Telegrami robotite loomiseks on HTML-i rakendusliides ehk HTML API. See element aktsepteerib külastajate päringuid ja saadab vastuseid teabe kujul. Valmis kujundused lihtsustavad programmiga töötamist. Telegrami jaoks roboti kirjutamiseks peate kasutama seda e-posti aadressi: https://api.telegram.org/bot/METHOD_NAME

Boti korrektseks toimimiseks on vaja ka tokenit – märkide kombinatsiooni, mis kaitseb programmi ja avab sellele ligipääsu usaldusväärsetele arendajatele. Iga märk on ainulaadne. String määratakse robotile loomisel. Meetodid võivad olla erinevad: getUpdates, getChat ja teised. Meetodi valik sõltub sellest, millist algoritmi arendajad robotilt ootavad. Märgi näide:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Botid kasutavad GET- ja POST-päringuid. Meetodi parameetreid tuleb sageli täiendada – näiteks siis, kui sendMessage meetod peaks saatma vestluse ID ja veidi teksti. Meetodi täpsustamise parameetreid saab edastada URL-i päringustringina, kasutades käsku application/x-www-form-urlencoded või rakenduse-json kaudu. Need meetodid ei sobi failide allalaadimiseks. Samuti on vaja UTF-8 kodeeringut. API-le päringu saates saate tulemuse JSON-vormingus. Vaadake programmi vastust teabe hankimisel getME meetodi abil:

HANKIGE https://api.telegram.org/bot/getMe{ ok: tõsi, tulemus: { id: 231757398, eesnimi: "Exchange Rate Bot", kasutajanimi: "exchangetestbot" } }

Tulemus saadakse, kui ok võrdub tõsi. Vastasel juhul annab süsteem veast märku.

Kohandatud sõnumite saamiseks robotites on kaks võimalust. Mõlemad meetodid on tõhusad, kuid sobivad erinevatel juhtudel. Sõnumite saamiseks saab käsitsi kirjutada päringu getUpdates meetodiga – programm kuvab ekraanile Update data massiivi. Päringuid tuleb saata regulaarselt, peale iga massiivi analüüsimist korratakse saatmist. Nihe on parameeter, mis määrab enne uue tulemuse laadimist vahele jäetud kirjete arvu, et vältida kontrollitud objektide uuesti ilmumist. GetUpdatesi meetodi eelised tulevad mängu, kui:

• HTTPS-i pole võimalik konfigureerida;
• kasutatakse keerulisi skriptikeeli;
• robotserver muutub aeg-ajalt;
• bot on kasutajaid täis.

Teine meetod, mille saab kasutajate sõnumite vastuvõtmiseks kirjutada, on setWebhook. Seda kasutatakse üks kord, pole vaja pidevalt uusi päringuid saata. Veebihaak saadab andmete värskendused määratud URL-ile. See meetod nõuab SSL-sertifikaati. Veebihaak on kasulik järgmistel juhtudel:

• kasutatakse veebiprogrammeerimiskeeli;
• bot ei ole üle koormatud, kasutajaid pole liiga palju;
• server ei muutu, programm jääb kauaks samasse serverisse.

Edasistes juhistes kasutame rakendust getUpdates.

Teenus @BotFather Telegram on loodud vestlusrobotite loomiseks. Selle süsteemi kaudu tehakse ka põhiseadeid – BotFather aitab teha kirjelduse, paneb profiilifoto, lisab tugitööriistu. Teegid – HTML-i päringute komplektid Telegrami robotitele – on Internetis saadaval, neid on päris palju. Näidisprogrammi loomisel kasutati pyTelegramBotApi.

1. samm: vahetuskursi taotluste rakendamine

Kõigepealt peate kirjutama päringuid sooritava koodi. Kasutame PrivatBanki API kirjutamisel, allpool on link sellele: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Peate oma koodis kasutama järgmisi meetodeid:

• load_exchange – otsib vahetuskursse ja kuvab kodeeritud infot;
• get_exchange – kuvab andmed konkreetse valuuta kohta;
• get_exchanges – näitab valuutade loetelu vastavalt näidisele.

Selle tulemusel näeb failis pb.py olev kood välja järgmine:

import uuesti importida taotlusi 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 Vale def get_exchanges(ccy_pattern): result = [] ccy_pattern = re.escape(ccy_pattern) + '.*' exc jaoks load_exchange(): kui re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) ei ole None: result.append(exc) tagastab tulemuse

Programm saab määratud päringutele anda järgmise vastuse:

[ { ccy:"USD", base_ccy:"UAH", ost:"25.90000", müük:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", ost:"29.10000", müük:"29.85000" " }, { ccy:"RUR", base_ccy:"UAH", osta:"0.37800", müük:"0.41800" }, { ccy:"BTC", base_ccy:"USD", osta:"11220.0384", müük: "12401.0950" } ]

2. samm: looge @BotFatheriga Telegrami robot

Saate luua programmi sõnumite vastuvõtmiseks ja neile vastamiseks, kasutades teenust @BotFather. Minge tema Telegrami lehele ja sisestage käsk /newbot. Vestlusse ilmuvad juhised, mille järgi tuleb kõigepealt kirja panna boti nimi ja seejärel aadress. Kui boti konto on loodud, ilmub ekraanile žetooniga tervitussõnum. Edasiseks konfigureerimiseks kasutage neid käske:

• /setdescription – kirjeldus;
• /setabouttext – teave uue roboti kohta;
• /setuserpic – profiilifoto;
• /setinline – tekstisisene režiim;
• /setcommands – käskude kirjeldus.

Viimases seadistamisetapis kirjeldame /help ja /exchange. Kui kõik sammud on tehtud, on aeg liikuda edasi kodeerimise juurde.

3. samm: Boti seadistamine ja käivitamine

Loome faili config.py. Selles peate määrama unikaalse boti koodi ja ajavööndi, millest programm teavet leiab.

TOKEN = '' # asenda oma roboti märgigaTIMEZONE = 'Euroopa/Kiiev' TIMEZONE_COMMON_NAME = 'Kiiev'

Järgmiseks loome teise faili, kus imporditakse eelnevalt kirjutatud pb.py, teegid ja muud vajalikud komponendid. Puuduvad teegid installitakse paketihaldussüsteemist (pip).

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

Kasutame roboti loomiseks pyTelegramBotApi sisu. Saadame saadud märgi kasutades järgmist koodi:

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

Parameeter none_stop tagab taotluste pideva saatmise. Meetodivead parameetri tööd ei mõjuta.

4. samm: kirjutage /start käsuhaldur

Kui kõik eelnevad toimingud on õigesti tehtud, on robot tööle hakanud. Programm genereerib päringuid regulaarselt, kuna kasutab meetodit getUpdates. Enne none_stop elemendiga rida vajame koodi, mis töötleb käsku /start:

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Tere! Võin teile näidata vahetuskursse.n' + 'Valuutakursside vaatamiseks vajutage / Exchange.n' + 'Abi saamiseks vajutage /help.' )

RџSЂRё commands=['start'] võrdne tõega kutsutakse start_command. Sõnumi sisu läheb sinna. Järgmisena peate rakendama saatmisfunktsiooni_sõnum seoses konkreetse sõnumiga.

5. samm: looge /help käsuhaldur

Käsku /help saab rakendada nupuna. Sellel klõpsates suunatakse kasutaja arendaja Telegrami kontole. Andke nupule nimi, näiteks "Küsi arendajalt". Määrake meetodi send_message jaoks parameeter reply_markup, mis suunab kasutaja lingile. Kirjutame koodi sisse parameetri, mis loob klaviatuuri (InlineKeyboardMarkup). Teil on vaja ainult ühte nuppu (InlineKeyboardButton).

Lõplik käsutöötleja kood näeb välja selline:

@bot.message_handler(commands=['help']) def help_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Küsi arendajalt', url='валкаа насы профиль' ) ) bot.send_message( message.chat.id, '1) Saadaolevate valuutade loendi saamiseks vajutage /exchange.n' + '2) Klõpsake valuutal, millest olete huvitatud.n' + '3) saab sõnumi, mis sisaldab teavet allika ja sihtvaluutade kohta, ' + 'ostu- ja müügikursid.n' + '4) Klõpsake "Uuenda", et saada päringu kohta käivat teavet. ' + 'Bot näitab ka erinevust eelmise ja praeguse vahetuskursi vahel.n' + '5) Bot toetab inline'i. Sisestage @ mis tahes vestluses ja valuuta algustähed.', reply_markup=klaviatuur )

Koodi toiming Telegrami vestluses:

6. samm: /exchange käsuhalduri lisamine

See samm on vajalik saadaolevate valuutade sümbolitega nuppude kuvamiseks vestluses. Valikutega ekraaniklaviatuur aitab teil vigu vältida. PrivatBank annab teavet rubla, dollari ja euro kohta. Valik InlineKeyboardButton töötab järgmiselt:

1. Kasutaja klõpsab soovitud tähistusega nuppu.
2. getUpdates saab tagasihelistamise (CallbackQuery).
3. Saab teada, kuidas klaviatuuri vajutamisega hakkama saada – edastatakse info vajutatud nupu kohta.

/vahetuskäitleja kood:

@bot.message_handler(commands=['vahetus']) def Exchange_command(message): klaviatuur = 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, 'Klõpsake valitud valuutal:', reply_markup=keyboard )

Koodi tulemus Telegramis:

7. samm: kirjutage sisseehitatud klaviatuuri nuppude jaoks käitleja

Pakett pyTelegramBot Api sisaldab dekoraatori funktsiooni @bot.callback_query_handler. See komponent on loodud tagasihelistamise funktsiooniks tõlkimiseks – API avab kõne lahti ja loob selle uuesti. See on kirjutatud nii:

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

Kirjutame ka meetodi get_ex_callback:

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

On veel üks kasulik meetod – answer_callback_query. See aitab eemaldada koormust nupu vajutamise ja tulemuse ekraanil kuvamise vahel. Saate saata sõnumi aadressile send_exchange_query, edastades valuutakoodi ja sõnumi. Kirjutame send_exchange_result:

def send_exchange_result(message, ex_code): bot.send_chat_action(message.chat.id, 'tipimine') ex = pb.get_exchange(ex_code) bot.send_message( message.chat.id, serialize_ex(ex), reply_markup=get_action(exdate_key) ), parse_mode='HTML' )

Samal ajal kui vestlusbot saab pangalt päringu tulemuse API, näeb külastaja kirja “Trükkides sõnumi”. Näib, et vastab päris inimene. Sellise indikaatori kuvamiseks ekraanil peate lisama sisendi olekuread. Järgmisena võtame kasutusele get_exchange – selle abiga saab programm valuuta tähise (rublad, eurod või dollarid). send_message kasutab täiendavaid meetodeid: serialize_ex teisendab valuuta teise vormingusse ja get_update_keyboard seadistab tarkvaraklahvid, mis värskendavad teavet ja saadavad valuutaturu andmeid teistele vestlustele.

Kirjutame koodi get_update_keyboard jaoks. Mainida tuleb kahte nuppu – t ja e tähistavad tüüpi ja vahetust. Jagamisnupu üksus switch_inline_query on vajalik selleks, et kasutaja saaks valida mitme vestluse vahel. Külastaja saab valida, kellele dollari, rubla või euro jooksev vahetuskurss saata.

def get_update_keyboard(ex): klaviatuur = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton('Update', callback_data=json.dumps({ 't': 'u', 'e': { ' b': ex['osta'], 's': ex['müük'], 'c': ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Jaga', switch_inline_query=ex['ccy']) ) tagasta klaviatuur

Mõnikord peate vaatama, kui palju on vahetuskurss lühikese aja jooksul muutunud. Kirjutame nupu Värskenda jaoks kaks meetodit, et kasutajad saaksid kursusi võrrelda.

Vahetuskursside erinevus edastatakse diff parameetri kaudu jadajadajasse.

Ettenähtud meetodid töötavad alles pärast andmete uuendamist, kursuse esmast kuvamist need ei mõjuta.

def serialize_ex(ex_json, diff=puudub): tulemus = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Osta: ' + ex_json['osta'] if diff: result += ' ' + serialize_exchange_diff(diff['buy_diff']) + 'n' + 'Müüa: ' + ex_json['müük'] + ' ' + serialize_exchange_diff(diff['sale_diff']) + 'n' else: result += 'nSell: ' + ex_json['müük'] + 'n' tagastab tulemuse def serialize_exchange_diff(diff): tulemus = '' kui diff > 0: tulemus = '(' + 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">)" tagastustulemus

Kujutage ette, et külastaja tahtis teada dollari vahetuskurssi. Kui valite sõnumis USD, juhtub järgmine.

8. samm: värskendamisnupu töötleja juurutamine

Kirjutame nupuga Update nupuga toimingute käsitlemise koodi ja lisame sellele osa iq_callback_method. Kui programmielemendid algavad parameetriga get, peate kirjutama get_ex_callback. Muudel juhtudel sõelume JSON-i ja proovime hankida võtme t.

@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) v.a ValueError: pass

Kui t on u, peate kirjutama programmi edit_message_callback meetodi jaoks. Jagame selle protsessi samm-sammult lahti:

1. Ajakohase teabe allalaadimine valuutaturu seisu kohta (exchange_now = pb.get_exchange(data['c']).

2. Uue sõnumi kirjutamine serialisaatori kaudu diff-iga.
3. Allkirja lisamine (get_edited_signature).

Kui esialgne teade ei muutu, kutsuge välja meetod edit_message_text.

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)), vahetus + 'n' + get_edited_signature(), kui query.message: bot.edit_message_text( text, query.message.chat.id, query.message.message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML'ssage. : bot.edit_message_text( text, inline_message_id=query.inline_message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Kirjutame JSON-i sõelumiseks meetodi get_ex_from_iq_data:

def get_ex_from_iq_data(exc_json): return { 'osta': exc_json['b'], 'müük': exc_json['s'] }

Teil on vaja veel mõnda meetodit: näiteks get_exchange_diff, mis loeb vana ja uue teabe valuutade maksumuse kohta ning kuvab erinevuse.

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

Viimane, get_edited_signature, näitab kursuse viimase uuendamise aega.

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

Selle tulemusel näeb stabiilse vahetuskursiga roboti värskendatud sõnum välja järgmine:

Kursuse muutumisel kuvatakse teates väärtuste erinevused ettenähtud parameetrite tõttu.

9. samm: sisseehitatud režiimi rakendamine

Sisseehitatud režiimi on vaja programmist teabe kiireks saatmiseks mis tahes vestlusesse – nüüd ei pea te osalejana vestlusesse robotit lisama. Kui Telegrami kasutaja sisestab roboti nime, mille ees on @-märk, peaksid teisendusvalikud ilmuma sisestusrea kohale. Kui klõpsate ühel üksusel, saadab bot vestlusele sõnumi koos tulemuste ja nuppudega andmete värskendamiseks ja saatmiseks. Saatja nimi sisaldab pealdist „via ".

InlineQuery edastatakse teegi kaudu päringule query_text. Kood kasutab funktsiooni answer_line, et tuua otsingutulemused andmemassiivina ja elemendisisene_query_id. Kasutame get_exchanges, et bot leiaks soovi korral mitu valuutat.

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

Edastame massiivi andmeid jaotisesse get_iq_articles, et selle meetodi kaudu InlineQueryResultArtiklist objekte tagastada.

def get_iq_articles(exchanges): result = [] exc jaoks vahetustes: 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 ) ) tagastada tulemus

Kui nüüd kirjutada @ ja tühik real, ilmuvad ekraanile otsingutulemused – valikud konverteerimiseks kolmeks saadaolevaks valuutaks.

Kasutajad saavad tulemusi filtreerida, sisestades soovitud valuuta.

Pärast loendis soovitud valuuta klõpsamist saab vestlus sama sõnumi, mille saavad roboti kasutajad. Võite kasutada ka nuppu Värskenda. Alloleval pildil on roboti kaudu saadetud uuendatud sõnum:

Järeldus

Nüüd teate, kuidas luua Telegrami jaoks robotit. Saate oma programmi lisada kasulikke tööriistu: nupud tulemuse värskendamiseks ja teistele Messengeri kasutajatele saatmiseks ning sisseehitatud režiim, mis võimaldab kasutada roboti funktsioone väljaspool sellega vestlust. Selle juhise põhjal saate luua mis tahes lihtsa roboti, millel on muud funktsioonid – mitte ainult see, mis näitab vahetuskursse. Ärge kartke katsetada raamatukogude, API-de ja koodidega, et luua automaatne assistent, mis vestleb klientidega Telegramis ja tugevdab huvitatud inimeste sidet ettevõttega.