精华内容
下载资源
问答
  • python显式等待
    2022-07-10 11:00:42

    不同点:

    1.隐式等待式全局性的,针对素有的查找元素。显式等待是局部的,只是针对一个或一组元素的查找。

    2.隐式等待可以设置查找条件。

    相同点:

    1.都是智能等待,都需要设置最长等待时间,在最长等待时间内找到了,就进行下一步操作。

    更多相关内容
  • 我的博客 网上教程挺多,看完还是没太理解,看了官方文档稍微理解了一些,在此记录。 部分观点为个人理解,请批判性阅读。如有错误,请指正,万分感谢。 参考: webdriver_waits ... selenium-python中文文档

    我的博客

    网上教程挺多,看完还是没太理解,看了官方文档稍微理解了一些,在此记录。

    部分观点为个人理解,请批判性阅读。如有错误,请指正,万分感谢。

    参考:

    webdriver_waits

    When to use explicit wait vs implicit wait in Selenium Webdriver?

    Selenium - Is it okay to mix implicit wait and explicit wait like this?

    selenium-python中文文档 5.等待事件

    Explicit Waits(显式等待)

    显示等待 是Selenium客户可以使用的命令式过程语言。它们允许您的代码暂停程序执行,或冻结线程,直到满足通过的 条件 。这个条件会以一定的频率一直被调用,直到等待超时。这意味着只要条件返回一个假值,它就会一直尝试和等待

    由于显式等待允许您等待条件的发生,所以它们非常适合在浏览器及其DOM和WebDriver脚本之间同步状态。

    为了弥补我们之前的错误指令集,我们可以使用等待来让 findElement 调用等待直到脚本中动态添加的元素被添加到DOM中:

    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.wait import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    
    driver = webdriver.Chrome()
    driver.get("https://www.baidu.com/")
    try:
        WebDriverWait(driver, timeout=5, poll_frequency=1, ignored_exceptions=None).until(
            EC.visibility_of_element_located((By.ID, "kw")), message='显式等待超时')
    finally:
        driver.quit()
    

    参数

    • timeout:超时时间(最大等待时间)
    • poll_frequency:轮询间隔(默认0.5s)
    • ignored_exceptions:忽略例外情况(None默认忽略NoSuchElementException)
    • message:自定义报错信息

    如果条件失败,例如从未得到条件为真实的返回值,等待将会抛出/引发一个叫 TimeoutException 的错误/异常。

    参考源码自己写了一个等待,实现显式等待的功能。

    from selenium.common.exceptions import TimeoutException
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.wait import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    import time
    
    
    def explicit_wait(driver, timeout, poll_frequency=0.5, message: str = None):
        end_time = time.time() + timeout
        while True:
            try:
                return driver.find_element_by_id("kw").is_displayed()
            except Exception as msg:
                error_msg = repr(msg)
            time.sleep(poll_frequency)
            if time.time() > end_time:
                break
        raise TimeoutException(message)
    
    
    driver = webdriver.Chrome()
    driver.get("https://www.baidu.com/")
    try:
        explicit_wait(driver, 5, 1, '显式等待超时')
    finally:
        driver.quit()
    

    Implicit Waits(隐式等待)

    隐式等待是告诉WebDriver如果在查找一个或多个不是立即可用的元素时轮询DOM一段时间。

    默认设置为0,表示禁用。一旦设置好,隐式等待就被设置为会话的生命周期(适用于所有driver.find_element_by_*())。

    from selenium import webdriver
    
    driver = Chrome()
    driver.implicitly_wait(10)
    driver.get("http://somedomain/url_that_delays_loading")
    my_dynamic_element = driver.find_element(By.ID, "myDynamicElement")
    

    如超过最大时间失败,等待将会抛出/引发一个叫 NoSuchElementException 的错误/异常。

    区别

    显式等待

    检查存在性、可见性、交互性和许多其他东西——动态地等待

    明确的行为表现 在本地的selenium运行(你选择的编程语言) 可以在任何你能想到的条件下工作 返回成功或者超时 可以定义元素的缺失为条件 可以定制重试间隔,可以忽略某些异常

    • 记录和定义行为。
    • 在selenium的本地部分运行(使用您的代码语言)。
    • 在任何你能想到的情况下都能工作。
    • 返回成功或超时错误。
    • 可以将缺少元素定义为成功条件。
    • 可以自定义要忽略的重试和异常之间的延迟。

    隐式等待

    只关心元素是否存在

    不明确的行为表现,同一个问题依赖于不同的操作系统,不同的浏览器,不同的selenium版本会有各种不同的表现 在远程的selenium上运行(控制浏览器的那部分). 只能在寻找元素的函数上工作 返回找到元素或者(在超时以后)没有找到 如果检查元素缺失那么总是会等待到超时 除了时间啥都不能指定

    • 未记录和实际上未定义的行为。
    • 运行在selenium的远程部分(控制浏览器的部分)。
    • 仅适用于查找元素方法。
    • 返回找到的元素或(超时后)找不到。
    • 如果检查是否缺少元素,则必须一直等到超时。
    • 除全局超时外,无法自定义。

    两个代码示例执行相同的操作。找到某个元素,10秒后找不到就放弃。隐式等待只能做到这一点。它只能尝试查找超时的元素。显式等待的优势在于它可以等待各种条件。还可以自定义超时并忽略某些异常。

    警告:

    不要混合使用隐式和显式等待。这样做会导致不可预测的等待时间。例如,将隐式等待设置为10秒,将显式等待设置为15秒,可能会导致在20秒后发生超时。

    混合使用可参考:Selenium - Is it okay to mix implicit wait and explicit wait like this?

    展开全文
  • 显式等待显式等待是你在代码中定义等待一定条件发生后再进一步执行你的代码。简单的说就是在指定时间内,一直等待某个条件成立,条件成立后立即执行定位元素的操作;如果超过这个时间条件仍然没有成立,则会抛出...

    分享知识  传递快乐

     

    现在的大多数的Web应用程序是使用Ajax或一些前端框架技术来完成加载页面,这样程序便不能确定某个元素何时才能完全加载出来。因不能确定元素被加载到浏览器的时间,这使得定位元素变得困难。

    如果程序定位某个元素时,实际页面中这个元素还未完全加载进来或元素不再页面之中,会抛出 ElementNotVisibleException 异常。为了解决这个问题,我们可以使用 selenium 提供的 waits 更好的解决这个问题。waits提供了一些操作之间的时间间隔,主要是定位元素或针对该元素的任何其他操作。

    Selenium Webdriver 提供两种类型的 waits - 隐式等待和显式等待。显式等待会让 WebDriver 等待满足一定的条件以后再进一步的执行。 而隐式等待让 Webdriver 等待一定的时间后再才是查找某元素。

    显式等待:

    显式等待是你在代码中定义等待一定条件发生后再进一步执行你的代码。简单的说就是在指定时间内,一直等待某个条件成立,条件成立后立即执行定位元素的操作;如果超过这个时间条件仍然没有成立,则会抛出异常!显式等待需要使用 selenium.webdriver.support.excepted_conditions 期望条件和 selenium.webdriver.support.ui.WebDriverWait 类来配合完成。

    隐式等待:

    隐式等待实际是设置了一个最长等待时间,如果在规定时间内网页加载完成,则执行下一步,否则一直等到时间结束,然后执行下一步。如果某些元素不是立即可用的,隐式等待是告诉 WebDriver 去等待一定的时间后去查找元素。默认等待时间是0秒,一旦设置该值,隐式等待是设置该 WebDriver 的实例的生命周期。这样的隐式等待会有个坑,有些页面的JS是放在body的最后进行加载,实际这是页面上的元素都已经加载完毕,我们却还在等待全部页面加载结束。

    需要特别说明的是:隐性等待对整个 driver 的周期都起作用,所以只要设置一次即可(在最开始设置一次就可以了),切不要当作固定等待使用。

    熟悉了什么是显式等待和隐式等待,下面就让我们来看看怎么使用这两种等待吧。

     

    1、显式等待

    显式等待是你在代码中定义等待一定条件发生后再进一步执行你的代码。

    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions
    
    driver = webdriver.Chrome()
    driver.get("url")
    
    locator = (By.ID, "你的标签ID")
    
    # 显式等待:条件成立,立即执行;超过指定时间则报错
    WebDriverWait(driver, 10).until(expected_conditions.presence_of_element_located(locator))
    driver.find_element_by_id("你的标签ID").click()
    # 或
    element = WebDriverWait(driver, 10).until(expected_conditions.presence_of_element_located((By.ID, "你的标签ID")))
    element.click()
    

    注意:传入的定位条件必须是元组形式。

    代码说明:

    WebDriverWait(driver, 10):设置了一个10秒上限的等待时间。在指定时间内,一直等待某个条件成立,条件成立后立即执行定位元素的操作;如果超过这个时间条件仍然没有成立,则会抛出 TimeoutException 异常!

    expected_conditions:后面是自动化的Web浏览器中一些常用的预期条件。请参考XXXXXXXXXXXXXXXXX

     

    WebDriverWait参数:

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

    这个模块中,一共只有两种方法 until 与 until_not:

    • until:当某元素出现或什么条件成立则继续执行
    • until_not:当某元素消失或什么条件不成立则继续执行

    until 与 until_not 参数如下:

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

     

    2、隐式等待

    如果某些元素不是立即可用的,隐式等待是告诉WebDriver去等待一定的时间后去查找元素。默认等待时间是0秒,一旦设置该值,隐式等待是设置该WebDriver的实例的生命周期。

    from selenium import webdriver
    
    driver = webdriver.Chrome()
    # 隐式等待:最长等待10秒钟往下执行
    driver.implicitly_wait(10) 
    driver.get("url")
    # 执行定位元素操作
    element = driver.find_element_by_id("标签ID")

    注意:隐式等待和显示等待都存在时,超时时间取二者中较大的。

     

     

     

     

     

     

     

     

    —————————
    如有不足请留言指正
    相互学习,共同进步

    展开全文
  • # 用于实现智能等待页面元素的出现 # encoding = utf-8 from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_...
    # 用于实现智能等待页面元素的出现
    # encoding = utf-8
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    
    class WaitUtil(object):
        def __init__(self, driver):
            self.locationTypeDict = {
                "xpath": By.XPATH,
                "id": By.ID,
                "name": By.NAME,
                "css_selector": By.CSS_SELECTOR,
                "class_name": By.CLASS_NAME,
                "tag_name": By.TAG_NAME,
                "link_text": By.LINK_TEXT,
                "partial_link_text": By.PARTIAL_LINK_TEXT
            }
            self.driver = driver
            self.wait = WebDriverWait(self.driver, 30)
    
        def presence_of_element_located(self, locationType, locatorExpression, *args):
            """
            显示等待页面元素出现在DOM中,但并不一定可见,存在则返回该页面元素对象
            :param locatorMethod:
            :param locatorExpression:
            :param arg:
            :return:
            """
            try:
                if locationType.lower() in self.locationTypeDict:
                    # if self.locationTypeDict.has_key(locatorMethod.lower()):
                    self.wait.until(
                        EC.presence_of_element_located((
                            self.locationTypeDict[locationType.lower()], locatorExpression)))
                else:
                    raise TypeError(u"未找到定位方式,请确认定位方法是否正确")
            except Exception as e:
                raise e
    
        def frame_to_be_available_and_switch_to_it(self, locationType, locatorExpression, *args):
            """
            检查frame是否存在,存在则切换进去
            :param locationType:
            :param locatorExpression:
            :param arg:
            :return:
            """
            try:
                self.wait.until(
                    EC.frame_to_be_available_and_switch_to_it((
                        self.locationTypeDict[locationType.lower()], locatorExpression)))
            except Exception as e:
                # 抛出异常信息给上层调用者
                raise e
    
        def visibility_element_located(self, locationType, locatorExpression, *args):
            """
            显示等待页面元素的出现
            :param locationType:
            :param locatorExpression:
            :param arg:
            :return:
            """
            try:
                element = self.wait.until(
                    EC.visibility_of_element_located((self.locationTypeDict[locationType.lower()], locatorExpression)))
                return element
            except Exception as e:
                raise e
    
    
    if __name__ == "__main__":
        from selenium import webdriver
        driver = webdriver.Chrome(executable_path=r"F:\automation\webdriver\chromedriver.exe")
        driver.get("http://mail.126.com")
        # 实例化WaitUtil类
        waitUtil = WaitUtil(driver)
        # 判断如果id = x-URS-iframe的iframe存在则切换进去
        wf = waitUtil.frame_to_be_available_and_switch_to_it("id", "x-URS-iframe")
        # 等待页面元素xpath = //input[@name='email']的出现
        wv = waitUtil.visibility_element_located("xpath", "//input[@name='email']")
        # 显示等待页面元素出现在DOM中,但并不一定可见,存在则返回该页面元素对象
        wp = waitUtil.presence_of_element_located("xpath", "//input[@name='email']")
        driver.quit()
        """
        WebDriverWait(driver,10).until(EC.title_is(u"百度一下,你就知道"))
        '''判断title,返回布尔值'''
        
        WebDriverWait(driver,10).until(EC.title_contains(u"百度一下"))
        '''判断title,返回布尔值'''
        
        WebDriverWait(driver,10).until(EC.presence_of_element_located((By.ID,'kw')))
        '''判断某个元素是否被加到了dom树里,并不代表该元素一定可见,如果定位到就返回WebElement'''
        
        WebDriverWait(driver,10).until(EC.visibility_of_element_located((By.ID,'su')))
        '''判断某个元素是否被添加到了dom里并且可见,可见代表元素可显示且宽和高都大于0'''
        
        WebDriverWait(driver,10).until(EC.visibility_of(driver.find_element(by=By.ID,value='kw')))
        '''判断元素是否可见,如果可见就返回这个元素'''
        
        WebDriverWait(driver,10).until(EC.presence_of_all_elements_located((By.CSS_SELECTOR,'.mnav')))
        '''判断是否至少有1个元素存在于dom树中,如果定位到就返回列表'''
        
        WebDriverWait(driver,10).until(EC.visibility_of_any_elements_located((By.CSS_SELECTOR,'.mnav')))
        '''判断是否至少有一个元素在页面中可见,如果定位到就返回列表'''
        
        WebDriverWait(driver,10).until(EC.text_to_be_present_in_element((By.XPATH,"//*[@id='u1']/a[8]"),u'设置'))
        '''判断指定的元素中是否包含了预期的字符串,返回布尔值'''
        
        WebDriverWait(driver,10).until(EC.text_to_be_present_in_element_value((By.CSS_SELECTOR,'#su'),u'百度一下'))
        '''判断指定元素的属性值中是否包含了预期的字符串,返回布尔值'''
        
        #WebDriverWait(driver,10).until(EC.frame_to_be_available_and_switch_to_it(locator))
        '''判断该frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False'''
        #注意这里并没有一个frame可以切换进去
        
        WebDriverWait(driver,10).until(EC.invisibility_of_element_located((By.CSS_SELECTOR,'#swfEveryCookieWrap')))
        '''判断某个元素在是否存在于dom或不可见,如果可见返回False,不可见返回这个元素'''
        #注意#swfEveryCookieWrap在此页面中是一个隐藏的元素
        
        WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='u1']/a[8]"))).click()
        '''判断某个元素中是否可见并且是enable的,代表可点击'''
        driver.find_element_by_xpath("//*[@id='wrapper']/div[6]/a[1]").click()
        #WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='wrapper']/div[6]/a[1]"))).click()
        
        #WebDriverWait(driver,10).until(EC.staleness_of(driver.find_element(By.ID,'su')))
        '''等待某个元素从dom树中移除'''
        #这里没有找到合适的例子
        
        WebDriverWait(driver,10).until(EC.element_to_be_selected(driver.find_element(By.XPATH,"//*[@id='nr']/option[1]")))
        '''判断某个元素是否被选中了,一般用在下拉列表'''
        
        WebDriverWait(driver,10).until(EC.element_selection_state_to_be(driver.find_element(By.XPATH,"//*[@id='nr']/option[1]"),True))
        '''判断某个元素的选中状态是否符合预期'''
        
        WebDriverWait(driver,10).until(EC.element_located_selection_state_to_be((By.XPATH,"//*[@id='nr']/option[1]"),True))
        '''判断某个元素的选中状态是否符合预期'''
        driver.find_element_by_xpath(".//*[@id='gxszButton']/a[1]").click()
        
        instance = WebDriverWait(driver,10).until(EC.alert_is_present())
        '''判断页面上是否存在alert,如果有就切换到alert并返回alert的内容'''
        print instance.text
        instance.accept()
    ···
    
    展开全文
  • 1、显式等待它指定要查找的节点,然后指定一个最长的等待时间,如果规定时间内加载出来了这个节点,就返回查找的节点;如果规定时间内没有加载出该节点,就抛出超时异常。from selenium import webdriverfrom ...
  • 1、显式等待它指定要查找的节点,然后指定一个最长的等待时间,如果规定时间内加载出来了这个节点,就返回查找的节点;如果规定时间内没有加载出该节点,就抛出超时异常。fromseleniumimportwebdriverfromselenium....
  • 浅谈隐式等待和显式等待的异同点
  • 等待时间目前有三种方法设置:显式等待,隐式等待,强制等待1,时间——显式等待(WebDriverWait类),WebDriverWait一般和until,until_not配合使用from selenium import webdriverfrom selenium.webdriver.common.by ...
  • 关于Python网络爬虫Selenium强制等待、隐式等待和显式等待的总结 from selenium import webdriver import time from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import ...
  • import unittest from selenium import webdriver from selenium.webdriver.common.by ...from selenium.webdriver.support import expected_conditions as EC #显示等待包 import time driver=webdriver.Chrome
  • python显示等待&隐式等待

    万次阅读 2019-05-29 14:24:20
    隐式等待不针对某一个元素进行等待,是全局元素等待 相关模块(类): WebDriverWait #显示等待,对元素比用 expectd_conditions #预期条件类(里面包含方法可以调用,用于显示等待) NoSuchElementException #用于隐式...
  • 通常使用方法 wait.until(EC.element_to_be_clickable((By.ID, "btn_submit"))).click() # 点击我已学完 隐式等待时间 driver.implicitly_wait(30) 作用于全局,设置最大等待时间30S 强制等待 time.sleep(5) 不...
  • 显式等待WebDriverWait()同样也是 webdirver 提供的方法。配合该类的until()和until_not()方法,能够根据判断条件而进行灵活地等待。它主要的意思就是:在设置时间内,程序每隔一段时间(默认是0.5秒)检测一次,如果...
  • Python显示等待、隐式等待和强制等待的区别 在实际使用selenium或者appium时,等待下个等待定位的元素出现,特别是web端加载的过程,都需要用到等待,而等待方式的设置是保证脚本稳定有效运行的一个非常重要的手段,...
  • python 隐式等待与显示等待

    千次阅读 2020-09-07 22:53:58
    隐式等待: 隐式等待 10秒钟 from selenium import webdriver option = webdriver.ChromeOptions() option.add_experimental_option('useAutomationExtension', False) option.add_experimental_option('...
  • 隐式等待不针对某一个元素进行等待,而是全局元素等待 --------------------------------------------- WebDriverWait--显示等待针对元素时使用 expected_conditions--预期条件类() NoSuchElementException--用于...
  • 等待概述 使用Selenium操控浏览器时,等待非常重要,因为浏览器进行渲染、执行交互都是非常耗费时间的,另外由于网络等因素,经常出现我们需要操纵的DOM元素未就绪的情况,此时经常抛出NoSuchElementException异常。...
  • '../pages/wait.html') #本地html文件 driver= webdriver.Chrome(executable_path=chrome_driver_path) driver.get('file://'+page_path) 一、等待操作 1.1显式等待 特点: 1)全局设置 对find_element、find_...
  • Selenium+Python--显式/隐式等待

    千次阅读 2018-09-17 14:24:28
    隐式等待是等页面加载,不是等元素!...一个显式等待是你定义的一段代码,用于等待某个条件发生然后再继续执行后续代码。显式等待是等元素加载!!!   from selenium import webdriver from selen...
  • 显式等待 强制等待 后面会一一介绍这三种模式的使用场景。 隐式等待 设置一个等待时间,轮询查找(默认 0.5 秒)元素是否出现,如果没出现就抛出异常。这也是最常见的等待方法。 隐式等待的作用是全局的...
  • python中是基于time模块的sleep方法。 优点: 使用非常简单,不需要考虑任何逻辑。 缺点: 1、浪费时间。 2、无法保证页面一定可以正常加载完成。 3、使用过于固定,一个流程中,会频繁使用,容易造成代码的重复度...
  • 经过查询,发现python中使用等待的方式主要有三种:硬式等待、隐式等待、显示等待等待 顾名思义,就是无条件的等待;time.sleep(2),程序执行到此,等待2S后继续执行 隐式等待 implicitly_wait(10),在范围内设定...
  • 最近学习selenium自动化, 由于代码执行速度过快,...所以打算学习一些显式等待,但是在网上看了很多博主的文章,关于显示等待的until(method)到底传入什么参数,我至今不解。所以记录下来,以供有需要的人观看。首...
  • 显式等待&隐式等待

    2020-02-18 16:01:18
    二、两个等待的区别:显式等待针对某一个特定元素,隐式等待针对全局元素 三、显示等待 1、相关模块 webDiverWait 显示等待针对元素比用 Expected conditions预期条件类(里面包含方法可以调用,用于显示等待) ...
  • 技术分享 | Web自动化之显式等待与隐式等待
  • 一、基本概念 1、隐式等待(implicitly_wait)...2、显式等待(WebDriverWait) 明确的要等到某个元素的出现或者是某个元素的可点击等条件,每隔poll_frequency=0.5(默认值)查找一下元素,等不到,就一直等,除非在规...
  • 隐式等待 定位元素时,如果能定位到元素则直接返回该元素,不触发等待; 如果不能定位到该元素,则间隔一段时间后再去定位元素;如果在达到最大时长时还没有找到指定元素,则抛出元素不存在的异常 ...
  • appium-显式等待

    2021-05-18 18:13:35
    显式等待 显示等待可以等待动态加载的ajax元素,显式等待需要使用ExpectedConditions来检查条件 一般页面上元素的呈现 title出现:首先出现title dom树出现:presence,还不完整 css出现:可见visibility js出现...
  • 强制等待: time.sleep(3) 在需要等待的操作之前加上等待时间time.sleep(3)强制等待固定时间3s。 隐式等待: driver.implicitly_wait(5)...显式等待: 显示等待的代码定义了等待条件,只有该条件触发,才执行后续代
  • 1.强制等待—sleep()设置固定休眠时间,python 的time 包提供了休眠方法sleep() ,导入time 包后就可以使用sleep()进行脚本的执行过程进行休眠。无论浏览器加载是否完成,程序都要等待设定的时间,继续执行下面的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,366
精华内容 6,146
关键字:

python显式等待