参考: http://www.pythontab.com/html/2014/pythonjichu_0121/681.html
参考: http://blog.csdn.net/supercooly/article/details/51046561
参考: http://blog.topspeedsnail.com/archives/8462
python编写断点续传下载软件：
https://www.leavesongs.com/PYTHON/resume-download-from-break-point-tool-by-python.html

Python 模块 requests 爬取图片：https://blog.csdn.net/freeking101/article/details/60769496

Python 下载文件的三种方法

当然你也可以利用 ftplib 从ftp站点下载文件。此外 Python 还提供了另外一种方法 requests。

下面来看看三种方法是如何来下载文件的：

方法 一 ：( 使用 urlopen() 方法 )

urlopen(url[, data[, proxies]]) ：创建一个表示远程 url 的类文件对象，然后像本地文件一样操作这个类文件对象来获取远程数据。

• url 表示远程数据的路径，一般是网址；
• data 表示以 post 方式提交到 url 的数据(提交数据的两种方式：post 与 get )
• proxies 用于设置代理。

urlopen 返回 一个类文件对象，它提供了如下方法：

• read() , readline() , readlines() , fileno() , close() ：这些方法的使用方式与文件对象完全一样;
• info()：返回一个 httplib.HTTPMessage 对象，表示远程服务器返回的头信息
• getcode()：返回 Http 状态码。如果是 http 请求，200 表示请求成功完成，404 表示网址未找到；
• geturl()：返回请求的 url；

示例代码 1：

# -*- coding: utf-8 -*-from urllib.request import urlopenresponse = urlopen('https://www.baidu.com/')
print(response.info())     # get header information from remote server
print(response.getcode())  # get status code
print(response.geturl())   # get request url# get all content on url page
html_byte = urlopen('https://www.baidu.com/').read()  
html_str = html_byte.decode('utf-8')
print(html_str)img_url = 'https://img9.doubanio.com/view/celebrity/s_ratio_celebrity/public/p28424.webp'
response = urlopen(img_url)
with open('./img.jpg', 'wb') as f:f.write(response.read())
pass

示例代码 2：

# -*- coding: utf-8 -*-import urllib.request
import urllib.parse
import json"""
利用有道翻译进行在线翻译
"""def translate(word=None):# 目标URLtarget_url = "http://fanyi.youdao.com/translate?smartresult=dict&smartresult=rule&smartresult=ugc&sessionFrom=null"# 用户自定义表单，word 表示的是用户要翻译的内容。这里使用的是dict类型，也可以使用元组列表（已经试过的）。data = dict()data['type'] = 'AUTO'data['i'] = wordsdata['doctype'] = 'json'data['xmlVersion'] = '1.8'data['keyfrom'] = 'fanyi.web'data['ue'] = 'UTF-8'data['action'] = 'FY_BY_CLICKBUTTON'data['typoResult'] = 'true'# 将自定义 data 转换成标准格式data = urllib.parse.urlencode(data).encode('utf-8')# 发送用户请求html = urllib.request.urlopen(target_url, data)# 读取并解码内容rst = html.read().decode("utf-8")rst_dict = json.loads(rst)return rst_dict['translateResult'][0][0]['tgt']passif __name__ == "__main__":print("输入字母q表示退出")while True:words = input("请输入要查询的单词或句子:\n")if words == 'q':breakresult = translate(words)print(f"翻译结果是:{result}")

方法 二：（ 使用 urlretrieve 方法 ）

urlretrieve() 方法直接将远程数据下载到本地。

urlretrieve(url, filename=None, reporthook=None, data=None)

• url：下载链接地址
• filename：指定了保存本地路径（如果参数未指定，urllib会生成一个临时文件保存数据。）
• reporthook：一个回调函数，当连接上服务器、以及相应的数据块传输完毕时会触发该回调，可以利用这个回调函数来显示当前的下载进度。
• data：指 post 到服务器的数据，该方法返回一个包含两个元素的(filename, headers) 元组，filename 表示保存到本地的路径，header 表示服务器的响应头
• header：表示服务器的响应头。

示例代码 1：下载并保存图片

# -*- coding: utf-8 -*-from urllib.request import urlretrieveprint("downloading with urllib")
img_url = 'https://img9.doubanio.com/view/celebrity/s_ratio_celebrity/public/p28424.webp'
urlretrieve(img_url, "./img.jpg")

