สาเหตุที่เกิดขึ้นคือไดรเวอร์เว็บ Selenium ต้องดาวน์โหลดหน้าเว็บและแสดงผลหน้าเว็บให้เสร็จสิ้นก่อนที่คุณจะสามารถทำอะไรกับมันได้ ในอดีต เว็บเซิร์ฟเวอร์สร้างเนื้อหาของเว็บไซต์ และเบราว์เซอร์เพิ่งดาวน์โหลดและแสดงผล ทุกวันนี้ เรามีเว็บแอปหน้าเดียวจำนวนมากที่ทำงานแตกต่างกันเล็กน้อย ใน Single Page Web Apps (SPA) เว็บเซิร์ฟเวอร์จะให้บริการเฉพาะรหัสส่วนหน้าเท่านั้น เมื่อแสดงโค้ดส่วนหน้าบนเบราว์เซอร์ รหัสส่วนหน้าจะใช้ AJAX เพื่อขอข้อมูล API ไปยังเว็บเซิร์ฟเวอร์ เมื่อฟรอนท์เอนด์ได้รับข้อมูล API ฟรอนท์เอนด์จะแสดงผลบนเบราว์เซอร์ ดังนั้น แม้ว่าเบราว์เซอร์จะดาวน์โหลดและแสดงผลหน้าเว็บเสร็จแล้ว แต่หน้าเว็บก็ยังไม่พร้อม คุณต้องรอให้ได้รับข้อมูล API และแสดงผลด้วยเช่นกัน ดังนั้น วิธีแก้ไขปัญหานี้คือรอให้ข้อมูลพร้อมใช้งานก่อนที่เราจะดำเนินการใดๆ กับซีลีเนียม
ในซีลีเนียม การรอมี 2 ประเภท:
1) รอโดยปริยาย
2) การรอที่ชัดเจน
1) รอโดยปริยาย: นี่เป็นวิธีที่ง่ายที่สุดในการดำเนินการ การรอโดยปริยายบอกให้ไดรเวอร์เว็บ Selenium รอสักครู่เพื่อให้ DOM (โมเดลอ็อบเจ็กต์เอกสาร) พร้อมใช้งาน (หน้าเว็บจะพร้อมใช้งาน)
2) การรอที่ชัดเจน: สิ่งนี้ซับซ้อนกว่าการรอโดยปริยายเล็กน้อย ในการรอที่ชัดเจน คุณต้องบอกไดรเวอร์เว็บของ Selenium ว่าจะรออะไร ซีลีเนียมรอให้เงื่อนไขเฉพาะนั้นสำเร็จ เมื่อดำเนินการเรียบร้อยแล้ว ไดรเวอร์เว็บ Selenium จะพร้อมรับคำสั่งอื่นๆ โดยปกติ เวลารอที่ชัดเจนจะแปรผัน ขึ้นอยู่กับเงื่อนไขว่าเสร็จเร็วแค่ไหน ในสถานการณ์กรณีที่เลวร้ายที่สุด การรออย่างชัดแจ้งจะรอตราบเท่าที่การรอโดยปริยาย
ในบทความนี้ ฉันจะแสดงให้คุณเห็นถึงวิธีการรอ (โดยนัยและชัดเจน) เพื่อให้หน้าโหลดด้วย Selenium มาเริ่มกันเลยดีกว่า
ข้อกำหนดเบื้องต้น:
หากต้องการลองใช้คำสั่งและตัวอย่างของบทความนี้ คุณต้องมี
1) การแจกจ่าย Linux (ควรเป็น Ubuntu) ที่ติดตั้งบนคอมพิวเตอร์ของคุณ
2) Python 3 ติดตั้งบนคอมพิวเตอร์ของคุณ
3) PIP 3 ติดตั้งบนคอมพิวเตอร์ของคุณ
4) Python virtualenv แพ็คเกจที่ติดตั้งบนคอมพิวเตอร์ของคุณ
5) เว็บเบราว์เซอร์ Mozilla Firefox หรือ Google Chrome ที่ติดตั้งบนคอมพิวเตอร์ของคุณ
6) ต้องรู้วิธีการติดตั้งไดรเวอร์ Firefox Gecko หรือ Chrome Web Driver
หากต้องการปฏิบัติตามข้อกำหนด 4, 5 และ 6 โปรดอ่านบทความของฉัน รู้เบื้องต้นเกี่ยวกับซีลีเนียมด้วย Python 3 ที่ Linuxhint.com
คุณสามารถค้นหาบทความมากมายในหัวข้ออื่น ๆ ได้ที่ LinuxHint.com . อย่าลืมตรวจสอบหากคุณต้องการความช่วยเหลือ
การตั้งค่าไดเรกทอรีโครงการ:
เพื่อให้ทุกอย่างเป็นระเบียบ ให้สร้างไดเร็กทอรีโครงการใหม่ ซีลีเนียมรอ/ ดังนี้
$mkdir -pvซีลีเนียมรอ/คนขับรถ 
นำทางไปยัง ซีลีเนียมรอ/ ไดเรกทอรีโครงการดังต่อไปนี้:
$ซีดีซีลีเนียมรอ/ 
สร้างสภาพแวดล้อมเสมือน Python ในไดเร็กทอรีโครงการดังนี้:
$virtualenv .venv 
เปิดใช้งานสภาพแวดล้อมเสมือนดังต่อไปนี้:
$แหล่งที่มา.venv/เป็น/เปิดใช้งาน 
ติดตั้งซีลีเนียมโดยใช้ PIP3 ดังนี้:
$ pip3 ติดตั้งซีลีเนียม 
ดาวน์โหลดและติดตั้งไดรเวอร์เว็บที่จำเป็นทั้งหมดในไฟล์ คนขับรถ/ ไดเรกทอรีของโครงการ ฉันได้อธิบายขั้นตอนการดาวน์โหลดและติดตั้งไดรเวอร์เว็บในบทความของฉันแล้ว รู้เบื้องต้นเกี่ยวกับซีลีเนียมด้วย Python 3 . หากคุณต้องการความช่วยเหลือ ค้นหาใน LinuxHint.com สำหรับบทความนั้น
ฉันจะใช้เว็บเบราว์เซอร์ Google Chrome สำหรับการสาธิตในบทความนี้ ดังนั้นฉันจะใช้ chromedriver เลขฐานสองจาก คนขับรถ/ ไดเรกทอรี
หากต้องการทดสอบด้วยการรอโดยปริยาย ให้สร้างสคริปต์ Python ใหม่ ex01.py ในไดเร็กทอรีโครงการของคุณและพิมพ์โค้ดต่อไปนี้ในไฟล์นั้น
จากซีลีเนียมนำเข้าไดรเวอร์เว็บจากซีลีเนียม.ไดรเวอร์เว็บ.ทั่วไป.กุญแจ นำเข้ากุญแจ
ตัวเลือก=ไดรเวอร์เว็บChromeOptions()
ตัวเลือก.หัวขาด = จริง
เบราว์เซอร์=ไดรเวอร์เว็บโครเมียม(executable_path='./drivers/chromedriver',ตัวเลือก=ตัวเลือก)
เบราว์เซอร์โดยปริยาย_รอ(10)
เบราว์เซอร์รับ('https://www.unixtimestamp.com/')
ประทับเวลา=เบราว์เซอร์find_element_by_xpath('//h3[@][1]')
พิมพ์('การประทับเวลาปัจจุบัน: %s'%(การประทับเวลาข้อความ.แยก('')[0]))
เบราว์เซอร์ปิด()
เมื่อเสร็จแล้วให้บันทึก ex01.py สคริปต์ไพทอน
บรรทัดที่ 1 และ 2 นำเข้าส่วนประกอบซีลีเนียมที่จำเป็นทั้งหมด
บรรทัดที่ 4 สร้างวัตถุตัวเลือก Chrome
บรรทัดที่ 5 เปิดใช้งานโหมดหัวขาดสำหรับไดรเวอร์เว็บ Chrome
บรรทัดที่ 7 สร้างวัตถุเบราว์เซอร์ Chrome โดยใช้ chromedriver เลขฐานสองจาก คนขับรถ/ ไดเรกทอรี
บรรทัดที่ 8 ใช้เพื่อบอกให้ซีลีเนียมรอโดยปริยายเป็นเวลา 10 วินาทีโดยใช้ปุ่ม โดยปริยาย_รอ() วิธีเบราว์เซอร์
บรรทัดที่ 10 โหลด www.unixtimestamp.com ในเบราว์เซอร์
บรรทัดที่ 12 ค้นหาองค์ประกอบการประทับเวลาโดยใช้ตัวเลือก XPath //h3[@class='text-danger'][1] และเก็บไว้ใน ประทับเวลา ตัวแปร.
ฉันได้รับตัวเลือก XPath จากเครื่องมือสำหรับนักพัฒนา Chrome อย่างที่คุณเห็นการประทับเวลาอยู่ในอันดับแรก h3 องค์ประกอบที่มีชื่อคลาส ข้อความอันตราย . มี2 h3 องค์ประกอบกับคลาส ข้อความอันตราย .
บรรทัดที่ 13 พิมพ์เฉพาะการประทับเวลาจากองค์ประกอบที่ฉันเลือกโดยใช้ตัวเลือก XPath และเก็บไว้ใน ประทับเวลา ตัวแปร.
บรรทัดที่ 14 ปิดเบราว์เซอร์
เมื่อเสร็จแล้ว ให้รันสคริปต์ Python ex01.py ดังนี้
$ python3 ex01.พาย 
อย่างที่คุณเห็น เวลาประทับปัจจุบันถูกดึงออกมาจาก unixtimestamp.com และพิมพ์บนคอนโซล
การทำงานกับการรออย่างชัดแจ้ง:
หากต้องการทดสอบด้วยการรอที่ชัดเจน ให้สร้างสคริปต์ Python ใหม่ ex02.py ในไดเร็กทอรีโครงการของคุณและพิมพ์โค้ดต่อไปนี้ในไฟล์นั้น
จากซีลีเนียมนำเข้าไดรเวอร์เว็บจากซีลีเนียม.ไดรเวอร์เว็บ.ทั่วไป.กุญแจ นำเข้ากุญแจ
จากซีลีเนียม.ไดรเวอร์เว็บ.ทั่วไป.โดย นำเข้าโดย
จากซีลีเนียม.ไดรเวอร์เว็บ.สนับสนุน.หัวหอม นำเข้าWebDriverWait
จากซีลีเนียม.ไดรเวอร์เว็บ.สนับสนุน นำเข้าคาดหวัง_เงื่อนไข
ตัวเลือก=ไดรเวอร์เว็บChromeOptions()
ตัวเลือก.หัวขาด = จริง
เบราว์เซอร์=ไดรเวอร์เว็บโครเมียม(executable_path='./drivers/chromedriver',ตัวเลือก=ตัวเลือก)
เบราว์เซอร์รับ('https://www.unixtimestamp.com/')
ลอง:
ประทับเวลา=WebDriverWait(เบราว์เซอร์, 10).จนกระทั่ง(
คาดหวัง_เงื่อนไขการมีอยู่_of_element_located((โดย.XPATH, '
//h3[@][1]'))
)
พิมพ์('การประทับเวลาปัจจุบัน: %s'%(การประทับเวลาข้อความ.แยก('')[0]))
ในที่สุด:
เบราว์เซอร์ปิด()
เมื่อเสร็จแล้วให้บันทึก ex02.py สคริปต์ไพทอน
บรรทัดที่ 1-5 นำเข้าส่วนประกอบที่จำเป็นทั้งหมดจากไลบรารี Selenium
บรรทัดที่ 7 สร้างวัตถุตัวเลือกของ Chrome
บรรทัดที่ 8 เปิดใช้งานโหมดหัวขาดสำหรับไดรเวอร์เว็บ Chrome
บรรทัดที่ 10 สร้างวัตถุเบราว์เซอร์ Chrome โดยใช้ chromedriver เลขฐานสองจาก คนขับรถ/ ไดเรกทอรี
บรรทัดที่ 12 โหลด www.unixtimestamp.com ในเบราว์เซอร์
การรอที่ชัดเจนถูกนำมาใช้ในบล็อก try-finally (จากบรรทัดที่ 14-20)
บรรทัดที่ 15-17 ใช้ create WebDriverWait() วัตถุ. อาร์กิวเมนต์แรกของ WebDriverWait() เป็นวัตถุของเบราว์เซอร์ และอาร์กิวเมนต์ที่สองคือเวลาสูงสุดที่อนุญาต (สถานการณ์กรณีที่เลวร้ายที่สุด) สำหรับการปฏิบัติตามเงื่อนไข ซึ่งในกรณีนี้คือ 10 วินาที
ใน จนกระทั่ง() บล็อก, คาดหวัง_conditions.presence_of_element_located() เมธอดใช้เพื่อให้แน่ใจว่าองค์ประกอบนั้นมีอยู่ก่อนที่จะพยายามเลือกองค์ประกอบ ที่นี่, By.XPATH ใช้เพื่อบอก การมีอยู่_of_element_located() วิธีที่เราใช้ตัวเลือก XPath เพื่อเลือกองค์ประกอบ ตัวเลือก XPath คือ //h3[@class='text-danger'][1] .
เมื่อพบองค์ประกอบแล้วจะถูกเก็บไว้ใน ประทับเวลา ตัวแปร.
บรรทัดที่ 18 พิมพ์เฉพาะการประทับเวลาจากองค์ประกอบที่เลือก
สุดท้ายบรรทัดที่ 19-20 ปิดเบราว์เซอร์
เมื่อเสร็จแล้วให้เรียกใช้ ex02.py สคริปต์ Python ดังต่อไปนี้:
$ python3 ex02.พาย 
อย่างที่คุณเห็น การประทับเวลาปัจจุบันจาก unixtimestamp.com ถูกพิมพ์บนคอนโซล
การเลือกองค์ประกอบในการรออย่างชัดเจน:
ในส่วนก่อนหน้านี้ฉันได้ใช้ By.XPATH สำหรับการเลือกองค์ประกอบโดยใช้ตัวเลือก XPath คุณยังสามารถเลือกองค์ประกอบโดยใช้ ID, ชื่อแท็ก, ชื่อคลาส CSS, ตัวเลือก CSS เป็นต้น
วิธีการเลือกที่รองรับได้รับด้านล่าง:
By.XPATH – เลือกองค์ประกอบ/องค์ประกอบโดยใช้ตัวเลือก XPath
โดย.CLASS_NAME – เลือกองค์ประกอบ/องค์ประกอบโดยใช้ชื่อคลาส CSS
โดย.CSS_SELECTOR – เลือกองค์ประกอบ/องค์ประกอบโดยใช้ตัวเลือก CSS
By.ID – เลือกองค์ประกอบตาม ID
โดยชื่อ – เลือกองค์ประกอบ/องค์ประกอบตามชื่อ
โดย.TAG_NAME – เลือกองค์ประกอบ/องค์ประกอบตามชื่อแท็ก HTML
โดย.LINK_TEXT – เลือกองค์ประกอบ/องค์ประกอบตามข้อความลิงก์ของ ถึง (สมอ) แท็ก HTML
โดย.PARTIAL_LINK_TEXT – เลือกองค์ประกอบ/องค์ประกอบตามข้อความลิงก์บางส่วนของ ถึง (สมอ) แท็ก HTML
ดูข้อมูลเพิ่มเติมได้ที่ หน้าเอกสาร Python Selenium API .
เงื่อนไขที่คาดหวังในการรออย่างชัดเจน:
ในตัวอย่างการรอที่ชัดเจนก่อนหน้านี้ ฉันได้ใช้ การมีอยู่_of_element_located() วิธีการของ คาดหวัง_เงื่อนไข เนื่องจากเงื่อนไขการรอที่ชัดเจนเพื่อให้แน่ใจว่าองค์ประกอบที่ฉันกำลังมองหามีอยู่ก่อนที่จะเลือก
มีอื่นๆ คาดหวัง_เงื่อนไข คุณสามารถใช้เป็นเงื่อนไขการรอที่ชัดเจนได้ บางส่วนของพวกเขาคือ:
title_is(หัวเรื่อง) – ตรวจสอบว่าชื่อหน้าเป็น ชื่อ .
title_contains(partial_title) – ตรวจสอบว่าชื่อหน้ามีส่วนของชื่อหรือไม่ บางส่วน_title .
การมองเห็น_of(องค์ประกอบ) – ตรวจสอบว่า ธาตุ ปรากฏบนหน้าที่เป็นองค์ประกอบที่มีความกว้างและความสูงมากกว่า 0
การมองเห็น_of_element_located(ตัวระบุตำแหน่ง) -
การมีอยู่_of_element_located (ตัวระบุตำแหน่ง) – ตรวจสอบให้แน่ใจว่าองค์ประกอบที่อยู่ (โดย ตัวระบุตำแหน่ง ) มีอยู่ในหน้า NS ตัวระบุตำแหน่ง เป็นทูเพิลของ (โดยตัวเลือก) ตามที่ฉันได้แสดงในตัวอย่างการรอที่ชัดเจน
การมีอยู่_of_all_element_located() – ตรวจสอบให้แน่ใจว่าองค์ประกอบทั้งหมดตรงกับ ตัวระบุตำแหน่ง มีอยู่ในเพจ NS ตัวระบุตำแหน่ง คือ (โดยตัวเลือก) ทูเปิล
text_to_be_present_in_element (ตัวระบุตำแหน่งข้อความ) – ตรวจสอบว่า ข้อความ มีอยู่ในองค์ประกอบที่อยู่โดย ตัวระบุตำแหน่ง . NS ตัวระบุตำแหน่ง คือ (โดยตัวเลือก) ทูเปิล
element_to_be_clickable(ตัวระบุตำแหน่ง) – ตรวจสอบว่าองค์ประกอบที่อยู่โดย ตัวระบุตำแหน่ง มองเห็นได้และคลิกได้ NS ตัวระบุตำแหน่ง คือ (โดยตัวเลือก) ทูเปิล
element_to_be_selected(ตัวระบุตำแหน่ง) – ตรวจสอบว่าองค์ประกอบที่อยู่โดย ตัวระบุตำแหน่ง ถูกเลือก NS ตัวระบุตำแหน่ง คือ (โดยตัวเลือก) ทูเปิล
alert_is_present() – คาดว่ากล่องโต้ตอบการแจ้งเตือนจะปรากฏบนหน้า
มีอีกเยอะครับ คาดหวัง_เงื่อนไข ให้คุณได้ใช้งาน ดูข้อมูลเพิ่มเติมได้ที่ หน้าเอกสาร Python Selenium API .
บทสรุป:
ในบทความนี้ ฉันได้กล่าวถึงการรอโดยนัยและชัดเจนของซีลีเนียม ฉันยังแสดงให้คุณเห็นถึงวิธีการทำงานด้วยการรอโดยปริยายและชัดเจน คุณควรพยายามใช้การรอที่ชัดเจนในโปรเจ็กต์ Selenium ของคุณเสมอ เนื่องจาก Selenium จะพยายามลดเวลารอให้มากที่สุด ด้วยวิธีนี้ คุณจะไม่ต้องรอเป็นจำนวนวินาทีที่เจาะจงในแต่ละครั้งที่คุณรันโปรเจ็กต์ Selenium การรอที่ชัดเจนจะช่วยประหยัดเวลาได้มาก
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการรอซีลีเนียม โปรดไปที่ ห้องสมุด Selenium Python อย่างเป็นทางการรอหน้าเอกสาร .