当前位置： 首页 > news >正文

解锁Selenium：Web自动化的常用操作秘籍

news 来源：原创 2025/6/25 11:21:57

目录

  • 一、Selenium 简介
  • 二、环境搭建
    • 2.1 安装 Selenium 库
    • 2.2 下载浏览器驱动
  • 三、定位元素
    • 3.1 通过 ID 定位
    • 3.2 通过名称定位
    • 3.3 通过 XPath 表达式定位
    • 3.4 通过 CSS 选择器定位
    • 3.5 通过类名定位
    • 3.6 通过标签名定位
  • 四、元素操作
    • 4.1 单击元素
    • 4.2 输入文本
    • 4.3 清除文本内容
    • 4.4 获取元素文本
    • 4.5 获取元素属性值
  • 五、浏览器操作
    • 5.1 打开 URL
    • 5.2 页面导航
    • 5.3 刷新页面
    • 5.4 窗口操作
    • 5.5 关闭浏览器
  • 六、等待操作
    • 6.1 隐式等待
    • 6.2 显式等待
    • 6.3 线程休眠
  • 七、其他常用操作
    • 7.1 切换 iframe
    • 7.2 处理弹窗
    • 7.3 获取和操作 Cookies
    • 7.4 执行 JavaScript 脚本
  • 八、实战演练
    • 8.1 场景设定
    • 8.2 代码实现
    • 8.3 结果验证
  • 九、总结与展望

一、Selenium 简介

Selenium 是一个用于 Web 应用程序自动化测试的工具，它可以直接驱动浏览器，模拟真实用户的操作，如点击按钮、输入文本、选择下拉框等。在 Web 开发和测试领域，Selenium 占据着举足轻重的地位，已然成为 Web 自动化测试的事实标准。凭借其强大的功能，Selenium 允许开发者和测试人员通过编写代码来控制浏览器，实现各种复杂的测试场景和操作，确保 Web 应用在不同环境下的稳定性和正确性。

Selenium 的适用场景极为广泛，其中最主要的应用场景包括：

  • 自动化测试：在 Web 应用的开发过程中，需要进行大量的测试工作，以确保应用的各项功能正常运行。Selenium 可以模拟用户在浏览器中的各种操作，自动执行功能测试、回归测试、性能测试、安全性测试等，大大提高测试效率，减少人工测试的工作量和错误率 。例如，在一个电商网站的开发中，使用 Selenium 可以自动测试用户注册、登录、商品搜索、添加购物车、支付等功能，确保这些功能在不同浏览器和操作系统下都能正常使用。
  • 网页抓取：对于一些需要从网页上获取数据的场景，Selenium 也能发挥重要作用。它可以模拟浏览器加载网页，获取动态生成的内容，突破传统爬虫在处理 JavaScript 渲染页面时的局限。比如，从招聘网站上抓取职位信息，从新闻网站上抓取文章内容等。以抓取某招聘网站的 Python 开发岗位信息为例，Selenium 可以自动登录网站，输入搜索关键词，点击搜索按钮，然后获取搜索结果页面中的职位名称、公司名称、薪资待遇等信息。
  • UI 自动化：通过 Selenium 可以自动化用户界面操作，模拟用户与界面的交互行为，验证 UI 是否按照预期工作，包括界面元素的显示、布局、交互响应等方面。例如，测试一个 Web 应用的界面，检查按钮的位置是否正确，输入框是否可编辑，菜单是否能正常展开和收起等。
  • Web 应用程序的持续集成：Selenium 可以集成到持续集成（CI）流程中，每次代码更改后自动执行测试，确保新的代码不会引入新的问题，保障 Web 应用的质量 。例如，在使用 Jenkins 搭建的持续集成环境中，可以配置 Selenium 测试脚本，在每次代码提交后自动运行测试，并生成测试报告。

二、环境搭建

在使用 Selenium 进行 Web 自动化操作之前，需要先搭建好相应的环境，主要包括安装 Selenium 库和下载浏览器驱动。

2.1 安装 Selenium 库

Selenium 库支持多种编程语言，下面以 Python 和 Java 为例，介绍其安装方法。

  • Python 环境：Python 拥有丰富的第三方库，Selenium 库是其中用于 Web 自动化的重要工具。在 Python 环境中安装 Selenium 库非常简单，前提是已经安装好了 Python 和 pip（Python 的包管理工具）。打开命令行工具，输入以下命令即可安装最新版本的 Selenium 库：
pip install selenium

如果使用的是 Python3，且默认的 pip 指向 Python2，可以使用 pip3 来安装：

pip3 install selenium

安装完成后，可以通过以下命令检查 Selenium 是否安装成功：

pip show selenium

如果显示了 Selenium 的版本信息，说明安装成功。此外，如果需要离线安装 Selenium 库，可以先在联网的计算机上使用pip download selenium命令将 Selenium 库及其所有依赖项的.whl文件下载到当前目录，然后将下载的.whl文件复制到目标离线计算机上，通过pip install selenium-<version>.whl命令进行安装（将<version>替换成具体的 Selenium 版本号）。

  • Java 环境：在 Java 开发中，通常使用 Maven 来管理项目依赖。首先，确保已经安装了 Java 开发工具包（JDK）和 Maven。创建一个新的 Maven 项目，在项目的pom.xml文件中添加 Selenium 的依赖。打开pom.xml文件，在<dependencies>标签内添加以下代码：
<dependency><groupId>org.seleniumhq.selenium</groupId><artifactId>selenium-java</artifactId><version>4.14.0</version> <!-- 请根据最新版本更新 -->
</dependency>

上述代码中，<groupId>指定了组 ID，<artifactId>指定了构件 ID，<version>指定了 Selenium 库的版本号，这里使用的是 4.14.0 版本，实际使用时可根据最新版本进行更新。添加依赖后，Maven 会自动下载 Selenium 库及其相关依赖。

2.2 下载浏览器驱动

Selenium 需要通过浏览器驱动来控制浏览器，不同的浏览器需要下载对应的驱动程序，且驱动程序版本需要与浏览器版本相适配。以下是常见浏览器驱动的下载方法及适配关系：

  • Chrome 浏览器：Chrome 浏览器使用 ChromeDriver 作为驱动程序。首先，查看当前安装的 Chrome 浏览器版本，打开 Chrome 浏览器，点击菜单中的 “帮助”→“关于 Google Chrome”，即可查看版本号。然后，前往 ChromeDriver 下载地址（http://chromedriver.storage.googleapis.com/index.html ），根据 Chrome 浏览器版本选择对应的 ChromeDriver 版本下载。例如，如果 Chrome 浏览器版本是 114.0.5735.110，就下载与之匹配的 ChromeDriver 版本 。下载完成后，解压得到chromedriver.exe文件。在 Windows 系统下，可将该文件移动到 Python 安装目录或添加到系统环境变量中；在 macOS 和 Linux 系统下，一般将其放置在/usr/local/bin目录下。
  • Firefox 浏览器：Firefox 浏览器使用 GeckoDriver 作为驱动程序。查看 Firefox 浏览器版本，点击菜单中的 “帮助”→“关于 Firefox” 即可查看 。前往 GeckoDriver 发布页面（https://github.com/mozilla/geckodriver/releases ），根据浏览器版本选择对应的 GeckoDriver 版本下载。Firefox 浏览器版本与 GeckoDriver 版本的适配关系如下：Firefox 版本≤47，使用 GeckoDriver 版本≤v0.18.0；Firefox 版本≥48，使用对应版本的 GeckoDriver；GeckoDriver 版本≥v0.19.0，支持 Firefox 版本≥55 。下载完成后，解压得到geckodriver文件，同样将其放置在系统环境变量包含的目录（如/usr/local/bin）或 Python 项目目录中。

