diff --git a/README.md b/README.md
index 170fabf..bae1f75 100644
--- a/README.md
+++ b/README.md
@@ -16,14 +16,14 @@ DrissionPage，即 driver 和 session 组合而成的 page。
 
 ## 📕 背景
 
-requests 爬虫面对要登录的网站时，要分析数据包、JS 源码，构造复杂的请求，往往还要应付验证码、JS 混淆、签名参数等反爬手段，门槛较高。若数据是由 JS 计算生成的，还须重现计算过程，体验不好，开发效率不高。  
+用 requests 做数据采集面对要登录的网站时，要分析数据包、JS 源码，构造复杂的请求，往往还要应付验证码、JS 混淆、签名参数等反爬手段，门槛较高。若数据是由 JS 计算生成的，还须重现计算过程，体验不好，开发效率不高。  
 使用 selenium，可以很大程度上绕过这些坑，但 selenium 效率不高。因此，这个库将 selenium 和 requests 合而为一，不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率。  
 除了合并两者，本库还以网页为单位封装了常用功能，简化了 selenium 的操作和语句，在用于网页自动化操作时，减少考虑细节，专注功能实现，使用更方便。  
 一切从简，尽量提供简单直接的使用方法，对新手更友好。
 
 # 💡 特性和亮点
 
-作者有多年自动化和爬虫经验，踩过无数坑，总结出的经验全写到这个库里了。内置了 N 多实用功能，对常用功能作了整合和优化。
+作者踩过无数坑，总结出的经验全写到这个库里了。内置了 N 多实用功能，对常用功能作了整合和优化。
 
 ## 🎉 特性
 
@@ -91,6 +91,7 @@ page.to_tab(0)
 ```python
 # 使用 selenium：
 from selenium.webdriver.support.select import Select
+
 select_element = Select(element)
 select_element.select_by_visible_text('text')
 
@@ -133,7 +134,8 @@ set_headless()
 
 ```python
 # 使用 selenium：
-text = webdriver.execute_script('return window.getComputedStyle(arguments[0], "::after").getPropertyValue("content");', element)
+text = webdriver.execute_script('return window.getComputedStyle(arguments[0], "::after").getPropertyValue("content");',
+                                element)
 
 # 使用 DrissionPage：
 text = element.pseudo_after
@@ -142,6 +144,7 @@ text = element.pseudo_after
 🌿 shadow-root 操作
 
 selenium 新增了`ShadowRoot`，但功能实在是太少。
