Python+Selenium 自动化测试 2. Webdriver API介绍

目录

一 Webdriver介绍

二 webdriver实现的原理

三  API介绍

Webdriver 元素的查找的八种方式

find_element_by_id()  源码

find_element_by_name()  源码

find_element_by_link_text() 源码

find_element_by_partial_link_text()  源码

find_element_by_tag_name() 源码

find_element_by_class_name() 源码：

find_element_by_css_selector()

find_elements_by_xpath() 

execute_script（） # JS操作

复数形式的8中元素查找

四 浏览器的基本操作

driver.get() #打开地址

driver.title 获取title

current_url  获取当前页面的URL

page_source # 返回页面的源码

driver.refresh() #刷新

driver.forward() # 前进

driver.back() # 后退

driver.maximize_window()  # 最大化浏览器

driver.minimize_window()  #最小化浏览器

五 窗口操作 

current_window_handle() #获得当前窗口的句柄

window_handles()  #获得当前所有打开的窗口的句柄

switch_to_window   #切换窗口

fullscreen_window   # 全屏浏览器

set_window_size #设置窗口的大小

get_window_size  #获得当前窗口的高度和大小

set_window_position # 设置窗口的坐标

get_window_position  # 获得当前窗口的坐标

get_window_rect  

set_window_rect

六 关闭浏览器

driver.close()

driver.quit()

七 切换

switch_to

switch_to_active_element   # 返回当前的焦点对象 

switch_to_window  # 切换窗口

switch_to_frame  

switch_to_default_content    # 嵌套frame操作

switch_to_alert

switch_to_alert  和switch_to_window的区别？

alert的操作

八 浏览器Cookie操作

cookie的结构和具体的信息

driver.get_cookies()  # 获得所有cookie信息

driver.get_cookie(name)    # 返回字典的key为“name”的cookie信息

driver.delete_cookie(name)

driver.delete_all_cookies()  # 删除所有的cookie信息

driver.add_cookie()  #添加cookie

绕过登录的验证码

九 等待时间

implicitly_wait()   # 隐式等待

selenium的显示等待

元素出现：until()

元素消失： until_not（）

driver.set_script_timeout()

driver.set_page_load_timeout() 

desired_capabilities

十 截图

driver.get_screenshot_as_file("D:\\Test\\1.png") # 截图,并设置保存路径

driver.save_screenshot()  #保存截图

driver.get_screenshot_as_png()  #截图，保存为二进制数据

driver.get_screenshot_as_base64()  #截图，保存为base64格式

十一 日志

driver.get_log() 

driver.log_types

---

一 Webdriver介绍

通过向远程服务器发送命令来控制浏览器。
该服务器应该运行WebDriver有线协议

属性：
       -  session_id  - 此WebDriver启动和控制的浏览器会话的字符串ID。
       - 功能 - 返回此浏览器会话的有效功能

       -  command_executor  - 用于执行命令的remote_connection.RemoteConnection对象。
       -  error_handler  - 用于处理错误的errorhandler.ErrorHandler对象。

创建一个使用有线协议发出命令的新驱动程序。

        ：参数数量：
          -  command_executor  - 表示远程服务器的URL或自定义的字符串
             remote_connection.RemoteConnection对象。默认为“http://127.0.0.1:4444/wd/hub”。
          -  desired_capabilities  - 请求何时的功能字典
             启动浏览器会话。必需参数。
          -  browser_profile  -  selenium.webdriver.firefox.firefox_profile.FirefoxProfile对象。
             仅在请求Firefox时使用。可选的。
          -  proxy  - 一个selenium.webdriver.common.proxy.Proxy对象。浏览器会话将
             如果可能，请使用给定的代理设置启动。可选的。
          -  keep_alive  - 是否配置要使用的remote_connection.RemoteConnection
             HTTP保持活跃。默认为False。
          -  file_detector  - 在实例化期间传递自定义文件检测器对象。如果没有，
             然后将使用默认的LocalFileDetector（）。
          -  options  - 驱动程序options.Options类的实例

二 webdriver实现的原理

关于实现的原理，可以看下这个博主的总结：

webdriver实现原理

