第四十基础：强制等待&隐士等待&显示等待&元素定位方法

一.问题

1.明明页面已经精准的定位到了元素，但是执行脚本的时候却经常报错没找到元素。其实原因很简单，就是脚本执行的速度很快，而浏览器加载页面的时候由于网速，css渲染，JS等各种原因导致页面加载缓慢，所以当脚本执行到定位一个元素的代码时，页面还未加载出这个元素，进而导致代码报错。那么有没有办法解决这种问题呢？

2.先看下面的一个用例(百度首页输入“linux超”关键词，点击“百度一下”，在搜索结果中找到我的博客地址并点击进入我的博客)此时不使用任何等待方法。

import time
from selenium import webdriver
import unittest
from selenium.common.exceptions import NoSuchElementException, TimeoutException


class TestWait(unittest.TestCase):
    
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get("https://www.baidu.com")
        self.driver.maximize_window()
        

    def test_no_wait(self):
        try:
            # 等输入框出现在DOM树中
            input_box = self.driver.find_element_by_id('kw')
            # 输入linux超
            input_box.send_keys(u'linux超')  
            # 等元素可点击
            query_btn = self.driver.find_element_by_id('su')
            # 点击
            query_btn.click()  
            # 等输入框出现在DOM树中,搜索结果找到我的博客
            my_blog = self.driver.find_element_by_xpath('//*[text()="https://www.cnblogs.com/"]')  
            # 进入我的博客
            my_blog.click()
            # 这里我是为了看到效果（跳转到我的博客首页）
            time.sleep(2)  
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3.执行结果：不使用任何等待方法的时候，定位搜索结果的时候就报错了，因为百度搜索关键词的时候结果页面会有一定时间的加载过程，还未加载完成时，代码就执行了定位方法，因此报错。

E
======================================================================
ERROR: test_no_wait (__main__.TestWait)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/MyThreading/nowait.py", line 38, in test_no_wait
    raise e
  File "D:/MyThreading/nowait.py", line 34, in test_no_wait
    my_blog = self.driver.find_element_by_xpath('//*[text()="https://www.cnblogs.com/"]')  # 搜索结果找到我的博客
  File "C:\Python36\lib\site-packages\selenium\webdriver\remote\webdriver.py", line 394, in find_element_by_xpath
    return self.find_element(by=By.XPATH, value=xpath)
  File "C:\Python36\lib\site-packages\selenium\webdriver\remote\webdriver.py", line 978, in find_element
    'value': value})['value']
  File "C:\Python36\lib\site-packages\selenium\webdriver\remote\webdriver.py", line 321, in execute
    self.error_handler.check_response(response)
  File "C:\Python36\lib\site-packages\selenium\webdriver\remote\errorhandler.py", line 242, in check_response
    raise exception_class(message, screen, stacktrace)
selenium.common.exceptions.NoSuchElementException: Message: Unable to locate element: //*[text()="https://www.cnblogs.com/"]


----------------------------------------------------------------------
Ran 1 test in 14.010s

FAILED (errors=1)

Process finished with exit code 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

二.强制等待

1.强制等待其实是python内置模块time的一个方法sleep(n)，顾名思义哈，强制等待就是死等固定时间n秒，比如女票叫你在楼下等10分钟她化妆，那么就必须等10分钟，10分钟后她还不来，那你就可以该干嘛干嘛去了，定位元素的时候也可以使用这个方法，在定位元素之前，等待固定的时间，再定位。我们使用这个方法修改上面的错误用例。

import time
from selenium import webdriver
import unittest
from selenium.common.exceptions import NoSuchElementException, TimeoutException


