精华内容
下载资源
问答
  • python selenium webdriverwait
    千次阅读
    2020-04-01 16:17:34

    分享知识  传递快乐

     

    Python Selenium 显示等待 WebDriverWait 与条件判断 expected_conditions。想要使用这些条件需要引入 expected_conditions 模块,而 expected_conditions 是 selenium 中的一个模块。

     

    预期的条件

    自动化的Web浏览器中一些常用的预期条件如下:

    验证title
    title_is: 判断当前页面的title是否精确等于预期,用于验证传入的参数title是否等于driver.title
    title_contains: 判断当前页面的title是否包含预期字符串,用于验证传入的参数title是否包含于driver.title
    
    验证元素是否出现
    presence_of_element_located: 判断某个元素是否被加到了dom树里,并不代表该元素一定可见,只要一个符合条件的元素加载出来就通过,如果定位到就返回WebElement,传入的参数都是元组类型的locator,如(By.ID, 'kw')
    presence_of_all_elements_located: 判断是否至少有1个元素存在于dom树中,所有符合条件的元素都会加载出来,以列表返回
    
    验证元素是否可见
    visibility_of_element_located: 判断某个元素是否可见,可见代表元素非隐藏;传入的参数都是元组类型的locator,如(By.ID, 'kw')
    invisibility_of_element_located: 判断某个元素中是否不存在于dom或不可见,如果可见返回False,不可见返回这个元素;传入的参数都是元组类型的locator,如(By.ID, 'kw')
    visibility_of: 跟上面的方法一样,都是判断元素是否可见,只是上面的方法要传入locator,这个方法直接传定位到的WebElement,如果可见就返回这个元素。
    
    判断某段文本是否出现在某元素中
    text_to_be_present_in_element: 判断某个元素中的text是否包含了预期的字符串
    text_to_be_present_in_element_value: 判断某个元素中的value属性是否包含了预期的字符串
    
    判断frame是否可切入
    frame_to_be_available_and_switch_to_it: 判断该frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False;可传入locator元组或者直接传入定位方式:id、name、index或WebElement
    
    判断元素是否可点击
    element_to_be_clickable: 判断某个元素中是否可见并且是可点击类型,这样的话才叫clickable;如果在指定时间范围内,元素可见,就执行操作,元素不可见,就会引发TimeoutException的异常。传入的参数都是元组类型的locator,如(By.ID, 'kw')。
    
    
    判断一个元素是否仍在DOM中
    staleness_of: 等某个元素从dom树中移除,传入WebElement对象,可以判断页面是否已刷新。
    注意,这个方法也是返回True或False
    
    件判断元素是否被选中
    element_to_be_selected: 判断某个元素是否被选中,一般用在下拉列表;传入WebElement对象。
    element_located_to_be_selected: 判断某个元素是否被选中,传入locator元组
    element_selection_state_to_be: 判断某个元素的选中状态是否符合预期,传入WebElement对象以及状态,相等返回True,否则返回False
    element_located_selection_state_to_be: 判断某个元素的选中状态是否符合预期,传入locator以及状态,相等返回True,否则返回False
    
    判断是否有alert出现
    alert_is_present: 判断页面上是否存在alert,如果有就切换到alert并返回alert的内容
    

    示例说明:

    # 想要使用以下条件必须引入 expected_conditions 模块
    selenium.webdriver.support.expected_conditions
    
    # 判断title,返回布尔值
    WebDriverWait(driver,10).until(EC.title_is(u"百度一下,你就知道"))
    
    # 判断title,返回布尔值
    WebDriverWait(driver,10).until(EC.title_contains(u"百度一下"))
    
    # 判断某个元素是否被加到了dom树里,并不代表该元素一定可见,如果定位到就返回WebElement
    WebDriverWait(driver,10).until(EC.presence_of_element_located((By.ID,'kw')))
    
    # 判断某个元素是否被添加到了dom里并且可见,可见代表元素可显示且宽和高都大于0
    WebDriverWait(driver,10).until(EC.visibility_of_element_located((By.ID,'su')))
    
    # 判断元素是否可见,如果可见就返回这个元素
    WebDriverWait(driver,10).until(EC.visibility_of(driver.find_element(by=By.ID,value='kw')))
    
    # 判断是否至少有1个元素存在于dom树中,如果定位到就返回列表
    WebDriverWait(driver,10).until(EC.presence_of_all_elements_located((By.CSS_SELECTOR,'.mnav')))
    
    #判断是否至少有一个元素在页面中可见,如果定位到就返回列表
    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'百度一下'))
     
    # 判断该frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False
    WebDriverWait(driver,10).until(EC.frame_to_be_available_and_switch_to_it(locator))
    
    # 判断某个元素在是否存在于dom或不可见,如果可见返回False,不可见返回这个元素
    WebDriverWait(driver,10).until(EC.invisibility_of_element_located((By.CSS_SELECTOR,'#swfEveryCookieWrap')))
    # 注意:swfEveryCookieWrap在此页面中是一个隐藏的元素
    
    # 判断某个元素中是否可见并且是enable的,代表可点击
    WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='u1']/a[2]"))).click()
    driver.find_element_by_xpath("//*[@id='wrapper']/div[3]/a[1]").click()
    #WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='wrapper']/div[3]/a[1]"))).click()
    
    # 等待某个元素从dom树中移除
    #WebDriverWait(driver,10).until(EC.staleness_of(driver.find_element(By.ID,'su')))
    
    # 判断某个元素是否被选中了,一般用在下拉列表
    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()
    
    # 判断页面上是否存在alert,如果有就切换到alert并返回alert的内容
    instance = WebDriverWait(driver,10).until(EC.alert_is_present())
    print(instance.text)
    instance.accept()

     

     

     

     

     

     

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

    更多相关内容
  • 大致代码如下,until里的方法是自己写的len_is_true,判断输入框输入的内容长度为5,我在方法里... WebDriverWait(driver, 30, 0.5).until(len_is_true()) except TimeoutException: print ‘TimeoutException’
  • 各位好我有个问题想要询问 我使用python selenium thread模拟10个等同开启十个浏览页(webDriver) 但是发现在这个代码下 我第一个webDriver按下了按钮1 但是第二个第三个页面还没有点击按钮1 但是好像由于第一个通过...
  • 前言:目前在使用selenium过程中,对于显示等待每次使用要写很长的内容,而对于expected_condition中的条件也不是很清楚,目前自己在使用过程中,为了方便实例华调用,特定二次封装了一下WebDriverWait模块 ...

    前言:目前在使用selenium过程中,对于显示等待每次使用要写很长的内容,而对于expected_condition中的条件也不是很清楚,目前自己在使用过程中,为了方便实例化调用,特定二次封装了一下WebDriverWait模块

    # coding = utf-8
    # Author = zhaoge
    # Date: 2021/6/24 5:43 下午
    
    from selenium.webdriver.support.wait import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.common.by import By
    
    
    class ExplicitWaiting(object):
        """
        title_is                                    -判断title是否出现,返回bool类型
        title_contains                              -判断title是否包含某些字符,布尔
        presence_of_element_located                 -判断某个元素是否被加到dom树里,并不代表该元素一定可见,WebElement
        visibility_of_element_located               -判断某个元素是否被添加到了dom里并且可见,宽和高都大于0,WebElement
        visibility_of                               -判断元素是否可见,如果可见就返回这个元素,WebElement
        presence_of_all_elements_located            -判断是否至少有1个元素存在于dom树中,列表
        visibility_of_any_elements_located          -判断是否至少有一个元素在页面中可见,列表
        text_to_be_present_in_element               -判断指定的元素中是否包含了预期的字符串,布尔
        text_to_be_present_in_element_value         -判断指定元素的属性值中是否包含了预期的字符串,布尔
        frame_to_be_available_and_switch_to_it      -判断该frame是否是否可以switch进去,布尔
        invisibility_of_element_located             -判断某个元素是否存在于dom或不可见,布尔
        element_to_be_clickable                     -判断某个元素中是否可见并且是enable的,代表可点击,布尔
        staleness_of                                -等待某个元素从dom树中移除,布尔
        element_to_be_selected                      -判断某个元素是否被选中了,一般用在下拉列表,布尔
        element_selection_state_to_be               -判断某个元素的选中状态是否符合预期,布尔
        element_located_selection_state_to_be       -判断某个元素的选中状态是否符合预期,布尔
        alert_is_present                            -判断页面上是否存在alert,布尔
        """
        def __init__(self,driver,timeout=20):
            """
            :param driver: WebDriver实例
            :param timeout: 超时时间,默认20s
            """
            self.locationTypeDict = {
                "id": By.ID,
                "name": By.NAME,
                "xpath": By.XPATH,
                "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,timeout)
    
        def title_is(self,expect_title):
            """
            判断title是否出现,type is bool
            :param expect_title: 传入期待的title信息,type is string
            :return:
            """
            try:
                self._wait.until(EC.title_is(expect_title))
            except Exception as e:
                raise e
    
        def title_contains(self,expect_contain_text):
            """
            判断title是否包含某些字符
            :param expect_contain_text: 期待包含的字符,type is string
            :return:
            """
            try:
                self._wait.until(EC.title_contains(expect_contain_text))
            except Exception as e:
                raise e
    
        def presence_of_element_located(self,locationType,locatorExpression):
            """
            判断元素是否被加载到dom树里,并不代表元素一定可见
            :param locationType: 定位方法,type is string,小写字母
            :param locatorExpression: 定位器表达式
            :return:
            """
            try:
                if locationType.lower() in self.locationTypeDict:
                    self._wait.until(
                        EC.presence_of_element_located((
                            self.locationTypeDict[locationType.lower()],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def visibility_of_element_located(self,locationType,locatorExpression):
            """
            判断某个元素是否被添加到了dom里并且可见,宽和高都大于0
            :param locationType: 定位方法,type is string,小写字母
            :param locatorExpression: 定位器表达式
            :return:
            """
            try:
                if locationType.lower() in self.locationTypeDict:
                    self._wait.until(
                        EC.visibility_of_element_located((
                            self.locationTypeDict[locationType.lower()],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def visibility_of(self,locationType,locatorExpression):
            """
            判断元素是否可见,如果可见就返回这个元素
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.visibility_of(self._driver.element(
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def presence_of_all_elements_located(self,locationType,locatorExpression):
            """
            判断是否至少有一个元素存在于dom树中,如果定位到就反回列表
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.presence_of_all_elements_located((
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def visibility_of_any_elements_located(self,locationType,locatorExpression):
            """
            判断是否至少有一个元素在页面中可见,如果定位到就返回列表
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.visibility_of_any_elements_located((
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def text_to_be_present_in_element(self,locationType,locatorExpression,expect_str):
            """
            判断指定的元素之中是否包含了预期的字符串,返回布尔值
            :param locationType:
            :param locatorExpression:
            :param current_str: 元素中预期包含的字符串
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.text_to_be_present_in_element((
                            self.locationTypeDict[locationType],locatorExpression
                        ),expect_str)
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def text_to_be_present_in_element_value(self,locationType,locatorExpression,expect_str):
            """
            判断指定元素的属性值中是否包含了预期的字符串,返回布尔值
            :param locationType:
            :param locatorExpression:
            :param expect_str: 元素属性值中预期包含的字符串
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.text_to_be_present_in_element_value((
                            self.locationTypeDict[locationType],locatorExpression
                        ),expect_str)
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def frame_to_be_available_and_switch_to_it(self,locationType,locatorExpression):
            """
            判断frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.frame_to_be_available_and_switch_to_it((
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def invisibility_of_element_located(self,locationType,locatorExpression):
            """
            判断某个元素是否存在于dom或不可见,如果可见返回False,不可见返回这个元素
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.invisibility_of_element_located((
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def element_to_be_clickable(self,locationType,locatorExpression):
            """
            判断某个元素是否可见并且是enable的,是代表可点击
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.element_to_be_clickable((
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def staleness_of(self,locationType,locatorExpression):
            """
            等待某个元素从dom树移除
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.staleness_of(self._driver.find_element(
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def element_to_be_selected(self,locationType,locatorExpression):
            """
            判断某个元素是否被选中,一般用在下拉列表
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.element_to_be_selected(self._driver.find_element(
                            self.locationTypeDict[locationType],locatorExpression
                        ))
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def element_selection_state_to_be(self,locationType,locatorExpression):
            """
            判断某个元素的选中状态是否符合预期
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.element_selection_state_to_be(self._driver.find_element(
                            self.locationTypeDict[locationType],locatorExpression
                        ),True)
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def element_located_selection_state_to_be(self,locationType,locatorExpression):
            """
            判断某个元素的选中状态是否符合预期
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.element_located_selection_state_to_be((
                            self.locationTypeDict[locationType],locatorExpression
                        ),True)
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e
    
        def alert_is_present(self,locationType,locatorExpression):
            """
            判断页面上是否存在alert,如果有就切换到alert并返回alert的内容
            :param locationType:
            :param locatorExpression:
            :return:
            """
            try:
                if locationType in self.locationTypeDict:
                    self._wait.until(
                        EC.alert_is_present()
                    )
                else:
                    raise TypeError("定位方式异常,请检查定位方式是否正确")
            except Exception as e:
                raise e

    展开全文
  • #coding=utf-8 from selenium import webdriver from selenium.webdriver.common.by import By ...from selenium.webdriver.support.wait import WebDriverWait base_url = "http://www.baidu.com" driver =
    #coding=utf-8
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.support.wait import WebDriverWait
     
    base_url = "http://www.baidu.com"
    driver = webdriver.Firefox()
    driver.implicitly_wait(5)
    '''隐式等待和显示等待都存在时,超时时间取二者中较大的'''
    locator = (By.ID,'kw')
    driver.get(base_url)
     
    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的内容'''
     
     
     
    
    展开全文
  • 很多人学习python,不知道从何学起。 很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。 很多已经做案例的人,却不知道如何去学习更加高深的知识。 那么针对这三类人,我给大家提供一个好的学习...

    在自动化测试脚本的运行过程中,可以通过设置等待的方式来避免由于网络延迟或浏览器卡顿导致的偶然失败,常用的等待方式有三种:

    很多人学习python,不知道从何学起。
    很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。
    很多已经做案例的人,却不知道如何去学习更加高深的知识。
    那么针对这三类人,我给大家提供一个好的学习平台,免费领取视频教程,电子书籍,以及课程的源代码!
    QQ群:1097524789

    一、固定等待(time)

      固定待是利用python语言自带的time库中的sleep()方法,固定等待几秒。这种方式会导致这个脚本运行时间过长,不到万不得已尽可能少用。(注:脚本调试过程时,还是可以使用的,方便快捷)

    from selenium import webdriver
    import time
    
    #驱动浏览器
    driver = webdriver.Chrome()
    
    #设置窗口最大化
    driver.maximize_window()
    driver.get('https://www.baidu.com/')
    
    #设置固定等待
    time.sleep(2)
    
    driver.quit()

    二、隐式等待(implicitly_wait())

     webdriver类提供了implicitly_wait()方法来配置超时时间。隐式等待表示在自动化实施过程中,为查找页面元素或者执行命令设置一个最长等待时间。如果在规定时间内页面元素被找到或者命令被执行完成,则执行下一步,否则继续等待直到设置的最长等待时间截止

    from selenium import webdriver
    
    #驱动浏览器
    driver = webdriver.Chrome()
    
    #设置隐式等待
    driver.implicitly_wait(30)
    
    #设置窗口最大化
    driver.maximize_window()
    driver.get('https://www.baidu.com/')

       注:隐式等待的好处是不用像固定等待方法一样死等时间N秒,可以在一定程度上提升测试用例的执行效率。不过这种方法也存在一定的弊端,那就是程序会一直等待整个页面加载完成,也就是说浏览器窗口标签栏中不再出现转动的小圆圈,才会继续执行下一步。

    三、显式等待(WebDriverWait)

      显示等待会每个一段时间(该时间一般都很短,默认为0.5秒,也可以自定义),执行自定义的程序判断条件,如果判断条件成立,就执行下一步,否则继续等待,直到超过设定的最长等待时间,然后抛出TimeOutEcpection的异常信息。

    alert_is_present():判断页面是否出现alert框

    # coding:utf-8
    from selenium import webdriver
    #导入By类
    from selenium.webdriver.common.by import By
    #导入显示等待类
    from selenium.webdriver.support.ui import WebDriverWait
    #导入期望场景类
    from selenium.webdriver.support import expected_conditions
    
    driver = webdriver.Chrome()
    
    #alert_is_present():判断页面是否出现alert框
    result=WebDriverWait(driver,10).until(expected_conditions.alert_is_present())
    print(result.text)

    element_located_selection_state_to_be(locator,state):判断一个元素的状态是否是给定的选择状态

    第一个传入参数是一个定位器,定位器是一个元组(by,path);第二个传入参数表示期望的元素状态,True表示选中状态,Flase表示未选中

    #element_located_selection_state_to_be():判断一个元素的状态是否是给定的选择状态
    result=WebDriverWait(driver,10).until(expected_conditions.element_located_selection_state_to_be((By.ID,'kw'),True))

    element_selection_state_to_be(driverObject,state):判断给定的元素是否被选中

    第一个传入参数是一个webdriver对象,第二个参数是期望的元素的状态,True表示选中状态,Flase表示未选中

    #element_selection_state_to_be():判断给定的元素是否被选中
    result=WebDriverWait(driver,10).until(expected_conditions.element_selection_state_to_be((driver.find_element_by_id('kw')),True))

    element_located_to_be_selected(locator):期望某个元素处于被选中状态

    参数传入的是一个定位器

    #element_located_to_be_selected():期望某个元素处于被选中状态
    result=WebDriverWait(driver,10).until(expected_conditions.element_located_to_be_selected((By.ID,'kw')))

    element_to_be_selected():期望某个元素处于选中状态

    传入参数是一个webdriver实例对象

    #element_to_be_selected():期望某个元素处于选中状态
    result=WebDriverWait(driver,10).until(expected_conditions.element_to_be_selected(driver.find_element_by_id('kw')))

    element_to_be_clickable():判断元素是否可见并且能被单击,条件满足返回页面元素对象,否则返回Flase

    #element_to_be_clickable():判断元素是否可见并且能被单击,条件满足返回页面元素对象,否则返回Flase
    result=WebDriverWait(driver,10).until(expected_conditions.element_to_be_clickable(driver.find_element_by_id('hh')))

    frame_to_be_available_and_switch_to_it(parm):判断frame是否可用

    如果可用返回True并切入到该frame,参数parm可以是定位器locator(by,path)组成的元组,或者定位方式:id、name、index(frame在页面上索引号),或者webelement对象。

    #frame_to_be_available_and_switch_to_it():判断frame是否可用
    #传入ID值‘kk'
    result1=WebDriverWait(driver,10,0.2).until(EC.frame_to_be_available_and_switch_to_it(By.ID,'kw'))
    #传入frame的webelement对象
    result2=WebDriverWait(driver,10,0.2).until(EC.frame_to_be_available_and_switch_to_it(driver.find_element_by_id('kw')))
    #传入frame在页面中索引号
    result3=WebDriverWait(driver,10,0.2).until(EC.frame_to_be_available_and_switch_to_it(1))

    invisibility_of_element_located(locator):希望某个元素不可见或者不存在DOM中

    满足条件返回True,否则返回定位到的元素对象

    #invisibility_of_element_located():希望某个元素不可见或者不存在DOM中,满足条件返回True,否则返回定位到的元素对象
    result8=WebDriverWait(driver,10,0.2).until(EC.invisibility_of_element_located(By.ID,'kw'))

    visibility_of_element_located(locator):希望某个元素出现在DOM中并且可见

    满足条件返回该元素的页面元素对象

    #visibility_of_element_located():希望某个元素出现在DOM中并且可见,满足条件返回该元素的页面元素对象
    result9=WebDriverWait(driver,10,0.2).until(EC.visibility_of_element_located(driver.find_element_by_id('kw')))

    visibility_of(webelement):希望某个元素出现在页面的DOM中,并且可见,满足条件返回该元素的页面元素对象

    #visibility_of():希望某个元素出现在页面的DOM中,并且可见,满足条件返回该元素的页面元素对象
    result10=WebDriverWait(driver,10,0.2).until(EC.visibility_of(driver.find_element_by_id('kw'))

    visibility_of_any_elements_located(locator):希望某个元素出现在DOM中并且可见

    如果满足条件返回该元素的页面元素对象

    #visibility_of_any_elements_located():希望某个元素出现在DOM中并且可见
    result11=WebDriverWait(driver,10,0.2).until(EC.visibility_of(By.TAG_NAME,'input'))

    presence_of_all_elements_located(locator):判断页面至少有一个如果元素出现,如果满足条件,返回所有满足定位表达式的页面元素

    #presence_of_all_elements_located():判断页面至少有一个如果元素出现,如果满足条件,返回所有满足定位表达式的压面元素
    result12=WebDriverWait(driver,10,0.2).until(EC.presence_of_all_elements_located(By.ID,'kw'))

    presence_of_element_located(locator):判断某个元素是否存在DOM中,不一定可见,存在返回该元素对象

    #presence_of_element_located():判断某个元素是否存在DOM中,不一定可见,存在返回该元素对象
    result12=WebDriverWait(driver,10,0.2).until(EC.presence_of_element_located(By.ID,'kw'))

    staleness_of(webelement):判断一个元素是否仍在DOM中,如果在规定时间内已经移除返回True,否则返回Flase

    #staleness_of():判断一个元素是否仍在DOM中,如果在规定时间内已经移除返回True,否则返回Flase
    result13=WebDriverWait(driver,10,0.2).until(EC.staleness_of(driver.find_element_by_id('kw')))

    text_to_be_present_in_element():判断文本内容test是否出现在某个元素中,判断的是元素的text

    #text_to_be_present_in_element():判断文本内容test是否出现在某个元素中,判断的是元素的text
    result15=WebDriverWait(driver,10,0.2).until(EC.text_to_be_present_in_element(By.TAG_NAME,"p"))

    text_to_be_present_in_element_value():判断text是否出现在元素的value属性值中

    #text_to_be_present_in_element_value():判断text是否出现在元素的value属性值中
    result16=WebDriverWait(driver,10,0.2).until(EC.text_to_be_present_in_element_value((By.ID,'kw'),'随便'))

    title_contains():判断页面title标签的内容包含partial_title,只需要部分匹配即可

    #title_contains():判断页面title标签的内容包含partial_title,只需要部分匹配即可,包含返回True,不包含返回Flase
    result17=WebDriverWait(driver,10,0.2).until(EC.title_contains("你就知道"))

    title_is():判断页面title内容是与传入的title_text内容完全匹配

    #title_is():判断页面title内容是与传入的title_text内容完全匹配,匹配返回True,否则返回Flase
    result18=WebDriverWait(driver,10,0.2).until(EC.title_is("百度一下,你就知道"))

    到此这篇关于selenium WebDriverWait类等待机制的实现的文章就介绍到这了

    展开全文
  • seleniumWebDriverWait 与 expected_conditions 在介绍WebDriverWait之前,先说一下,在selenium中的两种等待页面加载的方式,第一种是隐式等待,在webdriver里面提供的implicitly_wait()方法,driver....
  • (1)PythonSelenium自动化测试之WebDriverWait类 在UI自动化测试中,等待的主要有三种形式,分别是: 固定等待:例如调用time模块中的sleep方法,固定等待多少秒。 隐式等待:用到的方法是implicitly_wait,隐藏...
  • 转载来自:... #coding=utf-8 from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.support import expected_conditions a
  • 最近学习selenium自动化, 由于代码执行速度过快,导致元素还没被加载出来,代码就去定位,导致报错,由于我一直使用的是time.sleep强制等待,虽然不好用,但胜在简单嘛, 但是有时设置的睡眠时间过长,大家懂的,干...
  • WebDriverWait类结合其until或者not_until方法可以实现显性等待,即通过until或者not_until的method参数把外部callable的函数或者实例传给WebDriverWait,然后进行判断。该方法通常会结合expected_conditions模块...
  • https://selenium-python.readthedocs.io/这里是引用 官網會舉出具體例子,并且把這些東西描述得非常清楚 正文: 1.等待: 隱式等待: 設置等待時間,輪詢查找元素是否出現(默認0.5),如果沒有出現抛出異常self...
  • selenium+pythonWebDriverWait使用方法

    千次阅读 2015-09-19 23:32:12
    当上传完成后,下面总大小的元素就会隐藏,当元素隐藏后,再判断上面进度,当文件上传时,显示进度条,进度到99%时,显示"处理中",上传成功后,显示"完成" ...from selenium.webdriver.support.ui imp
  • 开发环境:win10-64 python2.7.16 chrome77from selenium import webdriverdriver = webdriver.Chrome(executable_path='chromedriver.exe')driver.get('http://全部加载完成超级慢的网站')user = 'abc'pwd = '123...
  • 38、SeleniumWebDriverWait

    万次阅读 多人点赞 2018-01-08 16:27:43
    之前有篇文章介绍过Selenium的等待知识,可惜当时水平有限,只介绍了sleep和implicitly_wait的用法。今天还是补充一下WebDriverWait的知识吧。...from selenium.webdriver.support.ui import WebDriverWait fro
  • WebDriverWait(driver, 20, 0.5).until(expected_conditions.presence_of_element_located(locator)),selenium中的wait模块的WebDriverWait()方法,配合until或者until_not方法,再辅助以一些判断条件,就可以...
  • seleniumWebDriverWait类(等待机制)

    千次阅读 2021-11-24 11:21:34
    固定待是利用python语言自带的time库中的sleep()方法,固定等待几秒。这种方式会导致这个脚本运行时间过长,不到万不得已尽可能少用。(注:脚本调试过程时,还是可以使用的,方便快捷) from selenium import ...
  • python的time包提供, 导入 time 包后就可以使用。 缺点:不智能,使用太多的sleep会影响脚本运行速度。 隐式等待:implicitly_wait() driver.implicitly_wait(10) #隐式等待10秒 由webdriver提供的方法,一旦设置...
  • #coding=utf-8from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support import expected_conditions as ECfrom selenium.webdriver.support.wait import WebDri...
  • python智能等待时间:WebDriverWait的使用方法: 一、导入包的语句: from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC 二、函数中要...
  • 等待下个等待定位的元素出现,特别是web端加载的过程,都需要用到等待,而等待方式的设置是保证脚本稳定有效运行的一个非常重要的手段,在selenium中(appium通用)常用的等待分为显示等待WebDriverWait()、隐式等待...
  • 主要介绍了Python selenium模拟手动操作达到无人值守刷积分目的,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 1、显式等待from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWaitfrom selenium.webdriver.support import expected_conditions as...
  • 前言 在之前提到爬虫时,我想到的步骤大多是: 查找要爬取内容的页面的url,...但今天我发现了selenium这个工具,selenium是一套完整的web应用程序测试系统,可以用它来模拟真实浏览器进行测试。在爬虫中使用它的...
  • 主要介绍了基于python+selenium的二次封装的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 比如有这个页面:点击按钮2s后替换div <!DOCTYPE html> <... <...selenium等待条件</title> </head> <body> <script> function f() { window.setTimeout("populate

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,269
精华内容 4,907
关键字:

python selenium webdriverwait