示例代码 2：将 baidu 的 html 抓取到本地，保存在 ''./baidu.html" 文件中，同时显示下载的进度。

# -*- coding: utf-8 -*-import os
from urllib.request import urlretrievedef loading(block_num, block_size, total_size):"""回调函数: 数据传输时自动调用:param block_num: 已经传输的数据块数目:param block_size: 每个数据块字节:param total_size: 总字节:return:"""percent = int(100 * block_num * block_size / total_size)if percent > 100:percent = 100print("正在下载>>>{}%".format(percent))import timetime.sleep(0.5)if __name__ == '__main__':url = 'http://www.baidu.com'current_path = os.path.abspath('.')work_path = os.path.join(current_path, 'baidu.html')urlretrieve(url, work_path, loading)pass

示例代码 3：爬取百度贴吧一些小图片  

# -*- coding: utf-8 -*-import re
from urllib.request import urlretrieve, urlopendef download_img(html=None):reg_str = re.compile(r'img.*?src="(.*?)"')img_url_list = re.findall(reg_str, html)index = 0for img_url in img_url_list:if 'tiebapic' in img_url:index += 1print(img_url)urlretrieve(img_url, f'./{index}.jpg')if __name__ == '__main__':# input_url = input('input url:')input_url = 'https://tieba.baidu.com/p/6679682935'response = urlopen(input_url)html_str = response.read().decode('utf-8')download_img(html_str)

方法 三：( 使用 requests 包 )

Python requests 库 的 用法：https://blog.csdn.net/freeking101/article/details/60868350

# -*- coding: utf-8 -*-import requestsdef download_img():print("downloading with requests")# test_url = 'http://www.pythontab.com/test/demo.zip'# r = requests.get(test_url)# with open("./demo.zip", "wb") as ff:#     ff.write(r.content)img_url = 'https://img9.doubanio.com/view/celebrity/s_ratio_celebrity/public/p28424.webp'r = requests.get(img_url)with open("./img.jpg", "wb") as ff:ff.write(r.content)if __name__ == '__main__':download_img()

使用 requests 模块显示下载进度

1. 相关资料

请求关键参数：stream=True。默认情况下，当你进行网络请求后，响应体会立即被下载。你可以通过 stream 参数覆盖这个行为，推迟下载响应体直到访问 Response.content 属性。

tarball_url = 'https://github.com/kennethreitz/requests/tarball/master'
r = requests.get(tarball_url, stream=True)

此时仅有响应头被下载下来了，连接保持打开状态，因此允许我们根据条件获取内容:

if int(r.headers['content-length']) < TOO_LONG:content = r.content...

进一步使用 Response.iter_content 和 Response.iter_lines 方法来控制工作流，或者以 Response.raw 从底层 urllib3 的 urllib3.HTTPResponse

from contextlib import closingwith closing(requests.get('http://httpbin.org/get', stream=True)) as r:# Do things with the response here.

保持活动状态（持久连接） 
归功于urllib3，同一会话内的持久连接是完全自动处理的，同一会话内发出的任何请求都会自动复用恰当的连接！

注意：只有当响应体的所有数据被读取完毕时，连接才会被释放到连接池；所以确保将 stream 设置为 False 或读取 Response 对象的 content 属性。

2. 下载文件并显示进度条

在 Python3 中，print()方法的默认结束符（end=’\n’），当调用完之后，光标自动切换到下一行，此时就不能更新原有输出。

将结束符改为 “\r” ，输出完成之后，光标会回到行首，并不换行。此时再次调用 print() 方法，就会更新这一行输出了。

结束符也可以使用 “\d”，为退格符，光标回退一格，可以使用多个，按需求回退。

在结束这一行输出时，将结束符改回 “\n” 或者不指定使用默认

下面是一个格式化的进度条显示模块。代码如下：

