2022年 11月 5日

手把手教你实现一个 Python 多线程下载器

前言

下载文件是我们生活中的一个常见的需求，因此衍生的下载工具也非常多，各有各的优势以及不足之处。作为一个编程爱好者，我喜欢去研究它们是怎么实现文件下载功能的。

我的主要使用的编程语言是 Python ，所以今天我将以 Python 为切入点带你一步步实现一个简易的文件下载器。 这个下载器将会分为几个版本

单线程不带进度条的下载器

单线程带进度条的下载器

多线程带进度条的下载器

如果你感兴趣，我们可以开始了！

懒得看过程的可以直接到文末取有详细注释的代码（开始之前这部分要看）。

开始之前

  1. Python版本要求

Python 3.7 及以上

2. 需要安装的库

tqdm

requests

retry

multitasking

库的安装方法是：打开 cmd（命令提示符或者其他终端工具），输入以下代码

pip install tqdm requests multitasking retry

输入完毕，按 Enter 键执行代码，等待 successfully 出现即可

正文

简易版文件下载器

基础知识

使用 requests 库发起请求

  1. # 导入requests 库
  2. import requests
  3. # 请求链接
  4. url = 'https://www.baidu.com/'
  5. # 请求头
  6. headers = {
  7.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  8. }
  9. # 发起请求
  10. response = requests.get(url, headers=headers)
  11.  
  12. # 响应状态码
  13. response.status_code
  14. # 200
  15.  
  16. # 响应的文本内容
  17. response.text
  18. '''
  19. <!DOCTYPE html><!--STATUS OK-->\n\n\n 
  20. ...
  21.  
  22. '''
  23.  
  24. # 响应内容
  25. response.content
  26. '''
  27. b'<!DOCTYPE html><!--STATUS OK-->\n\n\n 
  28. ...
  29.  
  30. '''
  31.  
  32. # 响应头
  33. response.headers
  34. '''
  35. {'Bdpagetype': '1', 'Bdqid': '0xa4413421000728b1'
  36. ...
  37. '''

向文件中写入网络响应内容

  1. # 导入requests 库
  2. import requests
  3. # 请求链接
  4. url = 'https://www.baidu.com/'
  5. # 请求头
  6. headers = {
  7.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  8. }
  9. # 发起请求
  10. response = requests.get(url, headers=headers)
  11.  
  12. content = response.content
  13. file_name = 'hello.html'
  14. # 以 wb 的模式打开文件
  15. with open(file_name, mode='wb') as f:
  16.     # 写入响应内容
  17.     f.write(content)
  18. print(f'写入文件成功！文件名 {file_name}')

实例操作

通过这学习上面的基础，我们实现了一个简易的文件下载器，下面继续来测试一个下载一个文件，文件直链如下

https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe

实例代码

  1. # 导入requests 库
  2. import requests
  3. # 文件下载直链
  4. url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  5. # 文件名
  6. file_name = 'BaiduNetdisk_7.2.8.9.exe'
  7. # 请求头
  8. headers = {
  9.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  10. }
  11. print('正在下载文件......')
  12. # 发起请求
  13. response = requests.get(url, headers=headers)
  14.  
  15. content = response.content
  16.  
  17. # 以 wb 的模式打开文件
  18. with open(file_name, mode='wb') as f:
  19.     # 写入响应内容
  20.     f.write(content)
  21. print(f'文件下载成功！文件名 {file_name}')

运行输出

  1. 正在下载文件......
  2. 文件下载成功！文件名 BaiduNetdisk_7.2.8.9.exe

打开代码运行目录即可看到文件：BaiduNetdisk_7.2.8.9.exe

带进度条的文件下载器

基础知识

获取文件大小 不难知道，要做一个进度条展示下载进度，我们得事先知道文件的大小以及每次写入文件的大小。还是以这个文件链接为例，展示如何获取待下载的文件大小

  1. # 导入requests 库
  2. import requests
  3. # 文件下载直链
  4. url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  5. # 请求头
  6. headers = {
  7.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  8. }
  9.  
  10. # 发起 head 请求，即只会获取响应头部信息
  11. response = requests.head(url, headers=headers)
  12. # 文件大小，以 B 为单位
  13. file_size = response.headers.get('Content-Length')
  14. if file_size is not None:
  15.     file_size = int(file_size)
  16. print('文件大小:', file_size, 'B')

