爬虫之图片懒加载技术、selenium和PhantomJS

目录：

知识点回顾

  • 验证码处理流程

 

动态数据加载处理

一.图片懒加载

  • 什么是图片懒加载？
    • 案例分析：抓取站长素材http://sc.chinaz.com/中的图片数据 
      #!/usr/bin/env python
# -*- coding:utf-8 -*-
import requests
from lxml import etree

if __name__ == "__main__":
     url = 'http://sc.chinaz.com/tupian/gudianmeinvtupian.html'
     headers = {
         'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36',
     }
     #获取页面文本数据
     response = requests.get(url=url,headers=headers)
     response.encoding = 'utf-8'
     page_text = response.text
     #解析页面数据（获取页面中的图片链接）
     #创建etree对象
     tree = etree.HTML(page_text)
     div_list = tree.xpath('//div[@id="container"]/div')
     #解析获取图片地址和图片的名称
     for div in div_list:
         image_url = div.xpath('.//img/@src')
         image_name = div.xpath('.//img/@alt')
         print(image_url) #打印图片链接
         print(image_name)#打印图片名称
      View Code

    • 运行结果观察发现，我们可以获取图片的名称，但是链接获取的为空，检查后发现xpath表达式也没有问题，究其原因出在了哪里呢？

    • 图片懒加载概念：

      • 图片懒加载是一种网页优化技术。图片作为一种网络资源，在被请求时也与普通静态资源一样，将占用网络资源，而一次性将整个页面的所有图片加载完，将大大增加页面的首屏加载时间。为了解决这种问题，通过前后端配合，使图片仅在浏览器当前视窗内出现时才加载该图片，达到减少首屏图片请求数的技术就被称为“图片懒加载”。

    • 网站一般如何实现图片懒加载技术呢？

      • 在网页源码中，在img标签中首先会使用一个“伪属性”（通常使用src2，original......）去存放真正的图片链接而并非是直接存放在src属性中。当图片出现到页面的可视化区域中，会动态将伪属性替换成src属性，完成图片的加载。

    • 站长素材案例后续分析：通过细致观察页面的结构后发现，网页中图片的链接是存储在了src2这个伪属性中

      #!/usr/bin/env python
# -*- coding:utf-8 -*-
import requests
from lxml import etree

if __name__ == "__main__":
     url = 'http://sc.chinaz.com/tupian/gudianmeinvtupian.html'
     headers = {
         'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36',
     }
     #获取页面文本数据
     response = requests.get(url=url,headers=headers)
     response.encoding = 'utf-8'
     page_text = response.text
     #解析页面数据（获取页面中的图片链接）
     #创建etree对象
     tree = etree.HTML(page_text)
     div_list = tree.xpath('//div[@id="container"]/div')
     #解析获取图片地址和图片的名称
     for div in div_list:
         image_url = div.xpath('.//img/@src2') #src2伪属性
         image_name = div.xpath('.//img/@alt')
         print(image_url) #打印图片链接
         print(image_name)#打印图片名称
      爬取 站长素材 的高清图片（图片懒加载）
       

二、selenium

import os
import random
from time import sleep
import urllib.request
from selenium import webdriver
from lxml import etree

ua_list = [
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon 2.0)",
    "Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/"
    "535.11"
]
headers = {
    'User-Agent': random.choice(ua_list),
    'connection': 'close',
}
# 设置保存路径
path = r'D:\项目相关\源码\自制\爬虫\taobao\ '
if not os.path.exists(path):
    os.mkdir(path)


def browser_get():
    # chromedriver引擎所在的路径
    chrome_driver = r'E:\chromedriver\chromedriver.exe'
    options = webdriver.ChromeOptions()
    # 指定浏览器分辨率
    options.add_argument('window-size=1920x3000')
    # 设置无头模式，不弹出浏览器
    options.add_argument("--headless")
    # 关闭左上方Chrome正受到自动测试软件的控制的提示
    options.add_experimental_option('useAutomationExtension', False)
    options.add_experimental_option("excludeSwitches", ['enable-automation'])
    browser = webdriver.Chrome(options=options, executable_path=chrome_driver)
    return browser


def scrape_taobao(browser, keyword, page_start, page_end):
    for page in range(page_start-1, page_end):
        url = f'https://uland.taobao.com/sem/tbsearch?keyword={keyword}&pnum={page}'
        try:
            browser.get(url)
            # 窗口最大化
            browser.maximize_window()
            # 下拉滚动条
            browser.execute_script("scroll(0,1500)")
            sleep(1)
            res = browser.page_source
            tree = etree.HTML(res)
            li_list = tree.xpath('//ul[@class="pc-search-items-list"]/li')
            for li in li_list:
                img_url = li.xpath('./a/img/@src')[0].strip('_.webp') # 将原来的URL中的后缀去掉才能下载能打开的图片
                # 将商品名称中的特殊符号去掉
                img_title = li.xpath('./a/div[1]/span/text()')[0].strip().replace('|', '').replace('/', '')
                img_path = path + img_title + '.jpg'
                urllib.request.urlretrieve(url=img_url, filename=img_path)
                print(f'{img_title} ok')
            print(f'page {page+1} ok')
        except Exception as e:
            print('页码或商品不存在', e)
    print('over')


