പൈത്തൺ - യാത്ര ചെയ്യാൻ ഇഷ്ടപ്പെടുന്നവർക്കായി വിലകുറഞ്ഞ വിമാന ടിക്കറ്റുകൾ കണ്ടെത്തുന്നതിനുള്ള ഒരു സഹായി

എയർലൈൻ ടിക്കറ്റ് നിരക്കുകൾക്കായി തിരയുന്ന സെലിനിയം ഉപയോഗിച്ച് പൈത്തണിൽ ഒരു വെബ് സ്‌ക്രാപ്പർ വികസിപ്പിക്കുന്നതിനെക്കുറിച്ച് സംസാരിക്കുക എന്നതാണ് അതിന്റെ ലക്ഷ്യമെന്ന് ലേഖനത്തിന്റെ രചയിതാവ്, അതിന്റെ വിവർത്തനം ഇന്ന് പ്രസിദ്ധീകരിക്കുന്നു. ടിക്കറ്റുകൾക്കായി തിരയുമ്പോൾ, ഫ്ലെക്സിബിൾ തീയതികൾ ഉപയോഗിക്കുന്നു (നിർദ്ദിഷ്ട തീയതികളുമായി ബന്ധപ്പെട്ട് +- 3 ദിവസം). സ്ക്രാപ്പർ തിരയൽ ഫലങ്ങൾ ഒരു Excel ഫയലിൽ സംരക്ഷിക്കുകയും തിരയൽ നടത്തിയ വ്യക്തിക്ക് അവർ കണ്ടെത്തിയതിന്റെ സംഗ്രഹം സഹിതം ഒരു ഇമെയിൽ അയയ്ക്കുകയും ചെയ്യുന്നു. മികച്ച ഡീലുകൾ കണ്ടെത്താൻ യാത്രക്കാരെ സഹായിക്കുക എന്നതാണ് ഈ പദ്ധതിയുടെ ലക്ഷ്യം.

മെറ്റീരിയൽ മനസ്സിലാക്കുമ്പോൾ, നിങ്ങൾക്ക് നഷ്ടപ്പെട്ടതായി തോന്നുന്നുവെങ്കിൽ, ഒന്ന് നോക്കുക ഇത് ലേഖനം.

നമ്മൾ എന്താണ് അന്വേഷിക്കാൻ പോകുന്നത്?

ഇവിടെ വിവരിച്ചിരിക്കുന്ന സിസ്റ്റം നിങ്ങളുടെ ഇഷ്ടാനുസരണം ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് സ്വാതന്ത്ര്യമുണ്ട്. ഉദാഹരണത്തിന്, വാരാന്ത്യ ടൂറുകൾക്കും എന്റെ ജന്മനാട്ടിലേക്കുള്ള ടിക്കറ്റുകൾക്കുമായി തിരയാൻ ഞാൻ ഇത് ഉപയോഗിച്ചു. ലാഭകരമായ ടിക്കറ്റുകൾ കണ്ടെത്തുന്നതിൽ നിങ്ങൾ ഗൗരവമുള്ള ആളാണെങ്കിൽ, നിങ്ങൾക്ക് സെർവറിൽ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാം (ലളിതമായ സെർവർ, പ്രതിമാസം 130 റൂബിളുകൾക്ക്, ഇതിന് തികച്ചും അനുയോജ്യമാണ്) കൂടാതെ ഇത് ദിവസത്തിൽ ഒന്നോ രണ്ടോ തവണ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. തിരയൽ ഫലങ്ങൾ നിങ്ങൾക്ക് ഇമെയിൽ വഴി അയയ്ക്കും. കൂടാതെ, എല്ലാം സജ്ജീകരിക്കാൻ ഞാൻ ശുപാർശചെയ്യുന്നു, അങ്ങനെ സ്ക്രിപ്റ്റ് തിരയൽ ഫലങ്ങളുള്ള ഒരു Excel ഫയൽ ഒരു ഡ്രോപ്പ്ബോക്സ് ഫോൾഡറിൽ സംരക്ഷിക്കുന്നു, ഇത് അത്തരം ഫയലുകൾ എവിടെനിന്നും എപ്പോൾ വേണമെങ്കിലും കാണാൻ നിങ്ങളെ അനുവദിക്കും.

പിശകുകളുള്ള താരിഫുകൾ ഞാൻ ഇതുവരെ കണ്ടെത്തിയിട്ടില്ല, പക്ഷേ അത് സാധ്യമാണെന്ന് ഞാൻ കരുതുന്നു