以 Python 为例，在代码中使用浏览器驱动时，需要指定驱动路径，示例如下：

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.firefox.service import Service as FirefoxService# 使用Chrome浏览器
chrome_service = ChromeService(executable_path='path/to/chromedriver')
driver = webdriver.Chrome(service=chrome_service)# 使用Firefox浏览器
firefox_service = FirefoxService(executable_path='path/to/geckodriver')
driver = webdriver.Firefox(service=firefox_service)

如果将浏览器驱动放在了系统路径中，或者将其放在了 Python 脚本所在的目录下，可以省略executable_path参数 。从 Selenium 4 开始，尝试自动检测系统中安装的浏览器版本并下载相应的驱动程序，不过在国内网络环境下，建议手动下载驱动并指定路径。

三、定位元素

在 Selenium 自动化操作中，定位页面元素是关键步骤，只有准确找到需要操作的元素，才能执行后续的点击、输入、获取文本等操作 。Selenium 提供了多种定位元素的方法，每种方法都有其特点和适用场景，下面将详细介绍这些方法及其使用示例。

3.1 通过 ID 定位

在 HTML 页面中，每个元素的id属性通常是唯一的，通过id定位元素是最直接、高效的方式之一。在 Selenium 中，可以使用find_element(By.ID, “value”)方法来通过id定位元素，其中"value"为元素的id值 。以 Python 语言结合 Selenium 操作百度搜索页面为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过ID定位搜索框
search_box = driver.find_element(By.ID, "kw")
search_box.send_keys("Selenium教程")  # 在搜索框中输入内容
# 通过ID定位搜索按钮并点击
search_button = driver.find_element(By.ID, "su")
search_button.click() 
driver.quit()

上述代码中，首先使用webdriver.Chrome()启动 Chrome 浏览器，然后打开百度首页。接着通过find_element(By.ID, “kw”)定位到百度搜索框（其id为kw），并使用send_keys()方法在搜索框中输入文本 “Selenium 教程” 。再通过find_element(By.ID, “su”)定位到搜索按钮（其id为su），并使用click()方法点击该按钮，实现搜索操作 。最后使用driver.quit()关闭浏览器。

3.2 通过名称定位

当元素具有name属性时，可以使用find_element(By.NAME, “value”)方法通过元素的name属性值来定位元素，其中"value"为元素的name值。继续以百度搜索页面为例，搜索框的name属性值为wd，示例代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过name定位搜索框
search_box = driver.find_element(By.NAME, "wd")
search_box.send_keys("Selenium学习")
driver.quit()

在这个示例中，通过find_element(By.NAME, “wd”)成功定位到百度搜索框，然后在搜索框中输入 “Selenium 学习” 。不过需要注意的是，name属性在页面中不一定是唯一的，如果有多个元素具有相同的name属性值，find_element方法只会返回第一个匹配的元素 。若要获取所有匹配的元素，可以使用find_elements(By.NAME, “value”)方法，它会返回一个包含所有匹配元素的列表。

3.3 通过 XPath 表达式定位

XPath（XML Path Language）是一种用于在 XML 或 HTML 文档中定位节点元素的查询语言，在 Selenium 中，它可以帮助我们在复杂的页面结构中准确定位元素 。XPath 表达式支持绝对路径和相对路径两种方式，绝对路径从文档的根元素开始，以/开头，如/html/body/div[1]/a，表示从html根元素开始，依次查找body元素下的第一个div元素内的a元素 。相对路径则从当前节点开始，以//开头，如//input[@type=‘text’]，表示在整个文档中查找所有type属性为text的input元素 。以下是一些 XPath 表达式的常见用法及示例：

  • 属性定位：通过元素的属性来定位元素，语法为//标签名[@属性名=‘属性值’] 。例如，要定位百度搜索框，可以使用//input[@id=‘kw’]，它会在整个文档中查找id属性为kw的input元素。
  • 索引定位：当有多个相同标签名的元素时，可以使用索引来定位特定的元素，索引从 1 开始。如//div[@class=‘list’]/li[2]，表示定位class属性为list的div元素内的第二个li元素。
  • 文本定位：根据元素的文本内容来定位元素，语法为//标签名[text()=‘文本内容’]。例如，要定位一个文本为 “登录” 的链接，可以使用//a[text()=‘登录’] 。
  • 多条件定位：可以使用and和or运算符组合多个条件来定位元素。如//input[@type=‘text’ and @name=‘username’]，表示定位type属性为text且name属性为username的input元素。

以 Python 代码示例展示如何使用 XPath 定位元素：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过XPath定位搜索框
search_box = driver.find_element(By.XPATH, "//input[@id='kw']")
search_box.send_keys("XPath定位示例")
# 通过XPath定位搜索按钮并点击
search_button = driver.find_element(By.XPATH, "//input[@id='su']")
search_button.click() 
driver.quit()

