Phenquestions
Il motivo per cui ciò accade è che il driver web Selenium deve scaricare la pagina web e completare il rendering della pagina prima che tu possa fare qualsiasi cosa su di essa. In passato, il server web generava il contenuto di un sito Web e il browser lo scaricava e lo visualizzava. In questi giorni abbiamo molte app web a pagina singola che funzionano in modo leggermente diverso. Nelle app Web a pagina singola (SPA), il server web serve solo i codici frontend. Una volta che il codice frontend è stato reso sul browser, il codice frontend utilizza AJAX per richiedere i dati API al server web. Una volta che il frontend riceve i dati API, li visualizza sul browser. Quindi, anche se il browser ha terminato il download e il rendering della pagina Web, la pagina Web non è ancora pronta. Devi aspettare che riceva i dati API e li renderà anche loro. Quindi, la soluzione a questo problema è aspettare che i dati siano disponibili prima di fare qualsiasi cosa con Selenium.
In Selenium ci sono 2 tipi di attese:
1) Attesa implicita
2) Attesa esplicita
1) Attesa implicita: Questo è il più facile da implementare. Un'attesa implicita indica al driver Web Selenium di attendere alcuni secondi affinché il DOM (modello a oggetti documento) sia pronto (la pagina Web sia pronta).
2) Attesa esplicita: Questo è un po' complesso rispetto all'attesa implicita. In attesa esplicita, dici al driver web Selenium cosa aspettare. Il selenio attende che quella specifica condizione sia soddisfatta. Una volta completato, il driver web Selenium sarà pronto per ricevere altri comandi. Di solito, il tempo di attesa esplicito è variabile. Dipende da quanto velocemente le condizioni sono soddisfatte. Nello scenario peggiore, l'attesa esplicita aspetterà quanto l'attesa implicita.
In questo articolo, ti mostrerò come aspettare (implicito ed esplicito) che una pagina venga caricata con Selenium. Quindi iniziamo.
Prerequisiti:
Per provare i comandi e gli esempi di questo articolo, devi avere,
1) Una distribuzione Linux (preferibilmente Ubuntu) installata sul tuo computer.
2) Python 3 installato sul tuo computer.
3) PIP 3 installato sul tuo computer.
4) Pitone virtualenv pacchetto installato sul tuo computer.
5) Browser web Mozilla Firefox o Google Chrome installati sul tuo computer.
6) Deve sapere come installare Firefox Gecko Driver o Chrome Web Driver.
Per soddisfare i requisiti 4, 5 e 6, leggi il mio articolo Introduzione al selenio con Python 3 su Linuxhint.come.
Puoi trovare molti articoli sugli altri argomenti su LinuxHint.come. Assicurati di controllarli se hai bisogno di assistenza.
Configurazione di una directory di progetto:
Per mantenere tutto organizzato, crea una nuova directory di progetto selenio-attesa/ come segue:
$ mkdir -pv selenium-wait/drivers
Vai a selenio-attesa/ directory del progetto come segue:
$ cd selenio-attesa/
Crea un ambiente virtuale Python nella directory del progetto come segue:
$ virtualenv .venv
Attiva l'ambiente virtuale come segue:
$ fonte .venv/bin/activate
Installa Selenium usando PIP3 come segue:
$ pip3 installa selenio
Scarica e installa tutti i driver web necessari nel autisti/ directory del progetto. Ho spiegato il processo di download e installazione dei driver web nel mio articolo Introduzione al selenio con Python 3. Se hai bisogno di assistenza, cerca su LinuxSuggerimento.come per quell'articolo.
Userò il browser web Google Chrome per la dimostrazione in questo articolo. Quindi, userò il chromedriver binario da autisti/ directory.
Lavorare con l'attesa implicita:
Per sperimentare l'attesa implicita, crea un nuovo script Python ex01.pi nella directory del tuo progetto e digita le seguenti righe di codici in quel file.
dal webdriver di importazione del seleniodal selenio.webdriver.Comune.chiavi di importazione chiavi
opzioni = driver web.Opzioni Chrome()
opzioni.senza testa = Vero
browser = driver web.Chrome(executable_path="./drivers/chromeddriver", opzioni=opzioni)
browser.implicitly_wait(10)
browser.get("https://www.unixtimestamp.com/")
timestamp = browser.find_element_by_xpath("//h3[@class='text-danger'][1]")
print('Timestamp attuale: %s' % (timestamp.testo.dividere(")[0]))
browser.vicino()
Una volta che hai finito, salva il ex01.pi Script Python.
Le linee 1 e 2 importano tutti i componenti di selenio richiesti.
La riga 4 crea un oggetto Opzioni di Chrome.
La linea 5 abilita la modalità headless per il driver web di Chrome.
La riga 7 crea un oggetto del browser Chrome utilizzando il chromedriver binario da autisti/ directory.
La riga 8 viene utilizzata per dire a Selenium di attendere implicitamente 10 secondi utilizzando il tasto implicitly_wait() metodo del browser.
La linea 10 carica il www.unixtimestamp.com nel browser.
La riga 12 trova l'elemento timestamp utilizzando il selettore XPath //h3[@class='text-pericolo'][1] e lo memorizza nel marca temporale variabile.
Ho ottenuto il selettore XPath dallo strumento per sviluppatori di Chrome. Come puoi vedere, il timestamp è nel primo h3 elemento con il nome della classe testo-pericolo. Ci sono 2 h3 elementi con la classe testo-pericolo.
La riga 13 stampa solo il timestamp dall'elemento che ho selezionato utilizzando il selettore XPath e memorizzato nel marca temporale variabile.
La riga 14 chiude il browser.
Una volta che hai finito, esegui lo script Python ex01.pi come segue:
$ python3 ex01.pi
Come puoi vedere, il timestamp corrente viene estratto da unixtimestamp.com e stampato sulla console.
Lavorare con l'attesa esplicita:
Per sperimentare l'attesa esplicita, crea un nuovo script Python ex02.pi nella directory del tuo progetto e digita le seguenti righe di codici in quel file.
dal webdriver di importazione del seleniodal selenio.webdriver.Comune.chiavi di importazione chiavi
dal selenio.webdriver.Comune.per importazione da
dal selenio.webdriver.supporto.ui import WebDriverWait
dal selenio.webdriver.supporta l'importazione di condizioni_aspettate
opzioni = driver web.Opzioni Chrome()
opzioni.senza testa = Vero
browser = driver web.Chrome(executable_path="./drivers/chromeddriver", opzioni=opzioni)
browser.get("https://www.unixtimestamp.com/")
provare:
timestamp = WebDriverWait(browser, 10).fino a(
condizioni_aspettate.presenza_di_elemento_located((Per.XPATH, "
//h3[@class='text-danger'][1]"))
)
print('Timestamp attuale: %s' % (timestamp.testo.dividere(")[0]))
finalmente:
browser.vicino()
Una volta che hai finito, salva il ex02.pi Script Python.
La riga 1-5 importa tutti i componenti richiesti dalla libreria Selenium.
La riga 7 crea un oggetto Opzioni di Chrome.
La linea 8 abilita la modalità headless per il driver web di Chrome.
La riga 10 crea un oggetto del browser Chrome utilizzando il chromedriver binario da autisti/ directory.
La linea 12 carica il www.unixtimestamp.com nel browser.
L'attesa esplicita è implementata nel blocco try-finally (dalla riga 14-20)
La riga 15-17 usa crea WebDriverAttendi() oggetto. Il primo argomento di WebDriverAttendi() è l'oggetto browser e il secondo argomento è il tempo massimo consentito (scenario peggiore) per soddisfare la condizione, che in questo caso è 10 secondi.
Nel fino a() bloccare, condizioni_aspettate.presenza_di_elemento_situato() viene utilizzato per assicurarsi che l'elemento sia presente prima di tentare di selezionare l'elemento. Qui, Di.XPATH è usato per dire al presenza_di_elemento_situato() metodo che abbiamo utilizzato un selettore XPath per selezionare l'elemento. Il selettore XPath è //h3[@class='text-pericolo'][1].
Una volta trovato l'elemento, viene memorizzato nella cartella marca temporale variabile.
La riga 18 stampa solo il timestamp dell'elemento selezionato.
Infine, la riga 19-20 chiude il browser.
Una volta che hai finito, esegui il ex02.pi Script Python come segue:
$ python3 ex02.pi
Come puoi vedere, il timestamp corrente da unixtimestamp.com è stampato sulla console.
Selezione di elementi nelle attese esplicite:
Nella sezione precedente, ho usato Di.XPATH per selezionare l'elemento utilizzando il selettore XPath. Puoi anche selezionare gli elementi usando ID, nome tag, nome classe CSS, selettore CSS, ecc.
Di seguito sono riportati i metodi di selezione supportati:
Di.XPATH - Seleziona elemento/elementi utilizzando il selettore XPath.
Di.NOME DELLA CLASSE - Seleziona elemento/elementi usando il nome della classe CSS.
Di.CSS_SELECTOR - Seleziona elemento/elementi utilizzando il selettore CSS.
Di.ID - Seleziona elemento per ID by
Di.NOME - Seleziona elemento/elementi per nome.
Di.TAG_NAME - Seleziona elemento/elementi in base al nome del tag HTML.
Di.LINK_TEXT - Seleziona elemento/elementi tramite il testo del collegamento di un (ancora) tag HTML.
Di.PARTIAL_LINK_TEXT - Seleziona elemento/elementi tramite il testo del collegamento parziale di un (ancora) tag HTML.
Per ulteriori informazioni su questi, visita la pagina di documentazione dell'API Python Selenium.
Condizioni previste nelle attese esplicite:
Nell'esempio di attesa esplicita precedente, ho usato il presenza_di_elemento_situato() metodo di condizioni_aspettate come condizione di attesa esplicita per assicurarsi che l'elemento che stavo cercando esista prima di selezionarlo.
Ci sono altri condizioni_aspettate puoi usare come condizione di attesa esplicita. Alcuni di loro sono:
title_is (titolo) - controlla se il titolo della pagina è titolo.
title_contains(partial_title) - controlla se il titolo della pagina contiene una parte del titolo parziale_titolo.
visibilità_di(elemento) - controlla se il elemento è visibile nella pagina cioè l'elemento ha larghezza e altezza maggiori di 0.
visibilità_di_elemento_located(locatore) -
presenza_di_elemento_located(locatore) - Assicurarsi che l'elemento localizzato (tramite il localizzatore) è presente nella pagina. Il localizzatore è una tupla di (Da, selettore), come ho mostrato nell'esempio di attesa esplicita.
presenza_di_tutti_elemento_situato() - Si assicura che tutti gli elementi corrisposti da localizzatore è presente nella pagina. Il localizzatore è un (Da, selettore) tupla.
text_to_be_present_in_element(locatore, testo) - Controlla se il testo è presente nell'elemento situato da localizzatore. Il localizzatore è un (Da, selettore) tupla.
element_to_be_clickable(localizzatore) - Verifica se l'elemento localizzato dal localizzatore è visibile e cliccabile. Il localizzatore è un (Da, selettore) tupla.
element_to_be_selected(locatore) - Verifica se l'elemento localizzato dal localizzatore è selezionato. Il localizzatore è un (Da, selettore) tupla.
alert_is_present() - aspettati che nella pagina sia presente una finestra di avviso.
Ce ne sono molti altri condizioni_aspettate disponibile per l'uso. Per ulteriori informazioni su questi, visita la pagina di documentazione dell'API Python Selenium.
Conclusione:
In questo articolo ho discusso delle attese implicite ed esplicite di Selenium. Ti ho anche mostrato come lavorare con un'attesa implicita ed esplicita. Dovresti sempre provare a utilizzare l'attesa esplicita nei tuoi progetti Selenium poiché Selenium cercherà di ridurre il tempo di attesa il più possibile. In questo modo, non dovrai attendere un numero specifico di secondi ogni volta che esegui i tuoi progetti Selenium. L'attesa esplicita dovrebbe far risparmiare molti secondi.
Per maggiori informazioni su Selenium waits, visita la pagina ufficiale della documentazione di Selenium Python Library waits.
