பைதான் - பயணம் செய்ய விரும்புவோருக்கு மலிவான விமான டிக்கெட்டுகளை கண்டுபிடிப்பதில் உதவியாளர்

இன்று நாம் வெளியிடும் கட்டுரையின் ஆசிரியர், விமான டிக்கெட் விலையைத் தேடும் செலினியத்தைப் பயன்படுத்தி பைத்தானில் ஒரு வலை ஸ்கிராப்பரை உருவாக்குவது பற்றி பேசுவதே அதன் குறிக்கோள் என்று கூறுகிறார். டிக்கெட்டுகளைத் தேடும்போது, ​​நெகிழ்வான தேதிகள் பயன்படுத்தப்படுகின்றன (+- குறிப்பிட்ட தேதிகளுடன் தொடர்புடைய 3 நாட்கள்). ஸ்கிராப்பர் தேடல் முடிவுகளை எக்செல் கோப்பில் சேமித்து, அதை இயக்கியவருக்கு அவர்கள் கண்டறிந்தவற்றின் சுருக்கத்துடன் மின்னஞ்சலை அனுப்புகிறது. இந்த திட்டத்தின் குறிக்கோள் பயணிகளுக்கு சிறந்த சலுகைகளைக் கண்டறிய உதவுவதாகும்.

பொருளைப் புரிந்து கொள்ளும்போது, ​​தொலைந்து போனதாக உணர்ந்தால், பாருங்கள் இந்த கட்டுரை.

எதைத் தேடப் போகிறோம்?

இங்கே விவரிக்கப்பட்டுள்ள கணினியை நீங்கள் விரும்பியபடி பயன்படுத்திக்கொள்ளலாம். எடுத்துக்காட்டாக, எனது சொந்த ஊருக்கு வார இறுதி சுற்றுப்பயணங்கள் மற்றும் டிக்கெட்டுகளைத் தேட இதைப் பயன்படுத்தினேன். லாபகரமான டிக்கெட்டுகளைக் கண்டுபிடிப்பதில் நீங்கள் தீவிரமாக இருந்தால், சர்வரில் ஸ்கிரிப்டை இயக்கலாம் (எளிமையானது சர்வர், ஒரு மாதத்திற்கு 130 ரூபிள், இதற்கு மிகவும் பொருத்தமானது) மற்றும் அது ஒரு நாளைக்கு ஒரு முறை அல்லது இரண்டு முறை இயங்குகிறது என்பதை உறுதிப்படுத்தவும். தேடல் முடிவுகள் மின்னஞ்சல் மூலம் உங்களுக்கு அனுப்பப்படும். கூடுதலாக, டிராப்பாக்ஸ் கோப்புறையில் தேடல் முடிவுகளுடன் எக்செல் கோப்பை ஸ்கிரிப்ட் சேமிக்கும் வகையில் அனைத்தையும் அமைக்க பரிந்துரைக்கிறேன், இது போன்ற கோப்புகளை எங்கிருந்தும் எந்த நேரத்திலும் பார்க்க உங்களை அனுமதிக்கும்.

பிழைகள் உள்ள கட்டணங்களை நான் இன்னும் கண்டுபிடிக்கவில்லை, ஆனால் அது சாத்தியம் என்று நினைக்கிறேன்

தேடும் போது, ​​ஏற்கனவே குறிப்பிட்டுள்ளபடி, "நெகிழ்வான தேதி" பயன்படுத்தப்படுகிறது; கொடுக்கப்பட்ட தேதிகளில் மூன்று நாட்களுக்குள் இருக்கும் சலுகைகளை ஸ்கிரிப்ட் கண்டறிகிறது. ஸ்கிரிப்டை இயக்கும்போது, ​​ஒரே ஒரு திசையில் சலுகைகளைத் தேடினாலும், பல விமானத் திசைகளில் தரவைச் சேகரிக்கும் வகையில் அதை மாற்றுவது எளிது. அதன் உதவியுடன், நீங்கள் தவறான கட்டணங்களைக் கூட தேடலாம்; அத்தகைய கண்டுபிடிப்புகள் மிகவும் சுவாரஸ்யமாக இருக்கும்.

