selenium常用函数，新手看这篇就够了！

前言

Selenium是一个用于自动化Web浏览器操作的工具。它提供了一组API和库，可以与各种Web浏览器进行交互，模拟用户在浏览器中的行为。

Selenium的主要用途包括以下几个方面：

1. 自动化测试：Selenium广泛应用于Web应用程序的自动化测试。通过编写测试脚本，可以使用Selenium模拟用户在浏览器中的操作，如点击按钮、填写表单、提交数据等，以验证应用程序的功能和稳定性。
2. 网页爬取：Selenium可以模拟浏览器行为并加载动态网页内容，因此可以用于网页爬取。它可以加载JavaScript、解析动态生成的HTML内容，并提取所需的数据。
3. 用户界面(UI)自动化：Selenium可用于模拟用户与Web应用程序的交互过程。通过使用Selenium，可以执行各种Web任务，如创建帐户、提交表单、执行搜索等，从而实现UI自动化。
4. Web界面验证：Selenium可以用于验证Web应用程序的界面。开发人员可以使用Selenium编写脚本来检查页面上的元素是否按预期显示，并执行其他验证任务，以确保Web应用程序的正确性和一致性。

总之，Selenium是一个强大的工具，可用于多种Web自动化任务，包括自动化测试、网页爬取、用户界面自动化和Web界面验证。

Selenium在网页爬取中具有以下几个优点：

1. 加载和解析动态内容：Selenium可以模拟真实的浏览器行为，包括加载和执行JavaScript代码。这使得它能够处理那些需要动态生成内容或通过JavaScript进行操作的网页。对于一些使用AJAX、动态HTML或基于JavaScript框架构建的网站，Selenium可以更好地加载和解析这些页面。
2. 处理复杂的用户交互：一些网页可能需要用户进行特定的操作（如点击、滚动、拖拽等）才能显示或加载所需的内容。Selenium可以模拟用户的交互操作，从而获取所有所需的数据。
3. 解析网页元素：Selenium提供了丰富的选择器和API，可以方便地获取网页上的各种元素，如文本、链接、图像、表格等。您可以通过使用XPath、CSS选择器或其他方法，定位并提取您需要的具体元素。
4. 处理验证码和登录认证：一些网站为了防止机器人爬取，会采用验证码或登录认证等方式。Selenium可以通过自动化模拟用户在浏览器中的输入和操作，处理这些验证过程，从而顺利爬取需要的数据。
5. 跨浏览器兼容性：Selenium支持多种主流浏览器，如Chrome、Firefox、Safari等。这使得您可以在不同浏览器中运行和测试爬虫脚本，确保您的爬取逻辑在各种环境中都能正常工作。

需要注意的是，由于Selenium模拟真实的浏览器行为，对于大规模的高频率网页爬取，性能可能会受到一些限制。此外，Selenium还需要安装浏览器驱动程序，使其能够与特定浏览器进行通信。因此，在选择爬取工具时，请根据具体情况综合考虑Selenium的优点和使用场景。

我最开始接触Selenium是因为我要爬取163邮箱的所有未读邮件内容。处理这个问题如果直接使用requests爬取要求会比较高，需要处理滑动验证，Cookie登录，网页动态加载等问题。Selenium在面对这些问题就比较简单解决。

使用Selenium之前，确保完成了下面的两项准备工作

1. 安装Selenium库：使用pip命令可以轻松安装Selenium库。在命令行中运行以下命令：

pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple selenium

2. 下载浏览器驱动程序：Selenium需要与特定浏览器进行交互，因此您需要下载相应的浏览器驱动程序，如ChromeDriver（用于Google Chrome）、GeckoDriver（用于Mozilla Firefox）等。您可以从它们的官方网站下载适用于您的浏览器和操作系统的驱动程序。

selenium常用函数

创建浏览器对象

使用Selenium创建浏览器对象需要选择一个浏览器驱动程序，并将其与Selenium的WebDriver类关联起来。以下是使用不同浏览器创建浏览器对象的示例：

1. 使用Chrome浏览器：

from selenium import webdriver

