精华内容
下载资源
问答
  • python webdriverwait
    千次阅读
    2020-12-29 16:18:39

    python智能等待时间:WebDriverWait的使用方法:

    一、导入包的语句:

    from selenium.webdriver.support.ui import WebDriverWait

    from selenium.webdriver.support import expected_conditions as EC

    二、函数中要定义的语句:(在def中定义)

    driver = self.driver

    wait = WebDriverWait(driver, 10)

    三、调用的例子:

    1、输入文本内容语句例子:

    wait.until(EC.visibility_of_element_located(

    (By.XPATH, ‘//[@id=“aForm”]/div[1]/table/input[1]’))).send_keys(“111111”)

    2、点击元素的例子:

    wait.until(EC.element_to_be_clickable((By.XPATH, '//[@id=“Subnet”]’))).click()

    失败的例子:

    原执行点击方法: 定义addt=(By.XPATH,'//*[@id="panelBox"]')

    self.find_element(*self.add).click()

    智能等待点击方法:wait.until(EC.element_to_be_clickable((By.XPATH,'//* [@id="panelBox"]))).click()

    前一个定义Xpath参数,并引用,没实现;比下面的少一对括号,但添加括号报错不能执行,不添加括号执行,报错:TypeError:takes 2 positional arguments but 3 were given,所以目前选择双括号内填入元素Xpath执行。

    2019年10月15号10:33已解决:

    解决方法: wait.until(EC.visibility_of_element_located(self.

    add)).send_keys(aaaaaa")即取消self之前的*,可将元素Xpath的参数传递。

    更多相关内容
  • #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的内容'''
     
     
     
    
    展开全文
  • 前言:目前在使用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

    展开全文
  • Python Selenium 显示等待 WebDriverWait 与条件判断 expected_conditions。想要使用这些条件需要引入expected_conditions 模块,而 expected_conditions 是 selenium 中的一个模块。 预期的条件 自动化的Web...

    分享知识  传递快乐

     

    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’
  • WebDriverWait类结合其until或者not_until方法可以实现显性等待,即通过until或者not_until的method参数把外部callable的函数或者实例传给WebDriverWait,然后进行判断。该方法通常会结合expected_conditions模块...
  • 一、显示等待 所谓显示等待,是针对某一个特定的元素设置等待时间,如果在规定的时间内找到了该元素,就执行相关的操作,如果在规定的时间内没有找到该元素,在抛出异常 ...WebDriverWait所在位置:在su...
  • 显式等待WebDriverWait()同样也是 webdirver 提供的方法。配合该类的until()和until_not()方法,能够根据判断条件而进行灵活地等待。它主要的意思就是:在设置时间内,程序每隔一段时间(默认是0.5秒)检测一次,如果...
  • 首先先说明一下 具体使用的参数 : WebDriverWait(driver,timeout=程序需要等待时间,poll_frequency=每隔几秒执行until中的方法).until(method='执行什么方法,具体来做什么事情') 第一个driver是固定的参数,就是...
  • webdriver.Chrome() WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, 'wrapper'))) WebDriverWait(driver, 3).until_not(EC.presence_of_element_located((By.ID, 'wrapper1'))) 其中...
  • 在自动化测试脚本的运行过程中,可以通过设置等待的方式来避免由于网络延迟或浏览器卡顿导致的偶然失败,常用的等待方式有三种:一、固定等待(time)固定待是利用python语言自带的time库中的sleep()方法,固定等待几...
  • from selenium.webdriver.support.wait import WebDriverWait base_url = "http://www.baidu.com" driver = webdriver.Firefox() driver.implicitly_wait(5) '''隐式等待和显示等待都存在时,超时时间取二者中较大...
  • python的time包提供, 导入 time 包后就可以使用。 缺点:不智能,使用太多的sleep会影响脚本运行速度。 隐式等待:implicitly_wait() driver.implicitly_wait(10) #隐式等待10秒 由webdriver提供的方法,一旦设置...
  • appium -python -webdriverwait思考等待时间

    千次阅读 2017-08-22 17:59:38
    1.考虑到自身项目,选了appium的显式等待,等待需要的元素出现(可以设置时间范围),再进行执行 2.参考了很多资料,都比较乱不太实用,自己去官网根据文档修改了一下,目前已经可以使用 3.需要引入如下包 ...
  • python的time包提供, 导入 time 包后就可以使用。 缺点:不智能,使用太多的sleep会影响脚本运行速度。 ''' import time sleep(10) #等待10秒 二、隐式等待:implicitly_wait() ''' 由webdriver提供的方法,...
  • (1)实例化等待类:WebDriverWait(driver, timeout, poll_frequency=0.5) driver:浏览器对象 timeout:超时的时长,单位:秒 poll_frequency:检测间隔时间,默认为0.5秒 (2)判断元素是否定位成功的方法 until...
  • 在进行web自动化的时候,受页面加载速度影响比较大,常常会报element not found的错误。...在webDriver中提供了WebDriverWait类,可以智能的等待页面元素加载完成再执行操作。核心函数如下:def un...
  • python+Appium组合等待方式(显性等待)
  • (1)Python与Selenium自动化测试之WebDriverWait类 在UI自动化测试中,等待的主要有三种形式,分别是: 固定等待:例如调用time模块中的sleep方法,固定等待多少秒。 隐式等待:用到的方法是implicitly_wait,隐藏...
  • WebDriverWait类签名:class selenium.webdriver.support.wait.WebDriverWait(driver, timeout, poll_frequency=0.5, ignored_exceptions=None) 构造函数参数: driver:WebDriver 实例。必备参数。 timeout:超时...
  • 各位好我有个问题想要询问 我使用python selenium thread模拟10个等同开启十个浏览页(webDriver) 但是发现在这个代码下 我第一个webDriver按下了按钮1 但是第二个第三个页面还没有点击按钮1 但是好像由于第一个通过...
  • 1.WebDriverWait类,由webdriver提供的等待方法,格式: WebDriverWait(dirver,timeout,poll_frequency=0.5,ignored_exceptions=None)  driver:浏览器驱动  timeout:最长超时时间,默认单位秒  poll_...
  • ajax技术出现使异步加载方式呈现数据的网站越来越多,当浏览器在加载页面时,页面上的元素可能并不是同时被加载完成,这给定位元素的定位增加了困难。...一、强制等待强制等待是利用python语言自带的time库中的sle...
  • 方法) # WebDriverWait 显示等待 """ 语法: 1、直接用 WebDriverWait(driver,20,0.5).until(可执行方法,超时后返回的信息) 2、结合expected_conditions模块 WebDriverWait(driver,20,0.5).until(EC.方法) """ from...
  • 是程序就会有异常,不管是什么程序,python使用try&except语句来处理异常。try&except语句不仅仅是要让其捕获异常更重要的是让其忽略异常,因为爬虫中的绝大多数异常可能重新请求就不存在,因此,发现异常的时候将其...
  • from selenium.webdriver.support.wait import WebDriverWait class BasePage(object): def __init__(self, driver): self.driver: webdriver.Chrome = driver def find_id(self, id): ele: WebElement = ...
  • 大大的减少重复代码,使得用例书写更简洁 代码: #coding:utf-8 #封装元素方法 from selenium import webdriver from selenium.webdriver.support.ui import WebDriverWait from selenium.common.exceptions import ...

空空如也

空空如也

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

python webdriverwait