തിരയുമ്പോൾ, ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, ഒരു "ഫ്ലെക്സിബിൾ തീയതി" ഉപയോഗിക്കുന്നു; തന്നിരിക്കുന്ന തീയതികളിൽ മൂന്ന് ദിവസത്തിനുള്ളിൽ ഓഫറുകൾ സ്ക്രിപ്റ്റ് കണ്ടെത്തുന്നു. സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ഒരു ദിശയിൽ മാത്രമേ ഓഫറുകൾക്കായി തിരയുന്നുള്ളൂവെങ്കിലും, അത് പരിഷ്‌ക്കരിക്കുന്നത് എളുപ്പമാണ്, അതുവഴി നിരവധി ഫ്ലൈറ്റ് ദിശകളിൽ ഡാറ്റ ശേഖരിക്കാനാകും. അതിന്റെ സഹായത്തോടെ, നിങ്ങൾക്ക് തെറ്റായ താരിഫുകൾ പോലും നോക്കാം; അത്തരം കണ്ടെത്തലുകൾ വളരെ രസകരമായിരിക്കും.

നിങ്ങൾക്ക് മറ്റൊരു വെബ് സ്ക്രാപ്പർ ആവശ്യമായി വരുന്നത് എന്തുകൊണ്ട്?

ഞാൻ ആദ്യമായി വെബ് സ്‌ക്രാപ്പിംഗ് ആരംഭിച്ചപ്പോൾ, സത്യസന്ധമായി എനിക്ക് അതിൽ പ്രത്യേകിച്ച് താൽപ്പര്യമില്ലായിരുന്നു. പ്രവചനാത്മക മോഡലിംഗ്, സാമ്പത്തിക വിശകലനം, ഒരുപക്ഷേ, ടെക്സ്റ്റുകളുടെ വൈകാരിക കളറിംഗ് വിശകലനം ചെയ്യുന്ന മേഖലകളിൽ കൂടുതൽ പ്രോജക്ടുകൾ ചെയ്യാൻ ഞാൻ ആഗ്രഹിച്ചു. എന്നാൽ വെബ്‌സൈറ്റുകളിൽ നിന്ന് ഡാറ്റ ശേഖരിക്കുന്ന ഒരു പ്രോഗ്രാം എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് മനസിലാക്കുന്നത് വളരെ രസകരമാണെന്ന് ഇത് മാറി. ഞാൻ ഈ വിഷയത്തിലേക്ക് ആഴ്ന്നിറങ്ങിയപ്പോൾ, വെബ് സ്ക്രാപ്പിംഗ് ഇന്റർനെറ്റിന്റെ "എഞ്ചിൻ" ആണെന്ന് ഞാൻ മനസ്സിലാക്കി.

ഇത് വളരെ ധീരമായ ഒരു പ്രസ്താവനയാണെന്ന് നിങ്ങൾ ചിന്തിച്ചേക്കാം. എന്നാൽ ജാവയും പൈത്തണും ഉപയോഗിച്ച് ലാറി പേജ് സൃഷ്ടിച്ച ഒരു വെബ് സ്‌ക്രാപ്പർ ഉപയോഗിച്ചാണ് ഗൂഗിൾ ആരംഭിച്ചതെന്ന് പരിഗണിക്കുക. ഗൂഗിൾ റോബോട്ടുകൾ ഇന്റർനെറ്റ് പര്യവേക്ഷണം ചെയ്യുന്നു, അതിന്റെ ഉപയോക്താക്കൾക്ക് അവരുടെ ചോദ്യങ്ങൾക്ക് മികച്ച ഉത്തരങ്ങൾ നൽകാൻ ശ്രമിക്കുന്നു. വെബ് സ്ക്രാപ്പിംഗിന് അനന്തമായ ഉപയോഗങ്ങളുണ്ട്, കൂടാതെ നിങ്ങൾക്ക് ഡാറ്റാ സയൻസിൽ മറ്റെന്തെങ്കിലും താൽപ്പര്യമുണ്ടെങ്കിൽപ്പോലും, വിശകലനം ചെയ്യേണ്ട ഡാറ്റ ലഭിക്കുന്നതിന് നിങ്ങൾക്ക് ചില സ്ക്രാപ്പിംഗ് കഴിവുകൾ ആവശ്യമാണ്.

ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്ന ചില സാങ്കേതിക വിദ്യകൾ ഞാൻ അത്ഭുതകരമായി കണ്ടെത്തി പുസ്തകം ഞാൻ അടുത്തിടെ നേടിയ വെബ് സ്ക്രാപ്പിംഗിനെക്കുറിച്ച്. നിങ്ങൾ പഠിച്ച കാര്യങ്ങളുടെ പ്രായോഗിക പ്രയോഗത്തിനുള്ള നിരവധി ലളിതമായ ഉദാഹരണങ്ങളും ആശയങ്ങളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു. കൂടാതെ, reCaptcha ചെക്കുകൾ ബൈപാസ് ചെയ്യുന്നതിൽ വളരെ രസകരമായ ഒരു അധ്യായമുണ്ട്. ഇത്തരം പ്രശ്‌നങ്ങൾ പരിഹരിക്കുന്നതിന് പ്രത്യേക ഉപകരണങ്ങളും മുഴുവൻ സേവനങ്ങളും ഉണ്ടെന്ന് പോലും അറിയാത്തതിനാൽ ഇത് എനിക്ക് വാർത്തയായി.