class TestWait(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get("https://www.baidu.com")
        self.driver.maximize_window()
        

    def test_no_wait(self):
        try:
            # 等输入框出现在DOM树中
            input_box = self.driver.find_element_by_id('kw')
            # 输入linux超
            input_box.send_keys(u'linux超')  
            # 等元素可点击
            query_btn = self.driver.find_element_by_id('su')
            # 点击
            query_btn.click()  
            # 设置强制等待5秒，再定位元素
            time.sleep(5)
            # 等输入框出现在DOM树中，搜索结果找到我的博客
            my_blog = self.driver.find_element_by_xpath('//*[text()="https://www.cnblogs.com/"]')  
            # 进入我的博客
            my_blog.click()  
            # 这里我是为了看到效果（跳转到我的博客首页）
            time.sleep(2)  
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2.执行结果。

2.1.没错，执行通过了，但是强制等待有很大的弊端，比如加载页面只需要1秒钟就能定位到元素，但是你设置了超过1秒的等待时间，严重浪费了其他时间，而且你无法判定页面加载完成到底需要多少时间。

2.2.那么脚本其实也是不稳定的， 再比如，为了节省脚本的执行时间， 只设置了1秒的等待，而且脚本通过了，但是当你的网络很差的时候，1秒的等待就无法成功定位到元素了，导致脚本执行失败。

2.3.因此只要有一个因素改变就可能导致脚本的失败很不稳定

.
----------------------------------------------------------------------
Ran 1 test in 21.043s

OK

Process finished with exit code 0
1
2
3
4
5
6
7

三.隐士等待

1.隐士等待表示在自动化实施过程中，为查找页面元素或执行命令设置一个最长等待时间，如果在规定时间内页面元素被找到或者命令被执行完成，则执行下一步，否则继续等待直到设置的最长等待时间截至。

2.使用webdriver 的implicitly_wait()方法设置隐士等待，我把前面用例使用隐士等待再做修改。

import time
from selenium import webdriver
import unittest
from selenium.common.exceptions import NoSuchElementException, TimeoutException


class TestWait(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        

    def test_implicitly_wait(self):
        self.driver.get("https://www.baidu.com")
        self.driver.maximize_window()
        self.driver.implicitly_wait(10)
        
        try:
            # 搜索框
            input_box = self.driver.find_element_by_id('kw')  
            # 输入linux超
            input_box.send_keys(u'linux超')  
            # 百度一下按钮
            query_btn = self.driver.find_element_by_id('su')  
            # 点击
            query_btn.click()  
            # 搜索结果找到我的博客
            my_blog = self.driver.find_element_by_xpath('//*[text()="https://www.cnblogs.com/"]')  
            # 进入我的博客
            my_blog.click()  
            # 这里我是为了看到效果（跳转到我的博客首页）
            time.sleep(2)  
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3.执行过程。

3.1.隐士等待的好处是不用像强制等待那样死等固定时间n秒，可以在一定程度上提升测试用例的执行效率和脚本的稳定性，不过这种方法也存在一个弊端，那就是程序会一直等待整个页面加载完成(页面左上角不再转圈圈)，才会继续执行下一步操作。比如某些时候想要的页面元素早就加载完了，但是由于个别JS等资源加载稍慢，此时程序仍然会等待页面全部加载完成才会继续执行下一步，这无形中加长了测试用例的执行时间。

四.显示等待

1.通过selenium.webdriver.support.ui模块提供的WebDriverWait类，再结合该类的until()和until_not()方法，并自定义好显示等待的条件，然后根据判断条件而进行灵活的等待，显示等待更比隐士等待节约脚本执行时间，推荐尽量使用显示等待的方式。

2.设置了显示等待，程序会每个一段时间(默认是0.5s)执行一下自定义的判断条件，如果条件成立就执行下一步操作，否则继续等待，直到超过设置的最长等待时间，然后抛出超时异常。

class WebDriverWait(object):
    def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):
        """Constructor, takes a WebDriver instance and timeout in seconds.
            :Args:
            - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
            - timeout - Number of seconds before timing out
            - poll_frequency - sleep interval between calls
              By default, it is 0.5 second.
            - ignored_exceptions - iterable structure of exception classes ignored during calls.
              By default, it contains NoSuchElementException only.

            Example:
             from selenium.webdriver.support.ui import WebDriverWait \n
             element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \n
             is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\ \n
                         until_not(lambda x: x.find_element_by_id("someId").is_displayed())
         """
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.参数解释

3.1.driver：webdriver的实例对象。

3.2.timeout：最长的显示等待时间，单位为s。

3.3.poll_frequency：调用频率，也就是再timeout设置的时间内，每隔poll_frequency时间执行一次判断条件，默认是0.5。

3.4.ignored_exception：执行过程中忽略的异常类型，默认忽略NoSuchElelmentException异常。

4.WebDriverWait提供的方法：until(method, message=‘’)

4.1.在规定等待时间内，每隔一段时间调用一下method方法，直到其返回值为True，如果超时，抛出带有message异常信息的TimeoutException异常。

5.WebDriverWait提供的方法：until_not(method, message=‘’)

5.1.与until方法相反，不赘述

6.实例

6.1.可以看到显示等待需要配合expected_conditions模块中的各个场景方法使用。

6.2.表面上和隐士等待执行效果一样，其实还是有一定差异的，当测试脚本操作的页面比较多时，你会发现两中等待方式对于脚本的执行效率是不一样的，显示等待更加节省时间。

import time
from selenium import webdriver
import unittest
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By


class TestWait(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        

    def test_webdriver_wait(self):
        self.driver.get("https://www.baidu.com")
        self.driver.maximize_window()
        try:
            # 等输入框出现在DOM树中
            input_box = WebDriverWait(self.driver, 10, 0.3).until(EC.visibility_of_element_located((By.ID, 'kw')))
            # 输入linux超
            input_box.send_keys(u'linux超')  
            # 等元素可点击
            query_btn = WebDriverWait(self.driver, 10, 0.3).until(EC.element_to_be_clickable((By.ID, 'su')))
            # 点击
            query_btn.click()  
            # 等输入框出现在DOM树中， 搜索结果找到我的博客
            my_blog = WebDriverWait(self.driver, 10, 0.3).until(EC.visibility_of_element_located((By.XPATH, '//*[text()="https://www.cnblogs.com/"]')))
            # 进入我的博客
            my_blog.click()  
            # 这里我是为了看到效果（跳转到我的博客首页）
            time.sleep(2)  
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

五.定位元素方法封装

1.显示等待案例中定位每个元素都要重新写一个显示等待然后调用判断场景，是不是很麻烦？

base.py

from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.support.ui import WebDriverWait


class Base(object):

    def __init__(self, driver):
        self.driver = driver


    def find_element(self, by, locator, timeout=30):
        """
        定位单个元素
        :param by: 定位方式 eg:By.ID
        :param locator: 定位表达式
        :param timeout: 显示等待超时时间
        :return:
        """
        try:
            element = WebDriverWait(self.driver, timeout).until(lambda driver: driver.find_element(by, locator))
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        else:
            return element


    def find_elements(self, by, locator, timeout=30):
        """
        定位一组元素
        :param by: 定位方式 eg:By.ID
        :param locator: 定位表达式
        :param timeout: 显示等待超时时间
        :return:
        """
        try:
            elements = WebDriverWait(self.driver, timeout).until(lambda driver: driver.find_elements(by, locator))
        except (NoSuchElementException, TimeoutException) as e:
            raise e
        else:
            return elements


if __name__ == '__main__':
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

1.下面测试一下封装的方法。

from selenium import webdriver
import unittest
from selenium.webdriver.common.by import By
from base import Base


class TestWait(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.base = Base(self.driver)
        self.driver.get("https://www.baidu.com")
        self.driver.maximize_window()
        
        
    def test_webdriver_wait(self):
        # 等输入框出现在DOM树中
        input_box = self.base.find_element(By.ID, 'kw')
        # 输入linux超
        input_box.send_keys(u'linux超')  
        # 等元素可点击
        query_btn = self.base.find_element(By.ID, 'su')
        # 点击
        query_btn.click()  
        # 找搜索结果中的每一个标题
        elements = self.base.find_elements(By.XPATH, '//h3[@class="t"]')
        # 循环打印每一个搜索结果
        for element in elements:
            print(element.text)
            

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2.执行过程及结果

Linux学习教程,Linux入门教程(超详细)
Linux命令(超详细版) - CSDN博客
linux超 - 博客园
新型Linux 病毒,脚本超 1000 行,功能复杂 - OSCHINA_开源中国
《Linux就该这么学》 - 必读的Linux系统与红帽RHCE认证免费自学书籍
技术|有所为,有所不为:在 Linux 中使用超级用户权限
Linux下挂载超过2T的磁盘 - qq_40143313的博客 - CSDN博客
现在Linux运行在 99.6%的TOP500超级计算机上_TechWeb
Linux 教程 | 菜鸟教程
linux中超级快 - 云+社区 - 腾讯云
.
----------------------------------------------------------------------
Ran 1 test in 20.094s

OK

Process finished with exit code 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

六.总结

1.强制等待：固定等待一段时间，即使设置一定的等待时间，也不能确保一定能够定位到元素，因为无法知道页面加载的时间，而且这种方法通常比较浪费脚本执行时间，效率低。

2.隐士等待：设置最长的等待时间，在这个时间内，当元素被加载出现在DOM树中且页面被完全加载完成之后，才执行下一步操作，保证了脚本的稳定性，但是执行效率相对较低，因为往往我们只需要目标元素出现即可，并不需要整个页面都加载完成，而隐士等待要等待整个页面加载完才能执行下一步，浪费一定时间，那么为了解决这种弊端又引入了显示等待。

3.显示等待：显示等待实现方式通过判断某一个条件是否成立，如果成立就立即执行下一步操作，不需要等待页面加载完成，执行效率高，脚本的稳定性也相对较高。

4.最后使用显示等待的方法封装了定位单一元素和定位一组元素的方法，解决了重复使用显示等待方法定位的代码，使用这个封装方法能够定位到大多数的元素(一些特殊的元素还是需要结合expected_conditions模块中的场景方法比较稳定)。