Telegram bot i Python. En komplett guide till att skriva en bot med växelkurser från grunden

Botar i Telegram är program som hjälper till att skapa kontakt med publiken eller förenkla åtgärder som tidigare behövt utföras manuellt. Dessa program är skrivna specifikt för messenger-plattformen. Bots fungerar på detta sätt: användaren skickar ett kommando genom inmatningsraden och systemet svarar med ett textmeddelande eller ett interaktivt meddelande. Ibland imiterar programmet till och med en verklig persons handlingar – en sådan bot inger mer förtroende bland kunderna.

Det finns flera typer av system för automatisk assistans till användare. Vissa bots kommunicerar bara med kunder, andra ger regelbundet information. Det är omöjligt att tydligt dela in program i typer – utvecklare kombinerar ofta flera funktioner i en bot.

Du kan skriva en enkel bot för Telegram med interaktiva element i form av knappar på skärmen i 9 steg. Låt oss titta på var och en av dem i detalj och svara på några frågor:

• hur man startar en bot;
• hur man registrerar ett inbyggt tangentbord från en eller flera knappar;
• hur man programmerar knapparna för önskade funktioner;
• vad är inline-läge och hur man ställer in det för en befintlig bot.

Steg 0: teoretisk bakgrund om Telegram bots API

Det huvudsakliga verktyget som används för att skapa Telegram-bots är HTML Application Programming Interface, eller HTML API. Detta element accepterar besöksförfrågningar och skickar svar i form av information. Färdiga mönster förenklar arbetet med programmet. För att skriva en bot för Telegram måste du använda denna e-postadress: https://api.telegram.org/bot/METHOD_NAME

För att boten ska fungera korrekt behövs också en token – en kombination av tecken som skyddar programmet och öppnar åtkomst till det för betrodda utvecklare. Varje token är unik. Strängen tilldelas boten när den skapas. Metoderna kan vara olika: getUpdates, getChat och andra. Valet av metod beror på vilken algoritm utvecklarna förväntar sig av boten. Token exempel:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Bots använder GET- och POST-förfrågningar. Metodparametrar måste ofta kompletteras – till exempel när sendMessage-metoden är tänkt att skicka chatt-id och lite text. Parametrar för metodförfining kan skickas som en URL-frågesträng med application/x-www-form-urlencoded eller via application-json. Dessa metoder är inte lämpliga för nedladdning av filer. UTF-8-kodning krävs också. Genom att skicka en begäran till API:t kan du få resultatet i JSON-format. Ta en titt på programmets svar på att hämta information via getME-metoden:

Hämta https://api.telegram.org/bot/getMe{ ok: true, result: { id: 231757398, first_name: "Exchange Rate Bot", användarnamn: "exchangetestbot" } }

Resultatet kommer att erhållas om ok är lika med sann. Annars kommer systemet att indikera ett fel.

Det finns två sätt att få anpassade meddelanden i bots. Båda metoderna är effektiva, men lämpar sig i olika fall. För att få meddelanden kan du manuellt skriva en förfrågan med metoden getUpdates – programmet kommer att visa Uppdatera datamatrisen på skärmen. Förfrågningar måste skickas regelbundet, efter analys av varje array upprepas sändningen. Offset är en parameter som bestämmer antalet överhoppade poster innan ett nytt resultat laddas för att undvika att kontrollerade objekt dyker upp igen. Fördelarna med getUpdates-metoden kommer in i bilden om:

• det finns inget sätt att konfigurera HTTPS;
• komplexa skriptspråk används;
• botservern ändras från tid till annan;
• boten är laddad med användare.

Den andra metoden som kan skrivas för att ta emot användarmeddelanden är setWebhook. Den används en gång, du behöver inte ständigt skicka nya förfrågningar. Webhook skickar datauppdateringar till den angivna URL:en. Denna metod kräver ett SSL-certifikat. Webhook kommer att vara användbar i dessa fall:

• webbprogrammeringsspråk används;
• boten är inte överbelastad, det finns inte för många användare;
• servern ändras inte, programmet ligger kvar på samma server under lång tid.

I ytterligare instruktioner kommer vi att använda getUpdates.