上述代码中，使用find_element(By.XPATH, “//input[@id=‘kw’]”)通过 XPath 表达式定位到百度搜索框，使用find_element(By.XPATH, “//input[@id=‘su’]”)定位到搜索按钮，实现搜索操作 。XPath 定位非常灵活强大，能够应对各种复杂的页面结构和定位需求，但相对来说，其表达式的编写可能较为复杂，需要对 XPath 语法有深入的理解。

3.4 通过 CSS 选择器定位

CSS 选择器是一种用于选择 HTML 元素的强大语法，它基于 CSS（层叠样式表）规则来定位元素 。在 Selenium 中，使用find_element(By.CSS_SELECTOR, “css表达式”)方法通过 CSS 选择器定位元素，其中"css表达式"为具体的 CSS 选择器表达式。CSS 选择器语法丰富多样，常见的用法包括：

  • ID 选择器：使用#号加上元素的id值来定位元素，如#kw表示定位id为kw的元素，等同于 XPath 中的//*[@id=‘kw’] 。例如，定位百度搜索框的代码为driver.find_element(By.CSS_SELECTOR, “#kw”) 。
  • 类选择器：使用.号加上元素的class值来定位元素，如.s_ipt表示定位class为s_ipt的元素。例如，百度搜索框的class为s_ipt，可以使用driver.find_element(By.CSS_SELECTOR, “.s_ipt”)来定位 。
  • 标签选择器：直接使用标签名来定位元素，如input表示定位所有的input元素 。例如，driver.find_element(By.CSS_SELECTOR, “input”)会返回页面中的第一个input元素 。
  • 属性选择器：通过元素的属性及属性值来定位元素，语法为[属性名=‘属性值’] 。如[type=‘submit’]表示定位所有type属性为submit的元素 。例如，要定位百度搜索按钮（其type属性为submit），可以使用driver.find_element(By.CSS_SELECTOR, “input[type=‘submit’]”) 。
  • 层级选择器：根据元素的父子关系来定位元素，使用>表示直接子元素关系，使用空格表示后代元素关系 。例如，form > input表示定位form元素的直接子元素input，而form input表示定位form元素内的所有后代input元素。

以下是使用 CSS 选择器定位百度搜索框和搜索按钮的 Python 代码示例：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过CSS选择器定位搜索框
search_box = driver.find_element(By.CSS_SELECTOR, "#kw")
search_box.send_keys("CSS选择器定位示例")
# 通过CSS选择器定位搜索按钮并点击
search_button = driver.find_element(By.CSS_SELECTOR, "#su")
search_button.click() 
driver.quit()

CSS 选择器的语法相对简洁，定位速度通常比 XPath 快一些，在实际应用中，如果页面结构比较复杂且元素具有明确的 CSS 样式属性，使用 CSS 选择器定位元素是一个不错的选择。

3.5 通过类名定位

如果元素具有class属性，可以使用find_element(By.CLASS_NAME, “value”)方法通过元素的class属性值来定位元素，其中"value"为元素的class值 。以百度搜索页面为例，搜索框的class属性值为s_ipt，示例代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过class定位搜索框
search_box = driver.find_element(By.CLASS_NAME, "s_ipt")
search_box.send_keys("通过类名定位测试")
driver.quit()

在上述代码中，通过find_element(By.CLASS_NAME, “s_ipt”)成功定位到百度搜索框，并在其中输入文本 “通过类名定位测试” 。需要注意的是，一个元素可能有多个class值，在使用class定位时，只需要传入其中一个唯一能标识该元素的class值即可 。另外，class属性在页面中不一定是唯一的，如果有多个元素具有相同的class属性值，find_element方法只会返回第一个匹配的元素 。若要获取所有匹配的元素，可以使用find_elements(By.CLASS_NAME, “value”)方法。

3.6 通过标签名定位

通过find_element(By.TAG_NAME, “value”)方法可以根据元素的标签名来定位元素，其中"value"为元素的标签名 。例如，要定位页面中的所有input标签元素，可以使用find_elements(By.TAG_NAME, “input”)方法，它会返回一个包含所有input标签元素的列表 。如果只想定位第一个input标签元素，可以使用find_element(By.TAG_NAME, “input”) 。以下是定位百度搜索框（input标签）的示例代码：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 通过标签名定位搜索框
search_box = driver.find_element(By.TAG_NAME, "input")
search_box.send_keys("通过标签名定位尝试")
driver.quit()

在这个示例中，由于百度首页第一个input标签元素就是搜索框，所以通过find_element(By.TAG_NAME, “input”)成功定位到搜索框并输入文本 。不过在实际应用中，一个页面通常会有多个相同标签名的元素，仅通过标签名定位可能无法准确找到目标元素，此时需要结合其他定位方法或筛选条件来进一步确定目标元素。

四、元素操作

在成功定位到页面元素后，就可以对这些元素执行各种操作，以实现自动化交互的目的。Selenium 提供了丰富的方法来对元素进行操作，如单击、输入文本、清除文本、获取文本及获取属性值等，这些操作是 Web 自动化测试和网页抓取的核心步骤。

4.1 单击元素

在 Web 自动化中，单击元素是最常用的操作之一，通常使用click()方法来模拟用户点击按钮、链接、复选框、单选框等元素 。以 Python 语言结合 Selenium 操作百度搜索按钮为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 定位搜索按钮并点击
search_button = driver.find_element(By.ID, "su")
search_button.click() 
driver.quit()

上述代码中，首先使用find_element(By.ID, “su”)定位到百度搜索按钮（其id为su），然后通过click()方法模拟点击该按钮，从而触发搜索操作 。在实际应用中，click()方法在自动化测试和网页抓取场景中有着广泛的应用 。例如，在自动化测试一个电商网站时，需要点击商品详情页的 “加入购物车” 按钮来测试购物车功能，就可以使用click()方法实现；在网页抓取中，有些网站的数据需要点击展开按钮才能获取完整内容，同样可以通过click()方法点击展开按钮，然后再进行数据抓取。此外，click()方法不仅适用于普通的按钮和链接，还可以用于操作各种交互性元素，如菜单的展开和收起、图片的点击放大等。

4.2 输入文本

向页面中的输入框输入文本是另一个常见的操作，利用send_keys()方法可以实现这一功能 。以登录页面输入用户名和密码为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://example.com/login")  # 替换为实际的登录页面URL
# 定位用户名输入框并输入用户名
username_input = driver.find_element(By.ID, "username")
username_input.send_keys("your_username")
# 定位密码输入框并输入密码
password_input = driver.find_element(By.ID, "password")
password_input.send_keys("your_password")
driver.quit()

上述代码中，通过find_element(By.ID, “username”)定位到用户名输入框，使用send_keys(“your_username”)在其中输入用户名；再通过find_element(By.ID, “password”)定位到密码输入框，使用send_keys(“your_password”)输入密码 。在实际的 Web 应用中，除了登录功能，还有许多需要输入文本的场景，如搜索框输入关键词、表单填写用户信息、评论框输入评论内容等，都可以通过send_keys()方法来实现 。在输入文本时，还可以模拟用户的输入行为，如输入过程中添加停顿、删除部分字符后重新输入等。例如，可以使用time模块在send_keys()方法之间添加停顿，模拟用户正常输入的速度：

import time
from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://example.com/form") 
name_input = driver.find_element(By.ID, "name")
name_input.send_keys("John")
time.sleep(1)  # 停顿1秒
name_input.send_keys(Keys.BACKSPACE)  # 删除最后一个字符
name_input.send_keys("n")  # 重新输入最后一个字符
driver.quit()

上述代码中，使用time.sleep(1)停顿 1 秒，模拟用户输入时的思考时间；使用Keys.BACKSPACE模拟按下退格键删除最后一个字符，再重新输入正确的字符。

4.3 清除文本内容

当需要在已有的输入框中重新输入内容时，首先需要清除输入框中已有的文本内容，clear()方法可以实现这一操作 。以百度搜索框为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 定位搜索框，输入内容，然后清除内容
search_box = driver.find_element(By.ID, "kw")
search_box.send_keys("初始输入内容")
search_box.clear() 
driver.quit()

上述代码中，先通过find_element(By.ID, “kw”)定位到百度搜索框，使用send_keys(“初始输入内容”)在搜索框中输入内容，然后使用clear()方法清除搜索框中的内容，以便重新输入新的搜索关键词 。在实际应用中，clear()方法常用于表单输入场景，例如在一个用户注册表单中，如果之前已经输入了错误的信息，需要重新输入时，就可以使用clear()方法清除已有的错误信息，再输入正确的内容 。需要注意的是，clear()方法只能清除可编辑元素（如input、textarea等）中的文本内容，如果元素不可编辑，调用clear()方法会抛出异常 。此外，对于一些特殊的输入框，可能存在默认值或占位符，clear()方法可以将这些默认值和占位符一并清除。

4.4 获取元素文本

在 Web 自动化操作中，经常需要获取页面中元素的可见文本内容，使用text属性可以轻松实现这一功能 。以获取百度首页 “新闻” 链接的文本为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 获取新闻链接的文本内容
news_link = driver.find_element(By.LINK_TEXT, "新闻")
text = news_link.text
print(text) 
driver.quit()

上述代码中，通过find_element(By.LINK_TEXT, “新闻”)定位到百度首页的 “新闻” 链接，然后使用text属性获取该链接的文本内容，并打印输出 。在实际应用中，获取元素文本常用于自动化测试中的断言和网页抓取中的数据提取 。例如，在自动化测试一个电商商品详情页时，可以获取商品名称、价格、描述等元素的文本内容，然后与预期值进行比较，以验证页面显示的信息是否正确；在网页抓取中，需要提取网页中的文章标题、正文内容、作者信息等，text属性可以帮助我们方便地获取这些文本数据。需要注意的是，text属性获取的是元素的可见文本内容，不包括元素内部的 HTML 标签和隐藏文本。如果需要获取包含 HTML 标签的内容，可以使用get_attribute(‘innerHTML’)方法。

4.5 获取元素属性值

除了获取元素文本，有时还需要获取元素的指定属性值，使用get_attribute()方法可以实现这一目的 。以获取链接的href属性值为例，代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://www.baidu.com")
# 获取新闻链接的href属性值
news_link = driver.find_element(By.LINK_TEXT, "新闻")
href_value = news_link.get_attribute("href")
print(href_value) 
driver.quit()

上述代码中，通过find_element(By.LINK_TEXT, “新闻”)定位到百度首页的 “新闻” 链接，然后使用get_attribute(“href”)方法获取该链接的href属性值，即链接的目标 URL，并打印输出 。在实际应用中，获取元素属性值有着广泛的用途 。例如，在自动化测试中，可以获取按钮的disabled属性值，判断按钮是否可点击；在网页抓取中，获取图片的src属性值，可以下载图片；获取表单元素的name和id属性值，方便进行表单提交等操作 。get_attribute()方法不仅可以获取常见的属性值，还可以获取自定义属性值 。如果元素不存在指定的属性，get_attribute()方法会返回None 。此外，对于一些特殊属性，如class属性，在 HTML 中可能存在多个类名，get_attribute(“class”)会返回所有类名组成的字符串。

五、浏览器操作

在 Selenium 自动化测试中，对浏览器本身的操作是不可或缺的一部分。通过对浏览器的各种操作，如打开 URL、页面导航、刷新页面、窗口操作以及关闭浏览器等，可以模拟用户在浏览器中的各种行为，实现更全面、更真实的自动化测试场景 。这些操作不仅能满足基本的页面访问需求，还能应对复杂的页面交互和多窗口管理情况，为 Web 自动化测试提供了强大的支持。

5.1 打开 URL

在 Selenium 中，使用get(url)方法可以打开指定的网页链接，其中url为要打开的网页地址 。以 Python 语言结合 Selenium 打开百度首页为例，代码如下：

from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://www.baidu.com") 
# 后续可以在此基础上进行页面元素定位和操作
driver.quit()

上述代码中，首先创建了一个 Chrome 浏览器的驱动实例driver，然后使用driver.get(“http://www.baidu.com”)打开百度首页 。在实际应用中，get(url)方法不仅用于打开普通的 HTML 页面，还可以用于打开各种类型的 Web 应用页面，如单页应用（SPA）、动态加载页面等 。在打开动态加载页面时，可能需要结合等待机制（如隐式等待或显式等待），确保页面元素完全加载后再进行后续操作，以避免因元素未加载而导致的定位失败或操作异常。

5.2 页面导航

在浏览网页时，经常需要使用浏览器的前进和后退功能，Selenium 提供了back()和forward()方法来模拟这些操作 。back()方法用于返回上一个浏览的页面，forward()方法用于前进到下一个页面 。以 Python 代码示例展示其在页面导航中的应用：

from selenium import webdriver
import timedriver = webdriver.Chrome()
driver.get("http://www.example.com")  # 打开第一个页面
time.sleep(2) 
# 点击某个链接，跳转到第二个页面
link = driver.find_element_by_link_text("链接文本") 
link.click() 
time.sleep(2) 
# 后退到第一个页面
driver.back() 
time.sleep(2) 
# 再前进到第二个页面
driver.forward() 
time.sleep(2) 
driver.quit()

上述代码中，先打开一个页面，然后点击链接跳转到另一个页面，接着使用driver.back()方法后退到上一个页面，再使用driver.forward()方法前进到下一个页面。在实际应用中，页面导航操作在自动化测试中常用于模拟用户在不同页面之间的切换，例如在一个电商网站的测试中，用户可能会在商品列表页、商品详情页、购物车页之间频繁切换，通过back()和forward()方法可以方便地模拟这些操作，测试页面之间的导航功能是否正常。

5.3 刷新页面

使用refresh()方法可以实现浏览器页面的刷新操作，当页面内容需要更新或者出现加载异常时，常常会用到页面刷新 。以 Python 代码示例说明如何实现页面刷新：

from selenium import webdriver
import timedriver = webdriver.Chrome()
driver.get("http://www.example.com") 
time.sleep(2) 
# 刷新页面
driver.refresh() 
time.sleep(2) 
driver.quit()

上述代码中，打开一个页面后，使用driver.refresh()方法刷新页面 。在实际应用中，页面刷新在自动化测试和网页抓取场景中都有广泛应用 。在自动化测试中，可能需要验证页面刷新后某些元素的状态是否正确，或者页面数据是否及时更新；在网页抓取中，有时需要刷新页面以获取最新的数据 。例如，在一个实时数据监控的网页抓取项目中，通过定时调用refresh()方法刷新页面，然后获取最新的监控数据。

5.4 窗口操作

在 Web 自动化测试中，经常需要对浏览器窗口进行操作，如最大化、最小化和设置大小等 。Selenium 提供了maximize_window()、minimize_window()和set_window_size(width, height)等方法来实现这些操作 。以 Python 代码示例展示对浏览器窗口的操作：

from selenium import webdriver
import timedriver = webdriver.Chrome()
# 最大化窗口
driver.maximize_window() 
time.sleep(2) 
# 最小化窗口
driver.minimize_window() 
time.sleep(2) 
# 设置窗口大小为800x600
driver.set_window_size(800, 600) 
time.sleep(2) 
driver.quit()

上述代码中，首先使用driver.maximize_window()将浏览器窗口最大化，然后使用driver.minimize_window()将窗口最小化，最后使用driver.set_window_size(800, 600)将窗口设置为指定大小（宽 800 像素，高 600 像素）。在实际应用中，窗口操作在自动化测试中非常重要，因为不同的窗口大小可能会影响页面元素的布局和显示，通过对窗口进行各种操作，可以测试页面在不同窗口状态下的兼容性和显示效果 。例如，在测试一个响应式 Web 设计的网站时，需要在不同的窗口大小下测试页面的布局是否合理，内容是否完整显示。

5.5 关闭浏览器

在完成 Web 自动化操作后，需要正确关闭浏览器窗口或退出浏览器进程，Selenium 提供了close()和quit()方法来实现这一目的 。close()方法用于关闭当前焦点所在的浏览器窗口，如果当前窗口是浏览器的唯一窗口，则关闭整个浏览器；quit()方法用于关闭所有与驱动程序关联的浏览器窗口，并退出浏览器进程，同时会释放与浏览器相关的资源。以下是两者的使用示例及区别说明：

from selenium import webdriver
import timedriver = webdriver.Chrome()
driver.get("http://www.example.com") 
# 打开一个新窗口
driver.execute_script("window.open('');") 
time.sleep(2) 
# 关闭当前窗口（假设当前窗口不是唯一窗口）
driver.close() 
time.sleep(2) 
# 退出浏览器进程，关闭所有窗口
driver.quit()

在上述示例中，首先打开一个网页，然后通过 JavaScript 脚本打开一个新窗口 。接着使用driver.close()关闭当前焦点所在的窗口（如果还有其他窗口打开，则其他窗口不会关闭） 。最后使用driver.quit()退出浏览器进程，关闭所有打开的窗口，并释放相关资源 。在实际应用中，如果只是需要关闭当前操作的窗口，并且不希望影响其他窗口的运行，可以使用close()方法；如果需要完全结束浏览器会话，关闭所有相关窗口并释放资源，则应使用quit()方法 。例如，在一个自动化测试脚本中，可能会打开多个窗口进行不同的操作，在测试结束时，使用quit()方法可以确保所有窗口都被关闭，避免资源占用和潜在的问题。

六、等待操作

在 Web 自动化测试中，由于网页加载速度受网络、服务器性能等因素影响，页面元素的加载时间可能会有所不同。如果在元素尚未加载完成时就进行操作，很可能会导致脚本失败 。因此，Selenium 提供了多种等待机制，以确保在执行操作之前，页面元素已经加载并可用 。这些等待机制可以有效地解决因元素加载延迟而引发的问题，提高自动化测试的稳定性和可靠性。

6.1 隐式等待

隐式等待是一种全局性的等待机制，它会在查找元素时等待一定的时间 。如果在指定的时间内找到了元素，Selenium 会立即继续执行后续操作；如果超时仍未找到元素，则会抛出NoSuchElementException异常 。隐式等待通过implicitly_wait()方法来设置，这个方法只需要调用一次，之后的所有元素查找操作都会遵循这个等待时间。以 Python 语言结合 Selenium 操作百度首页为例，设置隐式等待时间为 10 秒，代码如下：

from selenium import webdriverdriver = webdriver.Chrome()
# 设置隐式等待时间为10秒
driver.implicitly_wait(10) 
driver.get("http://www.baidu.com")
# 查找新闻链接元素
news_link = driver.find_element_by_link_text("新闻") 
news_link.click() 
driver.quit()

上述代码中，首先创建了 Chrome 浏览器的驱动实例driver，然后使用driver.implicitly_wait(10)设置隐式等待时间为 10 秒 。接着打开百度首页，使用driver.find_element_by_link_text(“新闻”)查找 “新闻” 链接元素时，如果该元素没有立即出现，Selenium 会在 10 秒内不断尝试查找，直到找到元素或超时 。找到元素后，点击该链接。最后关闭浏览器。

6.2 显式等待

显式等待是一种更为灵活的等待机制，它允许为特定的操作设置等待条件 。显式等待通常与WebDriverWait类和expected_conditions模块一起使用 。WebDriverWait类提供了等待的功能，expected_conditions模块则提供了一系列预定义的等待条件 。例如，presence_of_element_located表示等待元素出现在 DOM 中，visibility_of_element_located表示等待元素出现在 DOM 中并且可见，element_to_be_clickable表示等待元素可点击 。以 Python 代码示例展示如何使用显式等待等待元素可点击：

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 ECdriver = webdriver.Chrome()
driver.get("http://www.example.com") 
# 设置显式等待，最多等待10秒，直到元素可点击
element = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, "element_id"))
)
element.click() 
driver.quit()