# 创建Chrome浏览器对象
driver = webdriver.Chrome()

2. 使用Firefox浏览器：

from selenium import webdriver

# 创建Firefox浏览器对象
driver = webdriver.Firefox()

3. 使用Edge浏览器：

from selenium import webdriver

# 创建Edge浏览器对象
driver = webdriver.Edge()

4. 使用Safari浏览器：

from selenium import webdriver

# 创建Safari浏览器对象
driver = webdriver.Safari()

get(url)

get(url) 是 WebDriver 对象在 Selenium 中的方法之一，用于在浏览器中加载指定的 URL 地址。

当你需要在浏览器中加载一个网页时，可以使用 get(url) 方法。该方法会打开一个新的窗口或标签，并在其中加载指定的 URL 地址。

示例代码：

driver.get("https://www.example.com")

以上代码中，我们创建了一个 WebDriver 对象 driver，然后调用 get() 方法并传入待加载的 URL 地址（例如 https://www.example.com），这样就会在浏览器中打开一个新的窗口或标签，并加载该网页。

需要注意的是，get() 方法会阻塞脚本的执行，直到页面完全加载完成和所有相关资源（如图片、样式文件等）都已下载。如果加载过程超时或出错，将抛出相应的异常。

示例代码：

from selenium.common.exceptions import TimeoutException

try:
    driver.get("https://www.example.com")
except TimeoutException:
    print("页面加载超时")

上述代码中，我们使用 try-except 语句捕获 TimeoutException 异常，以便在页面加载超时时进行处理。

通过使用 get(url) 方法，你可以在自动化测试中模拟用户访问网页的行为，以测试网站的功能和验证页面的内容。

find_element(by, value)和find_elements(by, value)

在Selenium中，可以使用find_element和find_elements方法来查找页面上的元素。

find_element(by, value)用于查找单个元素。它接受两个参数：

• by: 定位元素的方式，可以是以下之一：
  • By.ID: 使用元素的ID属性进行定位
  • By.NAME: 使用元素的name属性进行定位
  • By.CLASS_NAME: 使用元素的class属性进行定位
  • By.TAG_NAME: 使用元素的标签名进行定位
  • By.LINK_TEXT: 使用链接文本进行定位，适用于标签
  • By.PARTIAL_LINK_TEXT: 使用链接文本的部分内容进行定位
  • By.CSS_SELECTOR: 使用CSS选择器进行定位
  • By.XPATH: 使用XPath进行定位
• value: 定位方式的值，用于匹配元素的具体属性或内容。

示例：

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

# 创建浏览器对象
driver = webdriver.Chrome()

# 打开网页
driver.get("http://example.com")

# 通过ID定位元素
element = driver.find_element(By.ID, "my-element-id")

# 通过CSS选择器定位元素
element = driver.find_element(By.CSS_SELECTOR, ".my-element-class")

# 通过XPath定位元素
element = driver.find_element(By.XPATH, "//input[@name='username']")

# 关闭浏览器
driver.quit()

find_elements(by, value)与find_element类似，但它返回一个元素列表，而不是单个元素。

elements = driver.find_elements(By.TAG_NAME, "a")
for element in elements:
    print(element.text)

注意：在使用这些方法之前，请确保已经创建了浏览器对象，并且页面已经加载完毕。

By.ID 和 By.XPATH 都是 Selenium 中常用的定位方式，它们各自适用于不同的场景。

使用 By.ID 定位方式时，是通过元素的 ID 属性来定位元素。对于具有唯一 ID 的元素，否则Selenium 会返回匹配到的第一个元素，使用 By.ID 是一个简单且高效的方法。示例代码如下：

element = driver.find_element(By.ID, "my-element-id")

使用 By.XPATH 定位方式时，则是通过 XPath 表达式来定位元素。XPath 是一种强大的定位语言，可以基于元素的标签、属性、内容以及元素之间的关系进行定位。相比于 By.ID，By.XPATH 提供了更大的灵活性和定位精度，可以处理更复杂的场景。示例代码如下：

element = driver.find_element(By.XPATH, "//input[@name='username']")

