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. 等待元素加载

    • 使用 WebDriverWaitexpected_conditions 来等待元素加载完成,例如 visibility_of_element_located
  11. 获取元素的尺寸和位置

    • 使用 sizelocation 属性来获取元素的尺寸和在页面上的位置。
  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. 获取元素的尺寸和位置
    • 使用 sizelocation 属性获取元素的大小和在页面上的位置。
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 ActionChainsdriver = 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 timeinput_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. 显式等待
    • 使用 WebDriverWaitexpected_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 模块导入 WebDriverWaitexpected_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. 等待弹出框出现
    • 有时弹出框可能需要一些时间出现,可以使用 WebDriverWaitexpected_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. 处理多个弹出框
    • 如果页面上连续出现多个弹出框,可以使用循环来依次处理。
# 假设页面上连续触发了多个 alert
for _ in range(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. 使用高级截图库
    • 对于更高级的截图需求,可以使用像 webkit2pngpyvirtualdisplay 这样的库。

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

十三、验证码

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

  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 的 venvvirtualenv 创建虚拟环境,并将所有依赖项安装在虚拟环境中。
# 创建虚拟环境
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-slimWORKDIR /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 操作(使用 openpyxlxlrd 库)

  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 Pt
    from docx.oxml.ns import qnrun = doc.paragraphs[0].add_run('Bold and italic run.')
    run.bold = True
    run.italic = True
    run.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 文档。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/36069.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【黑龙江哪些行业需要做等保?】

黑龙江等保测评是衡量企业网络安全水平的一项主要指标&#xff0c;包括&#xff1a;金融&#xff0c;能源&#xff0c;电信&#xff0c;医疗&#xff0c;教育&#xff0c;交通&#xff0c;制造&#xff0c;电商等。 等保测评是黑龙江省信息化建设的重要组成部分&#xff0c;也…

旅游管理系统源码小程序

便捷旅行&#xff0c;尽在掌握 旅游管理系统是一款基于FastAdminElementUNIAPP开发的多端&#xff08;微信小程序、公众号、H5&#xff09;旅游管理系统&#xff0c;拥有丰富的装修组件、多端分享、模板消息、电子合同、旅游攻略、旅游线路及相关保险预订等功能&#xff0c;提…

Code Page 历史

1. Code Page 历史发展 此技术的使用最早追溯到 MS-DOS3.3&#xff08;1987 年 4 月发行&#xff09;向 IBMPC 用户引进了内码表的概念&#xff0c;Windows 也使用此概念。 最初的 IBM 字元集被称作内码表 437&#xff0c;或者&#xff08;MS-DOSLatinUS&#xff09;。内码表…

1961 Springboot自习室预约系统idea开发mysql数据库web结构java编程计算机网页源码maven项目

一、源码特点 springboot 自习室预约管理系统是一套完善的信息系统&#xff0c;结合springboot框架和bootstrap完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用springboot框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统具有完整的源代码和数据库…

大型企业组网如何规划网络

大型企业组网是一个复杂的过程&#xff0c;它需要细致的规划和设计&#xff0c;以确保网络能够满足企业的业务需求&#xff0c;同时保证性能、安全性和可扩展性。以下是规划大型企业网络的一些关键步骤和考虑因素&#xff1a; 1. 需求分析 业务需求&#xff1a;与各个业务部门…

EWM学习之旅-1-EWM100

系统学习一个业务模块已经变得越来越重要&#xff0c;开始吧&#xff0c;EWM&#xff01; EWM的Learning Journey中包括7本 ebook,100/110/115/120/125/130/140&#xff0c;一本一本的啃吧&#xff0c;相信很多内容是重复的。 EWM100很适合初学者&#xff0c;了解概念术语&…

Lesson 40 What are you going to do?

Lesson 40 What are you going to do? 词汇 show v. 展示&#xff0c;展出 搭配&#xff1a;show人东西    show东西to人 口语&#xff1a;Show me your hands! 拿出来&#xff01; n. 秀&#xff0c;表演 搭配&#xff1a;talk show 脱口秀    show room 展厅 take v…

高级同步机制:Phaser与CountDownLatch详解

在Java并发编程中&#xff0c;同步机制是确保多线程环境下数据一致性和程序正确性的关键。Java提供了多种同步工具&#xff0c;其中Phaser和CountDownLatch是两个强大的工具&#xff0c;它们可以帮助我们更好地控制线程的执行顺序和同步。 1. CountDownLatch CountDownLatch是…

BPF:BCC工具 funccount 统计内核函数调用(内核函数、跟踪点USDT探针)认知

写在前面 博文内容涉及BCC工具 funccount 认知funccount 可以帮助用户追踪和分析Linux系统上特定函数、系统探针或USDT探针的运行次数。这对于性能分析、故障排查和系统优化等场景非常有用。理解不足小伙伴帮忙指正 &#x1f603;,生活加油 不必太纠结于当下&#xff0c;也不必…

byte[]、MultipartFile、File转换

需求背景 当你需要将byte[]、MultipartFile、File实现互转时&#xff0c;无外乎以下场景&#xff1a; 保存第三方接口返回二进制流 前/后端文件流上传 微服务间调用 文件格式转换 byte[]转MultipartFile 错误示例-MockMultipartFile 首先来看一下摘自Spring官网对MockM…

精益生产推进时如何营造持续变革的氛围?

在快速变化的市场环境中&#xff0c;企业如何保持竞争力&#xff1f;精益生产无疑为众多企业提供了一个强大的战略工具。但是&#xff0c;单纯的引入精益生产理念和方法并不能保证企业的持续成功。关键在于如何营造一种持续变革的氛围&#xff0c;让精益生产成为推动企业不断前…

SDN控制器有哪些推荐品牌?

SDN控制器是SDN架构中的核心组件&#xff0c;负责管理网络设备并实现网络策略。随着SDN技术的不断发展&#xff0c;市场上出现了多种SDN控制器&#xff0c;它们来自不同的供应商&#xff0c;各有特色。以下是一些知名的SDN控制器品牌和产品&#xff1a; 1. **OpenDaylight**&a…

智慧校园-宿舍管理系统总体概述

在教育信息化的不断推动下&#xff0c;智慧校园宿舍管理系统脱颖而出&#xff0c;它以一种全新的视角和方式&#xff0c;重塑了高校宿舍管理的传统模式。该系统深度融合了云计算、物联网、大数据等先进科技&#xff0c;旨在为学生提供一个既安全可靠又充满便捷与温馨的居住体验…

Node.js全栈指南:认识MIME和HTTP

MIME&#xff0c;全称 “多用途互联网邮件扩展类型”。 这名称相当学术&#xff0c;用人话来说就是&#xff1a; 我们浏览一个网页的时候&#xff0c;之所以能看到 html 文件展示成网页&#xff0c;图片可以正常显示&#xff0c;css 样式能正常影响网页效果&#xff0c;js 脚…

Arduino - 电磁锁

Arduino - Electromagnetic Lock Arduino - 电磁锁 The electromagnetic lock (EM lock) is widely used to lock the door. It is usually used with switch, fingerprint reader, RFID/NFC reader, keypad, or application on PC/mobille to control access to door, buid…

气膜体育馆对高度的要求—轻空间

在现代体育场馆的建设中&#xff0c;气膜体育馆以其独特的优势&#xff0c;逐渐成为人们关注的焦点。不同于传统的钢筋混凝土结构&#xff0c;气膜体育馆以其轻盈、灵活、环保的特点&#xff0c;为人们带来了全新的体育体验。在设计与建设气膜体育馆时&#xff0c;高度是一个关…

爬虫是什么?

目录 1.什么是互联网爬虫&#xff1f; 2.爬虫核心? 3.爬虫的用途? 4.爬虫分类&#xff1f; 5.反爬手段&#xff1f; 1.什么是互联网爬虫&#xff1f; 如果我们把互联网比作一张大的蜘蛛网&#xff0c;那一台计算机上的数据便是蜘蛛网上的一个猎物&#xff0c;而爬虫程序…

Hadoop简单应用程序实例

Hadoop是一个分布式系统基础架构&#xff0c;主要用于大数据的存储和处理。它允许使用简单的编程模型跨集群处理和生成大数据集。Hadoop主要由HDFS&#xff08;Hadoop Distributed FileSystem&#xff0c;分布式文件系统&#xff09;和MapReduce编程模型两部分组成。 准备工作…

第十节 动态面板实现推动和拉动效果

在原型设计中我们经常会遇到元件使用显示更多或者收起效果,下面以面板元件推动与拉动效果做案件说明。 一、设置原有内容 我这里添加一个表格内容,添加“显示更多”文本超链接 二、设置在更多显示面板内容 添加一个动态面板,设置有内容、无内容两个状态 在有内容面板中添…

WDF驱动开发-WDF总线枚举

支持在总线驱动程序中进行 PnP 和电源管理 某些设备永久插入系统&#xff0c;而其他设备可以在系统运行时插入和拔出电源。 总线驱动 必须识别并报告连接到其总线的设备&#xff0c;并且他们必须发现并报告系统中设备的到达和离开情况。 总线驱动程序标识和报告的设备称为总线…