def main():
    browser = browser_get()
    keyword = input('请输入要搜索的商品名称：').strip()
    page_start = input('请输入要搜索的起始页：').strip()
    page_end = input('请输入要搜索的最后一页：').strip()
    if page_start.isdigit() and page_end.isdigit():
        page_start = int(page_start)
        page_end = int(page_end)
        if page_start <= page_end and page_start >= 1:
            scrape_taobao(browser, keyword, page_start, page_end)
        else:
            main()
    else:
        main()


if __name__ == '__main__':
    main()
爬取淘宝商品图片（selenium）
import os
import random
import logging
from time import sleep
import requests
from selenium import webdriver

# 日志输出的基本配置
logging.basicConfig(filename='lol_logging.log', level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s')
ua_list = [
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon 2.0)",
    "Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/"
    "535.11"
]
ua = random.choice(ua_list)
headers = {
    'User-Agent': ua,
    'connection': 'close'
}
# chromedriver引擎所在的路径
chrome_driver = r'E:\chromedriver\chromedriver.exe'

options = webdriver.ChromeOptions()
# 指定浏览器分辨率
options.add_argument('window-size=1920x3000')
# 设置无头模式，不弹出浏览器
options.add_argument("--headless")
# 关闭左上方Chrome正受到自动测试软件的控制的提示
options.add_experimental_option('useAutomationExtension', False)
options.add_experimental_option("excludeSwitches", ['enable-automation'])
browser = webdriver.Chrome(options=options, executable_path=chrome_driver)
# 设置皮肤保存路径
path = r'D:\项目相关\源码\自制\爬虫\lol_hero_skins\ '
if not os.path.exists(path):
    os.mkdir(path)


def create_urls():
    res = requests.get(url='https://game.gtimg.cn/images/lol/act/img/js/heroList/hero_list.js', headers=headers)
    res_json = res.json()
    # https://lol.qq.com/data/info-defail.shtml?id=876
    id_ = []
    for item in res_json['hero']:
        id_.append((item['heroId'], item['name']))
    return id_


def scrape_skin(items):
    name = items[1]
    # 创建英雄名称的文件夹
    if not os.path.exists(path + name):
        os.mkdir(path + name)
    url = f'https://lol.qq.com/data/info-defail.shtml?id={items[0]}'
    # print(url)
    browser.get(url)
    # 窗口最大化
    browser.maximize_window()
    # 下拉滚动条
    browser.execute_script("scroll(0,1500)")
    sleep(2)
    # xpath定位提取图片
    imgs = browser.find_elements_by_xpath('//*[@id="skinNAV"]/li/a/img')
    try:
        for i in imgs:
            # https://game.gtimg.cn/images/lol/act/img/skin/small1000.jpg
            src = i.get_attribute('src')
            # 得到的是略图   替换small 为 big  得到大图
            src = src.replace('small', 'big')
            skin_name = i.get_attribute('alt') + '.jpg'
            # 特殊符号 / 去掉 比如痛苦之拥/K/DA 伊芙琳.jpg 保存就会报错
            if '/' in skin_name:
                skin_name = skin_name.replace('/', '')
            # print(src, skin_name)
            img = requests.get(src, headers=headers).content
            with open(path + name + '/' + skin_name, 'wb') as f:
                f.write(img)
                logging.info(f'已为您成功下载：{skin_name}')
        print(name + ' skins download success!!!')

    except Exception as e:
        logging.info(e.args[0])
        pass


def main():
    nums = create_urls()
    for item in nums:
        scrape_skin(item)
        sleep(random.randint(1, 3))


if __name__ == '__main__':
    main()
爬LOL所有英雄的皮肤（selenium+谷歌无头浏览器 ，日志的使用）
环境安装:pip install selenium
编码流程:
    导包:from selenium import webdriver
    实例化某一款浏览器对象
    自指定自动化操作代码
    
使用方法：
    bro = webdriver.Chrome(executable_path=r'E:\pythonfile\项目new\test\chromedriver.exe')
    bro.get(url='https://www.baidu.com/')  # get方法 打开某个url对应页面
    text_input = bro.find_element_by_id('kw')  # find_element_by_id方法 找到对应标签
    text_input.send_keys('人民币')  # send_keys方法 在input框输入 指定文字
    bro.find_element_by_id('su').click()  # click() 执行对应标签的 click事件  点击搜索按钮
    bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')  # 执行JavaScript
    bro.page_source  # 获取当前的页面源码数据
    bro.quit()  # 关闭浏览器
selenium 的安装使用
from selenium import webdriver
from time import sleep

bro = webdriver.Chrome(executable_path=r'E:\pythonfile\项目new\test\chromedriver.exe')
bro.get(url='https://www.baidu.com/')
sleep(2)
text_input = bro.find_element_by_id('kw')
text_input.send_keys('人民币')
sleep(2)
bro.find_element_by_id('su').click()
sleep(3)

#获取当前的页面源码数据
print(bro.page_source)
bro.quit()
selenium 的简单使用示例
#获取豆瓣电影中更多电影详情数据
from selenium import webdriver
from time import sleep

