Как в телеграм боте сделать функцию input
Перейти к содержимому

Как в телеграм боте сделать функцию input

  • автор:

How can I input() using TeleBot?

Yeah, sure. When the user replies to the message, the message object that gets passed as an argument into the message handler function would store the id of the message that they replied to, so you can use this to keep track of the message that the user has replied to. Another way to work around this is to just keep a record of the last message that you sent the user and match the user’s next reply, in which case, the user doesn’t have to reply to any message, which might be similar to input()

Aug 23, 2020 at 14:36

So you could create a message handler just looking out for the message with the reply_to_message.message_id attribute that is the same as your sent_message_id or one that just catches the next message after your «Enter your POL» message to catch the input from the user

Aug 23, 2020 at 14:38

import telebot TELEGRAM_TOKEN = '' bot = telebot.TeleBot(TELEGRAM_TOKEN) user_register_dict = <> @bot.message_handler(commands=['start']) def start(message): bot.reply_to(message , 'now send your name') user_register_dict[message.chat.id] = <> bot.register_next_step_handler(message , start_step2) def start_step2(message): user_register_dict[message.chat.id]['name'] = message.text bot.reply_to(message , 'now send your age') bot.register_next_step_handler(message , start_step3) def start_step3(message): user_register_dict[message.chat.id]['age'] = message.text bot.reply_to(message , 'your name is <> and you are <> years old!' .format(user_register_dict[message.chat.id]['name'] , [message.chat.id]['age'] )) start(message = message) 

Create a dict for handling the data, which is important because if you use lists (eg.) maybe 2 people starts to register in same time and data gonna crash!

Difference between create bot.register_next_step_handler (line 13 for example) with connect directly for example start(message = message) in end line is in register_next_step_handler bot waits for new message and when received puts it in message and start defection but in direct start defection bot doesn’t wait for user message, and start defection with current message start(message = message)

Telebot python как сделать функцию input?

Как можно осуществить функцию input? конкретнее мне нужно получить от пользователя число от 1 до 86, в том случае если число будет меньше 1 или больше 86, то пользователю будет предложено ввести число заново

  • Вопрос задан более года назад
  • 225 просмотров

Комментировать

Решения вопроса 1

donko1

Изучаю python

@bot.message_handler(content_types=['text']) def func1(message): bot.send_message(message.from_user.id, 'Введите текст') bot.register_next_step_handler(message, func2) def func2(message): var = message.text # Текст сообщения от пользователя bot.send_message(message.from_user.id, var) # Вернет сообщение пользователя обартно

Ответ написан более года назад

Комментировать

Нравится Комментировать

Урок 5. Клавиатуры и кнопки

В сегодняшнем уроке мы разберём шаблоны сообщений и инлайн-клавиатуры и научимся применять встроенные в aiogram методы для составления сложных клавиатур.

Не забывайте своевременно обновлять библиотеку командой python3.6 -m pip install aiogram -U ! Урок проводится с использованием версии 1.2.3

Весь код, использованный в уроке, как обычно доступен на GitHub

Для начала стоит понять, в чем основное различие ReplyKeyboardMarkup и InlineKeyboardMarkup :

ReplyKeyboardMarkup — это шаблоны сообщений. К примеру, ваш бот задаёт пользователю вопрос и предлагает варианты ответа. Пользователь может самостоятельно напечатать ответ, либо нажать на готовую кнопку. Такая клавиатура показывается вместо основной и не привязана ни к какому сообщению. В кнопки такой клавиатуры нельзя заложить никакой информации, нельзя запрограммировать для неё подобный если пользователь нажимает кнопку с текстом «abc» отправить текст «qwerty» алгоритм, отправлено будет только то, что написано на кнопке (есть два исключения, о которых ниже).

InlineKeyboardMarkup — это уже настоящая кастомная клавиатура. С её помощью мы можем выполнять более сложные действия. Она привязывается к сообщению, с которым была отправлена. В кнопки можно заложить любой текст размером от 1 до 64 байт (будьте осторожны, недобросовестные клиенты позволяют изменять эти данные). Инлайн кнопки позволяют скрыть в себе внутреннюю телеграм ссылку, ссылку на внешний ресурс, а также шорткат для инлайн запроса (об инлайн режиме в одном из следующих уроков).

И ту и другую клавиатуру можно редактировать, но разными способами. Первая обновляется при отправке сообщения с новой клавиатурой типа ReplyKeyboardMarkup , вторую можно редактировать вместе с сообщением, к которому она прикреплена (или только саму разметку).

Переходим к коду

