Spiegazione dei tre modi di attesa in Python selenium

Ho scoperto che molte persone non sanno come usare l'attesa, oggi non posso fare a meno di spiegare l'importanza dell'attesa.

Molte persone nella chat chiedono, questo menu a discesa non può essere localizzato, quella finestra emergente non può essere localizzata... vari problemi di localizzazione non trovati. In realtà, nella maggior parte dei casi ci sono solo due problemi: 1 ci sono frame, 2 non è stato aggiunto l'attesa. Non si sa quanto sia veloce la velocità di esecuzione del codice, e quanto sia veloce la velocità di caricamento e rendering del browser, è come se Flash e Ultraman avessero concordato di combattere il mostro, poi Flash torna indietro e chiede a Ultraman perché non è uscito ancora, indossando le scarpe. Ultraman passa attraverso un milione di capre nel cuore, accusa Flash di essere veloce e dice che non gioca più con lui, lancia un'eccezione e lascia la scena.

Allora come possiamo tener conto della lenta velocità di caricamento di Ultraman? C'è solo un modo, aspettare. Parlando di aspettare, ci sono tre modi di aspettare, ascoltami spiegare uno per uno:

1. Attesa forzata

Il primo metodo è anche il più semplice e più brutale, ossia l'attesa forzata sleep(xx), che forza Flash a aspettare per xx secondi, indipendentemente dal fatto che Ultraman possa stare al passo o sia arrivato prima, deve aspettare per xx secondi.

Guarda il codice:

# -*- coding: utf-8 -*-
from selenium import webdriver
from time import sleep
driver = webdriver.Firefox()
driver.get('https://huilansame.github.io')
sleep(3) # Attesa forzata di 3 secondi prima di eseguire il passo successivo
print driver.current_url
driver.quit()

Questo si chiama attesa forzata, indipendentemente dal fatto che il browser sia stato caricato o meno, il programma deve aspettare 3 secondi. Una volta trascorsi 3 secondi, si continua a eseguire il codice seguente. È molto utile per il debug, a volte si può aspettare così nel codice, ma non si consiglia di usarlo sempre, è troppo rigido e può influenzare notevolmente la velocità di esecuzione del programma.

2. Attesa invisibile

Il secondo metodo si chiama attesa invisibile, implicitly_wait(xx), il significato dell'attesa invisibile è: Flash e Ultraman hanno concordato che, indipendentemente da dove Flash vada, deve aspettare Ultraman per xx secondi. Se Ultraman arriva entro questo tempo, i due partono immediatamente per combattere il mostro. Se Ultraman non arriva entro il tempo stabilito, Flash parte da solo. Naturalmente, aspetta che Ultraman ti lanci un'eccezione.

Guarda il codice:

# -*- coding: utf-8 -*-
from selenium import webdriver
driver = webdriver.Firefox()
driver.implicitly_wait(30) # Attesa invisibile, massimo 30 secondi
driver.get('https://huilansame.github.io')
print driver.current_url
driver.quit()

L'attesa invisibile stabilisce un tempo massimo di attesa, se la pagina web si carica entro il tempo stabilito, si esegue il passo successivo, altrimenti si aspetta fino alla scadenza del tempo e poi si esegue il passo successivo. Attenzione, c'è un difetto qui, ovvero il programma aspetta che l'intera pagina sia completamente caricata, ossia solitamente quando vedi il cerchio che gira nella barra dei tag del browser smette di girare, allora si esegue il passo successivo, ma a volte gli elementi che si desiderano sono già stati caricati, ma a causa di alcuni script molto lenti, devo aspettare che la pagina sia completamente completata prima di eseguire il passo successivo. Cosa posso fare quando voglio che il passo successivo venga eseguito dopo che l'elemento desiderato è apparso? C'è un modo, e questo dipende da un altro modo di attesa fornito da selenium - l'attesa esplicita wait.

Occorre precisare che l'attesa implicita è efficace per tutto il ciclo del driver, quindi è sufficiente impostarla una volta. Ho visto qualcuno usare l'attesa implicita come sleep ovunque...

3. Attesa esplicita

Il terzo metodo è l'attesa esplicita, WebDriverWait, utilizzato insieme ai metodi until() e until_not() della classe per attendere in modo flessibile in base alle condizioni di judgment. Il suo significato principale è: il programma controlla ogni xx secondi, se la condizione è soddisfatta, esegue il passo successivo, altrimenti continua a attendere, fino a che non viene superato il tempo massimo impostato, quindi viene lanciata l'eccezione TimeoutException.

Ecco un esempio di codice:

# -*- 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) # L'attesa implicita e l'attesa esplicita possono essere utilizzate contemporaneamente, ma attenzione: la durata massima di attesa è quella maggiore tra le due
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()