代码运行输出

文件大小: 67765560 B

分块获取响应内容

上面的文件大小为：67765560 B。如果我们一次性下载 67765560 B 这么大的文件的话，进度条的跨度显然太大了，那么做这么一个进度条的意义并不大，所以我们需要考虑通过一个循环，分多次连续地读取响应直到读取完毕。

  1. # 导入requests 库
  2. import requests
  3. # 文件下载直链
  4. url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  5. # 请求头
  6. headers = {
  7.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  8. }
  9.  
  10. # 发起 head 请求，即只会获取响应头部信息
  11. head = requests.head(url, headers=headers)
  12. # 文件大小，以 B 为单位
  13. file_size = head.headers.get('Content-Length')
  14. if file_size is not None:
  15.     file_size = int(file_size)
  16. response = requests.get(url, headers=headers, stream=True)
  17. # 一块文件的大小
  18. chunk_size = 1024
  19. # 记录已经读取的文件大小
  20. read = 0
  21. for chunk in response.iter_content(chunk_size=chunk_size):
  22.     read += chunk_size
  23.     read = min(read, file_size)
  24.     print(f'已读取: {read} 总大小: {file_size}')

部分输出结果

  1. 已读取: 1024 总大小: 67765560
  2. 已读取: 2048 总大小: 67765560
  3. 已读取: 3072 总大小: 67765560
  4. 已读取: 4096 总大小: 67765560
  5. 已读取: 5120 总大小: 67765560
  6. 已读取: 6144 总大小: 67765560
  7. 已读取: 7168 总大小: 67765560
  8. 已读取: 8192 总大小: 67765560

通过以上操作，我们成功实现分段、连续下载文件。但是输出显然太多了，我们更希望有一个单行的进度条。 这里不得不说到 tqdm 这个进度条库

一个 tqdm 的使用例子

  1. import time
  2. from tqdm import tqdm
  3. total = 100
  4. for _ in tqdm(range(total)):
  5.     time.sleep(0.1)

在终端或者jupyter运行上面的代码即可看到下面的动图

如果想一次更新指定次数个进度怎么办呢？比如说进度总共是 100 ，每 10 个刷新一次进度

实现代码例子如下

  1. import time
  2. from tqdm import tqdm
  3. # 总进度
  4. total = 100
  5. # 每次刷新的进度
  6. step = 10
  7. # 总共要刷新的次数
  8. flush_count = total//step
  9. bar = tqdm(total=total)
  10. for _ in range(flush_count):
  11.     time.sleep(0.1)
  12.     bar.update(step)
  13. bar.close()

以上代码可实现 每 10 个单位刷新一次直进度满 100

下面来给我们的下载器加进度条吧！

  1. # 导入requests 库
  2. import requests
  3. # 导入 tqdm
  4. from tqdm import tqdm
  5. # 文件下载直链
  6. url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  7. # 请求头
  8. headers = {
  9.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  10. }
  11. file_name = 'BaiduNetdisk_7.2.8.9.exe'
  12. # 发起 head 请求，即只会获取响应头部信息
  13. head = requests.head(url, headers=headers)
  14. # 文件大小，以 B 为单位
  15. file_size = head.headers.get('Content-Length')
  16. if file_size is not None:
  17.     file_size = int(file_size)
  18. response = requests.get(url, headers=headers, stream=True)
  19. # 一块文件的大小
  20. chunk_size = 1024
  21. bar = tqdm(total=file_size, desc=f'下载文件 {file_name}')
  22. with open(file_name, mode='wb') as f:
  23.     # 写入分块文件
  24.     for chunk in response.iter_content(chunk_size=chunk_size):
  25.         f.write(chunk)
  26.         bar.update(chunk_size)
  27. # 关闭进度条
  28. bar.close()

代码运行过程如下

就这样，我们成功实现了一个带进度条的文件下载器！ 为了调用方便，我们可以考虑把它封装为函数，这里我直接附上代码了

实例代码