உங்களுக்கு ஏன் மற்றொரு வலை ஸ்கிராப்பர் தேவை?

நான் முதலில் வலை ஸ்கிராப்பிங்கைத் தொடங்கியபோது, ​​நான் அதில் குறிப்பாக ஆர்வம் காட்டவில்லை. முன்கணிப்பு மாடலிங் துறையில், நிதி பகுப்பாய்வு மற்றும், ஒருவேளை, உரைகளின் உணர்ச்சி வண்ணத்தை பகுப்பாய்வு செய்யும் துறையில் நான் அதிக திட்டங்களைச் செய்ய விரும்பினேன். ஆனால் வலைத்தளங்களிலிருந்து தரவைச் சேகரிக்கும் ஒரு நிரலை எவ்வாறு உருவாக்குவது என்பதைக் கண்டுபிடிப்பது மிகவும் சுவாரஸ்யமானது என்று மாறியது. இந்த தலைப்பில் நான் ஆராய்ந்தபோது, ​​​​வெப் ஸ்கிராப்பிங் என்பது இணையத்தின் "இயந்திரம்" என்பதை உணர்ந்தேன்.

இது மிகவும் தைரியமான அறிக்கை என்று நீங்கள் நினைக்கலாம். ஆனால் ஜாவா மற்றும் பைத்தானைப் பயன்படுத்தி லாரி பேஜ் உருவாக்கிய வெப் ஸ்கிராப்பருடன் கூகுள் தொடங்கியது என்று கருதுங்கள். கூகுள் ரோபோக்கள் இணையத்தை ஆராய்ந்து, அதன் பயனர்களின் கேள்விகளுக்கு சிறந்த பதில்களை வழங்க முயல்கின்றன. வெப் ஸ்கிராப்பிங்கில் முடிவற்ற பயன்கள் உள்ளன, மேலும் தரவு அறிவியலில் நீங்கள் வேறு ஏதாவது ஆர்வமாக இருந்தாலும், நீங்கள் பகுப்பாய்வு செய்ய வேண்டிய தரவைப் பெற சில ஸ்கிராப்பிங் திறன்கள் தேவைப்படும்.

இங்கு பயன்படுத்தப்பட்டுள்ள சில நுட்பங்களை அற்புதமாக கண்டேன் புத்தகம் நான் சமீபத்தில் வாங்கிய வலை ஸ்கிராப்பிங் பற்றி. நீங்கள் கற்றுக்கொண்டவற்றின் நடைமுறை பயன்பாட்டிற்கான பல எளிய எடுத்துக்காட்டுகள் மற்றும் யோசனைகள் இதில் உள்ளன. கூடுதலாக, reCaptcha காசோலைகளைத் தவிர்ப்பதில் மிகவும் சுவாரஸ்யமான அத்தியாயம் உள்ளது. இது போன்ற சிக்கல்களைத் தீர்ப்பதற்கான சிறப்புக் கருவிகள் மற்றும் முழு சேவைகளும் கூட இருப்பதாக எனக்குத் தெரியாததால், இது எனக்குச் செய்தியாக வந்தது.

நீங்கள் பயணம் செய்ய விரும்புகிறீர்களா?!