#!/usr/bin/env python3import requests
from contextlib import closing"""
作者：微微寒
链接：https://www.zhihu.com/question/41132103/answer/93438156
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
"""class ProgressBar(object):def __init__(self, title, count=0.0, run_status=None, fin_status=None,total=100.0, unit='', sep='/', chunk_size=1.0):super(ProgressBar, self).__init__()self.info = "[%s] %s %.2f %s %s %.2f %s"self.title = titleself.total = totalself.count = countself.chunk_size = chunk_sizeself.status = run_status or ""self.fin_status = fin_status or " " * len(self.status)self.unit = unitself.seq = sepdef __get_info(self):# 【名称】状态 进度 单位 分割线 总数 单位_info = self.info % (self.title, self.status, self.count/self.chunk_size, self.unit, self.seq, self.total/self.chunk_size, self.unit)return _infodef refresh(self, count=1, status=None):self.count += count# if status is not None:self.status = status or self.statusend_str = "\r"if self.count >= self.total:end_str = '\n'self.status = status or self.fin_statusprint(self.__get_info(), end=end_str)def main():with closing(requests.get("http://www.futurecrew.com/skaven/song_files/mp3/razorback.mp3", stream=True)) as response:chunk_size = 1024content_size = int(response.headers['content-length'])progress = ProgressBar("razorback", total=content_size, unit="KB", chunk_size=chunk_size, run_status="正在下载", fin_status="下载完成")# chunk_size = chunk_size < content_size and chunk_size or content_sizewith open('./file.mp3', "wb") as file:for data in response.iter_content(chunk_size=chunk_size):file.write(data)progress.refresh(count=len(data))if __name__ == '__main__':main()

Python 编写断点续传下载软件

另一种方法是调用 curl 之类支持断点续传的下载工具。后续补充

一、HTTP 断点续传原理

其实HTTP断点续传原理比较简单，在HTTP数据包中，可以增加Range头，这个头以字节为单位指定请求的范围，来下载范围内的字节流。如：

如上图勾下来的地方，我们发送数据包时选定请求的内容的范围，返回包即获得相应长度的内容。所以，我们在下载的时候，可以将目标文件分成很多“小块”，每次下载一小块（用Range标明小块的范围），直到把所有小块下载完。

当网络中断，或出错导致下载终止时，我们只需要记录下已经下载了哪些“小块”，还没有下载哪些。下次下载的时候在Range处填写未下载的小块的范围即可，这样就能构成一个断点续传。

其实像迅雷这种多线程下载器也是同样的原理。将目标文件分成一些小块，再分配给不同线程去下载，最后整合再检查完整性即可。

二、Python 下载文件实现方式

我们仍然使用之前介绍过的 requests 库作为 HTTP 请求库。

先看看这段文档：http://docs.python-requests.org/en/latest/user/advanced/#body-content-workflow，当请求时设置steam=True的时候就不会立即关闭连接，而我们以流的形式读取body，直到所有信息读取完全或者调用Response.close关闭连接。

所以，如果要下载大文件的话，就将 steam 设置为True，慢慢下载，而不是等整个文件下载完才返回。

stackoverflow上有同学给出了一个简单的下载 demo：

#!/usr/bin/env python3import requestsdef download_file(url):local_filename = url.split('/')[-1]# NOTE the stream=True parameterr = requests.get(url, stream=True)with open(local_filename, 'wb') as f:for chunk in r.iter_content(chunk_size=1024): if chunk:  # filter out keep-alive new chunksf.write(chunk)f.flush()return local_filename

这基本上就是我们核心的下载代码了。

当使用 requests 的 get 下载大文件/数据时，建议使用使用 stream 模式。

当把 get 函数的 stream 参数设置成 False 时，它会立即开始下载文件并放到内存中，如果文件过大，有可能导致内存不足。

当把 get 函数的 stream 参数设置成 True 时，它不会立即开始下载，当你使用 iter_content 或 iter_lines 遍历内容或访问内容属性时才开始下载。需要注意一点：文件没有下载之前，它也需要保持连接。

iter_content：一块一块的遍历要下载的内容
iter_lines：一行一行的遍历要下载的内容
使用上面两个函数下载大文件可以防止占用过多的内存，因为每次只下载小部分数据。

示例代码：r = requests.get(url_file, stream=True)
f = open("file_path", "wb")
for chunk in r.iter_content(chunk_size=512):
if chunk:
f.write(chunk)

三、断点续传结合大文件下载

现在结合这两个知识点写个小程序：支持断点续传的下载器。

我们可以先考虑一下需要注意的有哪些点，或者可以添加的功能有哪些：

1. 用户自定义性：可以定义cookie、referer、user-agent。如某些下载站检查用户登录才允许下载等情况。
2. 很多服务端不支持断点续传，如何判断？
3. 怎么去表达进度条？
4. 如何得知文件的总大小？使用HEAD请求？那么服务器不支持HEAD请求怎么办？
5. 下载后的文件名怎么处理？还要考虑windows不允许哪些字符做文件名。（header中可能有filename，url中也有filename，用户还可以自己指定filename）
6. 如何去分块，是否加入多线程。