url = 'https://movie.douban.com/typerank?type_name=%E6%83%8A%E6%82%9A&type=19&interval_id=100:90&action='
bro = webdriver.Chrome(executable_path=r'E:\pythonfile\项目new\test\chromedriver.exe')
bro.get(url)
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(2)
page_text = bro.page_source

with open('./douban.html','w',encoding='utf-8') as fp:
    fp.write(page_text)

sleep(1)
bro.quit()
获取豆瓣电影中更多电影详情数据 简单示例
# 谷歌无头浏览器
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')

# 获取豆瓣电影中更多电影详情数据
from selenium import webdriver
from time import sleep

url = 'https://movie.douban.com/typerank?type_name=%E6%83%8A%E6%82%9A&type=19&interval_id=100:90&action='
bro = webdriver.Chrome(executable_path=r'E:\pythonfile\项目new\test\chromedriver.exe',chrome_options=chrome_options)  # 加上谷歌无头浏览器
bro.get(url)
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(3)
bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
sleep(2)
page_text = bro.page_source

with open('./douban.html','w',encoding='utf-8') as fp:
    fp.write(page_text)
print(page_text)
sleep(1)
bro.quit()
获取豆瓣电影中更多电影详情数据（selenium + 谷歌无头浏览器）
#phantomJs （注意 安装phantomJs）
from selenium import webdriver
from time import sleep

bro = webdriver.PhantomJS(r'PhantomJS驱动路径')
url = 'https://movie.douban.com/typerank?type_name=%E6%83%8A%E6%82%9A&type=19&interval_id=100:90&action='
bro.get(url)
bro.save_screenshot(r'phantomjs\baidu.png')  # 截屏

sleep(1)
bro.quit()
phantomJs 的简单使用
#qq空间
bro = webdriver.Chrome(executable_path=r'E:\pythonfile\项目new\test\chromedriver.exe')
url = 'https://qzone.qq.com/'
bro.get(url=url)
sleep(2)
#定位到一个具体的iframe
bro.switch_to.frame('login_frame')
bro.find_element_by_id('switcher_plogin').click()
sleep(2)

bro.find_element_by_id('u').send_keys('460086804')
bro.find_element_by_id('p').send_keys('shuo0127')

bro.find_element_by_id('login_button').click()

sleep(5)

page_text = bro.page_source
with open('qq.html','w',encoding='utf-8') as fp:
    fp.write(page_text)
bro.quit()
获取qq空间内容（使用selenium，注意iframe）
import re
import time
from lxml import etree
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By


class LagouSpider(object):
    driver_path = r'E:\chromedriver\chromedriver.exe'

    def __init__(self):
        self.driver = webdriver.Chrome(executable_path=LagouSpider.driver_path)
        self.url = 'https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput='
        self.positions = []

    def run(self):
        self.driver.get(self.url)
        # btn = self.driver.find_element_by_class_name('body-btn')
        # btn.click()
        while True:
            source = self.driver.page_source
            WebDriverWait(driver=self.driver, timeout=10).until(
                EC.presence_of_element_located((By.XPATH, "//div[@class='pager_container']/span[last()]"))
            )
            self.parse_list_page(source)
            try:
                next_btn = self.driver.find_element_by_xpath("//div[@class='pager_container']/span[last()]")
                if 'pager_next_disabled' in next_btn.get_attribute('class'):
                    break
                else:
                    next_btn.click()
            except:
                print(source)
            time.sleep(1)

    def parse_list_page(self, source):
        html = etree.HTML(source)
        links = html.xpath('//a[@class="position_link"]/@href')
        for link in links:
            self.request_detail_page(link)
            time.sleep(1)

    def request_detail_page(self, url):
        self.driver.execute_script('window.open(%s)' % url)
        self.driver.switch_to.window(self.driver.window_handles[1])
        WebDriverWait(driver=self.driver, timeout=10).until(
            EC.presence_of_element_located((By.XPATH, "//div[@class='job-name']/span[@class='name']"))
        )
        source = self.driver.page_source
        self.parse_detail_page(source)
        # 关闭当前这个详情页
        self.driver.close()
        # 继续切换回职位列表页
        self.driver.switch_to.window(self.driver.window_handles[0])

    def parse_detail_page(self, source):
        html = etree.HTML(source)
        position_name = html.xpath('//span[@class="name"]/text()')[0]
        job_request_spans = html.xpath('//dd[@class="job_request"]//span')
        salary = job_request_spans[0].xpath('.//text()')[0].strip()
        city = job_request_spans[1].xpath('.//text()')[0].strip()
        city = re.sub(r'[\s/]', '', city)
        work_years = job_request_spans[2].xpath('.//text()')[0].strip()
        work_years = re.sub(r'[\s/]', '', work_years)
        education = job_request_spans[3].xpath('.//text()')[0].strip()
        education = re.sub(r'[\s/]', '', education)
        desc = ''.join(html.xpath('//dd[@class="job_bt"]//text()')).strip()
        company_name = html.xpath('//h2[@class="fl"]/text()')[0].strip()
        position = {
            'name': position_name,
            'company_name': company_name,
            'salary': salary,
            'city': city,
            'work_year': work_years,
            'education': education,
            'desc': desc
        }
        self.positions.append(position)
        print(position)
        print('*' * 33)


