0
0

selenium网页自动化使用教程

Selenium 是一个流行的自动化测试工具，它支持多种编程语言，包括 Python。以下是关于 Selenium 安装和使用的一些详细步骤：

安装 Selenium：

  • 确保 Python 环境已经安装在你的计算机上。Selenium 支持 Python 2.7 以及 Python 3.2 至 3.4 版本。
  • 使用 pip 来安装 Selenium。打开命令行工具，输入以下命令：pip install selenium
  • 如果你使用的是 Python 3.4 或更高版本，那么 pip 已经包含在标准库中。
  1. 安装浏览器驱动：- Selenium 需要特定浏览器的驱动程序来与浏览器进行交互。例如，对于 Chrome 浏览器，你需要下载 ChromeDriver。- 下载与你的浏览器版本相匹配的驱动程序，并确保它在系统的 PATH 环境变量中，或者在代码中指定其路径。
  2. 编写测试脚本：- 创建一个 Python 脚本文件，例如 my_selenium_script.py。- 在脚本中，你可以使用 Selenium 的 API 来编写自动化测试代码。例如，启动浏览器、导航到网页、查找元素等。
  3. 运行测试脚本：- 在命令行中，使用 Python 来运行你的测试脚本：python my_selenium_script.py
  4. 使用 Selenium Server：- 如果你需要使用 Remote WebDriver，那么你需要安装 Selenium Server，这是一个 Java 程序。- 从 Selenium 官网下载 Selenium Server 的 JAR 文件，并使用 Java 运行它：java -jar selenium-server-standalone-2.x.x.jar
  5. 解决安装问题：- 如果在安装过程中遇到超时问题，可以尝试使用国内镜像源来加速下载，例如使用豆瓣的源：pip install -U selenium -i https://pypi.douban.com/simple。```
  6. 测试 Selenium 是否安装成功：- 编写一个简单的测试脚本来检查 Selenium 是否能够正常控制浏览器。例如，使用 Edge 浏览器打开一个网页并检查是否成功弹出。

确保你已经根据你的操作系统和 Python 版本下载了正确版本的 Selenium 和浏览器驱动程序。通过上述步骤，你应该能够成功安装并开始使用 Selenium 进行自动化测试。

一、元素操作方法

在 Selenium 中，元素操作方法是进行自动化测试和网页交互的基础。以下是一些常用的元素操作方法：

  1. 定位元素：- 使用 find_element_by_id, find_element_by_name, find_element_by_xpath, find_element_by_css_selector 等方法来定位页面上的元素。
  2. 点击元素：- 使用 click() 方法来模拟鼠标点击操作。
  3. 输入文本：- 使用 send_keys() 或 clear() 后跟 send_keys() 来在输入框中输入文本。
  4. 获取元素属性：- 使用 get_attribute('attribute_name') 方法来获取元素的特定属性值。
  5. 获取元素文本：- 直接使用 text 属性来获取元素的文本内容。
  6. 提交表单：- 对于表单提交按钮，使用 click() 方法可以提交表单。
  7. 检查元素是否可见：- 使用 is_displayed() 方法来检查元素是否在页面上可见。
  8. 检查元素是否被选中：- 使用 is_selected() 方法来检查复选框或单选按钮是否被选中。
  9. 切换元素（如 iframe）：- 使用 switch_to.frame() 方法来切换到 iframe 中进行操作。
  10. 等待元素加载：- 使用 WebDriverWait 和 expected_conditions 来等待元素加载完成，例如 visibility_of_element_located。
  11. 获取元素的尺寸和位置：- 使用 size 和 location 属性来获取元素的尺寸和在页面上的位置。
  12. 滚动到元素：- 使用 execute_script("arguments[0].scrollIntoView();", element) 来滚动到页面上的特定元素。
  13. 执行 JavaScript：- 使用 execute_script() 方法来执行 JavaScript 代码，可以对元素进行更复杂的操作。
  14. 拖放操作：- 使用 ActionChains 类来执行拖放操作。
  15. 获取元素的标签名：- 使用 tag_name 属性来获取元素的标签名。

当然，以下是一些 Selenium 元素操作方法的 Python 代码示例：

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

# 初始化 WebDriver，以 Chrome 浏览器为例
driver = webdriver.Chrome()# 打开网页
driver.get("http://www.example.com")# 定位元素# 假设我们要定位一个id为"myInput"的输入框
input_element = driver.find_element(By.ID,"myInput")# 输入文本
input_element.send_keys("Hello, Selenium!")# 定位一个按钮并点击
submit_button = driver.find_element(By.XPATH,"//button[@type='submit']")
submit_button.click()# 获取元素属性
href_value = driver.find_element(By.CSS_SELECTOR,"a").get_attribute("href")# 获取元素文本
text_element = driver.find_element(By.ID,"textElement")
element_text = text_element.text

# 检查元素是否可见
is_visible = text_element.is_displayed()# 检查复选框是否被选中
checkbox = driver.find_element(By.ID,"myCheckbox")
is_selected = checkbox.is_selected()# 切换到 iframe
iframe = driver.find_element(By.ID,"myIframe")
driver.switch_to.frame(iframe)# 等待元素加载
wait = WebDriverWait(driver,10)try:
    element = wait.until(EC.visibility_of_element_located((By.ID,"myElement")))finally:
    element.click()# 滚动到元素
element = driver.find_element(By.ID,"bottomElement")
driver.execute_script("arguments[0].scrollIntoView();", element)# 执行 JavaScript
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")# 拖放操作from selenium.webdriver import ActionChains
source = driver.find_element(By.ID,"sourceElement")
target = driver.find_element(By.ID,"targetElement")
action = ActionChains(driver)
action.drag_and_drop(source, target).perform()# 获取元素的尺寸和位置
size = element.size
location = element.location

# 获取元素的标签名
tag_name = element.tag_name

# 关闭浏览器
driver.quit()

