პითონი - ასისტენტი იაფფასიანი ავიაბილეთების პოვნაში მათთვის, ვისაც მოგზაურობა უყვარს

სტატიის ავტორი, რომლის თარგმანსაც დღეს ვაქვეყნებთ, ამბობს, რომ მისი მიზანია ვისაუბროთ ვებ სკრეპერის განვითარებაზე Python-ში Selenium-ის გამოყენებით, რომელიც ეძებს ავიაბილეთის ფასებს. ბილეთების ძებნისას გამოიყენება მოქნილი თარიღები (+- 3 დღე მითითებულ თარიღებთან შედარებით). Scraper ინახავს ძიების შედეგებს Excel ფაილში და აგზავნის იმ პირს, ვინც ძიების პროცესში ჩაატარა, ელფოსტას მის მიერ ნაპოვნი შეჯამებით. ამ პროექტის მიზანია დაეხმაროს მოგზაურებს საუკეთესო გარიგებების პოვნაში.

თუ მასალის გაგებისას თავს დაკარგულად გრძნობთ, შეხედეთ ეს სტატია.

რას ვეძებთ?

თქვენ თავისუფლად შეგიძლიათ გამოიყენოთ აქ აღწერილი სისტემა, როგორც გსურთ. მაგალითად, გამოვიყენე შაბათ-კვირის ტურებისა და მშობლიურ ქალაქში ბილეთების მოსაძებნად. თუ სერიოზულად ფიქრობთ მომგებიანი ბილეთების პოვნაში, შეგიძლიათ სკრიპტის გაშვება სერვერზე (მარტივი სერვერზე, თვეში 130 რუბლისთვის, საკმაოდ შესაფერისია ამისთვის) და დარწმუნდით, რომ ის დღეში ერთხელ ან ორჯერ მუშაობს. ძიების შედეგები გამოგიგზავნეთ ელექტრონული ფოსტით. გარდა ამისა, გირჩევთ დააყენოთ ყველაფერი ისე, რომ სკრიპტმა შეინახოს Excel ფაილი ძიების შედეგებით Dropbox საქაღალდეში, რაც საშუალებას მოგცემთ ნახოთ ასეთი ფაილები ნებისმიერი ადგილიდან და ნებისმიერ დროს.

შეცდომით ტარიფები ჯერ ვერ ვიპოვე, მაგრამ ვფიქრობ, რომ შესაძლებელია

ძიებისას, როგორც უკვე აღვნიშნეთ, გამოიყენება „მოქნილი თარიღი“; სკრიპტი პოულობს შეთავაზებებს, რომლებიც მოცემულია მოცემული თარიღებიდან სამი დღის განმავლობაში. მიუხედავად იმისა, რომ სკრიპტის გაშვებისას ის ეძებს შეთავაზებებს მხოლოდ ერთი მიმართულებით, ადვილია მისი შეცვლა ისე, რომ მას შეუძლია შეაგროვოს მონაცემები ფრენის რამდენიმე მიმართულებაზე. მისი დახმარებით თქვენ შეგიძლიათ მოძებნოთ არასწორი ტარიფებიც კი, ასეთი აღმოჩენები შეიძლება ძალიან საინტერესო იყოს.

რატომ გჭირდებათ სხვა ვებ სკრაპერი?

როდესაც პირველად დავიწყე ვებ სკრაპინგი, გულწრფელად რომ ვთქვათ, ეს განსაკუთრებით არ მაინტერესებდა. მინდოდა მეტი პროექტი გამეკეთებინა პროგნოზირებადი მოდელირების, ფინანსური ანალიზის და, შესაძლოა, ტექსტების ემოციური შეფერილობის ანალიზის სფეროში. მაგრამ აღმოჩნდა, რომ ძალიან საინტერესო იყო იმის გარკვევა, თუ როგორ უნდა შექმნათ პროგრამა, რომელიც აგროვებს მონაცემებს ვებსაიტებიდან. ამ თემას რომ ჩავუღრმავდი, მივხვდი, რომ ვებ სკრაპი არის ინტერნეტის „ძრავა“.

შეიძლება ფიქრობთ, რომ ეს ძალიან თამამი განცხადებაა. მაგრამ ჩათვალეთ, რომ Google-მა დაიწყო ვებ სკრეპერით, რომელიც ლარი პეიჯმა შექმნა ჯავის და პითონის გამოყენებით. Google-ის რობოტები იკვლევდნენ ინტერნეტს და ცდილობდნენ მის მომხმარებლებს საუკეთესო პასუხები მისცენ მათ კითხვებზე. ვებ სკრაპს აქვს გაუთავებელი გამოყენება და მაშინაც კი, თუ თქვენ დაინტერესებული ხართ სხვა რამით მონაცემთა მეცნიერებაში, დაგჭირდებათ სკრაპინგის გარკვეული უნარები, რათა მიიღოთ ინფორმაცია, რომლის ანალიზიც გჭირდებათ.