if __name__ == '__main__':
    spider = LagouSpider()
    spider.run()
selenium爬拉勾网职位信息

 selunium自动登录12306示例：

from time import sleep
from selenium import webdriver
from selenium.webdriver import ActionChains
from PIL import Image  # 安装PIL或者是Pillow
from chaojiying_img_handle import Chaojiying_Client
from settings import *


def browser_get():
    # chromedriver引擎所在的路径
    chrome_driver = r'E:\chromedriver\chromedriver.exe'
    options = webdriver.ChromeOptions()
    # 加上这句代码，不然验证码会一直报错,因为12306会识别出是使用selenium 登陆的
    options.add_argument("--disable-blink-features=AutomationControlled")
    # 指定浏览器分辨率
    options.add_argument('window-size=1366x954')
    # 关闭左上方Chrome正受到自动测试软件的控制的提示
    options.add_experimental_option('useAutomationExtension', False)
    options.add_experimental_option("excludeSwitches", ['enable-automation'])
    browser = webdriver.Chrome(options=options, executable_path=chrome_driver)
    return browser


# 封装一个识别验证码的函数
def transformCode(imgPath, imgType):
    chaojiying = Chaojiying_Client(chaojiying_user, chaojiying_pwd, chaojiying_soft_id)
    im = open(imgPath, 'rb').read()
    return chaojiying.PostPic(im, imgType)['pic_str']


# 获取验证码图片
def code_img_get(browser):
    # 将当前浏览器页面进行图片保存
    browser.save_screenshot('./main.png')
    # 将验证码的局部区域进行裁剪 捕获标签在页面中的位置信息
    img_tag = browser.find_element_by_xpath('//img[@id="J-loginImg"]')
    location = img_tag.location  # 标签的起始位置坐标（左下角坐标）
    size = img_tag.size  # 标签的尺寸
    # 裁剪范围对应的矩形区域
    rangle = (
        int(location['x']), int(location['y']), int(location['x'] + size['width']), int(location['y'] + size['height'])
    )
    # 使用Image工具进行指定区域的裁剪
    i = Image.open('./main.png')
    frame = i.crop(rangle)  # crop就是根据指定的裁剪范围进行图片的截取
    frame.save('code.png')
    return img_tag


# 验证码结果处理
def img_code_result_handle(browser, result):
    # x1,y1|x2,y2|x3,y3 ==>[[x1,y1],[x2,y2],[x3,y3]]
    all_list = []  # [[x1,y1],[x2,y2],[x3,y3]]    验证码中图片中的点击内容的坐标
    if '|' in result:
        list_1 = result.split('|')
        count_1 = len(list_1)
        for i in range(count_1):
            xy_list = []
            x = int(list_1[i].split(',')[0])
            y = int(list_1[i].split(',')[1])
            xy_list.append(x)
            xy_list.append(y)
            all_list.append(xy_list)
        return all_list
    else:
        try:
            x = int(result.split(',')[0])
            y = int(result.split(',')[1])
            xy_list = []
            xy_list.append(x)
            xy_list.append(y)
            all_list.append(xy_list)
            return all_list
        except:
            print('题分不足或验证码识别错误，即将重试')
            sleep(3)
            code_img_get(browser)


# 输入账号密码验证码点击登录
def login_click(all_list, img_tag, browser):
    # 根据结果点击图片验证码
    for point in all_list:
        x = point[0]
        y = point[1]
        ActionChains(browser).move_to_element_with_offset(img_tag, x, y).click().perform()
        sleep(1)

    browser.find_element_by_id('J-userName').send_keys(user)  # 12306用户名
    browser.find_element_by_id('J-password').send_keys(pwd)  # 密码
    browser.find_element_by_id('J-login').click()  # 点击事件,登录
    sleep(2)
    browser.save_screenshot('./main1.png')

    return browser


# 处理滑块验证
def slide_code(browser):
    try:
        span = browser.find_element_by_id('nc_1_n1z')
        # 对div_tag进行滑动操作
        action = ActionChains(browser)
        # 点击长按指定的标签
        action.click_and_hold(span).perform()
        action.drag_and_drop_by_offset(span, 350, 0).perform()
        print('登录成功')
        sleep(3)
        browser.save_screenshot('./main2.png')
        return browser
    except:
        browser.quit()
        main()


def main():
    browser = browser_get()
    browser.implicitly_wait(10)
    browser.get('https://kyfw.12306.cn/otn/resources/login.html')
    sleep(1)
    # 窗口最大化
    browser.maximize_window()
    # 从二维码登录转到账号密码登录
    browser.find_element_by_xpath('//ul[@class="login-hd"]/li[@class="login-hd-account"]/a').click()
    sleep(1)
    # 获取验证码图片
    img_tag = code_img_get(browser)
    # 调用打码平台进行验证码的识别
    result = transformCode('./code.png', chaojiying_trans_code)
    print(result)  # x1,y1|x2,y2|x3,y3
    # 处理验证码结果格式
    all_list = img_code_result_handle(browser, result)
    # 输入账号密码验证码点击登录
    browser = login_click(all_list, img_tag, browser)
    # 处理滑块验证
    browser = slide_code(browser)
    sleep(1)
    browser.quit()


