详解如何使用 Python 操作 Telegram（电报）机器人-51CTO.COM

楔子

Telegram（电报）相信大家都知道，关于它的介绍和注册方式这里就跳过了，我假设你已经注册好了。本篇文章来聊一聊 Telegram 提供的机器人，以及如何用 Python 为机器人实现各种各样的功能。

创建机器人

首先我们使用浏览器打开 https://web.telegram.org，然后用手机上的 APP 扫码登录。

图片

登录之后搜索 BotFather，机器人需要通过 BotFather 来创建，当然 BotFather 本身也是一个机器人，但它同时管理着其它的机器人。

我们点击 BotFather，下面将通过和它聊天的方式来创建机器人，过程如下。

1）在页面中输入命令 /newbot 并回车，相当于给 BotFather 发指令，表示要创建机器人。注：命令要以 / 开头。

2）BotFather 收到之后会将机器人创建好，并提示我们给机器人起一个名字，这里我起名为：古明地觉。

3）回车之后，BotFather 会继续让我们给机器人起一个用户名，这个用户名会作为机器人的唯一标识，用于定位和查找。这里我起名为 Satori_Koishi_bot，注：用户名必须以 Bot 或 bot 结尾。

下面来实际演示一下。

图片

我们点击 t.me/Satori_Koishi_bot，看看结果如何。

图片

点击 t.me/Satori_Koishi_bot 之后，再点击屏幕中的 start（相当于发送了一条 /start 指令），就可以和机器人聊天了。因为我们还没有编写代码，来为机器人添加相应的功能，所以目前不会有任何事情发生。

然后我们给自定义的机器人添加一些描述信息，显然这依赖于 BotFather。向其发送 /mybots 指令，会返回我们创建的所有的机器人，当然这里目前只有一个。

图片

我们点击它，看看结果：

图片

里面提供了很多的选项，这里我们再点击 Edit Bot，来编辑机器人的相关信息。

图片

不难发现，我们除了给当前机器人一个名字之外，其它的信息就没有了，所以 Telegram 提供了一系列按钮，供我们进行编辑。比如我们点击 Edit Botpic，编辑头像。

图片

然后机器人的头像会发生改变，当然这些都属于锦上添花的东西，最重要的是 Edit Commands，它是机器人能够产生行为的核心，否则当前的机器人就是个绣花枕头，中看不中用。

下面我们点击 Edit Commands，添加一个 /help 命令。

图片

添加格式为命令 - 描述，可同时添加多个。

图片

目前机器人便支持了 /help 命令，另外如果点击 Edit Command 之后再输入 /empty，那么也可以将机器人现有的命令清空掉。

虽然 /help 命令有了，但发送这个命令之后，机器人不会有任何的反应，因为我们还没有给命令绑定相应的处理函数，下面就来看看如何绑定。当然啦，机器人不光要对命令做出反应，就算是普通的文本、表情、图片等消息，也应该做出反应。至于命令本质上就是一个纯文本，只不过它应该以 / 开头。

接收消息并处理

我们可以使用 Python 连接 Telegram 机器人，为它绑定处理函数，首先需要安装一个第三方库。

安装：pip3 install "python-telegram-bot[all]"

然后获取机器人的 Token，这个 Token 怎么获取呢？

图片

像 BotFather 发送 /mybots 命令，点击指定机器人的 API Token 即可获取。

图片

有了这个 Token 之后，就可以和机器人建立连接了。

import asyncio
import telegram
from telegram.request import HTTPXRequest
# 代理，由于不方便展示，因此我定义在了一个单独的文件中
# 这里的 PROXY 是一个字符串，类似于 "http://username:password@ip:port"
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def main():
    # 传递机器人的 Token，内部会自动和它建立连接
    bot = telegram.Bot(
        BOT_API_TOKEN,
        # 指定代理
        request=HTTPXRequest(proxy=PROXY),
        get_updates_request=HTTPXRequest(proxy=PROXY),
    )
    async with bot:
        # 测试连接是否成功，如果成功，会返回机器人的信息
        print(await bot.get_me())

asyncio.run(main())
"""
User(api_kwargs={'has_main_web_app': False}, 
     can_connect_to_business=False, 
     can_join_groups=True, 
     can_read_all_group_messages=False, 
     first_name='古明地觉', 
     id=6485526535, 
     is_bot=True, 
     supports_inline_queries=False, 
     username='Satori_Koishi_bot')
"""1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