இந்தப் பிரிவின் தலைப்பில் கேட்கப்பட்ட எளிய மற்றும் பாதிப்பில்லாத கேள்விக்கு, யாரிடம் கேட்கப்பட்டதோ அந்த நபரின் பயணங்களிலிருந்து ஓரிரு கதைகளுடன் சேர்ந்து நேர்மறையான பதிலை நீங்கள் அடிக்கடி கேட்கலாம். புதிய கலாச்சார சூழல்களில் உங்களை மூழ்கடிப்பதற்கும் உங்கள் எல்லைகளை விரிவுபடுத்துவதற்கும் பயணம் ஒரு சிறந்த வழியாகும் என்பதை நம்மில் பெரும்பாலோர் ஒப்புக்கொள்கிறோம். இருப்பினும், விமான டிக்கெட்டுகளைத் தேடுவது உங்களுக்கு பிடிக்குமா என்று நீங்கள் ஒருவரிடம் கேட்டால், பதில் அவ்வளவு சாதகமாக இருக்காது என்று நான் நம்புகிறேன். உண்மையில், பைதான் இங்கே எங்கள் உதவிக்கு வருகிறது.

விமான டிக்கெட்டுகளில் தகவல்களைத் தேடுவதற்கான அமைப்பை உருவாக்குவதற்கான வழியில் நாம் தீர்க்க வேண்டிய முதல் பணி, பொருத்தமான தளத்தைத் தேர்ந்தெடுப்பது, அதில் இருந்து நாங்கள் தகவல்களைப் பெறுவோம். இந்த சிக்கலைத் தீர்ப்பது எனக்கு எளிதானது அல்ல, ஆனால் இறுதியில் நான் கயாக் சேவையைத் தேர்ந்தெடுத்தேன். நான் Momondo, Skyscanner, Expedia மற்றும் சிலவற்றின் சேவைகளை முயற்சித்தேன், ஆனால் இந்த ஆதாரங்களில் ரோபோ பாதுகாப்பு வழிமுறைகள் ஊடுருவ முடியாதவை. பல முயற்சிகளுக்குப் பிறகு, நான் போக்குவரத்து விளக்குகள், பாதசாரிகள் மற்றும் சைக்கிள்களை சமாளிக்க வேண்டியிருந்தது, நான் ஒரு மனிதன் என்று அமைப்புகளை நம்ப வைக்க முயன்றேன், பல பக்கங்கள் ஏற்றப்பட்டாலும், கயாக் எனக்கு மிகவும் பொருத்தமானது என்று முடிவு செய்தேன். சிறிது நேரத்தில், காசோலைகளும் தொடங்கும். நான் 4 முதல் 6 மணிநேர இடைவெளியில் தளத்திற்கு கோரிக்கைகளை அனுப்பும்படி செய்தேன், எல்லாம் நன்றாக வேலை செய்தது. அவ்வப்போது, ​​கயாக்குடன் பணிபுரியும் போது சிரமங்கள் எழுகின்றன, ஆனால் அவர்கள் காசோலைகளால் உங்களைத் தொந்தரவு செய்யத் தொடங்கினால், நீங்கள் அவற்றை கைமுறையாகச் சமாளித்து, பின்னர் போட்டைத் தொடங்க வேண்டும், அல்லது சில மணிநேரம் காத்திருக்க வேண்டும், காசோலைகள் நிறுத்தப்படும். தேவைப்பட்டால், குறியீட்டை மற்றொரு தளத்திற்கு எளிதாக மாற்றியமைக்கலாம், அவ்வாறு செய்தால், கருத்துகளில் அதைப் புகாரளிக்கலாம்.

நீங்கள் வெப் ஸ்கிராப்பிங்கைத் தொடங்கினால், சில இணையதளங்கள் ஏன் போராடுகின்றன என்று தெரியாவிட்டால், இந்தப் பகுதியில் உங்கள் முதல் திட்டத்தைத் தொடங்குவதற்கு முன், நீங்களே ஒரு உதவி செய்து, "வெப் ஸ்கிராப்பிங் ஆசாரம்" என்ற வார்த்தைகளில் கூகுளில் தேடவும். . நீங்கள் புத்திசாலித்தனமாக வலை ஸ்கிராப்பிங் செய்தால், உங்கள் சோதனைகள் நீங்கள் நினைப்பதை விட விரைவில் முடிவடையும்.