if __name__ == '__main__':
    main()
login.py
import requests
from hashlib import md5


# 调用了打码平台的相关的接口对指定的验证码图片进行识别，返回图片上的数据值
class Chaojiying_Client(object):

    def __init__(self, username, password, soft_id):
        self.username = username
        password = password.encode('utf8')
        self.password = md5(password).hexdigest()
        self.soft_id = soft_id
        self.base_params = {
            'user': self.username,
            'pass2': self.password,
            'softid': self.soft_id,
        }
        self.headers = {
            'Connection': 'Keep-Alive',
            'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
        }

    def PostPic(self, im, codetype):
        """
        im: 图片字节
        codetype: 题目类型 参考 http://www.chaojiying.com/price.html
        """
        params = {
            'codetype': codetype,
        }
        params.update(self.base_params)
        files = {'userfile': ('ccc.jpg', im)}
        r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files,
                          headers=self.headers)
        return r.json()

    def ReportError(self, im_id):
        """
        im_id:报错题目的图片ID
        """
        params = {
            'id': im_id,
        }
        params.update(self.base_params)
        r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
        return r.json()
chaojiying_img_handle.py（处理图片验证码）
# chaojiying
chaojiying_user = '****'
chaojiying_pwd = '*********'
chaojiying_soft_id = '911742'    # 软件id
chaojiying_trans_code = 9004   # 验证码类型

# 12306
user = '******'
pwd = '*********'
settings.py（12306账号密码和超级鹰账号密码等信息）

 

selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题 selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器

1、环境安装

  • 下载安装selenium：pip install selenium
  • 下载浏览器驱动程序：
    • http://chromedriver.storage.googleapis.com/index.html
  • 查看驱动和浏览器版本的映射关系：
    • http://blog.csdn.net/huilan_same/article/details/51896672

2、简单使用/效果展示

from selenium import webdriver
from time import sleep

# 后面是你的浏览器驱动位置，记得前面加r'','r'是防止字符转义的
driver = webdriver.Chrome(r'驱动程序路径')
# 用get打开百度页面
driver.get("http://www.baidu.com")
# 查找页面的“设置”选项，并进行点击
driver.find_elements_by_link_text('设置')[0].click()
sleep(2)
# # 打开设置后找到“搜索设置”选项，设置为每页显示50条
driver.find_elements_by_link_text('搜索设置')[0].click()
sleep(2)

# 选中每页显示50条
m = driver.find_element_by_id('nr')
sleep(2)
m.find_element_by_xpath('//*[@id="nr"]/option[3]').click()
m.find_element_by_xpath('.//option[3]').click()
sleep(2)

# 点击保存设置
driver.find_elements_by_class_name("prefpanelgo")[0].click()
sleep(2)

# 处理弹出的警告页面   确定accept() 和 取消dismiss()
driver.switch_to_alert().accept()
sleep(2)
# 找到百度的输入框，并输入 美女
driver.find_element_by_id('kw').send_keys('美女')
sleep(2)
# 点击搜索按钮
driver.find_element_by_id('su').click()
sleep(2)
# 在打开的页面中找到“Selenium - 开源中国社区”，并打开这个页面
driver.find_elements_by_link_text('美女_百度图片')[0].click()
sleep(3)

# 关闭浏览器
driver.quit()
View Code
driver.close()：关闭当前页面。
driver.quit()：退出整个浏览器。
关闭页面
find_element_by_id：根据id来查找某个元素。等价于：
 submitTag = driver.find_element_by_id('su')
 submitTag1 = driver.find_element(By.ID,'su')
find_element_by_class_name：根据类名查找元素。 等价于：
 submitTag = driver.find_element_by_class_name('su')
 submitTag1 = driver.find_element(By.CLASS_NAME,'su')
find_element_by_name：根据name属性的值来查找元素。等价于：
 submitTag = driver.find_element_by_name('email')
 submitTag1 = driver.find_element(By.NAME,'email')
find_element_by_tag_name：根据标签名来查找元素。等价于：
 submitTag = driver.find_element_by_tag_name('div')
 submitTag1 = driver.find_element(By.TAG_NAME,'div')
find_element_by_xpath：根据xpath语法来获取元素。等价于：
 submitTag = driver.find_element_by_xpath('//div')
 submitTag1 = driver.find_element(By.XPATH,'//div')
find_element_by_css_selector：根据css选择器选择元素。等价于：

 submitTag = driver.find_element_by_css_selector('//div')
 submitTag1 = driver.find_element(By.CSS_SELECTOR,'//div')
要注意，find_element是获取第一个满足条件的元素。find_elements是获取所有满足条件的元素。
定位元素
1.操作输入框：分为两步。第一步：找到这个元素。第二步：使用send_keys(value)，将数据填充进去。示例代码如下：

 inputTag = driver.find_element_by_id('kw')
 inputTag.send_keys('python')
使用clear方法可以清除输入框中的内容。示例代码如下：

 inputTag.clear()

