Telegram bot Pythonban. Teljes útmutató egy bot írásához az árfolyamokkal a semmiből

A táviratban található botok olyan programok, amelyek segítik a közönséggel való kapcsolatteremtést vagy leegyszerűsítik azokat a műveleteket, amelyeket korábban kézzel kellett végrehajtani. Ezek a programok kifejezetten a messenger platformhoz készültek. A botok így működnek: a felhasználó a beviteli soron keresztül parancsot küld, a rendszer pedig szöveges vagy interaktív üzenettel válaszol. Néha a program egy valós személy cselekedeteit is utánozza – egy ilyen bot nagyobb bizalmat kelt az ügyfelek körében.

A felhasználók automatikus segítségére többféle rendszer létezik. Egyes robotok csak kommunikálnak az ügyfelekkel, mások rendszeresen adnak információkat. A programokat nem lehet egyértelműen típusokra osztani – a fejlesztők gyakran több funkciót kombinálnak egy botban.

Egy egyszerű botot írhat a Telegramhoz interaktív elemekkel, képernyőn megjelenő gombok formájában, 9 lépésben. Nézzük meg mindegyiket részletesen, és válaszoljunk néhány kérdésre:

• hogyan indítsunk el egy botot;
• hogyan regisztrálhat beépített billentyűzetet egy vagy több gombbal;
• hogyan kell programozni a gombokat a kívánt funkciókhoz;
• mi az az inline mód, és hogyan kell beállítani egy meglévő bothoz.

0. lépés: elméleti háttér a Telegram bots API-ról

A Telegram-botok létrehozásának fő eszköze a HTML Application Programming Interface vagy HTML API. Ez az elem fogadja a látogatói kéréseket, és válaszokat küld információ formájában. A kész tervek leegyszerűsítik a programon végzett munkát. Ha robotot szeretne írni a Telegram számára, ezt az e-mail címet kell használnia: https://api.telegram.org/bot/METHOD_NAME

A bot megfelelő működéséhez szükség van egy tokenre is – egy olyan karakterkombinációra, amely védi a programot, és hozzáférést biztosít a megbízható fejlesztők számára. Minden token egyedi. A karakterlánc hozzá van rendelve a bothoz a létrehozáskor. A módszerek eltérőek lehetnek: getUpdates, getChat és mások. A módszer megválasztása attól függ, hogy a fejlesztők milyen algoritmust várnak el a bottól. Token példa:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

A robotok GET és POST kéréseket használnak. A metódus paramétereit gyakran ki kell egészíteni – például amikor a sendMessage metódusnak el kell küldenie a chat-azonosítót és némi szöveget. A metódusfinomítás paraméterei URL-lekérdezési karakterláncként adhatók át az application/x-www-form-urlencoded vagy az application-json használatával. Ezek a módszerek nem alkalmasak fájlok letöltésére. UTF-8 kódolás is szükséges. Ha kérelmet küld az API-nak, az eredményt JSON formátumban kaphatja meg. Vessen egy pillantást a program válaszára az információk getME metódussal történő lekérésére:

Töltsd le https://api.telegram.org/bot/getMe{ ok: igaz, eredmény: { azonosító: 231757398, keresztnév: "Exchange Rate Bot", felhasználónév: "exchangetestbot" } }

Az eredmény akkor lesz meg, ha ok egyenlő igaz. Ellenkező esetben a rendszer hibát jelez.

Kétféleképpen kaphat egyéni üzeneteket a robotokban. Mindkét módszer hatékony, de különböző esetekben megfelelő. Üzenetek fogadásához manuálisan írhat kérést a getUpdates metódussal – a program megjeleníti a képernyőn az Update data tömböt. A kéréseket rendszeresen el kell küldeni, az egyes tömbök elemzése után a küldés megismétlődik. Az eltolás egy olyan paraméter, amely meghatározza az átugrott rekordok számát az új eredmény betöltése előtt, hogy elkerülje az ellenőrzött objektumok újbóli megjelenését. A getUpdates módszer előnyei akkor lesznek érvényesek, ha:

• nincs mód a HTTPS konfigurálására;
• összetett szkriptnyelveket használnak;
• a botszerver időről időre változik;
• a bot meg van töltve felhasználókkal.

A második módszer, amely felhasználói üzenetek fogadására írható, a setWebhook. Egyszer használatos, nem kell folyamatosan új kéréseket küldeni. A webhook adatfrissítéseket küld a megadott URL-re. Ehhez a módszerhez SSL-tanúsítvány szükséges. A Webhook a következő esetekben lesz hasznos:

• webes programozási nyelveket használnak;
• a bot nincs túlterhelve, nincs túl sok felhasználó;
• a szerver nem változik, a program sokáig ugyanazon a szerveren marad.

A további utasításokban a getUpdates alkalmazást fogjuk használni.

A @BotFather Telegram szolgáltatást csevegőbotok létrehozására tervezték. Az alapbeállítások is ezen a rendszeren keresztül állíthatók be – a BotFather segít leírást készíteni, profilfotót elhelyezni, támogatási eszközöket ad hozzá. A könyvtárak – a Telegram robotok HTML-kéréseinek készletei – elérhetők az interneten, elég sok van belőlük. A példaprogram létrehozásakor a pyTelegramBotApi-t használtuk.

1. lépés: Árfolyamkérések végrehajtása

Először meg kell írnia a lekérdezéseket végrehajtó kódot. A PrivatBank API írásakor használjuk, az alábbiakban egy link található: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. A következő módszereket kell használnia a kódban:

• load_exchange – megkeresi az árfolyamokat és megjeleníti a kódolt információkat;
• get_exchange – egy adott pénznemre vonatkozó adatokat jelenít meg;
• get_exchanges – a pénznemek listázását mutatja a minta szerint.

Ennek eredményeként a pb.py fájl kódja így néz ki:

import re import kérések 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(): ha a re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) nem Nincs: result.append(exc) eredményt ad vissza

A program a következő válaszokat tudja kiadni a megadott kérésekre:

[ { ccy:"USD", base_ccy:"UAH", vétel:"25.90000", akció:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", vétel:"29.10000", akció:"29.85000" " }, { ccy:"RUR", base_ccy:"UAH", vásárlás:"0.37800", akció:"0.41800" }, { ccy:"BTC", base_ccy:"USD", vétel:"11220.0384", akció: "12401.0950" } ]

2. lépés: Hozzon létre egy Telegram Botot a @BotFather segítségével

A @BotFather szolgáltatás segítségével létrehozhat egy programot üzenetek fogadására és megválaszolására. Menjen a Telegram oldalára, és írja be a /newbot parancsot. A chaten megjelennek az utasítások, amelyek szerint először a bot nevét, majd a címét kell felírni. A botfiók létrehozásakor egy tokent tartalmazó üdvözlő üzenet jelenik meg a képernyőn. További konfigurációhoz használja az alábbi parancsokat:

• /setdescription – leírás;
• /setabouttext – információ az új botról;
• /setuserpic – profilfotó;
• /setinline – soros mód;
• /setcommands – a parancsok leírása.

Az utolsó konfigurációs lépésben a /help és /exchange leírását írjuk le. Ha az összes lépést elvégezte, ideje továbblépni a kódolásra.

3. lépés: A Bot beállítása és indítása

Hozzon létre egy config.py fájlt. Ebben meg kell adni az egyedi bot kódot és azt az időzónát, amelyben a program információt talál.

TOKEN = '' # csere a robotod tokenjéreTIMEZONE = 'Európa/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

Ezután létrehozunk egy másik fájlt a korábban megírt pb.py, könyvtárak és egyéb szükséges összetevők importálásával. A hiányzó könyvtárakat a csomagkezelő rendszerből (pip) telepíti.

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

Használjuk a pyTelegramBotApi tartalmát egy bot létrehozásához. A kapott tokent a következő kóddal küldjük el:

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

A none_stop paraméter biztosítja a kérések folyamatos küldését. A paraméter működését nem befolyásolják a metódushibák.

4. lépés: Írja meg a /start parancskezelőt

Ha az összes előző lépést helyesen hajtja végre, a bot elkezdett dolgozni. A program rendszeresen generál kéréseket, mert a getUpdates metódust használja. A none_stop elemet tartalmazó sor előtt szükségünk van egy kódrészletre, amely feldolgozza a /start parancsot:

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Üdvözlöm! Megmutatom az árfolyamok.n' + 'Az árfolyamok megtekintéséhez nyomja meg a / gombot exchange.n' + 'Segítség kéréséhez nyomja meg a /help gombot.' )

RџSЂRo commands=['start'] egyenlő a True-val start_command meghívásra kerül. Az üzenet tartalma oda kerül. Ezután végre kell hajtania a küldés funkciót_üzenet egy adott üzenettel kapcsolatban.

5. lépés: Hozzon létre egy /help parancskezelőt

A /help parancs gombként is megvalósítható. Ha rákattint, a felhasználó a fejlesztő Telegram fiókjába kerül. Adjon nevet a gombnak, például „Kérdezze meg a fejlesztőt”. Állítsa be a reply_markup paramétert, amely a felhasználót egy hivatkozásra irányítja át a send_message metódushoz. Írjuk be a kódba a billentyűzetet létrehozó paramétert (InlineKeyboardMarkup). Csak egy gombra van szüksége (InlineKeyboardButton).