上述代码中，首先创建 Chrome 浏览器驱动实例driver，打开网页http://www.example.com 。然后使用WebDriverWait(driver, 10)创建一个显式等待对象，设置最长等待时间为 10 秒 。接着使用until()方法，传入EC.element_to_be_clickable((By.ID, “element_id”))等待条件，等待 ID 为element_id的元素变为可点击状态。当元素满足可点击条件时，until()方法返回该元素，然后对该元素执行点击操作。最后关闭浏览器。在实际应用中，显式等待适用于复杂的、动态加载的网页，可以根据实际情况灵活设置等待条件。例如，在测试一个电商网站的购物车功能时，添加商品到购物车后，可能需要等待 “去结算” 按钮变为可点击状态，才能进行下一步操作，这时就可以使用显式等待来实现。

6.3 线程休眠

线程休眠是一种简单的等待方式，通过time.sleep()方法让脚本暂停执行指定的时间。无论页面是否加载完成，脚本都会等待指定的时间后再继续执行 。以 Python 代码示例说明如何使用线程休眠：

import time
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://www.example.com") 
# 线程休眠5秒
time.sleep(5) 
# 查找元素
element = driver.find_element_by_id("element_id") 
element.click() 
driver.quit()

上述代码中，打开网页后，使用time.sleep(5)使线程暂停执行 5 秒 。在这 5 秒内，页面可能会继续加载元素。5 秒后，继续查找 ID 为element_id的元素并点击 。最后关闭浏览器。在自动化操作中，适当使用线程休眠的场景通常是在需要等待一些固定时间的操作之后，例如在登录操作后，等待页面跳转完成。不过需要注意的是，线程休眠是一种固定的等待方式，可能会导致不必要的等待时间，降低自动化测试的效率 。而且它无法根据页面加载情况动态调整等待时间，在复杂的测试场景中，不建议大量使用线程休眠 ，更多时候应结合隐式等待或显式等待来确保操作的准确性和稳定性。