2.操作checkbox：因为要选中checkbox标签，在网页中是通过鼠标点击的。因此想要选中checkbox标签，那么先选中这个标签，然后执行click事件。示例代码如下：

 rememberTag = driver.find_element_by_name("rememberMe")
 rememberTag.click()

3.选择select：select元素不能直接点击。因为点击后还需要选中元素。这时候selenium就专门为select标签提供了一个类selenium.webdriver.support.ui.Select。将获取到的元素当成参数传到这个类中，创建这个对象。以后就可以使用这个对象进行选择了。示例代码如下：

 from selenium.webdriver.support.ui import Select
 # 选中这个标签，然后使用Select创建对象
 selectTag = Select(driver.find_element_by_name("jumpMenu"))
 # 根据索引选择
 selectTag.select_by_index(1)
 # 根据值选择
 selectTag.select_by_value("http://www.95yueba.com")
 # 根据可视的文本选择
 selectTag.select_by_visible_text("95秀客户端")
 # 取消选中所有选项
 selectTag.deselect_all()

4.操作按钮：操作按钮有很多种方式。比如单击、右击、双击等。这里讲一个最常用的。就是点击。直接调用click函数就可以了。示例代码如下：

 inputTag = driver.find_element_by_id('su')
 inputTag.click()
操作表单元素
有时候在页面中的操作可能要有很多步，那么这时候可以使用鼠标行为链类ActionChains来完成。比如现在要将鼠标移动到某个元素上并执行点击事件。那么示例代码如下：

inputTag = driver.find_element_by_id('kw')
submitTag = driver.find_element_by_id('su')

actions = ActionChains(driver)
actions.move_to_element(inputTag)
actions.send_keys_to_element(inputTag,'python')
actions.move_to_element(submitTag)
actions.click(submitTag)
actions.perform()
还有更多的鼠标相关的操作。

click_and_hold(element)：点击但不松开鼠标。
context_click(element)：右键点击。
double_click(element)：双击。 更多方法请参考：http://selenium-python.readthedocs.io/api.html
行为链
获取所有的cookie：
 for cookie in driver.get_cookies():
     print(cookie)
根据cookie的key获取value：
 value = driver.get_cookie(key)
删除所有的cookie：
 driver.delete_all_cookies()
删除某个cookie：
 driver.delete_cookie(key)
Cookie操作
现在的网页越来越多采用了 Ajax 技术，这样程序便不能确定何时某个元素完全加载出来了。如果实际页面等待时间过长导致某个dom元素还没出来，但是你的代码直接使用了这个WebElement，那么就会抛出NullPointer的异常。为了解决这个问题。所以 Selenium 提供了两种等待方式：一种是隐式等待、一种是显式等待。

1.隐式等待：调用driver.implicitly_wait。那么在获取不可用的元素之前，会先等待10秒中的时间。示例代码如下：

driver = webdriver.Chrome(executable_path=driver_path)
driver.implicitly_wait(10)
# 请求网页
driver.get("https://www.douban.com/")

2.显示等待：显示等待是表明某个条件成立后才执行获取元素的操作。也可以在等待的时候指定一个最大的时间，如果超过这个时间那么就抛出一个异常。显示等待应该使用selenium.webdriver.support.excepted_conditions期望的条件和selenium.webdriver.support.ui.WebDriverWait来配合完成。示例代码如下：

 from selenium import webdriver
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC

 driver = webdriver.Firefox()
 driver.get("http://somedomain/url_that_delays_loading")
 try:
     element = WebDriverWait(driver, 10).until(
         EC.presence_of_element_located((By.ID, "myDynamicElement"))
     )
 finally:
     driver.quit()

3.一些其他的等待条件：

presence_of_element_located：某个元素已经加载完毕了。
presence_of_all_emement_located：网页中所有满足条件的元素都加载完毕了。
element_to_be_cliable：某个元素是可以点击了。

更多条件请参考：http://selenium-python.readthedocs.io/waits.html
页面等待
有时候窗口中有很多子tab页面。这时候肯定是需要进行切换的。selenium提供了一个叫做switch_to_window来进行切换，具体切换到哪个页面，可以从driver.window_handles中找到。示例代码如下：

# 打开一个新的页面
self.driver.execute_script("window.open('"+url+"')")
# 切换到这个新的页面中
self.driver.switch_to_window(self.driver.window_handles[1])
切换页面
有时候频繁爬取一些网页。服务器发现你是爬虫后会封掉你的ip地址。这时候我们可以更改代理ip。更改代理ip，不同的浏览器有不同的实现方式。这里以Chrome浏览器为例来讲解：

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://110.73.2.248:8123")
driver_path = r"D:\ProgramApp\chromedriver\chromedriver.exe"
driver = webdriver.Chrome(executable_path=driver_path,chrome_options=options)

driver.get('http://httpbin.org/ip')
设置代理ip
from selenium.webdriver.remote.webelement import WebElement类是每个获取出来的元素的所属类。
有一些常用的属性：

get_attribute：这个标签的某个属性的值。
screentshot：获取当前页面的截图。这个方法只能在driver上使用。
driver的对象类，也是继承自WebElement。
WebElement元素

