ಲೇಖನದ ಲೇಖಕರು, ನಾವು ಇಂದು ಪ್ರಕಟಿಸುತ್ತಿರುವ ಅನುವಾದವು, ಸೆಲೆನಿಯಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪೈಥಾನ್‌ನಲ್ಲಿ ವೆಬ್ ಸ್ಕ್ರಾಪರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಬಗ್ಗೆ ಮಾತನಾಡುವುದು ಇದರ ಗುರಿಯಾಗಿದೆ, ಇದು ವಿಮಾನಯಾನ ಟಿಕೆಟ್ ಬೆಲೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ. ಟಿಕೆಟ್‌ಗಳನ್ನು ಹುಡುಕುವಾಗ, ಹೊಂದಿಕೊಳ್ಳುವ ದಿನಾಂಕಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ (+- ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ದಿನಾಂಕಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ 3 ದಿನಗಳು). ಸ್ಕ್ರಾಪರ್ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ಎಕ್ಸೆಲ್ ಫೈಲ್‌ನಲ್ಲಿ ಉಳಿಸುತ್ತದೆ ಮತ್ತು ಹುಡುಕಾಟವನ್ನು ನಡೆಸಿದ ವ್ಯಕ್ತಿಗೆ ಅವರು ಕಂಡುಕೊಂಡ ಸಾರಾಂಶದೊಂದಿಗೆ ಇಮೇಲ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಈ ಯೋಜನೆಯ ಗುರಿಯು ಪ್ರಯಾಣಿಕರಿಗೆ ಉತ್ತಮ ಡೀಲ್‌ಗಳನ್ನು ಹುಡುಕಲು ಸಹಾಯ ಮಾಡುವುದು.
ವಸ್ತುವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಾಗ, ನೀವು ಕಳೆದುಹೋದರೆ, ಒಮ್ಮೆ ನೋಡಿ ಲೇಖನ.
ನಾವು ಏನನ್ನು ಹುಡುಕಲಿದ್ದೇವೆ?
ಇಲ್ಲಿ ವಿವರಿಸಿದ ವ್ಯವಸ್ಥೆಯನ್ನು ನೀವು ಬಯಸಿದಂತೆ ಬಳಸಲು ನೀವು ಸ್ವತಂತ್ರರಾಗಿದ್ದೀರಿ. ಉದಾಹರಣೆಗೆ, ನನ್ನ ಊರಿಗೆ ವಾರಾಂತ್ಯದ ಪ್ರವಾಸಗಳು ಮತ್ತು ಟಿಕೆಟ್‌ಗಳನ್ನು ಹುಡುಕಲು ನಾನು ಇದನ್ನು ಬಳಸಿದ್ದೇನೆ. ಲಾಭದಾಯಕ ಟಿಕೆಟ್‌ಗಳನ್ನು ಹುಡುಕುವಲ್ಲಿ ನೀವು ಗಂಭೀರವಾಗಿರುತ್ತಿದ್ದರೆ, ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು (ಸರಳ , ತಿಂಗಳಿಗೆ 130 ರೂಬಲ್ಸ್‌ಗಳಿಗೆ, ಇದಕ್ಕೆ ಸಾಕಷ್ಟು ಸೂಕ್ತವಾಗಿದೆ) ಮತ್ತು ಅದು ದಿನಕ್ಕೆ ಒಂದು ಅಥವಾ ಎರಡು ಬಾರಿ ಚಲಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ಇಮೇಲ್ ಮೂಲಕ ನಿಮಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಎಕ್ಸೆಲ್ ಫೈಲ್ ಅನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ಉಳಿಸಲು ಎಲ್ಲವನ್ನೂ ಹೊಂದಿಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಇದು ಅಂತಹ ಫೈಲ್‌ಗಳನ್ನು ಎಲ್ಲಿಂದಲಾದರೂ ಮತ್ತು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ವೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ನಾನು ಇನ್ನೂ ದೋಷಗಳೊಂದಿಗೆ ಸುಂಕಗಳನ್ನು ಕಂಡುಕೊಂಡಿಲ್ಲ, ಆದರೆ ಇದು ಸಾಧ್ಯ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ
ಹುಡುಕುವಾಗ, ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, "ಹೊಂದಿಕೊಳ್ಳುವ ದಿನಾಂಕ" ವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ; ಸ್ಕ್ರಿಪ್ಟ್ ನೀಡಿದ ದಿನಾಂಕಗಳ ಮೂರು ದಿನಗಳಲ್ಲಿ ಕೊಡುಗೆಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ, ಇದು ಕೇವಲ ಒಂದು ದಿಕ್ಕಿನಲ್ಲಿ ಕೊಡುಗೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ, ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಸುಲಭವಾಗಿದೆ ಇದರಿಂದ ಅದು ಹಲವಾರು ವಿಮಾನ ನಿರ್ದೇಶನಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಅದರ ಸಹಾಯದಿಂದ, ನೀವು ತಪ್ಪಾದ ಸುಂಕಗಳನ್ನು ಸಹ ನೋಡಬಹುದು; ಅಂತಹ ಸಂಶೋಧನೆಗಳು ತುಂಬಾ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ.
ನಿಮಗೆ ಇನ್ನೊಂದು ವೆಬ್ ಸ್ಕ್ರಾಪರ್ ಏಕೆ ಬೇಕು?
ನಾನು ಮೊದಲು ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಅದರಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಆಸಕ್ತಿ ಹೊಂದಿರಲಿಲ್ಲ. ಭವಿಷ್ಯಸೂಚಕ ಮಾಡೆಲಿಂಗ್, ಹಣಕಾಸು ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಬಹುಶಃ ಪಠ್ಯಗಳ ಭಾವನಾತ್ಮಕ ಬಣ್ಣವನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೆಚ್ಚಿನ ಯೋಜನೆಗಳನ್ನು ಮಾಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಆದರೆ ವೆಬ್‌ಸೈಟ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ತುಂಬಾ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಎಂದು ಅದು ಬದಲಾಯಿತು. ನಾನು ಈ ವಿಷಯವನ್ನು ಪರಿಶೀಲಿಸಿದಾಗ, ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಇಂಟರ್ನೆಟ್‌ನ "ಎಂಜಿನ್" ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ.
ಇದು ತುಂಬಾ ಬೋಲ್ಡ್ ಹೇಳಿಕೆ ಎಂದು ನೀವು ಭಾವಿಸಬಹುದು. ಆದರೆ ಜಾವಾ ಮತ್ತು ಪೈಥಾನ್ ಬಳಸಿ ಲ್ಯಾರಿ ಪೇಜ್ ರಚಿಸಿದ ವೆಬ್ ಸ್ಕ್ರಾಪರ್‌ನೊಂದಿಗೆ ಗೂಗಲ್ ಪ್ರಾರಂಭವಾಯಿತು ಎಂದು ಪರಿಗಣಿಸಿ. ಗೂಗಲ್ ರೋಬೋಟ್‌ಗಳು ಇಂಟರ್ನೆಟ್ ಅನ್ನು ಅನ್ವೇಷಿಸುತ್ತಿವೆ, ಅದರ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತಮ ಉತ್ತರಗಳನ್ನು ಒದಗಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿವೆ. ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಅಂತ್ಯವಿಲ್ಲದ ಉಪಯೋಗಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ನೀವು ಡೇಟಾ ಸೈನ್ಸ್‌ನಲ್ಲಿ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೂ ಸಹ, ನೀವು ವಿಶ್ಲೇಷಿಸಲು ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ನಿಮಗೆ ಕೆಲವು ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಕೌಶಲ್ಯಗಳು ಬೇಕಾಗುತ್ತವೆ.
ಇಲ್ಲಿ ಬಳಸಲಾದ ಕೆಲವು ತಂತ್ರಗಳನ್ನು ನಾನು ಅದ್ಭುತವಾಗಿ ಕಂಡುಕೊಂಡಿದ್ದೇನೆ ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಬಗ್ಗೆ, ನಾನು ಇತ್ತೀಚೆಗೆ ಸ್ವಾಧೀನಪಡಿಸಿಕೊಂಡಿದ್ದೇನೆ. ನೀವು ಕಲಿತದ್ದನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಅನ್ವಯಿಸಲು ಇದು ಅನೇಕ ಸರಳ ಉದಾಹರಣೆಗಳನ್ನು ಮತ್ತು ಕಲ್ಪನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, reCaptcha ಚೆಕ್‌ಗಳನ್ನು ಬೈಪಾಸ್ ಮಾಡುವಲ್ಲಿ ಬಹಳ ಆಸಕ್ತಿದಾಯಕ ಅಧ್ಯಾಯವಿದೆ. ಅಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ವಿಶೇಷ ಪರಿಕರಗಳು ಮತ್ತು ಸಂಪೂರ್ಣ ಸೇವೆಗಳಿವೆ ಎಂದು ನನಗೆ ತಿಳಿದಿರದ ಕಾರಣ ಇದು ನನಗೆ ಸುದ್ದಿಯಾಗಿದೆ.
ನೀವು ಪ್ರಯಾಣ ಮಾಡಲು ಇಚ್ಚಿಸುವಿರಾ?!
ಈ ವಿಭಾಗದ ಶೀರ್ಷಿಕೆಯಲ್ಲಿ ಕೇಳಲಾದ ಸರಳ ಮತ್ತು ಬದಲಿಗೆ ನಿರುಪದ್ರವ ಪ್ರಶ್ನೆಗೆ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಧನಾತ್ಮಕ ಉತ್ತರವನ್ನು ಕೇಳಬಹುದು, ಅದರೊಂದಿಗೆ ಕೇಳಲಾದ ವ್ಯಕ್ತಿಯ ಪ್ರಯಾಣದಿಂದ ಒಂದೆರಡು ಕಥೆಗಳು. ಹೊಸ ಸಾಂಸ್ಕೃತಿಕ ಪರಿಸರದಲ್ಲಿ ನಿಮ್ಮನ್ನು ಮುಳುಗಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಪರಿಧಿಯನ್ನು ವಿಸ್ತರಿಸಲು ಪ್ರಯಾಣವು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ ಎಂದು ನಮ್ಮಲ್ಲಿ ಹೆಚ್ಚಿನವರು ಒಪ್ಪುತ್ತಾರೆ. ಹೇಗಾದರೂ, ನೀವು ವಿಮಾನ ಟಿಕೆಟ್‌ಗಳನ್ನು ಹುಡುಕಲು ಇಷ್ಟಪಡುತ್ತೀರಾ ಎಂದು ನೀವು ಯಾರನ್ನಾದರೂ ಕೇಳಿದರೆ, ಉತ್ತರವು ಸಕಾರಾತ್ಮಕವಾಗಿರುವುದಿಲ್ಲ ಎಂದು ನನಗೆ ಖಾತ್ರಿಯಿದೆ. ವಾಸ್ತವವಾಗಿ, ಪೈಥಾನ್ ಇಲ್ಲಿ ನಮ್ಮ ಸಹಾಯಕ್ಕೆ ಬರುತ್ತದೆ.
ಏರ್ ಟಿಕೆಟ್‌ಗಳಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕುವ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವ ಮಾರ್ಗದಲ್ಲಿ ನಾವು ಪರಿಹರಿಸಬೇಕಾದ ಮೊದಲ ಕಾರ್ಯವೆಂದರೆ ಸೂಕ್ತವಾದ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು, ಇದರಿಂದ ನಾವು ಮಾಹಿತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು ನನಗೆ ಸುಲಭವಲ್ಲ, ಆದರೆ ಕೊನೆಯಲ್ಲಿ ನಾನು ಕಾಯಕ ಸೇವೆಯನ್ನು ಆರಿಸಿದೆ. ನಾನು Momondo, Skyscanner, Expedia, ಮತ್ತು ಕೆಲವು ಇತರ ಸೇವೆಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದೆ, ಆದರೆ ಈ ಸಂಪನ್ಮೂಲಗಳ ಮೇಲೆ ರೋಬೋಟ್ ರಕ್ಷಣೆ ಕಾರ್ಯವಿಧಾನಗಳು ತೂರಲಾಗಲಿಲ್ಲ. ಹಲವಾರು ಪ್ರಯತ್ನಗಳ ನಂತರ, ನಾನು ಟ್ರಾಫಿಕ್ ದೀಪಗಳು, ಪಾದಚಾರಿ ಕ್ರಾಸಿಂಗ್‌ಗಳು ಮತ್ತು ಬೈಸಿಕಲ್‌ಗಳನ್ನು ಎದುರಿಸಬೇಕಾಗಿತ್ತು, ನಾನು ಮನುಷ್ಯ ಎಂದು ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಮನವರಿಕೆ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದೆ, ಹಲವಾರು ಪುಟಗಳು ಲೋಡ್ ಆಗಿದ್ದರೂ ಸಹ, ಕಯಾಕ್ ನನಗೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ನಿರ್ಧರಿಸಿದೆ. ಕಡಿಮೆ ಸಮಯದಲ್ಲಿ, ಮತ್ತು ತಪಾಸಣೆಗಳು ಸಹ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ. 4 ರಿಂದ 6 ಗಂಟೆಗಳ ಮಧ್ಯಂತರದಲ್ಲಿ ಸೈಟ್‌ಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ಬೋಟ್ ಮಾಡಲು ನಾನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೆ ಮತ್ತು ಎಲ್ಲವೂ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಕಾಲಕಾಲಕ್ಕೆ, ಕಯಾಕ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ತೊಂದರೆಗಳು ಉಂಟಾಗುತ್ತವೆ, ಆದರೆ ಅವರು ನಿಮ್ಮನ್ನು ಚೆಕ್‌ಗಳೊಂದಿಗೆ ಪೀಡಿಸಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ನೀವು ಅವರೊಂದಿಗೆ ಹಸ್ತಚಾಲಿತವಾಗಿ ವ್ಯವಹರಿಸಬೇಕು ಮತ್ತು ನಂತರ ಬೋಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು ಅಥವಾ ಕೆಲವು ಗಂಟೆಗಳ ಕಾಲ ಕಾಯಬೇಕು ಮತ್ತು ಚೆಕ್‌ಗಳು ನಿಲ್ಲಬೇಕು. ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಇನ್ನೊಂದು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನೀವು ಹಾಗೆ ಮಾಡಿದರೆ, ನೀವು ಅದನ್ನು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ವರದಿ ಮಾಡಬಹುದು.
ನೀವು ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು ಕೆಲವು ವೆಬ್‌ಸೈಟ್‌ಗಳು ಅದರೊಂದಿಗೆ ಏಕೆ ಹೋರಾಡುತ್ತಿವೆ ಎಂದು ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಈ ಪ್ರದೇಶದಲ್ಲಿ ನಿಮ್ಮ ಮೊದಲ ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನೀವೇ ಒಂದು ಸಹಾಯ ಮಾಡಿ ಮತ್ತು "ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಶಿಷ್ಟಾಚಾರ" ಪದಗಳ ಮೇಲೆ Google ಹುಡುಕಾಟವನ್ನು ಮಾಡಿ. . ನೀವು ಅವಿವೇಕದಿಂದ ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಮಾಡಿದರೆ ನಿಮ್ಮ ಪ್ರಯೋಗಗಳು ನೀವು ಯೋಚಿಸುವುದಕ್ಕಿಂತ ಬೇಗ ಮುಗಿಯಬಹುದು.
ಆರಂಭಿಸುವಿಕೆ
ನಮ್ಮ ವೆಬ್ ಸ್ಕ್ರಾಪರ್ ಕೋಡ್ನಲ್ಲಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದರ ಸಾಮಾನ್ಯ ಅವಲೋಕನ ಇಲ್ಲಿದೆ:
- ಅಗತ್ಯವಿರುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ.
- 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 ಹೊಸ ಹುಡುಕಾಟ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಸೆಕೆಂಡುಗಳವರೆಗೆ ಬೋಟ್ ಅನ್ನು "ನಿದ್ರಿಸಲು" ಬಳಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ಇಲ್ಲದೆ ಒಂದೇ ಬೋಟ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ನೀವು ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ, ಕ್ರೋಮ್ ವಿಂಡೋ ತೆರೆಯುತ್ತದೆ, ಅದನ್ನು ಸೈಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬೋಟ್ ಬಳಸುತ್ತದೆ.
ಸ್ವಲ್ಪ ಪ್ರಯೋಗ ಮಾಡೋಣ ಮತ್ತು 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.....')
ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪರೀಕ್ಷೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೆಸ್ಟ್ ರನ್
ಫಲಿತಾಂಶಗಳು
ನೀವು ಇಲ್ಲಿಯವರೆಗೆ ಸಾಧಿಸಿದ್ದರೆ, ಅಭಿನಂದನೆಗಳು! ನೀವು ಈಗ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ವೆಬ್ ಸ್ಕ್ರಾಪರ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ, ಆದರೂ ಅದನ್ನು ಸುಧಾರಿಸಲು ನಾನು ಈಗಾಗಲೇ ಹಲವು ಮಾರ್ಗಗಳನ್ನು ನೋಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಇದನ್ನು Twilio ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು ಇದರಿಂದ ಅದು ಇಮೇಲ್‌ಗಳ ಬದಲಿಗೆ ಪಠ್ಯ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಹಲವಾರು ಸರ್ವರ್‌ಗಳಿಂದ ಏಕಕಾಲದಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ನೀವು VPN ಅಥವಾ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಬಳಸಬಹುದು. ನಿಯತಕಾಲಿಕವಾಗಿ ಉದ್ಭವಿಸುವ ಸಮಸ್ಯೆಯು ಸೈಟ್ ಬಳಕೆದಾರರನ್ನು ಅವನು ಒಬ್ಬ ವ್ಯಕ್ತಿಯೇ ಎಂದು ನೋಡಲು ಪರಿಶೀಲಿಸುವಲ್ಲಿ ಸಹ ಇದೆ, ಆದರೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಸಹ ಪರಿಹರಿಸಬಹುದು. ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಈಗ ನೀವು ಬಯಸಿದಲ್ಲಿ ವಿಸ್ತರಿಸಬಹುದಾದ ಬೇಸ್ ಅನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ. ಉದಾಹರಣೆಗೆ, ಎಕ್ಸೆಲ್ ಫೈಲ್ ಅನ್ನು ಇಮೇಲ್‌ಗೆ ಲಗತ್ತಾಗಿ ಬಳಕೆದಾರರಿಗೆ ಕಳುಹಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ನೋಂದಾಯಿತ ಬಳಕೆದಾರರು ಮಾತ್ರ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದು. , ದಯವಿಟ್ಟು.
ನೀವು ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಬಳಸುತ್ತೀರಾ?
-
ಹೌದು
-
ಯಾವುದೇ
8 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 1 ಬಳಕೆದಾರರು ದೂರವಿದ್ದಾರೆ.
ಮೂಲ: www.habr.com