+
 ```python
 # 使用 selenium：
 shadow_element = webdriver.execute_script('return arguments[0].shadowRoot', element)
@@ -188,8 +191,10 @@ url = 'https://baike.baidu.com/item/python'
 
 # 使用 requests：
 from lxml import etree
-headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36'}
-response = requests.get(url, headers = headers)
+
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36'}
+response = requests.get(url, headers=headers)
 html = etree.HTML(response.text)
 element = html.xpath('//h1')[0]
 title = element.text
@@ -274,7 +279,9 @@ Git 命令学习
 [点击查看版本历史](http://g1879.gitee.io/drissionpage/#/%E7%89%88%E6%9C%AC%E5%8E%86%E5%8F%B2)
 
 # 🖐🏻 免责声明
-请勿将 DrissionPage 应用到任何可能会违反法律规定和道德约束的工作中,请友善使用 DrissionPage，遵守蜘蛛协议，不要将 DrissionPage 用于任何非法用途。如您选择使用 DrissionPage 即代表您遵守此协议，作者不承担任何由于您违反此协议带来任何的法律风险和损失，一切后果由您承担。
+
+请勿将 DrissionPage 应用到任何可能会违反法律规定和道德约束的工作中,请友善使用 DrissionPage，遵守蜘蛛协议，不要将 DrissionPage 用于任何非法用途。如您选择使用 DrissionPage
+即代表您遵守此协议，作者不承担任何由于您违反此协议带来任何的法律风险和损失，一切后果由您承担。
 
 # ☕ 请我喝咖啡
 
diff --git a/docs/README.md b/docs/README.md
index d0893d0..f6a4812 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -16,14 +16,14 @@ DrissionPage，即 driver 和 session 组合而成的 page。
 
 ## 📕 背景
 
-requests 爬虫面对要登录的网站时，要分析数据包、JS 源码，构造复杂的请求，往往还要应付验证码、JS 混淆、签名参数等反爬手段，门槛较高。若数据是由 JS 计算生成的，还须重现计算过程，体验不好，开发效率不高。  
+用 requests 做数据采集面对要登录的网站时，要分析数据包、JS 源码，构造复杂的请求，往往还要应付验证码、JS 混淆、签名参数等反爬手段，门槛较高。若数据是由 JS 计算生成的，还须重现计算过程，体验不好，开发效率不高。  
 使用 selenium，可以很大程度上绕过这些坑，但 selenium 效率不高。因此，这个库将 selenium 和 requests 合而为一，不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率。  
 除了合并两者，本库还以网页为单位封装了常用功能，简化了 selenium 的操作和语句，在用于网页自动化操作时，减少考虑细节，专注功能实现，使用更方便。  
 一切从简，尽量提供简单直接的使用方法，对新手更友好。
 
 # 🍀 特性和亮点
 
-作者有多年自动化和爬虫经验，踩过无数坑，总结出的经验全写到这个库里了。内置了 N 多实用功能，对常用功能作了整合和优化。
+作者踩过无数坑，总结出的经验全写到这个库里了。内置了 N 多实用功能，对常用功能作了整合和优化。
 
 ## 🎉 特性
 
diff --git a/docs/使用方法/查找页面元素.md b/docs/使用方法/查找页面元素.md
index 163fb76..159fa17 100644
--- a/docs/使用方法/查找页面元素.md
+++ b/docs/使用方法/查找页面元素.md
@@ -1,6 +1,6 @@
 本节介绍如何从页面对象或元素对象中获取需要的元素对象。
 
-无论是爬虫还是页面自动化，定位元素都是重中之重的的技能，浏览器开发者工具虽然可以直接复制绝对 xpath 或 css 路径，但这样做一来代码繁琐，可读性低，二来难以应付动态变化的页面。  
+无论是数据采集还是页面自动化，定位元素都是重中之重的的技能，浏览器开发者工具虽然可以直接复制绝对 xpath 或 css 路径，但这样做一来代码繁琐，可读性低，二来难以应付动态变化的页面。  
 本库提供一套简洁易用的语法，用于快速定位元素，并且内置等待功能、支持链式查找，减少了代码的复杂性。
 
 定位元素大致分为三种方法：
@@ -34,22 +34,22 @@ d 模式的元素还有专门用于处理 shadow dom 的`shadow_root`属性。
 
 ```python
 # 获取 id 为 one 的元素
-div1 = page.ele('#one')  
+div1 = page.ele('#one')
 
 # 获取 div1 元素内所有 p 元素组成的列表
-p_eles = div1.eles('tag:p')  
+p_eles = div1.eles('tag:p')
 
 # 获取 name 属性为 row1 的元素
-p1 = page.ele('@name=row1')  
+p1 = page.ele('@name=row1')
 
 # 获取 name 属性为 row2 且包含“第二”文本的 p 元素
-p_ele = page.ele('tag:p@@text():第二@@name=row2')  
+p_ele = page.ele('tag:p@@text():第二@@name=row2')
 
 # 获取包含“第二个div”文本的元素
-div2 = page.ele('第二个div')  
+div2 = page.ele('第二个div')
 
 # 用 xpath 查找
-div2 = page.ele('xpath://div[@id="tow"]')  
+div2 = page.ele('xpath://div[@id="tow"]')
 
 # 从第一行元素用相对定位获取第三行元素
 p3 = p1.next(2)
@@ -61,8 +61,6 @@ parent = p1.parent()
 div2 = p1.after(1, 'tag:div')
 ```
 
-
-
 ## 实际示例
 
 复制此代码可直接运行查看结果。
@@ -109,17 +107,16 @@ IOT/物联网/边缘计算
 
 ```python
 # 在页面内查找元素
-ele1 = page.ele('search text')  
+ele1 = page.ele('search text')
 
 # 在元素内查找后代元素