请注意，这些代码示例需要根据你实际要操作的网页元素进行相应的调整。例如，你需要替换 

"http://www.example.com"

为你想要访问的网址，以及使用正确的元素定位方法和属性。此外，确保你已经安装了 Selenium 库和相应的 WebDriver。

二、浏览器操作方法

在 Selenium 中，除了对元素进行操作外，还有一些浏览器操作方法，可以控制浏览器的行为。以下是一些常见的浏览器操作方法及其 Python 代码示例：

  1. 打开和关闭浏览器： - 使用 get() 方法打开一个特定的 URL。- 使用 close() 方法关闭当前浏览器窗口。- 使用 quit() 方法关闭浏览器会话并结束 WebDriver。
# 打开浏览器并访问网页
driver.get("http://www.example.com")# 关闭当前浏览器窗口
driver.close()# 关闭浏览器会话
driver.quit()
  1. 最大化浏览器窗口： - 使用 maximize_window() 方法来最大化浏览器窗口。
driver.maximize_window()
  1. 设置浏览器窗口大小： - 使用 set_window_size(width, height) 方法来设置浏览器窗口的大小。
driver.set_window_size(800,600)
  1. 前进和后退： - 使用 forward() 方法来前进到历史记录中的下一个页面。- 使用 back() 方法来后退到历史记录中的上一个页面。
# 前进
driver.forward()# 后退
driver.back()
  1. 刷新页面： - 使用 refresh() 方法来刷新当前页面。
driver.refresh()
  1. 获取当前 URL： - 使用 current_url 属性来获取当前页面的 URL。
current_url = driver.current_url
print("Current URL:", current_url)
  1. 获取页面标题： - 使用 title 属性来获取当前页面的标题。
page_title = driver.title
print("Page Title:", page_title)
  1. 获取页面源代码： - 使用 page_source 属性来获取当前页面的 HTML 源代码。
page_source = driver.page_source
print("Page Source:", page_source)
  1. 执行 JavaScript： - 使用 execute_script() 方法来执行 JavaScript 代码。
result = driver.execute_script("return document.title;")print("JavaScript Execution Result:", result)
  1. 切换浏览器窗口或标签页： - 使用 switch_to.window(window_name) 方法来切换到不同的浏览器窗口或标签页。
# 切换到新的窗口或标签页
driver.switch_to.window("new_window_name")
  1. 切换到 iframe： - 使用 switch_to.frame() 方法来切换到 iframe。
# 切换到 iframe
driver.switch_to.frame("iframe_id")
  1. 切换到默认内容： - 使用 switch_to.default_content() 方法来从 iframe 切换回主文档。
driver.switch_to.default_content()
  1. 获取所有窗口或标签页的句柄： - 使用 window_handles 属性来获取当前浏览器会话中所有窗口或标签页的句柄列表。
window_handles = driver.window_handles
print("Window Handles:", window_handles)
  1. 获取当前窗口或标签页的句柄： - 使用 current_window_handle 属性来获取当前活动窗口或标签页的句柄。
current_window_handle = driver.current_window_handle
print("Current Window Handle:", current_window_handle)

这些浏览器操作方法可以帮助你控制浏览器的行为，以适应不同的测试场景。记得在编写测试脚本时，根据实际需求选择合适的方法。

三、获取元素信息操作

在 Selenium 中，获取元素信息是进行自动化测试和数据提取的重要部分。以下是一些常用的获取元素信息的方法及其 Python 代码示例：

  1. 获取元素的文本内容： - 使用 text 属性获取元素内的文本。
element_text = driver.find_element(By.ID,"elementId").text
  1. 获取元素的属性值： - 使用 get_attribute('attribute_name') 方法获取元素的特定属性值。
element_attribute = driver.find_element(By.ID,"elementId").get_attribute("data-attribute")
  1. 判断元素是否可见： - 使用 is_displayed() 方法判断元素是否在页面上可见。
is_element_visible = driver.find_element(By.ID,"elementId").is_displayed()
  1. 判断元素是否被选中： - 对于复选框或单选按钮，使用 is_selected() 方法判断元素是否被选中。
is_element_selected = driver.find_element(By.ID,"checkboxId").is_selected()
  1. 获取元素的标签名： - 使用 tag_name 属性获取元素的 HTML 标签名。
element_tag = driver.find_element(By.ID,"elementId").tag_name
  1. 获取元素的尺寸和位置： - 使用 size 和 location 属性获取元素的大小和在页面上的位置。
element_size = driver.find_element(By.ID,"elementId").size
element_location = driver.find_element(By.ID,"elementId").location
  1. 获取元素的 CSS 值： - 使用 value_of_css_property('css_property_name') 方法获取元素的 CSS 属性值。
element_css_value = driver.find_element(By.ID,"elementId").value_of_css_property("background-color")
  1. 获取元素内的所有文本： - 对于包含多个子元素的容器，可以使用 text 属性获取所有文本。
container_text = driver.find_element(By.ID,"containerId").text
  1. 获取元素的子元素： - 使用 find_elements(By.CHILD_SELECTOR) 方法获取元素的所有子元素。
child_elements = driver.find_element(By.ID,"parentId").find_elements(By.TAG_NAME,"li")
  1. 获取元素的父元素： - 使用 find_element(By.XPATH, '..') 方法获取元素的直接父元素。
parent_element = driver.find_element(By.ID,"childId").find_element(By.XPATH,"..")
  1. 获取元素的兄弟元素： - 使用 XPath 或其他定位方法获取元素的前一个或后一个兄弟元素。
previous_sibling = driver.find_element(By.ID,"elementId").find_element(By.XPATH,"preceding-sibling::*")
next_sibling = driver.find_element(By.ID,"elementId").find_element(By.XPATH,"following-sibling::*")
  1. 获取页面源代码中的元素： - 使用 page_source 属性获取当前页面的 HTML 源代码，然后解析出特定元素的信息。
page_source = driver.page_source
# 假设使用 BeautifulSoup 或其他库解析 HTML 并提取元素信息

