WebDriver 文档

定位元素

定位元素
使用 WebDriver 时要学习的最基本的技术之一是如何查找页面上的元素。 WebDriver 提供了许多内置的选择器类型，其中包括根据 id 属性查找元素:

Java Python C# Ruby JavaScript Kotlin

driver.find_element(By.ID, “cheese”)

如示例所示，在 WebDriver 中定位元素是在 WebDriver 实例对象上完成的。 findElement(By) 方法返回另一个基本对象类型 WebElement。

WebDriver 代表浏览器
WebElement 表示特定的 DOM 节点（控件，例如链接或输入栏等）
一旦你已经找到一个元素的引用，你可以通过对该对象实例使用相同的调用来缩小搜索范围：

Java Python C# Ruby JavaScript Kotlin

cheese = driver.find_element(By.ID, “cheese”)
cheddar = cheese.find_elements_by_id(“cheddar”)

你可以这样做是因为， WebDriver 和 WebElement 类型都实现了 搜索上下文 接口。在 WebDriver 中，这称为 基于角色的接口。基于角色的接口允许你确定特定的驱动程序实现是否支持给定的功能。这些接口定义得很清楚，并且尽量只承担单一的功能。你可以阅读更多关于 WebDriver 的设计，以及在 WebDriver 中有哪些角色被支持，在其他被命名的部分。

因此，上面使用的 By 接口也支持许多附加的定位器策略。嵌套查找可能不是最有效的定位 cheese 的策略，因为它需要向浏览器发出两个单独的命令：首先在 DOM 中搜索 id 为“cheese”的元素，然后在较小范围的上下文中搜索“cheddar”。

为了稍微提高性能，我们应该尝试使用一个更具体的定位器：WebDriver 支持通过 CSS 定位器查找元素，我们可以将之前的两个定位器合并到一个搜索里面:

Java Python C# Ruby JavaScript Kotlin

cheddar = driver.find_element_by_css_selector("#cheese #cheddar")

定位多个元素
我们正在处理的文本中可能会有一个我们最喜欢的奶酪的订单列表：

1. …
2. …
3. …
4. …

因为有更多的奶酪无疑是更好的，但是单独检索每一个项目是很麻烦的，检索奶酪的一个更好的方式是使用复数版本 findElements(By) 。此方法返回 web 元素的集合。如果只找到一个元素，它仍然返回(一个元素的)集合。如果没有元素被定位器匹配到，它将返回一个空列表。

Java Python C# Ruby JavaScript Kotlin

mucho_cheese = driver.find_elements_by_css_selector("#cheese li")

元素选择策略
在 WebDriver 中有 8 种不同的内置元素定位策略：

定位器 Locator 描述
class name 定位class属性与搜索值匹配的元素（不允许使用复合类名）
css selector 定位 CSS 选择器匹配的元素
id 定位 id 属性与搜索值匹配的元素
name 定位 name 属性与搜索值匹配的元素
link text 定位link text可视文本与搜索值完全匹配的锚元素
partial link text 定位link text可视文本部分与搜索值部分匹配的锚点元素。如果匹配多个元素，则只选择第一个元素。
tag name 定位标签名称与搜索值匹配的元素
xpath 定位与 XPath 表达式匹配的元素
使用选择器的提示
一般来说，如果 HTML 的 id 是可用的、唯一的且是可预测的，那么它就是在页面上定位元素的首选方法。它们的工作速度非常快，可以避免复杂的 DOM 遍历带来的大量处理。

如果没有唯一的 id，那么最好使用写得好的 CSS 选择器来查找元素。XPath 和 CSS 选择器一样好用，但是它语法很复杂，并且经常很难调试。尽管 XPath 选择器非常灵活，但是他们通常未经过浏览器厂商的性能测试，并且运行速度很慢。

基于链接文本和部分链接文本的选择策略有其缺点，即只能对链接元素起作用。此外，它们在 WebDriver 内部调用 XPath 选择器。

标签名可能是一种危险的定位元素的方法。页面上经常出现同一标签的多个元素。这在调用 findElements(By) 方法返回元素集合的时候非常有用。

建议您尽可能保持定位器的紧凑性和可读性。使用 WebDriver 遍历 DOM 结构是一项性能花销很大的操作，搜索范围越小越好。