-ele2 = ele1.ele('search text')  
+ele2 = ele1.ele('search text')
+
 
 # 使用 xpath 获取后代中第一个 div 元素的 class 属性
 class = ele1.ele('xpath://div/@class')
 ```
 
-
-
 ## eles()
 
 此方法与`ele()`相似，但返回的是匹配到的所有元素组成的列表，用 xpath 获取元素属性时，返回属性文本组成的列表。
@@ -133,13 +130,11 @@ class = ele1.ele('xpath://div/@class')
 
 ```python
 # 获取 ele 元素内的所有 p 元素
-p_eles = ele.eles('tag:p')  
+p_eles = ele.eles('tag:p')
 # 打印第一个 p 元素
 print(p_eles[0])  
 ```
 
-
-
 ## s_ele()
 
 此方法用于在一个元素下查找后代元素，以`SessionElement`形式返回结果（xpath 获取属性值时依然是返回`str`），也可以直接将一个元素或页面转换为`SessionElement`版本。
@@ -161,14 +156,12 @@ ele2 = ele1.s_ele()
 ele2 = page.s_ele()
 
 # 在 ele1 元素下查找元素，并以 SessionElemnet 返回
-ele2 = ele1.s_ele('search text')  
+ele2 = ele1.s_ele('search text')
 
 # 在页面下查找元素，并以 SessionElemnet 返回
 ele = page.s_ele('search text')  
 ```
 
-
-
 ## s_eles()
 
 此方法与`s_ele()`相似，但返回的是匹配到的所有元素组成的列表，或属性值组成的列表。
@@ -179,8 +172,6 @@ ele = page.s_ele('search text')
 
 返回：`SessionElement`组成的列表，或用 xpath 获取到的属性值组成的列表
 
-
-
 ## active_ele
 
 该属性返回当前页面焦点所在元素。d 模式独有。
@@ -189,25 +180,25 @@ ele = page.s_ele('search text')
 ele = page.active_ele
 ```
 
-
-
 ## shadow_root
 
 `DriverElement`元素除了以上方法和属性外，还有`shadow_root`属性，用于获取其内部的 shadow_root 元素。  
-该属性返回的是一个`ShadowRootElement`，类似于`DriverElement`，功能比`DriverElement`少。但也有`ele()`和`eles()`方法，可直接搜索其下的元素，返回 `DriverElement`元素。返回的`DriverElement`和普通的没有区别。
+该属性返回的是一个`ShadowRootElement`，类似于`DriverElement`，功能比`DriverElement`少。但也有`ele()`和`eles()`方法，可直接搜索其下的元素，返回 `DriverElement`
+元素。返回的`DriverElement`和普通的没有区别。
 
 ```python
 # 获取一个元素下是 shadow root
-shadow_ele = ele.shadow_root  
+shadow_ele = ele.shadow_root
 # 获取该 shadow root 下的一个元素
-ele1 = shadow_ele.ele('search text')  
+ele1 = shadow_ele.ele('search text')
 # 点击获取到的元素
 ele1.click()  
 ```
 
 # 查找语法
 
-我们使用一套简洁高效的语法去定位元素，大大简化了定位元素的代码量，增强了功能，也兼容 css selector、xpath、selenium 原生的 loc 元组（s 模式也能用）。d 模式和 s 模式定位元素的语法是完全一样的，便于模式切换时平滑过渡。
+我们使用一套简洁高效的语法去定位元素，大大简化了定位元素的代码量，增强了功能，也兼容 css selector、xpath、selenium 原生的 loc 元组（s 模式也能用）。d 模式和 s
+模式定位元素的语法是完全一样的，便于模式切换时平滑过渡。
 
 **匹配模式** 指字符串是否完全匹配，有以下两种：
 
@@ -215,14 +206,10 @@ ele1.click()
 
 表示精确匹配，匹配完全符合的文本或属性。
 
-
-
 ## `:`
 
 表示模糊匹配，匹配含有某个字符串的文本或属性。
 
-
-
 **关键字** 是出现在定位语句最左边，用于指明该语句以哪种方式去查找元素，有以下这些：
 
 ## `#`
