પાયથોન - મુસાફરી કરવાનું પસંદ કરતા લોકો માટે સસ્તી એર ટિકિટ શોધવામાં સહાયક

લેખના લેખક, જેનો અનુવાદ અમે આજે પ્રકાશિત કરી રહ્યા છીએ, તે કહે છે કે તેનું લક્ષ્ય સેલેનિયમનો ઉપયોગ કરીને પાયથોનમાં વેબ સ્ક્રેપરના વિકાસ વિશે વાત કરવાનું છે, જે એરલાઇન ટિકિટના ભાવની શોધ કરે છે. ટિકિટની શોધ કરતી વખતે, લવચીક તારીખોનો ઉપયોગ કરવામાં આવે છે (+- ઉલ્લેખિત તારીખોની તુલનામાં 3 દિવસ). સ્ક્રેપર શોધ પરિણામોને એક્સેલ ફાઇલમાં સાચવે છે અને શોધ ચલાવનાર વ્યક્તિને તેઓ જે મળ્યું તેના સારાંશ સાથે ઈમેલ મોકલે છે. આ પ્રોજેક્ટનો ધ્યેય પ્રવાસીઓને શ્રેષ્ઠ ડીલ શોધવામાં મદદ કરવાનો છે.

જો, સામગ્રીને સમજતી વખતે, તમે ખોવાઈ ગયા છો, તો એક નજર નાખો આ લેખ

આપણે શું જોવા જઈ રહ્યા છીએ?

તમે તમારી ઈચ્છા મુજબ અહીં વર્ણવેલ સિસ્ટમનો ઉપયોગ કરવા માટે સ્વતંત્ર છો. ઉદાહરણ તરીકે, મેં તેનો ઉપયોગ મારા વતનના સપ્તાહના પ્રવાસો અને ટિકિટો શોધવા માટે કર્યો હતો. જો તમે નફાકારક ટિકિટો શોધવા માટે ગંભીર છો, તો તમે સર્વર પર સ્ક્રિપ્ટ ચલાવી શકો છો (સરળ સર્વર, એક મહિનામાં 130 રુબેલ્સ માટે, આ માટે એકદમ યોગ્ય છે) અને ખાતરી કરો કે તે દિવસમાં એક કે બે વાર ચાલે છે. શોધ પરિણામો તમને ઇમેઇલ દ્વારા મોકલવામાં આવશે. વધુમાં, હું બધું સેટ કરવાની ભલામણ કરું છું જેથી સ્ક્રિપ્ટ ડ્રૉપબૉક્સ ફોલ્ડરમાં શોધ પરિણામો સાથે એક્સેલ ફાઇલને સાચવે, જે તમને ગમે ત્યાંથી અને કોઈપણ સમયે આવી ફાઇલોને જોવાની મંજૂરી આપશે.

મને હજુ સુધી ભૂલો સાથેના ટેરિફ મળ્યા નથી, પરંતુ મને લાગે છે કે તે શક્ય છે

શોધ કરતી વખતે, પહેલેથી જ ઉલ્લેખ કર્યો છે તેમ, "લવચીક તારીખ" નો ઉપયોગ કરવામાં આવે છે; સ્ક્રિપ્ટ આપેલ તારીખોના ત્રણ દિવસની અંદરની ઑફર્સ શોધે છે. જો કે સ્ક્રિપ્ટ ચલાવતી વખતે, તે માત્ર એક જ દિશામાં ઑફર્સ શોધે છે, તેને સંશોધિત કરવું સરળ છે જેથી તે ઘણી ફ્લાઇટ દિશાઓ પર ડેટા એકત્રિત કરી શકે. તેની સહાયથી, તમે ભૂલભરેલા ટેરિફ પણ શોધી શકો છો; આવા શોધો ખૂબ જ રસપ્રદ હોઈ શકે છે.

તમારે બીજા વેબ સ્ક્રેપરની શા માટે જરૂર છે?

