devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

selenium小练习：自写利用 selenium 下载Google高清图片、大众点评自动传头像/评论_selenium下载图片

作者：代码探险家 | 2024-07-09 02:38:23

赞

踩

selenium下载图片

一、 selenium 下载高清图片

1、版本介绍

  1. python 3.7.4 
  2. selenium = 3.141.0
  3. chromedriver=84.0.4147.30

2、保存 base64 图片格式代码

  1. src="data:image/gif;base64,R0lGODlhMwAxAIAAAAAAAPyH5BAAAAAAALAAAAAAzADEAAAK8jI+pBr0PowytzotTtbm/DTqQ6C3hGX
  2. ElcraA9jIr66ozVpM3nseUvYP1UEHF0FUUHkNJxhLZfEJNvol06tzwrgd
  3. LbXsFZYmSMPnHLB+zNJFbq15+SOf50+6rG7lKOjwV1ibGdhHYRVYVJ9Wn
  4. k2HWtLdIWMSH9lfyODZoZTb4xdnpxQSEF9oyOWIqp6gaI9pI1Qo7BijbF
  5. ZkoaAtEeiiLeKn72xM7vMZofJy8zJys2UxsCT3kO229LH1tXAAAOw=="

     提取出其中的base64地址（即 base64, 后的内容）然后base64解码，然后保存为图片

  1. url='''R0lGODlhMwAxAIAAAAAAAPyH5BAAAAAAALAAAAAAzADEAAAK8jI+pBr0PowytzotTtbm/DTqQ6C3hGX
  2. ElcraA9jIr66ozVpM3nseUvYP1UEHF0FUUHkNJxhLZfEJNvol06tzwrgd
  3. LbXsFZYmSMPnHLB+zNJFbq15+SOf50+6rG7lKOjwV1ibGdhHYRVYVJ9Wn
  4. k2HWtLdIWMSH9lfyODZoZTb4xdnpxQSEF9oyOWIqp6gaI9pI1Qo7BijbF
  5. ZkoaAtEeiiLeKn72xM7vMZofJy8zJys2UxsCT3kO229LH1tXAAAOw=='''
  6. import base64 
  7. img=base64.urlsafe_b64decode(url + '=' * (4 - len(url) % 4))
  8. fh = open("imageToSave.png", "wb")
  9. fh.write(img)
  10. fh.close()
'
运行

3、selenium 对某个元素截图保存 .screenshot()方法

由于Google网络的原因，一些外网的图片高清图加载失败，导致下载的是缩减图，这一部分数据通过截取详情图片的元素来解决。
  1. from selenium import webdriver
  2. from selenium.webdriver.common.by import By
  3. from selenium.webdriver.support.ui import WebDriverWait
  4. from selenium.webdriver.support import expected_conditions as EC
  5. import time
  6. import os
  7. import re
  8. import requests
  9. import urllib3
  10. urllib3.disable_warnings() # 去除警告
  11.  
  12. options = webdriver.ChromeOptions()
  13. # 增加无头
  14. options.add_argument('--disable-gpu')
  15. # 防止被网站识别,开发者模式
  16. options.add_experimental_option('excludeSwitches', ['enable-automation'])
  17.  
  18. browser = webdriver.Chrome(options=options)
  19. browser.maximize_window()
  20.  
  21. browser.implicitly_wait(10)
  22. browser.get('https://www.google.com/search?q=%E6%BF%80%E5%87%B8&tbm=isch&hl=zh-CN&hl=zh-CN#imgrc=1lpdzdDLl6rN9M')
  23. ele = browser.find_element_by_xpath('//*[@id="Sva75c"]/div/div/div[3]/div[2]/c-wiz/div[1]/div[1]/div/div[2]/a/img')
  24. print(ele.get_attribute('src'))
  25.  
  26. # 截图保存
  27. ele.screenshot('1.png')

4 、selenium 常常遇见的反爬虫几个策略

         主要参考：

                         Selenium反反爬-滑块验证

                         Selenium 系列篇（六）：反反爬篇

                         使用 mitmproxy + python 做拦截代理

                         如何突破网站对selenium的屏蔽

                         Selenium-webdriver绕开反爬虫机制的4种方法

                         网站对Selenium的屏蔽

                         

5、爬高清图片的代码