这些方法可以帮助你获取页面元素的各种信息，从而进行进一步的处理或断言。在实际使用中，你可能需要根据元素的具体情况和测试需求来选择合适的方法。

四、鼠标操作 （需要实例化鼠标对象）

在 Selenium 中执行鼠标相关的操作，可以通过 

ActionChains

类来实现。这个类允许你创建一系列鼠标事件，比如移动到元素、点击、长按、双击、右键点击等。以下是一些使用 

ActionChains

进行鼠标操作的 Python 代码示例：

  1. 实例化 ActionChains 对象： - 首先，你需要从 selenium.webdriver 模块中导入 ActionChains 并实例化。
from selenium import webdriver
from selenium.webdriver import ActionChains

driver = webdriver.Chrome()
driver.get("http://www.example.com")
action = ActionChains(driver)
  1. 移动到元素： - 使用 move_to_element(element) 方法将鼠标指针移动到指定的元素上。
element = driver.find_element(By.ID,"elementId")
action.move_to_element(element)
  1. 点击元素： - 使用 click(element) 方法模拟鼠标点击操作。
action.click(element)
  1. 长按元素： - 使用 context_click(element) 进行鼠标右键点击，或者 double_click(element) 进行双击操作。
action.context_click(element)# 右键点击
action.double_click(element)# 双击
  1. 拖放操作： - 使用 drag_and_drop(source, target) 将一个元素拖放到另一个元素上。
source_element = driver.find_element(By.ID,"sourceElementId")
target_element = driver.find_element(By.ID,"targetElementId")
action.drag_and_drop(source_element, target_element)
  1. 鼠标悬停： - 使用 move_by_offset(xoffset, yoffset) 将鼠标指针移动到相对于当前位置的偏移位置。
action.move_by_offset(200,100)# 向右移动200像素，向下移动100像素
  1. 滚动鼠标滚轮： - 使用 scroll_by_amount(value) 滚动鼠标滚轮，value 可以是正数或负数。
action.scroll_by_amount(100)# 向下滚动100像素
  1. 释放鼠标按钮： - 使用 release() 方法释放鼠标按钮。
action.click_and_hold(element)# 长按
action.move_to_element(other_element)# 移动到另一个元素
action.release()# 释放鼠标按钮
  1. 执行动作序列： - 使用 perform() 方法执行所有创建的动作序列。
action.perform()
  1. 鼠标退出： - 有时在执行完鼠标操作后，需要将鼠标移动到浏览器窗口外，可以使用 ActionChains.context_click() 后跟 perform() 实现。
# 移动到页面的一个角落
bottom_right = driver.execute_script("return document.body.getBoundingClientRect()")
action.move_by_offset(bottom_right['right']-100, bottom_right['bottom']-100)
action.context_click()
action.perform()

请注意，

ActionChains

的每个方法调用后，都不会立即执行，而是存储为一个待执行的动作。只有调用 

perform()

方法后，这些动作才会按照创建的顺序被执行。这允许你创建复杂的鼠标操作序列，然后一次性执行它们。

五、键盘操作（不需要实例化对象）

在 Selenium 中进行键盘操作，通常不需要单独实例化对象，而是直接在 WebDriver 的实例上调用相关方法。以下是一些键盘操作的 Python 代码示例：

  1. 发送按键操作： - 使用 send_keys() 方法向网页元素发送按键输入。
element = driver.find_element(By.ID,"inputField")
element.send_keys("Hello, World!")
  1. 模拟按键组合： - 可以通过 send_keys() 方法发送组合键，例如 Ctrl+A、Ctrl+C、Ctrl+V。
# 定位到一个文本输入区域
text_area = driver.find_element(By.ID,"textAreaId")# 发送 Ctrl+A 选择所有文本
text_area.send_keys(Keys.CONTROL,'a')# 发送 Ctrl+C 复制文本
text_area.send_keys(Keys.CONTROL,'c')# 切换到另一个输入区域并粘贴 Ctrl+V
another_input = driver.find_element(By.ID,"anotherInputId")
another_input.send_keys(Keys.CONTROL,'v')
  1. 特殊按键： - 可以使用 Keys 类中的常量来模拟特殊按键，如箭头键、Enter 键、Esc 键等。
# 定位到一个输入框并按 Enter 键
input_box = driver.find_element(By.ID,"inputBoxId")
input_box.send_keys(Keys.ENTER)# 按 Esc 键
input_box.send_keys(Keys.ESCAPE)
  1. 清除输入框内容： - 在发送新内容之前，可以使用 clear() 方法清空输入框。
input_box = driver.find_element(By.ID,"inputBoxId")
input_box.clear()
input_box.send_keys("New content")
  1. 使用快捷键： - 可以组合使用 Keys 中的常量来模拟快捷键操作。
# 模拟 Alt+F4 关闭当前窗口
driver.execute_script("window.close();")
  1. 模拟连续按键： - 可以通过连续调用 send_keys() 方法发送多个按键。
# 模拟连续按键操作
input_box.send_keys("Hello")
input_box.send_keys(Keys.ARROW_LEFT, Keys.ARROW_LEFT)# 向左移动光标两次
input_box.send_keys(", World!")
  1. 模拟按键延迟： - 有时可能需要在按键之间添加延迟，可以使用 time.sleep(seconds) 来实现。
import time

input_box.send_keys("Hello")
time.sleep(2)# 等待2秒
input_box.send_keys(Keys.ARROW_LEFT)
  1. 模拟按键释放： - 在某些情况下，可能需要模拟按键的释放，这可以通过发送空格然后再次发送按键来实现。
# 模拟按键按下并释放
input_box.send_keys(Keys.SHIFT)
input_box.send_keys("a")# 模拟按下 Shift 并输入小写 a
input_box.send_keys(" ")# 释放 Shift 键

请注意，

Keys

类提供了许多用于模拟键盘操作的常量，例如 

Keys.CONTROL