WebDriver 是按照 server – client 的经典设计模式设计的。
server 端就是 remote server，可以是任意的浏览器。当我们的脚本启动浏览器后，该浏览器就是 remote server，它的职责就是等待 client 发送请求并做出相应。client 端简单说来就是我们的测试代码，我们测试代码中的一些行为，比如打开浏览器，转跳到特定的 url 等操作是以 http 请求的方式发送给被 测试浏览器，也就是 remote server；remote server 接受请求，并执行相应操作，并在 response 中返回执行状态、返回值等信息。
 

webdriver 的工作流程：
1. WebDriver 启动目标浏览器，并绑定到指定端口。该启动的浏览器实例，做为 WebDriver 的 remote
server。
2. Client 端通过 CommandExcuter 发送 HTTPRequest 给 remote server 的侦听端口（通信协议： the
webriver wire protocol）
3. Remote server 需要依赖原生的浏览器组件（如：IEDriverServer.exe、chromedriver.exe），来转化转
化浏览器的 native 调用

 

webdriver 利用的是驱动来操作浏览器中的页面元素。 具体的过程是这样的，利用各种驱动（谷歌的 chromedriver 等）来控制浏览器 ，这里也就是为什么我们每次新建一个 webdriver 对象时，需要这样定义。driver=webdriver.Chrome() 不同的浏览器需要使用不同的方法，驱动也不一样。然后操作浏览器时使用的是与浏览器之间的通信协议 The WebDriver Wire Protocol 。

 

每次都使用 json 来传输数据。客户端发送一个 requset，服务器端返回一个 response。代码控制驱动器然后驱动去控制浏览器 然后浏览器完成我们代码的需要的操作。

 

每次都需要借助一个 ComandExecutor 发送一个命令，实际上是一个 HTTP request 给监听端口上的 Web Service。在我们的 HTTP request 的 body 中，会以 WebDriver Wire 协议规定的 JSON 格式的字符串来告诉浏览器怎么做。

三  API介绍

详细的API介绍，这个从网上找的别人写好的总结，非常棒。

Webdriver 元素的查找的八种方式

1. find_element_by_id()
2. find_element_by_name()
3. find_element_by_class_name()
4. find_element_by_tag_name()
5. find_element_by_link_text()
6. find_element_by_partial_link_text()
7. find_element_by_xpath()
8. find_element_by_css_selector()

• find_element_by_id()  源码

例子

driver.find_element_by_id("kw")

• find_element_by_name()  源码

例子：

find_element_by_name("wd")

• find_element_by_link_text() 源码

例子：

地图

find_element_by_link_text("地图")

• find_element_by_partial_link_text()  源码

parial link 定位是对 link 定们的一个种补充，有些文本连接会比较长，这个时候我们可以取文本链接的有一部分定位，只要这一部分信息可以唯一的标识这个链接。

例子：

链接非常的长长长哒哒哒哒哒哒多点对点

find_element_by_partial_link_text("链接非常的长")

• find_element_by_tag_name() 源码

Args: tag定位取的是一个HTML页面的 tag(标签) 比如：h1, a, span

缺点：元素很多都是相同的tag，定位会不准确，不推荐使用

• find_element_by_class_name() 源码：

• find_element_by_css_selector()

CSS语法：

例子：

find_element_by_css_selector(".s_ipt") 

find_element_by_css_selector("#kw")

• find_elements_by_xpath() 

例子：

find_element_by_xpath("//input[@id='kw']")

• execute_script（） # JS操作

js="return $('#nv a')"

link = driver.execute_script(js)

• 复数形式的8中元素查找

1. find_elements_by_id()
2. find_elements_by_name()
3. find_elements_by_class_name()
4. find_elements_by_tag_name()
5. find_elements_by_link_text()
6. find_elements_by_partial_link_text()
7. find_elements_by_xpath()
8. find_elements_by_css_selector()

四 浏览器的基本操作

• driver.get() #打开地址

例子：

from selenium import webdriver

driver = webdriver.FireFox()

driver.get("http://www.baidu.com")

• driver.title 获取title

例子：

import time
from selenium import webdriver
 
 
driver = webdriver.Chrome()

 driver.get("http://www.baidu.com/")
time.sleep(1)
driver.find_element_by_link_text("新闻").click()
time.sleep(1)
print (driver.title)  # title方法可以获取当前页面的标题显示的字段

• current_url  获取当前页面的URL

import time
from selenium import webdriver

driver = webdriver.FireFox()
drive.get("https://www.baidu.com")
driver.find_element_by_link_text("新闻").click()