தொடங்குதல்

எங்கள் வலை ஸ்கிராப்பர் குறியீட்டில் என்ன நடக்கும் என்பதற்கான பொதுவான கண்ணோட்டம் இங்கே:

• தேவையான நூலகங்களை இறக்குமதி செய்யவும்.
• Google Chrome தாவலைத் திறக்கிறது.
• போட்டைத் தொடங்கும் செயல்பாட்டை அழைக்கவும், டிக்கெட்டுகளைத் தேடும்போது பயன்படுத்தப்படும் நகரங்கள் மற்றும் தேதிகளைக் கடந்து செல்லவும்.
• இந்தச் செயல்பாடு முதல் தேடல் முடிவுகளை எடுத்து, சிறந்த முறையில் வரிசைப்படுத்தி, மேலும் முடிவுகளை ஏற்றுவதற்கு ஒரு பொத்தானைக் கிளிக் செய்கிறது.
• மற்றொரு செயல்பாடு முழுப் பக்கத்திலிருந்தும் தரவைச் சேகரித்து தரவுச் சட்டத்தை வழங்குகிறது.
• முந்தைய இரண்டு படிகள் டிக்கெட் விலை (மலிவான) மற்றும் விமான வேகம் (வேகமான) மூலம் வரிசைப்படுத்தும் வகைகளைப் பயன்படுத்தி செய்யப்படுகின்றன.
• ஸ்கிரிப்ட்டின் பயனருக்கு டிக்கெட் விலைகளின் சுருக்கம் (மலிவான டிக்கெட்டுகள் மற்றும் சராசரி விலை) அடங்கிய மின்னஞ்சல் அனுப்பப்படும், மேலும் மேலே குறிப்பிட்டுள்ள மூன்று குறிகாட்டிகளால் வரிசைப்படுத்தப்பட்ட தகவலுடன் கூடிய தரவு சட்டகம் எக்செல் கோப்பாக சேமிக்கப்படும்.
• மேலே உள்ள அனைத்து செயல்களும் ஒரு குறிப்பிட்ட காலத்திற்குப் பிறகு ஒரு சுழற்சியில் செய்யப்படுகின்றன.

ஒவ்வொரு செலினியம் திட்டமும் ஒரு வலை இயக்கியுடன் தொடங்குகிறது என்பதை கவனத்தில் கொள்ள வேண்டும். நான் பயன்படுத்துகின்ற குரோம் டிரைவர், நான் 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 புதிய தேடல் செயல்பாட்டைத் தொடங்குவதற்கு முன், சீரற்ற எண்ணிக்கையிலான வினாடிகளுக்கு போட் "தூங்க" செய்யப் பயன்படுகிறது. பொதுவாக, இது இல்லாமல் ஒரு போட் கூட செய்ய முடியாது. மேலே உள்ள குறியீட்டை நீங்கள் இயக்கினால், ஒரு Chrome சாளரம் திறக்கும், இது தளங்களுடன் பணிபுரிய போட் பயன்படுத்தும்.

ஒரு சிறிய பரிசோதனை செய்து kayak.com இணையதளத்தை தனி சாளரத்தில் திறக்கலாம். நாங்கள் எந்த நகரத்திலிருந்து பறக்கப் போகிறோம், நாங்கள் செல்ல விரும்பும் நகரம் மற்றும் விமானத் தேதிகளைத் தேர்ந்தெடுப்போம். தேதிகளைத் தேர்ந்தெடுக்கும்போது, ​​+-3 நாட்களின் வரம்பு பயன்படுத்தப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். அத்தகைய கோரிக்கைகளுக்கு பதிலளிக்கும் வகையில் தளம் என்ன உற்பத்தி செய்கிறது என்பதை கணக்கில் எடுத்துக்கொண்டு குறியீட்டை எழுதினேன். எடுத்துக்காட்டாக, நீங்கள் குறிப்பிட்ட தேதிகளுக்கு மட்டுமே டிக்கெட்டுகளைத் தேட வேண்டும் என்றால், நீங்கள் போட் குறியீட்டை மாற்ற வேண்டிய அதிக நிகழ்தகவு உள்ளது. நான் குறியீட்டைப் பற்றி பேசும்போது, ​​நான் பொருத்தமான விளக்கங்களை வழங்குகிறேன், ஆனால் நீங்கள் குழப்பமாக உணர்ந்தால், எனக்கு தெரியப்படுத்துங்கள்.