જ્યારે મેં પ્રથમ વેબ સ્ક્રેપિંગ શરૂ કર્યું, ત્યારે મને પ્રામાણિકપણે તેમાં ખાસ રસ નહોતો. હું અનુમાનિત મોડેલિંગ, નાણાકીય વિશ્લેષણ અને, સંભવતઃ, પાઠોના ભાવનાત્મક રંગના વિશ્લેષણના ક્ષેત્રમાં વધુ પ્રોજેક્ટ્સ કરવા માંગતો હતો. પરંતુ તે બહાર આવ્યું છે કે વેબસાઇટ્સમાંથી ડેટા એકત્રિત કરતા પ્રોગ્રામ કેવી રીતે બનાવવો તે શોધવાનું ખૂબ જ રસપ્રદ હતું. જેમ જેમ હું આ વિષયમાં ગયો તેમ, મને સમજાયું કે વેબ સ્ક્રેપિંગ એ ઇન્ટરનેટનું "એન્જિન" છે.

તમે વિચારી શકો છો કે આ ખૂબ બોલ્ડ નિવેદન છે. પરંતુ ધ્યાનમાં લો કે ગૂગલે વેબ સ્ક્રેપરથી શરૂઆત કરી હતી જે લેરી પેજે જાવા અને પાયથોનનો ઉપયોગ કરીને બનાવી હતી. ગૂગલ રોબોટ્સ ઈન્ટરનેટની શોધ કરી રહ્યા છે, તેના વપરાશકર્તાઓને તેમના પ્રશ્નોના શ્રેષ્ઠ જવાબો આપવાનો પ્રયાસ કરી રહ્યા છે. વેબ સ્ક્રેપિંગના અનંત ઉપયોગો છે, અને જો તમને ડેટા સાયન્સમાં કંઈક બીજું રસ હોય તો પણ, તમારે વિશ્લેષણ કરવા માટે જરૂરી ડેટા મેળવવા માટે તમારે કેટલીક સ્ક્રેપિંગ કુશળતાની જરૂર પડશે.

મને અહીં ઉપયોગમાં લેવાતી કેટલીક તકનીકો અદ્ભુત મળી પુસ્તક વેબ સ્ક્રેપિંગ વિશે, જે મેં તાજેતરમાં મેળવ્યું છે. તમે જે શીખ્યા છો તેના વ્યવહારિક ઉપયોગ માટે તેમાં ઘણા સરળ ઉદાહરણો અને વિચારો છે. વધુમાં, reCaptcha ચેકને બાયપાસ કરવા પર એક ખૂબ જ રસપ્રદ પ્રકરણ છે. આ મારા માટે સમાચાર તરીકે આવ્યું, કારણ કે મને એ પણ ખબર ન હતી કે આવી સમસ્યાઓના નિરાકરણ માટે વિશેષ સાધનો અને સંપૂર્ણ સેવાઓ પણ છે.

શું તમને મુસાફરી કરવી ગમે છે ?!

આ વિભાગના શીર્ષકમાં પૂછવામાં આવેલા સરળ અને તેના બદલે હાનિકારક પ્રશ્ન માટે, તમે ઘણીવાર સકારાત્મક જવાબ સાંભળી શકો છો, જેની સાથે તે વ્યક્તિની મુસાફરીની કેટલીક વાર્તાઓ સાથે, જેને તે પૂછવામાં આવ્યું હતું. આપણામાંથી મોટાભાગના લોકો સંમત થશે કે નવા સાંસ્કૃતિક વાતાવરણમાં તમારી જાતને લીન કરવા અને તમારી ક્ષિતિજોને વિસ્તૃત કરવા માટે મુસાફરી એ એક સરસ રીત છે. જો કે, જો તમે કોઈને પૂછો કે શું તેઓ એરલાઇન ટિકિટ શોધવાનું પસંદ કરે છે, તો મને ખાતરી છે કે જવાબ એટલો હકારાત્મક નહીં હોય. વાસ્તવમાં, પાયથોન અહીં અમારી મદદ માટે આવે છે.