七、其他常用操作

7.1 切换 iframe

在网页中，iframe 是一种常见的元素，它允许在一个 HTML 页面中嵌入另一个 HTML 页面 。当需要操作 iframe 框架内的元素时，首先需要切换到对应的 iframe 框架，在 Selenium 中，可以使用switch_to.frame()方法来实现这一操作 。这个方法接受一个参数，该参数可以是 iframe 的id、name属性值，也可以是通过定位方法找到的 iframe 元素对象。

假设网页中有一个 id 为my_iframe的 iframe，要切换到该 iframe 并操作其中的元素，示例代码如下：

from selenium import webdriver
from selenium.webdriver.common.by import Bydriver = webdriver.Chrome()
driver.get("http://example.com") 
# 切换到id为my_iframe的iframe
driver.switch_to.frame("my_iframe") 
# 定位并操作iframe内的元素
element = driver.find_element(By.ID, "element_in_iframe") 
element.click() 
# 操作完成后，切换回主页面
driver.switch_to.default_content() 
driver.quit()

上述代码中，首先使用driver.get(“http://example.com”)打开网页，然后通过driver.switch_to.frame(“my_iframe”)切换到 id 为my_iframe的 iframe。接着在 iframe 内定位到 id 为element_in_iframe的元素，并点击该元素。最后，使用driver.switch_to.default_content()切换回主页面 。在实际应用中，切换 iframe 的场景非常常见，例如在自动化测试一个包含 iframe 的富文本编辑器时，需要切换到 iframe 内，才能对编辑器中的内容进行输入、删除、格式设置等操作。如果页面中存在多层嵌套的 iframe，需要逐层切换。例如，有一个主 iframe，其中又嵌套了一个子 iframe，要切换到子 iframe，代码如下：

# 切换到主iframe
driver.switch_to.frame("parent_iframe") 
# 再切换到子iframe
driver.switch_to.frame("child_iframe")

如果要从子 iframe 切换回主 iframe，可以使用driver.switch_to.parent_frame()方法。切换 iframe 时，务必确保 iframe 已经加载完成，否则可能会出现定位失败的情况。可以结合显式等待来等待 iframe 加载，示例代码如下：

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC# 等待iframe可切换，最多等待10秒
WebDriverWait(driver, 10).until(EC.frame_to_be_available_and_switch_to_it("my_iframe"))

上述代码中，使用WebDriverWait和EC.frame_to_be_available_and_switch_to_it等待条件，等待 id 为my_iframe的 iframe 可用并切换到该 iframe ，如果在 10 秒内 iframe 可用，就会切换到该 iframe，否则会抛出异常。

7.2 处理弹窗

在 Web 应用中，经常会遇到各种弹窗，如alert、confirm和prompt弹窗 。这些弹窗通常用于向用户显示提示信息、确认操作或获取用户输入。在 Selenium 自动化测试中，需要正确处理这些弹窗，才能保证测试流程的顺利进行。Selenium 提供了switch_to.alert方法来切换到弹窗，结合accept()、dismiss()和send_keys()等方法来对弹窗进行操作。

  • 处理 alert 弹窗：alert弹窗通常用于显示一条简单的提示信息，用户只能点击 “确定” 按钮关闭弹窗 。以 Python 代码示例展示如何处理alert弹窗：
from selenium import webdriver
from selenium.webdriver.common.alert import Alert
import timedriver = webdriver.Chrome()
driver.get("http://example.com/alert_page") 
# 触发alert弹窗，这里假设页面上有一个按钮，点击后会弹出alert弹窗
driver.find_element(By.ID, "alert_button").click() 
time.sleep(2) 
# 切换到alert弹窗
alert = Alert(driver) 
# 获取弹窗文本
print(alert.text) 
# 点击“确定”按钮关闭弹窗
alert.accept() 
driver.quit()

上述代码中，首先打开包含alert弹窗的页面，然后点击触发alert弹窗的按钮 。接着使用Alert(driver)切换到alert弹窗，通过alert.text获取弹窗文本并打印，最后使用alert.accept()点击 “确定” 按钮关闭弹窗。

  • 处理 confirm 弹窗：confirm弹窗用于确认用户的操作，用户可以选择点击 “确定” 或 “取消” 按钮 。以 Python 代码示例展示如何处理confirm弹窗：
from selenium import webdriver
from selenium.webdriver.common.alert import Alert
import timedriver = webdriver.Chrome()
driver.get("http://example.com/confirm_page") 
# 触发confirm弹窗，假设页面上有一个按钮，点击后会弹出confirm弹窗
driver.find_element(By.ID, "confirm_button").click() 
time.sleep(2) 
# 切换到confirm弹窗
alert = Alert(driver) 
# 获取弹窗文本
print(alert.text) 
# 点击“确定”按钮
alert.accept() 
# 再次触发confirm弹窗
driver.find_element(By.ID, "confirm_button").click() 
time.sleep(2) 
# 切换到confirm弹窗
alert = Alert(driver) 
# 点击“取消”按钮
alert.dismiss() 
driver.quit()

上述代码中，打开包含confirm弹窗的页面，点击触发confirm弹窗的按钮 。切换到confirm弹窗，获取弹窗文本并打印，然后点击 “确定” 按钮 。再次触发confirm弹窗，切换到弹窗后点击 “取消” 按钮。

  • 处理 prompt 弹窗：prompt弹窗用于获取用户输入，用户可以在弹窗中输入文本，并选择点击 “确定” 或 “取消” 按钮 。以 Python 代码示例展示如何处理prompt弹窗：
from selenium import webdriver
from selenium.webdriver.common.alert import Alert
import timedriver = webdriver.Chrome()
driver.get("http://example.com/prompt_page") 
# 触发prompt弹窗，假设页面上有一个按钮，点击后会弹出prompt弹窗
driver.find_element(By.ID, "prompt_button").click() 
time.sleep(2) 
# 切换到prompt弹窗
alert = Alert(driver) 
# 获取弹窗文本
print(alert.text) 
# 输入文本
alert.send_keys("用户输入内容") 
# 点击“确定”按钮
alert.accept() 
driver.quit()

上述代码中，打开包含prompt弹窗的页面，点击触发prompt弹窗的按钮 。切换到prompt弹窗，获取弹窗文本并打印，使用alert.send_keys(“用户输入内容”)在弹窗中输入文本，最后点击 “确定” 按钮 。在处理弹窗时，需要注意弹窗的出现时机，确保在弹窗出现后再进行切换和操作 。可以结合显式等待来等待弹窗出现，例如：

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC# 等待alert弹窗出现，最多等待10秒
WebDriverWait(driver, 10).until(EC.alert_is_present()) 
alert = Alert(driver)

上述代码中，使用WebDriverWait和EC.alert_is_present等待条件，等待alert弹窗出现，最多等待 10 秒 。如果在 10 秒内alert弹窗出现，就可以进行后续操作，否则会抛出异常。

7.3 获取和操作 Cookies

在 Web 应用中，Cookies 用于存储用户的会话信息、登录状态等 。在 Selenium 自动化测试中，有时需要获取、添加和删除页面的 Cookies，以满足不同的测试需求。Selenium 提供了get_cookies()、add_cookie()和delete_cookie()等方法来操作 Cookies。

  • 获取 Cookies：使用get_cookies()方法可以获取当前页面的所有 Cookies，该方法返回一个包含所有 Cookie 信息的列表，每个 Cookie 信息以字典的形式存储 。以 Python 代码示例展示如何获取 Cookies：
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://example.com") 
# 获取所有Cookies
cookies = driver.get_cookies() 
for cookie in cookies:print(cookie) 
driver.quit()

上述代码中，打开网页后，使用driver.get_cookies()获取所有 Cookies，并遍历打印每个 Cookie 的信息 。如果只需要获取某个特定名称的 Cookie，可以使用get_cookie(name)方法，其中name为 Cookie 的名称 。例如：

# 获取名为"username"的Cookie
username_cookie = driver.get_cookie("username") 
print(username_cookie)
  • 添加 Cookies：使用add_cookie(cookie_dict)方法可以向当前页面添加一个 Cookie，其中cookie_dict是一个包含 Cookie 信息的字典，字典的键包括name（Cookie 名称）、value（Cookie 值）、domain（Cookie 所属域名）、path（Cookie 路径）等。以 Python 代码示例展示如何添加 Cookie：
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://example.com") 
# 添加Cookie
new_cookie = {"name": "test_cookie","value": "test_value","domain": "example.com","path": "/"
}
driver.add_cookie(new_cookie) 
# 再次获取所有Cookies，查看添加后的结果
cookies = driver.get_cookies() 
for cookie in cookies:print(cookie) 
driver.quit()

上述代码中，打开网页后，定义一个包含 Cookie 信息的字典new_cookie，然后使用driver.add_cookie(new_cookie)添加该 Cookie 。最后再次获取所有 Cookies，查看添加后的结果。

  • 删除 Cookies：使用delete_cookie(name)方法可以删除指定名称的 Cookie，使用delete_all_cookies()方法可以删除当前页面的所有 Cookies。以 Python 代码示例展示如何删除 Cookie：
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://example.com") 
# 删除名为"test_cookie"的Cookie
driver.delete_cookie("test_cookie") 
# 删除所有Cookies
driver.delete_all_cookies() 
driver.quit()

上述代码中，打开网页后，先使用driver.delete_cookie(“test_cookie”)删除名为test_cookie的 Cookie，然后使用driver.delete_all_cookies()删除所有 Cookies 。在实际应用中，获取和操作 Cookies 的场景非常广泛。例如，在自动化测试中，可以通过获取登录后的 Cookie，实现免登录访问；在网页抓取中，可以添加特定的 Cookie，模拟已登录用户获取受限的数据。

7.4 执行 JavaScript 脚本

虽然 Selenium 提供了丰富的方法来操作网页元素，但在某些情况下，使用 Selenium 的 API 无法满足复杂的页面操作需求 。这时，可以通过执行 JavaScript 脚本来实现更高级的功能 。Selenium 提供了execute_script()方法来执行 JavaScript 代码，该方法接受一个 JavaScript 脚本字符串作为参数，如果脚本有返回值，可以通过该方法获取返回值。

  • 滚动页面：在 Web 自动化测试中，有时需要滚动页面来使某些元素可见或加载更多内容。通过执行 JavaScript 脚本可以轻松实现页面滚动。以 Python 代码示例展示如何滚动页面到指定位置：
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://example.com") 
# 滚动页面到页面底部
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);") 
# 滚动页面到页面顶部
driver.execute_script("window.scrollTo(0, 0);") 
driver.quit()

