Selenium2+python自动化38-显式等待（WebDriverWait）

Posted 2020-10-14 小曹

前言：

在脚本中加入太多的sleep后会影响脚本的执行速度，虽然implicitly_wait()这种方法隐式等待方法一定程度上节省了很多时间。

但是一旦页面上某些js无法加载出来（其实界面元素经出来了），左上角那个图标一直转圈，这时候会一直等待的。

一、参数解释

1.这里主要有三个参数：

class WebDriverWait(object):driver, timeout, poll_frequency

2.driver:返回浏览器的一个实例，这个不用多说

3.timeout：超时的总时长

4.poll_frequency：循环去查询的间隙时间，默认0.5秒

以下是源码的解释文档（案例一个是元素出现，一个是元素消失）
    def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):
        """Constructor, takes a WebDriver instance and timeout in seconds.

           :Args:
            - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
            - timeout - Number of seconds before timing out
            - poll_frequency - sleep interval between calls
              By default, it is 0.5 second.
            - ignored_exceptions - iterable structure of exception classes ignored during calls.
              By default, it contains NoSuchElementException only.

           Example:
            from selenium.webdriver.support.ui import WebDriverWait \\n
            element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \\n
            is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\\ \\n
                        until_not(lambda x: x.find_element_by_id("someId").is_displayed())
        """

二、元素出现：until()

1.until里面有个lambda函数，这个语法看python文档吧

2.以百度输入框为例

三、元素消失：until_not（）

1.判断元素是否消失，是返回Ture,否返回False

备注：此方法未调好，暂时放这

四、参考代码：

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait

driver = webdriver.Firefox()
driver.get("http://www.baidu.com")
# 等待时长10秒，默认0.5秒询问一次
WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("kw")).send_keys("yoyo")

# 判断id为kw元素是否消失
is_disappeared = WebDriverWait(driver, 10, 1).\\
    until_not(lambda x: x.find_element_by_id("kw").is_displayed())
print is_disappeared

 

五、WebDriverWait源码

1.WebDriverWait主要提供了两个方法，一个是until(),另外一个是until_not(）

以下是源码的注释，有兴趣的小伙伴可以看下

# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import time
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import TimeoutException

POLL_FREQUENCY = 0.5  # How long to sleep inbetween calls to the method
IGNORED_EXCEPTIONS = (NoSuchElementException,)  # exceptions ignored during calls to the method


class WebDriverWait(object):
    def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):
        """Constructor, takes a WebDriver instance and timeout in seconds.

           :Args:
            - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
            - timeout - Number of seconds before timing out
            - poll_frequency - sleep interval between calls
              By default, it is 0.5 second.
            - ignored_exceptions - iterable structure of exception classes ignored during calls.
              By default, it contains NoSuchElementException only.

           Example:
            from selenium.webdriver.support.ui import WebDriverWait \\n
            element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \\n
            is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\\ \\n
                        until_not(lambda x: x.find_element_by_id("someId").is_displayed())
        """
        self._driver = driver
        self._timeout = timeout
        self._poll = poll_frequency
        # avoid the divide by zero
        if self._poll == 0:
            self._poll = POLL_FREQUENCY
        exceptions = list(IGNORED_EXCEPTIONS)
        if ignored_exceptions is not None:
            try:
                exceptions.extend(iter(ignored_exceptions))
            except TypeError:  # ignored_exceptions is not iterable
                exceptions.append(ignored_exceptions)
        self._ignored_exceptions = tuple(exceptions)

    def __repr__(self):
        return \'<{0.__module__}.{0.__name__} (session="{1}")>\'.format(
            type(self), self._driver.session_id)

    def until(self, method, message=\'\'):
        """Calls the method provided with the driver as an argument until the \\
        return value is not False."""
        screen = None
        stacktrace = None

        end_time = time.time() + self._timeout
        while True:
            try:
                value = method(self._driver)
                if value:
                    return value
            except self._ignored_exceptions as exc:
                screen = getattr(exc, \'screen\', None)
                stacktrace = getattr(exc, \'stacktrace\', None)
            time.sleep(self._poll)
            if time.time() > end_time:
                break
        raise TimeoutException(message, screen, stacktrace)

    def until_not(self, method, message=\'\'):
        """Calls the method provided with the driver as an argument until the \\
        return value is False."""
        end_time = time.time() + self._timeout
        while True:
            try:
                value = method(self._driver)
                if not value:
                    return value
            except self._ignored_exceptions:
                return True
            time.sleep(self._poll)
            if time.time() > end_time:
                break
        raise TimeoutException(message)