相对定位
在Selenium 4中带来了相对定位这个新功能，在以前的版本中被称之为"好友定位 (Friendly Locators)"。 它可以帮助你通过某些元素作为参考来定位其附近的元素。 现在可用的相对定位有：

above 元素上
below 元素下
toLeftOf 元素左
toRightOf 元素右
near 附近
findElement 方法现在支持witTagName()新方法其可返回RelativeLocator相对定位对象。

如何工作
Selenium是通过使用JavaScript函数 getBoundingClientRect() 来查找相对元素的。这个函数能够返回对应元素的各种属性例如：右，左，下，上。

通过下面的例子我们来理解一下关于相对定位的使用

Relative Locators

above() 元素上
返回当前指定元素位置上方的WebElement对象

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.support.relative_locator import with_tag_name

passwordField = driver.find_element(By.ID, “password”)
emailAddressField = driver.find_element(with_tag_name(“input”).above(passwordField))

below() 元素下
返回当前指定元素位置下方的WebElement对象

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.support.relative_locator import with_tag_name

emailAddressField = driver.find_element(By.ID, “email”)
passwordField = driver.find_element(with_tag_name(“input”).below(emailAddressField))

toLeftOf() 元素左
返回当前指定元素位置左方的WebElement对象

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.support.relative_locator import with_tag_name

submitButton = driver.find_element(By.ID, “submit”)
cancelButton = driver.find_element(with_tag_name(“button”).
to_left_of(submitButton))

toRightOf() 元素右
返回当前指定元素位置右方的WebElement对象

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.support.relative_locator import with_tag_name

cancelButton = driver.find_element(By.ID, “cancel”)
submitButton = driver.find_element(with_tag_name(“button”).
to_right_of(cancelButton))

near() 附近
返回当前指定元素位置附近大约px5050像素的WebElement对象

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.support.relative_locator import with_tag_name

emailAddressLabel = driver.find_element(By.ID, “lbl-email”)
emailAddressField = driver.find_element(with_tag_name(“input”).
near(emailAddressLabel))

操控浏览器

操控浏览器
Ruby
默认情况下，Ruby 没有安装在 Windows 上。下载最新版本 并运行安装程序。你可以保留所有设置的默认值，除要勾选 安装位置和可选任务 屏幕上 将 Ruby 可执行程序添加到您的系统路径 复选框外。想要驱动任何浏览器，你必须安装 selenium-webdriver Ruby gem. 打开命令提示符并输入以下命令来安装它:

gem install selenium-webdriver
如果你使用 Bundler，添加这一行到你的应用程序的 Gemfile 中:

gem “selenium-webdriver”
然后在命令提示符中执行以下命令：

bundle install
Internet Explorer
IE 浏览器默认安装在 Windows 上，不需要再次安装。要在 Windows 上驱动 IE，您必须下载最新的 Internet Explorer 驱动程序 并将文件放入 PATH 路径中的文件夹中。要查看 PATH 路径中的目录，在命令提示符中键入 echo %PATH%。

$ echo %PATH%
C:\Ruby200\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem
C:\Ruby200\bin 看起来是个不错的位置。解压 IEDriverServer 文件并将 IEDriverServer.exe 移动进去。

这将打开一个新的 IE 浏览器窗口:

require “selenium-webdriver”
driver = Selenium::WebDriver.for :internet_explorer
浏览器导航
打开网站
启动浏览器后你要做的第一件事就是打开你的网站。这可以通过一行代码实现:

Java Python C# Ruby JavaScript Kotlin