, 

Keys.ALT

, 

Keys.SHIFT

等，以及数字和字母的常量表示。在使用键盘操作时，确保元素是可接受键盘输入的，并且已经正确定位。

六、元素等待

在 Selenium 中，元素等待是一个重要的概念，用于确保元素在进行操作前已经加载完成并且可以交互。Selenium 提供了几种等待机制：

  1. 隐式等待（推荐使用显式等待）： - 告诉 WebDriver 等待一段时间来加载页面上的元素。如果元素在指定时间内没有加载完成，将抛出 NoSuchElementException。
driver.implicitly_wait(10)# 等待10秒
element = driver.find_element(By.ID,"myElement")
  1. 显式等待： - 使用 WebDriverWait 和 expected_conditions 来创建一个等待条件，直到条件满足或超时。
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 设置显式等待，最长等待时间10秒
wait = WebDriverWait(driver,10)# 等待一个元素可被点击
element = wait.until(EC.element_to_be_clickable((By.ID,"myButton")))# 执行点击操作
element.click()
  1. 等待元素可见： - 等待元素在页面上可见（可能被其他元素遮挡）。
# 等待元素可见
element = wait.until(EC.visibility_of_element_located((By.ID,"myElement")))
  1. 等待元素不可见： - 等待元素在页面上不可见。
# 等待元素不可见
wait.until(EC.invisibility_of_element_located((By.ID,"myElement")))
  1. 等待元素存在： - 等待元素存在于DOM中。
# 等待元素存在
wait.until(EC.presence_of_element_located((By.ID,"myElement")))
  1. 等待元素被选中： - 等待元素被选中，如复选框或单选按钮。
# 等待复选框被选中
checkbox = wait.until(EC.element_to_be_selected((By.ID,"myCheckbox")))
  1. 等待元素未被选中： - 等待元素未被选中。
# 等待复选框未被选中
checkbox = wait.until(EC.element_located_to_be_unselected((By.ID,"myCheckbox")))
  1. 等待元素数量： - 等待页面上存在特定数量的元素。
# 等待页面上至少有5个元素
elements = wait.until(EC.number_of_elements_to_be(By.ID,"myElement"),5)
  1. 自定义等待条件： - 创建自定义的等待条件，例如等待某个JavaScript表达式的结果为真。
# 等待某个JavaScript表达式的结果为真
wait.until(lambda driver: driver.execute_script("return window.readyState")=="complete")

显式等待比隐式等待更灵活，因为它允许你为不同的操作设置不同的等待条件和超时时间。显式等待也有助于编写更清晰和更易于理解的测试代码。使用显式等待时，你需要从 

selenium.webdriver.support

模块导入 

WebDriverWait

和 

expected_conditions

。

七、下拉框（需要实例化下拉框）

在 Selenium 中操作下拉框，可以使用 

Select

类，它提供了一些方法来选择下拉框中的选项。以下是一些操作下拉框的 Python 代码示例：

  1. 实例化 Select 对象： - 使用 Select 类来包装下拉框元素。
from selenium.webdriver.support.ui import Select

# 定位到下拉框元素
select_element = driver.find_element(By.ID,"selectElementId")# 实例化 Select 对象
select = Select(select_element)
  1. 选择下拉框中的选项： - 使用 select_by_visible_text(text) 方法根据可见的文本选择选项。
# 根据文本选择下拉框中的选项
select.select_by_visible_text("Option 1")
  1. 通过索引选择下拉框中的选项： - 使用 select_by_index(index) 方法根据选项的索引选择。
# 根据索引选择下拉框中的选项
select.select_by_index(1)
  1. 通过值选择下拉框中的选项： - 使用 select_by_value(value) 方法根据选项的值选择。
# 根据值选择下拉框中的选项
select.select_by_value("option1")
  1. 获取下拉框中的所有选项： - 使用 all_selected_options 属性获取所有被选中的选项。
# 获取所有被选中的选项
selected_options = select.all_selected_options
for option in selected_options:print(option.text)
  1. 获取下拉框中的单个选项： - 使用 first_selected_option 属性获取第一个被选中的选项。
# 获取第一个被选中的选项
first_option = select.first_selected_option
print(first_option.text)
  1. 取消选择下拉框中的选项： - 使用 deselect_all() 方法取消选择下拉框中的所有选项。
# 取消选择下拉框中的所有选项
select.deselect_all()
  1. 取消选择特定的下拉框选项： - 使用 deselect_by_visible_text(text) 方法取消选择特定的选项。
# 根据文本取消选择下拉框中的选项
select.deselect_by_visible_text("Option 1")
  1. 检查下拉框选项是否被选中： - 使用 is_multiple 属性判断下拉框是否允许多选。
# 判断下拉框是否允许多选if select.is_multiple:print("This is a multiple select box.")
  1. 获取下拉框中的选项数量： - 使用 options 属性获取下拉框中的所有选项，然后使用 len() 函数计算数量。
# 获取下拉框中的选项数量
option_count =len(select.options)print("Number of options:", option_count)

请注意，在使用 

Select

类之前，必须确保已经定位到下拉框元素，并且该元素是一个 

<select>

标签。此外，根据下拉框的特性（如是否允许多选），你可能需要使用不同的方法来选择或取消选择选项。

八、弹出框

在 Selenium 中处理弹出框（如 alert、confirm 或 prompt）需要使用 WebDriver 的 

switch_to

方法来切换到相应的弹出框。以下是处理不同类型弹出框的 Python 代码示例：

  1. 切换到 Alert 弹出框： - 使用 switch_to.alert 切换到 alert 弹出框。
# 假设页面上有一个按钮点击后会触发 alert
alert_button = driver.find_element(By.ID,"alertButtonId")
alert_button.click()# 切换到 alert 弹出框
alert = driver.switch_to.alert()# 获取 alert 文本print(alert.text)# 接受 alert
alert.accept()# 取消 alert# alert.dismiss()
  1. 切换到 Confirm 弹出框： - Confirm 弹出框在 Selenium 中被视为 Alert 类型，处理方式与 Alert 类似。