Создадим отдельный модуль с клавиатурами, которые будем использовать в основной программе.

В первую очередь импортируем необходимые нам модули и создаём первую клавиатуру:

from aiogram.types import ReplyKeyboardRemove, \ ReplyKeyboardMarkup, KeyboardButton, \ InlineKeyboardMarkup, InlineKeyboardButton button_hi = KeyboardButton('Привет! ��') greet_kb = ReplyKeyboardMarkup() greet_kb.add(button_hi) 

При инициализации класса KeyboardButton необходимо передать один обязательный параметр — текст, который пользователь будет отправлять по нажатию на эту кнопку. У объекта класса ReplyKeyboardMarkup есть несколько методов, позволяющих добавить кнопку, в данном случае мы используем add . Таким образом мы получили первую готовую клавиатуру.

Создаём обработчик, который будет отправлять нам сообщение и наш шаблон (напомню, что отправить отдельно клавиатуру никак нельзя, она является параметром к сообщению).

@dp.message_handler(commands=['start']) async def process_start_command(message: types.Message): await message.reply("Привет!", reply_markup=kb.greet_kb) 

Запускаем и проверяем:

Отлично, клавиатура появилась! Но эта одна кнопка с маленьким текстом занимает очень много места. Телеграм позволяет автоматически уменьшить размер, для этого необходимо передать в инициализатор класса ReplyKeyboardMarkup параметру resize_keyboard значение True . Создадим новую клавиатуру:

greet_kb1 = ReplyKeyboardMarkup(resize_keyboard=True).add(button_hi) 

Мы передали параметр в инициализатор и следом сразу добавили уже существующую кнопку. Отправляем новую версию клавиатуры:

@dp.message_handler(commands=['hi1']) async def process_hi1_command(message: types.Message): await message.reply("Первое - изменяем размер клавиатуры", reply_markup=kb.greet_kb1) 

Очевидно, так как у нас нет обработчика обычных сообщений, текст, отправляемый нажатием на эту кнопку, остаётся без ответа. При желании можно добавить функцию эхо из первого урока. А что ещё можно было заметить при использовании этой кнопки? Что она остаётся всё там же, даже если мы после нажатия хотели бы вернуться к привычной клавиатуре. Да, нажать одну кнопку, чтобы переключиться, не сложно. Но если клавиатура в принципе не подразумевает повторного нажатия прямо сейчас? И для этого тоже есть решение:

# keyboards.py greet_kb2 = ReplyKeyboardMarkup( resize_keyboard=True, one_time_keyboard=True ).add(button_hi) # bot.py @dp.message_handler(commands=['hi2']) async def process_hi2_command(message: types.Message): await message.reply("Второе - прячем клавиатуру после одного нажатия", reply_markup=kb.greet_kb2) 

Эти параметры можно комбинировать. Вследствие чего мы получили маленькую клавиатуру, которая скрывается после одной отправки. Но пользователь может снова её открыть нажатием на соответствующую кнопку в поле ввода.

Добавляем больше кнопок

Рассмотрим подробно работу встроенных методов для создания более сложных клавиатур, а именно row , insert и add . Создаём кнопки, которые мы сможем использовать повторно и генерируем несколько разных клавиатур:

button1 = KeyboardButton('1️⃣') button2 = KeyboardButton('2️⃣') button3 = KeyboardButton('3️⃣') markup3 = ReplyKeyboardMarkup().add( button1).add(button2).add(button3) markup4 = ReplyKeyboardMarkup().row( button1, button2, button3 ) markup5 = ReplyKeyboardMarkup().row( button1, button2, button3 ).add(KeyboardButton('Средний ряд')) button4 = KeyboardButton('4️⃣') button5 = KeyboardButton('5️⃣') button6 = KeyboardButton('6️⃣') markup5.row(button4, button5) markup5.insert(button6) 

Важно: сейчас мы отталкиваемся от того, что клавиатура по умолчанию имеет 3 кнопки в ряд. О том, как изменить это значение, будет в примере с инлайн клавиатурами — этот параметр идентичен для обоих видов.

  • Метод add принимает в себя любое количество кнопок, всегда начинает добавление с новой строки и переносит ряд при достижении значения установленной ширины.
  • Метод row тоже принимает любое количество, но при этом не переносит кнопки на новый ряд, а добавляет всё полученное в одну строчку.
  • Метод insert работает по схеме схожей с add , но только начинает добавлять к последнему ряду. И только если там уже достигнута максимальная ширина, начинает новую строку. Взглянем на него ещё раз при создании следующей клавиатуры.

Отправляем все готовые кнопки и смотрим на результат:

@dp.message_handler(commands=['hi3']) async def process_hi3_command(message: types.Message): await message.reply("Третье - добавляем больше кнопок", reply_markup=kb.markup3) 

@dp.message_handler(commands=['hi4']) async def process_hi4_command(message: types.Message): await message.reply("Четвертое - расставляем кнопки в ряд", reply_markup=kb.markup4) 

@dp.message_handler(commands=['hi5']) async def process_hi5_command(message: types.Message): await message.reply("Пятое - добавляем ряды кнопок", reply_markup=kb.markup5) 

Думаю, здесь достаточно наглядно видно работу методов добавления кнопок в разметку.

И последнее по этому виду клавиатур. ReplyKeyboardMarkup позволяет запросить у пользователя его контакт или локацию. Это те самые два исключения из правила, когда при нажатии кнопки будет отправлено не то, что написано на ней. Их можно отправлять как по одной, так и в составе более сложной клавиатуры. Добавим обе кнопки и посмотрим, что будет (обращу внимание читателя на то, что нельзя одной кнопкой запросить сразу и то и то):

# keyboards.py markup_request = ReplyKeyboardMarkup(resize_keyboard=True).add( KeyboardButton('Отправить свой контакт ☎️', request_contact=True) ).add( KeyboardButton('Отправить свою локацию ��️', request_location=True) ) #bot.py @dp.message_handler(commands=['hi6']) async def process_hi6_command(message: types.Message): await message.reply("Шестое - запрашиваем контакт и геолокацию\nЭти две кнопки не зависят друг от друга", reply_markup=kb.markup_request) 

При нажатии на каждую из этих кнопок клиент (приложение Телеграм) спросит, уверены ли вы, что хотите поделиться с ботом этими данными и при утвердительном ответе отправит их.

Запрос контакта

Запрос текущей геолокации

Данные пользователя

Рассмотрим подробнее последний метод для составления клавиатур — insert . Он похож на метод add , но начинает добавлять кнопки не с нового ряда, а сначала проверяет, заполнен ли до конца последний ряд. И если нет, то сначала добавляет кнопки туда, а переносит строку только при достижении указанного лимита.

# keyboards.py markup_big = ReplyKeyboardMarkup() markup_big.add( button1, button2, button3, button4, button5, button6 ) markup_big.row( button1, button2, button3, button4, button5, button6 ) markup_big.row(button4, button2) markup_big.add(button3, button2) markup_big.insert(button1) markup_big.insert(button6) markup_big.insert(KeyboardButton('9️⃣')) # bot.py @dp.message_handler(commands=['hi7']) async def process_hi7_command(message: types.Message): await message.reply("Седьмое - все методы вместе", reply_markup=kb.markup_big) 

После каждой отправки ботом пользователю клавиатуры, последняя заменяет предыдущую. Поэтому пользователь всегда может открыть её, даже когда по контексту она не нужна. Для того, чтобы у пользователя в клиенте клавиатура убралась совсем, нужно отправить ему ReplyKeboardRemove :

@dp.message_handler(commands=['rm']) async def process_rm_command(message: types.Message): await message.reply("Убираем шаблоны сообщений", reply_markup=kb.ReplyKeyboardRemove()) 

Получив сообщение с такой клавиатурой, клиент уберёт шаблоны полностью.

Инлайн клавиатуры

Теперь перейдем к инлайн клавиатурам. Они имеют больше параметров, поэтому позволяют нам делать больше разных вещей. Самое популярное использование — как кнопка, являющаяся шорткатом для какого-то действия. То есть «если пользователь нажал кнопку X, сделать Y». И под Y можно понимать вообще что угодно, так как это уже не ограничивается даже API. Рассмотрим наглядно, для этого передадим в инициализатор значение callback_data :

# keyboards.py inline_btn_1 = InlineKeyboardButton('Первая кнопка!', callback_data='button1') inline_kb1 = InlineKeyboardMarkup().add(inline_btn_1) #bot.py @dp.message_handler(commands=['1']) async def process_command_1(message: types.Message): await message.reply("Первая инлайн кнопка", reply_markup=kb.inline_kb1) 

Нажимаем кнопку и.. ничего не происходит! Почему? Если у бота было включено логгирование, то вы могли заметить, что приходит обновление типа CallbackQuery . Так вот именно его нам и нужно отлавливать. Добавляем нужный хэндлер (я предпочитаю ставить их выше, но относительно хэндлеров обычных сообщений значения это не имеет):