返回值包含了机器人的具体信息，还是比较简单的，只需指定一个 Token 即可访问。当然啦，由于网络的原因还需要使用代理。

然后通过该模块还可以给机器人发消息，但这显然不是我们的重点，因为消息肯定是通过 APP 或者浏览器发送的。我们要做的是，定义机器人的回复逻辑，当用户给它发消息时，它应该做些什么事情。

先来一个简单的案例，当用户输入 /start 命令时，回复一段文本。

from telegram import Update
from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

# 定义一个处理函数
# update 封装了用户发送的消息数据
# context 则封装了 Bot 对象和一些会话数据
# 这两个对象非常重要，后面还会详细说
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # context.bot 便是机器人，可以调用它的 send_message 方法回复消息
    await context.bot.send_message(
        # 关于 chat_id 稍后解释
        chat_id=update.message.chat.id,
        # 回复的文本内容
        text="欢迎来到地灵殿"
    )

# 构建一个应用
application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
# 创建一个 CommandHandler 实例，当用户输入 /start 的时候，执行 start 函数
start_handler = CommandHandler("start", start)
# 将 start_handler 加到应用当中
application.add_handler(start_handler)
# 开启无限循环，监听事件
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

我们来测试一下：

图片

显然结果是成功的，不过目前这个机器人只能处理 /start 命令，如果希望它支持更多的命令，那么就定义多个 CommandHandler 即可。但是问题来了，如果我们希望这个机器人能处理普通文本的话，该怎么办呢？

