Interprétation de trois méthodes d'attente en Python Selenium

J’ai découvert que trop de gens ne savent pas attendre. Le blogueur n’a vraiment pas pu s’empêcher de parler à tout le monde de la nécessité d’attendre aujourd’hui.

Beaucoup de personnes ont demandé dans le groupe que cette boîte déroulante ne pouvait pas être localisée, que cette boîte pop-up ne pouvait pas être localisée... divers types de ne pouvaient pas être localisés, en fait, dans la plupart des cas, il y a Il y a deux problèmes : 1. Il y a un cadre, 2 sans attendre. Comme chacun le sait, quel est l'ordre de grandeur de la vitesse d'exécution de votre code, et quel est l'ordre de grandeur de la vitesse de chargement et de rendu du navigateur C'est comme si Flash et Alto Man prenaient rendez-vous pour combattre des monstres, et puis après ? Flash est revenu du combat, il a demandé à Alto Man à propos de toi. Pourquoi tu mets toujours tes chaussures et tu ne sors pas ? Dix mille alpagas ont volé au centre du jeu. En m'intimidant parce que j'étais lent, j'ai arrêté de jouer avec toi, j'ai lancé une exception et j'ai abandonné mon choix.

Alors, comment pouvons-nous gérer la vitesse de chargement lente d'Aotuman ? Il n’y a qu’un seul moyen, c’est d’attendre. En parlant d'attente, il y a trois façons d'attendre. Laissez le blogueur les expliquer une par une :

1. L'attente forcée

La première et la plus simple et grossière. is La première façon est de forcer l'attente de sleep(xx), forçant le Flash à attendre xx fois. Que Bumpman puisse suivre la vitesse ou soit arrivé tôt, il doit attendre xx fois.

Regardez le code :

# -*- 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()

C'est ce qu'on appelle une attente forcée. Que votre navigateur ait fini de se charger ou non, le programme a terminé. pour attendre 3 secondes, une fois les 3 secondes écoulées, continuez à exécuter le code suivant. Parfois, vous pouvez attendre comme ça dans le code, mais il n'est pas recommandé de toujours utiliser cette méthode d'attente. est trop rigide et affecte sérieusement la vitesse d'exécution du programme.

2. Attente implicite

La deuxième méthode est appelée attente implicite, implicitly_wait(xx) La signification de l'attente implicite est : The Flash et Bumpman sont d'accord. D'accord, non. Peu importe où va le Flash, il doit attendre xx secondes pour Bump Man. Si Bump Man arrive dans ce délai, les deux partiront immédiatement pour combattre les monstres. Si Bump Man n'arrive pas dans le délai imparti, le Flash doit attendre xx secondes. Flashez-vous Go, puis attendez naturellement qu'Aotuman lance une exception pour vous.

Regardez le code :

# -*- 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()

L'attente invisible consiste à définir un temps d'attente maximum si la page Web est chargée dans le délai. heure spécifiée, puis exécutez l'étape suivante, sinon attendez que le délai expire, puis exécutez l'étape suivante. Notez qu'il y a ici un inconvénient, c'est-à-dire que le programme attendra que la page entière soit chargée. En d'autres termes, généralement lorsque vous voyez que le petit cercle dans la barre d'onglets du navigateur ne tourne plus, il exécutera l'étape suivante. . Mais parfois les éléments que vous voulez sur la page sont chargés depuis longtemps, mais comme certains js et d'autres choses sont très lents, je dois encore attendre que la page soit complètement terminée avant de passer à l'étape suivante. attendre que l'élément que je souhaite sortir et ensuite que dois-je faire ? Il existe un moyen, cela dépend d'une autre méthode d'attente fournie par Selenium - l'attente explicite.

Il convient de noter que l'attente implicite fonctionne pour tout le cycle du pilote, elle ne doit donc être définie qu'une seule fois. J'ai vu certaines personnes utiliser l'attente implicite comme sommeil, et elle peut être utilisée n'importe où pendant un moment. ...

3. Attente explicite

La troisième méthode consiste à attendre explicitement, WebDriverWait, avec les méthodes Until() et Until_not() de cette classe, cela Vous pouvez attendre de manière flexible en fonction des conditions de jugement. Sa signification principale est la suivante : le programme vérifie toutes les xx secondes. Si la condition est vraie, exécutez l'étape suivante. Sinon, continuez à attendre que le temps maximum défini soit dépassé, puis lancez une TimeoutException.

Regardons d'abord un exemple de code :

# -*- 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()

Dans l'exemple ci-dessus, nous définissons l'attente implicite et l'attente explicite en opération. , l'attente implicite joue un rôle déterminant, et l'attente explicite joue un rôle majeur dans WebDriverWait..., mais il faut noter que le temps d'attente le plus long dépend du plus grand des deux, dans cet exemple il est de 20, si Temps d'attente implicite > ; Temps d'attente explicite, alors le temps d'attente maximum du code est égal au temps d'attente implicite.

Nous utilisons principalement la classe WebDriverWait et le module Expected_conditions Le blogueur suivant examinera de plus près ces deux modules :

WebDriverWait

wait. module La classe WebDriverWait est une classe d'attente explicite. Jetons d'abord un coup d'œil à ses paramètres et méthodes :

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

Après avoir lu le contenu ci-dessus, c'est le cas. fondamentalement clair. La méthode d'appel est la suivante :

WebDriverWait (pilote, durée d'expiration, fréquence d'appel, ignorer l'exception).until (méthode exécutable, informations renvoyées en cas d'expiration du délai)

Spécial il faut faire attention ici. Il s'agit du paramètre de méthode exécutable dans Until ou Until_not. De nombreuses personnes transmettent l'objet WebElement, comme suit :

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

C'est une mauvaise utilisation. Les paramètres ici doivent être appelables, c'est-à-dire que cet objet doit avoir une méthode __call__(), sinon une exception sera levée :

TypeError : l'objet 'xxx' n'est pas appelable

Ici, vous pouvez utiliser diverses conditions dans le module Expected_conditions fourni par Selenium, ou vous pouvez utiliser is_displayed(), is_enabled(), is_selected( de WebElement. ), ou utiliser Vous pouvez l'encapsuler vous-même, alors jetons un coup d'œil aux conditions fournies par le sélénium :

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

Les 17 conditions ci-dessus peuvent être combinées avec jusqu'à et jusqu'à_pas pour obtenir de nombreux jugements. Si elles peuvent être encapsulées de manière flexible par elles-mêmes, la stabilité du script sera grandement améliorée.

Je partagerai ces contenus aujourd'hui. Si vous avez des questions, n'hésitez pas à me laisser un message, j'espère que cela pourra aider les étudiants dans le besoin. Merci pour votre soutien à ce site !

Pour plus d'articles liés à l'interprétation des trois méthodes d'attente de Python Selenium, veuillez faire attention au site Web PHP chinois !