இப்போது தேடல் பொத்தானைக் கிளிக் செய்து முகவரிப் பட்டியில் உள்ள இணைப்பைப் பார்க்கவும். கீழே உள்ள எடுத்துக்காட்டில் மாறி அறிவிக்கப்படும் இணைப்பைப் போலவே இது இருக்க வேண்டும் kayak, இது URL ஐ சேமிக்கிறது மற்றும் முறை பயன்படுத்தப்படுகிறது get வலை இயக்கி. தேடல் பொத்தானைக் கிளிக் செய்த பிறகு, முடிவுகள் பக்கத்தில் தோன்றும்.

நான் கட்டளையைப் பயன்படுத்தியபோது get சில நிமிடங்களுக்குள் இரண்டு அல்லது மூன்று முறைக்கு மேல், reCaptcha ஐப் பயன்படுத்தி சரிபார்ப்பை முடிக்கும்படி என்னிடம் கேட்கப்பட்டது. இந்தக் காசோலையை நீங்கள் கைமுறையாக அனுப்பலாம் மற்றும் புதிய காசோலையை இயக்க கணினி முடிவு செய்யும் வரை பரிசோதனையைத் தொடரலாம். நான் ஸ்கிரிப்டைச் சோதித்தபோது, ​​முதல் தேடல் அமர்வு எப்போதுமே சீராகச் சென்றது போல் தோன்றியது, எனவே நீங்கள் குறியீட்டைப் பரிசோதனை செய்ய விரும்பினால், தேடல் அமர்வுகளுக்கு இடையே நீண்ட இடைவெளிகளைப் பயன்படுத்தி, குறியீட்டை அவ்வப்போது கைமுறையாக சரிபார்த்து, குறியீட்டை இயக்க அனுமதிக்க வேண்டும். மேலும், நீங்கள் இதைப் பற்றி சிந்தித்தால், தேடல் நடவடிக்கைகளுக்கு இடையில் 10 நிமிட இடைவெளியில் பெறப்பட்ட டிக்கெட் விலைகள் பற்றிய தகவல் ஒரு நபருக்குத் தேவைப்படாது.

XPath ஐப் பயன்படுத்தி ஒரு பக்கத்துடன் பணிபுரிதல்

எனவே, நாங்கள் ஒரு சாளரத்தைத் திறந்து தளத்தை ஏற்றினோம். விலை மற்றும் பிற தகவல்களைப் பெற, நாங்கள் XPath தொழில்நுட்பம் அல்லது CSS தேர்விகளைப் பயன்படுத்த வேண்டும். நான் XPath உடன் இணைந்திருக்க முடிவு செய்தேன், மேலும் CSS தேர்வாளர்களைப் பயன்படுத்த வேண்டிய அவசியத்தை உணரவில்லை, ஆனால் அந்த வழியில் செயல்படுவது மிகவும் சாத்தியம். XPath ஐப் பயன்படுத்தி ஒரு பக்கத்தைச் சுற்றிச் செல்வது தந்திரமானதாக இருக்கலாம், நான் விவரித்த நுட்பங்களைப் பயன்படுத்தினாலும் கூட இந்த கட்டுரை, பக்கக் குறியீட்டிலிருந்து தொடர்புடைய அடையாளங்காட்டிகளை நகலெடுப்பதை உள்ளடக்கியது, இது உண்மையில் தேவையான கூறுகளை அணுகுவதற்கான உகந்த வழி அல்ல என்பதை நான் உணர்ந்தேன். மூலம், உள்ளே இந்த XPath மற்றும் CSS தேர்வாளர்களைப் பயன்படுத்தி பக்கங்களுடன் பணிபுரியும் அடிப்படைகள் பற்றிய சிறந்த விளக்கத்தை புத்தகம் வழங்குகிறது. தொடர்புடைய வலை இயக்கி முறை இப்படித்தான் இருக்கும்.