In the above example, we set implicit and explicit waits, in other operations, implicit waiting plays a decisive role, in WebDriverWait.. explicit waiting plays a main role, but it should be noted that: the longest waiting time depends on the larger of the two, in this case it is 20, if the implicit waiting time is greater than the explicit waiting time, then the longest waiting time of this sentence of code is equal to the implicit waiting time.

We mainly use the WebDriverWait class and the expected_conditions module, let's take a detailed look at these two modules:

WebDriverWait

The WebDriverWait class in the wait module is an explicit wait class, let's take a look at what parameters and methods it has:

selenium.webdriver.support.wait.WebDriverWait (class)
__init__
  driver: Pass in a WebDriver instance, that is, the driver in our previous example
  timeout: Timeout time, the longest waiting time (considering the implicit waiting time as well)
  poll_frequency: The interval time for calling the method in until or until_not, the default is 0.5 seconds
  ignored_exceptions: Exceptions to be ignored, if this tuple of exceptions is thrown during the call to until or until_not,
      then do not interrupt the code, continue to wait, if the exception thrown is not in this tuple, then interrupt the code and throw the exception. The default is NoSuchElementException.
until
  method: During the waiting period, call this passed-in method at regular intervals until the return value is not False
  message: If a timeout occurs, throw TimeoutException, pass the message into the exception
until_not is the opposite of until, until is executed when an element appears or a condition is met,
    until_not is executed when an element disappears or a condition does not hold, the parameters are the same, no longer elaborated.
  method
  message

After reading the above content, it is basically clear, the calling method is as follows:

WebDriverWait(driver, timeout, polling_frequency, ignored_exceptions).until(executable_method, timeout_message)

It is especially important to pay attention to the executable method parameter method in until or until_not, as many people pass in a WebElement object, as follows:

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

Questo è un uso errato, i parametri devono essere chiamabili, ossia l'oggetto deve avere il metodo __call__(), altrimenti viene lanciata un'eccezione:

TypeError: 'xxx' oggetto non è callable

In questo caso, puoi utilizzare vari condizionamenti del modulo expected_conditions forniti da selenium, come i metodi is_displayed() ,is_enabled() ,is_selected() del WebElement, o puoi utilizzare i metodi che tu stesso hai encapsulato, quindi diamo un'occhiata ai condizionamenti forniti da selenium:

expected_conditions

expected_conditions è un modulo di selenium, che contiene una serie di condizioni disponibili per la giudiazione:
selenium.webdriver.support.expected_conditions（modulo）
Queste due condizioni di condizione verificano il title, verificano se il parametro title è uguale o contiene driver.title
title_is
title_contains
Queste due condizioni verificano se un elemento appare, i parametri passati sono di tipo tupla locator, come (By.ID, 'kw')
Come suggerisce il nome, una passa se viene caricato almeno un elemento che soddisfa i requisiti; l'altra richiede che vengano caricati tutti gli elementi che soddisfano i requisiti
presence_of_element_located
presence_of_all_elements_located
Queste tre condizioni verificano se un elemento è visibile, i primi due parametri sono di tipo tupla locator, il terzo è un WebElement
Il primo e il terzo sono essenzialmente uguali
visibility_of_element_located
invisibility_of_element_located
visibility_of
Queste due condizioni giudicano se un testo specifico appare in un elemento, una giudica il testo dell'elemento, l'altra il valore dell'elemento
text_to_be_present_in_element
text_to_be_present_in_element_value
Questa condizione giudica se frame può essere interrotto, può essere passata una tupla locator o direttamente un metodo di localizzazione: id, name, index o WebElement
frame_to_be_available_and_switch_to_it
Questa condizione giudica se c'è un alert presente
alert_is_present
Questa condizione giudica se un elemento è cliccabile, passing locator
element_to_be_clickable
Queste quattro condizioni giudicano se un elemento è selezionato, la prima condizione passing oggetto WebElement, la seconda condizione passing tuple locator
La terza condizione passing oggetto WebElement e stato, se sono uguali restituisce True, altrimenti False
La quarta condizione passing locator e stato, se sono uguali restituisce True, altrimenti False
element_to_be_selected
element_located_to_be_selected
element_selection_state_to_be
element_located_selection_state_to_be
L'ultima condizione giudica se un elemento è ancora nel DOM, passing WebElement oggetto, può giudicare se la pagina è stata ricaricata
staleness_of

Sopra ci sono tutte le 17 condizioni, combinate con until, until_not, possono realizzare molte giudizi, se possono essere encapsulate in modo flessibile, miglioreranno notevolmente la stabilità dello script.

Oggi condivide queste informazioni, se hai domande puoi lasciare un commento per farmi sapere, spero di aiutare chi ha bisogno. Grazie per il supporto a questo sito!

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright è dell'autore originale, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.