# 假设页面上有一个按钮点击后会触发 confirm
confirm_button = driver.find_element(By.ID,"confirmButtonId")
confirm_button.click()# 切换到 confirm 弹出框
confirm = driver.switch_to.alert()# 接受 confirm
confirm.accept()# 取消 confirm# confirm.dismiss()
  1. 处理 Prompt 弹出框： - Prompt 弹出框同样可以通过 Alert 接口进行处理。
# 假设页面上有一个按钮点击后会触发 prompt
prompt_button = driver.find_element(By.ID,"promptButtonId")
prompt_button.click()# 切换到 prompt 弹出框
prompt = driver.switch_to.alert()# 输入文本到 prompt
prompt.send_keys("Hello, Prompt!")# 接受 prompt
prompt.accept()# 取消 prompt# prompt.dismiss()
  1. 等待弹出框出现： - 有时弹出框可能需要一些时间出现，可以使用 WebDriverWait 和 expected_conditions 来等待。
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 等待 alert 出现
wait = WebDriverWait(driver,10)
alert = wait.until(EC.alert_is_present())
  1. 处理多个弹出框： - 如果页面上连续出现多个弹出框，可以使用循环来依次处理。
# 假设页面上连续触发了多个 alertfor _ inrange(number_of_alerts):
    alert = driver.switch_to.alert()
    alert.accept()# 或者使用 alert.dismiss() 或其他操作
  1. 切换回主文档： - 处理完弹出框后，通常需要切换回主文档继续操作。
# 切换回主文档
driver.switch_to.default_content()

请注意，弹出框的处理可能受到页面加载和脚本执行的影响，因此在实际操作中可能需要适当等待。另外，确保在处理弹出框之前已经正确触发了弹出框，否则 

switch_to.alert

将抛出 

NoAlertPresentException

异常。

九、滚动条

在 Selenium 中，滚动条操作通常涉及到滚动页面或者滚动到页面中的特定元素。以下是一些处理滚动条的 Python 代码示例：

  1. 滚动到页面的特定元素： - 使用 JavaScript 执行器来滚动到页面中的特定元素。
element = driver.find_element(By.ID,"elementId")
driver.execute_script("arguments[0].scrollIntoView();", element)
  1. 滚动到页面的顶部或底部： - 使用 JavaScript 来滚动到页面的顶部或底部。
# 滚动到页面顶部
driver.execute_script("window.scrollTo(0, 0);")# 滚动到页面底部
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
  1. 滚动页面到元素的可视区域： - 有时你可能只想让元素出现在视口中，而不是滚动到页面的顶部或底部。
# 滚动页面，使元素出现在视口中
driver.execute_script("window.scrollBy(0, arguments[0].getBoundingClientRect().top)", element)
  1. 平滑滚动到元素： - 使用 arguments[0].scrollIntoView({behavior: 'smooth'}) 可以实现平滑滚动效果。
driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth'})", element)
  1. 滚动页面指定的像素数： - 通过 window.scrollBy() 方法，你可以指定滚动的像素数。
# 向下滚动 100 像素
driver.execute_script("window.scrollBy(0, 100);")
  1. 滚动到页面的指定位置： - 通过 window.scrollTo() 方法，可以滚动到页面的指定位置。
# 滚动到页面的 x=100, y=200 位置
driver.execute_script("window.scrollTo(100, 200);")
  1. 获取页面滚动的当前位置： - 使用 JavaScript 获取页面的水平和垂直滚动位置。
# 获取当前滚动位置
scroll_position = driver.execute_script("return {x: window.pageXOffset, y: window.pageYOffset};")print("Current scroll position:", scroll_position)
  1. 滚动元素到页面的中心： - 可以通过计算元素的位置和视口大小来滚动元素到页面中心。
element_location = element.location
viewport_size = driver.execute_script("return {width: window.innerWidth, height: window.innerHeight};")
scroll_to_x =(element_location['x']+(element.size['width']/2))-(viewport_size['width']/2)
scroll_to_y =(element_location['y']+(element.size['height']/2))-(viewport_size['height']/2)
driver.execute_script(f"window.scrollTo({scroll_to_x}, {scroll_to_y});")

请注意，滚动操作可能需要一些时间来完成，尤其是在处理大量数据或长页面时。在自动化脚本中，可能需要适当等待以确保滚动操作已经完成。此外，不同的浏览器和不同的设备上滚动行为可能略有不同，因此在某些情况下可能需要调整滚动策略。

十、切换frame表单 ☆

在 Selenium 中，frame 表单（通常指的是 

<iframe>

元素）的处理需要使用 

switch_to.frame()

方法来切换 WebDriver 的上下文。以下是一些处理 frame 表单的 Python 代码示例：

  1. 切换到 <iframe> 元素： - 使用 switch_to.frame() 方法切换到 <iframe> 元素中。
# 定位到iframe元素
iframe_element = driver.find_element(By.ID,"iframeId")# 切换到iframe
driver.switch_to.frame(iframe_element)
  1. 通过 <iframe> 的索引切换： - 如果页面中有多个 <iframe>，可以通过索引来切换。
# 获取所有iframe元素
iframes = driver.find_elements(By.TAG_NAME,"iframe")# 切换到第一个iframe
driver.switch_to.frame(0)# 索引从0开始
  1. 通过 <iframe> 的名称或ID切换： - 也可以通过 <iframe> 的名称或ID来切换。
# 切换到iframe，通过名称或ID
driver.switch_to.frame("iframeNameOrId")
  1. 切换回默认内容： - 在处理完 <iframe> 后，可以使用 switch_to.default_content() 切换回主文档。
# 切换回主文档
driver.switch_to.default_content()
  1. **切换到嵌套 <iframe>**： - 如果 <iframe> 内部还有嵌套的 <iframe>，可以连续调用 switch_to.frame() 方法。