@dp.callback_query_handler(func=lambda c: c.data == 'button1') async def process_callback_button1(callback_query: types.CallbackQuery): await bot.answer_callback_query(callback_query.id) await bot.send_message(callback_query.from_user.id, 'Нажата первая кнопка!') 

Здесь мы делаем проверку прямо в хэндлере. Аргумент func ожидает функцию, которая принимает один параметр (туда передаётся апдейт), и хэндлер срабатывает, если возвращается истина. Этот аргумент можно использовать и в других хэндлерах, мы уже использовали его в уроке по FSM.

Внутри мы можем делать вообще что угодно, так как работаем с обычным питоном. Подача корма для кошки? Управление светом? Пределом является только ваша фантазия.

Хорошим тоном будет отвечать на все колбеки — для этого есть метод answerCallbackQuery . В документации сказано, что ответ ожидается клиентом, и дать его нужно обязательно, даже если вы не собираетесь передавать что-либо. Этого времени предостаточно, чтобы собрать необходимые данные и прислать их. При этом во время ожидания на кнопке будут крутиться часики, показывающие, то клиент ждёт ответа, поэтому если мы не хотим, чтобы пользователь наблюдал их, то нужно не забывать отвечать. Обязательный аргумент — айди запроса, на который мы отвечаем. Остальные параметры рассмотрим ниже. А в данном случае мы для наглядности отправим сообщение с информацией о том, что нажата первая кнопка. Запускаем снова, жмём кнопку и таки получаем ответ:

В этот раз установим ширину клавиатуры 2 и посмотрим, что будет.
Ну и так как методы добавления новых элементов мы уже разобрали, добавим сразу все доступные кнопки и отправим получившуюся клавиатуру, не забыв добавить хэндлер кнопок:

# keyboards.py inline_kb_full = InlineKeyboardMarkup(row_width=2).add(inline_btn_1) inline_kb_full.add(InlineKeyboardButton('Вторая кнопка', callback_data='btn2')) inline_btn_3 = InlineKeyboardButton('кнопка 3', callback_data='btn3') inline_btn_4 = InlineKeyboardButton('кнопка 4', callback_data='btn4') inline_btn_5 = InlineKeyboardButton('кнопка 5', callback_data='btn5') inline_kb_full.add(inline_btn_3, inline_btn_4, inline_btn_5) inline_kb_full.row(inline_btn_3, inline_btn_4, inline_btn_5) inline_kb_full.insert(InlineKeyboardButton("query=''", switch_inline_query='')) inline_kb_full.insert(InlineKeyboardButton("query='qwerty'", switch_inline_query='qwerty')) inline_kb_full.insert(InlineKeyboardButton("Inline в этом же чате", switch_inline_query_current_chat='wasd')) inline_kb_full.add(InlineKeyboardButton('Уроки aiogram', url='https://surik00.gitbooks.io/aiogram-lessons/content/')) # bot.py @dp.callback_query_handler(func=lambda c: c.data and c.data.startswith('btn')) async def process_callback_kb1btn1(callback_query: types.CallbackQuery): code = callback_query.data[-1] if code.isdigit(): code = int(code) if code == 2: await bot.answer_callback_query(callback_query.id, text='Нажата вторая кнопка') elif code == 5: await bot.answer_callback_query( callback_query.id, text='Нажата кнопка с номером 5.\nА этот текст может быть длиной до 200 символов ��', show_alert=True) else: await bot.answer_callback_query(callback_query.id) await bot.send_message(callback_query.from_user.id, f'Нажата инлайн кнопка! code=') @dp.message_handler(commands=['2']) async def process_command_2(message: types.Message): await message.reply("Отправляю все возможные кнопки", reply_markup=kb.inline_kb_full) 

Пройдёмся по строчкам по порядку, чтобы не осталось вопросов:

  • мы создаём клавиатуру типа InlineKeyboardMarkup , указываем, что ширина строки должна быть не больше двух (напомню, что это не распространяется на метод row ) и сразу добавляем туда уже готовую кнопку
  • далее добавляем кнопку, у которой указываем другие данные в параметре callback_data
  • следом генерируем три новые кнопки и добавляем их дважды. Сначала методом add , затем через row . И так как ширина клавиатуры равна двум, то в первом случае происходит перенос третьей кнопки, во втором случае нет
  • затем добавляем кнопки, у которых указываем уже не callback_data , а другие параметры. То, что мы добавим в switch_inline_query , будет автоматически использовано при нажатии кнопки: пользователю предложат выбрать чат, а там вызовется инлайн режим этого бота (в поле ввода сообщения добавится юзернейм бота), следом через пробел будет прописано то, что мы указали. Параметр может принимать пустую строку, тогда инлайн режим запустится без какого-либо запроса, но если будет указан текст, то он и добавится
  • при использовании switch_inline_query_current_chat произойдёт ровно то же, что и в предыдущем пункте, но без выбора чата, а запустится в текущем (было сложно догадаться по названию, я знаю)
  • ну и последний параметр url - добавляем ссылку на внешний ресурс, либо диплинк в самом Телеграме