上述代码中，使用driver.execute_script(“window.scrollTo(0, document.body.scrollHeight);”)将页面滚动到页面底部，使用driver.execute_script(“window.scrollTo(0, 0);”)将页面滚动到页面顶部。如果要将某个元素滚动到可见区域，可以使用以下代码：

element = driver.find_element(By.ID, "element_id") 
driver.execute_script("arguments[0].scrollIntoView();", element)

上述代码中，先定位到 id 为element_id的元素，然后使用driver.execute_script(“arguments[0].scrollIntoView();”, element)将该元素滚动到可见区域。arguments[0]指代传递给 JavaScript 脚本的第一个参数，即定位到的元素。

  • 修改页面元素属性：通过执行 JavaScript 脚本，可以修改页面元素的属性，如修改输入框的readonly属性，使其可编辑。以 Python 代码示例展示如何修改元素属性：
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://example.com") 
# 修改输入框的readonly属性为false，使其可编辑
driver.execute_script("document.getElementById('input_id').readOnly = false;") 
# 向输入框中输入内容
driver.find_element(By.ID, "input_id").send_keys("修改后的内容") 
driver.quit()

上述代码中，使用driver.execute_script(“document.getElementById(‘input_id’).readOnly = false;”)修改 id 为input_id的输入框的readonly属性为false，使其可编辑 。然后使用driver.find_element(By.ID, “input_id”).send_keys(“修改后的内容”)向输入框中输入内容 。在实际应用中，执行 JavaScript 脚本可以实现许多复杂的页面操作，如模拟鼠标悬停、点击隐藏元素、修改页面样式等。通过结合 Selenium 的元素定位方法和 JavaScript 脚本执行功能，可以大大扩展 Web 自动化测试和网页抓取的能力。需要注意的是，在执行 JavaScript 脚本时，要确保脚本的正确性和安全性，避免因脚本错误导致自动化测试失败或对页面造成不良影响。