# 定位到嵌套的iframe元素
nested_iframe = driver.find_element(By.ID,"nestedIframeId")# 先切换到外部iframe
driver.switch_to.frame(iframe_element)# 再切换到嵌套的iframe
driver.switch_to.frame(nested_iframe)
  1. **使用相对定位切换 <iframe>**： - 可以使用 switch_to.parent_frame() 切换回当前 <iframe> 的父级 <iframe> 或主文档。
# 切换到父级iframe或主文档
driver.switch_to.parent_frame()
  1. 定位 <iframe> 中的元素： - 在成功切换到 <iframe> 上下文后，就可以像在主文档中一样定位和操作元素。
# 在iframe中定位元素
element_in_iframe = driver.find_element(By.ID,"elementIdInsideIframe")# 操作元素
element_in_iframe.click()

请注意，切换到 

<iframe>

后，所有的操作都将在这个 

<iframe>

的上下文中执行，直到你切换回主文档或另一个 

<iframe>

。此外，如果 

<iframe>

是通过 JavaScript 动态加载的，可能需要使用等待机制来确保 

<iframe>

已经加载完成。

10.1 连续切换frame

连续切换 

iframe

（即嵌套的 

iframe

）在 Selenium 中可以通过连续调用 

switch_to.frame()

方法实现。以下是处理嵌套 

iframe

的步骤和示例代码：

  1. **定位并切换到最外层的 iframe**： - 首先，你需要定位到最外层 iframe 并切换到它的上下文。
# 假设outer_iframe_id是外层iframe的ID
outer_iframe = driver.find_element(By.ID,"outer_iframe_id")
driver.switch_to.frame(outer_iframe)
  1. **定位并切换到内层的 iframe**： - 在外层 iframe 的上下文中，定位并切换到内层 iframe。
# 假设inner_iframe_id是内层iframe的ID
inner_iframe = driver.find_element(By.ID,"inner_iframe_id")
driver.switch_to.frame(inner_iframe)
  1. 继续切换到更深层的 iframe（如果有）： - 如果内层 iframe 里还有更深层的 iframe，重复上面的步骤。
# 假设deeper_iframe_id是更深层iframe的ID
deeper_iframe = driver.find_element(By.ID,"deeper_iframe_id")
driver.switch_to.frame(deeper_iframe)
  1. 执行所需的操作： - 在最里层的 iframe 上下文中，执行所需的定位和操作元素。
# 定位并操作最深层iframe中的元素
element_in_deepest_iframe = driver.find_element(By.ID,"element_id")
element_in_deepest_iframe.click()# 假设执行点击操作
  1. 切换回上一层 iframe 或主文档： - 完成操作后，如果需要回到上一层 iframe，可以使用 switch_to.default_content() 切换回主文档，或者使用 switch_to.parent_frame() 切换回上一层 iframe。
# 切换回上一层iframe
driver.switch_to.parent_frame()# 或者切换回主文档# driver.switch_to.default_content()
  1. 连续切换 iframe 示例：
# 假设我们要在三层嵌套的iframe中操作一个元素# 定位并切换到第一层iframe
driver.switch_to.frame(driver.find_element(By.ID,"first_layer_iframe"))# 在第一层iframe中定位并切换到第二层iframe
driver.switch_to.frame(driver.find_element(By.ID,"second_layer_iframe"))# 在第二层iframe中定位并切换到第三层iframe
driver.switch_to.frame(driver.find_element(By.ID,"third_layer_iframe"))# 在第三层iframe中定位元素并执行操作
element = driver.find_element(By.ID,"target_element")
element.send_keys("Hello, World!")# 切换回主文档
driver.switch_to.default_content()

请注意，每次调用 

switch_to.frame()

后，WebDriver 的上下文将切换到指定的 

iframe

，之后的元素定位和操作都将在这个 

iframe

的上下文中进行。使用 

switch_to.parent_frame()

或 

switch_to.default_content()

可以逐层切换回上层 

iframe

或主文档。在处理动态加载的 

iframe

时，可能需要使用等待机制确保 

iframe

加载完成。

十一、多窗口的切换 ☆

在Selenium中处理多个浏览器窗口（或标签页）时，需要能够在它们之间进行切换。以下是一些处理多窗口和进行切换的Python代码示例：

  1. 打开新窗口： - 有时点击一个链接或按钮会打开一个新的浏览器窗口或标签页。
# 点击一个按钮或链接，这将打开一个新窗口
new_window_button = driver.find_element(By.ID,"newWindowButton")
new_window_button.click()
  1. 获取所有窗口句柄： - 窗口句柄是每个窗口的唯一标识符。
# 获取所有窗口句柄的列表
window_handles = driver.window_handles
  1. 切换到其他窗口： - 使用 switch_to.window() 方法和窗口句柄来切换到特定的窗口。
# 切换到第一个窗口（通常主窗口）
driver.switch_to.window(window_handles[0])# 切换到新打开的窗口
driver.switch_to.window(window_handles[1])
  1. 使用窗口标题切换： - 如果你知道窗口的标题，也可以通过窗口标题来切换。
# 假设你已经获取了窗口的标题
window_titles =[driver.switch_to.window(handle).title for handle in window_handles]
target_title ="Target Window Title"# 切换到具有特定标题的窗口for title in window_titles:if target_title in title:
        driver.switch_to.window(window_handles[window_titles.index(title)])break
  1. 最大化窗口： - 使用 maximize_window() 方法可以最大化当前窗口。
driver.maximize_window()
  1. 设置窗口大小： - 使用 set_window_size() 方法可以设置当前窗口的大小。
driver.set_window_size(800,600)
  1. 关闭当前窗口： - 使用 close() 方法可以关闭当前窗口。
# 关闭当前窗口
driver.close()# 注意：关闭窗口后，需要切换回其他窗口
driver.switch_to.window(window_handles[0])# 假设0是主窗口的句柄
  1. 关闭新打开的窗口并返回： - 如果你打开了新窗口并完成了操作，可能需要关闭它并返回到原来的窗口。