current_url = driver.current_url  # 获取当前页面的url
print(current_url)
driver.quit()

• page_source # 返回页面的源码

用途：当你8大元素定位都定位不到时候，你可以用这个试试，获取到页面信息，用正则提取出我们想要的东西

例子：

from selenium import webdriver

driver = webdriver.FireFox()
driver.get("https://blog.csdn.net/ricky_yangrui")
page = driver.page_source
print(page)

• driver.refresh() #刷新

from selenium import webdriver

import time

driver = webdriver.FireFox()
driver.get("http://www.baidu.com")
time.sleep(3)
driver.refresh()

• driver.forward() # 前进

• driver.back() # 后退

from selenium import webdriver
import time

driver = webdriver.FireFox()
driver.get("https://www.baidu.com")
time.sleep(2)
driver.get("https://www.hao123.com")
time.sleep(2)
# 返回到上一页
driver.back()
time.sleep(3)
# 切换到下一页
driver.forward()

• driver.maximize_window()  # 最大化浏览器

相当于我们浏览器的 最大化浏览器

• driver.minimize_window()  #最小化浏览器

例子：相当于我们点击浏览器右上角的  -  号， 最小化浏览器

import time
from selenium import webdriver
import re
driver = webdriver.Firefox()
driver.get("https://www.baidu.com")
time.sleep(2)
driver.minimize_window()

五 窗口操作 

• current_window_handle() #获得当前窗口的句柄

• window_handles()  #获得当前所有打开的窗口的句柄

• switch_to_window   #切换窗口

例子：

#coding=utf-8
from selenium import webdriver
driver = webdriver.Firefox()
driver.implicitly_wait(10)
driver.get("http://www.baidu.com")
#获得百度搜索窗口句柄
sreach_windows= driver.current_window_handle
driver.find_element_by_link_text(u'登录').click()
driver.find_element_by_link_text(u"立即注册").click()

#获得当前所有打开的窗口的句柄
all_handles = driver.window_handles
#进入注册窗口
for handle in all_handles:
    if handle != sreach_windows:
        driver.switch_to_window(handle)
        print 'now register window!'
        driver.find_element_by_name("account").send_keys('username')
        driver.find_element_by_name('password').send_keys('password')
#……
#进入搜索窗口
for handle in all_handles:
    if handle == sreach_windows:
        driver.switch_to_window(handle)
        print 'now sreach window!'
        driver.find_element_by_id('TANGRAM__PSP_2__closeBtn').click()
        driver.find_element_by_id("kw").send_keys("selenium")
        driver.find_element_by_id("su").click()
        time.sleep(5)
driver.quit()

• fullscreen_window   # 全屏浏览器

例子：

import time
from selenium import webdriver
import re
driver = webdriver.Firefox()
driver.get("https://www.baidu.com")
time.sleep(2)
# 全屏
driver.fullscreen_window()

• set_window_size #设置窗口的大小

# 设置窗口大小500 * 234
driver.set_window_size(500, 234)

• get_window_size  #获得当前窗口的高度和大小

例子：

• set_window_position # 设置窗口的坐标

• get_window_position  # 获得当前窗口的坐标

例子：

• get_window_rect  

例子：

• set_window_rect

例子： 见源码上的 Usage

六 关闭浏览器

1. close用于关闭当前窗口，当打开的窗口较多时，就可以用close关闭部分窗口
2. quit用于结束进程，关闭所有的窗口

Note: 有时候写driver.close()  会报错

sys.meta_path is None, Python is likely shutting down，这个我们看源代码就发现了，close只是关闭其中一个窗口，并没有关闭进程，看quit() ，就发现了，他是关闭了进程的 self.stop_client()  ，遇到这个报错的时候，我们可以使用driver.quit()  试试。

 

• driver.close()

• driver.quit()

七 切换

• switch_to

我们看源码上的例子：

element = driver.switch_to.active_element
alert = driver.switch_to.alert
driver.switch_to.default_content()
driver.switch_to.frame('frame_name')
driver.switch_to.frame(1)
driver.switch_to.frame(driver.find_elements_by_tag_name("iframe")[0])
driver.switch_to.parent_frame()
driver.switch_to.window('main')