Tjänsten @BotFather Telegram är designad för att skapa chattbots. Grundinställningar ställs också in via det här systemet – BotFather hjälper dig att göra en beskrivning, lägga till ett profilfoto, lägga till supportverktyg. Bibliotek – uppsättningar HTML-förfrågningar för Telegram-bots – finns tillgängliga på Internet, det finns ganska många av dem. När du skapade exempelprogrammet användes pyTelegramBotApi.

Steg 1: Implementera växelkursförfrågningar

Först måste du skriva koden som utför frågor. Vi kommer att använda när vi skriver PrivatBank API, nedan är en länk till det: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Du måste använda dessa metoder i din kod:

• load_exchange – hittar växelkurser och visar kodad information;
• get_exchange – visar data om en specifik valuta;
• get_exchanges – visar lista över valutor enligt provet.

Som ett resultat ser koden i filen pb.py ut så här:

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) ): för exc i load_exchange(): om ccy_key == exc['ccy']: returnera exc return False def get_exchanges(ccy_pattern): resultat = [] ccy_pattern = re.escape(ccy_pattern) + '.*' för exc i load_exchange(): om re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) inte är Inget: result.append(exc) returnerar resultatet

Programmet kan ge följande svar på de angivna förfrågningarna:

[ { ccy:"USD", base_ccy:"UAH", köp:"25.90000", rea:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", köp:"29.10000", rea:"29.85000 " }, { ccy:"RUR", base_ccy:"UAH", köp:"0.37800", rea:"0.41800" }, { ccy:"BTC", base_ccy:"USD", köp:"11220.0384", rea: "12401.0950" } ]

Steg 2: Skapa en Telegram Bot med @BotFather

Du kan skapa ett program för att ta emot meddelanden och svara på dem med hjälp av tjänsten @BotFather. Gå till hans Telegram-sida och ange kommandot /newbot. Instruktioner kommer att visas i chatten, enligt vilka du måste skriva ner namnet på boten först och sedan dess adress. När botkontot skapas kommer ett välkomstmeddelande som innehåller en token att visas på skärmen. För ytterligare konfiguration, använd dessa kommandon:

• /setbeskrivning – beskrivning;
• /setabouttext – information om den nya boten;
• /setuserpic – profilbild;
• /setinline – inline-läge;
• /setcommands – beskrivning av kommandon.

I det sista konfigurationssteget beskriver vi /help och /exchange. När alla steg har slutförts är det dags att gå vidare till kodning.

Steg 3: Konfigurera och starta boten

Låt oss skapa en config.py-fil. I den måste du ange den unika botkoden och tidszonen där programmet kommer att hitta information.

TOKEN = '' # ersätt med din bots tokenTIMEZONE = 'Europa/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

Därefter skapar vi en annan fil med import av tidigare skrivna pb.py, bibliotek och andra nödvändiga komponenter. De saknade biblioteken installeras från pakethanteringssystemet (pip).

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

Låt oss använda innehållet i pyTelegramBotApi för att skapa en bot. Vi skickar den mottagna token med följande kod:

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

Parametern none_stop säkerställer att förfrågningar ständigt skickas. Funktionen av parametern kommer inte att påverkas av metodfel.

Steg 4: Skriv kommandohanteraren /start

Om alla föregående steg är korrekt utförda har boten börjat fungera. Programmet genererar förfrågningar regelbundet eftersom det använder metoden getUpdates. Innan raden med none_stop-elementet behöver vi en bit kod som bearbetar kommandot /start:

@bot.message_handler(commands=['start']) def start_command(meddelande): bot.send_message( message.chat.id, 'Hälsningar! Jag kan visa dig valutakurser.n' + 'För att få växelkurserna tryck / exchange.n' + 'För att få hjälp tryck på /help.')

RџСўРё commands=['start'] lika med Sant start_command anropas. Innehållet i meddelandet går dit. Därefter måste du implementera sändningsfunktionen_meddelande i förhållande till ett visst budskap.

Steg 5: Skapa en /help-kommandohanterare

Kommandot /help kan implementeras som en knapp. Genom att klicka på den kommer användaren att tas till utvecklarens Telegram-konto. Ge knappen ett namn, till exempel "Fråga utvecklaren". Ställ in parametern reply_markup, som omdirigerar användaren till en länk, för metoden send_message. Låt oss skriva i koden parametern som skapar tangentbordet (InlineKeyboardMarkup). Du behöver bara en knapp (InlineKeyboardButton).

Den sista kommandohanterarkoden ser ut så här:

@bot.message_handler(commands=['hjälp']) def help_command(meddelande): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Fråga utvecklaren', url='ваша ссылка на профиль' ) ) bot.send_message( message.chat.id, '1) För att få en lista över tillgängliga valutor tryck /exchange.n' + '2) Klicka på den valuta du är intresserad av.n' + '3) Du kommer att få ett meddelande som innehåller information om källan och målvalutorna, ' + 'köpkurser och säljkurser.n' + '4) Klicka på "Uppdatera" för att få aktuell information om begäran. ' + 'Boten kommer också att visa skillnaden mellan föregående och nuvarande växelkurs.n' + '5) Boten stöder inline. Skriv @ i valfri chatt och de första bokstäverna i en valuta.', reply_markup=keyboard )