მე ვიპოვე რამდენიმე ტექნიკა, რომელიც აქ გამოიყენება მშვენიერში წიგნი ვებ სკრაპინგის შესახებ, რომელიც ახლახან შევიძინე. ის შეიცავს უამრავ მარტივ მაგალითს და იდეას თქვენი ნასწავლის პრაქტიკული გამოყენებისთვის. გარდა ამისა, არის ძალიან საინტერესო თავი reCaptcha ჩეკების გვერდის ავლით. ეს ჩემთვის სიახლე იყო, რადგან არც კი ვიცოდი, რომ არსებობდა სპეციალური ხელსაწყოები და მთელი სერვისებიც კი ასეთი პრობლემების გადასაჭრელად.

Გიყვარს მოგზაურობა?!

ამ განყოფილების სათაურში დასმულ მარტივ და საკმაოდ უვნებელ კითხვაზე, ხშირად შეგიძლიათ მოისმინოთ დადებითი პასუხი, რომელსაც თან ახლავს რამდენიმე ამბავი იმ ადამიანის მოგზაურობიდან, ვისაც ეს დაუსვეს. ბევრი ჩვენგანი დამეთანხმება, რომ მოგზაურობა შესანიშნავი გზაა ახალ კულტურულ გარემოში ჩაძირვისა და თქვენი ჰორიზონტის გაფართოებისთვის. თუმცა, თუ ვინმეს ჰკითხავთ, უყვარს თუ არა ავიაბილეთების ძებნა, დარწმუნებული ვარ, პასუხი არც ისე დადებითი იქნება. ფაქტობრივად, პითონი აქ გვეხმარება.

პირველი ამოცანა, რომელიც უნდა გადავწყვიტოთ ავიაბილეთებზე ინფორმაციის მოძიების სისტემის შექმნის გზაზე, იქნება შესაფერისი პლატფორმის შერჩევა, საიდანაც ავიღებთ ინფორმაციას. ამ პრობლემის მოგვარება ჩემთვის ადვილი არ იყო, მაგრამ საბოლოოდ კაიაკის სერვისი ავირჩიე. მე ვცადე Momondo-ს, Skyscanner-ის, Expedia-ს და რამდენიმე სხვა სერვისი, მაგრამ ამ რესურსებზე რობოტების დაცვის მექანიზმები შეუღწევადი იყო. რამდენიმე მცდელობის შემდეგ, რომლის დროსაც მომიწია გამკლავება შუქნიშანთან, ფეხით მოსიარულეთა გადასასვლელთან და ველოსიპედებთან, ვცდილობდი დამერწმუნებინა სისტემები, რომ ადამიანი ვიყავი, გადავწყვიტე, რომ კაიაკი ყველაზე შესაფერისი იყო ჩემთვის, მიუხედავად იმისა, რომ თუნდაც ძალიან ბევრი გვერდი იყოს დატვირთული. მოკლე დროში და დაიწყება შემოწმებებიც. მე მოვახერხე, რომ ბოტი გამოეგზავნა მოთხოვნები საიტზე 4-დან 6 საათამდე ინტერვალით და ყველაფერი კარგად მუშაობდა. დროდადრო, სირთულეები წარმოიქმნება Kayak-თან მუშაობისას, მაგრამ თუ ისინი დაიწყებენ თქვენს შეწუხებას ჩეკებით, მაშინ თქვენ ან ხელით უნდა გაუმკლავდეთ მათ და შემდეგ გაუშვათ ბოტი, ან დაელოდოთ რამდენიმე საათს და შემოწმებები უნდა შეწყდეს. საჭიროების შემთხვევაში, თქვენ შეგიძლიათ მარტივად მოარგოთ კოდი სხვა პლატფორმისთვის და თუ ამას გააკეთებთ, შეგიძლიათ შეატყობინოთ კომენტარებში.

თუ თქვენ ახლა იწყებთ ვებ სკრაპინგით და არ იცით რატომ ებრძვის ზოგიერთ ვებსაიტს ეს, მაშინ სანამ დაიწყებთ თქვენს პირველ პროექტს ამ სფეროში, გააკეთეთ საკუთარი თავის სიკეთე და მოიძიეთ Google-ში სიტყვები „ვებ სკრაპინგის ეტიკეტი“ . თქვენი ექსპერიმენტები შეიძლება დასრულდეს იმაზე ადრე, ვიდრე ფიქრობთ, თუ უგუნურად გააკეთებთ ვებ სკრაპს.

ნაცნობობა

აქ არის ზოგადი მიმოხილვა იმის შესახებ, თუ რა მოხდება ჩვენს ვებ სკრაპერ კოდში:

• საჭირო ბიბლიოთეკების იმპორტი.
• Google Chrome ჩანართის გახსნა.
• გამოიძახეთ ფუნქცია, რომელიც იწყებს ბოტს, გადასცემს მას ქალაქებსა და თარიღებს, რომლებიც გამოყენებული იქნება ბილეთების ძებნისას.
• ეს ფუნქცია იღებს ძიების პირველ შედეგებს, დალაგებულია საუკეთესოს მიხედვით და აჭერს ღილაკს მეტი შედეგის ჩასატვირთად.
• სხვა ფუნქცია აგროვებს მონაცემებს მთელი გვერდიდან და აბრუნებს მონაცემთა ჩარჩოს.
• წინა ორი ნაბიჯი შესრულებულია ბილეთის ფასის (იაფი) და ფრენის სიჩქარის მიხედვით (ყველაზე სწრაფი) ტიპების დახარისხების გამოყენებით.
• სკრიპტის მომხმარებელს ეგზავნება ელ.წერილი, რომელიც შეიცავს ბილეთების ფასების შეჯამებას (ყველაზე იაფი ბილეთები და საშუალო ფასი) და მონაცემთა ჩარჩო სამი ზემოაღნიშნული ინდიკატორის მიხედვით დალაგებული ინფორმაციით ინახება Excel ფაილის სახით.
• ყველა ზემოაღნიშნული ქმედება ხორციელდება ციკლში განსაზღვრული დროის შემდეგ.

უნდა აღინიშნოს, რომ სელენის ყველა პროექტი იწყება ვებ დრაივერით. მე ვიყენებ Chromedriver, მე ვმუშაობ 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 ამორჩევის კოდი მონიშნულია წითლად. კოდის სანახავად, თქვენ უნდა დააწკაპუნოთ მაუსის მარჯვენა ღილაკით თქვენთვის საინტერესო გვერდის ელემენტზე და აირჩიეთ ბრძანება Inspect მენიუდან, რომელიც გამოჩნდება. ამ ბრძანების გამოძახება შესაძლებელია გვერდის სხვადასხვა ელემენტებისთვის, რომელთა კოდი გამოჩნდება და მონიშნული იქნება კოდის მაყურებელში.

გვერდის კოდის ნახვა

იმისათვის, რომ იპოვოთ ჩემი მსჯელობის დადასტურება კოდიდან სელექტორების კოპირების უარყოფითი მხარეების შესახებ, ყურადღება მიაქციეთ შემდეგ მახასიათებლებს.

აი რას მიიღებთ კოდის კოპირებისას:

//*[@id="wtKI-price_aTab"]/div[1]/div/div/div[1]/div/span/span

იმისათვის, რომ დააკოპიროთ მსგავსი რამ, თქვენ უნდა დააწკაპუნოთ მაუსის მარჯვენა ღილაკით კოდის განყოფილებაზე, რომელიც გაინტერესებთ და მენიუდან აირჩიეთ ბრძანება Copy > Copy 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.....')

მე გამოვცადე ეს სკრიპტი 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.....')

ასე გამოიყურება სკრიპტის სატესტო გაშვება.

სკრიპტის სატესტო გაშვება

შედეგები

თუ აქამდე მიაღწიეთ, გილოცავთ! ახლა თქვენ გაქვთ სამუშაო ვებ სკრაპერი, თუმცა მე უკვე ვხედავ მისი გაუმჯობესების ბევრ გზას. მაგალითად, ის შეიძლება იყოს ინტეგრირებული Twilio-სთან ისე, რომ ელფოსტის ნაცვლად აგზავნის ტექსტურ შეტყობინებებს. შეგიძლიათ გამოიყენოთ VPN ან სხვა რამ, რომ ერთდროულად მიიღოთ შედეგები რამდენიმე სერვერიდან. ასევე პერიოდულად ჩნდება პრობლემა საიტის მომხმარებლის შემოწმებასთან დაკავშირებით, არის თუ არა ის ადამიანი, მაგრამ ეს პრობლემაც შეიძლება მოგვარდეს. ნებისმიერ შემთხვევაში, ახლა თქვენ გაქვთ ბაზა, რომელიც შეგიძლიათ გააფართოვოთ თუ გსურთ. მაგალითად, დარწმუნდით, რომ Excel ფაილი ეგზავნება მომხმარებელს ელფოსტის დანართის სახით.

გამოკითხვაში მონაწილეობა შეუძლიათ მხოლოდ დარეგისტრირებულ მომხმარებლებს. Შებრძანდითგთხოვთ

იყენებთ ვებ სკრაპინგის ტექნოლოგიებს?

• დიახ

• არარის

მისცა ხმა 8 მომხმარებელმა. 1 მომხმარებელმა თავი შეიკავა.

წყარო: www.habr.com