Mentre l'automazione Web o la raschiatura Web con il driver Web Selenium, è possibile affrontare problemi come l'elemento che si desidera selezionare non è disponibile o il pulsante che si desidera premere non è pronto per essere cliccata e così via.

Il motivo per cui ciò accade è che il driver web Selenium deve scaricare la pagina web e terminare la rendering della pagina prima di poter fare qualsiasi cosa su di essa. In passato, il server Web ha generato il contenuto di un sito Web e il browser lo ha appena scaricato e lo ha reso. In questi giorni abbiamo molte app Web single-pagine che funzionano in modo leggermente diverso. Nelle app Web single page (SPAS), il server Webs 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 rende sul browser. Quindi, anche se il browser ha finito di scaricare e rendere la pagina web, la pagina web non è ancora pronta. Devi aspettare che riceva i dati API e renderli anche. Quindi, la soluzione a questo problema è attendere che i dati siano disponibili prima di fare qualsiasi cosa con selenio.

In selenio, ci sono 2 tipi di attese:
1) Aspetta implicita
2) attesa esplicita

1) Aspetta implicita: Questo è il più semplice da implementare. Un'attesa implicita indica al driver web Selenium di attendere diversi secondi affinché il modello DOM (Document Object) sia pronto (la pagina Web sia pronta).

2) Aspetta esplicita: Questo è un po 'complesso rispetto all'attesa implicita. In esplicito attesa, dici al Web Driver di Selenium cosa aspettare. Selenio attende che quella condizione specifica sia soddisfatta. Una volta adempiuto, il driver web Selenium sarà pronto a prendere altri comandi. Di solito, il tempo di attesa esplicito è variabile. Dipende dalla velocità con cui le condizioni sono soddisfatte. Nello scenario peggiore, l'attesa esplicita aspetterà fintanto che l'attesa implicita.

In questo articolo, ti mostrerò come aspettare (implicito ed esplicito) che una pagina carichi con selenio. 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) Python Virtualenv pacchetto installato sul tuo computer.
5) Mozilla Firefox o browser Web di Google Chrome installati sul tuo computer.
6) Deve sapere come installare il driver GECKO Firefox o il driver Web Chrome.

Per soddisfare i requisiti 4, 5 e 6, leggi il mio articolo Introduzione al selenio con Python 3 a Linuxhint.com.

Puoi trovare molti articoli sugli altri argomenti su Linuxhint.com. Assicurati di verificarli se hai bisogno di assistenza.

Impostazione di una directory del progetto:

Per mantenere tutto organizzato, crea una nuova directory di progetto Selenium-Wait/ come segue:

$ MKDIR -PV Selenium -Wait/Driver

Navigare verso il Selenium-Wait/ Directory del progetto come segue:

$ cd selenio-wait/

Crea un ambiente virtuale Python nella directory del progetto come segue:

$ virtualenv .Venv

Attiva l'ambiente virtuale come segue:

$ fonte .venv/bin/attiva

Installa il selenio utilizzando PIP3 come segue:

$ PIP3 Installa selenio

Scarica e installa tutto il driver Web richiesto in autisti/ directory del progetto. Ho spiegato il processo di download e installazione di Web driver nel mio articolo Introduzione al selenio con Python 3. Se hai bisogno di assistenza, cerca Linuxhint.com per quell'articolo.

Utilizzerò il browser Web di Google Chrome per la dimostrazione in questo articolo. Quindi, userò il Chromedriver binario dal autisti/ directory.

Lavorare con l'attesa implicita:

Per sperimentare l'attesa implicita, crea un nuovo script Python ex01.Py nella directory del progetto e digita le seguenti righe di codici in quel file.

dal webdriver di import selenio
da selenio.Webdriver.comune.tasti di importazione delle chiavi
Opzioni = WebDriver.Chromeoptions ()
opzioni.senza testa = vero
browser = webdriver.Chrome (Executable_Path = "./driver/chromedriver ", options = options)
browser.implicitamente_wait (10)
browser.get ("https: // www.UnixTimestamp.com/")
timestamp = browser.find_element_by_xpath ("// h3 [@class = 'text-danger'] [1]")
Stampa ('Timestamp corrente: % s' % (timestamp.testo.split (") [0]))
browser.vicino()

Una volta che hai finito, salva il ex01.Py Script di Python.

La linea 1 e 2 importano tutti i componenti di selenio richiesti.

La riga 4 crea un oggetto Opzioni Chrome.

La riga 5 abilita la modalità senza testa per il driver Web Chrome.

La riga 7 crea un oggetto browser cromato usando il Chromedriver binario dal autisti/ directory.

La riga 8 viene utilizzata per dire a selenio di attendere implicitamente 10 secondi usando il implicitly_wait () Metodo del browser.

La riga 10 carica il www.UnixTimestamp.com nel browser.

La riga 12 trova l'elemento timestamp usando il selettore XPath // h3 [@class = 'text-danger'] [1] e lo memorizza nel timestamp variabile.

Ho ottenuto il selettore XPath dallo strumento Chrome Developer. Come puoi vedere, il timestamp è nel primo H3 Elemento con il nome di classe canale di testo. Ce ne sono 2 H3 elementi con la classe canale di testo.

La riga 13 stampica solo il timestamp dall'elemento che ho selezionato utilizzando il selettore XPath e memorizzato in timestamp variabile.

La riga 14 chiude il browser.

Una volta che hai finito, esegui lo script Python ex01.Py come segue:

$ Python3 Ex01.Py

Come puoi vedere, l'attuale timestamp viene estratto da UnixTimestamp.com e stampato sulla console.

Lavorare con un'attesa esplicita:

Per sperimentare l'attesa esplicita, crea un nuovo script Python ex02.Py nella directory del progetto e digita le seguenti righe di codici in quel file.

dal webdriver di import selenio
da selenio.Webdriver.comune.tasti di importazione delle chiavi
da selenio.Webdriver.comune.per importazione da
da selenio.Webdriver.supporto.UI Import WebDriverwait
da selenio.Webdriver.Supporta l'importazione previsto_conditions
Opzioni = WebDriver.Chromeoptions ()
opzioni.senza testa = vero
browser = webdriver.Chrome (Executable_Path = "./driver/chromedriver ", options = options)
browser.get ("https: // www.UnixTimestamp.com/")
Tentativo:
Timestamp = WebDriverWait (browser, 10).Fino a(
previsto_conditions.presenza_of_element_located ((da.XPath, "
// h3 [@class = 'text-danger'] [1] "))
)
Stampa ('Timestamp corrente: % s' % (timestamp.testo.split (") [0]))
Finalmente:
browser.vicino()

Una volta che hai finito, salva il ex02.Py Script di Python.

La riga 1-5 importa tutti i componenti richiesti dalla libreria di selenio.

La riga 7 crea un oggetto Opzioni Chrome.

La riga 8 abilita la modalità senza testa per il driver Web Chrome.

La riga 10 crea un oggetto browser cromato usando il Chromedriver binario dal autisti/ directory.

La riga 12 carica il www.UnixTimestamp.com nel browser.

L'attesa esplicita è implementata nel blocco try-finalmente (dalla riga 14-20)

La riga 15-17 usa crea WebDriverWait () oggetto. Il primo argomento di WebDriverWait () è l'oggetto browser e il secondo argomento è il tempo massimo consentito (scenario peggiore) per soddisfare la condizione, che è 10 secondi in questo caso.

Nel Fino a() bloccare, previsto_conditions.presenza_of_element_located () il metodo viene utilizzato per assicurarsi che l'elemento sia presente prima di tentare di selezionare l'elemento. Qui, Di.Xpath è usato per dire il presenza_of_element_located () Metodo che abbiamo usato un selettore XPath per selezionare l'elemento. Il selettore XPath è // h3 [@class = 'text-danger'] [1].

Una volta trovato l'elemento, viene archiviato in timestamp variabile.

La riga 18 stampa solo il timestamp dall'elemento selezionato.

Infine, la linea 19-20 chiude il browser.

Una volta che hai finito, esegui il ex02.Py Script Python come segue:

$ Python3 Ex02.Py

Come puoi vedere, l'attuale timestamp di UnixTimeStamp.com è stampato sulla console.

Selezione di elementi in attese esplicite:

Nella sezione precedente, ho usato Di.Xpath Per la selezione dell'elemento utilizzando il selettore XPath. È inoltre possibile selezionare gli elementi utilizzando ID, nome del tag, nome della classe CSS, selettore CSS, ecc.

I metodi di selezione supportati sono riportati di seguito:

Di.Xpath - Seleziona elemento/elementi utilizzando il selettore XPath.

Di.NOME DELLA CLASSE - Seleziona elementi/elementi utilizzando il nome della classe CSS.

Di.Css_selector - Seleziona elemento/elementi utilizzando il selettore CSS.

Di.ID - Seleziona Element per ID

Di.NOME - Seleziona elemento/elementi per nome.

Di.Tag_name - Seleziona elemento/elementi per nome del tag HTML.

Di.Link_text - Seleziona elemento/elementi per testo di collegamento di UN (ancoraggio) tag HTML.

Di.Partial_link_text - Seleziona elemento/elementi mediante testo di collegamento parziale di UN (ancoraggio) tag HTML.

Per ulteriori informazioni su questi, visitare la pagina della documentazione API Python Selenio.

Condizioni attese in attese esplicite:

Nell'esempio di attesa esplicita precedente, ho usato il presenza_of_element_located () metodo di previsto_conditions Come esplicita condizione di attesa per assicurarsi che l'elemento che stavo cercando esiste prima di selezionarlo.

Ci sono altri previsto_conditions 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_title.

visibilità_of (elemento) - controlla se il elemento è visibile nella pagina che è l'elemento ha larghezza e altezza maggiore di 0.

visibilità_of_element_located (localizzatore) -

Presence_of_element_located (Locater) - Assicurati che l'elemento situato (dal localizzatore) è presente nella pagina. IL localizzatore è una tupla di (Di, selettore), Come ho mostrato nell'esempio di attesa esplicita.

presenza_of_all_element_located () - Si assicura che tutto l'elemento abbinato a localizzatore è presente nella pagina. IL localizzatore è un (Di, selettore) tupla.

text_to_be_present_in_element (locatore, testo) - Controlla se il testo è presente nell'elemento situato dal localizzatore. IL localizzatore è un (Di, selettore) tupla.

Element_to_be_Clickable (Locater) - Controlla se l'elemento situato dal localizzatore è visibile e cliccabile. IL localizzatore è un (Di, selettore) tupla.

Element_to_be_selected (Locatar) - Controlla se l'elemento situato dal localizzatore è selezionato. IL localizzatore è un (Di, selettore) tupla.

alert_is_present () - Aspettatevi che sia presente una finestra di dialogo Avviso sulla pagina.

Ce ne sono molti altri previsto_conditions Disponibile per te. Per ulteriori informazioni su questi, visitare la pagina della documentazione API Python Selenio.

Conclusione:

In questo articolo, ho discusso delle attese implicite ed esplicite di Selenio. Ti ho anche mostrato come lavorare con un'attesa implicita ed esplicita. Dovresti sempre provare a utilizzare l'attesa esplicita nei tuoi progetti di selenio poiché il selenio cercherà di ridurre il tempo di attesa il più possibile. In questo modo, non dovrai aspettare un numero specifico di secondi ogni volta che esegui i tuoi progetti di selenio. L'attesa esplicita dovrebbe salvare molti secondi.

Per ulteriori informazioni su Selenium Waits, visitare la pagina di documentazione ufficiale di Selenium Python Biblioteca.