其实想一下还是有很多疑虑，而且有些地方可能一时还解决不了。先大概想一下各个问题的答案：

1. headers可以由用户自定义
2. 正式下载之前先HEAD请求，得到服务器status code是否是206，header中是否有Range-content等标志，判断是否支持断点续传。
3. 可以先不使用进度条，只显示当前下载大小和总大小
4. 在HEAD请求中匹配出Range-content中的文件总大小，或获得content-length大小（当不支持断点续传的时候会返回总content-length）。如果不支持HEAD请求或没有content-type就设置总大小为0.（总之不会妨碍下载即可）
5. 文件名优先级：用户自定义 > header中content-disposition > url中的定义，为了避免麻烦，我这里和linux下的wget一样，忽略content-disposition的定义。如果用户不指定保存的用户名的话，就以url中最后一个“/”后的内容作为用户名。
6. 为了稳定和简单，不做多线程了。如果不做多线程的话，我们分块就可以按照很小来分，如1KB，然后从头开始下载，一K一K这样往后填充。这样避免了很多麻烦。当下载中断的时候，我们只需要简单查看当前已经下载了多少字节，就可以从这个字节后一个开始继续下载。
解决了这些疑问，我们就开始动笔了。实际上，疑问并不是在未动笔的时候干想出来的，基本都是我写了一半突然发现的问题。

解决了这些疑问，我们就开始动笔了。实际上，疑问并不是在未动笔的时候干想出来的，基本都是我写了一半突然发现的问题。

def download(self, url, filename, headers = {}):finished = Falseblock = self.config['block']local_filename = self.remove_nonchars(filename)tmp_filename = local_filename + '.downtmp'if self.support_continue(url):  # 支持断点续传try:with open(tmp_filename, 'rb') as fin:self.size = int(fin.read()) + 1except:self.touch(tmp_filename)finally:headers['Range'] = "bytes=%d-" % (self.size, )else:self.touch(tmp_filename)self.touch(local_filename)size = self.sizetotal = self.totalr = requests.get(url, stream = True, verify = False, headers = headers)if total > 0:print "[+] Size: %dKB" % (total / 1024)else:print "[+] Size: None"start_t = time.time()with open(local_filename, 'ab') as f:try:for chunk in r.iter_content(chunk_size = block): if chunk:f.write(chunk)size += len(chunk)f.flush()sys.stdout.write('\b' * 64 + 'Now: %d, Total: %s' % (size, total))sys.stdout.flush()finished = Trueos.remove(tmp_filename)spend = int(time.time() - start_t)speed = int(size / 1024 / spend)sys.stdout.write('\nDownload Finished!\nTotal Time: %ss, Download Speed: %sk/s\n' % (spend, speed))sys.stdout.flush()except:import tracebackprint traceback.print_exc()print "\nDownload pause.\n"finally:if not finished:with open(tmp_filename, 'wb') as ftmp:ftmp.write(str(size))

这是下载的方法。首先if语句调用self.support_continue(url)判断是否支持断点续传。如果支持则从一个临时文件中读取当前已经下载了多少字节，如果不存在这个文件则会抛出错误，那么size默认=0，说明一个字节都没有下载。

然后就请求url，获得下载连接，for循环下载。这个时候我们得抓住异常，一旦出现异常，不能让程序退出，而是正常将当前已下载字节size写入临时文件中。下次再次下载的时候读取这个文件，将Range设置成bytes=(size+1)-，也就是从当前字节的后一个字节开始到结束的范围。从这个范围开始下载，来实现一个断点续传。

判断是否支持断点续传的方法还兼顾了一个获得目标文件大小的功能：

def support_continue(self, url):headers = {'Range': 'bytes=0-4'}try:r = requests.head(url, headers = headers)crange = r.headers['content-range']self.total = int(re.match(ur'^bytes 0-4/(\d+)$', crange).group(1))return Trueexcept:passtry:self.total = int(r.headers['content-length'])except:self.total = 0return False

用正则匹配出大小，获得直接获取 headers['content-length']，获得将其设置为0.

核心代码基本上就是这些，再就是一些设置。github：https://github.com/phith0n/py-wget/blob/master/py-wget.py