八、实战演练

8.1 场景设定

假设我们要在一个电商网站（以京东为例）上进行一系列操作，模拟用户搜索商品、添加商品到购物车并结账的流程 。具体步骤如下：

  1. 打开京东首页。
  2. 在搜索框中输入商品关键词，如 “笔记本电脑”。
  3. 点击搜索按钮，进入搜索结果页面。
  4. 选择搜索结果中的一款商品，点击进入商品详情页。
  5. 在商品详情页中，点击 “加入购物车” 按钮，将商品添加到购物车。
  6. 进入购物车页面，点击 “去结算” 按钮。
  7. 在结算页面，填写收货地址、选择支付方式等信息，完成结账操作 。

8.2 代码实现

以下是使用 Python 和 Selenium 编写的实现上述场景的自动化脚本：

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time# 初始化浏览器驱动
driver = webdriver.Chrome()
# 打开京东首页
driver.get("https://www.jd.com/")
# 最大化窗口
driver.maximize_window()# 定位搜索框，输入“笔记本电脑”，并回车搜索
search_box = driver.find_element(By.ID, "key")
search_box.send_keys("笔记本电脑")
search_box.send_keys(Keys.RETURN)# 等待搜索结果页面加载完成，这里使用显式等待，最多等待10秒，直到页面中出现商品列表元素
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".gl-item"))
)# 选择搜索结果中的第一款商品，点击进入商品详情页
first_product = driver.find_element(By.CSS_SELECTOR, ".gl-item:first-child .p-img a")
first_product.click()# 切换到新打开的商品详情页窗口，因为点击商品链接会打开新窗口，所以需要切换窗口句柄
# 获取当前所有窗口句柄
window_handles = driver.window_handles
# 切换到最新打开的窗口（即商品详情页窗口）
driver.switch_to.window(window_handles[-1])# 等待商品详情页加载完成，使用显式等待，最多等待10秒，直到“加入购物车”按钮可点击
WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, "InitCartUrl"))
)
# 点击“加入购物车”按钮
add_to_cart_button = driver.find_element(By.ID, "InitCartUrl")
add_to_cart_button.click()# 等待商品添加到购物车提示出现，使用显式等待，最多等待10秒，直到提示元素出现
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".text"))
)# 进入购物车页面，这里通过点击页面右上角的购物车图标进入
# 先定位购物车图标元素，再点击
cart_icon = driver.find_element(By.CSS_SELECTOR, ".mini-cart")
cart_icon.click()# 等待购物车页面加载完成，使用显式等待，最多等待10秒，直到购物车中出现商品元素
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".cart-list-goods"))
)# 点击“去结算”按钮
checkout_button = driver.find_element(By.CSS_SELECTOR, ".submit-btn")
checkout_button.click()# 这里省略填写收货地址、选择支付方式等复杂操作，实际应用中需要根据具体页面元素进行操作
# 可以添加一些简单的提示信息，表明已进入结账流程
print("已进入结账流程，后续需手动完成收货地址填写和支付方式选择等操作")# 暂停5秒，以便观察操作结果
time.sleep(5)# 关闭浏览器
driver.quit()

