前提要求：具备python基础便可以，老年人也无妨~
这里针对的是selenium常见、常用的API操作，更多应用于web项目中。
一、开始selenium的旅程
1、安装selenium和浏览器驱动
使用指令对selenium进行安装，如果使用pycharm这样的编译器，注意在开启项目前调整项目运行环境
pip install selenium你需要对selenimu的版本进行指定，目前看selenium4是一个非常不稳定，且bug频出的版本，推荐使用selenium3
pip install selenium3.14.0你需要了解你的浏览器版本信息，并在网上下载它对应版本的驱动，他们广泛的存在与网络中，并且很好找到，搜索：xxx浏览器驱动。
在驱动的安装中，你需要将驱动文件存在一个比较方便管理的位置，并为它添加系统环境变量，我的电脑>>右键属性>>高级系统设置>>高级>>环境变量>>系统变量>>Path，并且把他复制2份到浏览器根目录和你的备份文件夹中（个人习惯）
2、开始一个简单的例子
打开百度首页，以谷歌chrome浏览器为例子
#导入selenium
from selenium import webdriver
#实例化浏览器驱动对象
driver= webdriver.Chrome()
#Navigate to url，打开网页
driver.get("http://www.baidu.com")
使用不同的浏览器对应不同的驱动实例化写法：
webdriver.Chrome(可接收参数、不写就是默认，也没问题)
driver= webdriver.Chrome()#谷歌
driver= webdriver.Firefox()#火狐
driver= webdriver.Ie()#IE如果实例化的驱动对象不是一个全局，打开的浏览器页面会在代码执行后自动关闭
我们需要对参数进行设置，避免关闭
option = webdriver.ChromeOptions()
option.add_experimental_option("detach", True)
#将option参数传入Chrome中
driver = webdriver.Chrome(chrome_options=option)
二、定位元素
元素选择策略
在 WebDriver 中有 8 种不同的内置元素定位策略：
| 定位器 Locator | 描述 |
|---|---|
| class name | 定位class属性与搜索值匹配的元素（不允许使用复合类名） |
| css selector | 定位 CSS 选择器匹配的元素 |
| id | 定位 id 属性与搜索值匹配的元素 |
| name | 定位 name 属性与搜索值匹配的元素 |
| link text | 定位link text可视文本与搜索值完全匹配的锚元素 |
| partial link text | 定位link text可视文本部分与搜索值部分匹配的锚点元素。如果匹配多个元素，则只选择第一个元素。 |
| tag name | 定位标签名称与搜索值匹配的元素 |
| xpath | 定位与 XPath 表达式匹配的元素 |
网络元素 | Selenium在DOM中识别和使用元素对象.
https://www.selenium.dev/zh-cn/documentation/webdriver/elements/
1、基础的元素定位
selenium给出了一些看名字会用的元素定位API，简单好用，干净又卫生，但这里也许你需要了解一些简单的前端小知识。
前端小知识：(其实不看也无所谓...因为就那么点东西)
基础的元素/标签定位: id、name、class、tag、Link（可见文本）、partial Link（模糊可见文本）
网页示例：（仅仅表示以下，并未和正文API操作有太大的关联）
<ol id="vegetables" name='vga'>
<li class="potatoes">…
<li class="onions">…
<li class="tomatoes"><span>Tomato is a Vegetable</span>…
</ol>
<ul id="fruits" name='green'>
<li class="bananas">…
<li class="apples">…
<li class="tomatoes"><span>Tomato is a Fruit</span>…
</ul>id：参数为id 2种代码书写方法
#返回一个元素
#找到ID为fruist的标签，如果有多个id相同，默认返回找到的第一个标签
fruits = driver.find_element(By.ID, "fruits")
fruit = fruits.find_element_by_id("tomatoes")
#返回一个元素list
#找到ID为tomatose的标签
fruits = driver.find_elements(By.ID, "fruits")
fruit = fruits.find_elements_by_id("tomatoes")
#我们注意到因为返回的是一个标签列表，所以是find_elements
name:参数为name 2种代码书写方法
#返回一个元素
#找到name为vga的标签，如果有多个id相同，默认返回找到的第一个标签
fruits = driver.find_element(By.Name, "vga")
fruit = fruits.find_element_by_name("vga")
#返回一个元素list
fruits = driver.find_elements(By.Name, "vga")
fruit = fruits.find_elements_by_name("")
class: 参数为class 2种代码书写方法
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.CLASS_NAME,'')
ele = driver.find_element_by_class_name('')
#返回元素列表
eles = driver.find_elements(By.CLASS_NAME,'')
eles = driver.find_elements_by_class_name('')tag: 参数为标签名 2种代码书写方法
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.TAG_NAME,'')
ele = driver.find_element_by_tag_name('')
#返回元素列表
eles = driver.find_elements(By.TAG_NAME,'')
eles = driver.find_elements_by_tag_name('')link: 参数为可见的文本 如<p>我是可见文本</p>
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.LINK_TEXT,'我是可见文本')
ele = driver.find_element_by_link_text('我是可见文本')
#返回元素列表
eles = driver.find_elements(By.LINK_TEXT,'我是可见文本')
eles = driver.find_elements_by_link_text('我是可见文本')partial link ：模糊文本定位，即不用传入精准的参数 如<p>我是可见文本</p>，使用：我是、可见、文本都可以
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.PARTIAL_LINK_TEXT,'文本')
ele = driver.find_element_by_partial_link_text('我是')
#返回元素列表
ele = driver.find_elements(By.PARTIAL_LINK_TEXT,'我是')
ele = driver.find_elements_by_partial_link_text('文本')
2、好用的元素定位
比较好用的是css选择器定位和XPATH路径定位
CSS定位速度块，个人比较喜欢
CSS选择器用于选择你想要的元素的样式的模式。
"CSS"列表示在CSS版本的属性定义（CSS1，CSS2，或对CSS3）。
| 选择器 | 示例 | 示例说明 | CSS |
|---|---|---|---|
| .class | .intro | 选择所有class="intro"的元素 | 1 |
| #id | #firstname | 选择所有id="firstname"的元素 | 1 |
| * | * | 选择所有元素 | 2 |
| element | p | 选择所有<p>元素 | 1 |
| element,element | div,p | 选择所有<div>元素和<p>元素 | 1 |
| element element | div p | 选择<div>元素内的所有<p>元素 | 1 |
| element>element | div>p | 选择所有父级是 <div> 元素的 <p> 元素 | 2 |
| element+element | div+p | 选择所有紧跟在 <div> 元素之后的第一个 <p> 元素 | 2 |
| [attribute] | [target] | 选择所有带有target属性元素 | 2 |
| [attribute=value] | [target=-blank] | 选择所有使用target="-blank"的元素 | 2 |
| [attribute~=value] | [title~=flower] | 选择标题属性包含单词"flower"的所有元素 | 2 |
| [attribute|=language] | [lang|=en] | 选择 lang 属性等于 en，或者以 en- 为开头的所有元素 | 2 |
| :link | a:link | 选择所有未访问链接 | 1 |
| :visited | a:visited | 选择所有访问过的链接 | 1 |
| :active | a:active | 选择活动链接 | 1 |
| :hover | a:hover | 选择鼠标在链接上面时 | 1 |
| :focus | input:focus | 选择具有焦点的输入元素 | 2 |
| :first-letter | p:first-letter | 选择每一个<p>元素的第一个字母 | 1 |
| :first-line | p:first-line | 选择每一个<p>元素的第一行 | 1 |
| :first-child | p:first-child | 指定只有当<p>元素是其父级的第一个子级的样式。 | 2 |
| :before | p:before | 在每个<p>元素之前插入内容 | 2 |
| :after | p:after | 在每个<p>元素之后插入内容 | 2 |
| :lang(language) | p:lang(it) | 选择一个lang属性的起始值="it"的所有<p>元素 | 2 |
| element1~element2 | p~ul | 选择p元素之后的每一个ul元素 | 3 |
| [attribute^=value] | a[src^="https"] | 选择每一个src属性的值以"https"开头的元素 | 3 |
| [attribute$=value] | a[src$=".pdf"] | 选择每一个src属性的值以".pdf"结尾的元素 | 3 |
| [attribute*=value] | a[src*="runoob"] | 选择每一个src属性的值包含子字符串"runoob"的元素 | 3 |
| :first-of-type | p:first-of-type | 选择每个p元素是其父级的第一个p元素 | 3 |
| :last-of-type | p:last-of-type | 选择每个p元素是其父级的最后一个p元素 | 3 |
| :only-of-type | p:only-of-type | 选择每个p元素是其父级的唯一p元素 | 3 |
| :only-child | p:only-child | 选择每个p元素是其父级的唯一子元素 | 3 |
| :nth-child(n) | p:nth-child(2) | 选择每个p元素是其父级的第二个子元素 | 3 |
| :nth-last-child(n) | p:nth-last-child(2) | 选择每个p元素的是其父级的第二个子元素，从最后一个子项计数 | 3 |
| :nth-of-type(n) | p:nth-of-type(2) | 选择每个p元素是其父级的第二个p元素 | 3 |
| :nth-last-of-type(n) | p:nth-last-of-type(2) | 选择每个p元素的是其父级的第二个p元素，从最后一个子项计数 | 3 |
| :last-child | p:last-child | 选择每个p元素是其父级的最后一个子级。 | 3 |
| :root | :root | 选择文档的根元素 | 3 |
| :empty | p:empty | 选择每个没有任何子级的p元素（包括文本节点） | 3 |
| :target | #news:target | 选择当前活动的#news元素（包含该锚名称的点击的URL） | 3 |
| :enabled | input:enabled | 选择每一个已启用的输入元素 | 3 |
| :disabled | input:disabled | 选择每一个禁用的输入元素 | 3 |
| :checked | input:checked | 选择每个选中的输入元素 | 3 |
| :not(selector) | :not(p) | 选择每个并非p元素的元素 | 3 |
| ::selection | ::selection | 匹配元素中被用户选中或处于高亮状态的部分 | 3 |
| :out-of-range | :out-of-range | 匹配值在指定区间之外的input元素 | 3 |
| :in-range | :in-range | 匹配值在指定区间之内的input元素 | 3 |
| :read-write | :read-write | 用于匹配可读及可写的元素 | 3 |
| :read-only | :read-only | 用于匹配设置 "readonly"（只读） 属性的元素 | 3 |
| :optional | :optional | 用于匹配可选的输入元素 | 3 |
| :required | :required | 用于匹配设置了 "required" 属性的元素 | 3 |
| :valid | :valid | 用于匹配输入值为合法的元素 | 3 |
| :invalid | :invalid | 用于匹配输入值为非法的元素 | 3 |
CSS选择器定位语法： 这里传入css选择语法
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.CSS_SELECTOR,'')
ele = driver.find_element_by_css_selector('')
#返回元素列表
ele = driver.find_elements(By.CSS_SELECTOR,'')
ele = driver.find_elements_by_css_selector('')XPATH:需要了解一些相关知识，但推荐安装浏览器定位插件一边用一边学比较上手块，比如Chrom的chrPath插件，以下为Xpath语法
#返回单个元素，如果存在多个用于定位所传入属性相同的，默认返回第一个
ele = driver.find_element(By.XPATH,'')
ele = driver.find_element_by_xpath('')
#返回元素列表
ele = driver.find_elements(By.XPATH,'')
ele = driver.find_elements_by_xpath('')3、进阶的元素定位
在selenium定位中经常回遇到一些令人懊恼，不好定位的元素，他们也许是不可见的，也许是和鼠标动作有关，但通过精进的定位，依然可以找到。
3.1 从父级元素中寻找子级元素
一个子级元素 = father.Ele.find_element(By.xxx,子级元素选择语句)
一个子级元素list = father.Ele.find_elements(By.xxx,子级元素选择语句)
3.2 定位不可见的元素
一般不可见的元素会有一个标签属性叫 style="display: none"，或者通过CSS控制让它不可见，我们可以通过js语句让它变为可见的。
#编写JS语句
js = "document.getElementById('Title').style.display='block'"
#执行JS,让元素显现出来，用于定位
driver.execute_script(js) selenium中执行网页js语句
driver.execute_script('js语句')这里用到JS DOM元素属性修改的一些知识
HTML DOM 修改 | 菜鸟教程HTML DOM - 修改 修改 HTML = 改变元素、属性、样式和事件。 修改 HTML 元素 修改 HTML DOM 意味着许多不同的方面： 改变 HTML 内容 改变 CSS 样式 改变 HTML 属性 创建新的 HTML 元素 删除已有的 HTML 元素 改变事件（处理程序） 在接下来的章节，我们会深入学习修改 HTML DOM 的常用方法。 创建 HTML 内容 改变元素内容的最简单的方法是使用 inn..https://www.runoob.com/htmldom/htmldom-modify.html例如<div id = 'd1' style = ' dispaly ：none'></div> 如果直接定位，很可能定位失败，不妨：
#JS语句
js = "document.getElementById('d1').style.display='block'"
#执行js语句，让不可见的元素显示，用于定位
driver.execute_script(js) 3.3 定位的升华
3.3.1 selenium 获取元素CSS值
# Retrieves the computed style property 'color' of linktext
cssValue = driver.findElement(By.LINK_TEXT, "More information...").value_of_css_property('color')3.3.2 selenium 获取元素的文本
# Retrieves the text of the element
text = driver.find_element(By.CSS_SELECTOR, "h1").text3.3.3 Is Element Selected selenium判断元素是否被选中
此方法确定是否 已选择 引用的元素. 此方法广泛用于复选框, 单选按钮, 输入元素和选项元素.
返回一个布尔值, 如果在当前浏览上下文中 已选择 引用的元素, 则返回 True, 否则返回 False.
# Returns true if element is checked else returns false
value = driver.find_element(By.CSS_SELECTOR, "input[type='checkbox']:first-of-type").is_selected()3.3.4 selenium 获取参考元素的尺寸和坐标.提取的数据主体包含以下详细信息:
元素左上角的X轴位置
元素左上角的y轴位置
元素的高度
元素宽度
# Returns height, width, x and y coordinates referenced element
res = driver.find_element(By.CSS_SELECTOR, "h1").rect3.3.5 selenium获取元素内的值
# Get attribute of current active element
attr = driver.switch_to.active_element.get_attribute("title")3.3.6 selenium above\below\left of\right or\near 上下左右旁边定位 这个用的很少，但还是用得到,用法如文意，一眼便知道
上above
#定位一个在id = password 之上的input 标签
email_locator = locate_with(By.TAG_NAME, "input").above({By.ID: "password"})下below
#定位一个id = email之下的input标签
password_locator = locate_with(By.TAG_NAME, "input").below({By.ID: "email"})左left of、右right of
cancel_locator = locate_with(By.TAG_NAME, "button").to_left_of({By.ID: "submit"})
submit_locator = locate_with(By.TAG_NAME, "button").to_right_of({By.ID: "cancel"})旁边near
如果相对定位不明显，或根据窗口大小而变化，官方给出的说明是定位50px之内的标签，我没用过，估计项目写的少，没见到。
email_locator = locate_with(By.TAG_NAME, "input").near({By.ID: "lbl-email"})
三、浏览器的操作
1、浏览器的前进、后退、刷新、退出
driver.forward()#前进
driver.back()#后退
driver.refresh()#刷新
driver.quit()#退出浏览器，大退
driver.close()#关闭标签页，小退2、JS弹出框的操作
浏览器弹窗行为一般就三种：警告alert 提示prompt 确认confirm
2.1 警告弹窗
# Wait for the alert to be displayed and store it in a variable
#等待弹窗显示，获取弹窗对象
alert = wait.until(expected_conditions.alert_is_present())
#获取弹窗文本
# Store the alert text in a variable
text = alert.text
#点确认让它消失
# Press the OK button
alert.accept()2.2 提示弹窗
# Wait for the alert to be displayed
#等待窗口弹出
wait.until(expected_conditions.alert_is_present())
#获取弹窗对象
# Store the alert in a variable for reuse
alert = Alert(driver)
#向弹窗对象输入内容selenium
# Type your message
alert.send_keys("Selenium")
#点击OK让他消失
# Press the OK button
alert.accept()
2.3 确认弹窗
#等待弹出
# Wait for the alert to be displayed
wait.until(expected_conditions.alert_is_present())
#获取弹窗对象
# Store the alert in a variable for reuse
alert = driver.switch_to.alert
#获取弹窗文本
# Store the alert text in a variable
text = alert.text
#点击取消，让它消失
# Press the Cancel button
alert.dismiss()3、浏览器窗口\选项卡（windos）与内置窗口/嵌套窗口/嵌套框架（frame/iframe）切换的操作
由于selenium具备焦点fouce的概念，同时开启多个窗口、选项卡、或单一页面有很多子窗口（iframe）的情况下跳跃定位和实现其他功能，所以要进行焦点切换的操作。
3.1 选项卡跳跃切换的操作
如果你的站点打开了一个新标签页或窗口，Selenium 使用窗口句柄来处理它。 每个窗口都有一个唯一的标识符，该标识符在单个会话中保持持久性。
获得当前窗口和已经打开的窗口list的句柄:
#获取当前唯一窗口
windowHandle = driver.current_window_handle
#获得已经打开的窗口，返回一个窗口对象list
windowHandles = driver.current_window_handles切换窗口焦点：
这里引用官方API建议方法，但是实际上你可以直接操作窗口list来进行切换，既windowHandles[0]、windowHandles[1]
官方推荐：
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
# 启动驱动程序
with webdriver.Firefox() as driver:
# 打开网址
driver.get("https://seleniumhq.github.io")
# 设置等待
wait = WebDriverWait(driver, 10)
# 存储原始窗口的 ID
original_window = driver.current_window_handle
# 检查一下，我们还没有打开其他的窗口
assert len(driver.window_handles) == 1
# 单击将在在新窗口中打开的链接标签
driver.find_element(By.LINK_TEXT, "new window").click()
# 等待新窗口或标签页
wait.until(EC.number_of_windows_to_be(2))
# 循环执行，直到找到一个新的窗口句柄
for window_handle in driver.window_handles:
if window_handle != original_window:
#这一步就是窗口切换！
driver.switch_to.window(window_handle)
break
# 等待新标签页完成加载内容
wait.until(EC.title_is("SeleniumHQ Browser Automation"))实际使用中：
#直接切换。。。
driver.switch_to.window(window_handles[x])3.2 单窗口下iframe的切换 操作
现在大多数功能集中的网页往往都使用frame/iframe,直接定位元素是不可能定位到的，某种情况下可以理解为html嵌套html，在原有html中打开了一个新的html，所以要切换焦点
切换的方法有很多种：
# 用选择器找到iframe
iframe = driver.find_element(By.CSS_SELECTOR, "#modal > iframe")
# 切换到选择的 iframe
driver.switch_to.frame(iframe)
#---------------------------------------------------------------
#frame 或 iframe 具有 id 或 name 属性，则可以使用该属性。如果名称或 id
#在页面上不是唯一的， 那么将切换到找到的第一个,传id\name 都可以
driver.switch_to.frame('targetframe')
# 基于索引切换到第 2 个 iframe，因为使用tag_name 方法返回的是iframe列表，用索引直接切换
iframe = driver.find_elements_by_tag_name('iframe')[1]
#返回到当前网页，既最外层的环境
driver.switch_to.default_content()
4、截屏
driver.get_screenshot_as_file("Filepath")四、鼠标、键盘的操作
0、Action 接口（很重要）详解
(来自W3C的解释：)Actions API 提供了一个低级接口，用于向 Web 浏览器提供虚拟化设备输入,Actions 命令将用户行为进行排列记录。用户、虚拟用户端发送一系列动作指令，这些动作对应于每个输入设备的操作。
selenium中的ActionChains
源码注释：
"""
ActionChains are a way to automate low level interactions such as
mouse movements, mouse button actions, key press, and context menu interactions.
This is useful for doing more complex actions like hover over and drag and drop.
Generate user actions.
When you call methods for actions on the ActionChains object,
the actions are stored in a queue in the ActionChains object.
When you call perform(), the events are fired in the order they
are queued up.
ActionChains can be used in a chain pattern::
menu = driver.find_element_by_css_selector(".nav")
hidden_submenu = driver.find_element_by_css_selector(".nav #submenu1")
ActionChains(driver).move_to_element(menu).click(hidden_submenu).perform()
Or actions can be queued up one by one, then performed.::
menu = driver.find_element_by_css_selector(".nav")
hidden_submenu = driver.find_element_by_css_selector(".nav #submenu1")
actions = ActionChains(driver)
actions.move_to_element(menu)
actions.click(hidden_submenu)
actions.perform()
Either way, the actions are performed in the order they are called, one after
another.
"""ActionChains可以理解为鼠标键盘一切动作组合起来的动作链，按照顺序依次执行，官方注释给出了将接口实例化的用法：
#实例化接口
actions = ActionChains(driver)
#添加第一个动作，鼠标移动到元素上
actions.move_to_element(menu)
#添加第二个动作，点击元素
actions.click(hidden_submenu)
#整个动作链开始执行
actions.perform()
1、点击、右击/右键、双击
#鼠标点击
ele.click()
#也可以：
act = ActionChains(driver)
act.click(ele)
act.perform()
#鼠标右击
webdriver.ActionChains(driver).context_click(ele).perform()
#也可以：
act = ActionChains(driver)
act.context_click(ele)
act.perform()
#鼠标双击
webdriver.ActionChains(driver).double_click(ele).perform()
#也可以：
act = ActionChains(driver)
act.double_click(ele)
act.perform()2、移动、拖拽
#移动到元素中心位置
move_to_element(gmailLink)
#移动到指定位置（X坐标，Y坐标）
move_by_offset(xOffset,yOffset)
#点击元素拖拽到目标元素位置
drag_and_drop(sourceEle,targetEle)
#源元素上单击并按住, 移至给定的偏移量后释放鼠标.
drag_and_drop_by_offset(sourceEle, targetEleXOffset, targetEleYOffset)
#鼠标释放
action.release()3、其他
鼠标滚轮操作：等到selenium更新后填坑
4、键盘操作
首先就是向输入框或者可输入元素单位传入文本：
ele.send_keys('context')
其次就是selenium键盘按下、抬起的操作
#输入q,之后按下回车
# Enter "webdriver" text and perform "ENTER" keyboard action
driver.find_element(By.NAME, "q").send_keys("webdriver" + Keys.ENTER)
#CTRL + A
# Perform action ctrl + A (modifier CONTROL + Alphabet A) to select the page
webdriver.ActionChains(driver).key_down(Keys.CONTROL).send_keys("a").perform()
#按住shift输入qwerty按下回车之后松开SHIFT输入qwerty
# Enters text "qwerty" with keyDown SHIFT key and after keyUp SHIFT key (QWERTYqwerty)
action.key_down(Keys.SHIFT).send_keys_to_element(search, "qwerty").key_up(Keys.SHIFT).send_keys("qwerty").perform()
五、等待元素加载
这是selenium官方给出的等待期望条件的全部链接，虽然是4.10版本的，但实际上向下几乎全部兼容
1、隐式等待
不要和显式等待混用，容易出bug,隐式等待作用于driver，所以它的影响是全局的，不推荐用。
#一般写在在生成driver对象后，对所有的操作都可以最大等待10秒，超出则报异常
driver.implicitly_wait(10)2、显式等待
不要和隐式等待混用，容易出bug,显示等待 是Selenium客户可以使用的命令式过程语言。它们允许您的代码暂停程序执行，或冻结线程，直到满足通过的 条件 。这个条件会以一定的频率一直被调用，直到等待超时。这意味着只要条件返回一个假值，它就会一直尝试和等待
由于显式等待允许您等待条件的发生，所以它们非常适合在浏览器及其DOM和WebDriver脚本之间同步状态。
driver.navigate("https://www.baidu.com")
#在DOM执行完成前，都在等待，超出30秒报错
WebDriverWait(driver，30).until('driver.execute_script("DOM指令")')
#之后便开始找到元素
ele = driver.find_element(By.TAG_NAME, "p")3、流畅等待
重点
流畅等待可以自定义等待条件的最大时间量，以及检查条件的频率。
用户可以配置等待来忽略等待时出现的特定类型的异常，例如在页面上搜索元素时出现的
driver = Firefox()
driver.get("http://somedomain/url_that_delays_loading")
#参数（driver对象，等待10S，间隔1S执行条件，忽略异常）
wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))六、cookit
官方文档：
同cookies一起工作 | Seleniumhttps://www.selenium.dev/zh-cn/documentation/webdriver/browser/cookies/
扫一扫
834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