alert ——返回浏览器的Alert对象，可对浏览器alert、confirm、prompt框操作
default_content() ——切到主文档
frame(frame_reference) ——切到某个frame
parent_frame() ——切到父frame，这个方法也不常被人所知，但有多层frame的时候很有用
window(window_name) ——切到某个浏览器窗口 
active_element ——返回当前焦点的WebElement对象

• switch_to_active_element   # 返回当前的焦点对象 

焦点就是我们操作网页的时候，光标的位置；

例子：我们常用的就是新建文件夹的时候，点击了右键，新建，我们的光标就会到新建的文件夹上，这个时候我们要输入名字，光标是在文件夹里面闪动的，这个时候我们就可以用  switch_to_active_element  去输入名字，完成新建文件夹的操作；

l = driver.find_element_by_id('pm_treeRoom_1_span')
ActionChains(driver).context_click(l).perform()

driver.find_element_by_class_name('fnew').click()
time.sleep(2)
driver.switch_to.active_element.send_keys('filename')
time.sleep(2)

• switch_to_window  # 切换窗口

这个前面说过了。

• switch_to_frame  

这个方法假如被划了横线，那我们用  switch_to.frame

frame标签有frameset、frame、iframe三种，frameset跟其他普通标签没有区别，不会影响到正常的定位，而frame与iframe对selenium定位而言是一样的，selenium有一组方法对frame进行操作

driver.switch_to.frame(0)  # 1.用frame的index来定位，第一个是0
# driver.switch_to.frame("frame1")  # 2.用id来定位
# driver.switch_to.frame("myframe")  # 3.用name来定位
# driver.switch_to.frame(driver.find_element_by_tag_name("iframe")) # # 4.用WebElement对象来定位

切换进入了，如何切换回来？

driver.switch_to.default_content()

• switch_to_default_content    # 嵌套frame操作

例子：

    


# 一层一层的进入
driver.switch_to.frame("frame1")
driver.switch_to.frame("frame2")

# 从frame2再切回frame1，这里selenium给我们提供了一个方法能够从
子frame切回到父frame，而不用我们切回主文档再切进来。相当于 back
driver.switch_to.parent_frame()  # 如果当前已是主文档，则无效果

# 切到 “frame1” 下的 “第一个frame” 下的 “frame3” 中
driver.switch_to.frame('frame1.0.frame3')

• switch_to_alert

switch_to_alert  和switch_to_window的区别？

alert：浏览器的弹出框

window：浏览器的窗口，我们点一个链接，会跳转到另外一个窗口中。alert和window是父子关系，alert必须依托某一个窗口

div对话框： 这个我们打开F12，可以看到他的元素，能够直接的定位。

alert的操作

 selenium.webdriver.common.alert.Alert(driver)

Alert(driver).accept()  # 确认
Alert(driver).dismiss()  # 取消
Alert(driver).authenticate(username,password)  # 验证，针对需要身份验证的alert
Alert(driver).send_keys(keysToSend)  # 发送文本，对有提交需求的prompt框
Alert(driver).text  # 获取alert文本内容，对有信息显示的alert框

例子：

# -*- coding: utf-8 -*-
from selenium import webdriver
from time import sleep

driver = webdriver.Firefox()
driver.maximize_window()
driver.get('http://sahitest.com/demo/alertTest.htm')

driver.find_element_by_name('b1').click()

a1 = driver.switch_to.alert  # 通过switch_to.alert切换到alert
sleep(1)
print a1.text  # text属性输出alert的文本
a1.accept()  # alert“确认”

# a1.dismiss()   #alert取消

# a1.send_keys("test words") #往prompt的alert中输入字符
# print driver.find_element_by_name('b1').get_attribute('value')

八 浏览器Cookie操作

cookie的结构和具体的信息

cookie ={u'domain': u'.cnblogs.com',
            u'name': u'.CNBlogsCookie',
            u'value': u'xxxx',
            u'expiry': 1491887887,
            u'path': u'/',
            u'httpOnly': True,
            u'secure': False}

name：cookie的名称

value：cookie对应的值，动态生成的

domain：服务器域名

expiry：Cookie有效终止日期

path：Path属性定义了Web服务器上哪些路径下的页面可获取服务器设置的Cookie

httpOnly：防脚本攻击

secure:在Cookie中标记该变量，表明只有当浏览器和Web Server之间的通信协议为加密认证协议时，

浏览器才向服务器提交相应的Cookie。当前这种协议只有一种，即为HTTPS。