એર ટિકિટો પર માહિતી શોધવા માટે સિસ્ટમ બનાવવાના માર્ગ પર આપણે જે પહેલું કાર્ય હલ કરવાની જરૂર છે તે યોગ્ય પ્લેટફોર્મ પસંદ કરવાનું છે જેમાંથી અમે માહિતી લઈશું. આ સમસ્યાનો ઉકેલ મારા માટે સરળ ન હતો, પરંતુ અંતે મેં કાયક સેવા પસંદ કરી. મેં મોમોન્ડો, સ્કાયસ્કેનર, એક્સપેડિયા અને અન્ય કેટલાકની સેવાઓ અજમાવી, પરંતુ આ સંસાધનો પર રોબોટ સંરક્ષણ મિકેનિઝમ્સ અભેદ્ય હતા. ઘણા પ્રયત્નો પછી, જે દરમિયાન મારે ટ્રાફિક લાઇટ, પગપાળા ક્રોસિંગ અને સાયકલનો સામનો કરવો પડ્યો હતો, સિસ્ટમને સમજાવવાનો પ્રયાસ કર્યો કે હું માનવ છું, મેં નક્કી કર્યું કે કાયક મારા માટે સૌથી યોગ્ય છે, તે હકીકત હોવા છતાં કે ઘણા બધા પૃષ્ઠો લોડ થયા હોવા છતાં. ટૂંક સમયમાં, અને તપાસ પણ શરૂ થાય છે. હું બોટને 4 થી 6 કલાકના અંતરાલમાં સાઇટ પર વિનંતીઓ મોકલવામાં વ્યવસ્થાપિત થયો, અને બધું બરાબર કામ કર્યું. સમયે સમયે, કાયક સાથે કામ કરતી વખતે મુશ્કેલીઓ ઊભી થાય છે, પરંતુ જો તેઓ તમને ચેકથી હેરાન કરવાનું શરૂ કરે, તો તમારે કાં તો તેમની સાથે મેન્યુઅલી ડીલ કરવાની અને પછી બોટને લોન્ચ કરવાની જરૂર છે, અથવા થોડા કલાકો રાહ જુઓ અને ચેક્સ બંધ થવા જોઈએ. જો જરૂરી હોય તો, તમે સરળતાથી બીજા પ્લેટફોર્મ માટે કોડને અનુકૂલિત કરી શકો છો, અને જો તમે આમ કરો છો, તો તમે ટિપ્પણીઓમાં તેની જાણ કરી શકો છો.

જો તમે હમણાં જ વેબ સ્ક્રેપિંગ સાથે પ્રારંભ કરી રહ્યાં છો અને તમને ખબર નથી કે કેટલીક વેબસાઇટ્સ તેની સાથે શા માટે સંઘર્ષ કરે છે, તો પછી તમે આ ક્ષેત્રમાં તમારો પહેલો પ્રોજેક્ટ શરૂ કરો તે પહેલાં, તમારી તરફેણ કરો અને "વેબ સ્ક્રેપિંગ શિષ્ટાચાર" શબ્દો પર Google શોધ કરો. . જો તમે અવિચારી રીતે વેબ સ્ક્રેપિંગ કરો છો, તો તમારા પ્રયોગો તમારા વિચારો કરતાં વહેલા સમાપ્ત થઈ શકે છે.

પ્રારંભ

અમારા વેબ સ્ક્રેપર કોડમાં શું થશે તેની સામાન્ય ઝાંખી અહીં છે:

• જરૂરી પુસ્તકાલયો આયાત કરો.
• ગૂગલ ક્રોમ ટેબ ખોલી રહ્યા છીએ.
• એક ફંક્શનને કૉલ કરો જે બૉટ શરૂ કરે છે, તેને શહેરો અને તારીખો પસાર કરે છે જેનો ઉપયોગ ટિકિટની શોધ કરતી વખતે કરવામાં આવશે.
• આ કાર્ય પ્રથમ શોધ પરિણામો લે છે, શ્રેષ્ઠ દ્વારા સૉર્ટ કરે છે, અને વધુ પરિણામો લોડ કરવા માટે એક બટનને ક્લિક કરે છે.
• અન્ય કાર્ય સમગ્ર પૃષ્ઠમાંથી ડેટા એકત્રિત કરે છે અને ડેટા ફ્રેમ પરત કરે છે.
• અગાઉના બે પગલાં ટિકિટની કિંમત (સસ્તી) અને ફ્લાઇટની ઝડપ (સૌથી ઝડપી) દ્વારા વર્ગીકરણ પ્રકારોનો ઉપયોગ કરીને કરવામાં આવે છે.
• સ્ક્રિપ્ટના વપરાશકર્તાને ટિકિટની કિંમતો (સસ્તી ટિકિટો અને સરેરાશ કિંમત)નો સારાંશ ધરાવતો ઈમેલ મોકલવામાં આવે છે અને ઉપરોક્ત ત્રણ સૂચકાંકો દ્વારા સૉર્ટ કરેલી માહિતી સાથેનો ડેટા ફ્રેમ એક્સેલ ફાઇલ તરીકે સાચવવામાં આવે છે.
• ઉપરોક્ત તમામ ક્રિયાઓ ચોક્કસ સમયગાળા પછી ચક્રમાં કરવામાં આવે છે.