缺点：慢，效果受网络的影响，现在没有更好的方案...
  1. 2个代码都未解决的问题：
  2.  
  3.     ① 使用 无头 浏览器在 ‘点击更多’ 的点击事件可能不能触发
  4.     ② 使用 无头 浏览器在 缩减图片截图时有的图片截的图可能有点问题
  5.  
  6. 希望有知道怎么回事或者怎么解决的老铁请留个言，感谢！

    （1）高清、缩减、base64 格式图片

  1. from selenium import webdriver
  2. from selenium.webdriver.common.by import By
  3. from selenium.webdriver.support.ui import WebDriverWait
  4. from selenium.webdriver.support import expected_conditions as EC
  5. from selenium.common.exceptions import ElementNotInteractableException
  6. from selenium.webdriver.common.keys import Keys
  7. from requests.adapters import HTTPAdapter
  8. import argparse
  9.  
  10. import time
  11. import os
  12. import re
  13. import requests
  14. import urllib3
  15. urllib3.disable_warnings()  # 去除警告
  16.  
  17.  
  18. class GoogleSpider():
  19.  
  20.     def __init__(self, url, keyword, time_sleep, target_dir):
  21.         self.url = url
  22.         self.keyword = keyword
  23.         self.time_sleep = time_sleep  # 等待高清图片加载的时间
  24.         self.target_dir = target_dir
  25.         self.img_tmp_dir = os.path.join(self.target_dir,
  26.                                         self.add_timestamp(self.keyword))
  27.         if not os.path.exists(self.img_tmp_dir):
  28.             os.makedirs(self.img_tmp_dir)
  29.  
  30.         self.head = None  # 浏览器是否存在头
  31.         self.implicitly_wait_time = 5  # 隐形等待时间
  32.         self.js_slide_wait = 30  # js 滑动窗口等待时间
  33.  
  34.     def clean_str(self, str_):
  35.         """
  36.         清除字符串为图片命名时不合规的字符
  37.         :return:
  38.         """
  39.         str_ = re.sub('[^\u4e00-\u9fa5A-Za-z\d]', '', str_)
  40.         return str_
  41.  
  42.     def add_timestamp(self, str_):
  43.         """
  44.         为字符串添加时间搓,保证字符串唯一不重复性
  45.         :param str_: str
  46.         :return:
  47.         """
  48.         assert isinstance(str_, str)
  49.         time_str = str(time.time()).replace('.', '')
  50.         str_ = str_ + time_str
  51.         return str_
  52.  
  53.     def create_browser(self,head):
  54.         """
  55.         创建一个浏览器的对象
  56.         :param headless: 是否使用无头浏览器
  57.         :return:
  58.         """
  59.         self.head = head
  60.  
  61.         options = webdriver.ChromeOptions()
  62.         # 增加无头
  63.         if not self.head:
  64.             options.add_argument('--headless')
  65.             # 无头浏览器设置窗口大小，主要是为了解决截屏时，如果窗口比较小，截屏时会获得较小的图片
  66.             options.add_argument("--window-size=4000,1600")
  67.  
  68.         options.add_argument('--disable-gpu')
  69.  
  70.         # 关闭自动测试状态显示 // 会导致浏览器报：请停用开发者模式
  71.         # window.navigator.webdriver还是返回True,当返回undefined时应该才可行。
  72.         options.add_experimental_option("excludeSwitches", ['enable-automation'])
  73.         # 关闭开发者模式
  74.         options.add_experimental_option("useAutomationExtension", False)
  75.         # 设置中文
  76.         options.add_argument('lang=zh_CN.UTF-8')
  77.         # 更换头部
  78.         options.add_argument(
  79.             'user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36"')
  80.         # 部署项目在linux时，其驱动会要求这个参数
  81.         options.add_argument('--no-sandbox')
  82.  
  83.         browser = webdriver.Chrome(options=options)
  84.         if self.head:
  85.             browser.maximize_window()
  86.  
  87.         # 设置执行js代码转换模式，反反爬虫检测 window.navigator.webdriver 属性换为 undefined
  88.         browser.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
  89.             "source": """Object.defineProperty(navigator, 'webdriver', {get: () => undefined})""",
  90.         })
  91.  
  92.         return browser
  93.  
  94.     def get_main_page_info(self, browser):
  95.         """
  96.         获取主页面且拉至最底部,且获取所有图片详情页的链接地址
  97.         :return:
  98.         """
  99.         browser.get(self.url)
  100.         browser.implicitly_wait(self.implicitly_wait_time)
  101.  
  102.         # TODO 滑动到底的js代码
  103.         js = """ 
  104.                    (function () { 
  105.                        var y = document.documentElement.scrollTop; 
  106.                        var step = 100; 
  107.                        window.scroll(0, y); 
  108.                        function f() { 
  109.                            if (y < document.body.scrollHeight) { 
  110.                                y += step; 
  111.                                window.scroll(0, y); 
  112.                                setTimeout(f, 100); //每两次间隔滑动的时间 100ms
  114.                            }
  115.                            else { 
  116.                                window.scroll(0, y); 
  117.                                document.title += "scroll-done"; 
  118.                            } 
  119.                        } 
  120.                        setTimeout(f, 1000); // 执行函数等待时间 1000ms
  121.                    })(); 
  122.             """
  123.  
  124.         # TODO 执行滑动到底的操作
  125.         browser.execute_script(js)
  126.         # 等待窗口滑动结束
  127.         for i in range(self.js_slide_wait):
  128.             print('\rJS窗口滑动中,请等待 {}s,现在是第 {}s，网络好可下调 '.format(self.js_slide_wait, i + 1), end='', flush=True)
  129.             time.sleep(1)
  130.         print()
  131.  
  132.         # TODO 点击 ‘ 加载更多的选项 ’
  133.         try:
  134.             browser.find_element_by_xpath(
  135.                 '//div[@id="islmp"]/.//div[@jsname="i3y3Ic"]/.//input[@class="mye4qd"]').send_keys(Keys.ENTER)
  136.  
  137.             print('缓冲中...')
  138.             time.sleep(8)  # ‘加载更多’ 缓冲
  139.  
  140.             # TODO 执行点击加载更多继续滚动
  141.             browser.execute_script(js)
  142.             # 等待窗口滑动结束
  143.             for i in range(self.js_slide_wait):
  144.                 print('\rJS加载更多图片窗口滑动中,请等待 {}s,现在是第 {}s，网络好可下调 '.format(self.js_slide_wait, i + 1), end='', flush=True)
  145.                 time.sleep(1)
  146.             print()
  147.         except Exception as e:
  148.             print(e, '网络不畅 或 该网页没有更多内容选项 .... ')
  149.  
  150.         # 获取图片详情页链接地址
  151.         div_infos = browser.find_elements_by_xpath(
  152.             "//div[@id='islmp']/.//div[contains(@class,'isv-r PNCib MSM1fd')]")  # 结果是一个列表
  153.  
  154.         self.reduceImg_num = len(div_infos)
  155.         if self.reduceImg_num == 0:
  156.             assert Exception('网络链接 {} 错误\n 获取主页面class属性已更改'.format(self.url))
  157.         print('一共获取到 {} 张缩减图'.format(self.reduceImg_num))
  158.  
  159.         # 定义重复请求的链接列表，保存 【{url，img_name}，...】二元组列表
  160.         self.repeat_urls = []
  161.         # TODO 通过缩减图 DIV 获取高清图片的地址
  162.         for idx, i in enumerate(div_infos):
  163.  
  164.             try:
  165.                 data_id = i.get_attribute('data-id')
  166.             except Exception as e:
  167.                 logger.error(e)
  168.                 logger.error('"data_id" 的属性值获取失败,可能网站已更改属性')
  169.                 continue
  170.  
  171.             # 图片详情页的 url 地址
  172.             img_url = self.url + '#imgrc=' + data_id
  173.             try:
  174.                 browser.get(img_url)
  175.  
  176.                 self.target_img_url = browser.find_element_by_xpath(
  177.                     "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  178.                     'src')
  179.                 self.target_img_name = browser.find_element_by_xpath(
  180.                     "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  181.                     'alt')
  182.  
  183.                 # 如果获取的url不以 data: 或者 http 开头,视为获取失败
  184.                 if not (self.target_img_url.startswith('data:') or self.target_img_url.startswith('http')):
  185.                     logger.info("第 {} 高清图片url: {} 格式错误,跳过".format(idx + 1, self.target_img_url))
  186.                     continue
  187.  
  188.                 # 对是否详情页加载为高清图的url进行判断: https://encrypted-tbn0.gstatic.com/images? 开头属于缩减图
  189.                 # 因此对详情页进行最长为 time_sleep 时间的等待,每次判断的时间step为250ms
  190.                 if self.target_img_url.startswith('https://encrypted-tbn0.gstatic.com/images?'):
  191.                     for step in range(time_sleep * 4):
  192.                         if not self.target_img_url.startswith('https://encrypted-tbn0.gstatic.com/images?'):
  193.                             break
  194.                         time.sleep(0.25)
  195.                         self.target_img_url = browser.find_element_by_xpath(
  196.                             "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  197.                             'src')
  198.  
  199.                 elif self.target_img_url.startswith('data:'):
  200.                     for step in range(int(max(1.5, time_sleep - 3) * 4)):  # data: 类型的图片，最少等待 1.5s 去加载图片
  201.                         if not self.target_img_url.startswith('data:'):
  202.                             break
  203.                         time.sleep(0.25)
  204.                         self.target_img_url = browser.find_element_by_xpath(
  205.                             "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  206.                             'src')
  207.  
  208.             except Exception as e:
  209.                 logger.error(e)
  210.                 logger.error('当前第 {} 张缩减图片详情信息url获取信息失败,跳过处理'.format(idx + 1))
  211.                 continue
  212.  
  213.             # TODO 图片高清地址获取完毕，现在构建图片保存所需要的路径
  214.             self.target_img_name = self.add_timestamp(self.clean_str(self.target_img_name)) + '.jpg'
  215.  
  216.             img_file_path = os.path.join(self.img_tmp_dir,
  217.                                          self.target_img_name)
  218.  
  219.             # TODO 图片保存
  220.             if self.target_img_url.startswith(
  221.                     'https://encrypted-tbn0.gstatic.com/images?') or self.target_img_url.startswith('data:'):
  222.                 print(
  223.                     '总量:{}, 图片序号为：{}，正在保存【缩减图】至 {}，图片名: {} url：{}'.format(self.reduceImg_num, idx, img_file_path,
  224.                                                                           self.target_img_name,
  225.                                                                           self.target_img_url[:150])
  226.                     # data: 链接太长，这里做一个截取
  227.                 )
  228.             else:
  229.                 print(
  230.                     '总量:{}, 图片序号为：{}，正在保存【高清图】至 {}，图片名: {} url：{}'.format(self.reduceImg_num, idx, img_file_path,
  231.                                                                           self.target_img_name,
  232.                                                                           self.target_img_url)
  233.                 )
  234.  
  235.             if self.target_img_url.startswith('http'):
  236.                 self.save_url_img(img_file_path)
  237.             elif self.target_img_url.startswith('data:'):
  238.                 self.save_base64_img(self.target_img_url, img_file_path)
  239.  
  240.         # 重新爬取请求失败的高清图片的链接
  241.         repeat_urls = self.repeat_urls
  242.         self.repeat_spider(repeat_urls)
  243.  
  244.         browser.quit()  # 浏览器退出
  245.  
  246.     def save_url_img(self, img_files_path):
  247.         """
  248.         通过 url 请求保存图片
  249.         :param img_files_path: 给定要保存的文件名的路径
  250.         :return:
  251.         """
  252.         try:
  253.             headers = {
  254.                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
  255.             }
  256.             # TODO 增加连接重试次数(一共2次请求链接)
  257.             # requests.adapters.DEFAULT_RETRIES = 1 
  258.             sess = requests.Session()
  259.             sess.keep_alive = False # 关闭多余连接
  260.             text = sess.get(self.target_img_url, headers=headers, stream=True, verify=False, timeout=5)
  261.             
  262.             with open(img_files_path, 'wb') as file:
  263.                 for i in text.iter_content(1024 * 10):
  264.                     file.write(i)
  265.         except Exception as e:
  266.             self.repeat_urls.append((self.target_img_url, img_files_path))
  267.             logger.error(e, self.target_img_url)
  268.  
  269.     def save_base64_img(self, url, img_files_path):
  270.         """
  271.         保存 base64 格式的图片
  272.         :param url:
  273.         :param img_files_path:
  274.         :return:
  275.         """
  276.         import base64
  277.         url = re.sub('.+base64,', '', url)
  278.         img = base64.urlsafe_b64decode(url + '=' * (4 - len(url) % 4))
  279.         fh = open(img_files_path, "wb")
  280.         fh.write(img)
  281.         fh.close()
  282.  
  283.     def screen_img(self, ele, img_files_path):
  284.         """
  285.         给定需要截图的 element元素，进行截图
  286.         :param ele: 需要截图的元素
  287.         :param img_files_path: 图片的路径
  288.         :return:
  289.         """
  290.         try:
  291.             ele.screenshot(img_files_path)
  292.         except Exception as e:
  293.             logger.error('一些原因导致截图失败，跳过处理', e)
  294.  
  295.     def repeat_spider(self, urls, repeat_num=3):
  296.         """
  297.             用于重复请求高清图片 get 失败的链接，下载图片 
  298.             urls: 请求失败的 图片链接及其图片名称组成的二元组的列表
  299.             repeat_num: 重复循环最多 repeat_nume 次，裆列表为零时终止循环
  300.         """
  301.         urls_num = len(urls)
  302.         logger.info('\n存在{}个链接请求失败，正在重新请求爬取，使用requests的方式请求：\n'.format(urls_num))
  303.         
  304.         sucess_idx = []  # 保存成功的url 的索引列表
  305.         for num in range(repeat_num):
  306.             urls_num = len(urls)
  307.             if urls_num == 0:
  308.                 break
  309.                 
  310.             for idx,url_info in enumerate(urls):
  311.                 
  312.                 if idx not in sucess_idx:
  313.                     url = url_info[0]
  314.                     img_name = url_info[1]
  315.                     
  316.                     try:
  317.                         headers = {
  318.                             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
  319.                         }
  320.                         # TODO 增加连接重试次数(一共4次链接)
  321.                         sess = requests.Session()
  322.                         sess.mount('http://', HTTPAdapter(max_retries=3)) 
  323.                         sess.mount('https://', HTTPAdapter(max_retries=3))     
  324.                         sess.keep_alive = False # 关闭多余连接
  325.                         
  326.                         text = requests.get(url, headers=headers, stream=True, verify=False, timeout=(4,5)) # connect 和 read 二者的 timeout
  327.                         
  328.                         with open(img_name, 'wb') as file:
  329.                             for i in text.iter_content(1024 * 10):
  330.                                 file.write(i)
  331.                                 
  332.                         text.close() # 关闭，很重要,确保不要过多的链接
  333.                         
  334.                         logger.info('使用requests的方式请求,重复爬取阶段 保存成功 ,现在是第{}次循环，第{}张图片name-url：{}-{}'.format(num+1,idx+1,img_name,url))
  335.                         # 保存成功的图片将成功的idx保存，确保下一次循环不会重新使用已成功的url
  336.                         sucess_idx.append(idx)
  337.                         
  338.                     except Exception as e:
  339.                         logger.error(e)
  340.                         logger.error('使用requests的方式请求,重复爬取请求失败：{}'.format(url))
  341.                     time.sleep(0.5)
  342.  
  343.  
  344. if __name__ == '__main__':
  345.  
  346.     # TODO 参数
  347.     head = False
  348.     target_dir = r'target_dir'
  349.     time_sleep = 3  # 网速好的时间可以下调，加载高清最长等待时间
  350.     # logger.info(urls,head,keyword,target_dir)
  351.     urls = [
  352.         'https://www.google.com/search?q=风景&newwindow=1&sxsrf=ALeKk002XUAM8lwptPWsSjuox8SjA1B7_A:1600079585015&source=lnms&tbm=isch&sa=X&ved=2ahUKEwimsZv6uOjrAhUNkJQKHW5HBD4Q_AUoAXoECAwQAw&biw=1920&bih=937']
  353.     keyword = '风景'
  354.  
  355.     for url in urls:
  356.         url = url.strip()
  357.  
  358.         # TODO 运行
  359.         spider_obj = GoogleSpider(url, keyword, time_sleep, target_dir)
  360.  
  361.         # 创建一个浏览器
  362.         browser = spider_obj.create_browser(head=head)
  363.  
  364.         # 下载图片
  365.         spider_obj.get_main_page_info(browser=browser)
  366.  
  367.

    （2）使用截图代替下载 缩减图

  1. tip：
  2.     1、删除：
  3.     from utils import utils
  4.     logger = utils.Logger_Hanlder.setup_logging(report_path='./log')
  5.     2、将所有的 logger语句转化为 print
  1. from selenium import webdriver
  2. from selenium.webdriver.common.by import By
  3. from selenium.webdriver.support.ui import WebDriverWait
  4. from selenium.webdriver.support import expected_conditions as EC
  5. from selenium.common.exceptions import ElementNotInteractableException
  6. from selenium.webdriver.common.keys import Keys
  7. from requests.adapters import HTTPAdapter
  8. import argparse
  9.  
  10. import time
  11. import os
  12. import re
  13. import requests
  14. import urllib3
  15. urllib3.disable_warnings() # 去除警告
  16. from utils import utils
  17. logger = utils.Logger_Hanlder.setup_logging(report_path='./log')
  18.  
  19.  
  20. class GoogleSpider():
  21.  
  22.     def __init__(self,url,keyword,time_sleep,target_dir,repeat_num,max_imgNum = None):
  23.         self.url = url
  24.         self.keyword = keyword
  25.         self.repeat_num = repeat_num # 高清图片链接请求失败后重新爬取的次数
  26.         self.time_sleep = time_sleep    # 等待高清图片加载的时间
  27.         self.max_imgNum = max_imgNum # 设置最大图片的下载量
  28.         self.target_dir = target_dir
  29.         self.img_tmp_dir = os.path.join(self.target_dir,
  30.                                    self.add_timestamp(self.keyword))
  31.         if not os.path.exists(self.img_tmp_dir):
  32.             os.makedirs(self.img_tmp_dir)
  33.  
  34.         self.head = None            # 浏览器是否存在头
  35.         self.implicitly_wait_time = 5 # 隐形等待时间
  36.         self.js_slide_wait = 30 # js 滑动窗口等待时间
  37.  
  38.     def clean_str(self,str_):
  39.         """
  40.         清除字符串为图片命名时不合规的字符
  41.         :return:
  42.         """
  43.         str_ = re.sub('[^\u4e00-\u9fa5A-Za-z\d]','',str_)
  44.         return str_
  45.  
  46.     def add_timestamp(self,str_):
  47.         """
  48.         为字符串添加时间搓,保证字符串唯一不重复性
  49.         :param str_: str
  50.         :return:
  51.         """
  52.         assert isinstance(str_,str)
  53.         time_str = str(time.time()).replace('.','')
  54.         str_ = str_ + time_str
  55.         return str_
  56.  
  57.     def create_browser(self,head):
  58.         """
  59.         创建一个浏览器的对象
  60.         :param headless: 是否使用无头浏览器
  61.         :return:
  62.         """
  63.         self.head = head
  64.  
  65.         options = webdriver.ChromeOptions()
  66.         # 增加无头
  67.         if not self.head:
  68.             options.add_argument('--headless')
  69.             # 无头浏览器设置窗口大小，主要是为了解决截屏时，如果窗口比较小，截屏时会获得较小的图片
  70.             options.add_argument("--window-size=4000,1600")
  71.  
  72.         options.add_argument('--disable-gpu')
  73.  
  74.         # 关闭自动测试状态显示 // 会导致浏览器报：请停用开发者模式
  75.         # window.navigator.webdriver还是返回True,当返回undefined时应该才可行。
  76.         options.add_experimental_option("excludeSwitches", ['enable-automation'])
  77.         # 关闭开发者模式
  78.         options.add_experimental_option("useAutomationExtension", False)
  79.         # 设置中文
  80.         options.add_argument('lang=zh_CN.UTF-8')
  81.         # 更换头部
  82.         options.add_argument(
  83.             'user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36"')
  84.         # 部署项目在linux时，其驱动会要求这个参数
  85.         options.add_argument('--no-sandbox')
  86.  
  87.         browser = webdriver.Chrome(options=options)
  88.         if self.head:
  89.             browser.maximize_window()
  90.  
  91.         # 设置执行js代码转换模式，反反爬虫检测 window.navigator.webdriver 属性换为 undefined
  92.         browser.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
  93.             "source": """Object.defineProperty(navigator, 'webdriver', {get: () => undefined})""",
  94.         })
  95.  
  96.         return browser
  97.  
  98.     def get_main_page_info(self,browser):
  99.         """
  100.         获取主页面且拉至最底部,且获取所有图片详情页的链接地址
  101.         :return:
  102.         """
  103.         browser.get(self.url)
  104.         browser.implicitly_wait(self.implicitly_wait_time)
  105.  
  106.         # TODO 滑动到底的js代码
  107.         js = """ 
  108.                    (function () { 
  109.                        var y = document.documentElement.scrollTop; 
  110.                        var step = 100; 
  111.                        window.scroll(0, y); 
  112.                        function f() { 
  113.                            if (y < document.body.scrollHeight) { 
  114.                                y += step; 
  115.                                window.scroll(0, y); 
  116.                                setTimeout(f, 100); //每两次间隔滑动的时间 100ms
  117.                                
  118.                            }
  119.                            else { 
  120.                                window.scroll(0, y); 
  121.                                document.title += "scroll-done"; 
  122.                            } 
  123.                        } 
  124.                        setTimeout(f, 1000); // 执行函数等待时间 1000ms
  125.                    })(); 
  126.             """
  127.  
  128.         # TODO 执行滑动到底的操作
  129.         browser.execute_script(js)
  130.         # 等待窗口滑动结束
  131.         for i in range(self.js_slide_wait):
  132.             print('\rJS窗口滑动中,请等待 {}s,现在是第 {}s，网络好可下调 '.format(self.js_slide_wait,i+1),end='',flush=True)
  133.             time.sleep(1)
  134.         print()
  135.  
  136.         # TODO 点击 ‘ 加载更多的选项 ’
  137.         try:
  138.             browser.find_element_by_xpath('//div[@id="islmp"]/.//div[@jsname="i3y3Ic"]/.//input[@class="mye4qd"]').send_keys(Keys.ENTER)
  139.  
  140.             print('缓冲中...')
  141.             time.sleep(8)  # ‘加载更多’ 缓冲
  142.  
  143.             # TODO 执行点击加载更多继续滚动
  144.             browser.execute_script(js)
  145.             # 等待窗口滑动结束
  146.             for i in range(self.js_slide_wait):
  147.                 print('\rJS加载更多图片窗口滑动中,请等待 {}s,现在是第 {}s，网络好可下调 '.format(self.js_slide_wait, i + 1), end='', flush=True)
  148.                 time.sleep(1)
  149.             print()
  150.         except Exception as e:
  151.             print(e, '网络不畅 或 该网页没有更多内容选项 .... ')
  152.  
  153.         # 获取图片详情页链接地址
  154.         div_infos = browser.find_elements_by_xpath(
  155.                 "//div[@id='islmp']/.//div[contains(@class,'isv-r PNCib MSM1fd')]")    # 结果是一个列表
  156.  
  157.         self.reduceImg_num = len(div_infos)
  158.         if self.reduceImg_num == 0:
  159.             assert Exception('网络链接 {} 错误\n 获取主页面class属性已更改'.format(self.url))
  160.         logger.info('一共获取到 {} 张缩减图，且图片下载给定的最大的数量为{}张'.format(self.reduceImg_num,self.max_imgNum))
  161.  
  162.         # 定义重复请求的链接列表，保存 【{url，img_name}，...】二元组列表
  163.         self.repeat_urls = []
  164.         # TODO 通过缩减图 DIV 获取高清图片的地址
  165.         for idx,i in enumerate(div_infos):
  166.             # 当图片下载超过给定的最大的数量时，停止爬取
  167.             if self.max_imgNum is not None:
  168.                 if idx >= self.max_imgNum:
  169.                     logger.info("当图片下载超过给定的最大的数量时,强制停止")
  170.                     break
  171.                     
  172.             try:
  173.                 data_id = i.get_attribute('data-id')
  174.             except Exception as e:
  175.                 logger.error(e)
  176.                 logger.error('"data_id" 的属性值获取失败,可能网站已更改属性')
  177.                 continue
  178.  
  179.             # 图片详情页的 url 地址
  180.             img_url = self.url + '#imgrc=' + data_id
  181.             try:
  182.                 browser.get(img_url)
  183.  
  184.                 self.target_img_url = browser.find_element_by_xpath(
  185.                     "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  186.                     'src')
  187.                 self.target_img_name = browser.find_element_by_xpath(
  188.                     "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  189.                     'alt')
  190.  
  191.                 # 如果获取的url不以 data: 或者 http 开头,视为获取失败
  192.                 if not (self.target_img_url.startswith('data:') or self.target_img_url.startswith('http')):
  193.                     logger.info("第 {} 高清图片url: {} 格式错误,跳过".format(idx+1 , self.target_img_url))
  194.                     continue
  195.  
  196.                 # 对是否详情页加载为高清图的url进行判断: https://encrypted-tbn0.gstatic.com/images? 开头属于缩减图
  197.                 # 因此对详情页进行最长为 time_sleep 时间的等待,每次判断的时间step为250ms
  198.                 if self.target_img_url.startswith('https://encrypted-tbn0.gstatic.com/images?'):
  199.                     for step in range(time_sleep * 4):
  200.                         if not self.target_img_url.startswith('https://encrypted-tbn0.gstatic.com/images?'):
  201.                             break
  202.                         time.sleep(0.25)
  203.                         self.target_img_url = browser.find_element_by_xpath(
  204.                             "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  205.                             'src')
  206.  
  207.                 elif self.target_img_url.startswith('data:'):
  208.                     for step in range(    int(max(1.5,time_sleep - 3) * 4)   ):  # data: 类型的图片，最少等待 1.5s 去加载图片
  209.                         if not self.target_img_url.startswith('data:'):
  210.                             break
  211.                         time.sleep(0.25)
  212.                         self.target_img_url = browser.find_element_by_xpath(
  213.                             "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img").get_attribute(
  214.                             'src')
  215.  
  216.             except Exception as e:
  217.                 logger.error(e)
  218.                 logger.error('当前第 {} 张缩减图片详情信息url获取信息失败,跳过处理'.format(idx+1))
  219.                 continue
  220.  
  221.             # TODO 图片高清地址获取完毕，现在构建图片保存所需要的路径
  222.             self.target_img_name = self.add_timestamp(self.clean_str(self.target_img_name)) + '.jpg'
  223.  
  224.             img_file_path = os.path.join(self.img_tmp_dir,
  225.                                          self.target_img_name)
  226.  
  227.             # TODO 图片保存
  228.             if self.target_img_url.startswith('https://encrypted-tbn0.gstatic.com/images?') or self.target_img_url.startswith('data:'):
  229.                 logger.info(
  230.                     '总量:{}, 图片序号为：{}，正在保存【截图】至 {}，图片名: {} url：{}'.format(self.reduceImg_num, idx, img_file_path,
  231.                                                                   self.target_img_name,
  232.                                                                   self.target_img_url[:150])  # data: 链接太长，这里做一个截取
  233.                                                                                 )
  234.                 # 保存截图
  235.                 ele_img = browser.find_element_by_xpath(
  236.                             "//div[@id='Sva75c']/.//div[@class='tvh9oe BIB1wf']/.//div[@class='zjoqD']/.//img")
  237.                 self.screen_img(ele_img,img_file_path)
  238.             else:
  239.                 logger.info(
  240.                     '总量:{}, 图片序号为：{}，正在保存【高清图】至 {}，图片名: {} url：{}'.format(self.reduceImg_num, idx, img_file_path,
  241.                                                                   self.target_img_name,
  242.                                                                   self.target_img_url)
  243.                                                                                 )
  244.                 # 保存高清图
  245.                 self.save_url_img(img_file_path)
  246.                 time.sleep(0.5)
  247.            
  248.            
  249.         # 重新爬取请求失败的高清图片的链接
  250.         repeat_urls = self.repeat_urls
  251.         repeat_num = self.repeat_num
  252.         
  253.         # self.repeat_spider_get(repeat_urls,repeat_num)
  254.         self.repeat_spider_screen(repeat_urls,repeat_num)
  255.             
  256.         browser.quit()  # 浏览器退出
  257.  
  258.     def save_url_img(self,img_files_path):
  259.         """
  260.         通过 url 请求保存图片
  261.         :param img_files_path: 给定要保存的文件名的路径
  262.         :return:
  263.         """
  264.         try:
  265.             headers = {
  266.                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
  267.             }
  268.             # TODO 增加连接重试次数(一共2次请求链接)
  269.             # requests.adapters.DEFAULT_RETRIES = 1 
  270.             sess = requests.Session()
  271.             sess.keep_alive = False # 关闭多余连接
  272.             text = sess.get(self.target_img_url, headers=headers, stream=True, verify=False, timeout=5)
  273.             
  274.             with open(img_files_path, 'wb') as file:
  275.                 for i in text.iter_content(1024 * 10):
  276.                     file.write(i)
  277.         except Exception as e:
  278.             self.repeat_urls.append((self.target_img_url,img_files_path))
  279.             logger.error(e)
  280.             logger.error("爬取请求失败：{}".format(self.target_img_url))
  281.  
  282.     def save_base64_img(self,url,img_files_path):
  283.         """
  284.         保存 base64 格式的图片
  285.         :param url:
  286.         :param img_files_path:
  287.         :return:
  288.         """
  289.         import base64
  290.         url = re.sub('.+base64,','',url)
  291.         img = base64.urlsafe_b64decode(url + '=' * (4 - len(url) % 4))
  292.         fh = open(img_files_path, "wb")
  293.         fh.write(img)
  294.         fh.close()
  295.  
  296.     def screen_img(self,ele,img_files_path):
  297.         """
  298.         给定需要截图的 element元素，进行截图
  299.         :param ele: 需要截图的元素
  300.         :param img_files_path: 图片的路径
  301.         :return:
  302.         """
  303.         try:
  304.             ele.screenshot(img_files_path)
  305.         except Exception as e:
  306.             logger.error('一些原因导致截图失败，跳过处理',e)
  307.             
  308.     def repeat_spider_get(self,urls,repeat_num):
  309.         """
  310.             用于重复请求高清图片 get 失败的链接，下载图片 
  311.             urls: 请求失败的 图片链接及其图片名称组成的二元组的列表
  312.             repeat_num: 重复循环最多 repeat_nume 次，裆列表为零时终止循环
  313.         """
  314.         urls_num = len(urls)
  315.         logger.info('\n存在{}个链接请求失败，正在重新请求爬取，使用requests的方式请求：\n'.format(urls_num))
  316.         
  317.         sucess_idx = []  # 保存成功的url 的索引列表
  318.         for num in range(repeat_num):
  319.             urls_num = len(urls)
  320.             if urls_num == 0:
  321.                 break
  322.             
  323.             fail_num = 0 # 判断连续失败的个数超过一定个数以后（本次设为6），终止重复爬取阶段，
  324.             for idx,url_info in enumerate(urls):
  325.                 
  326.                 if idx not in sucess_idx:
  327.                     url = url_info[0]
  328.                     img_name = url_info[1]
  329.                     
  330.                     try:
  331.                         headers = {
  332.                             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
  333.                         }
  334.                         # TODO 增加连接重试次数(一共4次链接)
  335.                         sess = requests.Session()
  336.                         sess.mount('http://', HTTPAdapter(max_retries=3)) 
  337.                         sess.mount('https://', HTTPAdapter(max_retries=3))     
  338.                         sess.keep_alive = False # 关闭多余连接
  339.                         
  340.                         text = requests.get(url, headers=headers, stream=True, verify=False, timeout=(4,5)) # connect 和 read 二者的 timeout
  341.                         
  342.                         with open(img_name, 'wb') as file:
  343.                             for i in text.iter_content(1024 * 10):
  344.                                 file.write(i)
  345.                                 
  346.                         text.close() # 关闭，很重要,确保不要过多的链接
  347.                         
  348.                         logger.info('使用requests的方式请求,重复爬取阶段 保存成功 ,现在是第{}次循环，第{}张图片name-url：{}-{}'.format(num+1,idx+1,img_name,url))
  349.                         # 保存成功的图片将成功的idx保存，确保下一次循环不会重新使用已成功的url
  350.                         sucess_idx.append(idx)
  351.                         
  352.                         fail_num = 0 # 将该数字归 0 
  353.                     except Exception as e:
  354.                         logger.error(e)
  355.                         logger.error('使用requests的方式请求,重复爬取请求失败：{}'.format(url))
  356.                         
  357.                         # 判断连续失败的个数超过一定个数以后（本次设为6），终止重复爬取阶段，
  358.                         fail_num += 1
  359.                         if fail_num >= 6:
  360.                             break
  361.                         
  362.                     time.sleep(0.5)
  363.                 
  364.     def repeat_spider_screen(self,urls,repeat_num):
  365.         """
  366.             用于重复请求高清图片 去 截图图片 
  367.             urls: 请求失败的 图片链接及其图片名称组成的二元组的列表
  368.             repeat_num: 重复循环最多 repeat_nume 次，裆列表为零时终止循环
  369.         """
  370.         urls_num = len(urls)
  371.         logger.info('\n存在{}个链接请求失败，正在重新请求爬取，使用浏览器截屏的方式来代替requests：\n'.format(urls_num))
  372.         
  373.         head = self.head
  374.         browser = self.create_browser(head)
  375.         browser.implicitly_wait(5)
  376.         
  377.         sucess_idx = []  # 保存成功的url 的索引列表
  378.         for num in range(repeat_num):
  379.             urls_num = len(urls)
  380.             if urls_num == 0:
  381.                 break
  382.         
  383.             fail_num = 0 # 判断连续失败的个数超过一定个数以后（本次设为6），终止重复爬取阶段，
  384.             for idx,url_info in enumerate(urls):
  385.             
  386.                 if idx not in sucess_idx:
  387.                     
  388.                     url = url_info[0]
  389.                     img_name = url_info[1]
  390.                     
  391.                     try:
  392.                         browser.get(url)
  393.                         ele = browser.find_element_by_xpath('//img')
  394.                         self.screen_img(ele = ele,img_files_path = img_name)
  395.                         
  396.                         logger.info('使用浏览器截屏的方式,重复爬取阶段 保存成功 ,现在是第{}次循环，第{}张图片name-url：{}-{}'.format(num+1,idx+1,img_name,url))
  397.                         
  398.                         # 保存成功的图片将成功的idx保存，确保下一次循环不会重新使用已成功的url
  399.                         sucess_idx.append(idx)
  400.                         
  401.                         fail_num = 0 # 将该数字归 0 
  402.                     except Exception as e:
  403.                         logger.error(e)
  404.                         logger.error('使用浏览器截屏的方式,重复爬取请求失败：{}'.format(url))
  405.                         
  406.                         # 判断连续失败的个数超过一定个数以后（本次设为6），终止重复爬取阶段，
  407.                         fail_num += 1
  408.                         if fail_num >= 6:
  409.                             break
  410.                             
  411.                     time.sleep(0.5)
  412.  
  413. if __name__ == '__main__':
  414.  
  415.     # argparse 回调函数
  416.     def str2bool(v):
  417.         if isinstance(v, bool):
  418.             return v
  419.         if v.lower() in ('yes', 'true', 't', 'y', '1'):
  420.             return True
  421.         elif v.lower() in ('no', 'false', 'f', 'n', '0'):
  422.             return False
  423.         else:
  424.             raise argparse.ArgumentTypeError('Boolean value expected.')
  425.  
  426.     # TODO 参数
  427.     # 创建对象
  428.     parser = argparse.ArgumentParser()
  429.  
  430.     # 添加参数
  431.     parser.add_argument('urls', help='main_page url',type=str,nargs='+')                # url 地址，可以给多个
  432.     parser.add_argument('--keywords', help='keywords',nargs='+',type=str)                          # 关键字
  433.     parser.add_argument('--repeat_num', help='repeat spider num',type=int,default=1)  # 高清图片url请求失败 重复获取的次数
  434.     parser.add_argument('--max_imgNums', help='each url max imgs num',nargs='+',type=int,default=400)     # 保存图片的最大数量
  435.     parser.add_argument('--head', help='headless YES or NO',type=str2bool,default=True) # 是否开启无头浏览器
  436.  
  437.     # 使用parse_args解析参数
  438.     args = parser.parse_args()
  439.     urls = args.urls
  440.     keywords = args.keywords
  441.     repeat_num = args.repeat_num
  442.     max_imgNums = args.max_imgNums
  443.     head = args.head
  444.  
  445.     target_dir = r'C:\Users\liukang17\Desktop'
  446.     time_sleep = 3 # 网速好的时间可以下调，加载高清最长等待时间
  447.     logger.info("\n\n urls:{}-head:{}-keywords:{}-target_dir:{}-repeat_num:{}-max_imgNums:{} \n\n".format(urls,head,keywords,target_dir,repeat_num,max_imgNums))
  448.     logger.error("\n\n urls:{}-head:{}-keywords:{}-target_dir:{}-repeat_num:{}-max_imgNums:{} \n\n".format(urls,head,keywords,target_dir,repeat_num,max_imgNums))
  449.  
  450.     
  451.     tmp1_num = len(max_imgNums)
  452.     tmp2_num = len(keywords)
  453.     for idx,url in enumerate(urls):
  454.         url = url.strip()
  455.         
  456.         # 判断 max_imgNums 与 keywords 列表索引是否越界
  457.         if idx >= tmp1_num:
  458.             max_imgNum = max_imgNums[-1]
  459.         else:
  460.             max_imgNum = max_imgNums[idx]
  461.         if idx >= tmp2_num:
  462.             keyword = keywords[-1]
  463.         else:
  464.             keyword = keywords[idx]
  465.         
  466.         # TODO 运行
  467.         spider_obj = GoogleSpider(url,keyword,time_sleep,target_dir,repeat_num,max_imgNum)
  468.  
  469.         # 创建一个浏览器
  470.         browser = spider_obj.create_browser(head=head)
  471.  
  472.         # 下载图片
  473.         spider_obj.get_main_page_info(browser=browser)
  474.     
  1. 执行脚本：
  2. cd C:\Users\****\Desktop\LanJunTools
  3. python google_image_main.py "https://www.google.com.tw/search?q=风景&source=lnms&tbm=isch&sa=X&ved=2ahUKEwijoaW6o7bsAhUEIIgKHUQPBeAQ_AUoAXoECBcQAw&biw=1366&bih=625" "https://www.google.com.tw/search?q=壁纸&tbm=isch&ved=2ahUKEwiRwNG7o7bsAhXENKYKHaUzBCcQ2-cCegQIABAA&oq=%E5%A3%81%E7%BA%B8&gs_lcp=CgNpbWcQAzICCAAyAggAMgIIADICCAAyBAgAEB4yBAgAEB4yBAgAEB4yBAgAEB4yBAgAEB4yBAgAEB46BAgAEAQ6BggAEAUQHlCqd1iGogFg16MBaABwAHgAgAGoA4gBiAqSAQkwLjMuMi4wLjGYAQCgAQGqAQtnd3Mtd2l6LWltZ7ABAMABAQ&sclient=img&ei=VBWIX5HGDcTpmAWl55C4Ag&bih=625&biw=1366" --max_imgNums 900 200 --head 0 --keywords 风景 壁纸

 

二、利用 selenium 自动上传文件(图片/文本)

  1、利用 .send_keys( file_path ) 的方式上传 图片

        selenium处理文件或图片上传弹窗的三种方式（input框，robot类，autoIT3工具）

  2、selenium 操作 textarea 文本域上传文本

  1. selenium 对文本框的输入操作一般有两种形式，传统的是直接通过定位元素通过sendKeys（）方法直接在文本框中输入信息。
  2. 但有时候我们可以通过xpath的方式将其进行定位，但却不能通过sendKeys()向文本框中输入文本信息。
  3. 这种情况下，也需要借助JavaScript 代码完成输入。

       HTML 文本域 

  1. <textarea id="id" style="width: 98%" cols="50" rows="5" class="txtarea">
  2. </textarea>
  3. ...
  4. ...

        第一种：

driver.find_element_by_id('id').sendKeys("需要输入的内容");

       第二种：

  1. text = '文本域上传的内容'
  2. js = "var kw = document.getElementById('kw') ;kw.value='{}';".format(text)
  3. driver.execute_script(js)

三、自动上传大众点评头像、评论

Directory_Hanlder 自定义库代码地址：https://blog.csdn.net/qq_16555103/article/details/107146429
失败，已放弃
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from selenium import webdriver
  5. from utils.utils import Directory_Hanlder
  6. from selenium.webdriver.common.keys import Keys
  7. from selenium.common.exceptions import ElementNotInteractableException
  8. import os    #
  9. import numpy as np
  10. import pandas as pd
  11. import time
  12. import argparse
  13.  
  14. class DumpMassage():
  15.     def __init__(self,choice,head_img_dir = None, comments_signs_file = None):
  16.         # 选择哪种方式执行 'img' 上传头像 'text' 上传文本 'all' 同时上传
  17.         assert choice in ['img','text','all']
  18.         self.choice = choice
  19.  
  20.         # 登录浏览器的参数
  21.         self.log_in_url = "https://account.dianping.com/login?"  # 登录点评网页的链接地址
  22.         self.log_in_sleep = 15  # 登录页面扫码等待时间
  23.         self.main_page = 'https://www.dianping.com/'
  24.  
  25.         # 上传头像图片的参数
  26.         self.head_img_url = 'http://www.dianping.com/member/myinfo/setup/userface'  # 头像上传的链接地址
  27.         self.head_img_sleep = 2.5  # 上传图片等待时间提交,最小为 time_sleep,最大为 time_sleep + 1.5 的随机数
  28.         self.head_img_dir = head_img_dir # 上传头像图片的目录路径
  29.  
  30.         # 评论与签名相关参数
  31.         self.comments_signs_file = comments_signs_file # 上传文本数据的文件路径
  32.  
  33.         # 浏览器对象参数
  34.         self.head = True
  35.         self.implicitly_wait = 15
  36.  
  37.             # 浏览器初始化
  38.         self.browser = self.create_browser(head=self.head)
  39.         self.browser.implicitly_wait(self.implicitly_wait)
  40.         self.browser = self.log_in_dianping(self.browser,self.log_in_url,time_sleep=self.log_in_sleep)
  41.             # 浏览器打开主页面 且 再打开一个窗口
  42.         # self.browser.get(self.main_page)
  43.         # self.browser.find_element_by_xpath("//a[@class= 'item left-split username J-user-trigger']").send_keys(Keys.ENTER)
  44.  
  45.         self.browser.get(self.head_img_url)   # 此时,浏览器其实已经有了两个窗口了{ 目前位于第一个窗口,即主窗口 },第一个窗口用来上传头像,第二个窗口用来上传文本数据
  46.         self.windows = self.browser.window_handles
  47.  
  48.     def create_browser(self,head):
  49.         """
  50.         创建一个浏览器的对象
  51.         :param headless: 是否使用无头浏览器
  52.         :return:
  53.         """
  54.         self.head = head
  55.  
  56.         options = webdriver.ChromeOptions()
  57.  
  58.         # 增加无头
  59.         if not self.head:
  60.             options.add_argument('--headless')
  61.             # 无头浏览器设置窗口大小，主要是为了解决截屏时，如果窗口比较小，截屏时会获得较小的图片
  62.             options.add_argument("--window-size=4000,1600")
  63.  
  64.         options.add_argument('--disable-gpu')
  65.  
  66.         # 关闭自动测试状态显示 // 会导致浏览器报：请停用开发者模式
  67.         # window.navigator.webdriver还是返回True,当返回undefined时应该才可行。
  68.         options.add_experimental_option("excludeSwitches", ['enable-automation'])
  69.         # 关闭开发者模式
  70.         options.add_experimental_option("useAutomationExtension", False)
  71.         # 设置中文
  72.         options.add_argument('lang=zh_CN.UTF-8')
  73.         # 更换头部
  74.         options.add_argument(
  75.             'user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36"')
  76.         # 部署项目在linux时，其驱动会要求这个参数
  77.         options.add_argument('--no-sandbox')
  78.  
  79.         browser = webdriver.Chrome(options=options)
  80.         if self.head:
  81.             browser.maximize_window()
  82.  
  83.         # 设置执行js代码转换模式，反反爬虫检测 window.navigator.webdriver 属性换为 undefined
  84.         browser.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
  85.             "source": """Object.defineProperty(navigator, 'webdriver', {get: () => undefined})""",
  86.         })
  87.         return browser
  88.  
  89.     def log_in_dianping(self,browser,url,time_sleep = 15):
  90.         """
  91.         浏览器登录点评
  92.         :param browser:
  93.         :param url: 登录点评的链接
  94.         :param time_sleep: 登录扫码等待的时间
  95.         :return:
  96.         """
  97.         # 浏览器登录
  98.         browser.get(url)  # 获取路径
  99.  
  100.         time.sleep(0.3)
  101.         browser.switch_to.frame((browser.find_element_by_xpath('//iframe')))
  102.         browser.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
  103.             "source": """Object.defineProperty(navigator, 'webdriver', {get: () => undefined})""",
  104.         })
  105.         browser.find_element_by_xpath('//span[@class="bottom-password-login"]').click()
  106.         time.sleep(0.3)
  107.         browser.find_element_by_id('tab-account').click()
  108.  
  109.         # 登录
  110.         browser.find_element_by_id('account-textbox').clear()
  111.         browser.find_element_by_id('account-textbox').send_keys('***********')
  112.         time.sleep(2)
  113.         browser.find_element_by_id('password-textbox').clear()
  114.         browser.find_element_by_id('password-textbox').send_keys('***********')  # password
  115.         time.sleep(1)
  116.         browser.find_element_by_id('login-button-account').click()
  117.  
  118.         # 登录等待
  119.         time.sleep(3)
  120.  
  121.         return browser
  122.  
  123.     def load_head_img_paths(self,img_dir):
  124.         """
  125.         给定头像图片目录路径,加载所有图片的路径
  126.         :param img_dir:
  127.         :return:
  128.         """
  129.         assert img_dir is not None
  130.         img_paths,_ = Directory_Hanlder.list_dir_all_files(img_dir)
  131.         img_nums = len(img_paths)
  132.  
  133.         self.img_paths = img_paths
  134.         self.img_nums = img_nums
  135.         return img_paths,img_nums
  136.  
  137.     def load_comments_sign(self,comments_path):
  138.         """
  139.         加载文件【①去除空行数据 ②去除首尾空格】至Series中，保存每段文本所对应的行号
  140.         :param comments_path: 文件的路径
  141.         :return: Series
  142.         """
  143.         assert comments_path is not None
  144.  
  145.         # 将数据保存至 Series 中
  146.         comments_ser = pd.Series()
  147.         try:
  148.             with open(comments_path,'r',encoding='utf-8-sig') as w:
  149.                 for row,line in enumerate(w.readlines()):
  150.                     # 对每一行的数据前后去除空格
  151.                     line = line.strip()
  152.                     # 判断去除空格后的数据是否有内容，只要有数据的内容【去除空行数据】
  153.                     if line:
  154.  
  155.                         # 添加行号
  156.                         row_index = row + 1
  157.                         comments_ser.loc[row_index] = line
  158.  
  159.         except Exception as e:
  160.             with open(comments_path, 'r', encoding='gbk') as w:
  161.                 for row, line in enumerate(w.readlines()):
  162.                     # 对每一行的数据前后去除空格
  163.                     line = line.strip()
  164.                     # 判断去除空格后的数据是否有内容，只要有数据的内容【去除空行数据】
  165.                     if line:
  166.  
  167.                         # 添加行号
  168.                         row_index = row + 1
  169.                         comments_ser.loc[row_index] = line
  170.  
  171.         return comments_ser,len(comments_ser)
  172.  
  173.     def dump_head_img(self,url,browser,img_path,time_sleep=1.5):
  174.         """
  175.         上传头像图片的函数,给定 一张头像图片地址进行上传,
  176.         :param url:
  177.         :param time_sleep: 上传图片等待时间提交, 最小为 time_sleep
  178.         :return:
  179.         """
  180.         try:
  181.             browser.find_element_by_xpath("//input[@capture='camera']").send_keys(img_path)
  182.         except:
  183.             # 当找不到元素的时候,重新请求一下页面
  184.             browser.get(url)
  185.             # 获取上传头像 ele 元素
  186.             browser.find_element_by_xpath("//input[@capture='camera']").send_keys(img_path)
  187.  
  188.         # 上传图片等待时间提交,最小为 time_sleep
  189.         tmp1_num = np.random.uniform(time_sleep, time_sleep + 1.5)
  190.         time.sleep(tmp1_num)
  191.  
  192.         # 点击提交 ---- 使用 js 大法
  193.         flag = True
  194.         try:
  195.             js = 'document.getElementById("J_usave").click();'
  196.             browser.execute_script(js)
  197.             # 判断url并非最初的美团图片,才进行打印
  198.             dump_url = browser.find_element_by_xpath("//img[@id='J_bface']").get_attribute('src')
  199.  
  200.             if not dump_url.startswith('https://p0.meituan.net/userheadpic/chicken.png%40120w'):
  201.                 print('随机数等待上传图片时间为: {:.1f} , 上传的图片url为:{}'.format(tmp1_num,dump_url))
  202.  
  203.             if len(self.browser.find_elements_by_class_name('medi-btn-ashdisb')) == 0:
  204.                 print('找不到button的类属性 medi-btn-ashdisb ，判断图片点击失败')
  205.                 flag = False
  206.  
  207.         except Exception as e:
  208.             flag = False
  209.             print('\nERROR: \n',e)
  210.             print('当前图片点击事件触发失败,上传失败，已跳过\n')
  211.  
  212.         # 上传后等待 1.6  -  2.5 s
  213.         time.sleep(np.random.uniform(1.6,2.5))
  214.         time.sleep(100)
  215.         return browser,flag
  216.  
  217.     def dump_text(self,line,browser):
  218.         """
  219.         上传文本
  220.         :return:
  221.         """
  222.         url = "http://www.dianping.com/member/myinfo/setup/basic"
  223.         browser.get(url)
  224.  
  225.         # TODO 给文本域上传文本
  226.         js = "var kw = document.getElementById('J_sign') ;kw.value='{}';".format(line)
  227.         browser.execute_script(js)
  228.  
  229.         time.sleep(1)
  230.         # js = 'document.getElementsByClassName("btn-txt J_submit")[0].click();'
  231.         browser.execute_script(js)
  232.         return browser
  233.  
  234.     def run_img(self,browser):
  235.         """
  236.         仅仅自动上传头像
  237.         :param browser: 浏览器对象
  238.         :return:
  239.         """
  240.         self.browser = browser
  241.  
  242.         # 获取 给定的头像目录路径 所有图片的路径
  243.         img_paths,img_num = self.load_head_img_paths(self.head_img_dir)
  244.         print('一共有 {} 张头像需要上传, 现在正在上传中....'.format(img_num))
  245.  
  246.         # 浏览器请求头像页面链接
  247.         self.browser.get(self.head_img_url)
  248.         for idx,head_img in enumerate(img_paths):
  249.  
  250.             # 每 10 张 图片重新请求下头像上传页面,防止假死状态
  251.             if (idx+1) % 10 == 0:
  252.                 self.browser.get(self.head_img_url)
  253.                 time.sleep(np.random.uniform(0.8,1.4))
  254.  
  255.             # 防止后台检测,每上传25 张图片, 睡眠 60s 的时间
  256.             if (idx + 1) % 25 == 0:
  257.                 for i in range(60):
  258.                     time.sleep(1)
  259.                     print('\r等待 60s 继续上传头像,现在是第{}s '.format(i+1),end='',flush=True)
  260.                 print()
  261.  
  262.                 # 重新请求头像上传的网址
  263.                 self.browser.get(self.head_img_url)
  264.                 time.sleep(np.random.uniform(0.8, 1.4))
  265.  
  266.             # 上传头像
  267.             self.browser,flag = self.dump_head_img(self.head_img_url,self.browser,head_img,time_sleep=self.head_img_sleep)
  268.             if not flag:
  269.                 continue
  270.             elif flag:
  271.                 print('第 {} 张头像图片-{} 上传成功!'.format(idx+1,head_img))
  272.  
  273.         print('头像 {} 张图片已全部上传完毕!'.format(img_num))
  274.         return self.browser
  275.  
  276.     def run_comments(self):
  277.         """"""
  278.         # 更换第二个窗口
  279.         self.browser.switch_to.window(self.windows[-1])
  280.         # 执行 js 更换 window.navigator.webdriver 属性
  281.         self.browser.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
  282.             "source": """Object.defineProperty(navigator, 'webdriver', {get: () => undefined})""",
  283.         })
  284.         # 获取需要所有的文本数据
  285.         comments,num = self.load_comments_sign(self.comments_signs_file)
  286.         print(comments,num)
  287.  
  288.         for idx,line in enumerate(comments):
  289.  
  290.             # 上传文本数据
  291.             self.browser = self.dump_text(line,self.browser)
  292.             print('共 {} 条文本，第 {} 条内容：  {} '.format(num,idx+1,line))
  293.             time.sleep(2)
  294.         return self.browser
  295.  
  296.     def run_all(self):
  297.         pass
  298.  
  299.     def run(self):
  300.         """
  301.         主函数,运行
  302.         :return:
  303.         """
  304.         if self.choice is 'img':
  305.             self.run_img(self.browser)
  306.  
  307.         elif self.choice is 'text':
  308.             self.run_comments()
  309.         elif self.choice is 'all':
  310.             self.run_all()
  311.         else:
  312.             raise Exception("choice 参数输入有误! 从 ['img','text','all'] 选择一个 ")
  313.  
  314. if __name__ == '__main__':
  315.  
  316.     head_img_dir = r'C:\Users\Hasee\Desktop\touxiang'
  317.     comments_sign = r'C:\Users\Hasee\Desktop\作文.txt'
  318.  
  319.     choice = 'text'
  320.  
  321.     obj = DumpMassage(choice = choice,head_img_dir = head_img_dir,comments_signs_file=comments_sign)
  322.     browser = obj.run()
  323.  
  324.     #退出浏览器
  325.     browser.quit()

 

 

Reference

        python解码data:image开头的图片地址

        python 爬取 谷歌以及百度图片

 

 

 

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号