Interpretation der drei Wartemethoden in Python Selenium

Ich habe festgestellt, dass zu viele Leute nicht wissen, wie man wartet. Der Blogger konnte nicht anders, als heute allen von der Notwendigkeit des Wartens zu erzählen.

Viele Leute fragten in der Gruppe, dass dieses Dropdown-Feld nicht gefunden werden kann, dass dieses Popup-Feld nicht gefunden werden kann ... verschiedene Arten von können dort tatsächlich in den meisten Fällen nicht gefunden werden Es gibt zwei Probleme: 1. Es gibt einen Frame, 2 ohne Warten. Wie jeder weiß, wie groß ist die Ausführungsgeschwindigkeit Ihres Codes und wie groß ist die Lade- und Rendergeschwindigkeit des Browsers? Es ist, als würden Flash und Alto Man einen Termin vereinbaren, um gegen Monster zu kämpfen, und dann danach Als der Blitz vom Kampf zurückkam, fragte er Alto Man nach dir. Warum ziehst du immer noch deine Schuhe an und gehst nicht raus? Zehntausende Alpakas flogen durch die Mitte des Spiels und schikanierten mich, weil ich langsam war. Ich habe aufgehört, mit dir zu spielen, und habe meine Wahl aufgegeben.

Wie können wir also mit der langsamen Ladegeschwindigkeit von Aotuman umgehen? Es gibt nur einen Weg: Warten. Apropos Warten: Der Blogger erklärt sie nacheinander:

Erzwungenes Warten

Die erste und einfachste und gröbste Methode Die erste Möglichkeit besteht darin, das Warten auf Sleep(xx) zu erzwingen, sodass der Flash xx Zeit warten muss. Unabhängig davon, ob Bumpman mit der Geschwindigkeit mithalten kann oder zu früh angekommen ist, muss er xx Zeit warten.

Sehen Sie sich den Code an:

# -*- coding: utf-8 -*-
from selenium import webdriver
from time import sleep

driver = webdriver.Firefox()
driver.get('https://huilansame.github.io')

sleep(3) # 强制等待3秒再执行下一步

print driver.current_url
driver.quit()

Dies wird als erzwungenes Warten bezeichnet. Unabhängig davon, ob Ihr Browser den Ladevorgang abgeschlossen hat, hat das Programm dies getan Um 3 Sekunden zu warten, fahren Sie mit der Ausführung des folgenden Codes fort. Dies ist zum Debuggen manchmal sehr nützlich, es wird jedoch nicht empfohlen, diese Wartemethode zu verwenden ist zu starr und beeinträchtigt ernsthaft die Ausführungsgeschwindigkeit des Programms.

2. Implizites Warten

Die zweite Methode heißt implizites Warten, implizit_wait(xx). Die Bedeutung von implizitem Warten ist: The Flash und Bumpman waren sich einig. Okay, nein Egal wohin der Flash geht, er muss xx Sekunden auf Bump Man warten, wenn Bump Man innerhalb dieser Zeit kommt, machen sich die beiden sofort auf den Weg, um gegen die Monster zu kämpfen Flash selbst. Gehen Sie und warten Sie dann natürlich, bis Aotuman eine Ausnahme für Sie auslöst.

Sehen Sie sich den Code an:

# -*- coding: utf-8 -*-
from selenium import webdriver

driver = webdriver.Firefox()
driver.implicitly_wait(30) # 隐性等待，最长等30秒
driver.get('https://huilansame.github.io')

print driver.current_url
driver.quit()

Unsichtbares Warten bedeutet, eine maximale Wartezeit festzulegen, wenn die Webseite innerhalb geladen wird Geben Sie die angegebene Zeit ein und führen Sie dann den nächsten Schritt aus. Andernfalls warten Sie, bis die Zeit abgelaufen ist, und führen Sie dann den nächsten Schritt aus. Beachten Sie, dass es hier einen Nachteil gibt, das heißt, dass das Programm darauf wartet, dass die gesamte Seite geladen wird. Mit anderen Worten: Wenn Sie sehen, dass sich der kleine Kreis in der Browser-Tab-Leiste nicht mehr dreht, führt es normalerweise den nächsten Schritt aus Aber manchmal sind die Elemente, die Sie auf der Seite haben möchten, schon lange geladen, aber da einige js und andere Dinge sehr langsam sind, muss ich immer noch warten, bis die Seite vollständig fertig ist, bevor ich den nächsten Schritt mache Warten Sie, bis das Element herauskommt, das ich möchte, und was soll ich dann tun? Es gibt eine Möglichkeit, die von einer anderen von Selenium bereitgestellten Wartemethode abhängt – dem expliziten Warten.

Es ist zu beachten, dass das implizite Warten für den gesamten Treiberzyklus funktioniert, sodass es nur einmal eingestellt werden muss. Ich habe gesehen, dass einige Leute das implizite Warten für einen Moment verwenden ...

3. Explizites Warten

Die dritte Methode besteht darin, explizit zu warten, WebDriverWait, mit den Methoden Until() und Until_not() dieser Klasse Sie können je nach Beurteilungsbedingungen flexibel warten. Seine Hauptbedeutung ist: Das Programm prüft alle xx Sekunden. Wenn die Bedingung wahr ist, führen Sie den nächsten Schritt aus. Andernfalls warten Sie weiter, bis die festgelegte maximale Zeit überschritten ist, und lösen Sie dann eine TimeoutException aus.