നിങ്ങള്ക്ക് യാത്ര ഇഷ്ട്ടമാണോ?!

ഈ വിഭാഗത്തിന്റെ ശീർഷകത്തിൽ ഉന്നയിക്കപ്പെട്ട ലളിതവും നിരുപദ്രവകരവുമായ ചോദ്യത്തിന്, അത് ചോദിച്ച വ്യക്തിയുടെ യാത്രകളിൽ നിന്നുള്ള രണ്ട് കഥകൾക്കൊപ്പം ഒരു നല്ല ഉത്തരം നിങ്ങൾക്ക് പലപ്പോഴും കേൾക്കാനാകും. പുതിയ സാംസ്കാരിക പരിതസ്ഥിതികളിൽ മുഴുകാനും നിങ്ങളുടെ ചക്രവാളങ്ങൾ വിശാലമാക്കാനുമുള്ള മികച്ച മാർഗമാണ് യാത്രയെന്ന് നമ്മളിൽ ഭൂരിഭാഗവും സമ്മതിക്കും. എന്നിരുന്നാലും, എയർലൈൻ ടിക്കറ്റുകൾക്കായി തിരയുന്നത് ഇഷ്ടപ്പെടുന്നുണ്ടോ എന്ന് നിങ്ങൾ ആരോടെങ്കിലും ചോദിച്ചാൽ, ഉത്തരം അത്ര പോസിറ്റീവ് ആയിരിക്കില്ലെന്ന് എനിക്ക് ഉറപ്പുണ്ട്. വാസ്തവത്തിൽ, പൈത്തൺ ഇവിടെ ഞങ്ങളുടെ സഹായത്തിനെത്തുന്നു.

എയർ ടിക്കറ്റുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ തിരയുന്നതിനുള്ള ഒരു സംവിധാനം സൃഷ്ടിക്കുന്നതിനുള്ള വഴിയിൽ ഞങ്ങൾ പരിഹരിക്കേണ്ട ആദ്യ ദൗത്യം ഞങ്ങൾ വിവരങ്ങൾ എടുക്കുന്ന അനുയോജ്യമായ ഒരു പ്ലാറ്റ്ഫോം തിരഞ്ഞെടുക്കുന്നതാണ്. ഈ പ്രശ്നം പരിഹരിക്കുന്നത് എനിക്ക് എളുപ്പമായിരുന്നില്ല, പക്ഷേ അവസാനം ഞാൻ കയാക്ക് സേവനം തിരഞ്ഞെടുത്തു. മോമോണ്ടോ, സ്കൈസ്‌കാനർ, എക്‌സ്‌പീഡിയ എന്നിവയുടെയും മറ്റ് ചിലതിന്റെയും സേവനങ്ങൾ ഞാൻ പരീക്ഷിച്ചു, എന്നാൽ ഈ ഉറവിടങ്ങളിലെ റോബോട്ട് സംരക്ഷണ സംവിധാനങ്ങൾ അഭേദ്യമായിരുന്നു. ട്രാഫിക് ലൈറ്റുകൾ, കാൽനട ക്രോസിംഗുകൾ, സൈക്കിളുകൾ എന്നിവ കൈകാര്യം ചെയ്യേണ്ടി വന്ന നിരവധി ശ്രമങ്ങൾക്ക് ശേഷം, ഞാൻ മനുഷ്യനാണെന്ന് സിസ്റ്റങ്ങളെ ബോധ്യപ്പെടുത്താൻ ശ്രമിച്ചപ്പോൾ, വളരെയധികം പേജുകൾ ലോഡുചെയ്‌തിട്ടും കയാക്കാണ് എനിക്ക് ഏറ്റവും അനുയോജ്യമെന്ന് ഞാൻ തീരുമാനിച്ചു. ചുരുങ്ങിയ സമയത്തിനുള്ളിൽ, പരിശോധനകളും ആരംഭിക്കും. 4 മുതൽ 6 മണിക്കൂർ വരെ ഇടവേളകളിൽ ബോട്ട് സൈറ്റിലേക്ക് അഭ്യർത്ഥനകൾ അയയ്ക്കാൻ എനിക്ക് കഴിഞ്ഞു, എല്ലാം നന്നായി പ്രവർത്തിച്ചു. കാലാകാലങ്ങളിൽ, കയാക്കിനൊപ്പം പ്രവർത്തിക്കുമ്പോൾ ബുദ്ധിമുട്ടുകൾ ഉണ്ടാകുന്നു, പക്ഷേ അവർ നിങ്ങളെ ചെക്കുകൾ ഉപയോഗിച്ച് ശല്യപ്പെടുത്താൻ തുടങ്ങിയാൽ, ഒന്നുകിൽ നിങ്ങൾ അവരുമായി സ്വമേധയാ ഇടപെട്ട് ബോട്ട് സമാരംഭിക്കേണ്ടതുണ്ട്, അല്ലെങ്കിൽ കുറച്ച് മണിക്കൂർ കാത്തിരിക്കുക, പരിശോധനകൾ നിർത്തണം. ആവശ്യമെങ്കിൽ, മറ്റൊരു പ്ലാറ്റ്‌ഫോമിനായി നിങ്ങൾക്ക് കോഡ് എളുപ്പത്തിൽ പൊരുത്തപ്പെടുത്താനാകും, അങ്ങനെ ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾക്ക് അത് അഭിപ്രായങ്ങളിൽ റിപ്പോർട്ടുചെയ്യാനാകും.