一般情况下，如果元素具有唯一的 ID 属性，建议优先使用 By.ID 进行定位，因为它效率更高。但是，在以下场景下，可能需要使用 By.XPATH：

1. 元素没有唯一的 ID 属性，而且其他属性也无法准确定位元素。
2. 需要组合多个条件来定位元素，例如定位某个父元素下的特定子元素。
3. 需要使用轴（axis）来定位元素，例如定位元素的兄弟、父级或祖先元素。

需要注意的是，XPath 表达式可以更灵活地定位元素，但在性能上相对较慢。因此，在定位元素时，应根据实际情况选择合适的定位方式。 任何一种定位方式都有其适用范围，具体选择哪种方式要根据页面结构以及需求来确定。

click()

click() 方法是 WebElement 对象在 Selenium 中的一个常用方法，它用于模拟用户点击元素的操作。

click() 方法会触发元素的点击事件，就像真实用户点击一样。它可以用于按钮、链接、复选框、单选按钮等可交互元素上。

示例代码：

element = driver.find_element(By.ID, "my-element-id")
element.click()

以上代码中，我们首先使用 find_element() 方法定位到具体的元素，然后调用 click() 方法模拟用户点击该元素。

当调用 click() 方法时，Selenium 会将鼠标点击事件派发给页面上对应的元素，从而触发与点击相关的事件处理程序。例如，如果点击一个按钮，按钮的点击事件处理程序将被执行。

需要注意的是，click() 方法只能用于可见且启用的元素。如果元素被隐藏或禁用，click() 方法将无法成功触发点击事件。

另外，如果时序间隙导致元素还未完全加载出来，你可能需要在调用 click() 之前添加一些等待逻辑，以确保元素已经可见并可交互。

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

element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "my-element-id"))
)
element.click()

上述代码使用了显示等待（WebDriverWait）来等待元素可被点击，直到超时时间为 10 秒或元素可被点击为止，然后再调用 click() 方法。

通过使用 click() 方法，你可以在自动化测试中模拟用户的点击操作，执行相应的交互行为。

send_keys(*value)

send_keys(*value) 是 WebElement 对象在 Selenium 中的方法之一，用于向元素发送文本输入。

send_keys() 方法可以将文本或字符序列输入到元素中，就像真实用户在输入框中键入文本一样。它适用于文本框、文本区域和其他可接受文本输入的元素。

示例代码：

element = driver.find_element(By.ID, "my-element-id")
element.send_keys("Hello World")

以上代码中，我们首先使用 find_element() 方法定位到具体的元素，然后调用 send_keys() 方法向该元素发送文本输入。

send_keys() 方法允许传入多个参数，每个参数都会被连续输入到元素中。例如：

element.send_keys("Hello", " ", "World")

上述代码将会依次输入 “Hello”、空格和 “World” 到元素中。

此外，send_keys() 方法还可以模拟特殊按键的操作，如回车键、删除键、Tab 键等。可以使用特殊字符来表示这些按键，例如：

element.send_keys("Hello", Keys.ENTER)

上述代码将会先输入 “Hello”，然后模拟按下回车键，实现回车操作。

需要注意的是，send_keys() 方法只能用于可见且启用的元素。如果元素被隐藏或禁用，send_keys() 方法将无法成功输入文字。

另外，如果时序间隙导致元素还未完全加载出来，你可能需要在调用 send_keys() 之前添加一些等待逻辑，以确保元素已经可见并可交互。

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

element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.ID, "my-element-id"))
)
element.send_keys("Hello World")

上述代码使用了显示等待（WebDriverWait）来等待元素可见，直到超时时间为 10 秒或元素可见为止，然后再执行 send_keys() 方法。

通过使用 send_keys() 方法，你可以在自动化测试中模拟用户的文本输入操作，进行交互测试和表单填写。

get_attribute()

ge_attribute() 是 WebElement 对象在 Selenium 中的方法之一，用于获取元素的属性值。

get_attribute() 方法可以获取元素的指定属性值，并将其作为字符串返回。你需要传入要获取的属性名称作为参数。

示例代码：