from telegram import Update
from telegram.ext import (
    ApplicationBuilder, ContextTypes,
    MessageHandler, filters
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def reply(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        # 通过 update.message.text 可以拿到用户发送的消息
        text=f"古明地觉已收到，你发的内容是：{update.message.text}"
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
# 前面使用了 CommandHandler，它专门用来处理命令，第一个参数应该是字符串
# 比如第一个参数是 "start"，那么就给机器人增加了一个回复 /start 命令的功能
# 而 MessageHandler 可以用于回复所有类型的消息，比如文本、表情、图片、视频等等
# 具体能回复哪些，通过第一个参数指定。这里表示只要用户发送了文本消息，就执行 reply 函数
reply_handler = MessageHandler(filters.TEXT, reply)
application.add_handler(reply_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

测试一下：

图片

结果没有问题，并且 /start 命令也被当成普通的文本处理了，因为命令本质上就是一个文本。然后代码中的 filters，它里面除了有表示文本类型的 TEXT，还有很多其它类型。

# 命令
filters.COMMAND
# 普通文本（包括 emoji）
filters.TEXT
# Telegram 贴纸包中的贴纸
filters.Sticker.ALL
# 图片文件
filters.PHOTO
# 音频文件
filters.AUDIO
# 视频文件
filters.VIDEO
# 文档（例如 PDF、DOCX 等等）
filters.Document.ALL
# 语音（使用 Telegram 录制的语音）
filters.VOICE
# 地理位置
filters.LOCATION
# 联系人
filters.CONTACT
# 动画，通常是 GIF
filters.ANIMATION
# 通过 Telegram 的视频笔记功能录制的视频
filters.VIDEO_NOTE

# 如果希望同时支持多种类型，那么可以使用 | 进行连接
# 比如同时支持 "文本" 和 "图片"
filters.TEXT | filters.PHOTO
# 当然也可以取反，~filters.TEXT 表示除了文本以外的类型
~filters.TEXT
# | 和 ~ 都出现了，显然还剩下 &，而 & 也是支持的 
# 我们知道命令本质上就是一个以 / 开头的文本
# 如果我们希望只处理普通文本，不处理命令，该怎么办呢？
# 很简单，像下面这样指定即可，此时以 / 开头的文本（命令）会被忽略掉
filters.TEXT & ~filters.COMMAND

# 除了以上这些，filters 还支持其它类型，有兴趣可以看一下
# 当然 filters 还提供了一个 ALL，表示所有类型
filters.ALL1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

然后注意一下里面的 filters.Sticker 和 filters.Document，这两个类型比较特殊，它们内部还可以细分，这里我们就不细分了，直接 .ALL 即可。

我们来测试一下，看看这些类型消息都长什么样子。

from telegram import Update
from telegram.ext import (
    ApplicationBuilder, ContextTypes,
    MessageHandler, filters
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def get_message_type(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # 获取消息
    message = update.message
    # 获取消息类型
    if message.text:
        if message.text[0] == "/":
            message_type = "filters.COMMAND"
        else:
            message_type = "filters.TEXT"
    elif message.sticker:
        message_type = "filters.Sticker"
    elif message.photo:
        message_type = "filters.PHOTO"
    elif message.audio:
        message_type = "filters.AUDIO"
    elif message.video:
        message_type = "filters.VIDEO"
    elif message.document:
        message_type = "filters.Document"
    elif message.voice:
        message_type = "filters.VOICE"
    elif message.location:
        message_type = "filters.LOCATION"
    elif message.contact:
        message_type = "filters.CONTACT"
    elif message.animation:
        message_type = "filters.ANIMATION"
    elif message.video_note:
        message_type = "filters.VIDEO_NOTE"
    else:
        message_type = "filters.<OTHER TYPE>"
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=f"你发送的消息的类型是 {message_type}"
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
reply_handler = MessageHandler(filters.ALL, get_message_type)
application.add_handler(reply_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

我们发几条消息，让机器人告诉我们消息的类型。

图片

至于其它类型，感兴趣可以测试一下。

update 和 context

处理函数里面有两个参数，分别是 update 和 context。它们非常重要，我们来打印一下，看看长什么样子。

async def reply(update: Update, context: ContextTypes.DEFAULT_TYPE):
    pprint(update.to_dict())
    await context.bot.send_message(chat_id=update.message.chat.id,
                                   text="不想说话")

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
reply_handler = MessageHandler(filters.ALL, reply)
application.add_handler(reply_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.

下面发送一条文本消息。

图片

然后查看 update.to_dict() 的输出是什么，为了方便理解，我将字段顺序调整了一下。

{
    'message': {
        # 是否创建了频道，因为是私聊，所以为 False
        'channel_chat_created': False,
        # 聊天照片是否已被删除，私聊一般也为 False
        'delete_chat_photo': False,
        # 是否创建了群组，因为是私聊，所以为 False
        'group_chat_created': False,
        # 是否创建了超级群组，因为是私聊，所以为 False
        'supergroup_chat_created': False,
        # "发送者" 发送的消息
        # 因为发送的是文本，所以这里是 text 字段
        'text': '这是一条文本消息',
        # 消息发送的时间
        'date': 1722623118,
        # 消息的 ID
        'message_id': 84,
        # 消息发送者的信息
        'from': {
            'first_name': '小云',
            'id': 6353481551,
            'is_bot': False,
            'language_code': 'zh-hans',
            'last_name': '同学'
        },
        # chat 表示会话环境，机器人要通过 chat 判断消息应该回复给谁
        # 因为目前是和机器人私聊，所以机器人的回复对象就是消息的发送者
        # 因此里面的 first_name、last_name、id 和消息发送者是一致的
        # 但如果是群聊，那么里面的 id 字段则表示群组的 id
        # 此外还会包含一个 title 字段，表示群组的名称
        'chat': {
            'first_name': '小云',
            'last_name': '同学',
            # 不管 chat 的类型是什么，里面一定会包含 id 字段
            # 这个 id 可能是用户的 id，也可能是群组的 id
            # 总之有了这个 id，机器人就知道要将消息回复给谁
            # 所以代码中的 send_message 方法至少要包含两个参数
            # 分别是 chat_id（发送给谁）和 text（发送的内容）
            'id': 6353481551,
            # chat 的类型，定义在 filters.ChatType 中
            # ChatType.PRIVATE：私人对话
            # ChatType.GROUP：普通群组聊天
            # ChatType.SUPERGROUP：超级群组聊天
            # ChatType.GROUPS：普通群组聊天或超级群组聊天
            # ChatType.CHANNEL：频道，用于向订阅者广播消息
            'type': '<ChatType.PRIVATE>'
        },
    },
    # 每发送一条消息，会话都在更新，所以 update_id 表示更新的唯一标识符
    # 用于跟踪更新，以确保消息处理没有丢失或重复
    'update_id': 296857735
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

以上就是 update.to_dict() 的输出结果，当用户向 bot 发送消息时，Telegram 服务器会将这些数据以 JSON 的形式发送给当前的应用程序，以便 bot 可以处理和响应这些消息。当然啦，我们这里使用的库会将数据封装成 Update 对象，因此获取数据时，可以有以下两种获取方式。

chat_id = update.to_dict()["message"]["chat"]["id"]
chat_id = update.message.chat.id1.
2.

以上是当用户发送文本消息时，Telegram 发送的数据，我们再试一下其它的，比如上传一个文档。

{
    'message': {
        'channel_chat_created': False,
        'delete_chat_photo': False,
        'group_chat_created': False,
        'supergroup_chat_created': False,
        'chat': {'first_name': '小云',
                 'id': 6353481551,
                 'last_name': '同学',
                 'type': '<ChatType.PRIVATE>'},
        'date': 1722628661,
        # 因为发送的是文档，所以这里是 document 字段
        'document': {'file_id': 'BQACAgUAAxkBAANgZq06NVL6......',
                     'file_name': 'OpenAI.pdf',
                     'file_size': 2279632,
                     'file_unique_id': 'AgADLw8AAn36cFU',
                     'mime_type': 'application/pdf',
                     'thumb': {
                         'file_id': 'AAMCBQADGQEAA2BmrTo1Uv......',
                         'file_size': 22533,
                         'file_unique_id': 'AQADLw8AAn36cFVy',
                         'height': 320,
                         'width': 243},
                     'thumbnail': {
                         'file_id': 'AAMCBQADGQEAA2BmrTo1U......',
                         'file_size': 22533,
                         'file_unique_id': 'AQADLw8AAn36cFVy',
                         'height': 320,
                         'width': 243}},
        'from': {'first_name': '小云',
                 'id': 6353481551,
                 'is_bot': False,
                 'language_code': 'zh-hans',
                 'last_name': '同学'},
        'message_id': 96,
    },
    'update_id': 296857741
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

至于其它的类型也是类似的，可以自己试一下，比如上传一段视频，看看打印的输出是什么。

不过还有一个问题，就是当用户上传音频、视频、文档等，bot 如何获取它们呢？显然要依赖里面的 file_id。

async def download(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document

    file_id = document.file_id  # 文件 id
    file_size = document.file_size  # 文件大小
    file_name = document.file_name  # 文件名
    # 用户上传的文件会保存在 Telegram 服务器，我们可以基于文件 id 获取
    file_obj = await context.bot.get_file(file_id)
    # file_obj.file_path 便是文件的地址，直接下载即可
    with open(file_name, "wb") as f:
        resp = httpx.get(file_obj.file_path, proxy=PROXY)
        f.write(resp.content)
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=f"{file_name} 下载完毕，大小 {file_size} 字节"
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
download_handler = MessageHandler(filters.Document.ALL, download)
application.add_handler(download_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

我们上传几个文件试试。

图片

结果没有问题，用户上传的文件也下载到了本地。

回复富文本消息

目前机器人回复的都是普通的纯文本，但也可以回复富文本消息。

async def rich_msg(update: Update, context: ContextTypes.DEFAULT_TYPE):
    message = update.message
    if message.text == "baidu":
        text = '<a href="https://www.baidu.com">点击进入百度页面</a>'
    elif message.text == "zhihu":
        text = '<a href="https://www.zhihu.com">点击进入知乎页面</a>'
    elif message.text == "bilibili":
        text = '<a href="https://www.bilibili.com">点击进入 B 站页面</a>'
    else:
        text = 'Unsupported Website'
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=text,
        # 按照 HTML 进行解析
        parse_mode="HTML"
    )1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

测试一下：

图片

结果没有问题，另外我们看到 a 标签自带预览功能，如果不希望预览，那么也可以禁用掉。

图片

将 disable_web_page_preview 参数指定为 False，即可禁用 a 标签的预览功能。另外发送的消息除了可以按照 HTML 格式解析，还可以按照 Markdown 格式解析，将 parse_mode 参数指定为 "Markdown" 或者 "MarkdownV2" 即可。

回复其它类型的消息

目前机器人回复的都是文本，那么能不能回复音频、视频、图片呢？显然是可以的，并且它们还可以和文本一起返回。

# 发送图片
await context.bot.send_photo(
    chat_id=update.message.chat.id,
    # 可以是路径、句柄、bytes 对象
    # 已经上传到 Telegram 服务器的文件会有一个 file_id
    # 指定 file_id 也是可以的
    photo="path/to/image.jpg",
)

# 发送音频
await context.bot.send_audio(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    audio="path/to/audio.mp3"
)

# 发送视频
await context.bot.send_video(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    video="path/to/video.mp4"
)

# 发送文档
await context.bot.send_document(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    document="path/to/document.pdf"
)

# 发送语音
await context.bot.send_voice(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    voice=r"path/to/voice.ogg",
)

# 发送位置
await context.bot.send_location(
    chat_id=update.message.chat.id,
    latitude=40.4750280, lnotallow=116.2676535
)

# 发送联系人
from telegram import Contact
contact = Contact(
    phone_number='+8618510286802',
    first_name='芙兰朵露',
    # 以下两个参数也可以不指定
    last_name='斯卡雷特',
    user_id=5783657687
)
await context.bot.send_contact(
    chat_id=update.message.chat.id,
    cnotallow=contact
)

# 发送贴纸
await context.bot.send_sticker(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    sticker="CAACAgIAAxkBAAO5Zq5kRNKkIGZpH......"
)

# 发送 GIF
await context.bot.send_animation(
    chat_id=update.message.chat.id,
    # 可以是 路径、句柄、bytes 对象、file_id
    animatinotallow="CgACAgIAAxkBAAPBZq5lekVT95I......"
)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.

除了以上这些，还可以发送其它类型的消息，不过不常用，有兴趣的话可以自己看一下，这些方法都以 send_ 开头。然后我们来发几条消息，测试一下。

图片

结果没有问题。

媒体组

现在我们已经知道如何让机器人回复不同种类的消息了，但如果我想实现更复杂的功能，比如同时发送多张图片、多个视频，并且还配带文字，要怎么做呢？可能有人觉得这还不简单，写个循环不就行了，比如要发送 5 个视频，那么调用 5 次 send_video 方法不就好了。

首先这是一种方法，但循环 5 次，那么这 5 个视频是作为不同的消息分开发送的。更多时候，我们是希望作为一个整体发送，那么此时可以使用媒体组功能。

from telegram import Update, InputMediaPhoto
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def send_media_group(update: Update,
                           context: ContextTypes.DEFAULT_TYPE):
    media_group = [
        # 可以是 URL、bytes 对象、文件句柄、file_id
        InputMediaPhoto(open('satori1.png', "rb"), captinotallow="古"),
        InputMediaPhoto(open('satori2.png', "rb"), captinotallow="明"),
        InputMediaPhoto(open('satori3.png', "rb"), captinotallow="地"),
        InputMediaPhoto(open('satori4.png', "rb"), captinotallow="觉")
    ]

    # 发送媒体组
    await context.bot.send_media_group(
        chat_id=update.message.chat.id,
        media=media_group
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
download_handler = CommandHandler("satori", send_media_group)
application.add_handler(download_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

我们输入命令 /satori，应该会返回 4 张图片。

图片

结果没有问题，并且这 4 张图片是整体作为一条消息发送的。然后我们在代码中还指定了一个 caption 参数，它是做什么的呢？我们点击一下图片就知道了。

图片

点击图片放大查看时，captaion 会显示在图片下方。另外，如果发送了多张图片，但只有一张图片指定了 caption 参数，那么该 caption 会和图片一起显示，我们举例说明。

async def send_media_group(update: Update,
                           context: ContextTypes.DEFAULT_TYPE):
    caption = "+v ❥(^_-) 解锁地灵殿隐藏福利"
    media_group = [
        # 可以是 URL、bytes 对象、文件句柄、file_id
        InputMediaPhoto(open('satori1.png', "rb")),
        InputMediaPhoto(open('satori2.png', "rb")),
        InputMediaPhoto(open('satori3.png', "rb"), captinotallow=caption),
        InputMediaPhoto(open('satori4.png', "rb"))
    ]

    # 发送媒体组
    await context.bot.send_media_group(
        chat_id=update.message.chat.id,
        media=media_group
    )1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

只有一张图片指定了 caption 参数，我们看看效果。

图片

此时图片会和文字一起显示，当然你也可以不指定 caption 参数，而是在发送完图片之后，再调用一次 send_message。这种做法也是可以的，只不过此时图片和文字会作为两条消息分开显示。

以上是发送图片，除了图片之外还可以发送音频、视频、文档，并且只支持这 4 种。但要注意：它们不能混在一起发，只有图片和视频可以，我们测试一下。

from telegram import (
    Update,
    InputMediaPhoto,
    InputMediaAudio,
    InputMediaVideo,
    InputMediaDocument
)
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def send_media_group(update: Update,
                           context: ContextTypes.DEFAULT_TYPE):
    video_caption = (
        "这游戏我玩不下去了，装备喂养和贴膜就算了，"
        "但自定义词条我是真忍不了，洗不出来，根本洗不出来。"
    )
    media_group = [
        InputMediaPhoto(open("satori1.png", "rb")),
        InputMediaVideo(open("DNF 装备销毁.mp4", "rb"), 
                        captinotallow=video_caption),
        # 也支持发送音频和文档，但不能混在一起
        # InputMediaAudio(open("3rd eye.mp3", "rb")),
        # InputMediaDocument(open('OpenAI.pdf', 'rb'))
    ]

    # 发送媒体组
    await context.bot.send_media_group(
        chat_id=update.message.chat.id,
        media=media_group
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
download_handler = CommandHandler("test_media_group", send_media_group)
application.add_handler(download_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.

测试一下：

图片

结果正常，只是因为视频和图片是一起返回的，所以没有预览功能，需要点击之后才会播放。并且我们只给视频指定了 caption 参数，所以文字直接显示在了下方，如果媒体组中有多个 caption，那么就不会单独显示了，需要点击放大之后才能看到。

当然啦，如果你不需要同时发送多个媒体文件，那么就没必要调用 send_media_group 方法了，直接使用之前的方法即可。

send_photo；
send_audio；
send_video；
send_document；

这些方法一次性只能发送一个媒体文件，比如发送视频。

async def send_video(update: Update, context: ContextTypes.DEFAULT_TYPE):
    video_caption = (
        "这游戏我玩不下去了，装备喂养和贴膜就算了，"
        "但自定义词条我是真忍不了，洗不出来，根本洗不出来。"
    )
    await context.bot.send_video(
        chat_id=update.message.chat.id,
        video="DNF 装备销毁.mp4",
        captinotallow=video_caption,
        # 让 caption 显示在上方，默认显示在下方
        show_caption_above_media=True,
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
download_handler = CommandHandler("destroy", send_video)
application.add_handler(download_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

测试一下：

图片

怎么样，是不是很有趣呢？另外 caption 还可以是富文本，只需将 parse_mode 参数指定为 "HTML"、"Markdown" 或 "MarkdownV2" 即可。

关于机器人如何回复不同种类的消息，以及同时回复多条消息，相关内容我们就说完了。有了这些功能，我们的机器人就已经很强大了，你也可以把它和公司的业务结合起来。

比如创建一个命令：/get，它的功能如下。

图片

然后在代码中添加一个 CommandHandler("get", get_table)，便可让用户通过 Telegram 查询数据库表，当然这里只是打个比方，具体怎么做取决于你的想法。另外多说一句，如果你希望输入 / 之后能像上面那样有提示，那么需要通过 BotFather 进行设置。

图片

要强调的是，这种方式只是起到一个提示作用，提示机器人支持 /get 命令。但机器人实际上是否支持，取决于代码中是否为机器人实现了 /get。所以当我们在代码中为机器人添加完命令之后，可以再通过 Edit Commands 进行设置，这样当用户输入 / 之后，机器人有哪些命令以及描述都会显示出来。

当然啦，如果你不通过 Edit Commands 进行设置的话，也是可以的，只是用户输入 / 之后不会有提示罢了，但命令是会回复的，只要在代码中实现了。同理，如果通过 Edit Commands 设置了，但代码中没实现，那么该命令也不会有效果。

自定义按钮

虽然目前的机器人已经很强大了，但是还不够，我们看一下 BotFather。

图片

你会发现它下面带了很多的按钮，点击按钮之后会执行相应的逻辑，那我们要怎么实现这些按钮呢？

from telegram import (
    Update,
    InlineKeyboardMarkup,
    InlineKeyboardButton,
)
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def add_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = "作为<i>程序猿</i>，你最喜欢哪种编程语言呢？"
    # 设置按钮
    reply_markup = InlineKeyboardMarkup([
        # 第一行
        [InlineKeyboardButton(text="Python", url="https://www.python.org")],
        # 第二行
        [InlineKeyboardButton(text="Golang", url="https://golang.org")],
        # 第三行
        [InlineKeyboardButton(text="Rust", url="https://www.rust-lang.org")],
        # 第四行
        [InlineKeyboardButton(text="Zig", url="https://ziglang.org")],
    ])
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=text,
        parse_mode="HTML",
        reply_markup=reply_markup
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
download_handler = CommandHandler("language", add_button)
application.add_handler(download_handler)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

测试一下：

图片

此时按钮就实现了，由于在 InlineKeyboardButton 里面指定的是 url，所以这是跳转按钮，点击之后会打开指定的页面。并且按钮的右上角还有一个小箭头，表示按钮是跳转按钮。

但除了跳转按钮之外，还有回调按钮，也就是点击按钮之后会执行回调函数，我们举例说明。

from telegram import (
    Update,
    InlineKeyboardMarkup,
    InlineKeyboardButton,
)
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler,
    CallbackQueryHandler,
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

async def add_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = "o(╥﹏╥)o😂╭(╯^╰)╮"
    # 设置按钮
    reply_markup = InlineKeyboardMarkup([
        # 第一行，两个跳转按钮
        [InlineKeyboardButton(text="百度", url="https://www.baidu.com"),
         InlineKeyboardButton(text="谷歌", url="https://www.google.com"),],
        # 第二行，两个回调按钮
        [InlineKeyboardButton(text="油管", callback_data="youtube"),
         InlineKeyboardButton(text="B站", callback_data="bilibili"),],
    ])
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=text,
        reply_markup=reply_markup
    )

async def callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # 当点击回调按钮时，会执行相应的回调函数
    cb_data = update.callback_query.data  # 回调按钮中指定的 callback_data
    if cb_data == "youtube":
        text = "欢迎来到油管"
    elif cb_data == "bilibili":
        text = "欢迎来到 B 站"
    else:
        text = "Unknown Website"
    await context.bot.send_message(
        # 注意：这里是 update.callback_query.message.chat.id
        chat_id=update.callback_query.message.chat.id,
        text=text
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
# 添加 Handler
application.add_handler(
    CommandHandler("website", add_button)
)
# 处理回调的 Handler，否则点击按钮不会有效果
application.add_handler(
    CallbackQueryHandler(callback)
)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.

测试一下效果：

图片

点击油管和 B站的时候会执行回调函数，结果没有问题。但是我们发现，这些文字是单独发送的，那可不可以本地修改呢，也就是将按钮上方的文字替换掉。答案是可以的，我们来测试一下。

from telegram import (
    Update,
    InlineKeyboardMarkup,
    InlineKeyboardButton,
)
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler,
    CallbackQueryHandler,
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"

def get_reply_markup():
    reply_markup = InlineKeyboardMarkup([
        [InlineKeyboardButton(text="古明地觉", callback_data="satori")],
        [InlineKeyboardButton(text="古明地恋", callback_data="koishi")],
        [InlineKeyboardButton(text="雾雨魔理沙", callback_data="marisa")],
        [InlineKeyboardButton(text="琪露诺", callback_data="cirno")],
    ])
    return reply_markup

async def add_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = "点击想要攻略的角色"
    await context.bot.send_message(
        chat_id=update.message.chat.id,
        text=text,
        reply_markup=get_reply_markup()
    )

async def callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    cb_data = update.callback_query.data
    if cb_data == "satori":
        img = "你将要攻略古明地觉"
    elif cb_data == "koishi":
        img = "你将要攻略古明地恋"
    elif cb_data == "marisa":
        img = "你将要攻略雾雨魔理沙"
    elif cb_data == "cirno":
        img = "你将要攻略琪露诺"
    else:
        raise RuntimeError("Unreachable")
    # 点击按钮之后，要对上方的文字进行修改，替换成其它内容
    # 所以这相当于编辑已有消息，既然要编辑，那么除了 chat_id 之外还要指定 message_id
    # 因为是回调，所以要多调用一次 callback_query
    message_id = update.callback_query.message.message_id
    chat_id = update.callback_query.message.chat.id
    # 调用 edit_message_media 方法，编辑消息
    await context.bot.edit_message_text(
        text=img,
        chat_id=chat_id,
        message_id=message_id,
        reply_markup=get_reply_markup()
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
application.add_handler(
    CommandHandler("gogogo", add_button)
)
application.add_handler(
    CallbackQueryHandler(callback)
)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

测试一下：

图片

然后点击按钮，看看文字内容有没有发生改变。

图片

点击按钮，文字的内容被替换了。所以当机器人回复一条消息时，只需知道 chat_id 即可。但如果是修改某条消息，那么除了 chat_id 之外，还要知道 message_id。

修改文字调用的方法是 edit_message_text，但除了修改文字之外，还可以修改其它内容。

图片

比如修改媒体文件，修改媒体文件的 caption，修改按钮等等。

修改消息综合案例

关于修改消息我们已经知道怎么做了，下面来做一个综合案例。假设当前有 N 张图片，用户默认会看到第一张，然后点击按钮可以查看下一张图片，当然也可以查看上一张。那么这个需求怎么实现呢？

from telegram import (
    Update,
    InlineKeyboardMarkup,
    InlineKeyboardButton,
    InputMediaPhoto
)
from telegram.ext import (
    ApplicationBuilder,
    ContextTypes,
    CommandHandler,
    CallbackQueryHandler,
)
from proxy import PROXY

BOT_API_TOKEN = "6485526535:AAEvGr9EDqtc4QPehkgohH6gczOTO5RIYRE"
# 这里我就用 4 张图片为例
IMAGES = ["satori.png", "koishi.png", "marisa.png", "cirno.png"]

def get_navigation_buttons(index):
    reply_markup = InlineKeyboardMarkup([
        [InlineKeyboardButton(text="上一张", callback_data=f"prev:{index}"),
         InlineKeyboardButton(text="下一张", callback_data=f"next:{index}")],
    ])
    return reply_markup

async def get_pic(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # 默认发送第一张图片
    await context.bot.send_photo(
        chat_id=update.message.chat.id,
        photo=IMAGES[0],
        captinotallow=f"正在浏览第 1 / {len(IMAGES)} 张图片",
        reply_markup=get_navigation_buttons(0)
    )

async def callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # 点击按钮，触发回调
    op, index = update.callback_query.data.split(":")
    if op == "prev":
        index = (int(index) - 1) % len(IMAGES)
    else:  # op == "next"
        index = (int(index) + 1) % len(IMAGES)
    # int(index) 减 1 和加 1 之后，就是上一张图片和下一张图片的索引
    # 但这里又对 len(IMAGES) 进行取模，主要是为了实现循环浏览
    # 比如第一张的上一张会返回最后一张，最后一张的下一张会返回第一张
    await context.bot.edit_message_media(
        chat_id=update.callback_query.message.chat.id,
        message_id=update.callback_query.message.message_id,
        media=InputMediaPhoto(
            open(IMAGES[index], "rb"),
            captinotallow=f"正在浏览第 {index + 1} / {len(IMAGES)} 张图片"
        ),
        reply_markup=get_navigation_buttons(index)
    )

application = ApplicationBuilder().token(BOT_API_TOKEN).proxy(PROXY).build()
application.add_handler(
    CommandHandler("get_pic", get_pic)
)
application.add_handler(
    CallbackQueryHandler(callback)
)
application.run_polling()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.

测试一下：

图片

此时点击按钮下一张，就会返回下一张图片，同理也可以返回上一张图片。如果已经是最后一张图片了，那么点击下一张，会返回第一张图片。

但问题来了，程序要如何得知用户正在浏览的是第几张图片呢？显然要借助于按钮。在创建按钮时，参数 callback_data 里面保存了 index，当点击下一张或上一张时，更新 index，返回新的图片，同时刷新按钮。

以上返回的是图片，你也可以换成视频，并增加一些点赞、是否喜欢等按钮。

小结

以上就是 Python 操作 Telegram 相关的内容，当然这里只介绍了一部分，还有一些更复杂的功能没有说，比如按钮的嵌套等等。另外目前是用户和机器人一对一私聊，但我们还可以创建一个组，让机器人回复组成员的消息。而关于这些内容，后续有空补上，本文就先到这儿，写的有点累了。