Так как параметр клавиатуры row_width равен двум, то кнопки автоматически расставились соответствующе. Рассмотрим реакцию на кнопки по порядку: При нажатии первой срабатывает наш первый колбек, так как не важно, в какую клавиатуру добавлена кнопка, важно, какая у неё callback_data ☝️. Поэтому добавлять инлайн кнопку можно сколько угодно раз в любые инлайн клавиатуры.

Кнопки со второй по пятую имеют схожую структуру в callback_data , поэтому внутри хэндлера проверяем, какой код у нажатой кнопки и:

  • если 2, то отвечаем на запрос и передаем информационное сообщение. Аргумент text это текст ответа на запрос. По умолчанию он будет показан вверху чата и сам скроется через пару секунд.
  • если 5, то отвечаем так же, но указываем show_alert=True , таким образом мы сообщаем клиенту, что нужно показать окошко с текстом
  • в ином случае просто отвечаем на колбек

И во всех случаях шлем сообщение пользователю:

Ещё можно отправить кнопку с игрой или платежом, но первое мы разберем в одном из следующих уроков, а о втором я уже упоминал в одном из предыдущих. При ответе на колбек можно ещё передать в ответ ссылку формата t.me/your_bot?start=XXXX , чтобы пользователь запустил вашего бота с определенным параметром, но диплинкинг мы тоже оставим для другого урока, так как здесь только о кнопках.

На последок не забываем добавить обработку команы /help и запускаем:

help_message = text( "Это урок по клавиатурам.", "Доступные команды:\n", "/start - приветствие", "\nШаблоны клавиатур:", "/hi1 - авто размер", "/hi2 - скрыть после нажатия", "/hi3 - больше кнопок", "/hi4 - кнопки в ряд", "/hi5 - больше рядов", "/hi6 - запрос локации и номера телефона", "/hi7 - все методы" "/rm - убрать шаблоны", "\nИнлайн клавиатуры:", "/1 - первая кнопка", "/2 - сразу много кнопок", sep="\n" ) @dp.message_handler(commands=['help']) async def process_help_command(message: types.Message): await message.reply(help_message) if __name__ == '__main__': executor.start_polling(dp) 

Вот и всё!

В этом уроке мы разобрали как работать с клавиатурами в Телеграм

Создаем Telegram бота

Телеграм боты - это крутой способ взаимодействия с пользователем прямо в привычном ему мессенджере. Это гораздо быстрее и чаще удобнее, чем писать полноценное мобильное приложение. Сегодня мы с вами разберемся, как они работают, и создадим несколько собственных ботов.

Вспоминая функции

Функция - это часть кода программы, которую можно повторно использовать. У функции есть имя, список параметров и возвращаемое значение.

Возвращаемое значение - это результат работы функции. Рассмотрим простой пример:

def getTwo(): return 2 a = getTwo() print(a)

В данном примере мы определили функцию getTwo , она не принимает параметров и всегда возвращает ( return ) число 2. Написав a = getTwo() , мы вызвали функцию и результат ее работы попал в переменную a . На следующей строчке программа выведет 2 .

Список параметров (или аргументов) - это значения, которые необходимы функции для выполнения задачи. Рассмотрим второй пример:

def sum(a, b): return a + b print(sum(23, 5)) # выведет 28 print(sum(-3, 6)) # выведет 3

Здесь функция принимает два параметра и возвращает их сумму.

Внутри функций мы можем использовать любые переменные и операции с единственным ограничением:

  1. переменные внутри функции недоступны вне этой функции;
  2. переменные извне функции доступны только для чтения (если не испольуется ключевое слово global ).

Телеграм боты

Телеграм бот - это программа, которая запущена на вашем компьютере и общается с серверами телеграма через интернет. Можно представить, что при регистрации бота, телеграм выделяет нам почтовый ящик, через который мы можем получать сообщения от пользователей и отправлять их им.

Чтобы создать собственного бота, сперва его надо зарегистрировать. Для этого в телеграме нужно добавить бота @BotFather и следовать инструкциям.

После того, как мы введем название бота, @BotFather сообщит нам токен - пароль к нашему почтовому ящику.

