学习显示等待和隐式等待使用

参考博客原址：https://blog.csdn.net/sinat_41774836/article/details/88965281

            
                            

                    
                    
                                            
文章目录
强制等待:sleep()
隐式等待:implicitly_wait()
显示等待:WebDriverWait()
与until()或者until_not()方法结合使用
WebDriverWait与expected_conditions结合使用
显示等待,自定义等待条件

强制等待: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相关教程

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


强制等待

time.sleep()

设置固定的线程休眠时间。


显示等待

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秒尚未出现则抛异常。


隐式等待

implicitly_wait()

比如：

driver.implicitly_wait(10)

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

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元素定位有时有效有时无效，先比较下

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");