前言
為了鞏固所學(xué)的知識，作者嘗試著開始發(fā)布一些學(xué)習(xí)筆記類的博客，方便日后回顧。當(dāng)然，如果能幫到一些萌新進(jìn)行新技術(shù)的學(xué)習(xí)那也是極好的。作者菜菜一枚，文章中如果有記錄錯誤，歡迎讀者朋友們批評指正。
（博客的參考源碼可以在我主頁的資源里找到，如果在學(xué)習(xí)的過程中有什么疑問歡迎大家在評論區(qū)向我提出）
發(fā)現(xiàn)寶藏
前些天發(fā)現(xiàn)了一個巨牛的人工智能學(xué)習(xí)網(wǎng)站，通俗易懂，風(fēng)趣幽默，忍不住分享一下給大家。【寶藏入口】。
第01節(jié) Selenium概述
Selenium 是一個Web的自動化測試工具，最初是為網(wǎng)站自動化測試而開發(fā)的，Selenium 可以直接運(yùn)行
在瀏覽器上，它支持所有主流的瀏覽器
因?yàn)?Selenium 可以控制瀏覽器發(fā)送請求，并獲取網(wǎng)頁數(shù)據(jù)，因此可以應(yīng)用于爬蟲領(lǐng)域
Selenium 可以根據(jù)我們的指令，讓瀏覽器自動加載頁面，獲取需要的數(shù)據(jù)，甚至頁面截屏，或者判斷網(wǎng)
站上某些動作是否發(fā)生
Selenium 自己不帶瀏覽器，不支持瀏覽器的功能，它需要與第三方瀏覽器結(jié)合在一起才能使用
Selenium 庫的版本不同對應(yīng)的方法名也會有所不同
官方文檔：http://selenium-python.readthedocs.io/index.html
第02節(jié) 安裝瀏覽器驅(qū)動（以Google為例）
1. 確認(rèn)瀏覽器版本
2. 下載對應(yīng)版本的驅(qū)動
3. 如何下載歷史版本的 chorm
- 獲得瀏覽器版本號
訪問 https://vikyd.github.io/download-chromium-history-version/ ，可能需要科學(xué)上網(wǎng)（dddd），然后在 version 下拉里面選擇你要的平臺，然后在輸入框輸入版本號，例如 : windows 64位 113.0版本
- 選擇瀏覽器版本并下載壓縮包
- 下載完成后解壓即可使用
- 將 chromedriver.exe 保存到任意位置，并把當(dāng)前路徑保存到環(huán)境變量中（我的電腦>>右鍵屬性>>高級系統(tǒng)設(shè)置>>高級>>環(huán)境變量>>系統(tǒng)變量>>Path），添加的時候要注意不要把 path 變量給覆蓋了，如果覆蓋了千萬別關(guān)機(jī)，然后百度。添加成功后使用下面代碼進(jìn)行測試。
# 導(dǎo)入 webdriver
import time
from selenium import webdriver
# 調(diào)用環(huán)境變量指定的PhantomJS瀏覽器創(chuàng)建瀏覽器對象
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
# get方法會一直等到頁面被完全加載，然后才會繼續(xù)程序，通常測試會在這里選擇
driver.get("https://www.baidu.com/")
# id="kw"是百度搜索輸入框，輸入字符串"長城"
driver.find_element(By.CSS_SELECTOR,"#kw").send_keys("長城")
# id="su"是百度搜索按鈕，click() 是模擬點(diǎn)擊
driver.find_element(By.CSS_SELECTOR,"#su").click()
time.sleep(20)
第03節(jié) 定位頁面元素
定位一個元素用 element,定位一組元素用 elements
1. 打開指定頁面
1. 不切換新窗口
要使用 Selenium 來打開指定頁面，首先需要初始化一個 WebDriver 實(shí)例，然后使用該實(shí)例打開目標(biāo)頁面。下面是一個使用 Python 和 Selenium 的示例，演示如何打開指定的頁面：
from selenium import webdriver
# 初始化一個WebDriver實(shí)例，這里使用Chrome作為瀏覽器
driver = webdriver.Chrome()
# 打開指定的頁面，將URL替換為你要訪問的網(wǎng)頁地址
url = "https://www.example.com"
driver.get(url)
# 在這里，你可以執(zhí)行與打開頁面相關(guān)的操作
# 最后，關(guān)閉瀏覽器窗口
driver.quit()
在上述代碼中，我們首先導(dǎo)入 Selenium 的 webdriver 模塊，并初始化了一個 Chrome 瀏覽器的 WebDriver 實(shí)例。然后，使用 get 方法打開指定的頁面，將目標(biāo)網(wǎng)頁的 URL 替換為你要訪問的網(wǎng)頁地址。之后，你可以在頁面上執(zhí)行與你的測試或任務(wù)相關(guān)的操作，然后使用 quit 方法關(guān)閉瀏覽器窗口
2. 切換新窗口
上面的方法會在當(dāng)前窗口或標(biāo)簽頁中打開一個新的頁面，將當(dāng)前頁面替換為新的 URL ，使用 window.open(url) 打開新頁面：
driver.execute_script("window.open('https://www.example.com', '_blank');") # 使用JavaScript打開一個新頁面
這種方法使用 execute_script 方法執(zhí)行 JavaScript 代碼，在新的瀏覽器窗口或標(biāo)簽頁中打開指定的 URL。'_blank' 參數(shù)告訴瀏覽器在新窗口或標(biāo)簽頁中打開 URL。這種方式適用于在新窗口中打開頁面，而不替換當(dāng)前頁面
請注意，如果你使用 window.open() 方法打開新頁面，你可能需要使用 driver.window_handles 和 driver.switch_to.window() 來管理不同窗口之間的切換，就像后面提到的窗口句柄一樣。這可以讓你在不同的瀏覽器窗口中執(zhí)行操作
總之，execute_script 方法通常與其他 Selenium 方法一起使用，用于執(zhí)行 JavaScript 以實(shí)現(xiàn)特定的交互和操作，但它本身不用于打開新頁面
3. 保持瀏覽器窗口打開
默認(rèn)情況下，Selenium WebDriver 在腳本執(zhí)行結(jié)束后會關(guān)閉瀏覽器窗口，但通過將選項(xiàng) "detach" 設(shè)置為 True，你可以使瀏覽器窗口保持打開狀態(tài)，以便手動進(jìn)行操作
from selenium import webdriver
# 創(chuàng)建ChromeOptions對象
options = webdriver.ChromeOptions()
# 添加選項(xiàng)，防止瀏覽器自動關(guān)閉
options.add_experimental_option("detach", True)
# 初始化一個WebDriver實(shí)例，將選項(xiàng)傳遞給Chrome
driver = webdriver.Chrome(options=options)
# 打開指定的頁面
url = "https://www.csdn.net"
driver.get(url)
# 在這里，你可以執(zhí)行與打開頁面相關(guān)的操作
# 手動關(guān)閉瀏覽器時，可以保持它打開
2. id 定位
要使用 Selenium 通過元素的 ID 進(jìn)行定位，你可以使用 By.ID 選擇器和 find_element 方法。以下是如何通過元素的ID進(jìn)行定位的示例：
from selenium import webdriver
# 初始化一個WebDriver實(shí)例，這里使用Chrome作為瀏覽器
driver = webdriver.Chrome()
# 打開指定的頁面
url = "https://www.example.com"
driver.get(url)
# 通過元素的ID進(jìn)行定位并執(zhí)行操作
element = driver.find_element(By.ID, "element_id")
# 在這里，你可以執(zhí)行與該元素相關(guān)的操作，例如單擊、輸入文本等
element.click()
# 最后，關(guān)閉瀏覽器窗口
driver.quit()
在上述示例中，driver.find_element(By.ID, "element_id") 通過元素的ID屬性來定位元素，并將其存儲在變量 element 中，然后可以執(zhí)行與該元素相關(guān)的操作。記得將 "element_id" 替換為你要查找的元素的實(shí)際 ID。
3. name 定位
# 通過元素的name屬性進(jìn)行定位并執(zhí)行操作
element = driver.find_element(By.NAME,"element_name")
4. class 定位
# 通過元素的CSS類名進(jìn)行定位并執(zhí)行操作
element = driver.find_element(By.By.CLASS_NAME, ".element_class")
5. tag 定位
每個 tag 往往用來定義一類功能，所以通過 tag 來識別某個元素的成功率很低，每個頁面一般都用很多相同的 tag
# 通過元素的標(biāo)簽名進(jìn)行定位并執(zhí)行操作
element = driver.find_element(By.TAG_NAME,"element_tag")
element_tag 在示例代碼中代表你要查找的元素的 HTML 標(biāo)簽名，例如 < div >, < a >, < p >等。具體來說，如果你要查找一個 < div > 元素，你可以將 element_tag 替換為 "div" ，如果你要查找一個 < a > 元素，你可以將 element_tag 替換為 "a"，以此類推
6. xpath 定位
XPath（XML Path Language）是一種用于在 XML 文檔中定位元素的語言，也適用于HTML 文檔，因?yàn)?HTML 是一種基于 XML 的標(biāo)記語言的變體。XPath 是一種功能強(qiáng)大的元素定位方法，它允許你準(zhǔn)確地定位網(wǎng)頁上的元素，無論它們在文檔中的位置如何。以下是XPath定位的一些示例：
1. 通過元素名稱定位：
- 定位所有的鏈接元素：//a
- 定位所有的段落元素：//p
- 定位第一個標(biāo)題元素：//h1
2. 通過元素屬性定位：
-
定位具有特定 id 屬性的元素：
//*[@id='element_id'] -
定位具有特定 class 屬性的元素：
//*[@class='element_class']
3. 通過文本內(nèi)容定位：
-
定位包含特定文本的元素：
//*[text()='要查找的文本'] -
定位以特定文本開頭的元素：
//*[starts-with(text(), '開頭文本')] -
定位包含特定文本的鏈接：
//a[contains(text(), '鏈接文本')]
4. 通過元素層次結(jié)構(gòu)定位：
-
定位父元素的子元素：
//div[@id='parent_id']/p（查找 id 屬性為 'parent_id' 的 < div > 元素下的所有 < p > 元素） -
定位祖先元素的子元素：
//div[@class='grandparent_class']//span（查找 class 屬性為 'grandparent_class' 的祖先元素下的所有< span >元素）
5. 使用邏輯運(yùn)算符：
-
定位同時滿足多個條件的元素：
//input[@type='text' and @name='username']（查找type屬性為 'text' 且 name 屬性為 'username' 的輸入框）
這些只是 XPath 的一些基本示例，XPath具有非常豐富的語法和功能，你可以根據(jù)需要組合和定制不同的條件來定位元素。在Selenium中，你可以使用 find_element + By.XPATH 方法來實(shí)現(xiàn) XPath 定位，例如：
element = driver.find_element(By.XPATH,"http://a[contains(text(), '鏈接文本')]")
這將查找包含特定文本的鏈接元素,你可以根據(jù)需要修改 XPath 表達(dá)式來定位不同的元素。
6. 示例
<html>
<head>...<head/>
<body>
<div id="csdn-toolbar">
<div class="toolbar-inside">
<div class="toolbar-container">
<div class="toolbar-container-left">...</div>
<div class="toolbar-container-middle">
<div class="toolbar-search onlySearch">
<div class="toolbar-search-container">
<input id="toolbar-search-input" autocomplete="off" type="text" value="" placeholder="C++難在哪里？">
根據(jù)上面的標(biāo)簽需要定位 最后一行 input 標(biāo)簽，以下列出了四種方式，xpath 定位的方式多樣并不唯一，使用時根據(jù)情況進(jìn)行解析即可。
# 絕對路徑（層級關(guān)系）定位
driver.find_element(By.XPATH,
"/html/body/div/div/div/div[2]/div/div/input[1]")
# 利用元素屬性定位
driver.find_element(By.XPATH,
"http://*[@id='toolbar-search-input']"))
# 層級+元素屬性定位
driver.find_element(By.XPATH,
"http://div[@id='csdn-toolbar']/div/div/div[2]/div/div/input[1]")
# 邏輯運(yùn)算符定位
driver.find_element(By.XPATH,
"http://*[@id='toolbar-search-input' and @autocomplete='off']")
7. css 選擇器
CSS 使用選擇器來為頁面元素綁定屬性，它可以較為靈活的選擇控件的任意屬性，一般定位速度比 xpath 要快，使用CSS 選擇器進(jìn)行元素定位在 Selenium 中是非常常見和方便的。以下是一些常見的 CSS 選擇器示例：
1. 通過元素名稱定位：
- 定位所有的鏈接元素：a
- 定位所有的段落元素：p
- 定位所有的按鈕元素：button
2. 通過元素ID定位：
定位具有特定 ID屬性的元素：#element_id
element = driver.find_element(By.CSS_SELECTOR,"#element_id")
3. 通過類名定位：
- 定位具有特定 class 屬性的元素：.element_class
element = driver.find_element(By.CSS_SELECTOR,".element_class")
4. 通過元素屬性定位：
- 定位具有特定屬性值的元素：[attribute=‘value’]
element = driver.find_element(By.CSS_SELECTOR,"[name='username']")
5. 通過屬性值的部分匹配：
- 定位包含特定屬性值的元素：[attribute*=‘value’]
element = driver.find_element(By.CSS_SELECTOR,"[href*='example.com']")
6. 通過組合條件：
- 定位同時滿足多個條件的元素：.class1.class2
element = driver.find_element(By.CSS_SELECTOR,".element_class1.element_class2")
7. 子元素定位：
- 定位父元素的子元素：#parent_id > .child_class
element = driver.find_element(By.CSS_SELECTOR,"#parent_id > .child_class")
8. 偽類選擇器：
例如 定位鼠標(biāo)懸停的元素：:hover
element = driver.find_element(By.CSS_SELECTOR,"a:hover")
8. link 定位
使用 Selenium 來定位超鏈接（link）元素通常涉及到查找?guī)в?<a> 標(biāo)簽的元素，這是 HTML 中的鏈接標(biāo)簽。你可以使用不同的方法來定位超鏈接，如通過文本內(nèi)容、鏈接文本、部分鏈接文本等。以下是一些常見的鏈接定位示例：
1.通過鏈接文本（完全匹配）定位：
使用鏈接的文本內(nèi)容來定位，確保文本與鏈接完全匹配：
# 查找所有鏈接文本為"下一頁"的元素
element = driver.find_elements(By.LINK_TEXT, "文本")
2.通過鏈接文本（部分匹配）定位：
使用鏈接的部分文本內(nèi)容來定位，可以匹配鏈接文本的一部分：
element = driver.find_element(By.PARTIAL_LINK_TEXT,"部分文本")
例如，如果你的鏈接文本是"點(diǎn)擊這里以獲取更多信息"，你可以使用"點(diǎn)擊這里"或"獲取更多信息"來進(jìn)行部分匹配。
這些方法非常方便，特別是當(dāng)你知道鏈接的文本內(nèi)容時。但請注意，它們對文本大小寫敏感，所以確保文本內(nèi)容的大小寫與鏈接文本匹配。
要查找多個鏈接，你可以使用 find_element**s**(By.LINK_TEXT, "文本") 或 find_element**s**(By.PARTIAL_LINK_TEXT,"部分文本")，它們會返回一個元素列表，你可以在列表中迭代查找多個鏈接元素。
示例：
elements = driver.find_elements(By.PARTIAL_LINK_TEXT,"部分文本")
for element in elements:
print(element.text)
這將打印所有包含"部分文本"的鏈接文本的鏈接元素。
9. 示例 有道翻譯
訪問有道翻譯網(wǎng)站，輸入單詞，并獲取翻譯后的內(nèi)容
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
# 創(chuàng)建ChromeOptions對象
options = webdriver.ChromeOptions()
# 添加選項(xiàng)，防止瀏覽器自動關(guān)閉
options.add_experimental_option("detach", True)
# 創(chuàng)建Chrome WebDriver
driver = webdriver.Chrome(options=options)
# 打開有道翻譯頁面
driver.get("https://fanyi.youdao.com/")
# 等待輸入框可見
input_element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "js_fanyi_input"))
)
# 輸入內(nèi)容
input_element.send_keys("hello")
# 如果有廣告彈出框，關(guān)閉它
try:
close_btn = driver.find_element(By.CSS_SELECTOR, ".close")
close_btn.click()
except Exception:
pass # 如果沒有廣告，繼續(xù)執(zhí)行
# 等待翻譯結(jié)果出現(xiàn)
transTarget = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "js_fanyi_output_resultOutput"))
)
# 輸出翻譯結(jié)果
print(transTarget.text)
# 關(guān)閉瀏覽器
# driver.quit()
第04節(jié) 瀏覽器控制
1. 修改瀏覽器窗口大小
webdriver 提供 set_window_size() 方法來修改瀏覽器窗口的大小
from selenium import webdriver
# 初始化瀏覽器驅(qū)動程序，這里使用Chrome作為示例
driver = webdriver.Chrome()
# 最大化瀏覽器窗口
driver.maximize_window()
# 或者設(shè)置特定大小的窗口
# driver.set_window_size(1024, 768) # 傳遞所需的寬度和高度
# 訪問網(wǎng)頁
driver.get("https://www.example.com")
# 在這里執(zhí)行其他操作...
# 關(guān)閉瀏覽器
driver.quit()
2. 瀏覽器前進(jìn)&后退
要在 Selenium 中執(zhí)行瀏覽器的前進(jìn)和后退操作，你可以使用 forward() 和 back() 方法
# 在這里執(zhí)行其他操作...
# 執(zhí)行前進(jìn)操作
driver.forward()
# 執(zhí)行后退操作
driver.back()
# 在這里執(zhí)行其他操作...
請注意，前進(jìn)和后退操作通常依賴于瀏覽器的歷史記錄。如果瀏覽器歷史記錄中沒有前進(jìn)或后退的頁面，這些方法可能不會執(zhí)行任何操作。因此，在使用前進(jìn)和后退之前，確保瀏覽器已經(jīng)訪問了多個頁面以建立歷史記錄
3. 瀏覽器刷新
要在Selenium中執(zhí)行瀏覽器刷新操作，你可以使用refresh()方法。以下是一個示例，演示如何在Python中使用Selenium來刷新瀏覽器頁面：
from selenium import webdriver
# 刷新瀏覽器頁面
driver.refresh()
這個方法將會重新加載當(dāng)前頁面，就像用戶手動點(diǎn)擊瀏覽器的刷新按鈕一樣。刷新操作可用于重新加載頁面內(nèi)容，以確保你的測試腳本在頁面狀態(tài)變化時可以重新加載頁面
4. 瀏覽器窗口切換
在 Selenium 中，要切換瀏覽器窗口，你可以使用 window_handles 屬性來獲取當(dāng)前打開的所有窗口句柄，然后使用 switch_to.window() 方法切換到特定的窗口句柄。以下是一個示例，演示如何在 Python 中使用 Selenium 來切換瀏覽器窗口：
from selenium import webdriver
# 初始化瀏覽器驅(qū)動程序，這里使用Chrome作為示例
driver = webdriver.Chrome()
# 打開第一個網(wǎng)頁
driver.get("https://www.example1.com")
# 打開第二個網(wǎng)頁
driver.execute_script("window.open('https://www.example2.com', '_blank');")
# 獲取所有窗口句柄
window_handles = driver.window_handles
# 切換到第二個窗口
driver.switch_to.window(window_handles[1])
# 在第二個窗口執(zhí)行操作
# 切換回第一個窗口
driver.switch_to.window(window_handles[0])
# 在第一個窗口執(zhí)行操作
# 關(guān)閉瀏覽器
driver.quit()
在上述示例中，我們首先打開兩個不同的網(wǎng)頁，然后使用 window_handles 獲取所有窗口句柄。通過切換到不同的窗口句柄，我們可以在不同的瀏覽器窗口中執(zhí)行操作
請注意，窗口句柄的索引通常是從 0 開始的，所以第一個窗口的句柄是 window_handles[0] ，第二個窗口的句柄是 window_handles[1] ，依此類推。你可以根據(jù)需要切換到其他窗口句柄以執(zhí)行操作
窗口句柄（Window Handle）是一個用來唯一標(biāo)識瀏覽器窗口的標(biāo)識符或引用。每當(dāng)你打開一個新的瀏覽器窗口或標(biāo)簽頁時，瀏覽器會為該窗口分配一個唯一的句柄。這些句柄是在瀏覽器級別分配的，用于標(biāo)識不同的瀏覽器窗口或標(biāo)簽頁，以便在多窗口瀏覽器環(huán)境中進(jìn)行切換和操作
在 Selenium 等自動化測試工具中，窗口句柄用于控制和切換不同的瀏覽器窗口，以便在多個窗口之間執(zhí)行操作。通過獲取窗口句柄，你可以將焦點(diǎn)從一個窗口切換到另一個窗口，從而執(zhí)行各種操作，例如在不同窗口之間切換、操作彈出窗口等
窗口句柄通常是一個字符串，你可以使用它來定位和操作特定的瀏覽器窗口。在 Selenium 中，你可以使用 window_handles 屬性來獲取當(dāng)前打開的所有窗口句柄，然后使用 switch_to.window() 方法切換到特定的窗口句柄。這使得在多窗口瀏覽器環(huán)境中進(jìn)行自動化測試或操作變得更加容易
5. 常見操作
當(dāng)使用 Selenium WebDriver 或類似的自動化測試工具時，這些方法可以用于與 Web 頁面的元素進(jìn)行交互和獲取信息。以下是每個方法的使用示例：
1. send_keys(): 模擬輸入指定內(nèi)容
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
# 找到輸入框元素并輸入文本
input_element = driver.find_element_by_id("username")
input_element.send_keys("myusername")
在這個例子中，send_keys() 方法模擬在具有 id 為 “username” 的輸入框中輸入 “myusername”
2. clear(): 清除文本內(nèi)容
# 清除輸入框中的文本
input_element.clear()
clear() 方法用于清除之前輸入框中的文本內(nèi)容
3. is_displayed(): 判斷該元素是否可見
# 檢查元素是否可見
if input_element.is_displayed():
print("Input element is visible on the page.")
else:
print("Input element is not visible on the page.")
is_displayed() 方法用于檢查頁面上的元素是否可見。在這個例子中，如果輸入框可見，將會打印 “Input element is visible on the page.”
4. get_attribute(): 獲取標(biāo)簽屬性值
# 獲取元素的href屬性值
link_element = driver.find_element_by_link_text("Example Link")
href_value = link_element.get_attribute("href")
print("Href attribute value is:", href_value)
get_attribute() 方法用于獲取元素的指定屬性的值。在這個例子中，它獲取鏈接文本為 “Example Link” 的元素的 href 屬性值
5. size: 返回元素的尺寸
# 獲取元素的寬度和高度
element_size = input_element.size
print("Element size is:", element_size)
size 是一個屬性，用于返回元素的寬度和高度。在這個例子中，它獲取輸入框元素的尺寸
6. text: 返回元素文本
# 獲取元素的文本內(nèi)容
paragraph_element = driver.find_element_by_css_selector("p")
paragraph_text = paragraph_element.text
print("Paragraph text is:", paragraph_text)
text 是一個屬性，用于返回元素的文本內(nèi)容。在這個例子中，它獲取 <p> 元素的文本內(nèi)容
6. 示例 CSDN頁面元素交互
# coding=utf-8
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
driver.get('https://www.csdn.net/')
time.sleep(2)
# 定位搜索輸入框
text_label = driver.find_element(By.ID, "toolbar-search-input")
# 在搜索框中輸入 東離與糖寶
text_label.send_keys('東離與糖寶')
time.sleep(2)
# 清除搜索框中的內(nèi)容
text_label.clear()
time.sleep(2)
# 輸出搜索框元素是否可見
print(text_label.is_displayed())
# 輸出placeholder的值
print(text_label.get_attribute('placeholder'))
# 定位搜索按鈕
button = driver.find_element(By.ID, 'toolbar-search-button')
# 輸出按鈕的大小
print(button.size)
# 輸出按鈕上的文本
print(button.text)
'''輸出內(nèi)容
True
搜CSDN
{'height': 32, 'width': 88}
搜索
'''
第05節(jié) 鼠標(biāo)控制
1.單擊元素
左鍵不需要用到 ActionChains
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
driver = webdriver.Chrome()
driver.get("https://example.com")
element = driver.find_element_by_id("my_element")
# 單擊元素
ActionChains(driver).click(element).perform()
2.雙擊元素
# 雙擊元素
ActionChains(driver).double_click(element).perform()
3.在元素上右鍵單擊
# 右鍵單擊元素
ActionChains(driver).context_click(element).perform()
4.在元素上懸停（鼠標(biāo)懸停）
模擬懸停的作用一般是為了顯示隱藏的下拉框
# 鼠標(biāo)懸停在元素上
ActionChains(driver).move_to_element(element).perform()
5.拖拽元素到另一個位置
# 拖拽元素到目標(biāo)位置
target_element = driver.find_element_by_id("target_element")
ActionChains(driver).drag_and_drop(element, target_element).perform()
第06節(jié) 鍵盤控制
1.輸入文本
使用 send_keys 方法可以將文本輸入到活動元素中，就像用戶手動鍵入一樣
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
# 定位到文本輸入框并輸入文本
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys("Hello, World!")
2.按鍵
使用 send_keys 方法可以模擬特定按鍵的操作，如回車鍵、退格鍵、Tab鍵等。
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome()
driver.get("https://example.com")
# 模擬按下回車鍵
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys(Keys.ENTER)
3.組合鍵
你可以使用 Keys 類來模擬鍵盤上的組合鍵，例如 Ctrl+C（復(fù)制）和Ctrl+V（粘貼）。
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome()
driver.get("https://example.com")
# 模擬Ctrl+C（復(fù)制）
text_input = driver.find_element_by_id("my_textbox")
text_input.send_keys(Keys.CONTROL, 'c')
# 模擬Ctrl+V（粘貼）
another_text_input = driver.find_element_by_id("another_textbox")
another_text_input.send_keys(Keys.CONTROL, 'v')
4. 其他鍵盤操作
| 操作 | 描述 |
|---|---|
| Keys.F1 | F1鍵 |
| Keys.SPACE | 空格 |
| Keys.TAB | Tab鍵 |
| Keys.ESCAPE | ESC鍵 |
| Keys.ALT | Alt鍵 |
| Keys.SHIFT | Shift鍵 |
| Keys.ARROW_DOWN | 向下箭頭 |
| Keys.ARROW_LEFT | 向左箭頭 |
| Keys.ARROW_RIGHT | 向右箭頭 |
| Keys.ARROW_UP | 向上箭頭 |
第07節(jié) 元素等待
現(xiàn)在的大多數(shù)的 Web 應(yīng)用程序是使用 Ajax 技術(shù)。當(dāng)一個頁面被加載到瀏覽器時， 該頁面內(nèi)的元素可以在不同的時間點(diǎn)被加載。這使得定位元素變得困難， 如果元素不再頁面之中，會拋出 ElementNotVisibleException 異常。 使用 waits, 我們可以解決這個問題。waits 提供了一些操作之間的時間間隔- 主要是定位元素或針對該元素的任何其他操作。
Selenium Webdriver 提供兩種類型的 waits - 隱式和顯式。 顯式等待會讓 WebDriver 等待滿足一定的條件以后再進(jìn)一步的執(zhí)行。 而隱式等待讓 Webdriver 等待一定的時間后再才是查找某元素。
1. 隱式等待
隱式等待（Implicit Wait）：設(shè)置一個全局等待時間，如果 Selenium 無法立即找到元素，它會等待指定的時間，然后再次嘗試。這對于整個測試過程都適用
from selenium import webdriver
driver = webdriver.Chrome()
driver.implicitly_wait(10) # 設(shè)置等待時間為10秒
driver.get("https://example.com")
element = driver.find_element_by_id("myElement")
2. 顯示等待
顯式等待（Explicit Wait）：顯式等待允許你為特定操作等待特定條件。你可以等待元素可見、可點(diǎn)擊等條件。
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Chrome()
driver.get("https://example.com")
# 等待元素可見
element = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located((By.ID, "myElement"))
)
# 等待元素可點(diǎn)擊
element = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable((By.ID, "myElement"))
)
3. 自定義等待
自定義等待：你還可以根據(jù)需要創(chuàng)建自定義等待條件。例如，你可以等待元素的文本內(nèi)容等于特定值。
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
def wait_for_element_with_text(driver, by, value, text, timeout=10):
return WebDriverWait(driver, timeout).until(
lambda driver: driver.find_element(by, value).text == text
)
driver = webdriver.Chrome()
driver.get("https://example.com")
# 等待元素文本內(nèi)容等于特定值
wait_for_element_with_text(driver, By.ID, "myElement", "Hello, World!")
4. 強(qiáng)制等待
將隱式等待改為強(qiáng)制等待（使用 time.sleep()）通常不是一個好的做法，因?yàn)樗鼤?dǎo)致代碼效率低下并且可能會浪費(fèi)時間。
import time
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com") # 替換為你要訪問的網(wǎng)頁URL
# 假設(shè)你已經(jīng)定位到了包含文本的 WebElement 對象
element = driver.find_element_by_css_selector("span.red-packet-icon-mini > span.num")
# 使用強(qiáng)制等待
time.sleep(5) # 強(qiáng)制等待 5 秒
# 獲取 <span> 元素的文本內(nèi)容
text_content = element.text
# 打印文本內(nèi)容
print(text_content)
值得一提的是，對于定位不到元素的時候，從耗時方面隱式等待和強(qiáng)制等待沒什么區(qū)別
第08節(jié) 切換操作
在 selenium 操作頁面的時候，可能會因?yàn)辄c(diǎn)擊某個鏈接而跳轉(zhuǎn)到一個新的頁面（打開了一個新標(biāo)簽頁），這時候 selenium 實(shí)際還是處于上一個頁面的，需要我們進(jìn)行切換才能夠定位最新頁面上的元素。
窗口切換需要使用 switch_to.windows() 方法。
1. 窗口切換
在 selenium 操作頁面的時候，可能會因?yàn)辄c(diǎn)擊某個鏈接而跳轉(zhuǎn)到一個新的頁面（打開了一個新標(biāo)簽頁），這時候 selenium 實(shí)際還是處于上一個頁面的，需要我們進(jìn)行切換才能夠定位最新頁面上的元素。
窗口切換需要使用 switch_to.windows() 方法。
from selenium import webdriver
handles = []
driver = webdriver.Chrome()
driver.get('https://blog.csdn.net/')
# 設(shè)置隱式等待
driver.implicitly_wait(3)
# 獲取當(dāng)前窗口的句柄
handles.append(driver.current_window_handle)
# 點(diǎn)擊 python，進(jìn)入分類頁面
driver.find_element_by_xpath('//*[@id="mainContent"]/aside/div[1]/div').click()
# 切換窗口
driver.switch_to.window(driver.window_handles[-1])
# 獲取當(dāng)前窗口的句柄
handles.append(driver.current_window_handle)
print(handles)
print(driver.window_handles)
上面代碼在點(diǎn)擊跳轉(zhuǎn)后，使用 switch_to 切換窗口，window_handles返回的 handle 列表是按照頁面出現(xiàn)時間進(jìn)行排序的，最新打開的頁面肯定是最后一個，這樣用 driver.window_handles[-1] + switch_to 即可跳轉(zhuǎn)到最新打開的頁面了。
那如果打開的窗口有多個，如何跳轉(zhuǎn)到之前打開的窗口，如果確實(shí)有這個需求，那么打開窗口是就需要記錄每一個窗口的 key(別名) 與 value(handle)，保存到字典中，后續(xù)根據(jù) key 來取 handle 。
2. 表單切換
1. iframe 切換
很多頁面也會用帶 frame/iframe 表單嵌套，對于這種內(nèi)嵌的頁面 selenium 是無法直接定位的，需要使用 switch_to.frame() 方法將當(dāng)前操作的對象切換成 frame/iframe 內(nèi)嵌的頁面。
switch_to.frame() 默認(rèn)可以用的 id 或 name 屬性直接定位，但如果 iframe 沒有 id 或 name ，這時就需要使用 xpath 進(jìn)行定位。
iframe = driver.find_element(By.ID, "my-iframe-id")
driver.switch_to.frame(iframe)
2.切換回默認(rèn)內(nèi)容：
如果在 iframe 中完成操作后，要切換回主頁面，可以使用 switch_to.default_content() 方法：
driver.switch_to.default_content()
這些方法可以幫助你在 Selenium 中進(jìn)行窗口和 iframe 的切換操作。記住，切換窗口或 iframe 之前，你需要獲取到對應(yīng)的窗口句柄或 iframe 元素。
3. 舉例
確切地，要找到位于 iframe 中的元素，你需要按照以下步驟進(jìn)行操作：
1.首先，你需要找到 iframe 元素本身，然后切換到該 iframe
2.在 iframe 內(nèi)部，你可以使用常規(guī)的方法來查找和操作元素
以下是一個示例，演示如何切換到 iframe 并找到其中的元素：
from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
driver.get("https://example.com")
# 找到 iframe 元素，可以根據(jù)其 ID、名稱或其他屬性來定位
iframe = driver.find_element(By.ID, "my-iframe-id")
# 切換到 iframe
driver.switch_to.frame(iframe)
# 在 iframe 中查找元素并執(zhí)行操作
element_inside_iframe = driver.find_element(By.CLASS_NAME, "element-class")
element_inside_iframe.click()
# 切換回主頁面
driver.switch_to.default_content()
在這個示例中，我們首先通過其 ID 找到了 iframe 元素，然后使用 driver.switch_to.frame() 切換到了 iframe 中，接下來在 iframe 內(nèi)查找元素并執(zhí)行操作。最后，使用 driver.switch_to.default_content() 切換回主頁面。
記住，要確保你正確找到了 iframe 元素，以及在切換到 iframe 后，使用 driver.find_element() 方法來查找位于 iframe 內(nèi)部的元素。
第09節(jié) 滾輪操作
要在 Selenium 中模擬滾輪操作，你可以使用 ActionChains 類的 send_keys 方法，將 Keys.PAGE_DOWN 或 Keys.SPACE 等按鍵發(fā)送到頁面。這將模擬向下滾動頁面。
在你的示例代碼中，你已經(jīng)創(chuàng)建了一個 ActionChains 對象，所以你只需要在循環(huán)中使用 send_keys 方法來模擬滾輪操作。以下是如何修改你的代碼以模擬滾輪向下滾動：
from selenium.webdriver.common.keys import Keys
# ...
# 計(jì)算滾動的時間間隔（以毫秒為單位）
scroll_interval = 500 # 每500毫秒滾動一次
# 創(chuàng)建ActionChains對象
action_chains = ActionChains(driver)
# 模擬滾動
for _ in range(int(scroll_duration * 1000 / scroll_interval)):
action_chains.send_keys(Keys.PAGE_DOWN).perform()
time.sleep(scroll_interval / 1000)
這段代碼會模擬按下 Page Down 鍵來滾動頁面。你可以根據(jù)需要調(diào)整 scroll_interval 和 scroll_duration 來控制滾動的速度和持續(xù)時間。文章來源：http://www.zghlxwxcb.cn/news/detail-751418.html
總結(jié)
歡迎各位留言交流以及批評指正，如果文章對您有幫助或者覺得作者寫的還不錯可以點(diǎn)一下關(guān)注，點(diǎn)贊，收藏支持一下。
（博客的參考源碼可以在我主頁的資源里找到，如果在學(xué)習(xí)的過程中有什么疑問歡迎大家在評論區(qū)向我提出）文章來源地址http://www.zghlxwxcb.cn/news/detail-751418.html
到了這里，關(guān)于一文帶你深入淺出Web的自動化測試工具Selenium【建議收藏】的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