Далее мы с вами научимся писать программы на питоне, которые, используя этот токен, смогут общаться с пользователями.

Устанавливаем библиотеки

Одно из ключевых преимуществ питона - наличие огромного количества встроенных и сторонних библиотек. Для того, чтобы сделать телеграм-бота, который будет присылать нам статьи из википедии по нашему запросу, нам потребуется установить сразу три библиотеки.

  • pyTelegramBotApi - для создания бота.

Для установки сторонних библиотек вместе с питоном на компьютер устанавливается программа pip.exe , которая умеет автоматически находить и скачивать библиотеки по их названию. Единственный нюанс - она работает только через командную строку (терминал).

Чтобы установить библиотеки нам потребуется открыть командную строку и последовательно ввести три команды.

pip install pytelegrambotapi

PS. Если у вас установлен питон, но компьютер все равно не находит pip, путь к нему нужно добавить в системную переменную PATH.

PS. Если у вас потребуют права администратора, можно поставить библиотеки только для текущего пользователя.

pip install --user pytelegrambotapi

Бот-попугай

Давайте сделаем нашего первого бота - бота-попугая. На все сообщения он будет отвечать повторением.

import telebot token = "ВСТАВЬТЕ СЮДА ТОКЕН" # подключаемся к телеграму bot = telebot.TeleBot(token=token) # content_types=['text'] - сработает, если нам прислали текстовое сообщение @bot.message_handler(content_types=['text']) def echo(message): # message - входящее сообщение # message.text - это его текст # message.chat.id - это номер его автора text = message.text user = message.chat.id #отправляем картинку с попугаем bot.send_photo(user, "https://i.ytimg.com/vi/R-RbmqzRC9c/maxresdefault.jpg") #отправляем сообщение тому же пользователю с тем же текстом bot.send_message(user, text) # поллинг - вечный цикл с обновлением входящих сообщений bot.polling(none_stop=True)

Помимо текстовых сообщений, в телеграме есть команды, они начинаются со слэша, например, /start или /help . Их тоже можно обрабатывать.

Давайте добавим пояснение к нашему боту, которое объяснит пользователю, что он делает.

import telebot token = "ВСТАВЬ СЮДА ТОКЕН" # подключаемся к телеграму bot = telebot.TeleBot(token=token) # реагируем на команды /start и /help @bot.message_handler(commands=['start', 'help']) def help(message): user = message.chat.id bot.send_message(user, "Это бот попугай! Просто пришли и я повторю.") # content_types=['text'] - сработает, если нам прислали текстовое сообщение @bot.message_handler(content_types=['text']) def echo(message): # message - входящее сообщение # message.text - это его текст # message.chat.id - это номер его автора text = message.text user = message.chat.id #отправляем картинку с попугаем bot.send_photo(user, "https://i.ytimg.com/vi/R-RbmqzRC9c/maxresdefault.jpg") #отправляем сообщение тому же пользователю с тем же текстом bot.send_message(user, text) # поллинг - вечный цикл с обновлением входящих сообщений bot.polling(none_stop=True)

Стикеры

Еще пример: бот, которому можно прислать стикер и получить стикер в ответ (он запоминает ранее присланные стикеры от всех пользователей).

import telebot import random token = "ТОКЕН" bot = telebot.TeleBot(token=token) stickers = [] @bot.message_handler(content_types=['sticker']) def echo(message): user = message.chat.id sticker = message.sticker.file_id stickers.append(sticker) bot.send_sticker(user,random.choice(stickers)) bot.polling(none_stop=True) 

Что такое словарь?

Списки - это очень круто! Можно хранить много данных и не придумывать имя каждому элементу. Но.

Рассмотрим другую задачу: нам нужно сделать базу клиентов для магазина комиксов. Магазин хочет помнить имя, возраст и любимые комиксы каждого клиента. Мы можем попробовать складывать это в список, но получится примерно так:

clients = ["Петька", 23, ["Майор гром", "Супермен"], "Чапаев", 43, ["Бэтмен"]]

Получаются тройки элементов, где первый элемент это имя, второй - возраст, а дальше список любимых комиксов. Жить, конечно, можно. Но ведь явно должен быть способ лучше. Да, и это - словари.

Вспомним коридор отеля, в котором на дверях написаны номера. Можно провести модернизацию и повесить на двери имя жильца вместо номера. Такой номер будет называться ключем, а сам жилец - значением.

Более естественный пример - это обычный бумажный словарь. Это книга, в которой перечислены слова и их определения. Слова - это ключи, а определения - значения.

Словарь - множество пар ключ-значение.