element = driver.find_element(By.ID, "my-element-id")
attribute_value = element.get_attribute("attribute_name")

以上代码中，我们首先使用 find_element() 方法定位到具体的元素，然后调用 get_attribute() 方法获取该元素指定属性的值。最后，将获取到的属性值赋值给变量 attribute_value。

例如，要获取元素的 href 属性值，可以使用以下代码：

element = driver.find_element(By.ID, "my-link-id")
href_value = element.get_attribute("href")

另外，如果你想获取元素的文本内容，可以使用 text 属性：

element = driver.find_element(By.ID, "my-element-id")
text_content = element.text

注意，get_attribute() 方法返回的属性值是一个字符串。如果属性不存在或为空，它将返回 None。

需要注意的是，使用 get_attribute() 方法获取元素的属性值，前提是元素必须已经被找到并且可见。

通过使用 get_attribute() 方法，你可以在测试中获取元素的各种属性值，如链接的 URL、输入框的默认值、图像的地址等，用于验证和断言测试结果。

get_attribute() 方法可以获取元素的各种属性值。以下是一些常见的元素属性示例：

1. href：链接元素的 URL。
2. src：图像或媒体元素的来源 URL。
3. value：输入框元素的当前值。
4. class：元素的 CSS 类名。
5. id：元素的唯一标识符。
6. name：元素的名称。
7. type：输入元素的类型，如文本、复选框或按钮。
8. checked：复选框或单选按钮元素的选中状态。
9. disabled：元素是否被禁用。
10. style：元素的内联样式。
11. innerText 或 textContent：元素包含的文本内容。
12. outerHTML：元素的完整 HTML 代码。

这些只是一些常见的示例，实际上，任何在 HTML 标签上定义的属性都可以通过 get_attribute() 方法来获取。

你可以根据具体的测试场景和需求，使用 get_attribute() 方法获取适当的属性值，并根据返回的值进行验证。

