Este artículo le brindará una introducción detallada a la herramienta de prueba automatizada de la Web Selenium [colección recomendada]

Language 2023-12-16 17:32:26 views: null

Directorio de artículos

Prefacio

Para consolidar los conocimientos adquiridos, el autor intentó comenzar a publicar algunos blogs de notas de estudio para facilitar revisiones futuras. Por supuesto, también sería fantástico si pudiera ayudar a algunos novatos a aprender nuevas tecnologías. El autor es un novato. Si hay errores de grabación en el artículo, los lectores y amigos pueden criticarlos y corregirlos.
(El código fuente de referencia del blog se puede encontrar en los recursos de mi página de inicio. Si tiene alguna pregunta durante el proceso de aprendizaje, puede preguntarme en el área de comentarios)

descubrir tesoro

Hace unos días descubrí un sitio web gigante de aprendizaje de inteligencia artificial. Es fácil de entender y divertido. No pude evitar compartirlo con todos. 【Entrada al tesoro】.

Sección 01 Descripción general del selenio

Selenium es unaherramienta de prueba web automatizada, desarrollada originalmente para pruebas de automatización de sitios web. Selenium puede ejecutarse directamente
en el navegador, es compatible con todos los navegadores principales

Debido a que Selenium puede controlar el navegador para enviar solicitudes y obtener datos de la página web, se puede aplicar al campo del rastreador.

Selenium puede permitir que el navegador cargue automáticamente la página según nuestras instrucciones, obtenga los datos requeridos e incluso tome capturas de pantalla de la página o determine si se han producido ciertas acciones en el sitio web
>a>

Selenium no tiene su propio navegador y no admite funciones del navegador.debe combinarse con un navegador de terceros para poder usarse

Los nombres de los métodos correspondientes serán diferentes según la versión de la biblioteca Selenium.

Documentación oficial:http://selenium-python.readthedocs.io/index.html

Sección 02 Instalar el controlador del navegador (tome Google como ejemplo)

1. Confirmar la versión del navegador

Insertar descripción de la imagen aquí

2. Descargue la versión correspondiente del controlador.

Insertar descripción de la imagen aquí

Insertar descripción de la imagen aquí

3. Cómo descargar versiones históricas de chorm

  • Obtener el número de versión del navegador

Visitahttps://vikyd.github.io/download-chromium-history-version/, es posible que necesites acceder a la información científica. Internet (dddd), luego seleccione la plataforma que desea en el menú desplegable de versiones y luego ingrese el número de versión en el cuadro de entrada, por ejemplo: Windows 64-bit versión 113.0

Insertar descripción de la imagen aquí

  • Seleccione la versión del navegador y descargue el paquete comprimido
    Insertar descripción de la imagen aquí
  • Después de descargar, descomprimir y usar.

Insertar descripción de la imagen aquí

  • Guarde chromedriver.exe en cualquier ubicación y guarde la ruta actual a la variable de entorno (Mi PC>>Haga clic derecho en Propiedades>>Configuración avanzada del sistema>>Avanzada>>Variables de entorno>Variables del sistema>Ruta). tenga cuidado de no sobrescribir la variable de ruta al agregarla. Si se sobrescribe, no cierre y luego use Baidu. Una vez que la adición sea exitosa, use el siguiente código para realizar la prueba.
# 导入 webdriver
import time
from selenium import webdriver

# 调用环境变量指定的PhantomJS浏览器创建浏览器对象
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
# get方法会一直等到页面被完全加载，然后才会继续程序，通常测试会在这里选择
driver.get("https://www.baidu.com/")

# id="kw"是百度搜索输入框，输入字符串"长城"
driver.find_element(By.CSS_SELECTOR,"#kw").send_keys("长城")
# id="su"是百度搜索按钮，click() 是模拟点击
driver.find_element(By.CSS_SELECTOR,"#su").click()

time.sleep(20)

Insertar descripción de la imagen aquí

Sección 03 Posicionamiento de elementos de página

定位一个元素用 element,定位一组元素用 elements

1. Abra la página especificada

1. No cambies a una nueva ventana

Para usar Selenium para abrir la página especificada, primero debe inicializar una instancia de WebDriver y luego usar esta instancia para abrir la página de destino. A continuación se muestra un ejemplo que utiliza Python y Selenium para mostrar cómo abrir una página específica: 

from selenium import webdriver

# 初始化一个WebDriver实例，这里使用Chrome作为浏览器
driver = webdriver.Chrome()