函数形式的带进度条的单线程文件下载器

  1. # 导入requests 库
  2. import requests
  3. # 导入 tqdm
  4. from tqdm import tqdm
  5.  
  6.  
  7. def download(url: str, file_name: str):
  8.     '''
  9.     根据文件直链和文件名下载文件
  11.     Parameters
  12.     ----------
  13.     url: 文件直链
  14.     file_name : 文件名（文件路径）
  16.     '''
  17.     # 文件下载直链
  18.     # 请求头
  19.     headers = {
  20.         'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  21.     }
  22.  
  23.     # 发起 head 请求，即只会获取响应头部信息
  24.     head = requests.head(url, headers=headers)
  25.     # 文件大小，以 B 为单位
  26.     file_size = head.headers.get('Content-Length')
  27.     if file_size is not None:
  28.         file_size = int(file_size)
  29.     response = requests.get(url, headers=headers, stream=True)
  30.     # 一块文件的大小
  31.     chunk_size = 1024
  32.     bar = tqdm(total=file_size, desc=f'下载文件 {file_name}')
  33.     with open(file_name, mode='wb') as f:
  34.         # 写入分块文件
  35.         for chunk in response.iter_content(chunk_size=chunk_size):
  36.             f.write(chunk)
  37.             bar.update(chunk_size)
  38.     # 关闭进度条
  39.     bar.close()
  40.  
  41.  
  42. if "__main__" == __name__:
  43.     url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  44.     file_name = 'BaiduNetdisk_7.2.8.9.exe'
  45.     download(url, file_name)

多线程文件下载器

絮絮叨叨

早些年还没会编程的时候，我喜欢寻找各种高速的下载工具，比如说简单易用的 IDM 以及命令行多线程下载工具 Aria2。它们的下载速度确实让人惊艳。通过查询一些资料，我大概了解到它们下载速度快的原因之一是它们对同一个服务器建立多个连接，然后分块请求响应的内容，于是人多力量大，下载速度自然就提高了。

基础知识

假设我们有下面这么一段代码

单线程程序

  1. import time
  2.  
  3.  
  4. def say(number: int):
  5.     print(number)
  6.     time.sleep(0.5)
  7.  
  8.  
  9. for i in range(5):
  10.     say(i)

代码运行输出

  1. 0
  2. 1
  3. 2
  4. 3
  5. 4

不难发现，该代码实现的功能是每间隔 0.5 秒输出一次数字，一共重复 5 次。所以这段程序耗时在 2.5 秒左右。 如果我们使用多线程呢？譬如对于每一次操作均开启一个线程，结果会是怎么样？

为了简化多线程的写法，我查阅了相关资料，发现了一个很好用的多线程库

multitasking

如果你没有安装它，则可以使用 pip 工具，在终端运行下面的代码进行安装（前提是 pip 安装目录在环电脑境变量里面）

pip install multitasking

使用它之后，我们只需要给自定义的函数前面加上一行代码（装饰器）即可在调用函数时，为被调用的这个函数开启新的线程。下面是一个使用例子

以上代码的多线程版本如下

  1. import time
  2. # 导入用于多线程操作的库
  3. # 这样子仅需要在自定义的函数前面使用装饰器即可将函数开启新的线程
  4. import multitasking
  5. import signal
  6. # 按快捷键 ctrl + c 终止已开启的全部线程
  7. signal.signal(signal.SIGINT, multitasking.killall)
  8.  
  9. # 多线程装饰器
  10.  
  11.  
  12. @multitasking.task
  13. def say(number: int):
  14.     print(number)
  15.     time.sleep(0.5)
  16.  
  17.  
  18. start_time = time.time()
  19. for i in range(5):
  20.     say(i)
  21. # 等待全部线程执行完毕
  22. multitasking.wait_for_tasks()
  23. end_time = time.time()
  24. print('耗时:', end_time-start_time, '秒')

代码运行输出

  1. 0
  2. 1
  3. 2
  4. 3
  5. 4
  6. 耗时: 0.5063784122467041 秒

同样是每 0.5 秒输出一个数字，上面的代码因为使用多线程，耗时只有 0.5 秒左右，而之前的单线程版本耗时是 2.5 秒左右。

这里面用了一个装饰器，要展开的话稍微有些麻烦，感兴趣的先自己去了解或者与我交流吧。在这篇文章中，我们只需要掌握怎么简单地使用它来完成一个多线程操作即可。

示例操作

回顾之前写的单线程版本下载器，我们知道怎么获取待下载的文件大小以及如何分块下载。注意上面的分块下载是仅有一个线程在操作的，譬如文件大小为： 1000 B，每次下载 100 B，那么单线程会连续地每次读取 100 B 的内容，直到没有内容可读取。

为了能让多线程下载同一个文件，我们需要为每一个线程分配属于它自己的任务，比如说要下载大小为 100 B的文件，那么线程一可以负责下载 0-50 B，线程二负责下载 50-100 B，这样子分两个线程来下载。

要实现任务以上的任务分配。我们自然得学会怎么将一个数字分为多个区间，下面以将 100 分为每一块 20 为例，展示怎么实现这样子的功能

  1. # 总大小
  2. total = 100
  3. # 每一块的大小
  4. step = 20
  5. # 分多块
  6. parts = [(start, min(start+step,total)) for start in range(0, total, step)]
  7. print(parts)

运行上面的代码，会达到以下输出

[(0, 20), (20, 40), (40, 60), (60, 80), (80, 100)]

可以看到，我们成功地完成了较为完美的切割操作！ 同样地，为了能够更好地维护代码，我们可以尝试把它抽取为函数，示例如下

  1. from __future__ import annotations
  2.  
  3.  
  4. def split(start: int, end: int, step: int) -> list[tuple[int, int]]:
  5.     '''
  6.     将指定区间的数切割为多个区间
  8.     Parameters
  9.     ----------
  10.     start :起始位置
  11.     end : 终止位置
  12.     step : 区间长度
  14.     Return
  15.     ------
  16.     区间元组构成的列表
  17.     '''
  18.     # 分多块
  19.     parts = [(start, min(start+step, end))
  20.              for start in range(0, end, step)]
  21.  
  22.     return parts
  23.  
  24.  
  25. if "__main__" == __name__:
  26.     # 起始位置
  27.     start = 1
  28.     # 终止位置
  29.     total = 102
  30.     # 区间长度
  31.     step = 20
  32.     parts = split(start, total, step)
  33.     print(parts)

以上操作是为了后续分段下载文件做准备

下载部分文件

下面我将以下面这个链接为例

https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe

演示如何下载某一部分的文件

示例代码

  1. import requests
  2. # 待下载部分的文件起始位置
  3. start = 0
  4. # 待下载部分的文件终止位置
  5. end = 1000
  6. # 每次读取的大小
  7. chunk_size = 128
  8. # 记录下载的位置
  9. seek = start
  10. # 请求头
  11. headers = {
  12.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  13. }
  14. # 这是核心！设定下载的范围
  15. headers['Range'] = f'bytes={start}-{end}'
  16. # 下载链接
  17. url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  18.  
  19. response = requests.get(url, headers=headers, stream=True)
  20. for chunk in response.iter_content(chunk_size=chunk_size):
  21.     _seek = min(seek+chunk_size, end)
  22.     print(f'下载: {seek}-{_seek}')
  23.     seek = _seek

代码运行输出

  1. 下载: 0-128
  2. 下载: 128-256 
  3. 下载: 256-384 
  4. 下载: 384-512 
  5. 下载: 512-640 
  6. 下载: 640-768 
  7. 下载: 768-896 
  8. 下载: 896-1000

有了以上基础，我们来尝试把之前的单线程下载器修改为多线程的（我还没想好怎么一步步教，先贴有详细注释的代码吧，后续更新）

最终代码（带进度条的多线程下载器）

  1. from __future__ import annotations
  2. # 用于显示进度条
  3. from tqdm import tqdm
  4. # 用于发起网络请求
  5. import requests
  6. # 用于多线程操作
  7. import multitasking
  8. import signal
  9. # 导入 retry 库以方便进行下载出错重试
  10. from retry import retry
  11. signal.signal(signal.SIGINT, multitasking.killall)
  12.  
  13. # 请求头
  14. headers = {
  15.     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
  16. }
  17. # 定义 1 MB 多少为 B
  18. MB = 1024**2
  19.  
  20.  
  21. def split(start: int, end: int, step: int) -> list[tuple[int, int]]:
  22.     # 分多块
  23.     parts = [(start, min(start+step, end))
  24.              for start in range(0, end, step)]
  25.     return parts
  26.  
  27.  
  28. def get_file_size(url: str, raise_error: bool = False) -> int:
  29.     '''
  30.     获取文件大小
  32.     Parameters
  33.     ----------
  34.     url : 文件直链
  35.     raise_error : 如果无法获取文件大小，是否引发错误
  37.     Return
  38.     ------
  39.     文件大小（B为单位）
  40.     如果不支持则会报错
  42.     '''
  43.     response = requests.head(url)
  44.     file_size = response.headers.get('Content-Length')
  45.     if file_size is None:
  46.         if raise_error is True:
  47.             raise ValueError('该文件不支持多线程分段下载！')
  48.         return file_size
  49.     return int(file_size)
  50.  
  51.  
  52. def download(url: str, file_name: str, retry_times: int = 3, each_size=16*MB) -> None:
  53.     '''
  54.     根据文件直链和文件名下载文件
  56.     Parameters
  57.     ----------
  58.     url : 文件直链
  59.     file_name : 文件名
  60.     retry_times: 可选的，每次连接失败重试次数
  61.     Return
  62.     ------
  63.     None
  65.     '''
  66.     f = open(file_name, 'wb')
  67.     file_size = get_file_size(url)
  68.  
  69.     @retry(tries=retry_times)
  70.     @multitasking.task
  71.     def start_download(start: int, end: int) -> None:
  72.         '''
  73.         根据文件起止位置下载文件
  75.         Parameters
  76.         ----------
  77.         start : 开始位置
  78.         end : 结束位置
  79.         '''
  80.         _headers = headers.copy()
  81.         # 分段下载的核心
  82.         _headers['Range'] = f'bytes={start}-{end}'
  83.         # 发起请求并获取响应（流式）
  84.         response = session.get(url, headers=_headers, stream=True)
  85.         # 每次读取的流式响应大小
  86.         chunk_size = 128
  87.         # 暂存已获取的响应，后续循环写入
  88.         chunks = []
  89.         for chunk in response.iter_content(chunk_size=chunk_size):
  90.             # 暂存获取的响应
  91.             chunks.append(chunk)
  92.             # 更新进度条
  93.             bar.update(chunk_size)
  94.         f.seek(start)
  95.         for chunk in chunks:
  96.             f.write(chunk)
  97.         # 释放已写入的资源
  98.         del chunks
  99.  
  100.     session = requests.Session()
  101.     # 分块文件如果比文件大，就取文件大小为分块大小
  102.     each_size = min(each_size, file_size)
  103.  
  104.     # 分块
  105.     parts = split(0, file_size, each_size)
  106.     print(f'分块数：{len(parts)}')
  107.     # 创建进度条
  108.     bar = tqdm(total=file_size, desc=f'下载文件：{file_name}')
  109.     for part in parts:
  110.         start, end = part
  111.         start_download(start, end)
  112.     # 等待全部线程结束
  113.     multitasking.wait_for_tasks()
  114.     f.close()
  115.     bar.close()
  116.  
  117.  
  118. if "__main__" == __name__:
  119.     # url = 'https://mirrors.tuna.tsinghua.edu.cn/pypi/web/packages/0d/ea/f936c14b6e886221e53354e1992d0c4e0eb9566fcc70201047bb664ce777/tensorflow-2.3.1-cp37-cp37m-macosx_10_9_x86_64.whl#sha256=1f72edee9d2e8861edbb9e082608fd21de7113580b3fdaa4e194b472c2e196d0'
  120.     url = 'https://issuecdn.baidupcs.com/issue/netdisk/yunguanjia/BaiduNetdisk_7.2.8.9.exe'
  121.     file_name = 'BaiduNetdisk_7.2.8.9.exe'
  122.     # 开始下载文件
  123.     download(url, file_name)

代码运行过程

写在最后

本文内容丰富，涉及到的主要知识有：文件读写、发起网络请求、多线程操作、代码出错重试。由浅入深，层层递进，最终实现了一个简易的带进度条的多线程下载器。