Schauen wir uns zunächst ein Codebeispiel an:

# -*- 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) # 隐性等待和显性等待可以同时用，但要注意：等待的最长时间取两者之中的大者
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()

Im obigen Beispiel legen wir implizites Warten und explizites Warten fest In WebDriverWait spielt das implizite Warten eine entscheidende Rolle und das explizite Warten eine große Rolle. Es ist jedoch zu beachten, dass die längste Wartezeit vom größeren der beiden abhängt. In diesem Beispiel beträgt sie 20, wenn implizite Wartezeit > ; Explizite Wartezeit, dann ist die maximale Wartezeit des Codes gleich der impliziten Wartezeit.

Wir verwenden hauptsächlich die WebDriverWait-Klasse und das erwartete_conditions-Modul. Der folgende Blogger wird sich diese beiden Module genauer ansehen:

WebDriverWait

wait Modul Die WebDriverWait-Klasse ist eine explizite Warteklasse. Schauen wir uns zunächst ihre Parameter und Methoden an:

selenium.webdriver.support.wait.WebDriverWait（类）

__init__
  driver: 传入WebDriver实例，即我们上例中的driver
  timeout: 超时时间，等待的最长时间（同时要考虑隐性等待时间）
  poll_frequency: 调用until或until_not中的方法的间隔时间，默认是0.5秒
  ignored_exceptions: 忽略的异常，如果在调用until或until_not的过程中抛出这个元组中的异常，
      则不中断代码，继续等待，如果抛出的是这个元组外的异常，则中断代码，抛出异常。默认只有NoSuchElementException。

until
  method: 在等待期间，每隔一段时间调用这个传入的方法，直到返回值不是False
  message: 如果超时，抛出TimeoutException，将message传入异常

until_not 与until相反，until是当某元素出现或什么条件成立则继续执行，
    until_not是当某元素消失或什么条件不成立则继续执行，参数也相同，不再赘述。
  method
  message

Nachdem wir den obigen Inhalt gelesen haben, ist dies der Fall Im Grunde ist die Aufrufmethode wie folgt:

WebDriverWait(Treiber, Timeout-Dauer, Aufrufhäufigkeit, Ausnahme ignorieren).until (ausführbare Methode, bei Timeout zurückgegebene Informationen)

Speziell Hier muss darauf geachtet werden, dass es sich um den ausführbaren Methodenparameter in Until oder Until_not handelt. Viele Leute übergeben das WebElement-Objekt wie folgt:

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

Dies ist eine falsche Verwendung. Die Parameter hier müssen aufrufbar sein, das heißt, dieses Objekt muss eine __call__()-Methode haben, sonst wird eine Ausnahme ausgelöst:

TypeError: 'xxx'-Objekt ist nicht aufrufbar

Hier können Sie verschiedene Bedingungen im von Selenium bereitgestellten Modul „expected_conditions“ verwenden oder Sie können is_displayed(), is_enabled(), is_selected( von WebElement verwenden ) Methoden oder verwenden Sie können es selbst kapseln. Schauen wir uns also die von Selen bereitgestellten Bedingungen an:

expected_conditions

expected_conditions是selenium的一个模块，其中包含一系列可用于判断的条件：

selenium.webdriver.support.expected_conditions（模块）

这两个条件类验证title，验证传入的参数title是否等于或包含于driver.title
title_is
title_contains

这两个人条件验证元素是否出现，传入的参数都是元组类型的locator，如(By.ID, 'kw')
顾名思义，一个只要一个符合条件的元素加载出来就通过；另一个必须所有符合条件的元素都加载出来才行
presence_of_element_located
presence_of_all_elements_located

这三个条件验证元素是否可见，前两个传入参数是元组类型的locator，第三个传入WebElement
第一个和第三个其实质是一样的
visibility_of_element_located
invisibility_of_element_located
visibility_of

这两个人条件判断某段文本是否出现在某元素中，一个判断元素的text，一个判断元素的value
text_to_be_present_in_element
text_to_be_present_in_element_value

这个条件判断frame是否可切入，可传入locator元组或者直接传入定位方式：id、name、index或WebElement
frame_to_be_available_and_switch_to_it

这个条件判断是否有alert出现
alert_is_present

这个条件判断元素是否可点击，传入locator
element_to_be_clickable

这四个条件判断元素是否被选中，第一个条件传入WebElement对象，第二个传入locator元组
第三个传入WebElement对象以及状态，相等返回True，否则返回False
第四个传入locator以及状态，相等返回True，否则返回False
element_to_be_selected
element_located_to_be_selected
element_selection_state_to_be
element_located_selection_state_to_be

最后一个条件判断一个元素是否仍在DOM中，传入WebElement对象，可以判断页面是否刷新了
staleness_of

Die oben genannten 17 Bedingungen können mit Until und Until_Not kombiniert werden, um viele Urteile zu erzielen. Wenn sie für sich genommen flexibel gekapselt werden können, wird die Stabilität des Skripts erheblich verbessert.

Ich werde diese Inhalte heute teilen. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht. Ich hoffe, dass sie Schülern in Not helfen kann. Vielen Dank für Ihre Unterstützung dieser Seite!

Weitere Artikel zur Interpretation der drei Wartemethoden von Python Selenium finden Sie auf der chinesischen PHP-Website!