Interpretación de tres métodos de espera en Python selenium

Se descubrió que mucha gente no sabe cómo usar la espera, y el blogger hoy no puede evitar darles una lección sobre la necesidad de la espera.

Mucha gente en el grupo pregunta, ¿por qué no puedo localizar este cuadro desplegable, o ese cuadro emergente… no puedo localizar varios. En realidad, en la mayoría de los casos, hay solo dos problemas:1 con frame,2 No se ha agregado espera. No sabe que la velocidad de ejecución de su código es de qué orden de magnitud, y la velocidad de carga y renderizado del navegador es de qué orden de magnitud. Es como si el Flash y el Powerman acuerdan ir a luchar contra un monstruo, y después de que el Flash ha luchado y regresado, le pregunta al Powerman por qué aún está en casa poniéndose los zapatos. El Powerman, en medio de su mente, tiene diez mil caballos alados pasando, se siente ofendido por su lentitud, y decide no jugar más, lanzando una excepción y dejando el desafío.

Entonces, ¿cómo podemos cuidar la lenta velocidad de carga del Powerman? Solo hay una manera, esperar. Al hablar de esperar, hay tres formas de esperar, y el blogger las explicará uno por uno:

1. Espera forzada

La primera y más sencilla manera es la espera forzada, sleep(xx), que fuerza al Flash a esperar xx segundos, sin importar si el Powerman puede seguir el ritmo o si ya llegó antes, debe esperar xx segundos.

Ver el código:

# -*- coding: utf-8 -*-
from selenium import webdriver
from time import sleep
driver = webdriver.Firefox()
driver.get('https://huilansame.github.io
sleep(3) # Espera forzada3seconds antes de ejecutar el siguiente paso
print driver.current_url
driver.quit()

Esto se llama espera forzada, independientemente de si el navegador ha cargado completamente o no, el programa debe esperar.3seconds,3Una vez que pasen los segundos, continúa ejecutando el código siguiente, es muy útil para la depuración. A veces también se puede esperar de esta manera en el código, pero no se recomienda usar este método constantemente, ya que es muy rígido y puede afectar significativamente la velocidad de ejecución del programa.

2. Espera implícita

La segunda manera se llama espera implícita, implicitly_wait(xx), el significado de la espera implícita es: El Flash y el Powerman acuerdan que, sin importar a dónde vaya el Flash, siempre esperarán al Powerman xx segundos. Si el Powerman llega en este tiempo, ambos inmediatamente saldrán a luchar contra el monstruo. Si el Powerman no llega en el tiempo establecido, el Flash se irá solo, y naturalmente esperará a que el Powerman te lance una excepción.

Ver el código:

# -*- coding: utf-8 -*-
from selenium import webdriver
driver = webdriver.Firefox()
driver.implicitly_wait(30) # Espera implícita, con un tiempo máximo de espera30 seconds
driver.get('https://huilansame.github.io
print driver.current_url
driver.quit()

La espera implícita establece un tiempo máximo de espera, si la carga de la página se completa dentro del tiempo establecido, se ejecuta el siguiente paso, de lo contrario, se espera hasta que se alcance el tiempo límite y luego se ejecuta el siguiente paso. Tenga en cuenta que aquí hay una desventaja, es que el programa esperará a que se complete toda la carga de la página, es decir, generalmente, cuando ya no se ve la rueda de carga en la barra de título del navegador, se ejecuta el siguiente paso, pero a veces los elementos que necesita ya se han cargado, pero debido a que algunos elementos js y otros son particularmente lentos, tengo que esperar a que se complete toda la página antes de ejecutar el siguiente paso. ¿Qué hago si quiero que se ejecute el siguiente paso tan pronto como el elemento que necesito aparezca? Hay una manera, esto depende de otro método de espera proporcionado por selenium, es decir, la espera explícita wait.

Es necesario destacar que la espera implícita actúa durante todo el ciclo del driver, por lo que solo es necesario configurarla una vez. He visto a algunas personas que utilizan la espera implícita como sleep en todas partes...

3. Espera explícita

La tercera manera es la espera explícita, WebDriverWait, combinada con los métodos until() y until_not() de esta clase, lo que permite una espera flexible basada en condiciones de juicio. Su principal significado es: el programa mira cada xx segundos, si se cumple la condición, se ejecuta el siguiente paso, de lo contrario, sigue esperando hasta que se supere el tiempo máximo configurado, luego se lanza TimeoutException.

Vamos a ver un ejemplo de código:

# -*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.implicitly_wait(10) # La espera implícita y explícita pueden usarse al mismo tiempo, pero preste atención: el tiempo máximo de espera debe ser el mayor de los dos
driver.get('https://huilansame.github.io
locator = (By.LINK_TEXT, 'CSDN')
try:
  WebDriverWait(driver, 20, 0.5).until(EC.presence_of_element_located(locator))
  print driver.find_element_by_link_text('CSDN').get_attribute('href')
finally:
  driver.close()

上例中，我们设置了隐性等待和显性等待，在其他操作中，隐性等待起决定性作用，在WebDriverWait..中显性等待起主要作用，但要注意的是：最长的等待时间取决于两者之间的大者，此例中为20，如果隐性等待时间 > 显性等待时间，则该句代码的最长等待时间等于隐性等待时间。

我们主要用到了WebDriverWait类与expected_conditions模块，下面博主带大家细看一下这两个模块：

WebDriverWait

wait模块的WebDriverWait类是显性等待类，先看下它有哪些参数与方法：

selenium.webdriver.support.wait.WebDriverWait（类）
__init__
  driver: 传入WebDriver实例，即我们上例中的driver
  timeout: 超时时间，等待的最长时间（同时要考虑隐性等待时间）
  poll_frequency: 调用until或until_not中的方法的间隔时间，默认是0.5秒
  ignored_exceptions: 忽略的异常，如果在调用until或until_not的过程中抛出这个元组中的异常，
      则不中断代码，继续等待，如果抛出的是这个元组外的异常，则中断代码，抛出异常。默认只有NoSuchElementException。
until
  method: 在等待期间，每隔一段时间调用这个传入的方法，直到返回值不是False
  message: 如果超时，抛出TimeoutException，将message传入异常
until_not 与until相反，until是当某元素出现或什么条件成立则继续执行，
    until_not是当某元素消失或什么条件不成立则继续执行，参数也相同，不再赘述。
  method
  message

看了以上内容基本上很清楚了，调用方法如下：

WebDriverWait(driver, 超时时长, 调用频率, 忽略异常).until(可执行方法, 超时时返回的信息)

这里需要特别注意的是until或until_not中的可执行方法method参数，很多人传入了WebElement对象，如下：

WebDriverWait(driver, 10).until(driver.find_element_by_id('kw')) # Error

Esto es un uso incorrecto, los parámetros aquí deben ser llamables, es decir, este objeto debe tener el método __call__(), de lo contrario se lanzará una excepción:

TypeError: 'xxx' object is not callable

Aquí, puedes usar las condiciones proporcionadas por el módulo expected_conditions de selenium, también puedes usar los métodos is_displayed() , is_enabled() , is_selected() del WebElement, o usar tus propios métodos encapsulados, por lo tanto, vamos a ver las condiciones proporcionadas por selenium:

expected_conditions

expected_conditions es un módulo de selenium, que contiene una serie de condiciones que se pueden usar para juzgar:
selenium.webdriver.support.expected_conditions（módulo）
Estas dos condiciones verifican el título, verificando si el parámetro de entrada title es igual o contiene driver.title
title_is
title_contains
Estas dos condiciones verifican si un elemento aparece, los parámetros pasados son tuplas de tipo locator, como (By.ID, 'kw')
Como su nombre indica, una pasa si se carga cualquier elemento que cumpla con las condiciones; la otra requiere que todos los elementos que cumplan con las condiciones se carguen
presence_of_element_located
presence_of_all_elements_located
Estas tres condiciones verifican si un elemento es visible, los dos primeros reciben parámetros de tipo tupla locator, y el tercero recibe WebElement
El primero y el tercero son esencialmente lo mismo
visibility_of_element_located
invisibility_of_element_located
visibility_of
Estas dos condiciones juzgan si un texto específico aparece en un elemento determinado, una juzga el texto del elemento, y la otra juzga el valor del elemento
text_to_be_present_in_element
text_to_be_present_in_element_value
Esta condición juzga si frame puede ser insertado, se puede pasar el tupla locator o ingresar directamente el modo de localización: id, name, index o WebElement
frame_to_be_available_and_switch_to_it
Esta condición determina si hay alerta
alert_is_present
Esta condición determina si un elemento es clickable, se transmite el locator
element_to_be_clickable
Estas cuatro condiciones determinan si un elemento está seleccionado, la primera condición transmite un objeto WebElement, la segunda transmite un tupla de locator
La tercera condición transmite un objeto WebElement y el estado, devuelve True si son iguales, de lo contrario devuelve False
La cuarta condición transmite el locator y el estado, devuelve True si son iguales, de lo contrario devuelve False
element_to_be_selected
element_located_to_be_selected
element_selection_state_to_be
element_located_selection_state_to_be
La última condición determina si un elemento sigue siendo en el DOM, se transmite un objeto WebElement, se puede determinar si la página se actualizó
staleness_of

Aquí están todos17Una condición, combinada con until y until_not, puede realizar muchas jugadas, y si puede encapsularse de manera flexible, aumentará significativamente la estabilidad del script.

Hoy comparto estos contenidos, si tienes alguna pregunta, puedes dejarme un mensaje para intercambiar, espero poder ayudar a los estudiantes que lo necesiten. Gracias por el apoyo de este sitio!

Declaración: el contenido de este artículo se obtiene de la red, pertenece al propietario original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha realizado una edición humana y no asume la responsabilidad legal correspondiente. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplace # con @ para denunciar y proporcione evidencia. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción.)