• driver.get_cookies()  # 获得所有cookie信息

例子：

from selenium import webdriver
 
driver = webdriver.Firefox()
driver.get("http://www.baidu.com")
 
# 获取cookie信息
cookie = driver.get_cookies()
print(cookie)
         
driver.quit()　

结果：cookie数据是以字典的形式进行存放的。

• driver.get_cookie(name)    # 返回字典的key为“name”的cookie信息

• driver.delete_cookie(name)

• driver.delete_all_cookies()  # 删除所有的cookie信息

例子：

# coding:utf-8
from selenium import webdriver
import time

driver = webdriver.Firefox()
# 启动浏览器后获取cookies
print driver.get_cookies()
driver.get("https://blog.csdn.net/ricky_yangrui/")
# 打开主页后获取cookies
print driver.get_cookies()
# 登录后获取cookies
url = "https://passport.csdn.net/login"
driver.get(url)
driver.implicitly_wait(30)
driver.find_element_by_id("input1").send_keys(u"ricky_yangrui")
driver.find_element_by_id("input2").send_keys(u"xxx")
driver.find_element_by_id("signin").click()
time.sleep(3)
print driver.get_cookies()

# 获取指定name的cookie
print driver.get_cookie(name=".csdn.net")

# 清除指定name的cookie
driver.delete_cookie(name=".csdn.net")
print driver.get_cookies()
# 为了验证此cookie是登录的，可以删除后刷新页面
driver.refresh()

# 清除所有的cookie
driver.delete_all_cookies()
print driver.get_cookies()

• driver.add_cookie()  #添加cookie

例子：

from selenium import webdriver
 
driver = webdriver.Firefox()
driver.get("http://www.youdao.com")
 
# 向cookie中添加新的信息
driver.add_cookie({'name':'key-aaaaa', 'value':'value-bbbbb'})
 
# 遍历cookie信息
for cookie in driver.get_cookies():
    print("%s -> %s" % (cookie['name'], cookie['value']))
 
driver.quit()

结果返回：

绕过登录的验证码

利用add_cookie  我们可以绕过登录的验证码。在登录的时候勾选记住密码，当下次访问该网站时就默认处于登录状态了。记住密码功能其实就记录了浏览器的cookie中。通过webdriver来操作浏览器的cookie，可以通过add_cookie()方法将用户名密码写入浏览器cookie，当再次访问时，服务器将直接读取浏览器的cookie进行登录。

Note：登录的时候需要勾选 下次自动登录按钮。没有记住登录状态的不合适

from selenium import webdriver
import time

driver = webdriver.Firefox()
driver.get("http://192.168.1.51/oneCard/login")
#将用户名密码写入浏览器cookie中
driver.add_cookie({'name':'username','value':'super'})
driver.add_cookie({'name':'password','value':'asd,./123*.'})
#再次访问网站，将会自动登录
driver.get("http://192.168.1.51/oneCard/login")
driver.refresh() #刷新下我们直接就登录进去了

九 等待时间

• implicitly_wait()   # 隐式等待

例子：

原理：隐式等待，就是在创建driver时，为浏览器对象创建一个等待时间，这个方法是得不到某个元素就等待一段时间，直到拿到某个元素位置。
注意：在使用隐式等待的时候，实际上浏览器会在你自己设定的时间内部断的刷新页面去寻找我们需要的元素

implicity_wait()默认参数的单位为妙，本例中设置等待时长为10秒，首先这10秒并非一个固定的等待时间，它并不影响脚本的执行速度。其次，它并不针对页面上的某一元素进行等待。当脚本执行到某个元素定位是，如果元素可以定位，则继续执行，如果元素定位不到，则它将以轮询的方式不断地判断元素是否被定位到。假设在第六秒定位到了元素则继续执行，若直到超出设置的时长10秒还没有定位到元素，则抛出异常。

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.Chrome()
driver.implicity_wait(10)
driver.get('http://www.baidu')

selenium的显示等待

原理：显示等待，就是明确的要等到某个元素的出现或者是某个元素的可点击等条件，等不到，就一直等，除非在规定的时间之内都没找到，那么久跳出Exception
(就是直到元素出现才去操作，如果超时则报异常)

源码：

# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import time
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import TimeoutException