运行程序，获取 emlog 最新的安装包：

中间我按 Ctrl + C人工打断了下载进程，但之后还是继续下载，实现了“断点续传”。

但在我实际测试过程中，并不是那么多请求可以断点续传的，所以我对于不支持断点续传的文件这样处理：重新下载。

下载后的压缩包正常解压，也充分证明了下载的完整性：

动态图演示

github 地址：一个支持断点续传的小下载器：py-wget：https://github.com/phith0n/py-wget

多线程下载文件

示例代码：

# 在python3下测试import sys
import requests
import threading
import datetime# 传入的命令行参数，要下载文件的url
url = sys.argv[1]def Handler(start, end, url, filename):headers = {'Range': 'bytes=%d-%d' % (start, end)}r = requests.get(url, headers=headers, stream=True)# 写入文件对应位置with open(filename, "r+b") as fp:fp.seek(start)var = fp.tell()fp.write(r.content)def download_file(url, num_thread = 5):r = requests.head(url)try:file_name = url.split('/')[-1]file_size = int(r.headers['content-length'])   # Content-Length获得文件主体的大小，当http服务器使用Connection:keep-alive时，不支持Content-Lengthexcept:print("检查URL，或不支持对线程下载")return#  创建一个和要下载文件一样大小的文件fp = open(file_name, "wb")fp.truncate(file_size)fp.close()# 启动多线程写文件part = file_size // num_thread  # 如果不能整除，最后一块应该多几个字节for i in range(num_thread):start = part * iif i == num_thread - 1:   # 最后一块end = file_sizeelse:end = start + partt = threading.Thread(target=Handler, kwargs={'start': start, 'end': end, 'url': url, 'filename': file_name})t.setDaemon(True)t.start()# 等待所有线程下载完成main_thread = threading.current_thread()for t in threading.enumerate():if t is main_thread:continuet.join()print('%s 下载完成' % file_name)if __name__ == '__main__':start = datetime.datetime.now().replace(microsecond=0)  download_file(url)end = datetime.datetime.now().replace(microsecond=0)print("用时: ", end='')print(end-start)

Python下载图片、音乐、视频

示例代码：

# -*- coding:utf-8 -*-import re
import requests
from contextlib import closing
from lxml import etreeclass Spider(object):""" crawl image """def __init__(self):self.index = 0self.url = "http://www.xiaohuar.com"self.proxies = {"http": "http://172.17.18.80:8080", "https": "https://172.17.18.80:8080"}passdef download_image(self, image_url):real_url = self.url + image_urlprint "downloading the {0} image".format(self.index)with open("{0}.jpg".format(self.index), 'wb') as f:self.index += 1f.write(requests.get(real_url, proxies=self.proxies).content)passpassdef start_crawl(self):start_url = "http://www.xiaohuar.com/hua/"r = requests.get(start_url, proxies=self.proxies)if r.status_code == 200:temp = r.content.decode("gbk")html = etree.HTML(temp)links = html.xpath('//div[@class="item_t"]//img/@src')map(self.download_image, links)# next_page_url = html.xpath('//div[@class="page_num"]//a/text()')# print next_page_url[-1]# print next_page_url[-2]# print next_page_url[-3]next_page_url = html.xpath(u'//div[@class="page_num"]//a[contains(text(),"下一页")]/@href')page_num = 2while next_page_url:print "download {0} page images".format(page_num)r_next = requests.get(next_page_url[0], proxies=self.proxies)if r_next.status_code == 200:html = etree.HTML(r_next.content.decode("gbk"))links = html.xpath('//div[@class="item_t"]//img/@src')map(self.download_image, links)try:next_page_url = html.xpath(u'//div[@class="page_num"]//a[contains(text(),"下一页")]/@href')except BaseException as e:next_page_url = Noneprint epage_num += 1passelse:print "response status code : {0}".format(r_next.status_code)passelse:print "response status code : {0}".format(r.status_code)passclass ProgressBar(object):def __init__(self, title, count=0.0, run_status=None, fin_status=None, total=100.0, unit='', sep='/', chunk_size=1.0):super(ProgressBar, self).__init__()self.info = "[%s] %s %.2f %s %s %.2f %s"self.title = titleself.total = totalself.count = countself.chunk_size = chunk_sizeself.status = run_status or ""self.fin_status = fin_status or " " * len(self.status)self.unit = unitself.seq = sepdef __get_info(self):# 【名称】状态 进度 单位 分割线 总数 单位_info = self.info % (self.title, self.status,self.count / self.chunk_size, self.unit, self.seq, self.total / self.chunk_size, self.unit)return _infodef refresh(self, count=1, status=None):self.count += count# if status is not None:self.status = status or self.statusend_str = "\r"if self.count >= self.total:end_str = '\n'self.status = status or self.fin_statusprint self.__get_info(), end_strdef download_mp4(video_url):print video_urltry:with closing(requests.get(video_url.strip().decode(), stream=True)) as response:chunk_size = 1024with open('./{0}'.format(video_url.split('/')[-1]), "wb") as f:for data in response.iter_content(chunk_size=chunk_size):f.write(data)f.flush()except BaseException as e:print ereturndef mp4():proxies = {"http": "http://172.17.18.80:8080", "https": "https://172.17.18.80:8080"}url = "http://www.budejie.com/video/"r = requests.get(url)print r.urlif r.status_code == 200:print "status_code:{0}".format(r.status_code)content = r.contentvideo_urls_compile = re.compile("http://.*?\.mp4")video_urls = re.findall(video_urls_compile, content)print len(video_urls)# print video_urlsmap(download_mp4, video_urls)else:print "status_code:{0}".format(r.status_code)def mp3():proxies = {"http": "http://172.17.18.80:8080", "https": "https://172.17.18.80:8080"}with closing(requests.get("http://www.futurecrew.com/skaven/song_files/mp3/razorback.mp3", proxies=proxies, stream=True)) as response:chunk_size = 1024content_size = int(response.headers['content-length'])progress = ProgressBar("razorback", total=content_size, unit="KB", chunk_size=chunk_size, run_status="正在下载",fin_status="下载完成")# chunk_size = chunk_size < content_size and chunk_size or content_sizewith open('./file.mp3', "wb") as f:for data in response.iter_content(chunk_size=chunk_size):f.write(data)progress.refresh(count=len(data))if __name__ == "__main__":t = Spider()t.start_crawl()   mp3()mp4()   pass