@@ -231,28 +218,24 @@ ele1.click()
 
 ```python
 # 在页面中查找 id 属性为 ele_id 的元素
-ele1 = page.ele('#ele_id')  
+ele1 = page.ele('#ele_id')
 
 # 在 ele1 元素内查找 id 属性包含 ele_id 文本的元素
 ele2 = ele1.ele('#:ele_id')  
 ```
 
-
-
 ## `.`
 
 表示`class`属性，只在语句最前面且单独使用时生效，可配合`=`或`:`。
 
 ```python
 # 查找 class 属性为 ele_class 的元素
-ele2 = ele1.ele('.ele_class')  
+ele2 = ele1.ele('.ele_class')
 
 # 查找 class 属性包含 ele_class 文本的元素
 ele2 = ele1.ele('.:ele_class')  
 ```
 
-
-
 ## `@`
 
 表示某个属性，只匹配一个属性。  
@@ -260,7 +243,7 @@ ele2 = ele1.ele('.:ele_class')
 
 ```python
 # 查找 name 属性为 ele_name 的元素
-ele2 = ele1.ele('@name=ele_name') 
+ele2 = ele1.ele('@name=ele_name')
 
 # 查找 name 属性包含 ele_name 文本的元素
 ele2 = ele1.ele('@name:ele_name')
@@ -269,14 +252,12 @@ ele2 = ele1.ele('@name:ele_name')
 ele2 = ele1.ele('@name')
 
 # 查找没有任何属性的元素
-ele2 = ele1.ele('@')  
+ele2 = ele1.ele('@')
 
 # 查找 emaile 属性为 abc@def.com 的元素，有多个 @ 也不会重复处理
 ele2 = ele1.ele('@email=abc@def.com')  
 ```
 
-
-
 ## `@@`
 
 表示某个属性，多属性匹配时使用，个数不限。还能匹配要忽略的元素，匹配文本时也和`@`不一样。  
@@ -294,7 +275,7 @@ ele2 = ele1.ele('@email=abc@def.com')
 
 ```python
 # 查找 name 属性为 name 且 class 属性包含 cls 文本的元素
-ele2 = ele1.ele('@@name=name@@class:cls')  
+ele2 = ele1.ele('@@name=name@@class:cls')
 
 # 查找没有 class 属性的元素
 ele2 = ele1.ele('@@-class')
@@ -303,8 +284,6 @@ ele2 = ele1.ele('@@-class')
 ele2 = ele1.ele('@@-name:ele_name')
 ```
 
-
-
 ## `text`
 
 要匹配的文本，查询字符串如开头没有任何关键字，也表示根据传入的文本作模糊查找。  
@@ -312,10 +291,10 @@ ele2 = ele1.ele('@@-name:ele_name')
 
 ```python
 # 查找文本为 some text 的元素
-ele2 = ele1.ele('text=some text')  
+ele2 = ele1.ele('text=some text')
 
 # 查找文本包含 some text 的元素
-ele2 = ele1.ele('text:some text')  
+ele2 = ele1.ele('text:some text')
 
 # 与上一行一致
 ele2 = ele1.ele('some text')  
@@ -327,8 +306,6 @@ ele2 = ele1.ele('some text')
 ele2 = page.ele('text:text:')
 ```
 
-
-
 ## `text()`
 
 作为查找属性时使用的文本关键字，必须与`@`或`@@`配合使用。  
@@ -338,16 +315,16 @@ ele2 = page.ele('text:text:')
 
 ```python
 # 查找文本为 some text 的元素
-ele2 = ele1.ele('@text()=some text')  
+ele2 = ele1.ele('@text()=some text')
 
 # 查找文本包含 some text 的元素
-ele2 = ele1.ele('@text():some text')  
+ele2 = ele1.ele('@text():some text')
 
 # 查找文本为 some text 且 class 属性为 cls 的元素
-ele2 = ele1.ele('@@text()=some text@@class=cls')  
+ele2 = ele1.ele('@@text()=some text@@class=cls')
 
 # 查找文本为 some text 且没有任何属性的元素（因第一个 @@ 后为空）
-ele2 = ele1.ele('@@@@text():some text')  
+ele2 = ele1.ele('@@@@text():some text')
 
 # 查找直接子文本包含 some text 字符串的元素，和 text 关键字没有区别
 ele = page.ele('@text():some text')
@@ -357,27 +334,25 @@ ele = page.ele('text:some text')
 ele = page.ele('@@text():some text')
 ```
 