clear()`

clear() 是 WebElement 对象在 Selenium 中的方法之一，用于清空输入框或文本区域等可编辑元素的文本内容。

当你想要在输入框中清空已有的文本内容时，可以使用 clear() 方法。

示例代码：

element = driver.find_element(By.ID, "my-input-id")
element.clear()

以上代码中，我们首先使用 find_element() 方法定位到具体的可编辑元素，然后调用 clear() 方法清空该元素的文本内容。这样，输入框中原有的文本内容将被删除。

需要注意的是，clear() 方法只能用于已经定位到且可见的可编辑元素。

submit()

submit() 是 WebElement 对象在 Selenium 中的方法之一，用于提交表单。

当你需要模拟用户提交表单的操作时，可以使用 submit() 方法。该方法会模拟用户点击表单中的提交按钮或按下回车键来提交表单。

示例代码：

form = driver.find_element(By.ID, "my-form-id")
form.submit()

以上代码中，我们首先使用 find_element() 方法定位到具体的表单元素，然后调用 submit() 方法来提交表单。这样，会触发表单的提交操作。

需要注意的是，submit() 方法只能用于 <form> 元素或具有表单行为的元素（如 <input> 或 <button>）。对于其他类型的元素，调用 submit() 方法将没有任何效果。

back()和forward()

back() 是 WebDriver 对象在 Selenium 中的方法之一，用于在浏览器中返回上一个页面。forward() 用于在浏览器中前进到下一个页面。

当你需要模拟用户点击浏览器返回按钮，返回到上一个页面时，可以使用 back() 方法。

当使用 driver.back() 方法时，它将模拟用户点击浏览器的返回按钮，返回到上一个已访问的页面。下面是一个示例：

from selenium import webdriver

# 创建 WebDriver 对象
driver = webdriver.Chrome()

# 访问第一个页面
driver.get("https://www.example.com/page1")

# 执行其他操作...

# 返回上一个页面
driver.back()

# 现在在第一个页面中，可以执行其他操作...

在上面的示例中，我们首先创建了一个 WebDriver 对象，并使用 get() 方法访问了第一个页面（“https://www.example.com/page1”）。然后，在执行其他操作之后，我们调用 back() 方法，将返回到上一个已访问的页面。

需要注意的是，back() 方法只能返回到上一个页面，无法返回到更早的历史页面。如果需要返回到更早的历史页面，可以多次调用 back() 方法。

driver.back()  # 返回上一个页面
driver.back()  # 再次返回上上一个页面

通过使用 back() 方法，你可以在自动化测试中模拟用户点击浏览器返回按钮的操作，以测试网页的导航和验证页面间的交互。类似back() 方法，当你需要模拟用户点击浏览器前进按钮，前往下一个页面时，可以使用 forward() 方法。

driver.forward()

以上代码中，我们创建了一个 WebDriver 对象 driver，然后调用 forward() 方法，这样就会在浏览器中模拟点击前进按钮，前往下一个页面。

refresh()

refresh() 是 WebDriver 对象在 Selenium 中的方法之一，用于刷新当前页面。

当你需要模拟用户点击浏览器的刷新按钮，重新加载当前页面时，可以使用 refresh() 方法。

示例代码：

driver.refresh()

以上代码中，我们创建了一个 WebDriver 对象 driver，然后调用 refresh() 方法，这样就会在浏览器中模拟点击刷新按钮，重新加载当前页面。

通过使用 refresh() 方法，你可以在自动化测试中模拟用户点击浏览器的刷新按钮的操作，以测试网页的动态内容更新或确保页面处于最新状态

switch_to.frame(frame_reference)

switch_to.frame(frame_reference) 是 WebDriver 对象在 Selenium 中的方法之一，用于切换到指定的 iframe（内嵌框架）。

在网页中，有时会使用 <iframe> 标签来嵌入其他网页或内容。如果需要在 Selenium 中对嵌入的 iframe 进行操作，就需要使用 switch_to.frame() 方法切换到该 iframe。

frame_reference 可以是以下三种形式之一：

1. 通过 frame 的索引进行切换：

   driver.switch_to.frame(0)  # 切换到第一个 iframe
   

2. 通过 frame 的名称或 ID 进行切换：

   driver.switch_to.frame("myframe")  # 切换到名称或 ID 为 "myframe" 的 iframe
   

3. 通过获取 iframe 元素对象进行切换：

   iframe_element = driver.find_element_by_css_selector("iframe")  # 获取 iframe 元素对象
   driver.switch_to.frame(iframe_element)  # 切换到指定的 iframe
   

切换到 iframe 后，你可以在该 iframe 中执行其他操作，比如查找元素、输入文本等。如果需要切换回最外层的页面，可以使用 switch_to.default_content() 方法。

示例代码：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 切换到第一个 iframe
driver.switch_to.frame(0)

# 在 iframe 中执行其他操作

# 切换回最外层的页面
driver.switch_to.default_content()

# 在最外层的页面执行其他操作

通过使用 switch_to.frame() 方法，你可以在 Selenium 中切换到指定的 iframe，并在其中执行需要的操作。

iframe（内嵌框架）是 HTML 标签的一种，用于在一个网页中嵌入另一个网页或内容。它可以将其他网页、多媒体内容或应用程序以框架的形式嵌入到当前页面中。

在使用 iframe 时，可以通过指定 iframe 的源文件（src）来加载另一个网页。以下是一个示例的 iframe 标签：

<iframe src="https://www.example.com" width="500" height="300"></iframe>

在上面的示例中，iframe 标签的 src 属性指定了要嵌入的网页的 URL，width 和 height 属性指定了 iframe 的宽度和高度。

使用 iframe 可以实现以下功能：

1. 嵌入其他网页：通过将其他网页嵌入到当前网页中的 iframe 中，可以在一个页面展示多个网页内容。
2. 嵌入多媒体内容：可以将视频、音频等多媒体内容嵌入到 iframe 中，以在当前页面中播放。
3. 嵌入应用程序：可以将 Web 应用程序或小部件嵌入到 iframe 中，以在当前页面中展示额外的功能或服务。

在使用 Selenium 进行网页自动化测试时，使用 switch_to.frame() 方法可以切换到嵌套的 iframe 中，以便对其中的内容进行操作。

需要注意的是，由于安全性考虑，某些网站可能会阻止其页面在 iframe 中进行嵌入或限制跨域的访问。在使用 iframe 时，应遵守相关的安全和法律规定。

switch_to.window(window_reference)

switch_to.window(window_reference) 是 WebDriver 对象在 Selenium 中的方法之一，用于切换到指定的浏览器窗口。在使用 Selenium 进行网页自动化测试时，涉及到多个浏览器窗口的情况，可以使用 switch_to.window() 方法切换到指定的窗口。

window_reference 可以是以下三种形式之一：

1. 通过窗口的句柄（handle）进行切换：

   window_handle = driver.window_handles[0]  # 获取第一个窗口的句柄
   driver.switch_to.window(window_handle)  # 切换到指定的窗口
   

2. 通过窗口的名称或标题进行切换：

   driver.switch_to.window("My Window")  # 切换到名称为 "My Window" 的窗口
   

3. 通过获取窗口元素对象进行切换：

   window_element = driver.find_element_by_css_selector("window-selector")  # 获取窗口元素对象
   driver.switch_to.window(window_element)  # 切换到指定的窗口
   

切换到窗口后，你可以在该窗口中执行其他操作，比如查找元素、输入文本等。

示例代码一：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 打开新的窗口
driver.execute_script("window.open('https://www.google.com', 'Google Window')")

# 切换到新的窗口
driver.switch_to.window(driver.window_handles[1])

# 在新的窗口中执行其他操作

# 切换回原来的窗口
driver.switch_to.window(driver.window_handles[0])

# 在原来的窗口中执行其他操作

通过使用 switch_to.window() 方法，你可以在 Selenium 中切换到指定的浏览器窗口，并在其中执行需要的操作。

在使用 Selenium 进行网页自动化测试时，每个打开的浏览器窗口都有一个唯一的名称或标题。这个名称或标题可以是由加载的网页提供，也可以是手动设置的。

driver.switch_to.window("My Window") 是用于切换到指定名称或标题为 “My Window” 的浏览器窗口。

在实际使用时，你需要根据具体的情况将 “My Window” 替换为你要切换的窗口的名称或标题，以确保切换到正确的窗口。

示例代码二：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 打开新的窗口
driver.execute_script("window.open('https://www.google.com', 'Google Window')")

# 切换到新的窗口
driver.switch_to.window("Google Window")

# 在新的窗口中执行其他操作

# 切换回原来的窗口
driver.switch_to.window(driver.window_handles[0])

# 在原来的窗口中执行其他操作

在上面的示例中，窗口 “Google Window” 是通过 window.open() 方法打开的，并且显式设置了窗口的名称。然后，通过 switch_to.window() 方法切换到该窗口，可以在其中执行其他操作。

execute_script(script, *args)

execute_script(script, *args) 是 WebDriver 对象在 Selenium 中的方法之一，用于在当前页面执行 JavaScript 脚本。

通过 execute_script() 方法，你可以在浏览器中执行自定义的 JavaScript 脚本，以实现一些特定的操作或获取页面中的信息。该方法接受两个参数：

• script：要执行的 JavaScript 脚本代码。
• *args：可选参数，用于传递给 JavaScript 脚本的参数。

示例代码：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 定义并执行 JavaScript 脚本
script = "return document.title;"
title = driver.execute_script(script)

print(title)  # 输出页面的标题

在上述示例中，execute_script() 方法执行了一个简单的 JavaScript 脚本，该脚本返回当前页面的标题。然后，将返回的结果赋值给变量 title，并将其打印出来。

除了获取页面信息外，execute_script() 还可以用于执行各种其他的 JavaScript 操作，例如修改页面元素样式、模拟用户交互、操纵 DOM 等。

close()

close() 是 WebDriver 对象在 Selenium 中的方法之一，用于关闭当前打开的浏览器窗口。

使用 close() 方法可以关闭当前活动的窗口，如果只有一个窗口被打开，则会关闭整个浏览器。该方法不会关闭整个 WebDriver 会话，仍然可以在其他窗口或标签页中继续执行操作。

示例代码：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 在当前窗口执行其他操作

# 关闭当前窗口
driver.close()

在上述示例中，首先创建了一个 Chrome WebDriver 对象，并打开了一个网页。然后，在当前窗口中执行其他操作。最后，通过 close() 方法关闭了当前窗口。

需要注意的是，如果同时打开了多个窗口或标签页，并且想要关闭除当前窗口外的其他窗口，可以使用 driver.switch_to.window() 方法切换到其他窗口，然后使用 close() 方法关闭它们。

示例代码：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.example.com")

# 打开新的窗口
driver.execute_script("window.open('https://www.google.com', 'Google Window')")

# 切换到新的窗口
driver.switch_to.window("Google Window")

# 在新的窗口中执行其他操作

# 关闭新的窗口
driver.close()

# 切换回原来的窗口
driver.switch_to.window(driver.window_handles[0])

# 在原来的窗口中执行其他操作

# 关闭原来的窗口
driver.close()

在上述示例中，通过 window.open() 方法打开了一个新的窗口，并使用 switch_to.window() 方法切换到该窗口。然后，在新的窗口中执行其他操作。最后，分别使用 close() 方法关闭了新的窗口和原来的窗口。

等待逻辑

在使用 Selenium 进行浏览器自动化时，如果存在时序间隙导致元素还未完全加载出来的情况，可以通过添加等待逻辑来解决。等待逻辑可以确保在操作元素之前，页面中的元素已经加载完成。

在 Selenium 中，有两种常见的等待方式：显式等待和隐式等待。

1. 显式等待： 显式等待是一种手动指定等待条件的方式。可以使用 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.Chrome()
driver.get("https://www.example.com")

# 设置等待条件和超时时间
wait = WebDriverWait(driver, 10)
element = wait.until(EC.presence_of_element_located((By.ID, "myElement")))

# 在元素加载完成后执行操作
element.click()

在上述示例中，首先创建了一个 Chrome WebDriver 对象，并打开了一个网页。然后，使用 WebDriverWait 类设置等待条件为元素的存在性（presence_of_element_located）以及元素的定位方式和值。最后，通过 until() 方法等待元素加载完成，并在加载完成后执行相应的操作。

在使用 Selenium 的显式等待时，可以根据需要设置不同的等待条件。下面列举了一些常用的显式等待条件：

a. presence_of_element_located：等待指定的元素出现在 DOM 中，可以通过元素的定位方式和值进行指定。 示例代码：

wait.until(EC.presence_of_element_located((By.ID, 'myElement')))

b. visibility_of_element_located：等待指定的元素在页面中可见，即元素在 DOM 中存在并且可见（display不为none且visibility不为hidden）。 示例代码：

wait.until(EC.visibility_of_element_located((By.XPATH, '//div[@class="myElement"]')))

c. element_to_be_clickable：等待指定的元素可被点击，即元素在 DOM 中存在、可见且启用（enabled）。 示例代码：

wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, '.myElement')))

d. text_to_be_present_in_element：等待指定元素中的文本包含特定的字符串。 示例代码：

wait.until(EC.text_to_be_present_in_element((By.XPATH, '//span[@class="myElement"]'), 'expected text'))

e. invisibility_of_element_located：等待指定的元素在页面中不可见，即元素在 DOM 中存在但不可见（display为none或visibility为hidden）。 示例代码：

wait.until(EC.invisibility_of_element_located((By.ID, 'myElement')))

f. frame_to_be_available_and_switch_to_it：等待指定的 frame（框架）在页面中可用，并切换到该 frame。 示例代码：

wait.until(EC.frame_to_be_available_and_switch_to_it("myFrame"))

这些只是显式等待条件的一部分，根据实际需求也可以自定义其他的等待条件。需要注意的是，每个等待条件都需要使用 By 类指定元素的定位方式和值。

要使用上述的显式等待条件，需要导入以下模块：

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

然后使用 WebDriverWait 类和对应的等待条件进行等待操作。

请根据具体的需求选择合适的等待条件，并根据元素的定位方式和值来指定等待的元素。

2. 隐式等待： 隐式等待是一种全局设置，在查找元素时等待一定的时间，如果元素在规定的时间内找到，则立即进行操作；如果超过规定时间仍未找到元素，则抛出异常。

示例代码：

from selenium import webdriver

driver = webdriver.Chrome()
driver.implicitly_wait(10)  # 设置隐式等待时间为10秒

driver.get("https://www.example.com")

# 元素查找和操作
element = driver.find_element_by_id("myElement")
element.click()

在上述示例中，通过 implicitly_wait() 方法设置了隐式等待时间为10秒。然后，打开了一个网页，并进行元素的查找和操作。当查找元素时，如果元素在10秒内找到，则立即进行操作；如果超过10秒仍未找到元素，则抛出异常。

通过使用显式等待或隐式等待，可以根据具体的需求，在操作元素之前添加一些等待逻辑，从而解决时序间隙导致元素未完全加载出来的问题。请根据实际情况选择适合的等待方式和等待时间。

ActionChains 类

在 Selenium 中，可以使用 ActionChains 类来模拟鼠标的点击操作。下面是一个简单的示例代码，演示了如何使用 Selenium 模拟鼠标点击：

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains

# 创建一个 WebDriver 实例
driver = webdriver.Chrome()

# 打开网页
driver.get("https://example.com")

# 定位到需要点击的元素
element = driver.find_element_by_xpath("//button[@id='myButton']")

# 创建 ActionChains 对象
actions = ActionChains(driver)

# 在元素上执行鼠标点击操作
actions.click(element).perform()

# 关闭浏览器
driver.quit()

上述示例代码中的关键步骤包括：

1. 创建一个 WebDriver 实例，这里使用 Chrome 浏览器作为示例。
2. 使用 get() 方法打开需要的网页。
3. 使用定位方法（例如 find_element_by_xpath()）找到需点击的元素。
4. 创建一个 ActionChains 对象，并将 WebDriver 实例传入。
5. 使用 click() 方法，在指定元素上执行鼠标点击操作。
6. 使用 perform() 方法执行之前的所有动作。
7. 最后，关闭浏览器。

请注意，示例中使用的是 Chrome 浏览器和 XPath 定位方式，你可以根据实际情况选择适合的浏览器和其他定位方式（如 ID、CSS 选择器等）。

通过以上步骤，你可以在 Selenium 中成功模拟鼠标点击操作。

鼠标点击的功能我们前面提到的click() 方法视乎也可以实现，那他们的区别是什么呢。

在 Selenium 中，click() 方法是直接点击一个元素，而 ActionChains 类是用于执行更复杂的鼠标操作。主要的区别包括：

1. click() 方法：
   • 直接点击指定的元素，不需要创建 ActionChains 对象。
   • 只能模拟简单的鼠标左键点击操作，不能执行其他复杂的动作。
   • 适用于大多数情况下的简单点击操作。
2. ActionChains 类：
   • 可以模拟更复杂的鼠标操作，如鼠标按下、移动、释放等操作。
   • 可以执行连续的动作序列，如拖动元素、悬停等操作。
   • 可以通过链式调用多个动作方法来实现复杂的操作。
   • 可以模拟右键点击、双击等特殊的鼠标操作。
   • 可以在特定元素上执行鼠标操作，也可以在屏幕的相对位置上执行操作。
   • 更灵活，适用于需要执行复杂鼠标交互的场景。

因此，如果只需要简单地点击一个元素，使用 click() 方法是更简便和直接的方式。但如果需要模拟更复杂的鼠标操作，或者需要执行多个动作组合，那么使用 ActionChains 类会更加适合。根据具体的测试需求和场景，选择合适的方法来模拟鼠标点击操作。

结语

在实际使用selenium的过程中需要灵活应对各种问题，如果你对selenium感兴趣，不妨接触一些小项目，在实战中加深这些函数的用法。我之前做过的一个获取163邮箱邮件内容的小项目，感兴趣的朋友可以看看这篇文章：采用selenium和beautifulsoup获取163邮箱邮件内容