A végső parancskezelő kód így néz ki:

@bot.message_handler(commands=['help']) def help_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Kérdezze meg a fejlesztőt', url='валкаа насы профиль' ) ) bot.send_message( message.chat.id, '1) Az elérhető pénznemek listájának megtekintéséhez nyomja meg a /exchange.n' + '2) Kattintson az Önt érdeklő pénznemre.n' + '3) Ön üzenetet fog kapni, amely információkat tartalmaz a forrásról és a célvalutákról, ' + 'vételi és eladási árfolyamokról.n' + '4) Kattintson a „Frissítés” gombra, hogy megkapja a kéréssel kapcsolatos aktuális információkat. ' + 'A bot az előző és a jelenlegi árfolyam közötti különbséget is mutatja.n' + '5) A bot támogatja az inline-t. Típus @ bármely csevegésben és a pénznem első betűiben.', reply_markup=keyboard )

Kódművelet a Telegram chatben:

6. lépés: Az /exchange parancskezelő hozzáadása

Ez a lépés a rendelkezésre álló pénznemek szimbólumait tartalmazó gombok megjelenítéséhez szükséges a chatben. A képernyő-billentyűzet opciókkal segít elkerülni a hibákat. A PrivatBank információkat nyújt a rubelről, a dollárról és az euróról. Az InlineKeyboardButton opció a következőképpen működik:

1. A felhasználó rákattint a kívánt megjelölésű gombra.
2. A getUpdates visszahívást kap (CallbackQuery).
3. Ismertté válik a billentyűzet lenyomásának kezelése – a megnyomott gombról információ továbbításra kerül.

/cserekezelő kódja:

@bot.message_handler(commands=['csere']) 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, 'Kattintson a választott pénznemre:', reply_markup=keyboard )

A kód eredménye a Telegramban:

7. lépés: Kezelő írása a beépített billentyűzet gombjaihoz

A pyTelegramBot Api csomag tartalmazza a @bot.callback_query_handler dekorátor funkciót. Ezt az összetevőt úgy tervezték, hogy a visszahívást függvényvé alakítsa – az API kibontja és újra létrehozza a hívást. Ezt így írják:

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

Írjuk be a get_ex_callback metódust is:

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

Van egy másik hasznos módszer – a answer_callback_query. Segít eltávolítani a terhelést a gomb megnyomása és az eredmény képernyőn való megjelenítése között. Üzenetet küldhet a send_exchange_query címre néhány pénznemkód és az Üzenet átadásával. Írjuk a send_exchange_result parancsot:

def send_exchange_result(message, ex_code): bot.send_chat_action(message.chat.id, 'beírás') ex = pb.get_exchange(ex_code) bot.send_message( message.chat.id, serialize_ex(ex), reply_markup=get_up ), parse_mode='HTML' )

Míg a chatbot megkapja a banktól a kérés eredményét API, a látogató az „üzenet beírása” feliratot látja. Úgy tűnik, egy valós személy válaszol. Egy ilyen jelző megjelenítéséhez a képernyőn beviteli állapotsorokat kell hozzáadnia. Ezután a get_exchange-t használjuk – segítségével a program megkapja a valutamegjelölést (rubel, euró vagy dollár). A send_message további módszereket használ: a serialize_ex a pénznemet egy másik formátumba konvertálja, a get_update_keyboard pedig programbillentyűket állít be, amelyek frissítik az információkat, és valutapiaci adatokat küldenek más csevegéseknek.

Írjuk be a get_update_keyboard kódját. Két gombot kell megemlíteni – a t és az e a típust és a cserét jelenti. A Megosztás gomb switch_inline_query elemére azért van szükség, hogy a felhasználó több csevegés közül tudjon választani. A látogató választhat, hogy kinek küldje el a dollár, rubel vagy euró aktuális árfolyamát.