# 关闭新打开的窗口
driver.close()# 由于关闭了当前窗口，Selenium会自动切换到其他打开的窗口# 如果有多个窗口，可能需要明确切换回主窗口或其他特定窗口
  1. 使用 window() 方法切换回主窗口： - 通常在打开新窗口后，完成操作关闭新窗口，Selenium 会自动切换回上一个窗口。
# 假设在新窗口完成操作并关闭后，自动回到了主窗口# 可以继续在主窗口执行操作

重点关注

# 获取当前窗口的句柄
    current_window = self.driver.current_window_handle
    # 获取所有窗口的句柄
    all_windows = self.driver.window_handles
    # 遍历所有窗口句柄for window_handle in all_windows:if window_handle != current_window:# 切换到新的窗口
            self.driver.switch_to.window(window_handle)break

请注意，在处理多窗口时，确保在关闭任何窗口后切换回其他窗口，因为关闭当前窗口后，Selenium 会失去对当前窗口的控制。另外，如果新窗口是通过JavaScript打开的，可能需要等待窗口完全打开后再进行切换。

十二、截图操作

在 Selenium 中进行截图操作是一个相对直接的过程，可以通过 

screenshot()

方法来实现。以下是一些基本的截图操作和示例代码：

  1. 获取当前页面的截图： - 使用 get_screenshot_as_file(filename) 方法可以将当前页面的截图保存到文件。
# 保存整个页面的截图到指定文件
driver.get_screenshot_as_file("full_page_screenshot.png")
  1. 获取当前窗口的截图： - 如果只需要当前窗口的截图，可以使用 get_screenshot_as_png() 方法，然后使用 PIL 库或其他图像处理库来保存。
from PIL import Image
import io

# 获取当前窗口的截图作为二进制数据
screenshot_data = driver.get_screenshot_as_png()# 使用PIL库保存为PNG文件
image = Image.open(io.BytesIO(screenshot_data))
image.save("window_screenshot.png")
  1. 截图特定元素： - 可以通过定位元素并获取其在页面上的位置，然后截取该区域的图像。
from selenium import webdriver
from PIL import Image
import io

# 定位元素
element = driver.find_element(By.ID,"elementId")# 获取元素在页面上的位置和尺寸
left = element.location['x']
top = element.location['y']
width = element.size['width']
height = element.size['height']# 滚动到元素
driver.execute_script("window.scrollTo({},{});".format(left, top))# 截取整个页面的截图
screenshot_data = driver.get_screenshot_as_png()# 使用PIL库来裁剪特定元素的截图
image = Image.open(io.BytesIO(screenshot_data))
box =(left, top, left + width, top + height)
element_screenshot = image.crop(box)
element_screenshot.save("element_screenshot.png")
  1. 截图并保存到字节流： - 如果需要在内存中处理截图，可以使用 get_screenshot_as_file() 方法将截图保存到字节流。
# 获取整个页面的截图并保存到字节流with io.BytesIO()as output:
    driver.get_screenshot_as_file(output)# 可以进一步处理output中的截图数据
  1. 使用高级截图库： - 对于更高级的截图需求，可以使用像 webkit2png 或 pyvirtualdisplay 这样的库。

请注意，截图操作可能会受到浏览器窗口大小和滚动位置的影响。如果需要截取整个页面的长截图，可能需要滚动页面并截取多个部分，然后使用图像处理库将它们拼接在一起。此外，确保在执行截图操作之前，页面已经加载完成，并且所有元素都已渲染。

十三、验证码

处理验证码是自动化测试中的一个挑战，因为验证码的目的是防止自动化脚本的运行。不过，有时在测试自己开发的应用程序时，可能需要绕过验证码或者对其进行测试。以下是一些处理验证码的策略：

  1. 设计避免验证码的测试：- 最好的方法是设计测试用例，使其不会触发验证码的显示。
  2. 手动输入验证码：- 在自动化测试中，如果无法避免验证码，可能需要手动输入验证码来完成测试。
  3. 使用第三方服务：- 有些第三方服务提供了验证码识别的功能，可以作为自动化测试的一部分。这些服务通常使用机器学习算法来识别图像中的文本。
  4. 验证码的自动化识别：- 对于研究或教育目的，可以使用开源的OCR（光学字符识别）库，如Tesseract，来尝试自动识别验证码。
  5. 调整测试环境：- 如果你在测试自己开发的应用程序，可以调整测试环境的配置，以避免在测试过程中显示验证码。
  6. 截图并使用机器学习模型：- 可以对验证码进行截图，然后使用预先训练好的机器学习模型来识别图像中的文本。

以下是使用 Python 和 Tesseract OCR 进行验证码识别的基本示例：

import pytesseract
from PIL import Image
import io

# 假设driver是已经初始化的Selenium WebDriver实例# 定位到验证码元素
captcha_element = driver.find_element(By.ID,"captchaImage")
captcha_location = captcha_element.location
captcha_size = captcha_element.size

# 滚动到验证码元素
driver.execute_script("window.scrollTo({},{});".format(captcha_location['x'], captcha_location['y']))# 获取整个页面的截图
screenshot_data = driver.get_screenshot_as_png()# 使用PIL库来裁剪验证码区域的截图
image = Image.open(io.BytesIO(screenshot_data))
captcha_box =(captcha_location['x'], captcha_location['y'], captcha_location['x']+ captcha_size['width'], captcha_location['y']+ captcha_size['height'])
captcha_image = image.crop(captcha_box)# 使用pytesseract进行OCR识别
pytesseract.pytesseract.tesseract_cmd =r'C:\Program Files\Tesseract-OCR\tesseract.exe'# 根据安装路径设置Tesseract路径
ocr_result = pytesseract.image_to_string(captcha_image, lang='eng')print("Recognized captcha:", ocr_result)

