精华内容
下载资源
问答
  • 显示等待和隐式等待

    千次阅读 2020-03-23 23:31:58
    文章目录强制等待:sleep()隐式等待:impl...

    学习显示等待和隐式等待使用
    参考博客原址:https://blog.csdn.net/sinat_41774836/article/details/88965281

    强制等待:sleep()

    import time
    sleep(5)  #等待5秒
    

    设置固定休眠时间,单位为秒。 由python的time包提供, 导入 time 包后就可以使用。
    缺点:不智能,使用太多的sleep会影响脚本运行速度。


    隐式等待:implicitly_wait()

    driver.implicitly_wait(10) #隐式等待10秒
    

    由webdriver提供的方法,一旦设置,这个隐式等待会在WebDriver对象实例的整个生命周期起作用,它不针对某一个元素,是全局元素等待,即在定位元素时,需要等待页面全部元素加载完成,才会执行下一个语句。如果超出了设置时间的则抛出异常。

    缺点:当页面某些js无法加载,但是想找的元素已经出来了,它还是会继续等待,直到页面加载完成(浏览器标签左上角圈圈不再转),才会执行下一句。某些情况下会影响脚本执行速度。


    显示等待:WebDriverWait()

    WebDriverWait(driver,timeout,poll_frequency=0.5,ignored_exceptions=None)
    

    需要通过from selenium.webdriver.support.wait import WebDriverWait导入模块

    • driver:浏览器驱动
    • timeout:最长超时时间,默认以秒为单位
    • poll_frequency:检测的间隔步长,默认为0.5s
    • ignored_exceptions:超时后的抛出的异常信息,默认抛出NoSuchElementExeception异常。

    与until()或者until_not()方法结合使用

    WebDriverWait(driver,10).until(method,message="")
    调用该方法提供的驱动程序作为参数,直到返回值为True
    
    WebDriverWait(driver,10).until_not(method,message="")
    调用该方法提供的驱动程序作为参数,直到返回值为False
    

    在设置时间(10s)内,等待后面的条件发生。如果超过设置时间未发生,则抛出异常。在等待期间,每隔一定时间(默认0.5秒),调用until或until_not里的方法,直到它返回True或False.

    WebDriverWait与expected_conditions结合使用

    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.common.by import By
    

    wait = WebDriverWait(driver,10,0.5)
    element =waite.until(EC.presence_of_element_located((By.ID,“kw”),message="")
    # 此处注意,如果省略message=“”,则By.ID外面是两层()

    expected_conditions类提供的预期条件判断的方法

    方法 说明
    title_is 判断当前页面的 title 是否完全等于(==)预期字符串,返回布尔值
    title_contains 判断当前页面的 title 是否包含预期字符串,返回布尔值
    presence_of_element_located 判断某个元素是否被加到了 dom 树里,并不代表该元素一定可见
    visibility_of_element_located 判断元素是否可见(可见代表元素非隐藏,并且元素宽和高都不等于 0)
    visibility_of 同上一方法,只是上一方法参数为locator,这个方法参数是 定位后的元素
    presence_of_all_elements_located 判断是否至少有 1 个元素存在于 dom 树中。举例:如果页面上有 n 个元素的 class 都是’wp’,那么只要有 1 个元素存在,这个方法就返回 True
    text_to_be_present_in_element 判断某个元素中的 text 是否 包含 了预期的字符串
    text_to_be_present_in_element_value 判断某个元素中的 value 属性是否包含 了预期的字符串
    frame_to_be_available_and_switch_to_it 判断该 frame 是否可以 switch进去,如果可以的话,返回 True 并且 switch 进去,否则返回 False
    invisibility_of_element_located 判断某个元素中是否不存在于dom树或不可见
    element_to_be_clickable 判断某个元素中是否可见并且可点击
    staleness_of 等某个元素从 dom 树中移除,注意,这个方法也是返回 True或 False
    element_to_be_selected 判断某个元素是否被选中了,一般用在下拉列表
    element_selection_state_to_be 判断某个元素的选中状态是否符合预期
    element_located_selection_state_to_be 跟上面的方法作用一样,只是上面的方法传入定位到的 element,而这个方法传入 locator
    alert_is_present 判断页面上是否存在 alert

    显示等待,自定义等待条件

    #设置等待
    wait = WebDriverWait(driver,10,0.5)
    #使用匿名函数
    wait.until(lambda diver:driver.find_element_by_id('kw'))
    

    lambda的使用可另行参考python相关教程

    展开全文
  • 强制等待、显示等待和隐式等待

    千次阅读 2019-05-17 17:46:48
    selenium和appium中强制等待、显示等待和隐式等待的区别: 强制等待 time.sleep() 设置固定的线程休眠时间。 显示等待 WebDriverWait() 比如: driver = webdriver.Chrome() driver.get(...

    selenium和appium中强制等待、显示等待和隐式等待的区别:

    1. 强制等待
      time.sleep()
      设置固定的线程休眠时间。

    2. 显示等待
      WebDriverWait()
      比如:
      driver = webdriver.Chrome()
      driver.get(‘http://www.baidu.com’)
      element = WebDriverWait(driver,5,0.5).until(EC.presence_of_element_located(By.ID,‘kw’))
      element.sendkeys(‘selenium’)
      说明:显示等待是单独针对某个元素,设置一个等待时间如5秒,每隔0.5秒检查一次是否出现,如果在5秒之前任何时候出现,则继续向下,超过5秒尚未出现则抛异常。

    3. 隐式等待
      implicitly_wait()
      比如:
      driver.implicitly_wait(10)
      说明:隐式等待是全局的是针对所有元素,设置等待时间如10秒,如果10秒内出现,则继续向下,否则抛异常。可以理解为在10秒以内,不停刷新看元素是否加载出来。

    展开全文
  • selenium的页面等待有显示等待和隐式等待大多数Web应用程序都是使用Ajax和Javascript开发的。当浏览器加载页面时,我们想要与之交互的元素可能以不同的时间间隔加载。它不仅难以识别元素,而且如果元素未定位,它将...

    selenium的页面等待有显示等待和隐式等待

    大多数Web应用程序都是使用Ajax和Javascript开发的。当浏览器加载页面时,我们想要与之交互的元素可能以不同的时间间隔加载。

    它不仅难以识别元素,而且如果元素未定位,它将抛出“ ElementNotVisibleException ”异常。使用Waits,我们可以解决此问题。

    隐式等待

    比较简单,提供一个等待时间,单位为秒,则等这个时间过去在去做其他操作。

    driver.implicitly_wait(10),如果不设置默认为0,隐式等待作用域是整个脚本的所有元素。

    显示等待

    指定某个条件,然后设置最长等待时间。如果在这个时间还没有找到元素,那么便会抛出异常。只有该条件触发,才执行后续代码,这个使用更灵活。 显式等待是一种智能的等待,但它只能应用于指定的元素。显式等待提供比隐式等待更好的选项,因为它将等待动态加载的Ajax元素。

    主要涉及到selenium.webdriver.support 下的expected_conditions类。

    example

    driver = webdriver.Chrome()

    driver.get("http://somedomain/url_that_delays_loading")

    try:

    element = WebDriverWait(driver, 10).until(

    EC.presence_of_element_located((By.ID, "myDynamicElement"))

    )

    finally:

    driver.quit()

    example2

    wait_result = WebDriverWait(driver=self.driver, timeout=300, poll_frequency=0.5, ignored_exceptions=None).until( EC.text_to_be_present_in_element((By.XPATH, '//*[@id="VolumeTable"]/tbody/tr[1]/td[4]/label'), u'可用'))

    这里的presence_of_element_located(())、text_to_be_present_in_element(())是其中两种方式,其实还有其他相关方式。

    EC配合使用的 until() 或者 until_not() 方法说明:

    until(method, message=’’)

    调用该方法体提供的回调函数作为一个参数,直到返回值为True

    until_not(method, message=’’)

    调用该方法体提供的回调函数作为一个参数,直到返回值为False

    模块包含一套预定义的条件集合。大大方便了 WebDriverWait 的使用。

    Expected Conditions 类提供的预期条件判断方法

    在进行浏览器自动化的时候,有一些条件是经常出现的,下面列出的是每个条件的实现。Selenium Python binding provides some convienence 提供了很多实用的方法。

    title_is:判断当前页面的title是否等于预期

    title_contains:判断当前页面的title是否包含预期字符串

    presence_of_element_located:判断某个元素是否被加到了dom树里,并不代表该元素一定可见

    visibility_of_element_located:判断某个元素是否可见. 可见代表元素非隐藏,并且元素的宽和高都不等于0

    visibility_of:跟上面的方法做一样的事情,只是上面的方法要传入locator,这个方法直接传定位到的element就好了

    presence_of_all_elements_located:判断是否至少有1个元素存在于dom树中。举个例子,如果页面上有n个元素的class都是'column-md-3',那么只要有1个元素存在,这个方法就返回True

    text_to_be_present_in_element:判断某个元素中的text是否 包含 了预期的字符串

    text_to_be_present_in_element_value:判断某个元素中的value属性是否包含了预期的字符串

    frame_to_be_available_and_switch_to_it:判断该frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False

    invisibility_of_element_located:判断某个元素中是否不存在于dom树或不可见

    element_to_be_clickable - it is Displayed and Enabled:判断某个元素中是否可见并且是enable的,这样的话才叫clickable

    staleness_of:等某个元素从dom树中移除,注意,这个方法也是返回True或False

    element_to_be_selected:判断某个元素是否被选中了,一般用在下拉列表

    element_located_to_be_selected

    element_selection_state_to_be:判断某个元素的选中状态是否符合预期

    element_located_selection_state_to_be:跟上面的方法作用一样,只是上面的方法传入定位到的element,而这个方法传入locator

    alert_is_present:判断页面上是否存在alert

    参数1:By类确定哪种选择方式

    from selenium.webdriver.common.by import By

    参数2:值,可能是xpath的值,可能是id,name等,取决于前面是By.XPATH,By.ID究竟是哪种方式去定位元素。

    可以在WebDriverWait()构造时传入下面参数,哪一个浏览器,来控制超时时间,多长时间检测一次这个元素是否加载,是否有异常报出。

    driver:浏览器驱动

    timeout:最长超时等待时间

    poll_frequency:检测的时间间隔,默认为500ms

    ignore_exception:超时后抛出的异常信息,默认情况下抛 NoSuchElementException 异常

    基本的使用方法:

    from selenium.webdriver.common.by import By

    from selenium.webdriver.support.ui import WebDriverWait

    from selenium.webdriver.support import expected_conditions as EC

    try{

    wait_result = WebDriverWait(四个参数).until( EC.条件实现((By类定位方式, 定位值), message))

    }finally{

    //

    }

    原文链接:https://blog.csdn.net/call_kk/article/details/106284154

    展开全文
  • Selenium显示等待和隐式等待

    千次阅读 2018-09-18 18:15:10
    Selenium显示等待和隐式等待的区别 1、selenium的显示等待 原理:显示等待,就是明确的要等到某个元素的出现,等不到就一直等,除非在规定的时间之内都没找到,那么就跳出Exception (简而言之,就是直到元素出现才去...

    在调试代码的时候经常会遇到,selenium元素定位有时有效有时无效,先比较下
    Selenium显示等待和隐式等待的区别
    1、selenium的显示等待
    原理:显示等待,就是明确的要等到某个元素的出现,等不到就一直等,除非在规定的时间之内都没找到,那么就跳出Exception
    (简而言之,就是直到元素出现才去操作,如果超时则报异常)
    2、selenium的隐式等待
    原理:隐式等待,就是在创建driver时,为浏览器对象创建一个等待时间,这个方法是得不到某个元素就等待一段时间,直到拿到某个元素位置。
    注意:在使用隐式等待的时候,实际上浏览器会在你自己设定的时间内部不断的刷新页面去寻找我们需要的元素
    3、笨方法等待
    使当前线程进入等待,Thread.sleep();这种等待属于死等,很容易让线程挂掉,使程序抛异常,所以要慎用此方法
    综上使用显示等待的方式比较保险:
    Java显式等待使用的是WebDriverWait+ExpectedConditions,使用方式如下:

    new WebDriverWait(driver,10).until( 
    ExpectedConditions.presenceOfElementLocated(By.cssSelector("css locator")));
    

    代码如下:
    pom.xml 同上一篇配置,只需修改testng文件路径即可:

    <suiteXmlFile>res/testng3.xml</suiteXmlFile>
    

    testng.xml 文件如下:

    <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
    <suite name="Suite3">
    	<test name="百度搜索">
    		<classes>
    			<class name="com.test.practice.maventest.BaidDuSearch" />
    			<class name="com.test.practice.maventest.TestBaiDu" />
    		</classes>
    	</test>
    </suite>
    

    创建公共类BasePage

    package com.test.practice.maventest;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.openqa.selenium.support.ui.WebDriverWait;
    /**
     * @author:lucy
     * @date:2018年9月18日
     * @Description: 处理页面元素公共类,重写页面操作事件,为每个元素加入显式等待
     */
    public class BasePage {
    	WebDriver webDriver;
    	private final int timeOut = 10;
    
    	public BasePage(WebDriver webDriver) {
    		// TODO Auto-generated constructor stub
    		this.webDriver = webDriver;
    	}
    
    	public void sendkeys(WebElement wElement, String s) {
    		// 加入显式等待
    		new WebDriverWait(webDriver, timeOut).until(ExpectedConditions.visibilityOf(wElement));
    		wElement.clear();// 清空输入框
    		wElement.sendKeys(s);// 输入数据
    	}
    
    	public void click(WebElement wElement) {
    		// 加入显式等待
    		new WebDriverWait(webDriver, timeOut).until(ExpectedConditions.visibilityOf(wElement));
    		wElement.click();//
    	}
    }
    

    创建BaidDuSearch类

    package com.test.practice.maventest;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.FindBy;
    /**
     * @author:lucy
     * @date:2018年9月18日
     * @Description: 百度页面,对象定位和操作,继承BasePage
     */
    public class BaidDuSearch extends BasePage {
    
    	public BaidDuSearch(WebDriver webDriver) {
    		super(webDriver);
    		// TODO Auto-generated constructor stub
    	}
    	
    
    //定位输入框 
    	@FindBy(id ="kw")
    	private WebElement kw_Element;
    //	定位搜索按钮
    	@FindBy(id ="su")
    	private WebElement su_Element;
    
    //输入关键字
    	public void kw_sendkeys(String s) {
    		this.sendkeys(kw_Element, s);
    	}
    
    //点击搜索
    	public void su_click() {
    		this.click(su_Element);
    	}
    }
    
    

    创建测试类TestBaiDu,

    package com.test.practice.maventest;
    import org.testng.annotations.Test;
    import junit.framework.Assert;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.firefox.FirefoxDriver;
    import org.openqa.selenium.support.PageFactory;
    import org.testng.annotations.AfterMethod;
    import org.testng.annotations.BeforeClass;
    /**
     * @author:lucy
     * @date:2018年9月18日
     * @Description: 测试百度搜索
     */
    public class TestBaiDu {
    
    	private WebDriver driver;
    	@BeforeClass
    	public void beforeClass() {
    		System.setProperty("webdriver.firefox.marionette", "D:\\selenium\\geckodriver-v0.21.0-win64\\geckodriver.exe");
    		driver = new FirefoxDriver();
    		System.out.println("执行BeforeClass");
    	}
    
    	@Test
    	public void Baidu_Search() {
    		BaidDuSearch bSearch = PageFactory.initElements(driver, BaidDuSearch.class);
    		driver.get("https://www.baidu.com");
    		driver.manage().window().maximize();// 窗口最大化
    		bSearch.kw_sendkeys("软件测试");
    		bSearch.su_click();
    
    	}
    
    	@Test
    	public void f2() {
    		Assert.assertEquals("abc", "abc");
    	}
    
    	@AfterMethod
    	public void close() {
    		System.out.println("执行AfterMethod");
    	}
    
    }
    

    run as》maven test:
    最后运行结果报告如下:
    在这里插入图片描述

    tips:
    遇到问题,执行测试时,一直报
    org.apache.maven.surefire.booter.SurefireExecutionException: Cannot instantiate class com.test.practice.maventest.TestBaiDu; nested exception is org.testng.TestNGException: Cannot instantiate class com.test.practice.maventest.TestBaiDu错误,通过重新初始化浏览器驱动,解决改该问题,代码如下:

    System.setProperty("webdriver.firefox.marionette", "D:\\selenium\\geckodriver-v0.21.0-win64\\geckodriver.exe");
    
    展开全文
  • 什么是显示等待和隐式等待?显示等待就是有条件的等待隐式等待就是无条件的等待隐式等待当使用了隐式等待执行测试的时候,如果 WebDriver 没有在 DOM 中找到元素,将继续等待,超出设定时间后则抛出找不到元素的异常...
  • 原因:当浏览器加载页面时,页面上的元素并不会同时被加载,因此增加了定位元素的困难(ElementNotVisibleException错误)WebDriver提供了2种类型的等待显示等待(WebDriverWait类):使WebDriver等待某个条件成立时继续...
  • selenium显示等待和隐式等待使用及区别 1. 隐式等待 Java语句:等待10秒 表示查找元素时超时时间是10秒; 如果没找到元素,那么查找元素会在10秒内,每隔半秒中去查找一 次元素,一旦找到则继续执行下一行代码 ;...
  • 什么是显示等待和隐式等待?显示等待就是有条件的等待隐式等待就是无条件的等待隐式等待 当使用了隐式等待执行测试的时候,如果 WebDriver没有在 DOM中找到元素,将继续等待,超出设定时间后则抛出找不到元素的异常...
  • Selenium显示等待和隐式等待的区别

    万次阅读 2016-10-08 16:31:26
    Selenium显示等待和隐式等待的区别 1、selenium的显示等待 原理:显示等待,就是明确的要等到某个元素的出现或者是某个元素的可点击等条件,等不到,就一直等,除非在规定的时间之内都没找到,那么久跳出Exception...
  • 现在许多网页使用AJAX技术,即不同元素...我们可以设置显示等待和隐式等待。 显示等待:要先达到这个条件,代码才继续运行from selenium import webdriver from selenium.webdriver.common.by import By from selen
  • 什么是显示等待和隐式等待? 显示等待就是有条件的等待 隐式等待就是无条件的等待 隐式等待 当使用了隐式等待执行测试的时候,如果 WebDriver 没有在 DOM 中找到元素,将继续等待,超出设定时间后则抛出找不到元素的...
  • Selenium的显示等待和隐式等待(区别:有条件/无条件的等待) ** 隐式等待:当查找元素或元素并没有立即出现的时候,隐式等待将等待一段时间再查找 DOM,默认的时间是0 from selenium import webdriver browser = ...
  • 什么是显示等待和隐式等待? 等待显示就是有条件的等待 隐式等待就是无条件的等待 隐式等待 当使用了隐式等待执行测试的时候,如果WebDriver没有在DOM中找到元素,将继续等待,超出设定时间后则抛出找不到元素的异常...
  • 隐式等待 设置一个等待时间,轮询查找(默认0.5秒)元素是否出现,如果没有出现就抛出异常 self.driver.implicitly_wait(3) 显式等待 代码中定义等待时间,当条件发生时才继续执行代码 ‘WebDriverWait’配合...
  • 1.selenium的显示等待 原理:显式等待,就是明确的要等到某个元素的出现或者是某个元素的可点击等条件,等不到,就一直等,除非在规定的时间之内都没找到,那么就跳出Exception.(简而言之:就是直到元素出现才去操作,...
  • 现在越来越多的 web app 使用 AJAX 技术。当一个页面加载到浏览器后,这个页面的很多元素加载的时间可能不一致。这就使得元素定位比较尴尬了,如果某个要...Selenium Webdriver 提供了两种类型的等待方法:隐式等待...
  • 显示等待 使webdriver等待某个条件成立时继续执行,否则在最大时长时抛出超时溢出 1 from selenium.webdriver.support.wait import WebDriverWait 2 from selenium.webdriver.support import expected_...
  • 首先介绍一下隐式等待和显示等待显示等待:设置一个超时时间和一个元素查找条件,在这个时间内不断寻找这个元素,超时找不到就会抛出异常: from selenium import webdriver from selenium.webdriver.common.by ...
  • 1、强制等待之前的脚本selenium打开网页后会强制sleep几秒然后退出,如果代码层面出现了quit(),有时候网页未加载完完浏览器就退出了。所以才要强制等待!sleep就是强制等待。2、显式等待每个网页加载时间是不同的,...
  • 1. 显示等待每隔一段时间检测一次当前页面元素是否存在,如果超过设置时间检测不到则抛出异常(TimeoutException)操作格式:WebDriverWait(driver, timeout, poll_frequency=0.5, ignored_exceptions=None)driver:...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 215
精华内容 86
关键字:

显示等待和隐式等待