• Python爬虫实战第二例【二】

    零.前言：

    本文章借鉴：Python爬虫实战（五）：根据关键字爬取某度图片批量下载到本地（附上完整源码）_python爬虫下载图片-CSDN博客

     大佬的文章里面有API的获取，在这里我就不赘述了。

    一.实战目标：

    对百度的图片进行爬取，利用代理IP实现批量下载。

    二.实现效果：

    实现批量下载指定内容的图片，存放到指定文件夹中：

     三.代码实现

    3.1分析网页

    右键网页，点击检查，进入我们的Google开发者工具。

    筛选出我们需要的文件（通过查找载荷寻找）

     接下来，只需要构建我们的载荷：

     3.2获取图片的URL链接

    1. def get_img_url(keyword):
    2.     #接口连接
    3.     url = "https://image.baidu.com/search/acjson"
    4.     #请求头
    5.     header = {
    6.         "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
    7.     }
    8.     #params参数
    9.     params = {
    10.         "tn": "resultjson_com",
    11.         "logid": "7831763171415538646",
    12.         "ipn": "rj",
    13.         "ct": "201326592",
    14.         "is":"",
    15.         "fp":"result",
    16.         "fr":"",
    17.         "word":f"{keyword}",
    18.         "queryWord":f"{keyword}",
    19.         "cl":"2",
    20.         "lm":"-1",
    21.         "ie":"utf - 8",
    22.         "oe":"utf - 8",
    23.         "adpicid":"",
    24.         "st":"",
    25.         "z":"",
    26.         "ic":"",
    27.         "hd":"",
    28.         "latest":"",
    29.         "copyright":"",
    30.         "s":"",
    31.         "se":"",
    32.         "tab":"",
    33.         "width":"",
    34.         "height":"",
    35.         "face":"",
    36.         "istype":"",
    37.         "qc":"",
    38.         "nc":"1",
    39.         "expermode":"",
    40.         "nojc":"",
    41.         "isAsync":"",
    42.         "pn":"1",
    43.         "rn":"100",
    44.         "gsm":"78",
    45.         "1709030173834":""
    46.     }
    47.     #创建get请求
    48.     r = requests.get(url=url,params=params,headers=header)
    49.     #切换编码格式
    50.     r.encoding = "utf-8"
    51.     json_dict = r.json()
    52.     #定位数据
    53.     data_list = json_dict["data"]
    54.     #存储链接
    55.     url_list = []
    56.     #循环取链接
    57.     for i in data_list:
    58.         if i:
    59.             u = i["thumbURL"]
    60.             url_list.append(u)
    61.     return url_list

    结果： 

     3.3实现代理

    1. def get_ip():
    2.     #代理API
    3.     url = "你的代理API"
    4.     while 1:
    5.         try:
    6.             r = requests.get(url,timeout=10)
    7.         except:
    8.             continue
    9.         ip = r.text.strip()
    10.         if "请求过于频繁" in ip:
    11.             print("IP请求频繁")
    12.             time.sleep(1)
    13.             continue
    14.         break
    15.     proxies = {
    16.         "https": f"{ip}"
    17.     }
    18.     return proxies

    效果：

     

     3.4实现爬虫

    1. def get_down_img(img_url_list):
    2.     #创建文件夹
    3.     if not os.path.isdir("鞠婧祎"):
    4.         os.mkdir("鞠婧祎")
    5.     #定义图片编号
    6.     n = 0
    7.     header = {
    8.         "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
    9.     }
    10.     times = 0
    11.     while times < len(img_url_list):
    12.         #获取代理IP
    13.         proxies = get_ip()
    14.         try:
    15.             img_data = requests.get(url=img_url_list[times],headers=header,proxies=proxies,timeout=2)
    16.         except Exception as e:
    17.             print(e)
    18.             continue
    19.         #拼接图片存放地址和名字
    20.         img_path = "鞠婧祎/" + str(n) + ".jpg"
    21.         #写入图片
    22.         with open(img_path,"wb") as f:
    23.             f.write(img_data.content)
    24.         n = n + 1
    25.         times += 1

     四、优化

    上面基本实现了批量爬取图片的目的，但是在实际使用中可能会因为代理IP的质量问题，网络问题，导致爬取效率低下，在这里作者给出几点优化的空间：

    1.设置timeout超时时间（秒/S）

    2.使用requests.sessions类，构建一个sessions对象，设置连接重试次数。

    3.使用多线程，分批爬取

    具体实现，可以等作者后面慢慢更新，挖个大坑，记得催更。。。

    五、全部代码

    1. import requests
    2. import time
    3. import  os
    4.  
    5. def get_img_url(keyword):
    6.     #接口连接
    7.     url = "https://image.baidu.com/search/acjson"
    8.     #请求头
    9.     header = {
    10.         "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
    11.     }
    12.     #params参数
    13.     params = {
    14.         "tn": "resultjson_com",
    15.         "logid": "7831763171415538646",
    16.         "ipn": "rj",
    17.         "ct": "201326592",
    18.         "is":"",
    19.         "fp":"result",
    20.         "fr":"",
    21.         "word":f"{keyword}",
    22.         "queryWord":f"{keyword}",
    23.         "cl":"2",
    24.         "lm":"-1",
    25.         "ie":"utf - 8",
    26.         "oe":"utf - 8",
    27.         "adpicid":"",
    28.         "st":"",
    29.         "z":"",
    30.         "ic":"",
    31.         "hd":"",
    32.         "latest":"",
    33.         "copyright":"",
    34.         "s":"",
    35.         "se":"",
    36.         "tab":"",
    37.         "width":"",
    38.         "height":"",
    39.         "face":"",
    40.         "istype":"",
    41.         "qc":"",
    42.         "nc":"1",
    43.         "expermode":"",
    44.         "nojc":"",
    45.         "isAsync":"",
    46.         "pn":"1",
    47.         "rn":"100",
    48.         "gsm":"78",
    49.         "1709030173834":""
    50.     }
    51.     #创建get请求
    52.     r = requests.get(url=url,params=params,headers=header)
    53.     #切换编码格式
    54.     r.encoding = "utf-8"
    55.     json_dict = r.json()
    56.     #定位数据
    57.     data_list = json_dict["data"]
    58.     #存储链接
    59.     url_list = []
    60.     #循环取链接
    61.     for i in data_list:
    62.         if i:
    63.             u = i["thumbURL"]
    64.             url_list.append(u)
    65.             print(u)
    66.     return url_list
    67.  
    68. def get_ip():
    69.     #代理API
    70.     url = "你的API"
    71.     while 1:
    72.         try:
    73.             r = requests.get(url,timeout=10)
    74.         except:
    75.             continue
    76.         ip = r.text.strip()
    77.         if "请求过于频繁" in ip:
    78.             print("IP请求频繁")
    79.             time.sleep(1)
    80.             continue
    81.         break
    82.     proxies = {
    83.         "https": f"{ip}"
    84.     }
    85.     return proxies
    86.  
    87. def get_down_img(img_url_list):
    88.     #创建文件夹
    89.     if not os.path.isdir("鞠婧祎"):
    90.         os.mkdir("鞠婧祎")
    91.     #定义图片编号
    92.     n = 0
    93.     header = {
    94.         "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
    95.     }
    96.     times = 0
    97.     while times < len(img_url_list):
    98.         #获取代理IP
    99.         proxies = get_ip()
    100.         try:
    101.             img_data = requests.get(url=img_url_list[times],headers=header,proxies=proxies,timeout=2)
    102.         except Exception as e:
    103.             print(e)
    104.             continue
    105.         #拼接图片存放地址和名字
    106.         img_path = "鞠婧祎/" + str(n) + ".jpg"
    107.         #写入图片
    108.         with open(img_path,"wb") as f:
    109.             f.write(img_data.content)
    110.         n = n + 1
    111.         times += 1
    112.  
    113. if __name__ == "__main__":
    114.     url_list = get_img_url("鞠婧祎")
    115.     get_down_img(url_list)

    六、前置文章

    有些读者可能不太懂一些爬虫的知识，在这里作者给出部分文章，方便读者理解：

    关于Cookie的浅谈-CSDN博客

    JSON简介以及如何在Python中使用JSON-CSDN博客

    Python爬虫实战第一例【一】-CSDN博客

  • 相关阅读:
    网格数据生成函数meshgrid
    我的创作纪念日
    c++读取inf文件，判断版本是否一致
    JAVA【Maven的下载和初次使用】
    Http客户端--Feign简介
    深入标签模板字面量
    量化交易是什么意思，量化到底是怎么赚钱的？
    雅迪、哈啰为什么都在做高端两轮电车
    Ubuntu 20.04.3 LTS 安装打印服务器 局域网发现系统服务 共享给 windows 10/11 使用
    [附源码]Python计算机毕业设计Django兴达五金日杂批发商店管理系统
  • 原文地址：https://blog.csdn.net/zheshiyangyang/article/details/136331841