В примере выше весь список клиентов - это и правда список, а вот отдельный клиент тянет на словарь.

Один клиент будет выглядеть так:

client = # это словарь

А весь список клиентов:

clients = [ , ] # это список словарей

Как работать со словарями?

Работа со словарями очень похожа на работу со списками, только вместо номера элемента используется его ключ (имя).

client = print("Как зовут клиента?") print(client["name"]) print('-' * 15) print("Сколько ему лет?") print(client["age"]) print('-' * 15) print("А можно вывести всю информацию о нем?") print(client) # print('-' * 15) print("А в столбик?") for key in client: print("<> - <>".format(key, client[key])) # словарь это много пар ключ-значение. Чтобы посмотреть на все элементы надо перебрать все ключи print('-' * 15) print("Он любит кошек или собак?") if "pet" in client: print(client["pet"]) else: print("Мы не знаем") # так можно проверить, есть ли ключ в словаре print('-' * 15) print("Он любит кошек, запишите это!") client["pets"] = "кошка" print(client) # так можно добавить в словарь новый элемент # print('-' * 15) print("Возраст не нужен, удалите!") del client["age"] print(client) # удаляем элемент и словаря # print('-' * 15) # кстати, можно вывести все ключи: print(list(client.keys())) # ['name', 'favorites', 'pets'] print('-' * 15) # и отдельно все значения print(list(client.values())) # ['Петька', ['Майор гром', 'Супермен'], 'кошка'] print('-' * 15) # а еще из словаря можно сделать список пар, вот так: print(list(client.items())) # [('name', 'Петька'), ('favorites', ['Майор гром', 'Супермен']), ('pets', 'кошка')] print('-' * 15) print("Ксати, он говорил, что бэтмен тоже ничего.") client["favorites"].append("Бэтмен") print(client) #

Привязка данных к пользователю

Предположим мы хотим сделать бота, которы будет запоминать какую-то фразу, а затем по просьбе пользователя напоминать ее ему. Чтобы решить эту задачу, нам понадобится где-то хранить последнее сообщение пользователя.

Если мы будем использовать переменную, то сможем сохранить сообщение только одного пользователя. Например, Вася попросил запомнить слово kitten . Мы положим эту строку в переменную note . А затем Петя, попросить запомнить слово puppy , и мы снова положим это переменную note . Когда Вася попросит нам напомнить его последнее сообщение, мы напишем ему puppy вместо kitten . Совершенно не годится!

Удобнее всего хранить все данные, которые привязаны к конкретному пользователю в словаре. Ключем в этом словаре будет id пользователя, а значением - произвольные данные.

Предположим, что наш словарь называется notes - заметки. Теперь, когда Вася (id88000) пришлет слово kitten мы положим его в notes[88000] , а слово puppy от Пети (id5300) - в notes[5300] . Посколько теперь мы используем разные переменные для хранения слова, сообщения от разных пользователей не будут путаться.

Реализация:

import telebot # Обходим блокировку с помощью прокси telebot.apihelper.proxy = token = "ВАШ ТОКЕН" bot = telebot.TeleBot(token=token) notes = <> @bot.message_handler(commands=['remind']) def remind(message): user_id = message.chat.id if user_id not in notes: bot.send_message(user_id, "Вы мне еще не писали.") else: bot.send_message(user_id, notes[user_id]) @bot.message_handler(content_types=['text']) def remember(message): user_id = message.chat.id notes[user_id] = message.text bot.send_message(user_id, "Я запомнил") bot.polling(none_stop=True)

Запланированный ответ на конкретное сообщение

Иногда нам приходиться проводить пользователя через конкретную цепочку вопросов, и проще всего сделать это с помощью функции bot.register_next_step_handler . Она позволит нам создать сразу много функций (как и в обычном квесте) и в ответ на сообщения от пользователя последовательно вызывать нужную.

Попробуем с ее помощью провексти квест.