# 打开指定的页面，将URL替换为你要访问的网页地址
url = "https://www.example.com"
driver.get(url)

# 在这里，你可以执行与打开页面相关的操作

# 最后，关闭浏览器窗口
driver.quit()

En el código anterior, primero importamos el módulo de Selenium e inicializamos un navegador método de la página de destino con la dirección de la página web que desea visitar. Luego, puede realizar acciones relacionadas con su prueba o tarea en la página y luego cerrar la ventana del navegador usando el y reemplace use el método get para abrir la página especificada Ejemplo. Luego, webdriverChromeWebDriverURLquit

2. Cambiar a nueva ventana

El método anterior abrirá una nueva página en la ventana o pestaña actual, reemplazará la página actual con una nueva URL, usewindow.open(url)< a i=2> Abrir nueva página:

driver.execute_script("window.open('https://www.example.com', '_blank');")  # 使用JavaScript打开一个新页面

Este método utiliza el método execute_script para ejecutar el código JavaScript y abrir el en una nueva ventana o pestaña. Este método es adecuado para abrir la página en una nueva ventana sin reemplazar la página actual le indica al navegador que abra URL'_blank'URL

Tenga en cuenta que si utiliza el método window.open() para abrir una nueva página, es posible que necesite utilizar driver.window_handles y para gestionar el cambio entre diferentes ventanas, tal como el identificador de ventana que se menciona más adelante. Esto le permite realizar acciones en diferentes ventanas del navegadordriver.switch_to.window()

En resumen, el método ejecutar_script se usa normalmente junto con otros métodos de Selenium para ejecutar JavaScript para interacciones y operaciones específicas, pero no se usa por sí solo para abrir una nueva página.

3. Mantenga abierta la ventana del navegador.

De forma predeterminada, Selenium WebDriver cierra la ventana del navegador después de que finaliza la ejecución del script, pero configurando la opción "separar" Verdadero, puede mantener la ventana del navegador abierta para realizar operaciones manuales

from selenium import webdriver

# 创建ChromeOptions对象
options = webdriver.ChromeOptions()

# 添加选项，防止浏览器自动关闭
options.add_experimental_option("detach", True)

# 初始化一个WebDriver实例，将选项传递给Chrome
driver = webdriver.Chrome(options=options)

# 打开指定的页面
url = "https://www.csdn.net"
driver.get(url)

# 在这里，你可以执行与打开页面相关的操作

# 手动关闭浏览器时，可以保持它打开

2. Posicionamiento de identificación

Para segmentar por ID de un elemento usando Selenium, puede usar el selector By.ID y find_element método. A continuación se muestra un ejemplo de cómo segmentar por el ID de un elemento:

from selenium import webdriver

# 初始化一个WebDriver实例，这里使用Chrome作为浏览器
driver = webdriver.Chrome()

# 打开指定的页面
url = "https://www.example.com"
driver.get(url)

# 通过元素的ID进行定位并执行操作
element = driver.find_element(By.ID, "element_id")

# 在这里，你可以执行与该元素相关的操作，例如单击、输入文本等
element.click()

# 最后，关闭浏览器窗口
driver.quit()

En el ejemplo anterior, driver.find_element(By.ID, "element_id") localiza el elemento por su atributo ID y lo almacena en la variable element , que luego se puede ejecutar con Element- operaciones relacionadas. Recuerde reemplazar "element_id" con el ID real del elemento que está buscando.

3. posicionamiento del nombre

# 通过元素的name属性进行定位并执行操作
element = driver.find_element(By.NAME,"element_name")

4. posicionamiento de clase

# 通过元素的CSS类名进行定位并执行操作
element = driver.find_element(By.By.CLASS_NAME, ".element_class")

Cinco, posicionamiento de etiquetas

Cada etiqueta se usa a menudo para definir un tipo de función, por lo que la tasa de éxito al identificar un elemento a través de etiquetas es muy baja. Cada página generalmente usa muchas de las mismas etiquetas.

# 通过元素的标签名进行定位并执行操作
element = driver.find_element(By.TAG_NAME,"element_tag")

element_tag en el código de muestra representa el nombre de la etiqueta HTML del elemento que está buscando, como < div >, < a >, < p >, etc. Específicamente, si desea encontrar un elemento < div >, puede reemplazar element_tag con "div", si desea encontrar un < / un elemento , y así sucesivamente por < a >, puede reemplazar element_tag"a"

Seis, posicionamiento xpath