8.3 结果验证

运行上述自动化脚本后，可以通过以下方式验证操作结果是否符合预期：

  • 检查商品是否成功添加到购物车：在点击 “加入购物车” 按钮后，通过显式等待购物车中商品元素的出现来验证 。如果在指定时间内成功定位到购物车中商品元素（如WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, “.cart-list-goods”)))），则说明商品已成功添加到购物车。此外，还可以获取购物车中商品的数量和名称等信息，与添加的商品进行比对。例如，可以使用cart_product_name = driver.find_element(By.CSS_SELECTOR, “.cart-list-goods .p-name em”).text获取购物车中商品的名称，然后与添加的商品名称进行比较，确保一致。
  • 检查是否成功进入结账流程：在点击 “去结算” 按钮后，可以通过检查页面 URL 是否跳转到结账页面来验证。例如，使用current_url = driver.current_url获取当前页面 URL，然后判断 URL 中是否包含结账页面的特征字符串，如if “checkout” in current_url.lower(): print(“成功进入结账流程”) 。还可以检查结账页面中是否出现了必要的元素，如收货地址填写区域、支付方式选择区域等。例如，使用address_area = driver.find_elements(By.CSS_SELECTOR, “.address-area”)查找收货地址填写区域元素，如果找到该元素，则说明结账页面加载正常。在实际应用中，还可以进一步验证结账流程中的各个步骤是否正常，如填写收货地址后是否能正确保存，选择支付方式后是否能正常跳转到支付页面等。

九、总结与展望

通过对 Selenium 常用方法操作的全面学习，我们深入掌握了从环境搭建、元素定位与操作，到浏览器控制、等待机制以及其他高级操作的核心要点。这些方法在 Web 自动化领域至关重要，是实现高效、准确自动化测试和网页抓取的基石。

在实际应用中，无论是对 Web 应用进行全面的功能测试，确保每个页面元素的交互和业务逻辑正常运行，还是从网页中精准抓取所需数据，Selenium 的这些方法都发挥着不可或缺的作用。例如，在电商平台的自动化测试中，通过定位元素实现用户登录、商品搜索、下单购买等操作的自动化，大大提高了测试效率和准确性；在数据采集项目中，利用 Selenium 获取动态网页的数据，为数据分析提供了丰富的数据来源。

展望未来，随着 Web 技术的持续创新和发展，Selenium 也将不断演进。一方面，在面对日益复杂的 Web 应用，如采用了先进的前端框架、具备复杂交互和动态加载特性的单页应用（SPA）时，Selenium 有望进一步优化其元素定位和操作机制，以更精准、高效地应对这些挑战 。例如，在处理 SPA 应用中频繁的异步数据加载和 DOM 更新时，Selenium 可能会引入更智能的等待策略和元素识别算法，确保在复杂场景下也能准确地定位和操作元素 。另一方面，随着人工智能（AI）和机器学习（ML）技术在测试领域的融合趋势不断增强，Selenium 有可能集成 AI 和 ML 技术，实现更智能化的测试。比如，利用机器学习算法自动分析测试结果，预测潜在的缺陷；借助 AI 技术实现自动化测试脚本的自动生成和优化，进一步提高测试效率和质量。同时，Selenium 在跨浏览器和跨平台测试方面也可能会有更出色的表现，更好地适应不同浏览器和操作系统的多样性，为 Web 开发和测试提供更强大、更全面的支持。

相关文章：

  • 嘉兴网嘉兴网站建设杭州网站关键词排名优化
  • 个人网站管理系统网店推广方案
  • 专门做自驾游攻略的网站网站产品怎么优化
  • 一个服务器可以做几个网站北京网站
  • 深圳网站制作济南短视频营销推广策略
  • 静态网站建设的主要技术重庆seo网页优化
  • 第九节 CSS工程化-预处理技术对比
  • DVWA Brute Force漏洞深度分析与利用指南
  • C# VB.NET中Tuple轻量级数据结构和固定长度数组
  • 秋招Day14 - MySQL - 场景题
  • RabbitMQ 利用死信队列来实现延迟消息
  • Linux Sonic Agent 端部署（详细版）（腾讯云）
  • Google Cloud Platform(GCP)实例中使用显卡信息报错问题
  • 裸机项目添加FreeRTOS操作系统--常见报错
  • Kubernetes生命周期管理：深入理解 Pod 生命周期
  • Aerotech系列（4）Aerotech.A3200名空间
  • SpringBoot + MyBatis 事务管理全解析：从 @Transactional 到 JDBC Connection 的旅程
  • Airtable 的数据超出上限，3 种常见应对方式
  • 较大项目 git(gitee, github) 拉取失败解决方法
  • Linux系统环境编程
  • NHDeep智能档案题名(标题)校对工具使用说明
  • Linux线程概念及常用接口（1）
  • Redis 乱码和LocalDateTime类型缓存问题
  • 电商领域企业级应用后端开发 (Java) 就业前景深度分析报告 (2025-2030)
  • uniapp项目之小兔鲜儿小程序商城(六) 地址模块:地址管理页的实现,地址表单页的实现
  • 随机算法设计思想总结