Kodåtgärd i Telegram-chatt:

Steg 6: Lägga till kommandohanteraren /exchange

Detta steg behövs för att visa knappar med symboler för tillgängliga valutor i chatten. Ett tangentbord på skärmen med alternativ hjälper dig att undvika misstag. PrivatBank ger information om rubel, dollar och euro. Alternativet InlineKeyboardButton fungerar så här:

1. Användaren klickar på knappen med önskad beteckning.
2. getUpdates får en återuppringning (CallbackQuery).
3. Det blir känt hur man hanterar att trycka på tangentbordet – information om den nedtryckta knappen sänds.

/exchange hanterarkod:

@bot.message_handler(commands=['exchange']) def exchange_command(meddelande): tangentbord = 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, "Klicka på valfri valuta:", reply_markup=tangentbord )

Resultatet av koden i Telegram:

Steg 7: Skriva en hanterare för de inbyggda tangentbordsknapparna

Paketet pyTelegramBot Api innehåller dekorationsfunktionen @bot.callback_query_handler. Den här komponenten är utformad för att översätta återuppringningen till en funktion – API:et lindar upp och återskapar samtalet. Det stavas så här:

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

Låt oss också skriva get_ex_callback-metoden:

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

Det finns en annan användbar metod – answer_callback_query. Det hjälper till att ta bort belastningen mellan att trycka på knappen och visa resultatet på skärmen. Du kan skicka ett meddelande till send_exchange_query genom att skicka någon valutakod och meddelande. Låt oss skriva 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), reply_markup=get_update_keyboard(ex ), parse_mode='HTML' )

Medan chatboten får resultatet av förfrågan från banken API, ser besökaren inskriptionen "att skriva ett meddelande". Det ser ut som att en riktig person svarar. För att visa en sådan indikator på skärmen måste du lägga till rader för inmatningsstatus. Därefter kommer vi att använda get_exchange – med dess hjälp kommer programmet att få valutabeteckningen (rubel, euro eller dollar). send_message använder ytterligare metoder: serialize_ex konverterar valutan till ett annat format och get_update_keyboard ställer in funktionstangenter som uppdaterar information och skickar valutamarknadsdata till andra chattar.

Låt oss skriva koden för get_update_keyboard. Två knappar måste nämnas – t och e står för typ och utbyte. Alternativet switch_inline_query för knappen Dela behövs så att användaren kan välja mellan flera chattar. Besökaren kommer att kunna välja till vem han vill skicka den aktuella växelkursen för dollarn, rubeln eller euron.

