Python selenium 三种等待方式详解(必会)

Molte persone chiedono nei gruppi, non riesco a trovare la posizione di questa casella a discesa, questa finestra emergente non si trova... vari problemi di localizzazione non trovata. In realtà, nella maggior parte dei casi ci sono solo due problemi: 1 ci sono frame, 2 non è stato aggiunto l'attesa. Non si rende conto della velocità di esecuzione del tuo codice, e la velocità di caricamento e rendering del browser è quale livello, è come se Flash e Ultraman avessero un appuntamento per combattere i mostri, e poi Flash torna indietro e chiede a Ultraman perché non è uscito ancora mentre sta indossando le scarpe? Ultraman ha diecimila capre volanti nel cuore, ti fa sapere che sei lento, non vuoi giocare con te, 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, ascolta il blogger spiegare uno per uno:

1. Attesa forzata

Il primo metodo è anche il più semplice e diretto, ovvero l'attesa forzata sleep(xx), che costringe Flash a aspettare per xx secondi, indipendentemente da quanto velocemente Ultraman possa seguire o se 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 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. Dopo 3 secondi, continua a eseguire il codice seguente, è molto utile per il debug, a volte si può aspettare in questo modo nel codice, ma non si consiglia di usarlo sempre, è troppo rigido e può influenzare significativamente la velocità di esecuzione del programma.

2. Attesa nascosta

Il secondo metodo si chiama attesa nascosta, implicitly_wait(xx), il significato dell'attesa nascosta è: Flash e Ultraman hanno stabilito un accordo, indipendentemente da dove Flash vada, deve aspettare Ultraman per xx secondi. Se Ultraman arriva entro questo tempo, i due partono immediatamente per combattere i mostri. Se Ultraman non arriva entro il tempo stabilito, Flash va 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 nascosta, massimo 30 secondi
driver.get('https://huilansame.github.io')
print driver.current_url
driver.quit()

L'attesa nascosta è impostare un tempo di attesa massimo, se il caricamento della pagina web è completato entro il tempo stabilito, esegui il passo successivo, altrimenti aspetta fino a quando il tempo scade, quindi esegui il passo successivo. Attenzione, c'è un difetto qui, ovvero il programma aspetterà il completamento completo della pagina, ossia generalmente quando vedi il cerchio che gira nella barra dei tag del browser smetterà di girare, quindi esegui il passo successivo, ma a volte gli elementi che desideri sono già stati caricati, ma a causa di alcune cose come JavaScript che sono particolarmente lenti, devo aspettare che la pagina sia completamente completata per eseguire il passo successivo. Cosa posso fare quando voglio che il passo successivo venga eseguito dopo che l'elemento desiderato è apparso? C'è un modo, questo dipende da un altro modo di attesa fornito da Selenium - l'attesa esplicita wait.

Occorre specificare in particolare che l'attesa implicita ha un effetto su 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, insieme ai metodi until() e until_not() di questa classe, può attendere in modo flessibile in base alle condizioni di giudizio. Il suo significato principale è: il programma controlla ogni xx secondi, se la condizione è soddisfatta, esegue il passo successivo, altrimenti continua a attendere, fino a superare il tempo massimo impostato, quindi lancia TimeoutException.

Vediamo 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 è importante notare che il tempo di attesa massimo è il maggiore tra i 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()

Nell'esempio precedente, abbiamo impostato l'attesa implicita e l'attesa esplicita, nell'altra operazione, l'attesa implicita gioca un ruolo decisivo, nell'attesa esplicita WebDriverWait... gioca un ruolo principale, ma è importante notare che: il tempo di attesa massimo dipende dal maggiore tra i due, in questo esempio è 20, se il tempo di attesa implicita > il tempo di attesa esplicita, allora il tempo di attesa massimo di questa riga di codice è uguale al tempo di attesa implicita.

Usiamo principalmente la classe WebDriverWait e il modulo expected_conditions, il blogger vi guiderà a guardare più da vicino questi due moduli:

WebDriverWait

La classe WebDriverWait del modulo wait è una classe di attesa esplicita, vediamo quali sono i suoi parametri e metodi:

selenium.webdriver.support.wait.WebDriverWait (classe)
__init__
driver: passare l'istanza di WebDriver, ossia l'oggetto driver nel nostro esempio
timeout: tempo di timeout, la durata massima dell'attesa (tenendo conto anche del tempo di attesa implicita)
poll_frequency: intervallo di tempo tra le chiamate al metodo di until o until_not, di default è 0.5 secondi
ignored_exceptions: eccezioni ignorate, se durante la chiamata a until o until_not viene lanciata una delle eccezioni di questo tuple, il codice continua a eseguire l'attesa, se viene lanciata un'eccezione al di fuori di questo tuple, il codice viene interrotto e viene lanciata l'eccezione. Di default c'è solo NoSuchElementException.
until
method: Durante l'attesa, ogni tanto viene chiamato questo metodo passato, fino a quando il valore di ritorno non è False
message: Se si verifica un timeout, viene lanciata l'eccezione TimeoutException, il messaggio viene passato all'eccezione
until_not è l'opposto di until, until continua l'esecuzione quando un elemento appare o una condizione è soddisfatta, mentre until_not continua l'esecuzione quando un elemento scompare o una condizione non è soddisfatta, i parametri sono gli stessi, non verranno ripetuti.
method
message

Dopo aver letto il contenuto sopra menzionato, è abbastanza chiaro, il metodo di chiamata è il seguente:

WebDriverWait(driver, durata dell'attesa, frequenza di chiamata, eccezioni ignorate).until(metodo eseguibile, messaggio di ritorno in caso di timeout)

Occorre prestare particolare attenzione al metodo eseguibile method nei parametri until o until_not, molti utenti passano un oggetto WebElement, come segue:

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

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

TypeError: 'xxx' oggetto non è callable

In questo caso, puoi utilizzare vari condizioni del modulo expected_conditions fornite da selenium, utilizzare i metodi is_displayed() , is_enabled() , is_selected() del WebElement, o utilizzare i metodi auto-avvolgenti, quindi vediamo quali condizioni fornisce selenium:

expected_conditions

expected_conditions è un modulo di selenium, che contiene una serie di condizioni disponibili per la giudicazione:

selenium.webdriver.support.expected_conditions（modulo）
Queste due condizioni verificano il title, verificano se il parametro title è uguale o contiene driver.title
title_is
title_contains
Queste due condizioni verificano se l'elemento appare, i parametri passati sono locator di tipo tuple, come (By.ID, 'kw')
Come suggerisce il nome, una passa se viene caricato un elemento che soddisfa i requisiti; l'altra deve essere caricato tutti gli elementi che soddisfano i requisiti
presence_of_element_located
presence_of_all_elements_located
Queste tre condizioni verificano se l'elemento è visibile, i primi due parametri sono locator di tipo tuple, il terzo passa WebElement
In realtà, la prima e la terza sono le stesse
visibility_of_element_located
invisibility_of_element_located
visibility_of
Queste due condizioni giudicano se un pezzo di testo appare in un elemento, una giudica il testo dell'elemento, l'altra giudica il value dell'elemento
text_to_be_present_in_element
text_to_be_present_in_element_value
Questa condizione giudica se il frame è accessibile e può essere切换, può passare locator tuple o direttamente passare il modo di localizzazione: id, name, index o WebElement
frame_to_be_available_and_switch_to_it
Questa condizione giudica se appare un alert
alert_is_present
Questa condizione giudica se l'elemento è cliccabile, passando 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, passando un oggetto WebElement, può giudicare se la pagina è stata ricaricata
staleness_of

I 17 condition elencati di seguito, combinati con until e until_not, possono realizzare molte judgment, se possono essere encapsulati flessibilmente, miglioreranno notevolmente la stabilità dello script.

Come è stato introdotto dall'editor, un'analisi dettagliata delle tre modalità di attesa di Python selenium (obbligatorio), spero possa essere utile a tutti. Se avete qualsiasi domanda, lasciate un messaggio, l'editor risponderà prontamente. In questo momento, ringrazio anche tutti i sostenitori del sito di tutorial di urla!

Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, il diritto d'autore appartiene agli autori originali, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non possiede 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 i contenuti sospetti di violazione del copyright.