એ નોંધવું જોઇએ કે દરેક સેલેનિયમ પ્રોજેક્ટ વેબ ડ્રાઇવરથી શરૂ થાય છે. હુ વાપરૂ છુ ક્રોમડ્રાઈવર, હું Google 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

તે તદ્દન સ્પષ્ટ છે કે બીજો વિકલ્પ વધુ સરળ લાગે છે. જ્યારે તેનો ઉપયોગ થાય છે, ત્યારે તે એવા તત્વની શોધ કરે છે કે જેમાં વિશેષતા હોય 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 એકાઉન્ટ સાથે યોગ્ય રીતે કામ કરવા માટે તેનું પરીક્ષણ કર્યું નથી, આ ઇમેઇલ સિસ્ટમ ખૂબ જ લોકપ્રિય છે, પરંતુ ઘણા સંભવિત વિકલ્પો છે. જો તમે હોટમેલ એકાઉન્ટનો ઉપયોગ કરો છો, તો પછી બધું કામ કરવા માટે, તમારે કોડમાં તમારો ડેટા દાખલ કરવાની જરૂર છે.

જો તમે આ કાર્ય માટે કોડના ચોક્કસ વિભાગોમાં બરાબર શું કરવામાં આવે છે તે સમજવા માંગતા હો, તો તમે તેમની નકલ કરી શકો છો અને તેમની સાથે પ્રયોગ કરી શકો છો. કોડ સાથે પ્રયોગ એ તેને સાચી રીતે સમજવાનો એકમાત્ર રસ્તો છે.

તૈયાર સિસ્ટમ

હવે જ્યારે અમે વાત કરી છે તે બધું કરી લીધું છે, અમે એક સરળ લૂપ બનાવી શકીએ છીએ જે અમારા કાર્યોને કૉલ કરે છે. સ્ક્રિપ્ટ વપરાશકર્તા પાસેથી શહેરો અને તારીખો વિશેના ડેટાની વિનંતી કરે છે. સ્ક્રિપ્ટના સતત પુનઃપ્રારંભ સાથે પરીક્ષણ કરતી વખતે, તમે દર વખતે આ ડેટાને મેન્યુઅલી દાખલ કરવા ઇચ્છતા હોવ તેવી શક્યતા નથી, તેથી પરીક્ષણના સમયગાળા માટે, અનુરૂપ રેખાઓ, તેમની નીચેની ટિપ્પણીઓને અનકમેન્ટ કરીને ટિપ્પણી કરી શકાય છે, જેમાં ડેટાને જરૂરી છે. સ્ક્રિપ્ટ હાર્ડકોડેડ છે.

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 અથવા અન્ય કોઈ વસ્તુનો ઉપયોગ કરી શકો છો. સાઈટ યુઝરને તપાસવામાં સમયાંતરે સમસ્યા ઊભી થાય છે કે તે વ્યક્તિ છે કે કેમ, પરંતુ આ સમસ્યા પણ ઉકેલી શકાય છે. કોઈ પણ સંજોગોમાં, હવે તમારી પાસે એક આધાર છે જેને તમે ઈચ્છો તો વિસ્તૃત કરી શકો છો. ઉદાહરણ તરીકે, ખાતરી કરો કે એક્સેલ ફાઇલ વપરાશકર્તાને ઇમેઇલના જોડાણ તરીકે મોકલવામાં આવે છે.

ફક્ત નોંધાયેલા વપરાશકર્તાઓ જ સર્વેમાં ભાગ લઈ શકે છે. સાઇન ઇન કરો, મહેરબાની કરીને.

શું તમે વેબ સ્ક્રેપિંગ તકનીકોનો ઉપયોગ કરો છો?

• હા

• કોઈ

8 વપરાશકર્તાઓએ મત ​​આપ્યો. 1 વપરાશકર્તા દૂર રહ્યો.

સોર્સ: www.habr.com