-
-
 ## `tag`
 
 表示元素的标签，只在语句最前面且单独使用时生效，可与`@`或`@@`配合使用。`tag:`与`tag=`效果一致。
 
 ```python
 # 定位 div 元素
-ele2 = ele1.ele('tag:div')  
+ele2 = ele1.ele('tag:div')
 
 # 定位 class 属性为 cls 的 div 元素
-ele2 = ele1.ele('tag:div@class=cls')  
+ele2 = ele1.ele('tag:div@class=cls')
 
 # 定位文本为 text 的 div 元素
-ele2 = ele1.ele('tag:div@text()=text')  
+ele2 = ele1.ele('tag:div@text()=text')
 
 # 定位 class 属性为 cls 且文本为 text 的 div 元素
-ele2 = ele1.ele('tag:div@@class=cls@@text()=text')  
+ele2 = ele1.ele('tag:div@@class=cls@@text()=text')
 
- # 查找直接文本节点包含 text 字符串的 div 元素
-ele2 = ele1.ele('tag:div@text():text') 
+# 查找直接文本节点包含 text 字符串的 div 元素
+ele2 = ele1.ele('tag:div@text():text')
 
 # 查找内部文本节点包含 text 字符串的 div 元素
 ele2 = ele1.ele('tag:div@@text():text')  
@@ -386,22 +361,18 @@ ele2 = ele1.ele('tag:div@@text():text')
 ?> **Tips:** <br>
 注意， `tag:div@text():text` 和 `tag:div@@text():text` 是有区别的，前者只在`div`的直接文本节点搜索，后者搜索`div`的整个内部。
 
-
-
 ## `css`
 
 表示用 css selector 方式查找元素。`css:`与`css=`效果一致。
 
 ```python
 # 查找 div 元素
-ele2 = ele1.ele('css:.div')  
+ele2 = ele1.ele('css:.div')
 
 # 查找 div 子元素元素，这个写法是本库特有，原生不支持
 ele2 = ele1.ele('css:>div')  
 ```
 
-
-
 ## `xpath`
 
 表示用 xpath 方式查找元素。`xpath:`与`xpath=`效果一致。  
@@ -409,19 +380,18 @@ ele2 = ele1.ele('css:>div')
 
 ```python
 # 查找 div 元素
-ele2 = ele1.ele('xpath:.//div')  
+ele2 = ele1.ele('xpath:.//div')
 
 # 和上面一行一样，查找元素的后代时，// 前面的 . 可以省略
-ele2 = ele1.ele('xpath://div')  
+ele2 = ele1.ele('xpath://div')
 
 # 获取 div 元素的 class 属性，返回字符串
 txt = ele1.ele('xpath://div/@class')  
 ```
 
 ?> **Tips:**   <br>
-查找元素的后代时，selenium 原生代码要求 xpath 前面必须加`.`，否则会变成在全个页面中查找。笔者觉得这个设计是画蛇添足，既然已经通过元素查找了，自然应该只查找这个元素内部的元素。所以，用 xpath 在元素下查找时，最前面`//`或`/`前面的`.`可以省略。
-
-
+查找元素的后代时，selenium 原生代码要求 xpath 前面必须加`.`，否则会变成在全个页面中查找。笔者觉得这个设计是画蛇添足，既然已经通过元素查找了，自然应该只查找这个元素内部的元素。所以，用 xpath
+在元素下查找时，最前面`//`或`/`前面的`.`可以省略。
 
 ## selenium 的 loc 元组
 