def get_update_keyboard(ex): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton( 'Update', callback_data=json.dumps({ 't': 'u', 'e': { ' b': ex['köp'], 's': ex['rea'], 'c': ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Dela', switch_inline_query=ex['ccy']) ) returnera tangentbordet

Ibland behöver man se hur mycket växelkursen har förändrats på kort tid. Låt oss skriva två metoder för Uppdatera-knappen så att användare kan se kurser i jämförelse.

Skillnaden mellan växelkurserna skickas till serialiseraren via parametern diff.

De föreskrivna metoderna fungerar först efter att data har uppdaterats, de kommer inte att påverka den första visningen av kursen.

def serialize_ex(ex_json, diff=Ingen): resultat = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Köp: ' + ex_json['köp'] if diff: resultat += ' ' + serialize_exchange_diff(diff['buy_diff']) + 'n' + 'Sälj: ' + ex_json['rea'] + ' ' + serialize_exchange_diff(diff['sale_diff']) + 'n' else: resultat += 'nSell: ' + ex_json['sale'] + 'n' returnerar resultat def serialize_exchange_diff(diff): resultat = '' om diff > 0: resultat = '(' + 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">)' returresultat

Föreställ dig att besökaren ville veta dollarkursen. Så här händer om du väljer USD i meddelandet:

Steg 8: Implementera uppdateringsknapphanteraren

Låt oss skriva koden för hantering av åtgärder med knappen Uppdatera och lägga till delen iq_callback_method till den. När programobjekt börjar med parametern get måste du skriva get_ex_callback. I andra situationer analyserar vi JSON och försöker få nyckeln 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) förutom ValueError: pass

Om t är lika med u måste du skriva ett program för metoden edit_message_callback. Låt oss bryta ner den här processen steg för steg:

1. Ladda ner uppdaterad information om tillståndet på valutamarknaden (exchange_now = pb.get_exchange(data['c']).

2. Att skriva ett nytt meddelande genom en serializer med diff.
3. Lägga till en signatur (get_edited_signature).

Om det ursprungliga meddelandet inte ändras, anropa metoden 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)), exchange_now + '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='elif_message' )_in : bot.edit_message_text( text, inline_message_id=query.inline_message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Låt oss skriva metoden get_ex_from_iq_data för att analysera JSON:

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

Du kommer att behöva några fler metoder: till exempel get_exchange_diff, som läser den gamla och nya informationen om kostnaden för valutor och visar skillnaden.

def get_exchange_diff(senaste, nu): return { 'sale_diff': float("%.6f" % (float(nu['sale']) - float(senaste['sale']))), 'buy_diff': float ("%.6f" % (float(nu['köp']) - float(sista['köp']))) }

Den sista, get_edited_signature, visar när kursen senast uppdaterades.

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

Som ett resultat ser det uppdaterade meddelandet från boten med en stabil växelkurs ut så här:

När kursen ändras visas skillnaderna mellan värdena i meddelandet på grund av de föreskrivna parametrarna.

Steg 9: Implementering av inbäddat läge

Det inbyggda läget behövs för att snabbt skicka information från programmet till valfri chatt – nu behöver du inte lägga till en bot i konversationen som deltagare. När en Telegram-användare anger ett botnamn med ett @-tecken framför sig, bör konverteringsalternativ visas ovanför inmatningsraden. Om du klickar på ett av objekten kommer boten att skicka ett meddelande till konversationen med resultat och knappar för att uppdatera och skicka data. Avsändarens namn kommer att innehålla bildtexten "via ".

InlineQuery skickas till query_text via biblioteket. Koden använder funktionen answer_line för att hämta sökresultaten som en array av data och elementet inline_query_id. Vi använder get_exchanges så att boten hittar flera valutor på begäran.

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

Vi skickar en array av data till get_iq_articles för att returnera objekt från InlineQueryResultArticle genom denna metod.

def get_iq_articles(exchanges): resultat = [] för ex i utbyten: 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='Konvertera ' + exc['base_ccy'] + ' -> ' + exc['ccy'], thumb_height=1 ) ) returnera resultatet

Nu, om du skriver @ och ett mellanslag i raden kommer sökresultaten att visas på skärmen – alternativ för att konvertera till tre tillgängliga valutor.

Användare kan filtrera resultaten genom att ange önskad valuta.

Efter att ha klickat på önskad valuta från listan får chatten samma meddelande som botanvändare får. Du kan också använda knappen Uppdatera. Bilden nedan visar det uppdaterade meddelandet som skickats via boten:

Slutsats

Nu vet du hur man skapar en bot för Telegram. Du kan lägga till användbara verktyg till ditt program: knappar för att uppdatera och skicka resultatet till andra användare av messenger och ett inbyggt läge som låter dig använda botens funktioner utanför chatten med den. Baserat på denna instruktion kan du skapa vilken enkel bot som helst med andra funktioner – inte bara den som visar växelkurser. Var inte rädd för att experimentera med bibliotek, API:er och kod för att skapa en automatisk assistent som chattar med kunder på Telegram och stärker kontakten mellan intresserade personer och företaget.