请注意，验证码识别的准确性高度依赖于验证码的复杂性、图像质量、OCR引擎的性能和使用的语言模型。此外，使用自动化方式绕过验证码可能违反某些服务的使用条款。

十四、打包

在 Selenium 自动化测试中，"打包"通常指的是将测试脚本和所有必要的依赖项（如 WebDriver、测试数据、配置文件等）整合在一起，以便于测试的分发和执行。以下是一些打包测试脚本的常见方法：

  1. 使用虚拟环境： - 使用 Python 的 venv 或 virtualenv 创建虚拟环境，并将所有依赖项安装在虚拟环境中。
# 创建虚拟环境
python -m venv myenv

# 激活虚拟环境# 在Windows上
myenv\Scripts\activate
# 在Unix或MacOS上source myenv/bin/activate

# 安装依赖项
pip install selenium
  1. 使用依赖文件： - 创建 requirements.txt 文件，列出所有依赖项。
selenium==3.141.0
other-dependency==1.0.0

然后使用以下命令安装依赖项：

pip install-r requirements.txt
  1. 将脚本和依赖打包成 zip 文件： - 将所有脚本文件、依赖项和配置文件放入同一个文件夹中，然后压缩为 zip 文件。
# 在命令行中导航到脚本所在的文件夹cd path/to/your/scripts

# 创建包含所有文件的zip文件zip-r my_test_suite.zip *
  1. 使用 Docker 容器： - 使用 Docker 将测试环境及其所有依赖项打包成一个容器。
# Dockerfile 示例
FROM python:3.8-slim

WORKDIR /app

# 安装Selenium和其他依赖项
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制测试脚本
COPY . .

# 运行测试脚本
CMD ["python", "./your_test_script.py"]

构建并运行 Docker 镜像：

# 构建Docker镜像docker build -t my-selenium-test .# 运行Docker容器docker run my-selenium-test
  1. 使用 PyInstaller 或其他打包工具： - 使用 PyInstaller 将 Python 脚本打包成可执行文件。
pip install pyinstaller

# 打包脚本
pyinstaller --onefile your_test_script.py
# 如果想要将所以文件打包到一起，则将common_old.onnx一起打包
pyinstaller --add-data "D:\\app\\ddddocr\\common_old.onnx;." test.py

这将生成一个独立的可执行文件，可以在没有 Python 环境的系统上运行。

  1. 使用云服务或持续集成工具：- 利用云服务平台或 CI/CD 工具（如 Jenkins、Travis CI、GitHub Actions 等）来执行打包和测试流程。
  2. 文档化：- 确保所有打包和安装的步骤都有详细的文档说明，方便其他人理解和运行测试。

Selenium 主要用于 web 应用的自动化测试，并不直接支持对 Excel 或 Word 文档的操作。然而，你可以使用 Python 的其他库来处理 Excel 和 Word 文档。以下是一些常见的操作示例：

Excel 操作（使用

openpyxl

或 

xlrd

库）

  1. 读取 Excel 文件：import pandas as pd# 使用 pandas 读取 Excel 文件df = pd.read_excel('path_to_your_excel_file.xlsx', sheet_name='Sheet1')
  2. 写入 Excel 文件：# 使用 pandas 写入 Excel 文件df.to_excel('output_excel_file.xlsx', index=False)
  3. 更新 Excel 文件：from openpyxl import load_workbook# 加载现有的 Excel 工作簿wb = load_workbook('path_to_your_excel_file.xlsx')ws = wb.active# 更新单元格ws['A1']='New Value'# 保存工作簿wb.save('updated_excel_file.xlsx')

Word 操作（使用

python-docx

库）

  1. 创建新的 Word 文档：from docx import Documentdoc = Document()doc.add_paragraph('Hello, World!')# 保存文档doc.save('new_word_document.docx')
  2. 读取 Word 文档：from docx import Document# 打开现有的 Word 文档doc = Document('path_to_your_word_file.docx')# 读取文档内容for para in doc.paragraphs:print(para.text)
  3. 修改 Word 文档：from docx import Documentdoc = Document('path_to_your_word_file.docx')doc.add_paragraph('This is a new paragraph.')# 保存修改后的文档doc.save('modified_word_document.docx')
  4. 设置字体样式：from docx.shared import Ptfrom docx.oxml.ns import qnrun = doc.paragraphs[0].add_run('Bold and italic run.')run.bold =Truerun.italic =Truerun.font.size = Pt(16)
  5. 添加表格到 Word 文档：from docx import Tabletable = doc.add_table(rows=2, cols=3)hdr_cell = table.rows[0].cells[0]hdr_cell.text ='Header 1'cell = table.rows[1].cells[0]cell.text ='Row 1, Cell 1'

请注意，这些库提供了丰富的功能来处理 Excel 和 Word 文档，包括但不限于读取、写入、修改内容、设置样式、添加表格等。根据你的具体需求，你可以选择合适的库和方法来实现自动化操作。在使用这些库之前，你需要使用 

pip

安装它们：

pip install openpyxl pandas python-docx

如果你需要在 Selenium 测试中使用这些文档操作，你可以在测试脚本中集成这些库的调用，例如，读取测试数据存储在 Excel 中，或者生成测试报告保存为 Word 文档。

标签： selenium 自动化 python
本文转载自: https://blog.csdn.net/mj256115/article/details/139993754
版权归原作者 熙尛 所有， 如有侵权，请联系我们删除。
登录后发布评论

“selenium网页自动化使用教程”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

Linux在Ubuntu系统下安装MySQL数据库（全网最详细）

chrome浏览器selenium点击下载pdf时总是提示“已阻止不安全的下载”

GuiHelper：面向Java Swing的开源GUI设计辅助工具

数据仓库面试题集&离线&实时

毕业设计项目 基于大数据的K-means广告效果分析

大数据-229 离线数仓 - ODS层的构建 Hive处理 JSON 数据处理 结构化

前端三件套(HTML + CSS + JS)

文章导航