def get_update_keyboard(ex): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton( 'Frissítés', callback_data=json.dumps({ 't': 'u', 'e': { ' b': ex['vásárlás'], 's': ex['kiárusítás'], 'c': ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Share', switch_inline_query=ex['ccy']) ) return billentyűzet

Néha látni kell, mennyit változott az árfolyam rövid idő alatt. Írjunk két módszert a Frissítés gombra, hogy a felhasználók összehasonlíthassák a kurzusokat.

Az árfolyamok közötti különbséget a diff paraméteren keresztül továbbítják a sorosítóhoz.

Az előírt módszerek csak az adatok frissítése után működnek, a pálya első megjelenítését nem befolyásolják.

def serialize_ex(ex_json, diff=Nincs): result = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Vásárlás: ' + ex_json['vásárlás'] if diff: result += ' ' + serialize_exchange_diff(diff['buy_diff']) + 'n' + 'Eladás: ' + ex_json['kiárusítás'] + ' ' + serialize_exchange_diff(diff['sale_diff']) + 'n' else: result += 'nSell: ' + ex_json['eladás'] + 'n' return result def serialize_exchange_diff(diff): eredmény = '' 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">)" visszatérési eredménye

Képzelje el, hogy a látogató tudni akarja a dollár árfolyamát. A következőképpen történik, ha az üzenetben az USD értéket választja:

8. lépés: A Frissítés gombkezelő megvalósítása

Írjuk meg a műveletek kezelésének kódját a Frissítés gombbal, és adjuk hozzá az iq_callback_method részt. Amikor a programelemek a get paraméterrel kezdődnek, meg kell írni a get_ex_callback parancsot. Más esetekben elemezzük a JSON-t, és megpróbáljuk megszerezni a t kulcsot.

@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) kivéve ValueError: pass

Ha t egyenlő u-val, akkor programot kell írnia az edit_message_callback metódushoz. Bontsuk le ezt a folyamatot lépésről lépésre:

1. Naprakész információk letöltése a devizapiac helyzetéről (exchange_now = pb.get_exchange(data['c']).

2. Új üzenet írása sorosítón keresztül diff-el.
3. Aláírás hozzáadása (get_edited_signature).

Ha a kezdeti üzenet nem változik, hívja meg az edit_message_text metódust.

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

Írjuk fel a get_ex_from_iq_data metódust a JSON elemzéséhez:

def get_ex_from_iq_data(exc_json): return { 'vásárlás': exc_json['b'], 'eladás': exc_json['s'] }

Szüksége lesz még néhány módszerre: például a get_exchange_diff, amely beolvassa a régi és új információkat a valuták költségeiről, és megjeleníti a különbséget.

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']))) }

Az utolsó, a get_edited_signature, a kurzus utolsó frissítésének időpontját mutatja.

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

Ennek eredményeként a bot frissített üzenete stabil árfolyammal így néz ki:

Ha a pálya módosul, az értékek közötti eltérések megjelennek az üzenetben az előírt paraméterek miatt.

9. lépés: Beágyazott mód megvalósítása

A beépített módra azért van szükség, hogy gyorsan elküldhessük az információkat a programból bármely csevegésbe – most már nem kell botot hozzáadnia a beszélgetéshez résztvevőként. Amikor a Telegram-felhasználó beír egy botnevet, előtte @ jellel, a konverziós lehetőségeknek a beviteli sor felett kell megjelenniük. Ha rákattint valamelyik elemre, a bot üzenetet küld a beszélgetésnek, amely tartalmazza az eredményeket és a frissítési és adatküldési gombokat. A feladó neve tartalmazza a „via ".

Az InlineQuery átadásra kerül a query_textnek a könyvtáron keresztül. A kód a answer_line függvényt használja a keresési eredmények adattömbként és az inline_query_id elemként történő lekéréséhez. A get_exchanges-t használjuk, hogy a bot kérésre több valutát is találjon.

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

Adattömböt adunk át a get_iq_articles-nek, hogy ezen a metóduson keresztül az InlineQueryResultArticle objektumokat adjuk vissza.

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 ) ) vissza az eredményt

Ha most írsz @ és egy szóközt a sorban, a keresési eredmények megjelennek a képernyőn – három elérhető pénznemre való átváltási lehetőségek.

A felhasználók a kívánt pénznem megadásával szűrhetik az eredményeket.

Miután a listában a kívánt pénznemre kattintott, a chat ugyanazt az üzenetet kapja, mint a bot felhasználók. Használhatja a Frissítés gombot is. Az alábbi képen a bot által küldött frissített üzenet látható:

Következtetés

Most már tudja, hogyan hozhat létre botot a Telegram számára. Hasznos eszközöket adhat a programjához: gombok a frissítéshez és az eredmény elküldéséhez a messenger többi felhasználójának, valamint egy beépített mód, amely lehetővé teszi a bot funkcióinak használatát a chaten kívül. Ezen utasítás alapján bármilyen egyszerű botot létrehozhat más funkciókkal – nem csak azzal, amelyik az árfolyamokat mutatja. Ne féljen kísérletezni a könyvtárakkal, API-kkal és kódokkal, hogy olyan automatizált asszisztenst hozzon létre, amely csevegni fog az ügyfelekkel a Telegramon, és megerősíti az érdeklődők kapcsolatát a vállalattal.