XPath (XML Path Language) es un lenguaje para localizar elementos en documentos XML. También se aplica a documentos HTML porque HTML es una variante de un lenguaje de marcado basado en XML. XPath es un poderoso método de localización de elementos que le permite localizar elementos con precisión en una página web,independientemente de su posiciónen el documento. A continuación se muestran algunos ejemplos de posicionamiento XPath:

1. Posicionamiento por nombre de elemento:

  • OrientaciónConexión posesivaElemento://a
  • OrientaciónPárrafo posesivoElemento://p
  • PosicionamientoPrimer títuloElemento://h1

2. Posicionamiento mediante atributos de elementos:

  • Ubicaun elemento con un atributo de identificación específico:

    //*[@id='element_id']

  • Orientaciónelementos con una clase específica atributo:

    //*[@class='element_class']

3. Posicionamiento a través del contenido textual:

  • SegmentaciónElementos que contienen texto específico:

    //*[text()='要查找的文本']

  • Ubica elementos que comiencencon un texto específico:

    //*[starts-with(text(), '开头文本')]

  • SegmentaciónEnlaces que contienen texto específico:

    //a[contains(text(), '链接文本')]

4. Posicionamiento mediante jerarquía de elementos:

  • PosicionamientoElemento hijo del elemento padre:

    //div[@id='parent_id']/p（查找 id 属性为 'parent_id' 的 < div > 元素下的所有 < p > 元素）

  • PosicionamientoElementos hijos de elementos ancestros:

    //div[@class='grandparent_class']//span（查找 class 属性为 'grandparent_class' 的祖先元素下的所有< span >元素）

5. Utilice operadores lógicos:

  • Posiciónelementos que cumplen múltiples condiciones al mismo tiempo:

    //input[@type='text' and @name='username']（查找type属性为 'text' 且 name 属性为 'username' 的输入框）

Estos son sólo algunos ejemplos básicos de XPath. XPath tiene una sintaxis y funcionalidad muy rica. Puedes combinar y personalizar diferentes condiciones para ubicar elementos según tus necesidades. En Selenium, puede utilizar el método find_element + By.XPATH para lograr el posicionamiento XPath, por ejemplo: 

element = driver.find_element(By.XPATH,"//a[contains(text(), '链接文本')]")

Esto encontrará elementos de enlace que contienen texto específico; puede modificar la expresión XPath para apuntar a diferentes elementos según sea necesario.

6. Ejemplo

<html>
  <head>...<head/>
  <body>
    <div id="csdn-toolbar">
      <div class="toolbar-inside">
        <div class="toolbar-container">
          <div class="toolbar-container-left">...</div>
          <div class="toolbar-container-middle">
            <div class="toolbar-search onlySearch">
			<div class="toolbar-search-container">
				<input id="toolbar-search-input" autocomplete="off" type="text" value="" placeholder="C++难在哪里？">

De acuerdo con la etiqueta anterior, debe colocar la última filainput etiqueta. A continuación se enumeran cuatro métodos.xpath Los métodos de posicionamiento son diversos y no es único Uso Se puede analizar según la situación. 

# 绝对路径（层级关系）定位
driver.find_element(By.XPATH,
	"/html/body/div/div/div/div[2]/div/div/input[1]")
# 利用元素属性定位
driver.find_element(By.XPATH,
	"//*[@id='toolbar-search-input']"))
# 层级+元素属性定位
driver.find_element(By.XPATH,
	"//div[@id='csdn-toolbar']/div/div/div[2]/div/div/input[1]")
# 逻辑运算符定位
driver.find_element(By.XPATH,
	"//*[@id='toolbar-search-input' and @autocomplete='off']")

7. selector css

CSS usa selectores para vincular atributos a elementos de la página. Puede seleccionar de manera flexible cualquier atributo del control. Generalmente, el posicionamiento es más rápido que xpath. Usar selectores CSS para posicionar elementos es muy común y conveniente en Selenium. A continuación se muestran algunos ejemplos comunes de selectores de CSS:

1. Posicionamiento por nombre de elemento:

  • Orientación Elemento de conjunción posesiva :a
  • Orientación Elemento de párrafo posesivo :p
  • Orientación Elemento aleatorio posesivo :botón

2. Posicionamiento por ID de elemento:

Objetivoun elemento con un atributo de ID específico:#element_id

element = driver.find_element(By.CSS_SELECTOR,"#element_id")

3. Ubique por nombre de clase:

  • Ubicarelementos con un atributo de clase específico: .element_class
element = driver.find_element(By.CSS_SELECTOR,".element_class")

4. Posicionamiento mediante atributos de elementos:

  • Ubicar elementos conun valor de atributo específico:[attribute='value']
element = driver.find_element(By.CSS_SELECTOR,"[name='username']")

5. Coincidencia parcial a través de valores de atributos:

  • Localice un elemento que contenga un valor de atributo específico: [atributo*='valor']
element = driver.find_element(By.CSS_SELECTOR,"[href*='example.com']")

6. Combinando condiciones:

  • Posiciónelementos que cumplen múltiples condiciones al mismo tiempo: .clase1.clase2
element = driver.find_element(By.CSS_SELECTOR,".element_class1.element_class2")

7. Posicionamiento de elementos secundarios:

  • Posicionamientoelemento hijo del elemento padre:#parent_id > .child_class
element = driver.find_element(By.CSS_SELECTOR,"#parent_id > .child_class")

8. Selector de pseudoclase:

Por ejemplo, posicionamientomouse-hover elemento: :hover

element = driver.find_element(By.CSS_SELECTOR,"a:hover")

8. posicionamiento del enlace

Localizar elementos de hipervínculo (enlace) usando Selenium generalmente implica buscar elementos con la etiqueta <a>, que es la etiqueta de enlace en HTML. Puede utilizar diferentes métodos para localizar hipervínculos, como por contenido de texto, texto de enlace, texto de enlace parcial, etc. A continuación se muestran algunos ejemplos comunes de orientación por enlace:

1. Segmentar por texto del enlace (coincidencia exacta):

Utilice el contenido de texto del enlace para la orientación, asegurándose de que el texto coincida exactamente con el enlace:

   # 查找所有链接文本为"下一页"的元素
   element = driver.find_elements(By.LINK_TEXT, "文本")

2. Orientación por texto del enlace (coincidencia parcial):

La segmentación que utiliza parte del contenido de texto del enlace puede coincidir con parte del texto del enlace:

   element = driver.find_element(By.PARTIAL_LINK_TEXT,"部分文本")

Por ejemplo, si el texto de su enlace es "Haga clic aquí para obtener más información", puede utilizar "Haga clic aquí" u "Obtener más información" para una coincidencia parcial.

Estos métodos son muy convenientes, especialmente cuando conoce el contenido del texto del enlace. Sin embargo, tenga en cuenta que distinguen entre mayúsculas y minúsculas, así que asegúrese de que las mayúsculas y minúsculas del contenido del texto coincidan con el texto del enlace.

Para encontrar múltiples enlaces, puede usar find_element**s**(By.LINK_TEXT, "文本") o find_element**s**(By.PARTIAL_LINK_TEXT,"部分文本"), que devolverá una lista de elementos y puede iterar a través de la lista para encontrar elemento de enlace múltiple.

Ejemplo:

elements = driver.find_elements(By.PARTIAL_LINK_TEXT,"部分文本")
for element in elements:
    print(element.text)

Esto imprimirá todos los elementos del enlace que contengan "texto parcial" del texto del enlace.

9. Ejemplo de traducción de Youdao

Visite el sitio web de Youdao Translation, ingrese palabras y obtenga el contenido traducido

import time

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

# 创建ChromeOptions对象
options = webdriver.ChromeOptions()

# 添加选项，防止浏览器自动关闭
options.add_experimental_option("detach", True)

# 创建Chrome WebDriver
driver = webdriver.Chrome(options=options)

# 打开有道翻译页面
driver.get("https://fanyi.youdao.com/")

# 等待输入框可见
input_element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "js_fanyi_input"))
)

# 输入内容
input_element.send_keys("hello")


# 如果有广告弹出框，关闭它
try:
    close_btn = driver.find_element(By.CSS_SELECTOR, ".close")
    close_btn.click()
except Exception:
    pass  # 如果没有广告，继续执行

# 等待翻译结果出现
transTarget = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "js_fanyi_output_resultOutput"))
)

# 输出翻译结果
print(transTarget.text)

# 关闭浏览器
# driver.quit()

Insertar descripción de la imagen aquí

Sección 04 Control del navegador

1. Modificar el tamaño de la ventana del navegador

webdriver proporciona set_window_size() método para modificar el tamaño de la ventana del navegador

from selenium import webdriver

# 初始化浏览器驱动程序，这里使用Chrome作为示例
driver = webdriver.Chrome()

# 最大化浏览器窗口
driver.maximize_window()

# 或者设置特定大小的窗口
# driver.set_window_size(1024, 768)  # 传递所需的宽度和高度

# 访问网页
driver.get("https://www.example.com")

# 在这里执行其他操作...

# 关闭浏览器
driver.quit()

2. Navegador hacia adelante y hacia atrás

Para realizar operaciones de avance y retroceso del navegador en Selenium, puede usar forward() y back. () método

# 在这里执行其他操作...

# 执行前进操作
driver.forward()

# 执行后退操作
driver.back()

# 在这里执行其他操作...

Tenga en cuenta que las operaciones hacia adelante y hacia atrás a menudo dependen del historial del navegador. Si no hay páginas hacia adelante o hacia atrás en el historial del navegador, es posible que estos métodos no hagan nada. Por lo tanto, antes de utilizar avanzar y retroceder,asegúrese de que el navegador haya visitado varias páginas para establecer un historial

3. Actualización del navegador

Para realizar la operación de actualización del navegador en Selenium, puede utilizar el método de actualización (). Aquí hay un ejemplo que muestra cómo usar Selenium en Python para actualizar una página del navegador:

from selenium import webdriver

# 刷新浏览器页面
driver.refresh()

Este método recargará la página actual como si el usuario hiciera clic manualmente en el botón de actualización del navegador. La operación de actualización se puede utilizar para recargar el contenido de la página y garantizar que su script de prueba pueda recargar la página cuando cambie el estado de la página.

4. Cambio de ventana del navegador

En Selenium, para cambiar las ventanas del navegador, puede usar elwindow_handles atributo para obtener el actualmente abiertoTodos los identificadores de ventana y luego use el método switch_to.window() Cambiar a un identificador de ventana específico. Aquí hay un ejemplo de cómo cambiar las ventanas del navegador usando Selenium en Python:

from selenium import webdriver

# 初始化浏览器驱动程序，这里使用Chrome作为示例
driver = webdriver.Chrome()

# 打开第一个网页
driver.get("https://www.example1.com")

# 打开第二个网页
driver.execute_script("window.open('https://www.example2.com', '_blank');")

# 获取所有窗口句柄
window_handles = driver.window_handles

# 切换到第二个窗口
driver.switch_to.window(window_handles[1])

# 在第二个窗口执行操作

# 切换回第一个窗口
driver.switch_to.window(window_handles[0])

# 在第一个窗口执行操作

# 关闭浏览器
driver.quit()

En el ejemplo anterior, primero abrimos dos páginas web diferentes y luego usamos window_handles para obtener todos los identificadores de ventana. Podemos realizar operaciones en diferentes ventanas del navegador cambiando a diferentes identificadores de ventana

Tenga en cuenta que los índices de identificadores de ventana generalmente comienzan en 0, por lo que el identificador de la primera ventana es window_handles[0] , el identificador de la segunda ventana es window_handles[1] , y así sucesivamente. Puede cambiar a otros identificadores de ventana para realizar operaciones según sea necesario

Window Handle es un identificador o referencia que se utiliza para identificar de forma única una ventana del navegador. Cada vez que abre una nueva ventana o pestaña del navegador, el navegador asigna un identificador único a la ventana. Estos identificadores se asignan a nivel del navegador y se utilizan para identificar diferentes ventanas o pestañas del navegador para cambiarlas y manipularlas en un entorno de navegador de múltiples ventanas.

En herramientas de prueba automatizadas como Selenium, los identificadores de ventana se utilizan para controlar y cambiar entre diferentes ventanas del navegador para realizar operaciones entre múltiples ventanas. Al obtener el identificador de la ventana, puede cambiar el foco de una ventana a otra para realizar diversas operaciones, como cambiar entre diferentes ventanas, operar ventanas emergentes, etc.

Un identificador de ventana suele ser una cadena que puede utilizar para localizar y manipular una ventana específica del navegador. En Selenium, puede usar la propiedad window_handles para obtener todos los identificadores de ventana actualmente abiertos y luego usar el método switch_to.window() para cambiar a un identificador de ventana específico. Esto facilita la automatización de pruebas u operaciones en un entorno de navegador de múltiples ventanas.

5. Operaciones comunes

Cuando se utiliza Selenium WebDriver o una herramienta de prueba automatizada similar, estos métodos se pueden utilizar para interactuar con elementos de la página web y obtener información. Aquí hay ejemplos de uso para cada método:

1. send_keys(): simula la entrada de contenido específico

from selenium import webdriver

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

# 找到输入框元素并输入文本
input_element = driver.find_element_by_id("username")
input_element.send_keys("myusername")

En este ejemplo, el método send_keys() simula ingresar "myusername" en el cuadro de entrada con la identificación "username"

2. clear(): contenido de texto claro

# 清除输入框中的文本
input_element.clear()

El método clear() se utiliza para borrar el contenido del texto en el cuadro de entrada anterior.

3. is_displayed(): determina si el elemento es visible

# 检查元素是否可见
if input_element.is_displayed():
    print("Input element is visible on the page.")
else:
    print("Input element is not visible on the page.")

El método is_displayed() se utiliza para comprobar si un elemento de la página es visible. En este ejemplo, si el cuadro de entrada está visible, se imprimirá "El elemento de entrada está visible en la página".

4. get_attribute(): obtiene el valor del atributo de la etiqueta

# 获取元素的href属性值
link_element = driver.find_element_by_link_text("Example Link")
href_value = link_element.get_attribute("href")
print("Href attribute value is:", href_value)

El método get_attribute() se utiliza para obtener el valor de un atributo específico de un elemento. En este ejemplo, obtiene el valor del atributo href del elemento cuyo texto de enlace es "Enlace de ejemplo".

5. tamaño: devuelve el tamaño del elemento

# 获取元素的宽度和高度
element_size = input_element.size
print("Element size is:", element_size)

El tamaño es una propiedad que devuelve el ancho y el alto de un elemento. En este ejemplo, obtiene el tamaño del elemento del cuadro de entrada.

6. texto: Devuelve el texto del elemento

# 获取元素的文本内容
paragraph_element = driver.find_element_by_css_selector("p")
paragraph_text = paragraph_element.text
print("Paragraph text is:", paragraph_text)

El texto es una propiedad que devuelve el contenido de texto de un elemento. En este ejemplo, obtiene el contenido de texto del elemento <p>

6. Ejemplo de interacción entre elementos de página CSDN

# coding=utf-8
import time

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

driver = webdriver.Chrome()

driver.get('https://www.csdn.net/')
time.sleep(2)
# 定位搜索输入框
text_label = driver.find_element(By.ID, "toolbar-search-input")

# 在搜索框中输入 东离与糖宝
text_label.send_keys('东离与糖宝')
time.sleep(2)

# 清除搜索框中的内容
text_label.clear()
time.sleep(2)

# 输出搜索框元素是否可见
print(text_label.is_displayed())
# 输出placeholder的值
print(text_label.get_attribute('placeholder'))

# 定位搜索按钮
button = driver.find_element(By.ID, 'toolbar-search-button')
# 输出按钮的大小
print(button.size)
# 输出按钮上的文本
print(button.text)

'''输出内容
True
搜CSDN
{'height': 32, 'width': 88}
搜索
'''

Sección 05 Control del mouse

1. Haga clic en el elemento

左键不需要用到 ActionChains

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

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

element = driver.find_element_by_id("my_element")

# 单击元素
ActionChains(driver).click(element).perform()

2. Haga doble clic en el elemento.

# 双击元素
ActionChains(driver).double_click(element).perform()

3. Haga clic derecho sobre el elemento.

# 右键单击元素
ActionChains(driver).context_click(element).perform()

4. Pase el cursor sobre el elemento (mouseover)

模拟悬停的作用一般是为了显示隐藏的下拉框

# 鼠标悬停在元素上
ActionChains(driver).move_to_element(element).perform()

5. Arrastra el elemento a otra ubicación.

# 拖拽元素到目标位置
target_element = driver.find_element_by_id("target_element")
ActionChains(driver).drag_and_drop(element, target_element).perform()

Sección 06 Control del teclado

1. Ingrese texto

Utilice el método send_keys para ingresar texto en el elemento activo como si el usuario lo hubiera escrito manualmente

from selenium import webdriver

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

# 定位到文本输入框并输入文本
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys("Hello, World!")

2.Botón

Utilice el método send_keys para simular el funcionamiento de teclas específicas, como la tecla Intro, la tecla Retroceso, la tecla Tab, etc.

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

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

# 模拟按下回车键
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys(Keys.ENTER)

3. Combinación de teclas

Puedes usarClase de teclas para simular combinaciones de teclas en el teclado, como Ctrl+C (copiar) y Ctrl+V (pegar). ). 

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

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

# 模拟Ctrl+C（复制）
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys(Keys.CONTROL, 'c')

# 模拟Ctrl+V（粘贴）
another_text_input = driver.find_element_by_id("another_textbox")
another_text_input.send_keys(Keys.CONTROL, 'v')

4. Otras operaciones del teclado

funcionar describir
Teclas.F1 Tecla F1
Teclas.ESPACIO espacio
Teclas.TAB Tecla de tabulación
Teclas.ESCAPE ESC
Claves.TODAS tecla Alt
Teclas.SHIFT Tecla Shift
Teclas.ARROW_DOWN flecha hacia abajo
Teclas.ARROW_LEFT flecha izquierda
Claves.ARROW_RIGHT flecha correcta
Teclas.ARROW_UP flecha arriba

Sección 07 Elementos Espera

La mayoría de las aplicaciones web actuales utilizan la tecnología Ajax. Cuando se carga una página en el navegador, los elementos dentro de la página se pueden cargar en diferentes momentos. Esto dificulta la localización del elemento y, si el elemento ya no está en la página, se generará una excepción ElementNotVisibleException. Usando esperas, podemos resolver este problema. esperas proporciona el intervalo de tiempo entre algunas operaciones, principalmente posicionar un elemento o cualquier otra operación en ese elemento.

Selenium Webdriver proporciona dos tipos de esperas: implícitas y explícitas. La espera explícita hará que WebDriver espere a que se cumplan ciertas condiciones antes de continuar con la ejecución. La espera implícita permite a Webdriver esperar un cierto período de tiempo antes de buscar un elemento.

1. Espera implícita

Espera implícita: establece un tiempo de espera global. Si Selenium no puede encontrar el elemento inmediatamente, esperará el tiempo especificado y volverá a intentarlo. Esto se aplica a todo el proceso de prueba.

from selenium import webdriver

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

driver.get("https://example.com")
element = driver.find_element_by_id("myElement")

2. Mostrar espera

Espera explícita: la espera explícita le permite esperar condiciones específicas para operaciones específicas. Puede esperar a que el elemento sea visible, se pueda hacer clic, etc.

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

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

# 等待元素可见
element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.ID, "myElement"))
)

# 等待元素可点击
element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "myElement"))
)

3. Espera personalizada

Espera personalizada: También puedes crear condiciones de espera personalizadas según tus necesidades. Por ejemplo, puede esperar a que el contenido de texto de un elemento sea igual a un valor específico.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait

def wait_for_element_with_text(driver, by, value, text, timeout=10):
    return WebDriverWait(driver, timeout).until(
        lambda driver: driver.find_element(by, value).text == text
    )

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

# 等待元素文本内容等于特定值
wait_for_element_with_text(driver, By.ID, "myElement", "Hello, World!")

4. Espera forzada

Cambiar una espera implícita a una espera forzada (usando time.sleep()) generalmente no es una buena práctica ya que genera código ineficiente y puede hacer perder tiempo.

import time
from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")  # 替换为你要访问的网页URL

# 假设你已经定位到了包含文本的 WebElement 对象
element = driver.find_element_by_css_selector("span.red-packet-icon-mini > span.num")

# 使用强制等待
time.sleep(5)  # 强制等待 5 秒

# 获取 <span> 元素的文本内容
text_content = element.text

# 打印文本内容
print(text_content)

值得一提的是，对于定位不到元素的时候，从耗时方面隐式等待和强制等待没什么区别

Sección 08 Operación de conmutación

Cuando Selenium opera una página, puede saltar a una nueva página (abrir una nueva pestaña) haciendo clic en un enlace. En este momento, Selenium todavía está en la página anterior y debemos cambiar para ubicar los elementos más recientes en la página. página.

El cambio de ventana requiere el uso del método switch_to.windows().

1. Cambio de ventana

Cuando Selenium opera una página, puede saltar a una nueva página (abrir una nueva pestaña) haciendo clic en un enlace. En este momento, Selenium todavía está en la página anterior y debemos cambiar para ubicar los elementos más recientes en la página. página.

El cambio de ventana requiere el uso del método switch_to.windows().

from selenium import webdriver

handles = []
driver = webdriver.Chrome()
driver.get('https://blog.csdn.net/')
# 设置隐式等待
driver.implicitly_wait(3)
# 获取当前窗口的句柄
handles.append(driver.current_window_handle)
# 点击 python，进入分类页面
driver.find_element_by_xpath('//*[@id="mainContent"]/aside/div[1]/div').click()
# 切换窗口
driver.switch_to.window(driver.window_handles[-1])
# 获取当前窗口的句柄
handles.append(driver.current_window_handle)

print(handles)
print(driver.window_handles)