@@ -430,7 +400,7 @@ txt = ele1.ele('xpath://div/@class')
 ```python
 # 查找 id 为 ele_id 的元素
 loc1 = By.ID, 'ele_id'
-ele = page.ele(loc1)  
+ele = page.ele(loc1)
 
 # 按 xpath 查找
 loc2 = By.XPATH, '//div[@class="ele_class"]'
@@ -443,16 +413,16 @@ d 模式下所有查找元素操作都自带等待，默认为跟随元素所在
 
 ```python
 # 页面初始化时设置查找元素超时时间为 15 秒
-page = MixPage(timeout=15)  
+page = MixPage(timeout=15)
 # 设置查找元素超时时间为 5 秒
-page.timeout = 5  
+page.timeout = 5
 
 # 使用页面超时时间来查找元素（5 秒）
-ele1 = page.ele('some text')  
+ele1 = page.ele('some text')
 # 为这次查找页面独立设置等待时间（1 秒）
-ele1 = page.ele('some text', timeout=1)  
+ele1 = page.ele('some text', timeout=1)
 # 查找后代元素，使用页面超时时间（5 秒）
-ele2 = ele1.ele('some text')  
+ele2 = ele1.ele('some text')
 # 查找后代元素，使用单独设置的超时时间（1 秒）
 ele2 = ele1.ele('some text', timeout=1)  
 ```
@@ -480,8 +450,6 @@ ele2 = ele1.parent(2)
 ele2 = ele1.parent('#id1')
 ```
 
-
-
 ## next()
 
 此方法返回当前元素后面的某一个兄弟元素，可指定筛选条件和第几个。
@@ -508,8 +476,6 @@ ele2 = ele1.next(3, 'tag:div')
 txt = ele1.next(1, 'xpath:text()')
 ```
 
-
-
 ## nexts()
 
 此方法返回后面全部符合条件的兄弟元素或节点组成的列表，可用查询语法筛选。
@@ -532,8 +498,6 @@ divs = ele1.nexts('tag:div')
 txts = ele1.nexts('xpath:text()')
 ```
 
-
-
 ## prev()
 
 此方法返回当前元素前面的某一个兄弟元素，可指定筛选条件和第几个。
@@ -560,8 +524,6 @@ ele2 = ele1.prev(3, 'tag:div')
 txt = ele1.prev(1, 'xpath:text()')
 ```
 
-
-
 ## prevs()
 
 此方法返回前面全部符合条件的兄弟元素或节点组成的列表，可用查询语法筛选。
@@ -581,8 +543,6 @@ eles = ele1.prevs()
 divs = ele1.prevs('tag:div')
 ```
 
-
-
 ## after()
 
 此方法返回当前元素后面的某一个元素，可指定筛选条件和第几个。这个方法查找范围不局限在兄弟元素间，而是整个 DOM 文档。
@@ -606,8 +566,6 @@ ele2 = ele1.after(3, 'tag:div')
 txt = ele1.after(1, 'xpath:text()')
 ```
 
-
-
 ## afters()
 
 此方法返回后面符合条件的全部元素或节点组成的列表，可用查询语法筛选。这个方法查找范围不局限在兄弟元素间，而是整个 DOM 文档。
@@ -627,8 +585,6 @@ eles = ele1.prevs()
 divs = ele1.prevs('tag:div')
 ```
 
-
-
 ## before()
 
 此方法返回当前元素前面的某一个元素，可指定筛选条件和第几个。这个方法查找范围不局限在兄弟元素间，而是整个 DOM 文档。
@@ -652,8 +608,6 @@ ele2 = ele1.before(3, 'tag:div')
 txt = ele1.before(1, 'xpath:text()')
 ```
 
-
-
 ## befores()
 
 此方法返回前面全部符合条件的元素或节点组成的列表，可用查询语法筛选。这个方法查找范围不局限在兄弟元素间，而是整个 DOM 文档。
@@ -698,8 +652,6 @@ ele2 = ele1.left(3)
 ele2 = ele1.left(3, 'tag:div')
 ```
 
-
-
 ## lefts()
 
 此方法返回左边全部符合条件的元素组成的列表，可用查询语法筛选。
@@ -718,8 +670,6 @@ eles = ele1.lefts()
 divs = ele1.lefts('tag:div')
 ```
 
-
-
 ## right()
 
 此方法返回当前元素左边的某一个元素，可指定筛选条件和第几个。
@@ -739,8 +689,6 @@ ele2 = ele1.right(3)
 ele2 = ele1.right(3, 'tag:div')
 ```
 