下载视频的效果

另一个下载图片示例代码：

( github 地址：https://github.com/injetlee/Python/blob/master/爬虫集合/meizitu.py )

包括了创建文件夹，利用多线程爬取，设置的是5个线程，可以根据自己机器自己来设置一下。

import requests
import os
import time
import threading
from bs4 import BeautifulSoupdef download_page(url):'''用于下载页面'''headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"}r = requests.get(url, headers=headers)r.encoding = 'gb2312'return r.textdef get_pic_list(html):'''获取每个页面的套图列表,之后循环调用get_pic函数获取图片'''soup = BeautifulSoup(html, 'html.parser')pic_list = soup.find_all('li', class_='wp-item')for i in pic_list:a_tag = i.find('h3', class_='tit').find('a')link = a_tag.get('href')text = a_tag.get_text()get_pic(link, text)def get_pic(link, text):'''获取当前页面的图片,并保存'''html = download_page(link)  # 下载界面soup = BeautifulSoup(html, 'html.parser')pic_list = soup.find('div', id="picture").find_all('img')  # 找到界面所有图片headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"}create_dir('pic/{}'.format(text))for i in pic_list:pic_link = i.get('src')  # 拿到图片的具体 urlr = requests.get(pic_link, headers=headers)  # 下载图片，之后保存到文件with open('pic/{}/{}'.format(text, link.split('/')[-1]), 'wb') as f:f.write(r.content)time.sleep(1)   # 休息一下，不要给网站太大压力，避免被封def create_dir(name):if not os.path.exists(name):os.makedirs(name)def execute(url):page_html = download_page(url)get_pic_list(page_html)def main():create_dir('pic')queue = [i for i in range(1, 72)]   # 构造 url 链接 页码。threads = []while len(queue) > 0:for thread in threads:if not thread.is_alive():threads.remove(thread)while len(threads) < 5 and len(queue) > 0:   # 最大线程数设置为 5cur_page = queue.pop(0)url = 'http://meizitu.com/a/more_{}.html'.format(cur_page)thread = threading.Thread(target=execute, args=(url,))thread.setDaemon(True)thread.start()print('{}正在下载{}页'.format(threading.current_thread().name, cur_page))threads.append(thread)if __name__ == '__main__':main()