3、浏览器创建

Selenium支持非常多的浏览器，如Chrome、Firefox、Edge等，还有Android、BlackBerry等手机端的浏览器。另外，也支持无界面浏览器PhantomJS。

from selenium import webdriver
  
browser = webdriver.Chrome()
browser = webdriver.Firefox()
browser = webdriver.Edge()
browser = webdriver.PhantomJS()
browser = webdriver.Safari()

4、元素定位

webdriver 提供了一系列的元素定位方法，常用的有以下几种：

find_element_by_id()
find_element_by_name()
find_elements_by_class_name()
find_elements_by_tag_name()
find_elements_by_link_text()
find_element_by_partial_link_text()
find_element_by_xpath()
find_element_by_css_selector()

注意

1、find_element_by_xxx找的是第一个符合条件的标签，find_elements_by_xxx找的是所有符合条件的标签。

2、根据ID、CSS选择器和XPath获取，它们返回的结果完全一致。

3、另外，Selenium还提供了通用方法find_element()，它需要传入两个参数：查找方式By和值。实际上，它就是find_element_by_id()这种方法的通用函数版本，比如find_element_by_id(id)就等价于find_element(By.ID, id)，二者得到的结果完全一致。

5、节点交互

Selenium可以驱动浏览器来执行一些操作，也就是说可以让浏览器模拟执行一些动作。比较常见的用法有：输入文字时用send_keys()方法，清空文字时用clear()方法，点击按钮时用click()方法。示例如下：

from selenium import webdriver
import time
 
browser = webdriver.Chrome()
browser.get('https://www.taobao.com')
input = browser.find_element_by_id('q')
input.send_keys('MAC')
time.sleep(1)
input.clear()
input.send_keys('IPhone')
button = browser.find_element_by_class_name('btn-search')
button.click()
browser.quit()
View Code

6、动作链

在上面的实例中，一些交互动作都是针对某个节点执行的。比如，对于输入框，我们就调用它的输入文字和清空文字方法；对于按钮，就调用它的点击方法。其实，还有另外一些操作，它们没有特定的执行对象，比如鼠标拖曳、键盘按键等，这些动作用另一种方式来执行，那就是动作链。

比如，现在实现一个节点的拖曳操作，将某个节点从一处拖曳到另外一处，可以这样实现：

from selenium import webdriver
from selenium.webdriver import ActionChains
import time
browser = webdriver.Chrome()
url = 'http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable'
browser.get(url)
browser.switch_to.frame('iframeResult')
source = browser.find_element_by_css_selector('#draggable')
target = browser.find_element_by_css_selector('#droppable')
actions = ActionChains(browser)
# actions.drag_and_drop(source, target)
# actions.perform() #执行动作链
actions.click_and_hold(source)
time.sleep(3)
for i in range(5):
    actions.move_by_offset(xoffset=17,yoffset=0).perform()
    time.sleep(0.5)

actions.release()
View Code

7、执行JavaScript

对于某些操作，Selenium API并没有提供。比如，下拉进度条，它可以直接模拟运行JavaScript，此时使用execute_script()方法即可实现，代码如下：

from selenium import webdriver
 
browser = webdriver.Chrome()
browser.get('https://www.jd.com/')
browser.execute_script('window.scrollTo(0, document.body.scrollHeight)')
browser.execute_script('alert("123")')

8、获取页面源码数据

通过page_source属性可以获取网页的源代码，接着就可以使用解析库（如正则表达式、Beautiful Soup、pyquery等）来提取信息了。

9、前进和后退 

#模拟浏览器的前进后退
import time
from selenium import webdriver
 
browser=webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.get('https://www.taobao.com')
browser.get('http://www.sina.com.cn/')
 
browser.back()
time.sleep(10)
browser.forward()
browser.close()
模拟浏览器的前进后退

10、Cookie处理

使用Selenium，还可以方便地对Cookies进行操作，例如获取、添加、删除Cookies等。示例如下：

from selenium import webdriver
 
browser = webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
print(browser.get_cookies())
browser.add_cookie({'name': 'name', 'domain': 'www.zhihu.com', 'value': 'germey'})
print(browser.get_cookies())
browser.delete_all_cookies()
print(browser.get_cookies())
View Code

11、异常处理

from selenium import webdriver
from selenium.common.exceptions import TimeoutException,NoSuchElementException,NoSuchFrameException

try:
    browser=webdriver.Chrome()
    browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
    browser.switch_to.frame('iframssseResult')

except TimeoutException as e:
    print(e)
except NoSuchFrameException as e:
    print(e)
finally:
    browser.close()
异常处理
 

三、phantomJS

PhantomJS是一款无界面的浏览器，其自动化操作流程和上述操作谷歌浏览器是一致的。由于是无界面的，为了能够展示自动化操作流程，PhantomJS为用户提供了一个截屏的功能，使用save_screenshot函数实现。

from selenium import webdriver
import time

# phantomjs路径
path = r'PhantomJS驱动路径'
browser = webdriver.PhantomJS(path)

# 打开百度
url = 'http://www.baidu.com/'
browser.get(url)

time.sleep(3)