எனவே, போட் மீது தொடர்ந்து பணியாற்றுவோம். மலிவான டிக்கெட்டுகளைத் தேர்ந்தெடுக்க நிரலின் திறன்களைப் பயன்படுத்துவோம். பின்வரும் படத்தில், XPath தேர்வி குறியீடு சிவப்பு நிறத்தில் முன்னிலைப்படுத்தப்பட்டுள்ளது. குறியீட்டைப் பார்க்க, நீங்கள் ஆர்வமுள்ள பக்க உறுப்பு மீது வலது கிளிக் செய்து, தோன்றும் மெனுவிலிருந்து ஆய்வு கட்டளையைத் தேர்ந்தெடுக்க வேண்டும். இந்த கட்டளையை வெவ்வேறு பக்க உறுப்புகளுக்கு அழைக்கலாம், அதன் குறியீடு குறியீடு பார்வையாளரில் காட்டப்படும் மற்றும் முன்னிலைப்படுத்தப்படும்.

பக்கக் குறியீட்டைப் பார்க்கவும்

குறியீட்டிலிருந்து தேர்வாளர்களை நகலெடுப்பதன் தீமைகள் பற்றிய எனது நியாயத்தை உறுதிப்படுத்த, பின்வரும் அம்சங்களுக்கு கவனம் செலுத்துங்கள்.

குறியீட்டை நகலெடுக்கும்போது நீங்கள் பெறுவது இதுதான்:

//*[@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).

முதல் மூன்று வரிகள் காட்டப்பட்டு நமக்குத் தேவையான அனைத்தையும் தெளிவாகக் காணலாம். இருப்பினும், தகவல்களைப் பெறுவதற்கு இன்னும் சுவாரஸ்யமான வழிகள் உள்ளன. ஒவ்வொரு உறுப்புகளிலிருந்தும் தனித்தனியாக தரவுகளை எடுக்க வேண்டும்.

செயலில் இறங்கு!

ஒரு செயல்பாட்டை எழுதுவதற்கான எளிதான வழி, கூடுதல் முடிவுகளை ஏற்றுவதாகும், எனவே நாங்கள் தொடங்குவோம். ஆய்வுக்கு வழிவகுக்கும் சேவையில் சந்தேகங்களை எழுப்பாமல், நிரல் தகவல்களைப் பெறும் விமானங்களின் எண்ணிக்கையை அதிகரிக்க விரும்புகிறேன், எனவே ஒவ்வொரு முறையும் பக்கம் காட்டப்படும்போது மேலும் முடிவுகளை ஏற்று பொத்தானைக் கிளிக் செய்கிறேன். இந்த குறியீட்டில், நீங்கள் தொகுதிக்கு கவனம் செலுத்த வேண்டும் 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.....')

அவுட்லுக் கணக்கை (hotmail.com) பயன்படுத்தி இந்த ஸ்கிரிப்டை சோதித்தேன். ஜிமெயில் கணக்குடன் சரியாக வேலை செய்ய நான் இதை சோதிக்கவில்லை, இந்த மின்னஞ்சல் அமைப்பு மிகவும் பிரபலமானது, ஆனால் பல சாத்தியமான விருப்பங்கள் உள்ளன. நீங்கள் ஹாட்மெயில் கணக்கைப் பயன்படுத்தினால், அனைத்தும் வேலை செய்ய, உங்கள் தரவை குறியீட்டில் உள்ளிட வேண்டும்.