POLL_FREQUENCY = 0.5  # How long to sleep inbetween calls to the method
IGNORED_EXCEPTIONS = (NoSuchElementException,)  # exceptions ignored during calls to the method


class WebDriverWait(object):
    def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):
        """Constructor, takes a WebDriver instance and timeout in seconds.

           :Args:
            - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
            - timeout - Number of seconds before timing out
            - poll_frequency - sleep interval between calls
              By default, it is 0.5 second.
            - ignored_exceptions - iterable structure of exception classes ignored during calls.
              By default, it contains NoSuchElementException only.

           Example:
            from selenium.webdriver.support.ui import WebDriverWait \n
            element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \n
            is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\ \n
                        until_not(lambda x: x.find_element_by_id("someId").is_displayed())
        """
        self._driver = driver
        self._timeout = timeout
        self._poll = poll_frequency
        # avoid the divide by zero
        if self._poll == 0:
            self._poll = POLL_FREQUENCY
        exceptions = list(IGNORED_EXCEPTIONS)
        if ignored_exceptions is not None:
            try:
                exceptions.extend(iter(ignored_exceptions))
            except TypeError:  # ignored_exceptions is not iterable
                exceptions.append(ignored_exceptions)
        self._ignored_exceptions = tuple(exceptions)

    def __repr__(self):
        return '<{0.__module__}.{0.__name__} (session="{1}")>'.format(
            type(self), self._driver.session_id)

    def until(self, method, message=''):
        """Calls the method provided with the driver as an argument until the \
        return value is not False."""
        screen = None
        stacktrace = None

        end_time = time.time() + self._timeout
        while True:
            try:
                value = method(self._driver)
                if value:
                    return value
            except self._ignored_exceptions as exc:
                screen = getattr(exc, 'screen', None)
                stacktrace = getattr(exc, 'stacktrace', None)
            time.sleep(self._poll)
            if time.time() > end_time:
                break
        raise TimeoutException(message, screen, stacktrace)

    def until_not(self, method, message=''):
        """Calls the method provided with the driver as an argument until the \
        return value is False."""
        end_time = time.time() + self._timeout
        while True:
            try:
                value = method(self._driver)
                if not value:
                    return value
            except self._ignored_exceptions:
                return True
            time.sleep(self._poll)
            if time.time() > end_time:
                break
        raise TimeoutException(message)

看了源码，具体使用一下：

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.Chrome()
driver.get('http://www.baidu')
 
element = WebDriverWait(driver,5,0.5).util(
                  EC.presence_of_element_located((By.ID,'kw'))
                    )  
element.send_keys('hello')
driver.quit()
 
 
 
WebDriverWait(driver,timeout,poll_frequency=0.5,ignored_exceptions=None)
driver:浏览器驱动
timeout:最长超过时间，默认以秒为单位
poll_frequency:监测的时间间隔，默认为0.5秒
ignored_exceptions:超时后的异常信息，默认情况下抛NoSuchElementException异常
WebDriverWait一般有until和until_not方法配合使用
until(method,message)
until_not(method ,message)

源码中还有

元素出现：until()

driver = webdriver.Firefox()
driver.get("http://www.baidu.com")
# 等待时长10秒，默认0.5秒询问一次
WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("kw")).send_keys("test")

源码中的

元素消失： until_not（）

# 判断id为kw元素是否消失
is_disappeared = WebDriverWait(driver, 10, 1).\
    until_not(lambda x: x.find_element_by_id("kw").is_displayed())
print is_disappeared

• driver.set_script_timeout()

• driver.set_page_load_timeout() 

例子：上述两个都是设置超时的时间 

 

• desired_capabilities

十 截图

• driver.get_screenshot_as_file("D:\\Test\\1.png") # 截图,并设置保存路径

• driver.save_screenshot()  #保存截图

• driver.get_screenshot_as_png()  #截图，保存为二进制数据

• driver.get_screenshot_as_base64()  #截图，保存为base64格式

十一 日志

• driver.get_log() 

• driver.log_types

例子：

driver = webdriver.FireFox()

driver.log_types
Out[36]: ['browser', 'driver']
 
driver.get_log("driver")
Out[37]: []
 
driver.get_log('browser')
Out[38]: []

其中get_log的参数可以从log_types获取。get_log('browser') 输出chrome控制台的各种日志信息。其中取一次后，就清空。get_log('driver')还没有观察到输出