browser.save_screenshot(r'phantomjs\baidu.png')

# 查找input输入框
my_input = browser.find_element_by_id('kw')
# 往框里面写文字
my_input.send_keys('美女')
time.sleep(3)
#截屏
browser.save_screenshot(r'phantomjs\meinv.png')

# 查找搜索按钮
button = browser.find_elements_by_class_name('s_btn')[0]
button.click()

time.sleep(3)

browser.save_screenshot(r'phantomjs\show.png')

time.sleep(3)

browser.quit()
View Code

四、谷歌无头浏览器

由于PhantomJs最近已经停止了更新和维护，所以推荐大家可以使用谷歌的无头浏览器，是一款无界面的谷歌浏览器。

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time
 
# 创建一个参数对象，用来控制chrome以无界面模式打开
chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
# 驱动路径
path = r'C:\Users\ZBLi\Desktop\1801\day05\ziliao\chromedriver.exe'
 
# 创建浏览器对象
browser = webdriver.Chrome(executable_path=path, chrome_options=chrome_options)
 
# 上网
url = 'http://www.baidu.com/'
browser.get(url)
time.sleep(3)
 
browser.save_screenshot('baidu.png')
 
browser.quit()
View Code

1、登录qq空间，爬取数据

import requests
from selenium import webdriver
from lxml import etree
import time

driver = webdriver.Chrome(executable_path='/Users/bobo/Desktop/chromedriver')
driver.get('https://qzone.qq.com/')
#在web 应用中经常会遇到frame 嵌套页面的应用，使用WebDriver 每次只能在一个页面上识别元素，对于frame 嵌套内的页面上的元素，直接定位是定位是定位不到的。这个时候就需要通过switch_to_frame()方法将当前定位的主体切换了frame 里。
driver.switch_to.frame('login_frame')
driver.find_element_by_id('switcher_plogin').click()

#driver.find_element_by_id('u').clear()
driver.find_element_by_id('u').send_keys('328410948')  #这里填写你的QQ号
#driver.find_element_by_id('p').clear()
driver.find_element_by_id('p').send_keys('xxxxxx')  #这里填写你的QQ密码
    
driver.find_element_by_id('login_button').click()
time.sleep(2)
driver.execute_script('window.scrollTo(0,document.body.scrollHeight)')
time.sleep(2)
driver.execute_script('window.scrollTo(0,document.body.scrollHeight)')
time.sleep(2)
driver.execute_script('window.scrollTo(0,document.body.scrollHeight)')
time.sleep(2)
page_text = driver.page_source

tree = etree.HTML(page_text)
#执行解析操作
li_list = tree.xpath('//ul[@id="feed_friend_list"]/li')
for li in li_list:
    text_list = li.xpath('.//div[@class="f-info"]//text()|.//div[@class="f-info qz_info_cut"]//text()')
    text = ''.join(text_list)
    print(text+'\n\n\n')
    
driver.close()
View Code

2、尽可能多的爬取豆瓣网中的电影信息

from selenium import webdriver
from time import sleep
import time

if __name__ == '__main__':
    url = 'https://movie.douban.com/typerank?type_name=%E6%81%90%E6%80%96&type=20&interval_id=100:90&action='
    # 发起请求前，可以让url表示的页面动态加载出更多的数据
    path = r'C:\Users\Administrator\Desktop\爬虫授课\day05\ziliao\phantomjs-2.1.1-windows\bin\phantomjs.exe'
    # 创建无界面的浏览器对象
    bro = webdriver.PhantomJS(path)
    # 发起url请求
    bro.get(url)
    time.sleep(3)
    # 截图
    bro.save_screenshot('1.png')

    # 执行js代码（让滚动条向下偏移n个像素（作用：动态加载了更多的电影信息））
    js = 'window.scrollTo(0,document.body.scrollHeight)'
    bro.execute_script(js)  # 该函数可以执行一组字符串形式的js代码
    time.sleep(2)

    bro.execute_script(js)  # 该函数可以执行一组字符串形式的js代码
    time.sleep(2)
    bro.save_screenshot('2.png') 
    time.sleep(2) 
    # 使用爬虫程序爬去当前url中的内容 
    html_source = bro.page_source # 该属性可以获取当前浏览器的当前页的源码（html） 
    with open('./source.html', 'w', encoding='utf-8') as fp: 
        fp.write(html_source) 
    bro.quit()
View Code

3、selenium规避被检测识别

现在不少大网站有对selenium采取了监测机制。比如正常情况下我们用浏览器访问淘宝等网站的 window.navigator.webdriver的值为 
undefined。而使用selenium访问则该值为true。那么如何解决这个问题呢？

只需要设置Chromedriver的启动参数即可解决问题。在启动Chromedriver之前，为Chrome开启实验性功能参数excludeSwitches，它的值为['enable-automation']，完整代码如下：

from selenium.webdriver import Chrome
from selenium.webdriver import ChromeOptions

option = ChromeOptions()
option.add_experimental_option('excludeSwitches', ['enable-automation'])
driver = Chrome(options=option)

 

posted on 2020-01-16 17:55  始终不够啊  阅读(280)  评论(0)  编辑  收藏  举报