Insertar descripción de la imagen aquí
Después de hacer clic para saltar, el código anterior usa switch_to para cambiar de ventana. window_handlesLa lista devuelta handle se basa en la página Cuando se ordena por tiempo de aparición, la última página abierta debe ser la última, por lo que puede usar driver.window_handles[-1] + switch_to para saltar a la última página abierta.

Si hay varias ventanas abiertas, ¿cómo saltar a la ventana abierta anteriormente? Si realmente es necesario, al abrir una ventana, debe registrar cada ventanakey(别名) y value(handle), guárdelo en el diccionario y luego recupérelo según key. handle

2. Cambio de forma

1. cambio de iframe

Muchas páginas también estarán anidadas con formularios de marcos/iframe. Selenium no puede ubicar directamente dichas páginas incrustadas. Debe usar el método switch_to.frame() para cambiar el objeto actualmente operado a una página incrustada de marco/iframe.

De forma predeterminada, switch_to.frame () puede usar el atributo id o nombre para el posicionamiento directo, pero si el iframe no tiene una identificación o un nombre, entonces debe usar xpath para el posicionamiento.

   iframe = driver.find_element(By.ID, "my-iframe-id")
   driver.switch_to.frame(iframe)

2. Vuelva al contenido predeterminado:

Si desea volver a la página principal después de completar la operación en el iframe, puede utilizar el método switch_to.default_content():

   driver.switch_to.default_content()

Estos métodos pueden ayudarle a cambiar entre ventanas e iframes en Selenium. Recuerde, antes de cambiar de ventana o iframe, debe obtener el identificador de ventana o elemento iframe correspondiente.

3. Ejemplos

Específicamente, para encontrar un elemento ubicado dentro de un iframe, debes seguir estos pasos:

1. Primero necesitas encontrar el elemento iframe y luego cambiar a ese iframe.

2. Dentro del iframe, puedes utilizar métodos habituales para buscar y manipular elementos.

A continuación se muestra un ejemplo de cómo cambiar a un iframe y encontrar los elementos que contiene:

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

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

# 找到 iframe 元素，可以根据其 ID、名称或其他属性来定位
iframe = driver.find_element(By.ID, "my-iframe-id")

# 切换到 iframe
driver.switch_to.frame(iframe)

# 在 iframe 中查找元素并执行操作
element_inside_iframe = driver.find_element(By.CLASS_NAME, "element-class")
element_inside_iframe.click()

# 切换回主页面
driver.switch_to.default_content()

En este ejemplo, primero encontramos el elemento a través de su ID y luego cambiamos a < usando / a> para volver a la página principal. y realice la operación. Finalmente, use , luego busque el elemento en iframedriver.switch_to.frame()iframeiframedriver.switch_to.default_content()

Recuerde asegurarse de encontrar el elemento iframe correctamente y, después de cambiar al iframe, use el método driver.find_element() para encontrar el elemento dentro del iframe.

Sección 09 Operación del rodillo

Para simular las operaciones de la rueda en Selenium, puede utilizar el método send_keys de la clase ActionChains para enviar claves como Keys.PAGE_DOWN o Keys.SPACE a la página. Esto simulará el desplazamiento hacia abajo en la página.

En su código de ejemplo, ya creó un objeto ActionChains, por lo que solo necesita usar el método send_keys en el bucle para simular la operación de la rueda. Aquí se explica cómo modificar su código para simular el desplazamiento hacia abajo:

from selenium.webdriver.common.keys import Keys

# ...

# 计算滚动的时间间隔（以毫秒为单位）
scroll_interval = 500  # 每500毫秒滚动一次

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

# 模拟滚动
for _ in range(int(scroll_duration * 1000 / scroll_interval)):
    action_chains.send_keys(Keys.PAGE_DOWN).perform()
    time.sleep(scroll_interval / 1000)

Este código simula presionar la tecla Av Pág para desplazarse por la página. Puede ajustar scroll_interval y scroll_duration según sea necesario para controlar la velocidad y la duración del desplazamiento.

Resumir

Puedes dejar mensajes, intercambiar comentarios y hacer críticas. Si el artículo te resulta útil o crees que la redacción del autor es buena, puedes hacer clic para seguirlo, darle me gusta, recopilarlo y apoyarlo.
(El código fuente de referencia del blog se puede encontrar en los recursos de mi página de inicio. Si tiene alguna pregunta durante el proceso de aprendizaje, puede preguntarme en el área de comentarios)

Supongo que te gusta

Origin blog.csdn.net/HHX_01/article/details/134015413
Recomendado
Clasificación
Diario
Más
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)

Code World

© 2018 codetd.com