നിങ്ങൾ ഇപ്പോൾ വെബ് സ്‌ക്രാപ്പിംഗ് ആരംഭിക്കുകയും ചില വെബ്‌സൈറ്റുകൾ എന്തിനാണ് ഇത് നേരിടുന്നതെന്ന് അറിയില്ലെങ്കിൽ, ഈ മേഖലയിൽ നിങ്ങളുടെ ആദ്യ പ്രോജക്റ്റ് ആരംഭിക്കുന്നതിന് മുമ്പ്, സ്വയം ഒരു ഉപകാരം ചെയ്യുകയും "വെബ് സ്‌ക്രാപ്പിംഗ് മര്യാദ" എന്ന വാക്കുകളിൽ Google തിരയുകയും ചെയ്യുക. . നിങ്ങൾ ബുദ്ധിശൂന്യമായി വെബ് സ്ക്രാപ്പിംഗ് നടത്തുകയാണെങ്കിൽ, നിങ്ങളുടെ പരീക്ഷണങ്ങൾ നിങ്ങൾ വിചാരിക്കുന്നതിലും വേഗത്തിൽ അവസാനിച്ചേക്കാം.

ആരംഭിക്കുന്നു

ഞങ്ങളുടെ വെബ് സ്‌ക്രാപ്പർ കോഡിൽ എന്ത് സംഭവിക്കും എന്നതിന്റെ പൊതുവായ ഒരു അവലോകനം ഇതാ:

• ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക.
• ഒരു Google Chrome ടാബ് തുറക്കുന്നു.
• ബോട്ട് ആരംഭിക്കുന്ന ഒരു ഫംഗ്‌ഷനെ വിളിക്കുക, ടിക്കറ്റുകൾക്കായി തിരയുമ്പോൾ ഉപയോഗിക്കുന്ന നഗരങ്ങളും തീയതികളും കൈമാറുക.
• ഈ ഫംഗ്‌ഷൻ ആദ്യ തിരയൽ ഫലങ്ങൾ എടുക്കുകയും മികച്ച രീതിയിൽ അടുക്കുകയും കൂടുതൽ ഫലങ്ങൾ ലോഡുചെയ്യാൻ ഒരു ബട്ടൺ ക്ലിക്കുചെയ്യുകയും ചെയ്യുന്നു.
• മറ്റൊരു ഫംഗ്‌ഷൻ മുഴുവൻ പേജിൽ നിന്നും ഡാറ്റ ശേഖരിക്കുകയും ഒരു ഡാറ്റ ഫ്രെയിം തിരികെ നൽകുകയും ചെയ്യുന്നു.
• മുമ്പത്തെ രണ്ട് ഘട്ടങ്ങൾ ടിക്കറ്റ് നിരക്ക് (വിലകുറഞ്ഞത്), ഫ്ലൈറ്റ് വേഗത (വേഗത) എന്നിവ പ്രകാരം തരം തിരിക്കൽ ഉപയോഗിച്ചാണ് നടത്തുന്നത്.
• ടിക്കറ്റ് നിരക്കുകളുടെ സംഗ്രഹം (ഏറ്റവും വിലകുറഞ്ഞ ടിക്കറ്റുകളും ശരാശരി വിലയും) അടങ്ങിയ ഒരു ഇമെയിൽ സ്‌ക്രിപ്റ്റ് ഉപയോക്താവിന് അയച്ചു, കൂടാതെ മുകളിൽ പറഞ്ഞ മൂന്ന് മെട്രിക്‌സ് പ്രകാരം അടുക്കിയ വിവരങ്ങളുള്ള ഒരു ഡാറ്റ ഫ്രെയിം ഒരു Excel ഫയലായി സംരക്ഷിക്കപ്പെടും.
• മുകളിലുള്ള എല്ലാ പ്രവർത്തനങ്ങളും ഒരു നിശ്ചിത സമയത്തിന് ശേഷം ഒരു സൈക്കിളിൽ നടത്തുന്നു.