-
-
 ## rights()
 
 此方法返回右边全部符合条件的元素组成的列表，可用查询语法筛选。
@@ -759,8 +707,6 @@ eles = ele1.rights()
 divs = ele1.rights('tag:div')
 ```
 
-
-
 ## below()
 
 此方法返回当前元素下边的某一个元素，可指定筛选条件和第几个。
@@ -780,8 +726,6 @@ ele2 = ele1.below(3)
 ele2 = ele1.below(3, 'tag:div')
 ```
 
-
-
 ## belows()
 
 此方法返回下边全部符合条件的元素组成的列表，可用查询语法筛选。
@@ -800,8 +744,6 @@ eles = ele1.belows()
 divs = ele1.belows('tag:div')
 ```
 
-
-
 ## above()
 
 此方法返回当前元素上边的某一个元素，可指定筛选条件和第几个。
@@ -821,8 +763,6 @@ ele2 = ele1.above(3)
 ele2 = ele1.above(3, 'tag:div')
 ```
 
-
-
 ## aboves()
 
 此方法返回上边全部符合条件的元素组成的列表，可用查询语法筛选。
@@ -841,8 +781,6 @@ eles = ele1.aboves()
 divs = ele1.aboves('tag:div')
 ```
 
-
-
 ## near()
 
 此方法返回最接近当前元素的某一个元素，可指定筛选条件和第几个。
@@ -862,8 +800,6 @@ ele2 = ele1.near(3)
 ele2 = ele1.near(3, 'tag:div')
 ```
 
-
-
 ## nears()
 
 此方法返回该元素附近全部符合条件的元素组成的列表，可用查询语法筛选。
@@ -888,7 +824,8 @@ divs = ele1.nears('tag:div')
 对`ShadowRootElement`对象进行相对定位时，把它看作其父对象内部的第一个对象，其余定位逻辑与普通对象一致。
 
 !> **注意：**  <br>
-如果`ShadowRootElement`元素的下级元素中有其它`ShadowRootElement`元素，那这些下级`ShadowRootElement`元素内部是无法直接通过定位语句查找到的，只能先定位到其父元素，再用`shadow-root`属性获取。
+如果`ShadowRootElement`元素的下级元素中有其它`ShadowRootElement`元素，那这些下级`ShadowRootElement`
+元素内部是无法直接通过定位语句查找到的，只能先定位到其父元素，再用`shadow-root`属性获取。
 
 ```python
 # 获取一个 shadow-root 元素
@@ -919,13 +856,13 @@ sr_ele2 = sr_ele.ele('tag:div').shadow_root
 
 ```python
 # 定位到页面中 id 为 table_id 的元素，然后获取它的所有 tr 元素
-eles = page('#table_id').eles('t:tr')  
+eles = page('#table_id').eles('t:tr')
 
 # 定位到 class 为 cls 的元素，然后在它里面查找文本为 text 的元素
-ele2 = ele1('.cls1')('tx=text')  
+ele2 = ele1('.cls1')('tx=text')
 
 # 获取 ele1 的 shadow_root 元素，再在里面查找 class 属性为 cls 的元素
-ele2 = ele1.sr('.cls')  
+ele2 = ele1.sr('.cls')
 
 # 按xpath 查找元素
 ele2 = ele1('x://div[@class="ele_class"]')  
diff --git a/docs/使用方法/页面操作.md b/docs/使用方法/页面操作.md
index e0414ce..24fe034 100644
--- a/docs/使用方法/页面操作.md
+++ b/docs/使用方法/页面操作.md
@@ -226,6 +226,16 @@ page.run_script('alert(arguments[0]+arguments[1])', 'Hello', ' world!')
 
 返回：`None`
 
+## set_ua_to_tab()
+
+此方法用于为当前 tab 设置 user agent，只在当前 tab 有效。
+
+参数：
+
+- ua：user agent字符串
+
+返回：None
+
 ## to_frame
 
 此属性用于将页面焦点移到某个`frame`或`iframe`。