இந்தச் செயல்பாட்டிற்கான குறியீட்டின் குறிப்பிட்ட பிரிவுகளில் சரியாக என்ன செய்யப்படுகிறது என்பதை நீங்கள் புரிந்து கொள்ள விரும்பினால், அவற்றை நகலெடுத்து அவற்றுடன் பரிசோதனை செய்யலாம். குறியீட்டைக் கொண்டு பரிசோதனை செய்வதே அதை உண்மையாகப் புரிந்துகொள்ள ஒரே வழி.

தயார் அமைப்பு

இப்போது நாம் பேசிய அனைத்தையும் செய்துவிட்டோம், எங்கள் செயல்பாடுகளை அழைக்கும் ஒரு எளிய வளையத்தை உருவாக்கலாம். ஸ்கிரிப்ட் நகரங்கள் மற்றும் தேதிகள் பற்றிய தரவை பயனரிடமிருந்து கோருகிறது. ஸ்கிரிப்டை தொடர்ந்து மறுதொடக்கம் செய்து சோதனை செய்யும் போது, ​​ஒவ்வொரு முறையும் இந்தத் தரவை கைமுறையாக உள்ளிட நீங்கள் விரும்ப மாட்டீர்கள், எனவே சோதனை நேரத்திற்கான தொடர்புடைய வரிகளை, கீழே உள்ளவற்றைக் கருத்துத் தெரிவிப்பதன் மூலம் கருத்துத் தெரிவிக்கலாம், அதில் தேவையான தரவு ஸ்கிரிப்ட் கடின குறியீடு.

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.....')

ஸ்கிரிப்ட்டின் சோதனை ஓட்டம் இப்படித்தான் இருக்கும்.

ஸ்கிரிப்ட்டின் சோதனை ஓட்டம்

முடிவுகளை

நீங்கள் இவ்வளவு தூரம் முன்னேறியிருந்தால், வாழ்த்துக்கள்! உங்களிடம் இப்போது வேலை செய்யும் வலை ஸ்கிராப்பர் உள்ளது, இருப்பினும் அதை மேம்படுத்த பல வழிகளை நான் ஏற்கனவே பார்க்கிறேன். எடுத்துக்காட்டாக, இது ட்விலியோவுடன் ஒருங்கிணைக்கப்படலாம், இதனால் அது மின்னஞ்சல்களுக்குப் பதிலாக உரைச் செய்திகளை அனுப்புகிறது. பல சேவையகங்களிலிருந்து முடிவுகளை ஒரே நேரத்தில் பெற நீங்கள் VPN அல்லது வேறு ஏதாவது ஒன்றைப் பயன்படுத்தலாம். தளப் பயனாளர் ஒரு நபரா என்பதைச் சரிபார்ப்பதில் அவ்வப்போது எழும் சிக்கல் உள்ளது, ஆனால் இந்த சிக்கலையும் தீர்க்க முடியும். எப்படியிருந்தாலும், இப்போது உங்களிடம் ஒரு தளம் உள்ளது, அதை நீங்கள் விரும்பினால் விரிவாக்கலாம். எடுத்துக்காட்டாக, ஒரு மின்னஞ்சலுக்கான இணைப்பாக எக்செல் கோப்பு பயனருக்கு அனுப்பப்படுவதை உறுதிசெய்யவும்.

பதிவு செய்த பயனர்கள் மட்டுமே கணக்கெடுப்பில் பங்கேற்க முடியும். உள்நுழையவும், தயவு செய்து.

நீங்கள் வலை ஸ்கிராப்பிங் தொழில்நுட்பங்களைப் பயன்படுத்துகிறீர்களா?

• ஆம்

• இல்லை

8 பயனர்கள் வாக்களித்தனர். 1 பயனர் வாக்களிக்கவில்லை.

ஆதாரம்: www.habr.com