ഓരോ സെലിനിയം പ്രോജക്റ്റും ഒരു വെബ് ഡ്രൈവർ ഉപയോഗിച്ചാണ് ആരംഭിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഞാൻ ഉപയോഗിക്കുന്നു ക്രോംഡ്രൈവർ, ഞാൻ 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 പകർത്തുക

രണ്ടാമത്തെ ഓപ്ഷൻ വളരെ ലളിതമായി കാണപ്പെടുന്നുവെന്നത് വളരെ വ്യക്തമാണ്. ഉപയോഗിക്കുമ്പോൾ, അത് ആട്രിബ്യൂട്ട് ഉള്ള ഒരു ഘടകത്തിനായി തിരയുന്നു 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.....')

തിരക്കഥയുടെ പരീക്ഷണ ഓട്ടം ഇങ്ങനെയാണ്.

സ്ക്രിപ്റ്റിന്റെ ടെസ്റ്റ് റൺ

ഫലങ്ങൾ

നിങ്ങൾ ഇത് വരെ എത്തിയെങ്കിൽ, അഭിനന്ദനങ്ങൾ! നിങ്ങൾക്ക് ഇപ്പോൾ പ്രവർത്തിക്കുന്ന ഒരു വെബ് സ്‌ക്രാപ്പർ ഉണ്ട്, എന്നിരുന്നാലും ഇത് മെച്ചപ്പെടുത്തുന്നതിനുള്ള നിരവധി മാർഗങ്ങൾ എനിക്ക് ഇതിനകം കാണാൻ കഴിയും. ഉദാഹരണത്തിന്, ഇത് ട്വിലിയോയുമായി സംയോജിപ്പിച്ച് ഇമെയിലുകൾക്ക് പകരം വാചക സന്ദേശങ്ങൾ അയയ്‌ക്കാൻ കഴിയും. നിരവധി സെർവറുകളിൽ നിന്ന് ഒരേസമയം ഫലങ്ങൾ സ്വീകരിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു VPN അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ഉപയോഗിക്കാം. അവൻ ഒരു വ്യക്തിയാണോ എന്നറിയാൻ സൈറ്റ് ഉപയോക്താവിനെ പരിശോധിക്കുന്നതിൽ ഇടയ്ക്കിടെ ഉയർന്നുവരുന്ന ഒരു പ്രശ്നമുണ്ട്, എന്നാൽ ഈ പ്രശ്നം പരിഹരിക്കാനും കഴിയും. ഏത് സാഹചര്യത്തിലും, ഇപ്പോൾ നിങ്ങൾക്ക് വേണമെങ്കിൽ വികസിപ്പിക്കാൻ കഴിയുന്ന ഒരു അടിത്തറയുണ്ട്. ഉദാഹരണത്തിന്, ഒരു എക്സൽ ഫയൽ ഒരു ഇമെയിലിലേക്കുള്ള അറ്റാച്ച്മെന്റായി ഉപയോക്താവിന് അയച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

നിങ്ങൾ വെബ് സ്ക്രാപ്പിംഗ് സാങ്കേതികവിദ്യകൾ ഉപയോഗിക്കുന്നുണ്ടോ?

• ആ

• ഇല്ല

8 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 1 ഉപയോക്താവ് വിട്ടുനിന്നു.

അവലംബം: www.habr.com