driver.get(“https://selenium.dev”)
获取当前 URL
您可以从浏览器的地址栏读取当前的 URL，使用:

Java Python C# Ruby JavaScript Kotlin
driver.current_url
后退
按下浏览器的后退按钮:

Java Python C# Ruby JavaScript Kotlin
driver.back()
前进
按下浏览器的前进键:

Java Python C# Ruby JavaScript Kotlin
driver.forward()
刷新
刷新当前页面:

Java Python C# Ruby JavaScript Kotlin
driver.refresh()
获取标题
从浏览器中读取当前页面的标题:

Java Python C# Ruby JavaScript Kotlin
driver.title
窗口和标签页
WebDriver 没有区分窗口和标签页。如果你的站点打开了一个新标签页或窗口，Selenium 将允许您使用窗口句柄来处理它。 每个窗口都有一个唯一的标识符，该标识符在单个会话中保持持久性。你可以使用以下方法获得当前窗口的窗口句柄:

Java Python C# Ruby JavaScript Kotlin
driver.current_window_handle
切换窗口或标签页
单击在 <a href=“https://seleniumhq.github.io"target=”_blank”>新窗口 中打开链接， 则屏幕会聚焦在新窗口或新标签页上，但 WebDriver 不知道操作系统认为哪个窗口是活动的。 要使用新窗口，您需要切换到它。 如果只有两个选项卡或窗口被打开，并且你知道从哪个窗口开始， 则你可以遍历 WebDriver， 通过排除法可以看到两个窗口或选项卡，然后切换到你需要的窗口或选项卡。

不过，Selenium 4 提供了一个新的 api NewWindow， 它创建一个新选项卡 (或) 新窗口并自动切换到它。

Java Python C# Ruby JavaScript Kotlin

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

启动驱动程序

with webdriver.Firefox() as driver:

打开网址

driver.get(“https://seleniumhq.github.io”)

# 设置等待
wait = WebDriverWait(driver, 10)

# 存储原始窗口的 ID
original_window = driver.current_window_handle

# 检查一下，我们还没有打开其他的窗口
assert len(driver.window_handles) == 1

# 单击在新窗口中打开的链接
driver.find_element(By.LINK_TEXT, "new window").click()

# 等待新窗口或标签页
wait.until(EC.number_of_windows_to_be(2))

# 循环执行，直到找到一个新的窗口句柄
for window_handle in driver.window_handles:
    if window_handle != original_window:
        driver.switch_to.window(window_handle)
        break

# 等待新标签页完成加载内容
wait.until(EC.title_is("SeleniumHQ Browser Automation"))

创建新窗口(或)新标签页并且切换
创建一个新窗口 (或) 标签页，屏幕焦点将聚焦在新窗口或标签在上。您不需要切换到新窗口 (或) 标签页。如果除了新窗口之外， 您打开了两个以上的窗口 (或) 标签页，您可以通过遍历 WebDriver 看到两个窗口或选项卡，并切换到非原始窗口。

注意: 该特性适用于 Selenium 4 及其后续版本。

Java Python C# Ruby JavaScript Kotlin

打开新标签页并切换到新标签页

driver.switch_to.new_window(‘tab’)

打开一个新窗口并切换到新窗口

driver.switch_to.new_window(‘window’)
关闭窗口或标签页
当你完成了一个窗口或标签页的工作时，_并且_它不是浏览器中最后一个打开的窗口或标签页时，你应该关闭它并切换回你之前使用的窗口。 假设您遵循了前一节中的代码示例，您将把前一个窗口句柄存储在一个变量中。把这些放在一起，你会得到:

Java Python C# Ruby JavaScript Kotlin

#关闭标签页或窗口
driver.close()

#切回到之前的标签页或窗口
driver.switch_to.window(original_window)
如果在关闭一个窗口后忘记切换回另一个窗口句柄，WebDriver 将在当前关闭的页面上执行，并触发一个 No Such Window Exception 无此窗口异常。必须切换回有效的窗口句柄才能继续执行。

在会话结束时退出浏览器
当你完成了浏览器会话，你应该调用 quit 退出，而不是 close 关闭:

Java Python C# Ruby JavaScript Kotlin
driver.quit()
退出将会
关闭所有与 WebDriver 会话相关的窗口和选项卡
结束浏览器进程
结束后台驱动进程
通知 Selenium Grid 浏览器不再使用，以便可以由另一个会话使用它(如果您正在使用 Selenium Grid)
调用 quit() 失败将留下额外的后台进程和端口运行在机器上，这可能在以后导致一些问题。

有的测试框架提供了一些方法和注释，您可以在测试结束时放入 teardown() 方法中。

Java Python C# Ruby JavaScript Kotlin

unittest teardown

https://docs.python.org/3/library/unittest.html?highlight=teardown#unittest.TestCase.tearDown

def tearDown(self):
self.driver.quit()
如果不在测试上下文中运行 WebDriver，您可以考虑使用 try / finally，这是大多数语言都提供的， 这样一个异常处理仍然可以清理 WebDriver 会话。

Java Python C# Ruby JavaScript Kotlin

try:
#WebDriver 代码…
finally:
driver.quit()
Python 的 WebDriver 现在支持 Python 上下文管理器，当使用 with 关键字时，可以在执行结束时自动退出驱动程序。

with webdriver.Firefox() as driver:

WebDriver 代码…

在此缩进位置后 WebDriver 会自动退出

Frames and Iframes
框架是一种现在已被弃用的方法，用于从同一域中的多个文档构建站点布局。除非你使用的是 HTML5 之前的 webapp，否则你不太可能与他们合作。内嵌框架允许插入来自完全不同领域的文档，并且仍然经常使用。

如果您需要使用框架或 iframe, WebDriver 允许您以相同的方式使用它们。考虑 iframe 中的一个按钮。 如果我们使用浏览器开发工具检查元素，我们可能会看到以下内容:

Java Python C# Ruby JavaScript Kotlin

这不会工作

driver.find_element(By.TAG_NAME, ‘button’).click()
但是，如果 iframe 之外没有按钮，那么您可能会得到一个 no such element 无此元素 的错误。 这是因为 Selenium 只知道顶层文档中的元素。为了与按钮进行交互，我们需要首先切换到框架， 这与切换窗口的方式类似。WebDriver 提供了三种切换到帧的方法。

使用 WebElement
使用 WebElement 进行切换是最灵活的选择。您可以使用首选的选择器找到框架并切换到它。

Java Python C# Ruby JavaScript Kotlin

存储网页元素

iframe = driver.find_element(By.CSS_SELECTOR, “#modal > iframe”)

切换到选择的 iframe

driver.switch_to.frame(iframe)

单击按钮

driver.find_element(By.TAG_NAME, ‘button’).click()
使用 name 或 id
如果您的 frame 或 iframe 具有 id 或 name 属性，则可以使用该属性。如果名称或 id 在页面上不是唯一的， 那么将切换到找到的第一个。

Java Python C# Ruby JavaScript Kotlin

通过 id 切换框架

driver.switch_to.frame(‘buttonframe’)

单击按钮

driver.find_element(By.TAG_NAME, ‘button’).click()
使用索引
还可以使用frame的索引， 例如可以使用JavaScript中的 window.frames 进行查询.

Java Python C# Ruby JavaScript Kotlin

切换到第 2 个框架

driver.switch_to.frame(1)
离开框架
离开 iframe 或 frameset，切换回默认内容，如下所示:

Java Python C# Ruby JavaScript Kotlin

切回到默认内容

driver.switch_to.default_content()
窗口管理
屏幕分辨率会影响 web 应用程序的呈现方式，因此 WebDriver 提供了移动和调整浏览器窗口大小的机制。

获取窗口大小
获取浏览器窗口的大小(以像素为单位)。

Java Python C# Ruby JavaScript Kotlin

分别获取每个尺寸

width = driver.get_window_size().get(“width”)
height = driver.get_window_size().get(“height”)

或者存储尺寸并在以后查询它们

size = driver.get_window_size()
width1 = size.get(“width”)
height1 = size.get(“height”)
设置窗口大小
恢复窗口并设置窗口大小。

Java Python C# Ruby JavaScript Kotlin
driver.set_window_size(1024, 768)
得到窗口的位置
获取浏览器窗口左上角的坐标。

Java Python C# Ruby JavaScript Kotlin

分别获取每个尺寸

x = driver.get_window_position().get(‘x’)
y = driver.get_window_position().get(‘y’)

或者存储尺寸并在以后查询它们

position = driver.get_window_position()
x1 = position.get(‘x’)
y1 = position.get(‘y’)
设置窗口位置
将窗口移动到设定的位置。

Java Python C# Ruby JavaScript Kotlin

将窗口移动到主显示器的左上角

driver.set_window_position(0, 0)
最大化窗口
扩大窗口。对于大多数操作系统，窗口将填满屏幕，而不会阻挡操作系统自己的菜单和工具栏。

Java Python C# Ruby JavaScript Kotlin
driver.maximize_window()
最小化窗口
最小化当前浏览上下文的窗口. 这种命令的精准行为将作用于各个特定的窗口管理器.

最小化窗口通常将窗口隐藏在系统托盘中.

注意: 此功能适用于Selenium 4以及更高版本.

Java Python C# Ruby JavaScript Kotlin
driver.minimize_window()
全屏窗口
填充整个屏幕，类似于在大多数浏览器中按下 F11。

Java Python C# Ruby JavaScript Kotlin
driver.fullscreen_window()
屏幕截图
用于捕获当前浏览上下文的屏幕截图. WebDriver端点 屏幕截图 返回以Base64格式编码的屏幕截图.

Java Python C# Ruby JavaScript Kotlin

from selenium import webdriver

driver = webdriver.Chrome()

Navigate to url

driver.get(“http://www.example.com”)

Returns and base64 encoded string into image

driver.save_screenshot(’./image.png’)

driver.quit()
元素屏幕截图
用于捕获当前浏览上下文的元素的屏幕截图. WebDriver端点 屏幕截图 返回以Base64格式编码的屏幕截图.

Java Python C# Ruby JavaScript Kotlin

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()

Navigate to url

driver.get(“http://www.example.com”)

ele = driver.find_element(By.CSS_SELECTOR, ‘h1’)

Returns and base64 encoded string into image

ele.screenshot(’./image.png’)

driver.quit()
执行脚本
在当前frame或者窗口的上下文中，执行JavaScript代码片段.

Java Python C# Ruby JavaScript Kotlin

// Stores the header element
let header = await driver.findElement(By.css(‘h1’));

// Executing JavaScript to capture innerText of header element
let text = await driver.executeScript(‘return arguments[0].innerText’, header);
打印页面
打印当前浏览器内的页面

注意: 此功能需要无头模式下的Chromium浏览器

Java Python C# Ruby JavaScript Kotlin

from selenium.webdriver.common.print_page_options import PrintOptions

print_options = PrintOptions()
print_options.page_ranges = ['1-2']

driver.get("printPage.html")

base64code = driver.print_page(print_options)

等待

WebDriver通常可以说有一个阻塞API。因为它是一个指示浏览器做什么的进程外库，而且web平台本质上是异步的，所以WebDriver不跟踪DOM的实时活动状态。这伴随着一些我们将在这里讨论的挑战。

根据经验，大多数由于使用Selenium和WebDriver而产生的间歇性问题都与浏览器和用户指令之间的 竞争条件 有关。例如，用户指示浏览器导航到一个页面，然后在试图查找元素时得到一个 no such element 的错误。

考虑下面的文档：

<!doctype html>
<meta charset=utf-8>
<title>Race Condition Example</title>

<script>
  var initialised = false;
  window.addEventListener("load", function() {
    var newElement = document.createElement("p");
    newElement.textContent = "Hello from JavaScript!";
    document.body.appendChild(newElement);
    initialised = true;
  });
</script>

这个 WebDriver的说明可能看起来很简单:

driver.navigate("file:///race_condition.html")
el = driver.find_element(By.TAG_NAME, "p")
assert el.text == "Hello from JavaScript!"

这里的问题是WebDriver中使用的默认页面加载策略页面加载策略听从document.readyState在返回调用 navigate 之前将状态改为"complete" 。因为p元素是在文档完成加载之后添加的，所以这个WebDriver脚本可能是间歇性的。它“可能”间歇性是因为无法做出保证说异步触发这些元素或事件不需要显式等待或阻塞这些事件。

幸运的是，WebElement接口上可用的正常指令集——例如 WebElement.click 和 WebElement.sendKeys—是保证同步的，因为直到命令在浏览器中被完成之前函数调用是不会返回的(或者回调是不会在回调形式的语言中触发的)。高级用户交互APIs,键盘和鼠标是例外的，因为它们被明确地设计为“按我说的做”的异步命令。

等待是在继续下一步之前会执行一个自动化任务来消耗一定的时间。

为了克服浏览器和WebDriver脚本之间的竞争问题，大多数Selenium客户都附带了一个 wait 包。在使用等待时，您使用的是通常所说的显式等待。

显式等待

显示等待 是Selenium客户可以使用的命令式过程语言。它们允许您的代码暂停程序执行，或冻结线程，直到满足通过的 条件 。这个条件会以一定的频率一直被调用，直到等待超时。这意味着只要条件返回一个假值，它就会一直尝试和等待

由于显式等待允许您等待条件的发生，所以它们非常适合在浏览器及其DOM和WebDriver脚本之间同步状态。

为了弥补我们之前的错误指令集，我们可以使用等待来让 findElement 调用等待直到脚本中动态添加的元素被添加到DOM中:

from selenium.webdriver.support.ui import WebDriverWait
def document_initialised(driver):
    return driver.execute_script("return initialised")

driver.navigate("file:///race_condition.html")
WebDriverWait(driver).until(document_initialised)
el = driver.find_element(By.TAG_NAME, "p")
assert el.text == "Hello from JavaScript!"

我们将 条件 作为函数引用传递， 等待 将会重复运行直到其返回值为true。“truthful”返回值是在当前语言中计算为boolean true的任何值，例如字符串、数字、boolean、对象(包括 WebElement )或填充(非空)的序列或列表。这意味着 空列表 的计算结果为false。当条件为true且阻塞等待终止时，条件的返回值将成为等待的返回值。

有了这些知识，并且因为等待实用程序默认情况下会忽略 no such element 的错误，所以我们可以重构我们的指令使其更简洁:

from selenium.webdriver.support.ui import WebDriverWait

driver.navigate("file:///race_condition.html")
el = WebDriverWait(driver).until(lambda d: d.find_element_by_tag_name("p"))
assert el.text == "Hello from JavaScript!"

在这个示例中，我们传递了一个匿名函数(但是我们也可以像前面那样显式地定义它，以便重用它)。传递给我们条件的第一个，也是唯一的一个参数始终是对驱动程序对象 WebDriver 的引用。在多线程环境中，您应该小心操作传入条件的驱动程序引用，而不是外部范围中对驱动程序的引用。

因为等待将会吞没在没有找到元素时引发的 no such element 的错误，这个条件会一直重试直到找到元素为止。然后它将获取一个 WebElement 的返回值，并将其传递回我们的脚本。

如果条件失败，例如从未得到条件为真实的返回值，等待将会抛出/引发一个叫 timeout error 的错误/异常。

选项

等待条件可以根据您的需要进行定制。有时候是没有必要等待缺省超时的全部范围，因为没有达到成功条件的代价可能很高。

等待允许你传入一个参数来覆盖超时:

WebDriverWait(driver, timeout=3).until(some_condition)

预期的条件

由于必须同步DOM和指令是相当常见的情况，所以大多数客户端还附带一组预定义的 预期条件 。顾名思义，它们是为频繁等待操作预定义的条件。

不同的语言绑定提供的条件各不相同，但这只是其中一些:

• alert is present
• element exists
• element is visible
• title contains
• title is
• element staleness
• visible text

您可以参考每个客户端绑定的API文档，以找到期望条件的详尽列表:

• Java’s org.openqa.selenium.support.ui.ExpectedConditions class
• Python’s selenium.webdriver.support.expected_conditions class
• .NET’s OpenQA.Selenium.Support.UI.ExpectedConditions type

隐式等待

还有第二种区别于显示等待 类型的 隐式等待 。通过隐式等待，WebDriver在试图查找_任何_元素时在一定时间内轮询DOM。当网页上的某些元素不是立即可用并且需要一些时间来加载时是很有用的。

默认情况下隐式等待元素出现是禁用的，它需要在单个会话的基础上手动启用。将显式等待和隐式等待混合在一起会导致意想不到的结果，就是说即使元素可用或条件为真也要等待睡眠的最长时间。

警告: 不要混合使用隐式和显式等待。这样做会导致不可预测的等待时间。例如，将隐式等待设置为10秒，将显式等待设置为15秒，可能会导致在20秒后发生超时。

隐式等待是告诉WebDriver如果在查找一个或多个不是立即可用的元素时轮询DOM一段时间。默认设置为0，表示禁用。一旦设置好，隐式等待就被设置为会话的生命周期。

driver = Firefox()
driver.implicitly_wait(10)
driver.get("http://somedomain/url_that_delays_loading")
my_dynamic_element = driver.find_element(By.ID, "myDynamicElement")

流畅等待

流畅等待实例定义了等待条件的最大时间量，以及检查条件的频率。

用户可以配置等待来忽略等待时出现的特定类型的异常，例如在页面上搜索元素时出现的NoSuchElementException。

driver = Firefox()
driver.get("http://somedomain/url_that_delays_loading")
wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))