import telebot bot = telebot.TeleBot(token="ВСТАВЬ СЮДА ТОКЕН") @bot.message_handler(commands=['start']) def start(message): # кто нам написал? узнаем id чата! chat_id = message.chat.id # отправляем приветствие answer = bot.send_message(chat_id, "Добро пожаловать в квест. Первое задание. ") # в ответ на приветствие просим вызвать функцию point1 bot.register_next_step_handler(answer, point1) # название функции мы придумали сами, но параметр message обязателен def point1(message): # кто нам написал? узнаем id чата! chat_id = message.chat.id # что написали? узнаем текст входящего сообщения # по сути это замена input text = message.text # если ответ верен if text == "Ответ 1": # пишем об этом пользвоателю и задаем следующие вопрос answer = bot.send_message(chat_id, "Правильный ответ. Второе задание. ") # в ответ на сообщение просим вызвать функцию point2 bot.register_next_step_handler(answer, point2) else: # пишем, что ответ неверен answer = bot.send_message(chat_id, "Нет, попробуйте еще раз. ") # в ответ на сообщение просим вызвать функцию point1 bot.register_next_step_handler(answer, point1) # все по аналогии с point1 def point2(message): chat_id = message.chat.id text = message.text if text == "Ответ 2": answer = bot.send_message(chat_id, "Правильный ответ. Вы прошли квест!\nЧтобы повторить напишите /start.") else: answer = bot.send_message(chat_id, "Нет, попробуйте еще раз. ") bot.register_next_step_handler(answer, point2) bot.polling(none_stop=True) 

Получение фотографий

Следующий пример показывает, как скачать и сохранить картинку, которую прислал пользователь. Не забудьте создать папку images, в которую мы будем сохранять полученные картинки.

import uuid import telebot from PIL import Image token = "ВАШ ТОКЕН" bot = telebot.TeleBot(token=token) def process(filename): # обработка фотографии pass @bot.message_handler(content_types=['photo']) def photo(message): # скачивание файла file_id = message.photo[-1].file_id path = bot.get_file(file_id) downloaded_file = bot.download_file(path.file_path) # узнаем расширение и случайное придумываем имя extn = '.' + str(path.file_path).split('.')[-1] name = 'images/' + str(uuid.uuid4()) + extn # создаем файл и записываем туда данные with open(name, 'wb') as new_file: new_file.write(downloaded_file) # обрабатываем картинку фильтром process(name) # открываем файл и отправляем его пользователю with open(name, 'rb') as new_file: bot.send_photo(message.chat.id, new_file.read()) bot.polling(none_stop=True) 

Отправка сообщений в произвольное время

Ваш телеграм бот может писать пользователю в произвольное время, если пользователь хоть раз с ним контактировал и вы запомнили id чата с ним.

В примере ниже после команды /spam бот будет отправлять пользователю сообщение каждые несколько секунд. Для этого используется многопоточность - в одном потоке осуществляется обновление сообщений с сервера телеграма, а во втором - отправка сообщений всем пользователям каждые несколько секунд.

import telebot import time from threading import Thread token = "ТОКЕН" bot = telebot.TeleBot(token=token) users = [] @bot.message_handler(commands=['start', 'help']) def start(message): user = message.chat.id bot.send_message(user, "https://www.youtube.com/watch?v=rdg4lkgsQ04") @bot.message_handler(commands=['spam']) def add_user(message): global user user = message.chat.id if user not in users: users.append(user) bot.send_message(user, "Берем сироп вишневый!") @bot.message_handler(commands=['stop']) def remove_user(message): user = message.chat.id users.remove(user) bot.send_message(user, "Все, все.") def spam(): global users while True: for user in users: bot.send_message(user, "Затем сироп вишневый!") time.sleep(2) # запускаем цикл спама в отдельном потоке spam_thread = Thread(target=spam) spam_thread.start() bot.polling(none_stop=True)

Получаем аудиосообщения

import struct import telebot import uuid bot = telebot.TeleBot("ВСТАВЬ ТОКЕН СЮДА") def download_audio(message): voice_id = message.voice.file_id file_description = bot.get_file(voice_id) downloaded_file = bot.download_file(file_description.file_path) filename = 'audio/' + str(uuid.uuid4()) + '.oga' with open(filename, 'wb') as file: file.write(downloaded_file) return filename def convert_audio(path): import subprocess src_filename = path dest_filename = path + '.wav' subprocess.run(['ffmpeg', '-i', src_filename, dest_filename]) return dest_filename def speed_up(path): import wave audio = wave.open(path) data = audio.readframes(audio.getnframes()) values = struct.unpack(f'h', data) values2 = [] for i in range(0, len(values), 2): values2.append(values[i]) data = struct.pack(f'h', *values2) audio2 = wave.open(path + '.2.wav', 'wb') audio2.setnchannels(audio.getnchannels()) audio2.setframerate(audio.getframerate()) audio2.setsampwidth(audio.getsampwidth()) audio2.writeframes(data) return path + '.2.wav' @bot.message_handler(content_types=['voice']) def voice(message): path = download_audio(message) path = convert_audio(path) path = speed_up(path) bot.send_audio(message.chat.id, open(path, 'rb').read()) print(path) bot.polling(none_stop=True)

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *