Mens nettautomatisering eller nettskraping med Selenium webdriver, kan du møte problemer som at elementet du vil velge ikke er tilgjengelig, eller at knappen du vil trykke ikke er klar til å bli klikket og så videre.

Årsaken til at dette skjer er at Selenium-nettdriveren må laste ned nettsiden og fullføre gjengivelsen av siden før du kan gjøre noe på den. Tidligere genererte webserveren innholdet på et nettsted, og nettleseren bare lastet det ned og gjengitt det. I disse dager har vi mange ensides webapper som fungerer litt annerledes. I SPA-er (Single Page Web Apps) serverer webserveren bare frontend-kodene. Når frontend-koden er gjengitt i nettleseren, bruker frontend-koden AJAX til å be om API-data til webserveren. Når frontend mottar API-data, gjengis det i nettleseren. Så selv om nettleseren er ferdig med å laste ned og gjengi websiden, er nettsiden fortsatt ikke klar. Du må vente på at den skal motta API-data og gjengi dem også. Så løsningen på dette problemet er å vente på at dataene skal være tilgjengelige før vi gjør noe med Selen.

I Selen er det to typer ventetider:
1) Implisitt ventetid
2) Eksplisitt ventetid

1) Implisitt ventetid: Dette er det enkleste å implementere. En implisitt venting forteller Selenium-nettdriveren å vente i flere sekunder for at DOM (dokumentobjektmodell) skal være klar (websiden skal være klar).

2) Eksplisitt ventetid: Dette er litt komplisert enn den implisitte ventetiden. I eksplisitt venting forteller du Selenium-nettdriveren hva du skal vente på. Selen venter på at den spesifikke forutsetningen skal være oppfylt. Når den er oppfylt, vil Selenium-nettdriveren være klar til å ta andre kommandoer. Vanligvis er den eksplisitte ventetiden variabel. Det kommer an på hvor raskt forholdene er oppfylt. I verste fall vil den eksplisitte ventetiden vente så lenge den implisitte ventetiden.

I denne artikkelen skal jeg vise deg hvordan du kan vente (implisitt og eksplisitt) på at en side skal lastes inn med Selen. Så la oss komme i gang.

Forutsetninger:

For å prøve kommandoene og eksemplene til denne artikkelen må du ha,

1) En Linux-distribusjon (helst Ubuntu) installert på datamaskinen din.
2) Python 3 installert på datamaskinen din.
3) PIP 3 installert på datamaskinen din.
4) Python virtualenv pakken installert på datamaskinen din.
5) Mozilla Firefox eller Google Chrome nettlesere installert på datamaskinen din.
6) Må vite hvordan du installerer Firefox Gecko Driver eller Chrome Web Driver.

For å oppfylle kravene 4, 5 og 6, les artikkelen min Introduksjon til selen med Python 3 på Linuxhint.com.

Du kan finne mange artikler om de andre emnene på LinuxHint.com. Husk å sjekke dem ut hvis du trenger hjelp.

Sette opp en prosjektkatalog:

For å holde alt organisert, opprett en ny prosjektkatalog selen-vent / som følger:

$ mkdir -pv selen-vent / drivere

Naviger til selen-vent / prosjektkatalog som følger:

$ cd selen-vent /

Opprett et virtuelt Python-miljø i prosjektkatalogen som følger:

$ virtualenv .venv

Aktiver det virtuelle miljøet som følger:

$ kilde .venv / bin / aktiver

Installer Selen med PIP3 som følger:

$ pip3 installer selen

Last ned og installer alle nødvendige nettdrivere i drivere / katalog av prosjektet. Jeg har forklart prosessen med å laste ned og installere nettdrivere i artikkelen min Introduksjon til selen med Python 3. Hvis du trenger hjelp, kan du søke på LinuxHint.com for den artikkelen.

Jeg vil bruke Google Chrome-nettleseren til demonstrasjonen i denne artikkelen. Så jeg skal bruke chromedriver binær fra drivere / katalog.

Arbeide med implisitt ventetid:

For å eksperimentere med implisitt venting, opprett et nytt Python-skript ex01.py i prosjektkatalogen og skriv inn følgende kodelinjer i den filen.

fra selen import webdriver
fra selen.webdriver.felles.nøkler importerer nøkler
opsjoner = webdriver.ChromeOptions ()
alternativer.hodeløs = Sant
nettleser = webdriver.Chrome (executable_path = "./ drivers / chromedriver ", opsjoner = opsjoner)
nettleser.implisitt_vente (10)
nettleser.få ("https: // www.unixtimestamp.com / ")
tidsstempel = nettleser.find_element_by_xpath ("// h3 [@ class = 'text-danger'] [1]")
utskrift ('Gjeldende tidsstempel:% s'% (tidsstempel.tekst.delt (") [0]))
nettleser.Lukk()

Når du er ferdig, lagrer du ex01.py Python-skript.

Linje 1 og 2 importerer alle nødvendige Selen-komponenter.

Linje 4 oppretter et Chrome Options-objekt.

Linje 5 muliggjør hodeløs modus for Chrome-nettdriveren.

Linje 7 oppretter et Chrome-nettleserobjekt ved hjelp av chromedriver binær fra drivere / katalog.

Linje 8 brukes til å be Selen om å vente implisitt i 10 sekunder med implisitt_vente () nettlesermetode.

Linje 10 laster www.unixtimestamp.com i nettleseren.

Linje 12 finner tidsstempelelementet ved hjelp av XPath-velgeren // h3 [@ class = 'text-danger'] [1] og lagrer den i tidsstempel variabel.

Jeg har XPath-velgeren fra Chrome Developer Tool. Som du kan se, er tidsstemplet i det første h3 element med kursnavnet tekst-fare. Det er 2 h3 elementer med klassen tekst-fare.

Linje 13 skriver bare ut tidsstempelet fra elementet jeg har valgt ved hjelp av XPath-velgeren og lagret i tidsstempel variabel.

Linje 14 lukker nettleseren.

Når du er ferdig, kjører du Python-skriptet ex01.py som følger:

$ python3 ex01.py

Som du kan se, blir den nåværende tidsstempelen hentet fra unixtimestamp.com og skrives ut på konsollen.

Arbeide med eksplisitt ventetid:

For å eksperimentere med eksplisitt venting, opprett et nytt Python-skript ex02.py i prosjektkatalogen og skriv inn følgende kodelinjer i den filen.

fra selen import webdriver
fra selen.webdriver.felles.nøkler importerer nøkler
fra selen.webdriver.felles.ved import av
fra selen.webdriver.Brukerstøtte.ui importerer WebDriverWait
fra selen.webdriver.støtte import forventet_betingelser
opsjoner = webdriver.ChromeOptions ()
alternativer.hodeløs = Sant
nettleser = webdriver.Chrome (executable_path = "./ drivers / chromedriver ", opsjoner = opsjoner)
nettleser.få ("https: // www.unixtimestamp.com / ")
prøve:
tidsstempel = WebDriverWait (nettleser, 10).før(
forventet_betingelser.tilstedeværelse av elementet ((av.XPATH, "
// h3 [@ class = 'text-danger'] [1] "))
)
utskrift ('Gjeldende tidsstempel:% s'% (tidsstempel.tekst.delt (") [0]))
endelig:
nettleser.Lukk()

Når du er ferdig, lagrer du ex02.py Python-skript.

Linje 1-5 importerer alle nødvendige komponenter fra Selenium-biblioteket.

Linje 7 oppretter et Chrome Options-objekt.

Linje 8 muliggjør hodeløs modus for Chrome-nettdriveren.

Linje 10 oppretter et Chrome-nettleserobjekt ved hjelp av chromedriver binær fra drivere / katalog.

Linje 12 laster www.unixtimestamp.com i nettleseren.

Den eksplisitte ventingen er implementert i forsøksblokken (fra linje 14-20)

Linje 15-17 bruker skaper WebDriverWait () gjenstand. Det første argumentet av WebDriverWait () er nettleserobjektet, og det andre argumentet er den maksimalt tillatte tiden (worst-case scenario) for å oppfylle vilkåret, som er 10 sekunder i dette tilfellet.

I før() blokkere, forventet_betingelser.tilstedeværelse_element_lokalisert () metoden brukes for å sikre at elementet er til stede før du prøver å velge elementet. Her, Av.XPATH brukes til å fortelle tilstedeværelse av elementelokert () metoden at vi har brukt en XPath-velger for å velge elementet. XPath-velgeren er // h3 [@ class = 'text-danger'] [1].

Når elementet er funnet, lagres det i tidsstempel variabel.

Linje 18 skriver ut bare tidsstempelet fra det valgte elementet.

Endelig stenger linje 19-20 nettleseren.

Når du er ferdig, kjør ex02.py Python-skript som følger:

$ python3 ex02.py

Som du kan se, gjeldende tidsstempel fra unixtimestamp.com er trykt på konsollen.

Velge elementer i eksplisitt ventetid:

I den tidligere delen har jeg brukt Av.XPATH for å velge elementet ved hjelp av XPath-velgeren. Du kan også velge elementene ved hjelp av ID, kodenavn, CSS-klassenavn, CSS-velger osv.

De støttede valgmetodene er gitt nedenfor:

Av.XPATH - Velger element / elementer ved hjelp av XPath-velgeren.

Av.KLASSENAVN - Velger element / elementer ved hjelp av CSS-klassenavn.

Av.CSS_SELECTOR - Velger element / elementer ved hjelp av CSS-velger.

Av.ID - Velger element etter ID

Av.NAVN - Velger element / elementer etter navn.

Av.TAG_NAME - Velger element / elementer etter HTML-kodenavn.

Av.LINK_TEXT - Velger element / elementer etter lenketekst av en (anker) HTML-tag.

Av.PARTIAL_LINK_TEXT - Velger element / elementer ved delvis lenketekst av en (anker) HTML-tag.

For mer informasjon om disse, besøk Python Selenium API Documentation Page.

Forventede forhold i eksplisitt ventetid:

I det tidligere eksplisitte venteeksemplet har jeg brukt tilstedeværelse_element_lokalisert () Metode av forventet_betingelser som den eksplisitte ventetilstanden for å sikre at elementet jeg lette etter eksisterer før du valgte det.

Det er andre forventet_betingelser du kan bruke som en eksplisitt ventetilstand. Noen av dem er:

title_is (tittel) - sjekker om tittelen på siden er tittel.

title_contains (partial_title) - sjekker om tittelen på siden inneholder en del av tittelen delvis_tittel.

visibility_of (element) - sjekker om element er synlig på siden der elementet har bredde og høyde større enn 0.

visibility_of_element_located (locator) -

tilstedeværelse_ av_elementlokalisert (locator) - Forsikre deg om at elementet er plassert (ved lokalisator) er tilstede på siden. De lokalisator er en tuple av (Av, velger), som jeg har vist i det eksplisitte venteeksemplet.

tilstedeværelse_all_element_located () - Sørger for at alt elementet samsvarer med lokalisator er tilstede på siden. De lokalisator er en (Av, velger) tuple.

text_to_be_present_in_element (locator, text) - Sjekker om tekst er tilstede i elementet som ligger ved lokalisator. De lokalisator er en (Av, velger) tuple.

element_to_be_clickable (locator) - Sjekker om elementet ligger ved lokalisator er synlig og klikkbar. De lokalisator er en (Av, velger) tuple.

element_til_be_selected (locator) - Sjekker om elementet ligger ved lokalisator er valgt. De lokalisator er en (Av, velger) tuple.

alert_is_present () - forventer at en varselsdialogboks skal være til stede på siden.

Det er mange flere forventet_betingelser tilgjengelig for deg å bruke. For mer informasjon om disse, besøk Python Selenium API Documentation Page.

Konklusjon:

I denne artikkelen har jeg diskutert Seleniums implisitte og eksplisitte ventetid. Jeg har også vist deg hvordan du kan jobbe med en implisitt og eksplisitt ventetid. Du bør alltid prøve å bruke eksplisitt ventetid i Selen-prosjektene dine, ettersom Selen vil prøve å redusere ventetiden så mye som mulig. På denne måten slipper du å vente på et bestemt antall sekunder hver gang du kjører Selen-prosjektene dine. Den eksplisitte ventetiden skal spare mange sekunder.

For mer informasjon om Selenium venter, besøk den offisielle Selenium Python Library waits Documentation siden.