អ្នកនិពន្ធអត្ថបទដែលជាការបកប្រែដែលយើងកំពុងបោះពុម្ពថ្ងៃនេះនិយាយថាគោលបំណងរបស់វាគឺដើម្បីនិយាយអំពីការអភិវឌ្ឍនៃ scraper បណ្តាញនៅក្នុង Python ដោយប្រើ Selenium ដែលស្វែងរកតម្លៃសំបុត្រយន្តហោះ។ នៅពេលស្វែងរកសំបុត្រ កាលបរិច្ឆេទដែលអាចបត់បែនបានត្រូវបានប្រើប្រាស់ (+- 3 ថ្ងៃទាក់ទងទៅនឹងកាលបរិច្ឆេទដែលបានបញ្ជាក់)។ scraper រក្សាទុកលទ្ធផលស្វែងរកនៅក្នុងឯកសារ Excel ហើយផ្ញើអ្នកដែលដំណើរការការស្វែងរកតាមអ៊ីមែលជាមួយនឹងសេចក្តីសង្ខេបនៃអ្វីដែលពួកគេបានរកឃើញ។ គោលដៅនៃគម្រោងនេះគឺដើម្បីជួយអ្នកធ្វើដំណើរស្វែងរកកិច្ចព្រមព្រៀងដ៏ល្អបំផុត។
ប្រសិនបើខណៈពេលដែលការយល់ដឹងអំពីសម្ភារៈ អ្នកមានអារម្មណ៍ថាបាត់បង់ សូមក្រឡេកមើល អត្ថបទ។
តើយើងនឹងស្វែងរកអ្វី?
អ្នកមានសេរីភាពក្នុងការប្រើប្រាស់ប្រព័ន្ធដែលបានពិពណ៌នានៅទីនេះតាមដែលអ្នកចង់បាន។ ជាឧទាហរណ៍ ខ្ញុំបានប្រើវាដើម្បីស្វែងរកដំណើរកម្សាន្តចុងសប្តាហ៍ និងសំបុត្រទៅស្រុកកំណើតរបស់ខ្ញុំ។ ប្រសិនបើអ្នកយកចិត្តទុកដាក់ក្នុងការស្វែងរកសំបុត្រដែលរកបានប្រាក់ចំណេញ អ្នកអាចដំណើរការស្គ្រីបនៅលើម៉ាស៊ីនមេ (សាមញ្ញ សម្រាប់ 130 rubles ក្នុងមួយខែគឺពិតជាសមរម្យសម្រាប់ការនេះ) ហើយត្រូវប្រាកដថាវាដំណើរការម្តងឬពីរដងក្នុងមួយថ្ងៃ។ លទ្ធផលស្វែងរកនឹងត្រូវបានផ្ញើទៅអ្នកតាមអ៊ីមែល។ លើសពីនេះទៀតខ្ញុំសូមណែនាំឱ្យរៀបចំអ្វីៗគ្រប់យ៉ាងដើម្បីឱ្យស្គ្រីបរក្សាទុកឯកសារ Excel ជាមួយនឹងលទ្ធផលស្វែងរកនៅក្នុងថត Dropbox ដែលនឹងអនុញ្ញាតឱ្យអ្នកមើលឯកសារបែបនេះពីគ្រប់ទីកន្លែងនិងគ្រប់ពេលវេលា។
ខ្ញុំមិនបានរកឃើញពន្ធដែលមានកំហុសនៅឡើយទេ ប៉ុន្តែខ្ញុំគិតថាវាអាចទៅរួច
នៅពេលស្វែងរក ដូចដែលបានបញ្ជាក់រួចមកហើយ "កាលបរិច្ឆេទដែលអាចបត់បែនបាន" ត្រូវបានប្រើ ស្គ្រីបរកឃើញការផ្តល់ជូនដែលមានក្នុងរយៈពេលបីថ្ងៃនៃកាលបរិច្ឆេទដែលបានផ្តល់ឱ្យ។ ទោះបីជានៅពេលដំណើរការស្គ្រីប វាស្វែងរកការផ្តល់ជូនក្នុងទិសដៅតែមួយក៏ដោយ វាងាយស្រួលក្នុងការកែប្រែវា ដើម្បីឱ្យវាអាចប្រមូលទិន្នន័យនៅលើទិសដៅហោះហើរជាច្រើន។ ដោយមានជំនួយរបស់វា អ្នកថែមទាំងអាចរកមើលពន្ធដែលខុសឆ្គងបាន ការរកឃើញបែបនេះអាចគួរឱ្យចាប់អារម្មណ៍ខ្លាំងណាស់។
ហេតុអ្វីបានជាអ្នកត្រូវការ scraper គេហទំព័រមួយផ្សេងទៀត?
នៅពេលខ្ញុំចាប់ផ្តើមការកោសគេហទំព័រដំបូង ខ្ញុំមិនចាប់អារម្មណ៍ជាពិសេសចំពោះវាទេ។ ខ្ញុំចង់ធ្វើគម្រោងបន្ថែមទៀតក្នុងវិស័យគំរូទស្សន៍ទាយ ការវិភាគហិរញ្ញវត្ថុ និងអាចក្នុងវិស័យវិភាគពណ៌អារម្មណ៍នៃអត្ថបទ។ ប៉ុន្តែវាបានប្រែក្លាយថាវាគួរឱ្យចាប់អារម្មណ៍ខ្លាំងណាស់ក្នុងការស្វែងយល់ពីរបៀបបង្កើតកម្មវិធីដែលប្រមូលទិន្នន័យពីគេហទំព័រ។ នៅពេលដែលខ្ញុំបានស្វែងយល់អំពីប្រធានបទនេះ ខ្ញុំបានដឹងថាការលួចយកគេហទំព័រគឺជា "ម៉ាស៊ីន" នៃអ៊ីនធឺណិត។
អ្នកប្រហែលជាគិតថានេះជាការថ្លែងដ៏ក្លាហានពេក។ ប៉ុន្តែសូមពិចារណាថា Google បានចាប់ផ្តើមជាមួយនឹងគេហទំព័រ scraper ដែល Larry Page បានបង្កើតដោយប្រើ Java និង Python ។ មនុស្សយន្ត Google បាននិងកំពុងរុករកអ៊ីនធឺណិត ដោយព្យាយាមផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវចម្លើយដ៏ល្អបំផុតចំពោះសំណួររបស់ពួកគេ។ Web scraping មានការប្រើប្រាស់គ្មានទីបញ្ចប់ ហើយទោះបីជាអ្នកចាប់អារម្មណ៍លើអ្វីផ្សេងទៀតនៅក្នុង Data Science ក៏ដោយ អ្នកនឹងត្រូវការជំនាញ scraping មួយចំនួនដើម្បីទទួលបានទិន្នន័យដែលអ្នកត្រូវការដើម្បីវិភាគ។
ខ្ញុំបានរកឃើញបច្ចេកទេសមួយចំនួនដែលប្រើនៅទីនេះក្នុងភាពអស្ចារ្យ អំពី web scraping ដែលខ្ញុំទើបតែទទួលបាន។ វាមានឧទាហរណ៍ និងគំនិតសាមញ្ញជាច្រើនសម្រាប់ការអនុវត្តជាក់ស្តែងនូវអ្វីដែលអ្នកបានរៀន។ លើសពីនេះទៀត មានជំពូកគួរឱ្យចាប់អារម្មណ៍មួយស្តីពីការឆ្លងកាត់ការត្រួតពិនិត្យ reCaptcha ។ នេះជាដំណឹងសម្រាប់ខ្ញុំ ដោយសារខ្ញុំមិនដឹងថាមានឧបករណ៍ពិសេស និងសូម្បីតែសេវាកម្មទាំងមូលសម្រាប់ដោះស្រាយបញ្ហាបែបនេះ។
តើអ្នកចូលចិត្តធ្វើដំណើរទេ?!
ចំពោះសំណួរសាមញ្ញ និងមិនបង្កគ្រោះថ្នាក់ដែលដាក់ក្នុងចំណងជើងនៃផ្នែកនេះ ជាញឹកញាប់អ្នកអាចឮចម្លើយវិជ្ជមាន អមដោយរឿងពីរបីពីការធ្វើដំណើររបស់មនុស្សដែលវាត្រូវបានសួរ។ ពួកយើងភាគច្រើនយល់ស្របថាការធ្វើដំណើរគឺជាវិធីដ៏ល្អមួយដើម្បីជ្រមុជខ្លួនអ្នកនៅក្នុងបរិយាកាសវប្បធម៌ថ្មី និងពង្រីកការយល់ដឹងរបស់អ្នក។ ទោះជាយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកសួរនរណាម្នាក់ថាតើពួកគេចូលចិត្តស្វែងរកសំបុត្រយន្តហោះដែរឬទេ ខ្ញុំប្រាកដថាចម្លើយនឹងមិនមានភាពវិជ្ជមាននោះទេ។ តាមពិត Python មករកជំនួយរបស់យើងនៅទីនេះ។
កិច្ចការដំបូងដែលយើងត្រូវដោះស្រាយតាមផ្លូវបង្កើតប្រព័ន្ធសម្រាប់ស្វែងរកព័ត៌មានអំពីសំបុត្រយន្តហោះនឹងជ្រើសរើសវេទិកាសមស្របដែលយើងនឹងយកព័ត៌មាន។ ការដោះស្រាយបញ្ហានេះមិនងាយស្រួលសម្រាប់ខ្ញុំទេ ប៉ុន្តែនៅទីបញ្ចប់ខ្ញុំបានជ្រើសរើសសេវាកម្ម Kayak ។ ខ្ញុំបានសាកល្បងសេវាកម្មរបស់ Momondo, Skyscanner, Expedia និងមួយចំនួនផ្សេងទៀត ប៉ុន្តែយន្តការការពារមនុស្សយន្តនៅលើធនធានទាំងនេះគឺមិនអាចចូលបាន។ បន្ទាប់ពីការព្យាយាមជាច្រើនដង ក្នុងអំឡុងពេលដែលខ្ញុំត្រូវដោះស្រាយភ្លើងចរាចរណ៍ ផ្លូវឆ្លងកាត់ថ្មើរជើង និងកង់ ដោយព្យាយាមបញ្ចុះបញ្ចូលប្រព័ន្ធថាខ្ញុំជាមនុស្ស ខ្ញុំបានសម្រេចចិត្តថា Kayak គឺសាកសមបំផុតសម្រាប់ខ្ញុំ បើទោះបីជាទំព័រជាច្រើនត្រូវបានផ្ទុកក៏ដោយ។ ក្នុងរយៈពេលដ៏ខ្លី ហើយការត្រួតពិនិត្យក៏ចាប់ផ្តើមផងដែរ។ ខ្ញុំបានគ្រប់គ្រងធ្វើឱ្យ bot ផ្ញើសំណើទៅគេហទំព័រនៅចន្លោះពេលពី 4 ទៅ 6 ម៉ោង ហើយអ្វីៗដំណើរការល្អ។ ពីពេលមួយទៅពេលមួយ ការលំបាកកើតឡើងនៅពេលធ្វើការជាមួយ Kayak ប៉ុន្តែប្រសិនបើពួកគេចាប់ផ្តើមរំខានអ្នកជាមួយនឹងការត្រួតពិនិត្យ នោះអ្នកត្រូវដោះស្រាយជាមួយពួកគេដោយដៃហើយបន្ទាប់មកបើកដំណើរការ bot ឬរង់ចាំពីរបីម៉ោង ហើយការត្រួតពិនិត្យគួរតែបញ្ឈប់។ បើចាំបាច់ អ្នកអាចសម្របកូដសម្រាប់វេទិកាមួយផ្សេងទៀតបានយ៉ាងងាយស្រួល ហើយប្រសិនបើអ្នកធ្វើដូច្នេះ អ្នកអាចរាយការណ៍វានៅក្នុងមតិយោបល់។
ប្រសិនបើអ្នកទើបតែចាប់ផ្តើមជាមួយគេហទំព័រ scraping ហើយមិនដឹងថាហេតុអ្វីបានជាគេហទំព័រខ្លះតស៊ូជាមួយវា នោះមុនពេលអ្នកចាប់ផ្តើមគម្រោងដំបូងរបស់អ្នកនៅក្នុងតំបន់នេះ សូមធ្វើការពេញចិត្តដោយខ្លួនឯង ហើយធ្វើការស្វែងរកតាម Google លើពាក្យ "website scraping etiquette" . ការពិសោធន៍របស់អ្នកអាចបញ្ចប់លឿនជាងអ្នកគិត ប្រសិនបើអ្នកធ្វើគេហទំព័ររបស់អ្នកដោយមិនដឹងខ្លួន។
ការចាប់ផ្តើម
នេះជាទិដ្ឋភាពទូទៅនៃអ្វីដែលនឹងកើតឡើងនៅក្នុងកូដ scraper គេហទំព័ររបស់យើង៖
- នាំចូលបណ្ណាល័យដែលត្រូវការ។
- ការបើកផ្ទាំង Google Chrome ។
- ហៅទៅមុខងារដែលចាប់ផ្តើមបូត ដោយឆ្លងកាត់ទីក្រុង និងកាលបរិច្ឆេទដែលនឹងត្រូវបានប្រើនៅពេលស្វែងរកសំបុត្រ។
- មុខងារនេះយកលទ្ធផលស្វែងរកដំបូង តម្រៀបតាមល្អបំផុត ហើយចុចប៊ូតុងដើម្បីផ្ទុកលទ្ធផលបន្ថែមទៀត។
- មុខងារមួយទៀតប្រមូលទិន្នន័យពីទំព័រទាំងមូល ហើយត្រឡប់ស៊ុមទិន្នន័យ។
- ជំហានមុនពីរត្រូវបានអនុវត្តដោយប្រើប្រភេទតម្រៀបតាមតម្លៃសំបុត្រ (ថោក) និងតាមល្បឿនហោះហើរ (លឿនបំផុត)។
- អ្នកប្រើស្គ្រីបត្រូវបានផ្ញើអ៊ីមែលដែលមានសេចក្ដីសង្ខេបនៃតម្លៃសំបុត្រ (សំបុត្រថោកបំផុតនិងតម្លៃមធ្យម) ហើយស៊ុមទិន្នន័យដែលមានព័ត៌មានតម្រៀបតាមសូចនាករទាំងបីខាងលើត្រូវបានរក្សាទុកជាឯកសារ Excel ។
- សកម្មភាពខាងលើទាំងអស់ត្រូវបានអនុវត្តនៅក្នុងវដ្តមួយបន្ទាប់ពីរយៈពេលជាក់លាក់មួយ។
វាគួរតែត្រូវបានកត់សម្គាល់ថារាល់គម្រោង Selenium ចាប់ផ្តើមជាមួយកម្មវិធីបញ្ជាបណ្តាញ។ ខ្ញុំប្រើ ខ្ញុំធ្វើការជាមួយ Google Chrome ប៉ុន្តែមានជម្រើសផ្សេងទៀត។ PhantomJS និង Firefox ក៏មានប្រជាប្រិយភាពផងដែរ។ បន្ទាប់ពីទាញយកកម្មវិធីបញ្ជាអ្នកត្រូវដាក់វានៅក្នុងថតដែលសមស្របហើយនេះបញ្ចប់ការរៀបចំសម្រាប់ការប្រើប្រាស់របស់វា។ បន្ទាត់ដំបូងនៃស្គ្រីបរបស់យើងបើកផ្ទាំង Chrome ថ្មី។
សូមចងចាំថានៅក្នុងរឿងរបស់ខ្ញុំ ខ្ញុំមិនព្យាយាមបើកជើងមេឃថ្មីសម្រាប់ការស្វែងរកកិច្ចព្រមព្រៀងដ៏អស្ចារ្យលើសំបុត្រយន្តហោះនោះទេ។ មានវិធីសាស្រ្តកម្រិតខ្ពស់បន្ថែមទៀតក្នុងការស្វែងរកការផ្តល់ជូនបែបនេះ។ ខ្ញុំគ្រាន់តែចង់ផ្តល់ជូនអ្នកអាននូវសម្ភារៈនេះនូវវិធីសាមញ្ញ ប៉ុន្តែជាក់ស្តែងដើម្បីដោះស្រាយបញ្ហានេះ។
នេះគឺជាកូដដែលយើងបាននិយាយខាងលើ។
from time import sleep, strftime
from random import randint
import pandas as pd
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import smtplib
from email.mime.multipart import MIMEMultipart
# Используйте тут ваш путь к chromedriver!
chromedriver_path = 'C:/{YOUR PATH HERE}/chromedriver_win32/chromedriver.exe'
driver = webdriver.Chrome(executable_path=chromedriver_path) # Этой командой открывается окно Chrome
sleep(2)
នៅដើមកូដ អ្នកអាចមើលឃើញពាក្យបញ្ជានាំចូលកញ្ចប់ដែលត្រូវបានប្រើពេញគម្រោងរបស់យើង។ ដូច្នេះ randint ប្រើដើម្បីធ្វើឱ្យ bot "ដេកលក់" សម្រាប់ចំនួនចៃដន្យនៃវិនាទីមុនពេលចាប់ផ្តើមប្រតិបត្តិការស្វែងរកថ្មី។ ជាធម្មតា មិនមែន bot តែមួយអាចធ្វើបានដោយគ្មានវាទេ។ ប្រសិនបើអ្នកដំណើរការកូដខាងលើ បង្អួច Chrome នឹងបើក ដែល bot នឹងប្រើដើម្បីធ្វើការជាមួយគេហទំព័រ។
ចូរធ្វើការពិសោធន៍បន្តិច ហើយបើកគេហទំព័រ kayak.com នៅក្នុងបង្អួចដាច់ដោយឡែកមួយ។ យើងនឹងជ្រើសរើសទីក្រុងដែលយើងនឹងហោះហើរ និងទីក្រុងដែលយើងចង់ទៅដល់ ក៏ដូចជាកាលបរិច្ឆេទហោះហើរផងដែរ។ នៅពេលជ្រើសរើសកាលបរិច្ឆេទ សូមប្រាកដថាជួរនៃ +-3 ថ្ងៃត្រូវបានប្រើប្រាស់។ ខ្ញុំបានសរសេរកូដដោយគិតគូរពីអ្វីដែលគេហទំព័រផលិតក្នុងការឆ្លើយតបទៅនឹងសំណើបែបនេះ។ ឧទាហរណ៍ ប្រសិនបើអ្នកត្រូវការស្វែងរកសំបុត្រសម្រាប់តែកាលបរិច្ឆេទដែលបានបញ្ជាក់ នោះមានប្រូបាបខ្ពស់ដែលអ្នកនឹងត្រូវកែប្រែកូដ bot ។ នៅពេលខ្ញុំនិយាយអំពីកូដ ខ្ញុំផ្តល់ការពន្យល់សមរម្យ ប៉ុន្តែប្រសិនបើអ្នកមានអារម្មណ៍ច្របូកច្របល់ សូមប្រាប់ខ្ញុំផង។
ឥឡូវចុចលើប៊ូតុងស្វែងរក ហើយមើលតំណក្នុងរបារអាសយដ្ឋាន។ វាគួរតែស្រដៀងនឹងតំណភ្ជាប់ដែលខ្ញុំប្រើក្នុងឧទាហរណ៍ខាងក្រោមដែលអថេរត្រូវបានប្រកាស kayakដែលរក្សាទុក URL ហើយវិធីសាស្ត្រត្រូវបានប្រើប្រាស់ get កម្មវិធីបញ្ជាគេហទំព័រ។ បន្ទាប់ពីចុចប៊ូតុងស្វែងរក លទ្ធផលគួរតែបង្ហាញនៅលើទំព័រ។
នៅពេលខ្ញុំប្រើពាក្យបញ្ជា get ច្រើនជាងពីរ ឬបីដងក្នុងរយៈពេលពីរបីនាទី ខ្ញុំត្រូវបានស្នើសុំឱ្យបញ្ចប់ការផ្ទៀងផ្ទាត់ដោយប្រើ reCaptcha ។ អ្នកអាចឆ្លងកាត់ការត្រួតពិនិត្យនេះដោយដៃ ហើយបន្តការពិសោធន៍រហូតដល់ប្រព័ន្ធសម្រេចចិត្តដំណើរការការត្រួតពិនិត្យថ្មី។ នៅពេលខ្ញុំសាកល្បងស្គ្រីប វាហាក់បីដូចជាវគ្គស្វែងរកដំបូងតែងតែដំណើរការយ៉ាងរលូន ដូច្នេះប្រសិនបើអ្នកចង់សាកល្បងជាមួយកូដ អ្នកគ្រាន់តែពិនិត្យមើលជាទៀងទាត់ និងអនុញ្ញាតឱ្យកូដដំណើរការដោយប្រើចន្លោះពេលវែងរវាងវគ្គស្វែងរក។ ហើយប្រសិនបើអ្នកគិតអំពីវា មនុស្សម្នាក់ទំនងជាមិនត្រូវការព័ត៌មានអំពីតម្លៃសំបុត្រដែលបានទទួលនៅចន្លោះពេល 10 នាទីរវាងប្រតិបត្តិការស្វែងរកនោះទេ។
ធ្វើការជាមួយទំព័រដោយប្រើ XPath
ដូច្នេះ យើងបានបើកវិនដូមួយ ហើយផ្ទុកគេហទំព័រ។ ដើម្បីទទួលបានតម្លៃ និងព័ត៌មានផ្សេងទៀត យើងត្រូវប្រើបច្ចេកវិទ្យា XPath ឬឧបករណ៍ជ្រើសរើស CSS ។ ខ្ញុំបានសម្រេចចិត្តបិទជាមួយ XPath ហើយមិនមានអារម្មណ៍ថាត្រូវការប្រើឧបករណ៍ជ្រើសរើស CSS ទេ ប៉ុន្តែវាពិតជាអាចទៅរួចក្នុងការដំណើរការបែបនោះ។ ការរុករកជុំវិញទំព័រដោយប្រើ XPath អាចជារឿងពិបាក ហើយទោះបីជាអ្នកប្រើបច្ចេកទេសដែលខ្ញុំបានពិពណ៌នានៅក្នុង អត្ថបទដែលពាក់ព័ន្ធនឹងការចម្លងឧបករណ៍កំណត់អត្តសញ្ញាណដែលត្រូវគ្នាពីកូដទំព័រ ខ្ញុំបានដឹងថា តាមពិតនេះមិនមែនជាវិធីល្អបំផុតដើម្បីចូលប្រើធាតុចាំបាច់នោះទេ។ ដោយវិធីនេះនៅក្នុង សៀវភៅនេះផ្តល់នូវការពិពណ៌នាដ៏ល្អអំពីមូលដ្ឋានគ្រឹះនៃការធ្វើការជាមួយទំព័រដោយប្រើឧបករណ៍ជ្រើសរើស XPath និង CSS ។ នេះគឺជាអ្វីដែលវិធីសាស្ត្រកម្មវិធីបញ្ជាគេហទំព័រដែលត្រូវគ្នាមើលទៅដូច។
ដូច្នេះសូមបន្តធ្វើការលើ bot ។ តោះប្រើសមត្ថភាពរបស់កម្មវិធីដើម្បីជ្រើសរើសសំបុត្រថោកបំផុត។ នៅក្នុងរូបភាពខាងក្រោម កូដជ្រើសរើស XPath ត្រូវបានបន្លិចជាពណ៌ក្រហម។ ដើម្បីមើលកូដ អ្នកត្រូវចុចកណ្ដុរស្ដាំលើធាតុទំព័រដែលអ្នកចាប់អារម្មណ៍ ហើយជ្រើសរើសពាក្យបញ្ជា Inspect ពីម៉ឺនុយដែលលេចឡើង។ ពាក្យបញ្ជានេះអាចត្រូវបានហៅសម្រាប់ធាតុទំព័រផ្សេងគ្នា ដែលកូដនឹងត្រូវបានបង្ហាញ និងបន្លិចក្នុងកម្មវិធីមើលកូដ។
មើលលេខកូដទំព័រ
ដើម្បីស្វែងរកការបញ្ជាក់ពីហេតុផលរបស់ខ្ញុំអំពីគុណវិបត្តិនៃការចម្លងអ្នកជ្រើសរើសពីកូដ សូមយកចិត្តទុកដាក់លើលក្ខណៈពិសេសខាងក្រោម។
នេះជាអ្វីដែលអ្នកទទួលបាននៅពេលអ្នកចម្លងកូដ៖
//*[@id="wtKI-price_aTab"]/div[1]/div/div/div[1]/div/span/spanដើម្បីចម្លងអ្វីមួយដូចនេះ អ្នកត្រូវចុចកណ្ដុរស្ដាំលើផ្នែកនៃកូដដែលអ្នកចាប់អារម្មណ៍ ហើយជ្រើសរើសពាក្យបញ្ជា ចម្លង> ចម្លង XPath ពីម៉ឺនុយដែលលេចឡើង។
នេះជាអ្វីដែលខ្ញុំធ្លាប់កំណត់ប៊ូតុងថោកបំផុត៖
cheap_results = ‘//a[@data-code = "price"]’
ចម្លងពាក្យបញ្ជា > ចម្លង XPath
វាច្បាស់ណាស់ថាជម្រើសទីពីរមើលទៅសាមញ្ញជាង។ នៅពេលប្រើ វាស្វែងរកធាតុ a ដែលមានគុណលក្ខណៈ data-codeស្មើនឹង price. នៅពេលប្រើជម្រើសទីមួយ ធាតុត្រូវបានស្វែងរក id ដែលស្មើនឹង wtKI-price_aTabហើយផ្លូវ XPath ទៅកាន់ធាតុមើលទៅដូច /div[1]/div/div/div[1]/div/span/span. សំណួរ XPath ដូចនេះទៅទំព័រមួយនឹងធ្វើល្បិច ប៉ុន្តែបានតែម្តង។ ខ្ញុំអាចនិយាយបាននៅពេលនេះ id នឹងផ្លាស់ប្តូរនៅពេលក្រោយទំព័រត្រូវបានផ្ទុក។ លំដាប់តួអក្សរ wtKI ផ្លាស់ប្តូរថាមវន្តរាល់ពេលដែលទំព័រត្រូវបានផ្ទុក ដូច្នេះកូដដែលប្រើវានឹងគ្មានប្រយោជន៍ទេ បន្ទាប់ពីទំព័របន្ទាប់ផ្ទុកឡើងវិញ។ ដូច្នេះសូមចំណាយពេលខ្លះដើម្បីយល់ពី XPath ។ ចំណេះដឹងនេះនឹងបម្រើអ្នកបានយ៉ាងល្អ។
ទោះជាយ៉ាងណាក៏ដោយគួរកត់សំគាល់ថាការចម្លងឧបករណ៍ជ្រើសរើស XPath អាចមានប្រយោជន៍នៅពេលធ្វើការជាមួយគេហទំព័រសាមញ្ញដោយយុត្តិធម៌ ហើយប្រសិនបើអ្នកមានផាសុកភាពជាមួយវា វាមិនមានអ្វីខុសជាមួយវាទេ។
ឥឡូវនេះ ចូរយើងគិតអំពីអ្វីដែលត្រូវធ្វើ ប្រសិនបើអ្នកត្រូវការដើម្បីទទួលបានលទ្ធផលស្វែងរកទាំងអស់នៅក្នុងបន្ទាត់ជាច្រើន នៅខាងក្នុងបញ្ជីមួយ។ សាមញ្ញណាស់។ លទ្ធផលនីមួយៗគឺនៅខាងក្នុងវត្ថុដែលមានថ្នាក់ resultWrapper. ការផ្ទុកលទ្ធផលទាំងអស់អាចត្រូវបានធ្វើនៅក្នុងរង្វិលជុំស្រដៀងនឹងអ្វីដែលបានបង្ហាញខាងក្រោម។
គួរកត់សម្គាល់ថាប្រសិនបើអ្នកយល់ពីចំណុចខាងលើនោះអ្នកគួរតែងាយស្រួលយល់អំពីកូដភាគច្រើនដែលយើងនឹងវិភាគ។ នៅពេលដែលកូដនេះដំណើរការ យើងចូលប្រើអ្វីដែលយើងត្រូវការ (តាមពិត ធាតុដែលលទ្ធផលត្រូវបានរុំ) ដោយប្រើយន្តការកំណត់ផ្លូវមួយចំនួន (XPath)។ វាត្រូវបានធ្វើដើម្បីទទួលបានអត្ថបទនៃធាតុ ហើយដាក់វាក្នុងវត្ថុដែលទិន្នន័យអាចត្រូវបានអាន (ប្រើជាលើកដំបូង flight_containersបន្ទាប់មក - flights_list).
បន្ទាត់បីដំបូងត្រូវបានបង្ហាញ ហើយយើងអាចមើលឃើញយ៉ាងច្បាស់នូវអ្វីគ្រប់យ៉ាងដែលយើងត្រូវការ។ ទោះយ៉ាងណាក៏ដោយ យើងមានវិធីគួរឱ្យចាប់អារម្មណ៍បន្ថែមទៀតក្នុងការទទួលបានព័ត៌មាន។ យើងត្រូវយកទិន្នន័យពីធាតុនីមួយៗដោយឡែកពីគ្នា។
ទៅធ្វើការ!
មធ្យោបាយងាយស្រួលបំផុតក្នុងការសរសេរមុខងារគឺត្រូវផ្ទុកលទ្ធផលបន្ថែម ដូច្នេះហើយជាកន្លែងដែលយើងនឹងចាប់ផ្តើម។ ខ្ញុំចង់បង្កើនចំនួនជើងហោះហើរជាអតិបរមាដែលកម្មវិធីទទួលបានព័ត៌មាន ដោយមិនបង្កើនការសង្ស័យនៅក្នុងសេវាកម្មដែលនាំទៅដល់ការត្រួតពិនិត្យ ដូច្នេះខ្ញុំចុចប៊ូតុង Load more results ម្តងរាល់ពេលដែលទំព័រត្រូវបានបង្ហាញ។ នៅក្នុងកូដនេះអ្នកគួរតែយកចិត្តទុកដាក់ចំពោះប្លុក tryដែលខ្ញុំបានបន្ថែមព្រោះពេលខ្លះប៊ូតុងមិនដំណើរការត្រឹមត្រូវ។ ប្រសិនបើអ្នកជួបប្រទះបញ្ហានេះដែរ សូមបញ្ចេញមតិអំពីការហៅទៅកាន់មុខងារនេះនៅក្នុងលេខកូដមុខងារ start_kayakដែលយើងនឹងមើលខាងក្រោម។
# Загрузка большего количества результатов для того, чтобы максимизировать объём собираемых данных
def load_more():
try:
more_results = '//a[@class = "moreButton"]'
driver.find_element_by_xpath(more_results).click()
# Вывод этих заметок в ходе работы программы помогает мне быстро выяснить то, чем она занята
print('sleeping.....')
sleep(randint(45,60))
except:
passឥឡូវនេះ បន្ទាប់ពីការវិភាគដ៏យូរនៃមុខងារនេះ (ពេលខ្លះខ្ញុំអាចយកទៅឆ្ងាយ) យើងត្រៀមខ្លួនរួចរាល់ហើយដើម្បីប្រកាសមុខងារដែលនឹងលុបចោលទំព័រ។
ខ្ញុំបានប្រមូលរួចហើយនូវអ្វីដែលត្រូវការជាចាំបាច់នៅក្នុងមុខងារខាងក្រោមហៅថា page_scrape. ពេលខ្លះទិន្នន័យផ្លូវត្រឡប់មកវិញត្រូវបានបញ្ចូលគ្នា ដូច្នេះខ្ញុំប្រើវិធីសាមញ្ញដើម្បីបំបែកវា។ ឧទាហរណ៍ នៅពេលខ្ញុំប្រើអថេរជាលើកដំបូង section_a_list и section_b_list. មុខងាររបស់យើងត្រឡប់ស៊ុមទិន្នន័យ flights_dfនេះអនុញ្ញាតឱ្យយើងបំបែកលទ្ធផលដែលទទួលបានពីវិធីសាស្ត្រតម្រៀបទិន្នន័យផ្សេងៗគ្នា ហើយក្រោយមកបញ្ចូលគ្នាពួកវា។
def page_scrape():
"""This function takes care of the scraping part"""
xp_sections = '//*[@class="section duration"]'
sections = driver.find_elements_by_xpath(xp_sections)
sections_list = [value.text for value in sections]
section_a_list = sections_list[::2] # так мы разделяем информацию о двух полётах
section_b_list = sections_list[1::2]
# Если вы наткнулись на reCaptcha, вам может понадобиться что-то предпринять.
# О том, что что-то пошло не так, вы узнаете исходя из того, что вышеприведённые списки пусты
# это выражение if позволяет завершить работу программы или сделать ещё что-нибудь
# тут можно приостановить работу, что позволит вам пройти проверку и продолжить скрапинг
# я использую тут SystemExit так как хочу протестировать всё с самого начала
if section_a_list == []:
raise SystemExit
# Я буду использовать букву A для уходящих рейсов и B для прибывающих
a_duration = []
a_section_names = []
for n in section_a_list:
# Получаем время
a_section_names.append(''.join(n.split()[2:5]))
a_duration.append(''.join(n.split()[0:2]))
b_duration = []
b_section_names = []
for n in section_b_list:
# Получаем время
b_section_names.append(''.join(n.split()[2:5]))
b_duration.append(''.join(n.split()[0:2]))
xp_dates = '//div[@class="section date"]'
dates = driver.find_elements_by_xpath(xp_dates)
dates_list = [value.text for value in dates]
a_date_list = dates_list[::2]
b_date_list = dates_list[1::2]
# Получаем день недели
a_day = [value.split()[0] for value in a_date_list]
a_weekday = [value.split()[1] for value in a_date_list]
b_day = [value.split()[0] for value in b_date_list]
b_weekday = [value.split()[1] for value in b_date_list]
# Получаем цены
xp_prices = '//a[@class="booking-link"]/span[@class="price option-text"]'
prices = driver.find_elements_by_xpath(xp_prices)
prices_list = [price.text.replace('$','') for price in prices if price.text != '']
prices_list = list(map(int, prices_list))
# stops - это большой список, в котором первый фрагмент пути находится по чётному индексу, а второй - по нечётному
xp_stops = '//div[@class="section stops"]/div[1]'
stops = driver.find_elements_by_xpath(xp_stops)
stops_list = [stop.text[0].replace('n','0') for stop in stops]
a_stop_list = stops_list[::2]
b_stop_list = stops_list[1::2]
xp_stops_cities = '//div[@class="section stops"]/div[2]'
stops_cities = driver.find_elements_by_xpath(xp_stops_cities)
stops_cities_list = [stop.text for stop in stops_cities]
a_stop_name_list = stops_cities_list[::2]
b_stop_name_list = stops_cities_list[1::2]
# сведения о компании-перевозчике, время отправления и прибытия для обоих рейсов
xp_schedule = '//div[@class="section times"]'
schedules = driver.find_elements_by_xpath(xp_schedule)
hours_list = []
carrier_list = []
for schedule in schedules:
hours_list.append(schedule.text.split('n')[0])
carrier_list.append(schedule.text.split('n')[1])
# разделяем сведения о времени и о перевозчиках между рейсами a и b
a_hours = hours_list[::2]
a_carrier = carrier_list[1::2]
b_hours = hours_list[::2]
b_carrier = carrier_list[1::2]
cols = (['Out Day', 'Out Time', 'Out Weekday', 'Out Airline', 'Out Cities', 'Out Duration', 'Out Stops', 'Out Stop Cities',
'Return Day', 'Return Time', 'Return Weekday', 'Return Airline', 'Return Cities', 'Return Duration', 'Return Stops', 'Return Stop Cities',
'Price'])
flights_df = pd.DataFrame({'Out Day': a_day,
'Out Weekday': a_weekday,
'Out Duration': a_duration,
'Out Cities': a_section_names,
'Return Day': b_day,
'Return Weekday': b_weekday,
'Return Duration': b_duration,
'Return Cities': b_section_names,
'Out Stops': a_stop_list,
'Out Stop Cities': a_stop_name_list,
'Return Stops': b_stop_list,
'Return Stop Cities': b_stop_name_list,
'Out Time': a_hours,
'Out Airline': a_carrier,
'Return Time': b_hours,
'Return Airline': b_carrier,
'Price': prices_list})[cols]
flights_df['timestamp'] = strftime("%Y%m%d-%H%M") # время сбора данных
return flights_df
ខ្ញុំបានព្យាយាមដាក់ឈ្មោះអថេរ ដើម្បីឱ្យកូដអាចយល់បាន។ ចងចាំថាអថេរដែលចាប់ផ្តើមជាមួយ a ជាកម្មសិទ្ធិរបស់ដំណាក់កាលដំបូងនៃផ្លូវ និង b - ទៅទីពីរ។ ចូរបន្តទៅមុខងារបន្ទាប់។
យន្តការគាំទ្រ
ឥឡូវនេះយើងមានមុខងារមួយដែលអនុញ្ញាតឱ្យយើងផ្ទុកលទ្ធផលស្វែងរកបន្ថែម និងមុខងារមួយដើម្បីដំណើរការលទ្ធផលទាំងនោះ។ អត្ថបទនេះអាចបញ្ចប់នៅទីនេះ ដោយសារមុខងារទាំងពីរនេះផ្តល់នូវអ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវការដើម្បីលុបទំព័រដែលអ្នកអាចបើកដោយខ្លួនឯង។ ប៉ុន្តែយើងមិនទាន់ពិចារណាលើយន្តការជំនួយមួយចំនួនដែលបានពិភាក្សាខាងលើនៅឡើយទេ។ ឧទាហរណ៍ នេះជាកូដសម្រាប់ផ្ញើអ៊ីមែល និងរបស់មួយចំនួនទៀត។ ទាំងអស់នេះអាចរកបាននៅក្នុងមុខងារ start_kayakដែលយើងនឹងពិចារណាឥឡូវនេះ។
មុខងារនេះទាមទារព័ត៌មានអំពីទីក្រុង និងកាលបរិច្ឆេទ។ ដោយប្រើព័ត៌មាននេះ វាបង្កើតជាតំណភ្ជាប់ក្នុងអថេរមួយ។ kayakដែលត្រូវបានប្រើដើម្បីនាំអ្នកទៅកាន់ទំព័រដែលនឹងមានលទ្ធផលស្វែងរកដែលតម្រៀបតាមការផ្គូផ្គងដ៏ល្អបំផុតរបស់ពួកគេទៅនឹងសំណួរ។ បន្ទាប់ពីវគ្គជម្រុះដំបូង យើងនឹងធ្វើការជាមួយតម្លៃក្នុងតារាងនៅផ្នែកខាងលើនៃទំព័រ។ ពោលគឺយើងនឹងស្វែងរកតម្លៃសំបុត្រអប្បបរមា និងតម្លៃមធ្យម។ ទាំងអស់នេះរួមជាមួយនឹងការព្យាករណ៍ដែលចេញដោយគេហទំព័រនឹងត្រូវបានផ្ញើតាមអ៊ីមែល។ នៅលើទំព័រ តារាងដែលត្រូវគ្នាគួរតែនៅជ្រុងខាងឆ្វេងខាងលើ។ ដោយវិធីនេះ ការធ្វើការជាមួយតារាងនេះអាចបណ្តាលឱ្យមានកំហុសនៅពេលស្វែងរកដោយប្រើកាលបរិច្ឆេទពិតប្រាកដ ដោយសារក្នុងករណីនេះតារាងមិនត្រូវបានបង្ហាញនៅលើទំព័រ។
def start_kayak(city_from, city_to, date_start, date_end):
"""City codes - it's the IATA codes!
Date format - YYYY-MM-DD"""
kayak = ('https://www.kayak.com/flights/' + city_from + '-' + city_to +
'/' + date_start + '-flexible/' + date_end + '-flexible?sort=bestflight_a')
driver.get(kayak)
sleep(randint(8,10))
# иногда появляется всплывающее окно, для проверки на это и его закрытия можно воспользоваться блоком try
try:
xp_popup_close = '//button[contains(@id,"dialog-close") and contains(@class,"Button-No-Standard-Style close ")]'
driver.find_elements_by_xpath(xp_popup_close)[5].click()
except Exception as e:
pass
sleep(randint(60,95))
print('loading more.....')
# load_more()
print('starting first scrape.....')
df_flights_best = page_scrape()
df_flights_best['sort'] = 'best'
sleep(randint(60,80))
# Возьмём самую низкую цену из таблицы, расположенной в верхней части страницы
matrix = driver.find_elements_by_xpath('//*[contains(@id,"FlexMatrixCell")]')
matrix_prices = [price.text.replace('$','') for price in matrix]
matrix_prices = list(map(int, matrix_prices))
matrix_min = min(matrix_prices)
matrix_avg = sum(matrix_prices)/len(matrix_prices)
print('switching to cheapest results.....')
cheap_results = '//a[@data-code = "price"]'
driver.find_element_by_xpath(cheap_results).click()
sleep(randint(60,90))
print('loading more.....')
# load_more()
print('starting second scrape.....')
df_flights_cheap = page_scrape()
df_flights_cheap['sort'] = 'cheap'
sleep(randint(60,80))
print('switching to quickest results.....')
quick_results = '//a[@data-code = "duration"]'
driver.find_element_by_xpath(quick_results).click()
sleep(randint(60,90))
print('loading more.....')
# load_more()
print('starting third scrape.....')
df_flights_fast = page_scrape()
df_flights_fast['sort'] = 'fast'
sleep(randint(60,80))
# Сохранение нового фрейма в Excel-файл, имя которого отражает города и даты
final_df = df_flights_cheap.append(df_flights_best).append(df_flights_fast)
final_df.to_excel('search_backups//{}_flights_{}-{}_from_{}_to_{}.xlsx'.format(strftime("%Y%m%d-%H%M"),
city_from, city_to,
date_start, date_end), index=False)
print('saved df.....')
# Можно следить за тем, как прогноз, выдаваемый сайтом, соотносится с реальностью
xp_loading = '//div[contains(@id,"advice")]'
loading = driver.find_element_by_xpath(xp_loading).text
xp_prediction = '//span[@class="info-text"]'
prediction = driver.find_element_by_xpath(xp_prediction).text
print(loading+'n'+prediction)
# иногда в переменной loading оказывается эта строка, которая, позже, вызывает проблемы с отправкой письма
# если это прозошло - меняем её на "Not Sure"
weird = '¯_(ツ)_/¯'
if loading == weird:
loading = 'Not sure'
username = '[email protected]'
password = 'YOUR PASSWORD'
server = smtplib.SMTP('smtp.outlook.com', 587)
server.ehlo()
server.starttls()
server.login(username, password)
msg = ('Subject: Flight Scrapernn
Cheapest Flight: {}nAverage Price: {}nnRecommendation: {}nnEnd of message'.format(matrix_min, matrix_avg, (loading+'n'+prediction)))
message = MIMEMultipart()
message['From'] = '[email protected]'
message['to'] = '[email protected]'
server.sendmail('[email protected]', '[email protected]', msg)
print('sent email.....')ខ្ញុំបានសាកល្បងស្គ្រីបនេះដោយប្រើគណនី Outlook (hotmail.com) ។ ខ្ញុំមិនបានសាកល្បងវាដើម្បីដំណើរការបានត្រឹមត្រូវជាមួយគណនី Gmail ទេ ប្រព័ន្ធអ៊ីមែលនេះមានប្រជាប្រិយភាពណាស់ ប៉ុន្តែមានជម្រើសជាច្រើនដែលអាចធ្វើបាន។ ប្រសិនបើអ្នកប្រើគណនី Hotmail បន្ទាប់មកដើម្បីឱ្យអ្វីៗដំណើរការបាន អ្នកគ្រាន់តែបញ្ចូលទិន្នន័យរបស់អ្នកទៅក្នុងលេខកូដប៉ុណ្ណោះ។
ប្រសិនបើអ្នកចង់យល់ពីអ្វីដែលកំពុងត្រូវបានធ្វើនៅក្នុងផ្នែកជាក់លាក់នៃកូដសម្រាប់មុខងារនេះ អ្នកអាចចម្លងពួកវា និងពិសោធន៍ជាមួយពួកគេ។ ការពិសោធជាមួយកូដគឺជាមធ្យោបាយតែមួយគត់ដើម្បីយល់ពីវាយ៉ាងពិតប្រាកដ។
ប្រព័ន្ធរួចរាល់
ឥឡូវនេះយើងបានធ្វើអ្វីគ្រប់យ៉ាងដែលយើងបាននិយាយ យើងអាចបង្កើតរង្វិលជុំសាមញ្ញដែលហៅមុខងាររបស់យើង។ ស្គ្រីបស្នើសុំទិន្នន័យពីអ្នកប្រើប្រាស់អំពីទីក្រុង និងកាលបរិច្ឆេទ។ នៅពេលសាកល្បងជាមួយនឹងការចាប់ផ្តើមឡើងវិញជាប្រចាំនៃស្គ្រីប អ្នកទំនងជាមិនចង់បញ្ចូលទិន្នន័យនេះដោយដៃរាល់ពេលទេ ដូច្នេះបន្ទាត់ដែលត្រូវគ្នាសម្រាប់ពេលសាកល្បង អាចត្រូវបានបញ្ចេញមតិដោយការមិនបញ្ចេញមតិខាងក្រោម ដែលក្នុងនោះទិន្នន័យដែលត្រូវការដោយ ស្គ្រីបត្រូវបានសរសេរកូដរឹង។
city_from = input('From which city? ')
city_to = input('Where to? ')
date_start = input('Search around which departure date? Please use YYYY-MM-DD format only ')
date_end = input('Return when? Please use YYYY-MM-DD format only ')
# city_from = 'LIS'
# city_to = 'SIN'
# date_start = '2019-08-21'
# date_end = '2019-09-07'
for n in range(0,5):
start_kayak(city_from, city_to, date_start, date_end)
print('iteration {} was complete @ {}'.format(n, strftime("%Y%m%d-%H%M")))
# Ждём 4 часа
sleep(60*60*4)
print('sleep finished.....')
នេះជាអ្វីដែលដំណើរការសាកល្បងនៃស្គ្រីបមើលទៅ។
ដំណើរការសាកល្បងនៃស្គ្រីប
លទ្ធផល
បើសម្រេចបានឆ្ងាយហើយ សូមអបអរសាទរ! ឥឡូវនេះ អ្នកមាន web scraper ដែលកំពុងដំណើរការ ទោះបីជាខ្ញុំអាចមើលឃើញវិធីជាច្រើនដើម្បីកែលម្អវាក៏ដោយ។ ឧទាហរណ៍ វាអាចត្រូវបានរួមបញ្ចូលជាមួយ Twilio ដើម្បីឱ្យវាផ្ញើសារជាអក្សរជំនួសឱ្យអ៊ីមែល។ អ្នកអាចប្រើ VPN ឬអ្វីផ្សេងទៀតដើម្បីទទួលលទ្ធផលក្នុងពេលដំណាលគ្នាពីម៉ាស៊ីនមេជាច្រើន។ វាក៏មានបញ្ហាកើតឡើងជាទៀងទាត់ជាមួយនឹងការពិនិត្យមើលអ្នកប្រើប្រាស់គេហទំព័រដើម្បីមើលថាតើគាត់ជាមនុស្សដែរឬអត់ ប៉ុន្តែបញ្ហានេះក៏អាចដោះស្រាយបានដែរ។ ក្នុងករណីណាក៏ដោយឥឡូវនេះអ្នកមានមូលដ្ឋានដែលអ្នកអាចពង្រីកប្រសិនបើអ្នកចង់បាន។ ជាឧទាហរណ៍ សូមប្រាកដថាឯកសារ Excel ត្រូវបានផ្ញើទៅអ្នកប្រើប្រាស់ជាឯកសារភ្ជាប់ទៅកាន់អ៊ីមែល។
មានតែអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះប៉ុណ្ណោះដែលអាចចូលរួមក្នុងការស្ទង់មតិនេះ។ សូម។
តើអ្នកប្រើបច្ចេកវិទ្យា scraping គេហទំព័រទេ?
-
ថា
-
គ្មាន
អ្នកប្រើប្រាស់ 8 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ 1 នាក់ត្រូវបានហាមឃាត់។
ប្រភព: www.habr.com