ਪਾਈਥਨ - ਯਾਤਰਾ ਕਰਨਾ ਪਸੰਦ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਸਸਤੀ ਹਵਾਈ ਟਿਕਟਾਂ ਲੱਭਣ ਵਿੱਚ ਇੱਕ ਸਹਾਇਕ

ਲੇਖ ਦੇ ਲੇਖਕ, ਜਿਸਦਾ ਅਨੁਵਾਦ ਅਸੀਂ ਅੱਜ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰ ਰਹੇ ਹਾਂ, ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਸਦਾ ਟੀਚਾ ਸੇਲੇਨਿਅਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਵੈਬ ਸਕ੍ਰੈਪਰ ਦੇ ਵਿਕਾਸ ਬਾਰੇ ਗੱਲ ਕਰਨਾ ਹੈ, ਜੋ ਏਅਰਲਾਈਨ ਟਿਕਟ ਦੀਆਂ ਕੀਮਤਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ. ਟਿਕਟਾਂ ਦੀ ਖੋਜ ਕਰਦੇ ਸਮੇਂ, ਲਚਕਦਾਰ ਤਾਰੀਖਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਨਿਸ਼ਿਸ਼ਟ ਮਿਤੀਆਂ ਦੇ ਮੁਕਾਬਲੇ +- 3 ਦਿਨ)। ਸਕ੍ਰੈਪਰ ਖੋਜ ਨਤੀਜਿਆਂ ਨੂੰ ਇੱਕ ਐਕਸਲ ਫਾਈਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ ਅਤੇ ਖੋਜ ਨੂੰ ਚਲਾਉਣ ਵਾਲੇ ਵਿਅਕਤੀ ਨੂੰ ਉਹਨਾਂ ਨੂੰ ਕੀ ਮਿਲਿਆ ਉਸ ਦੇ ਸੰਖੇਪ ਦੇ ਨਾਲ ਇੱਕ ਈਮੇਲ ਭੇਜਦਾ ਹੈ। ਇਸ ਪ੍ਰੋਜੈਕਟ ਦਾ ਟੀਚਾ ਯਾਤਰੀਆਂ ਨੂੰ ਵਧੀਆ ਸੌਦੇ ਲੱਭਣ ਵਿੱਚ ਮਦਦ ਕਰਨਾ ਹੈ।

ਜੇ, ਸਮੱਗਰੀ ਨੂੰ ਸਮਝਦੇ ਹੋਏ, ਤੁਸੀਂ ਗੁਆਚ ਗਏ ਮਹਿਸੂਸ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਨਜ਼ਰ ਮਾਰੋ ਇਹ ਲੇਖ।

ਅਸੀਂ ਕੀ ਭਾਲਣ ਜਾ ਰਹੇ ਹਾਂ?

ਤੁਸੀਂ ਇੱਥੇ ਵਰਣਿਤ ਸਿਸਟਮ ਨੂੰ ਆਪਣੀ ਮਰਜ਼ੀ ਅਨੁਸਾਰ ਵਰਤਣ ਲਈ ਸੁਤੰਤਰ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਮੈਂ ਇਸਨੂੰ ਆਪਣੇ ਜੱਦੀ ਸ਼ਹਿਰ ਲਈ ਵੀਕੈਂਡ ਟੂਰ ਅਤੇ ਟਿਕਟਾਂ ਦੀ ਖੋਜ ਕਰਨ ਲਈ ਵਰਤਿਆ। ਜੇ ਤੁਸੀਂ ਲਾਭਦਾਇਕ ਟਿਕਟਾਂ ਲੱਭਣ ਬਾਰੇ ਗੰਭੀਰ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਰਵਰ 'ਤੇ ਸਕ੍ਰਿਪਟ ਚਲਾ ਸਕਦੇ ਹੋ (ਸਰਲ ਸਰਵਰ, 130 ਰੂਬਲ ਇੱਕ ਮਹੀਨੇ ਲਈ, ਇਸਦੇ ਲਈ ਕਾਫ਼ੀ ਢੁਕਵਾਂ ਹੈ) ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਇਹ ਦਿਨ ਵਿੱਚ ਇੱਕ ਜਾਂ ਦੋ ਵਾਰ ਚੱਲਦਾ ਹੈ। ਖੋਜ ਨਤੀਜੇ ਤੁਹਾਨੂੰ ਈਮੇਲ ਦੁਆਰਾ ਭੇਜੇ ਜਾਣਗੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਤਾਂ ਕਿ ਸਕ੍ਰਿਪਟ ਇੱਕ ਐਕਸਲ ਫਾਈਲ ਨੂੰ ਡ੍ਰੌਪਬਾਕਸ ਫੋਲਡਰ ਵਿੱਚ ਖੋਜ ਨਤੀਜਿਆਂ ਨਾਲ ਸੁਰੱਖਿਅਤ ਕਰੇ, ਜੋ ਤੁਹਾਨੂੰ ਅਜਿਹੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਕਿਤੇ ਵੀ ਅਤੇ ਕਿਸੇ ਵੀ ਸਮੇਂ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ।

ਮੈਨੂੰ ਅਜੇ ਤੱਕ ਗਲਤੀਆਂ ਵਾਲੇ ਟੈਰਿਫ ਨਹੀਂ ਮਿਲੇ ਹਨ, ਪਰ ਮੈਨੂੰ ਲੱਗਦਾ ਹੈ ਕਿ ਇਹ ਸੰਭਵ ਹੈ

ਖੋਜ ਕਰਦੇ ਸਮੇਂ, ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਇੱਕ "ਲਚਕਦਾਰ ਮਿਤੀ" ਵਰਤੀ ਜਾਂਦੀ ਹੈ; ਸਕ੍ਰਿਪਟ ਉਹਨਾਂ ਪੇਸ਼ਕਸ਼ਾਂ ਨੂੰ ਲੱਭਦੀ ਹੈ ਜੋ ਦਿੱਤੀਆਂ ਮਿਤੀਆਂ ਦੇ ਤਿੰਨ ਦਿਨਾਂ ਦੇ ਅੰਦਰ ਹਨ। ਹਾਲਾਂਕਿ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਂਦੇ ਸਮੇਂ, ਇਹ ਸਿਰਫ ਇੱਕ ਦਿਸ਼ਾ ਵਿੱਚ ਪੇਸ਼ਕਸ਼ਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਸੋਧਣਾ ਆਸਾਨ ਹੈ ਤਾਂ ਜੋ ਇਹ ਕਈ ਫਲਾਈਟ ਦਿਸ਼ਾਵਾਂ 'ਤੇ ਡਾਟਾ ਇਕੱਠਾ ਕਰ ਸਕੇ। ਇਸਦੀ ਮਦਦ ਨਾਲ, ਤੁਸੀਂ ਗਲਤ ਟੈਰਿਫ ਵੀ ਲੱਭ ਸਕਦੇ ਹੋ; ਅਜਿਹੇ ਖੋਜ ਬਹੁਤ ਦਿਲਚਸਪ ਹੋ ਸਕਦੇ ਹਨ.

ਤੁਹਾਨੂੰ ਇੱਕ ਹੋਰ ਵੈੱਬ ਸਕ੍ਰੈਪਰ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ?

ਜਦੋਂ ਮੈਂ ਪਹਿਲੀ ਵਾਰ ਵੈਬ ਸਕ੍ਰੈਪਿੰਗ ਸ਼ੁਰੂ ਕੀਤੀ ਸੀ, ਤਾਂ ਮੈਂ ਇਮਾਨਦਾਰੀ ਨਾਲ ਇਸ ਵਿੱਚ ਖਾਸ ਤੌਰ 'ਤੇ ਦਿਲਚਸਪੀ ਨਹੀਂ ਰੱਖਦਾ ਸੀ. ਮੈਂ ਭਵਿੱਖਬਾਣੀ ਮਾਡਲਿੰਗ, ਵਿੱਤੀ ਵਿਸ਼ਲੇਸ਼ਣ, ਅਤੇ, ਸੰਭਵ ਤੌਰ 'ਤੇ, ਟੈਕਸਟ ਦੇ ਭਾਵਨਾਤਮਕ ਰੰਗ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਖੇਤਰ ਵਿੱਚ ਹੋਰ ਪ੍ਰੋਜੈਕਟ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ। ਪਰ ਇਹ ਪਤਾ ਚਲਿਆ ਕਿ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਬਹੁਤ ਦਿਲਚਸਪ ਸੀ ਕਿ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਵੈਬਸਾਈਟਾਂ ਤੋਂ ਡੇਟਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ. ਜਿਵੇਂ ਕਿ ਮੈਂ ਇਸ ਵਿਸ਼ੇ ਵਿੱਚ ਖੋਜ ਕੀਤੀ, ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ ਇੰਟਰਨੈਟ ਦਾ "ਇੰਜਣ" ਹੈ.

ਤੁਸੀਂ ਸੋਚ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਬਹੁਤ ਦਲੇਰ ਬਿਆਨ ਹੈ। ਪਰ ਵਿਚਾਰ ਕਰੋ ਕਿ ਗੂਗਲ ਨੇ ਇੱਕ ਵੈਬ ਸਕ੍ਰੈਪਰ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤੀ ਸੀ ਜੋ ਲੈਰੀ ਪੇਜ ਨੇ ਜਾਵਾ ਅਤੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਸੀ. ਗੂਗਲ ਰੋਬੋਟ ਇੰਟਰਨੈਟ ਦੀ ਖੋਜ ਕਰ ਰਹੇ ਹਨ, ਆਪਣੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਵਧੀਆ ਜਵਾਬ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਨ. ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ ਦੇ ਬੇਅੰਤ ਉਪਯੋਗ ਹਨ, ਅਤੇ ਭਾਵੇਂ ਤੁਸੀਂ ਡੇਟਾ ਸਾਇੰਸ ਵਿੱਚ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਡੇਟਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੁਝ ਸਕ੍ਰੈਪਿੰਗ ਹੁਨਰਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ.

ਮੈਨੂੰ ਇੱਕ ਸ਼ਾਨਦਾਰ ਵਿੱਚ ਇੱਥੇ ਵਰਤਿਆ ਤਕਨੀਕ ਦੇ ਕੁਝ ਪਾਇਆ ਕਿਤਾਬ ਵੈਬ ਸਕ੍ਰੈਪਿੰਗ ਬਾਰੇ, ਜੋ ਮੈਂ ਹਾਲ ਹੀ ਵਿੱਚ ਹਾਸਲ ਕੀਤਾ ਹੈ. ਇਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਸਾਧਾਰਨ ਉਦਾਹਰਣਾਂ ਅਤੇ ਵਿਚਾਰ ਸ਼ਾਮਲ ਹਨ ਜੋ ਤੁਸੀਂ ਸਿੱਖੀਆਂ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਰੀਕੈਪਚਾ ਜਾਂਚਾਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨ ਦਾ ਇੱਕ ਬਹੁਤ ਹੀ ਦਿਲਚਸਪ ਅਧਿਆਇ ਹੈ। ਇਹ ਮੇਰੇ ਲਈ ਖ਼ਬਰ ਦੇ ਰੂਪ ਵਿੱਚ ਆਇਆ, ਕਿਉਂਕਿ ਮੈਨੂੰ ਇਹ ਵੀ ਨਹੀਂ ਪਤਾ ਸੀ ਕਿ ਅਜਿਹੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਵਿਸ਼ੇਸ਼ ਟੂਲ ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਪੂਰੀਆਂ ਸੇਵਾਵਾਂ ਵੀ ਹਨ।

ਕੀ ਤੁਸੀਂ ਯਾਤਰਾ ਕਰਨਾ ਪਸੰਦ ਕਰਦੇ ਹੋ ?!

ਇਸ ਸੈਕਸ਼ਨ ਦੇ ਸਿਰਲੇਖ ਵਿੱਚ ਪੁੱਛੇ ਗਏ ਸਧਾਰਨ ਅਤੇ ਨਾ ਕਿ ਨੁਕਸਾਨਦੇਹ ਸਵਾਲ ਲਈ, ਤੁਸੀਂ ਅਕਸਰ ਇੱਕ ਸਕਾਰਾਤਮਕ ਜਵਾਬ ਸੁਣ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਉਸ ਵਿਅਕਤੀ ਦੀ ਯਾਤਰਾ ਦੀਆਂ ਕੁਝ ਕਹਾਣੀਆਂ ਹਨ ਜਿਸਨੂੰ ਇਹ ਪੁੱਛਿਆ ਗਿਆ ਸੀ। ਸਾਡੇ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਇਸ ਗੱਲ ਨਾਲ ਸਹਿਮਤ ਹੋਣਗੇ ਕਿ ਯਾਤਰਾ ਕਰਨਾ ਆਪਣੇ ਆਪ ਨੂੰ ਨਵੇਂ ਸੱਭਿਆਚਾਰਕ ਮਾਹੌਲ ਵਿੱਚ ਲੀਨ ਕਰਨ ਅਤੇ ਆਪਣੇ ਦੂਰੀ ਨੂੰ ਵਿਸ਼ਾਲ ਕਰਨ ਦਾ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਹੈ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਨੂੰ ਪੁੱਛਦੇ ਹੋ ਕਿ ਕੀ ਉਹ ਏਅਰਲਾਈਨ ਟਿਕਟਾਂ ਦੀ ਖੋਜ ਕਰਨਾ ਪਸੰਦ ਕਰਦੇ ਹਨ, ਤਾਂ ਮੈਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਜਵਾਬ ਇੰਨਾ ਸਕਾਰਾਤਮਕ ਨਹੀਂ ਹੋਵੇਗਾ। ਅਸਲ ਵਿੱਚ, ਪਾਇਥਨ ਇੱਥੇ ਸਾਡੀ ਸਹਾਇਤਾ ਲਈ ਆਉਂਦਾ ਹੈ।

ਹਵਾਈ ਟਿਕਟਾਂ 'ਤੇ ਜਾਣਕਾਰੀ ਖੋਜਣ ਲਈ ਇੱਕ ਸਿਸਟਮ ਬਣਾਉਣ ਦੇ ਰਸਤੇ 'ਤੇ ਸਾਨੂੰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜਿਸ ਕੰਮ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਉਹ ਇੱਕ ਢੁਕਵਾਂ ਪਲੇਟਫਾਰਮ ਚੁਣਨਾ ਹੋਵੇਗਾ ਜਿਸ ਤੋਂ ਅਸੀਂ ਜਾਣਕਾਰੀ ਲਵਾਂਗੇ। ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨਾ ਮੇਰੇ ਲਈ ਆਸਾਨ ਨਹੀਂ ਸੀ, ਪਰ ਅੰਤ ਵਿੱਚ ਮੈਂ ਕਯਾਕ ਸੇਵਾ ਨੂੰ ਚੁਣਿਆ। ਮੈਂ ਮੋਮੋਂਡੋ, ਸਕਾਈਸਕੈਨਰ, ਐਕਸਪੀਡੀਆ, ਅਤੇ ਕੁਝ ਹੋਰਾਂ ਦੀਆਂ ਸੇਵਾਵਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਪਰ ਇਹਨਾਂ ਸਰੋਤਾਂ 'ਤੇ ਰੋਬੋਟ ਸੁਰੱਖਿਆ ਪ੍ਰਣਾਲੀ ਅਭੇਦ ਸੀ। ਕਈ ਕੋਸ਼ਿਸ਼ਾਂ ਦੇ ਬਾਅਦ, ਜਿਸ ਦੌਰਾਨ ਮੈਨੂੰ ਟ੍ਰੈਫਿਕ ਲਾਈਟਾਂ, ਪੈਦਲ ਚੱਲਣ ਵਾਲੇ ਕਰਾਸਿੰਗਾਂ ਅਤੇ ਸਾਈਕਲਾਂ ਨਾਲ ਨਜਿੱਠਣਾ ਪਿਆ, ਸਿਸਟਮਾਂ ਨੂੰ ਯਕੀਨ ਦਿਵਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋਏ ਕਿ ਮੈਂ ਮਨੁੱਖ ਹਾਂ, ਮੈਂ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਕਯਾਕ ਮੇਰੇ ਲਈ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਸੀ, ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਭਾਵੇਂ ਬਹੁਤ ਸਾਰੇ ਪੰਨੇ ਲੋਡ ਕੀਤੇ ਗਏ ਹਨ. ਥੋੜ੍ਹੇ ਸਮੇਂ ਵਿੱਚ, ਅਤੇ ਜਾਂਚ ਵੀ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੀ ਹੈ। ਮੈਂ ਬੋਟ ਨੂੰ 4 ਤੋਂ 6 ਘੰਟਿਆਂ ਦੇ ਅੰਤਰਾਲ 'ਤੇ ਸਾਈਟ 'ਤੇ ਬੇਨਤੀਆਂ ਭੇਜਣ ਲਈ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ, ਅਤੇ ਸਭ ਕੁਝ ਠੀਕ ਕੰਮ ਕੀਤਾ. ਸਮੇਂ-ਸਮੇਂ 'ਤੇ, ਕਾਇਕ ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਮੁਸ਼ਕਲਾਂ ਆਉਂਦੀਆਂ ਹਨ, ਪਰ ਜੇ ਉਹ ਤੁਹਾਨੂੰ ਚੈਕਾਂ ਨਾਲ ਪਰੇਸ਼ਾਨ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਜਾਂ ਤਾਂ ਉਹਨਾਂ ਨਾਲ ਹੱਥੀਂ ਨਜਿੱਠਣ ਅਤੇ ਫਿਰ ਬੋਟ ਨੂੰ ਲਾਂਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਕੁਝ ਘੰਟਿਆਂ ਦੀ ਉਡੀਕ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਜਾਂਚਾਂ ਨੂੰ ਬੰਦ ਕਰ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਜਰੂਰੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਪਲੇਟਫਾਰਮ ਲਈ ਕੋਡ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਅਜਿਹਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਇਸਦੀ ਰਿਪੋਰਟ ਕਰ ਸਕਦੇ ਹੋ।

ਜੇ ਤੁਸੀਂ ਹੁਣੇ ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਇਹ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਕੁਝ ਵੈਬਸਾਈਟਾਂ ਇਸ ਨਾਲ ਕਿਉਂ ਸੰਘਰਸ਼ ਕਰਦੀਆਂ ਹਨ, ਤਾਂ ਇਸ ਖੇਤਰ ਵਿੱਚ ਆਪਣਾ ਪਹਿਲਾ ਪ੍ਰੋਜੈਕਟ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਆਪ ਦਾ ਪੱਖ ਲਓ ਅਤੇ "ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ ਸ਼ਿਸ਼ਟਤਾ" ਸ਼ਬਦਾਂ 'ਤੇ ਗੂਗਲ ਸਰਚ ਕਰੋ। . ਤੁਹਾਡੇ ਪ੍ਰਯੋਗ ਤੁਹਾਡੇ ਸੋਚਣ ਨਾਲੋਂ ਜਲਦੀ ਖਤਮ ਹੋ ਸਕਦੇ ਹਨ ਜੇਕਰ ਤੁਸੀਂ ਬੇਵਕੂਫੀ ਨਾਲ ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ ਕਰਦੇ ਹੋ।

ਸ਼ੁਰੂਆਤ

ਇੱਥੇ ਸਾਡੇ ਵੈਬ ਸਕ੍ਰੈਪਰ ਕੋਡ ਵਿੱਚ ਕੀ ਹੋਵੇਗਾ ਇਸ ਬਾਰੇ ਇੱਕ ਆਮ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਹੈ:

• ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੋ।
• ਇੱਕ ਗੂਗਲ ਕਰੋਮ ਟੈਬ ਖੋਲ੍ਹਣਾ।
• ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ ਜੋ ਬੋਟ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਸ਼ਹਿਰਾਂ ਅਤੇ ਤਾਰੀਖਾਂ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ ਜੋ ਟਿਕਟਾਂ ਦੀ ਖੋਜ ਕਰਨ ਵੇਲੇ ਵਰਤੇ ਜਾਣਗੇ।
• ਇਹ ਫੰਕਸ਼ਨ ਪਹਿਲੇ ਖੋਜ ਨਤੀਜੇ ਲੈਂਦਾ ਹੈ, ਸਭ ਤੋਂ ਵਧੀਆ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹੋਰ ਨਤੀਜੇ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਦਾ ਹੈ।
• ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਪੂਰੇ ਪੰਨੇ ਤੋਂ ਡੇਟਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਡੇਟਾ ਫਰੇਮ ਵਾਪਸ ਕਰਦਾ ਹੈ।
• ਦੋ ਪਿਛਲੇ ਪੜਾਅ ਟਿਕਟ ਦੀ ਕੀਮਤ (ਸਸਤੇ) ਅਤੇ ਉਡਾਣ ਦੀ ਗਤੀ (ਸਭ ਤੋਂ ਤੇਜ਼) ਦੁਆਰਾ ਲੜੀਬੱਧ ਕਿਸਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
• ਸਕ੍ਰਿਪਟ ਦੇ ਉਪਭੋਗਤਾ ਨੂੰ ਟਿਕਟ ਦੀਆਂ ਕੀਮਤਾਂ (ਸਸਤੀਆਂ ਟਿਕਟਾਂ ਅਤੇ ਔਸਤ ਕੀਮਤ) ਦੇ ਸੰਖੇਪ ਵਾਲੀ ਇੱਕ ਈਮੇਲ ਭੇਜੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਉਪਰੋਕਤ ਤਿੰਨ ਸੂਚਕਾਂ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਜਾਣਕਾਰੀ ਵਾਲਾ ਇੱਕ ਡੇਟਾ ਫਰੇਮ ਇੱਕ ਐਕਸਲ ਫਾਈਲ ਵਜੋਂ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਿਰਿਆਵਾਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਦੇ ਬਾਅਦ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਹਰੇਕ ਸੇਲੇਨਿਅਮ ਪ੍ਰੋਜੈਕਟ ਇੱਕ ਵੈਬ ਡਰਾਈਵਰ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ. ਮੈਂ ਵਰਤਦਾ ਕਰੋਮਡ੍ਰਾਈਵਰ, ਮੈਂ ਗੂਗਲ ਕਰੋਮ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹਾਂ, ਪਰ ਹੋਰ ਵਿਕਲਪ ਹਨ. ਫੈਂਟਮਜੇਐਸ ਅਤੇ ਫਾਇਰਫਾਕਸ ਵੀ ਪ੍ਰਸਿੱਧ ਹਨ। ਡਰਾਈਵਰ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਉਚਿਤ ਫੋਲਡਰ ਵਿੱਚ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਅਤੇ ਇਹ ਇਸਦੀ ਵਰਤੋਂ ਲਈ ਤਿਆਰੀ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ. ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਦੀਆਂ ਪਹਿਲੀਆਂ ਲਾਈਨਾਂ ਇੱਕ ਨਵਾਂ ਕਰੋਮ ਟੈਬ ਖੋਲ੍ਹਦੀਆਂ ਹਨ।

ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਮੇਰੀ ਕਹਾਣੀ ਵਿੱਚ ਮੈਂ ਹਵਾਈ ਟਿਕਟਾਂ 'ਤੇ ਵਧੀਆ ਸੌਦੇ ਲੱਭਣ ਲਈ ਨਵੇਂ ਦਿਸ਼ਾਵਾਂ ਨੂੰ ਖੋਲ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹਾਂ। ਅਜਿਹੀਆਂ ਪੇਸ਼ਕਸ਼ਾਂ ਦੀ ਖੋਜ ਕਰਨ ਦੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਉੱਨਤ ਤਰੀਕੇ ਹਨ। ਮੈਂ ਇਸ ਸਮਗਰੀ ਦੇ ਪਾਠਕਾਂ ਨੂੰ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦਾ ਇੱਕ ਸਧਾਰਨ ਪਰ ਵਿਹਾਰਕ ਤਰੀਕਾ ਪੇਸ਼ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ।

ਇਹ ਉਹ ਕੋਡ ਹੈ ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਉੱਪਰ ਗੱਲ ਕੀਤੀ ਹੈ।

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 ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਦੋ ਜਾਂ ਤਿੰਨ ਤੋਂ ਵੱਧ ਵਾਰ, ਮੈਨੂੰ ਰੀਕੈਪਚਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੁਸ਼ਟੀਕਰਨ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਕਿਹਾ ਗਿਆ। ਤੁਸੀਂ ਇਸ ਚੈੱਕ ਨੂੰ ਹੱਥੀਂ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਦੋਂ ਤੱਕ ਪ੍ਰਯੋਗ ਕਰਨਾ ਜਾਰੀ ਰੱਖ ਸਕਦੇ ਹੋ ਜਦੋਂ ਤੱਕ ਸਿਸਟਮ ਇੱਕ ਨਵੀਂ ਜਾਂਚ ਚਲਾਉਣ ਦਾ ਫੈਸਲਾ ਨਹੀਂ ਕਰਦਾ। ਜਦੋਂ ਮੈਂ ਸਕ੍ਰਿਪਟ ਦੀ ਜਾਂਚ ਕੀਤੀ, ਤਾਂ ਅਜਿਹਾ ਲਗਦਾ ਸੀ ਕਿ ਪਹਿਲਾ ਖੋਜ ਸੈਸ਼ਨ ਹਮੇਸ਼ਾ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਚਲਦਾ ਸੀ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਕੋਡ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਖੋਜ ਸੈਸ਼ਨਾਂ ਦੇ ਵਿਚਕਾਰ ਲੰਬੇ ਅੰਤਰਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਦਸਤੀ ਜਾਂਚ ਅਤੇ ਕੋਡ ਨੂੰ ਚੱਲਣ ਦੇਣਾ ਹੋਵੇਗਾ। ਅਤੇ, ਜੇ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਸੋਚਦੇ ਹੋ, ਤਾਂ ਕਿਸੇ ਵਿਅਕਤੀ ਨੂੰ ਖੋਜ ਕਾਰਜਾਂ ਦੇ ਵਿਚਕਾਰ 10-ਮਿੰਟ ਦੇ ਅੰਤਰਾਲਾਂ 'ਤੇ ਪ੍ਰਾਪਤ ਟਿਕਟ ਦੀਆਂ ਕੀਮਤਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

XPath ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਪੰਨੇ ਨਾਲ ਕੰਮ ਕਰਨਾ

ਇਸ ਲਈ, ਅਸੀਂ ਇੱਕ ਵਿੰਡੋ ਖੋਲ੍ਹੀ ਅਤੇ ਸਾਈਟ ਨੂੰ ਲੋਡ ਕੀਤਾ. ਕੀਮਤ ਅਤੇ ਹੋਰ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਸਾਨੂੰ XPath ਤਕਨਾਲੋਜੀ ਜਾਂ CSS ਚੋਣਕਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਮੈਂ XPath ਨਾਲ ਜੁੜੇ ਰਹਿਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਅਤੇ CSS ਚੋਣਕਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਮਹਿਸੂਸ ਨਹੀਂ ਕੀਤੀ, ਪਰ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਨਾ ਕਾਫ਼ੀ ਸੰਭਵ ਹੈ। XPath ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਪੰਨੇ ਦੇ ਆਲੇ ਦੁਆਲੇ ਨੈਵੀਗੇਟ ਕਰਨਾ ਔਖਾ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਭਾਵੇਂ ਤੁਸੀਂ ਉਹਨਾਂ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਵਰਣਨ ਕੀਤਾ ਹੈ ਇਹ ਲੇਖ, ਜਿਸ ਵਿੱਚ ਪੰਨਾ ਕੋਡ ਤੋਂ ਸੰਬੰਧਿਤ ਪਛਾਣਕਰਤਾਵਾਂ ਦੀ ਨਕਲ ਕਰਨਾ ਸ਼ਾਮਲ ਸੀ, ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਇਹ ਅਸਲ ਵਿੱਚ, ਲੋੜੀਂਦੇ ਤੱਤਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦਾ ਅਨੁਕੂਲ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਤਰੀਕੇ ਨਾਲ, ਵਿਚ ਇਹ ਕਿਤਾਬ XPath ਅਤੇ CSS ਚੋਣਕਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪੰਨਿਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਦਾ ਸ਼ਾਨਦਾਰ ਵਰਣਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਇਹ ਉਹੀ ਹੈ ਜੋ ਅਨੁਸਾਰੀ ਵੈੱਬ ਡਰਾਈਵਰ ਢੰਗ ਦਿਸਦਾ ਹੈ।

ਇਸ ਲਈ, ਆਓ ਬੋਟ 'ਤੇ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖੀਏ। ਆਉ ਸਭ ਤੋਂ ਸਸਤੀਆਂ ਟਿਕਟਾਂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰੀਏ। ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵਿੱਚ, XPath ਚੋਣਕਾਰ ਕੋਡ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੋਡ ਨੂੰ ਦੇਖਣ ਲਈ, ਤੁਹਾਨੂੰ ਉਸ ਪੰਨੇ ਦੇ ਤੱਤ 'ਤੇ ਸੱਜਾ-ਕਲਿਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ ਅਤੇ ਦਿਖਾਈ ਦੇਣ ਵਾਲੇ ਮੀਨੂ ਤੋਂ ਜਾਂਚ ਕਮਾਂਡ ਦੀ ਚੋਣ ਕਰੋ। ਇਸ ਕਮਾਂਡ ਨੂੰ ਵੱਖ-ਵੱਖ ਪੰਨਿਆਂ ਦੇ ਤੱਤਾਂ ਲਈ ਬੁਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਦਾ ਕੋਡ ਕੋਡ ਵਿਊਅਰ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਅਤੇ ਉਜਾਗਰ ਕੀਤਾ ਜਾਵੇਗਾ।

ਪੰਨਾ ਕੋਡ ਵੇਖੋ

ਕੋਡ ਤੋਂ ਚੋਣਕਾਰਾਂ ਦੀ ਨਕਲ ਕਰਨ ਦੇ ਨੁਕਸਾਨਾਂ ਬਾਰੇ ਮੇਰੇ ਤਰਕ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵੱਲ ਧਿਆਨ ਦਿਓ।

ਜਦੋਂ ਤੁਸੀਂ ਕੋਡ ਦੀ ਨਕਲ ਕਰਦੇ ਹੋ ਤਾਂ ਇਹ ਤੁਹਾਨੂੰ ਮਿਲਦਾ ਹੈ:

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

ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਨਕਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕੋਡ ਦੇ ਉਸ ਭਾਗ 'ਤੇ ਸੱਜਾ-ਕਲਿਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ ਅਤੇ ਦਿਖਾਈ ਦੇਣ ਵਾਲੇ ਮੀਨੂ ਤੋਂ ਕਾਪੀ > ਕਾਪੀ ਕਰੋ XPath ਕਮਾਂਡ ਨੂੰ ਚੁਣੋ।

ਇਹ ਉਹ ਹੈ ਜੋ ਮੈਂ ਸਭ ਤੋਂ ਸਸਤੇ ਬਟਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਸੀ:

cheap_results = ‘//a[@data-code = "price"]’

ਕਮਾਂਡ ਕਾਪੀ ਕਰੋ > XPath ਕਾਪੀ ਕਰੋ

ਇਹ ਬਿਲਕੁਲ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਦੂਜਾ ਵਿਕਲਪ ਬਹੁਤ ਸੌਖਾ ਲੱਗਦਾ ਹੈ. ਜਦੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਇੱਕ ਐਲੀਮੈਂਟ a ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਗੁਣ ਹੁੰਦਾ ਹੈ data-codeਦੇ ਬਰਾਬਰ price. ਪਹਿਲੇ ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਤੱਤ ਦੀ ਖੋਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ id ਜੋ ਕਿ ਬਰਾਬਰ ਹੈ wtKI-price_aTab, ਅਤੇ ਤੱਤ ਦਾ XPath ਮਾਰਗ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ /div[1]/div/div/div[1]/div/span/span. ਇੱਕ ਪੰਨੇ ਲਈ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਇੱਕ XPath ਪੁੱਛਗਿੱਛ ਟ੍ਰਿਕ ਕਰੇਗੀ, ਪਰ ਸਿਰਫ ਇੱਕ ਵਾਰ। ਮੈਂ ਹੁਣੇ ਇਹ ਕਹਿ ਸਕਦਾ ਹਾਂ id ਅਗਲੀ ਵਾਰ ਪੰਨਾ ਲੋਡ ਹੋਣ 'ਤੇ ਬਦਲ ਜਾਵੇਗਾ। ਅੱਖਰ ਕ੍ਰਮ wtKI ਹਰ ਵਾਰ ਜਦੋਂ ਪੰਨਾ ਲੋਡ ਹੁੰਦਾ ਹੈ ਤਾਂ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਬਦਲਦਾ ਹੈ, ਇਸਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲਾ ਕੋਡ ਅਗਲੇ ਪੰਨੇ ਦੇ ਰੀਲੋਡ ਹੋਣ ਤੋਂ ਬਾਅਦ ਬੇਕਾਰ ਹੋ ਜਾਵੇਗਾ। ਇਸ ਲਈ XPath ਨੂੰ ਸਮਝਣ ਲਈ ਕੁਝ ਸਮਾਂ ਲਓ। ਇਹ ਗਿਆਨ ਤੁਹਾਡੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੇਵਾ ਕਰੇਗਾ।

ਹਾਲਾਂਕਿ, ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ XPath ਚੋਣਕਾਰਾਂ ਦੀ ਨਕਲ ਕਰਨਾ ਕਾਫ਼ੀ ਸਧਾਰਨ ਸਾਈਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਨਾਲ ਅਰਾਮਦੇਹ ਹੋ, ਤਾਂ ਇਸ ਵਿੱਚ ਕੁਝ ਵੀ ਗਲਤ ਨਹੀਂ ਹੈ.

ਹੁਣ ਆਓ ਇਸ ਬਾਰੇ ਸੋਚੀਏ ਕਿ ਜੇਕਰ ਤੁਹਾਨੂੰ ਇੱਕ ਸੂਚੀ ਦੇ ਅੰਦਰ, ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ ਸਾਰੇ ਖੋਜ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ। ਬਹੁਤ ਹੀ ਸਧਾਰਨ. ਹਰ ਨਤੀਜਾ ਇੱਕ ਕਲਾਸ ਦੇ ਨਾਲ ਇੱਕ ਵਸਤੂ ਦੇ ਅੰਦਰ ਹੁੰਦਾ ਹੈ resultWrapper. ਸਾਰੇ ਨਤੀਜਿਆਂ ਨੂੰ ਲੋਡ ਕਰਨਾ ਹੇਠਾਂ ਦਰਸਾਏ ਗਏ ਵਾਂਗ ਲੂਪ ਵਿੱਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਜੇ ਤੁਸੀਂ ਉਪਰੋਕਤ ਨੂੰ ਸਮਝਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਜ਼ਿਆਦਾਤਰ ਕੋਡ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਸਮਝ ਲੈਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸਦਾ ਅਸੀਂ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਾਂਗੇ. ਜਿਵੇਂ ਕਿ ਇਹ ਕੋਡ ਚੱਲਦਾ ਹੈ, ਅਸੀਂ ਕਿਸੇ ਕਿਸਮ ਦੇ ਮਾਰਗ-ਨਿਰਧਾਰਤ ਵਿਧੀ (XPath) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ (ਅਸਲ ਵਿੱਚ, ਉਹ ਤੱਤ ਜਿਸ ਵਿੱਚ ਨਤੀਜਾ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ) ਤੱਕ ਪਹੁੰਚ ਕਰਦੇ ਹਾਂ। ਇਹ ਤੱਤ ਦੇ ਪਾਠ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਰੱਖਣ ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ flight_containers, ਫਿਰ - flights_list).

ਪਹਿਲੀਆਂ ਤਿੰਨ ਲਾਈਨਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਅਸੀਂ ਸਾਫ਼-ਸਾਫ਼ ਉਹ ਸਭ ਕੁਝ ਦੇਖ ਸਕਦੇ ਹਾਂ ਜਿਸਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ। ਹਾਲਾਂਕਿ, ਸਾਡੇ ਕੋਲ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਹੋਰ ਦਿਲਚਸਪ ਤਰੀਕੇ ਹਨ। ਸਾਨੂੰ ਹਰੇਕ ਤੱਤ ਤੋਂ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਡੇਟਾ ਲੈਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਕੰਮ 'ਤੇ ਜਾਓ!

ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖਣ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਹੈ ਵਾਧੂ ਨਤੀਜੇ ਲੋਡ ਕਰਨਾ, ਇਸ ਲਈ ਅਸੀਂ ਇੱਥੋਂ ਸ਼ੁਰੂ ਕਰਾਂਗੇ। ਮੈਂ ਉਹਨਾਂ ਉਡਾਣਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਕਰਨਾ ਚਾਹਾਂਗਾ ਜਿਹਨਾਂ ਬਾਰੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ, ਸੇਵਾ ਵਿੱਚ ਸ਼ੱਕ ਪੈਦਾ ਕੀਤੇ ਬਿਨਾਂ, ਜੋ ਇੱਕ ਨਿਰੀਖਣ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਮੈਂ ਹਰ ਵਾਰ ਪੰਨਾ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣ 'ਤੇ ਇੱਕ ਵਾਰ ਹੋਰ ਨਤੀਜੇ ਲੋਡ ਕਰੋ ਬਟਨ ਨੂੰ ਦਬਾਉਦਾ ਹਾਂ। ਇਸ ਕੋਡ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਬਲਾਕ ਵੱਲ ਧਿਆਨ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ try, ਜੋ ਮੈਂ ਜੋੜਿਆ ਹੈ ਕਿਉਂਕਿ ਕਈ ਵਾਰ ਬਟਨ ਸਹੀ ਤਰ੍ਹਾਂ ਲੋਡ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਵੀ ਇਸਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਫੰਕਸ਼ਨ ਕੋਡ ਵਿੱਚ ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਕਾਲਾਂ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ start_kayak, ਜਿਸ ਨੂੰ ਅਸੀਂ ਹੇਠਾਂ ਦੇਖਾਂਗੇ।

# Загрузка большего количества результатов для того, чтобы максимизировать объём собираемых данных
def load_more():
    try:
        more_results = '//a[@class = "moreButton"]'
        driver.find_element_by_xpath(more_results).click()
        # Вывод этих заметок в ходе работы программы помогает мне быстро выяснить то, чем она занята
        print('sleeping.....')
        sleep(randint(45,60))
    except:
        pass

ਹੁਣ, ਇਸ ਫੰਕਸ਼ਨ ਦੇ ਲੰਬੇ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਬਾਅਦ (ਕਈ ਵਾਰ ਮੈਂ ਦੂਰ ਹੋ ਸਕਦਾ ਹਾਂ), ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਤਿਆਰ ਹਾਂ ਜੋ ਪੰਨੇ ਨੂੰ ਸਕ੍ਰੈਪ ਕਰੇਗਾ।

ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਸਭ ਤੋਂ ਵੱਧ ਇਕੱਠਾ ਕਰ ਲਿਆ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੈ page_scrape. ਕਈ ਵਾਰ ਵਾਪਸ ਕੀਤੇ ਮਾਰਗ ਡੇਟਾ ਨੂੰ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਮੈਂ ਇਸਨੂੰ ਵੱਖ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ। ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਮੈਂ ਪਹਿਲੀ ਵਾਰ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ section_a_list и section_b_list. ਸਾਡਾ ਫੰਕਸ਼ਨ ਇੱਕ ਡਾਟਾ ਫਰੇਮ ਦਿੰਦਾ ਹੈ flights_df, ਇਹ ਸਾਨੂੰ ਵੱਖ-ਵੱਖ ਡੇਟਾ ਛਾਂਟਣ ਦੇ ਤਰੀਕਿਆਂ ਤੋਂ ਪ੍ਰਾਪਤ ਨਤੀਜਿਆਂ ਨੂੰ ਵੱਖ ਕਰਨ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

def page_scrape():
    """This function takes care of the scraping part"""
    
    xp_sections = '//*[@class="section duration"]'
    sections = driver.find_elements_by_xpath(xp_sections)
    sections_list = [value.text for value in sections]
    section_a_list = sections_list[::2] # так мы разделяем информацию о двух полётах
    section_b_list = sections_list[1::2]
    
    # Если вы наткнулись на reCaptcha, вам может понадобиться что-то предпринять.
    # О том, что что-то пошло не так, вы узнаете исходя из того, что вышеприведённые списки пусты
    # это выражение if позволяет завершить работу программы или сделать ещё что-нибудь
    # тут можно приостановить работу, что позволит вам пройти проверку и продолжить скрапинг
    # я использую тут SystemExit так как хочу протестировать всё с самого начала
    if section_a_list == []:
        raise SystemExit
    
    # Я буду использовать букву A для уходящих рейсов и B для прибывающих
    a_duration = []
    a_section_names = []
    for n in section_a_list:
        # Получаем время
        a_section_names.append(''.join(n.split()[2:5]))
        a_duration.append(''.join(n.split()[0:2]))
    b_duration = []
    b_section_names = []
    for n in section_b_list:
        # Получаем время
        b_section_names.append(''.join(n.split()[2:5]))
        b_duration.append(''.join(n.split()[0:2]))

    xp_dates = '//div[@class="section date"]'
    dates = driver.find_elements_by_xpath(xp_dates)
    dates_list = [value.text for value in dates]
    a_date_list = dates_list[::2]
    b_date_list = dates_list[1::2]
    # Получаем день недели
    a_day = [value.split()[0] for value in a_date_list]
    a_weekday = [value.split()[1] for value in a_date_list]
    b_day = [value.split()[0] for value in b_date_list]
    b_weekday = [value.split()[1] for value in b_date_list]
    
    # Получаем цены
    xp_prices = '//a[@class="booking-link"]/span[@class="price option-text"]'
    prices = driver.find_elements_by_xpath(xp_prices)
    prices_list = [price.text.replace('$','') for price in prices if price.text != '']
    prices_list = list(map(int, prices_list))

    # stops - это большой список, в котором первый фрагмент пути находится по чётному индексу, а второй - по нечётному
    xp_stops = '//div[@class="section stops"]/div[1]'
    stops = driver.find_elements_by_xpath(xp_stops)
    stops_list = [stop.text[0].replace('n','0') for stop in stops]
    a_stop_list = stops_list[::2]
    b_stop_list = stops_list[1::2]

    xp_stops_cities = '//div[@class="section stops"]/div[2]'
    stops_cities = driver.find_elements_by_xpath(xp_stops_cities)
    stops_cities_list = [stop.text for stop in stops_cities]
    a_stop_name_list = stops_cities_list[::2]
    b_stop_name_list = stops_cities_list[1::2]
    
    # сведения о компании-перевозчике, время отправления и прибытия для обоих рейсов
    xp_schedule = '//div[@class="section times"]'
    schedules = driver.find_elements_by_xpath(xp_schedule)
    hours_list = []
    carrier_list = []
    for schedule in schedules:
        hours_list.append(schedule.text.split('n')[0])
        carrier_list.append(schedule.text.split('n')[1])
    # разделяем сведения о времени и о перевозчиках между рейсами a и b
    a_hours = hours_list[::2]
    a_carrier = carrier_list[1::2]
    b_hours = hours_list[::2]
    b_carrier = carrier_list[1::2]

    
    cols = (['Out Day', 'Out Time', 'Out Weekday', 'Out Airline', 'Out Cities', 'Out Duration', 'Out Stops', 'Out Stop Cities',
            'Return Day', 'Return Time', 'Return Weekday', 'Return Airline', 'Return Cities', 'Return Duration', 'Return Stops', 'Return Stop Cities',
            'Price'])

    flights_df = pd.DataFrame({'Out Day': a_day,
                               'Out Weekday': a_weekday,
                               'Out Duration': a_duration,
                               'Out Cities': a_section_names,
                               'Return Day': b_day,
                               'Return Weekday': b_weekday,
                               'Return Duration': b_duration,
                               'Return Cities': b_section_names,
                               'Out Stops': a_stop_list,
                               'Out Stop Cities': a_stop_name_list,
                               'Return Stops': b_stop_list,
                               'Return Stop Cities': b_stop_name_list,
                               'Out Time': a_hours,
                               'Out Airline': a_carrier,
                               'Return Time': b_hours,
                               'Return Airline': b_carrier,                           
                               'Price': prices_list})[cols]
    
    flights_df['timestamp'] = strftime("%Y%m%d-%H%M") # время сбора данных
    return flights_df

ਮੈਂ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਨਾਮ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਤਾਂ ਜੋ ਕੋਡ ਨੂੰ ਸਮਝਿਆ ਜਾ ਸਕੇ. ਯਾਦ ਰੱਖੋ ਕਿ ਵੇਰੀਏਬਲ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ a ਮਾਰਗ ਦੇ ਪਹਿਲੇ ਪੜਾਅ ਨਾਲ ਸਬੰਧਤ ਹੈ, ਅਤੇ b - ਦੂਜੇ ਨੂੰ. ਚਲੋ ਅਗਲੇ ਫੰਕਸ਼ਨ ਤੇ ਚਲਦੇ ਹਾਂ।

ਸਹਾਇਤਾ ਵਿਧੀ

ਸਾਡੇ ਕੋਲ ਹੁਣ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਸਾਨੂੰ ਵਾਧੂ ਖੋਜ ਨਤੀਜੇ ਲੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨਤੀਜਿਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ. ਇਹ ਲੇਖ ਇੱਥੇ ਖਤਮ ਹੋ ਸਕਦਾ ਸੀ, ਕਿਉਂਕਿ ਇਹ ਦੋ ਫੰਕਸ਼ਨ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਪੰਨਿਆਂ ਨੂੰ ਸਕ੍ਰੈਪ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਹਰ ਚੀਜ਼ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ। ਪਰ ਅਸੀਂ ਅਜੇ ਤੱਕ ਉੱਪਰ ਦੱਸੇ ਗਏ ਕੁਝ ਸਹਾਇਕ ਵਿਧੀਆਂ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਈਮੇਲਾਂ ਅਤੇ ਕੁਝ ਹੋਰ ਚੀਜ਼ਾਂ ਭੇਜਣ ਦਾ ਕੋਡ ਹੈ। ਇਹ ਸਭ ਫੰਕਸ਼ਨ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ start_kayak, ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਹੁਣ ਵਿਚਾਰ ਕਰਾਂਗੇ।

ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਸ਼ਹਿਰਾਂ ਅਤੇ ਮਿਤੀਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਇਹ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇੱਕ ਲਿੰਕ ਬਣਾਉਂਦਾ ਹੈ kayak, ਜਿਸਦੀ ਵਰਤੋਂ ਤੁਹਾਨੂੰ ਇੱਕ ਪੰਨੇ 'ਤੇ ਲੈ ਜਾਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਖੋਜ ਨਤੀਜੇ ਸ਼ਾਮਲ ਹੋਣਗੇ ਜੋ ਕਿ ਪੁੱਛਗਿੱਛ ਨਾਲ ਉਹਨਾਂ ਦੇ ਸਭ ਤੋਂ ਵਧੀਆ ਮੇਲ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕੀਤੇ ਜਾਣਗੇ। ਪਹਿਲੇ ਸਕ੍ਰੈਪਿੰਗ ਸੈਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਪੰਨੇ ਦੇ ਸਿਖਰ 'ਤੇ ਸਾਰਣੀ ਵਿੱਚ ਕੀਮਤਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਾਂਗੇ. ਅਰਥਾਤ, ਅਸੀਂ ਟਿਕਟ ਦੀ ਘੱਟੋ-ਘੱਟ ਕੀਮਤ ਅਤੇ ਔਸਤ ਕੀਮਤ ਦਾ ਪਤਾ ਲਗਾਵਾਂਗੇ। ਇਹ ਸਭ, ਸਾਈਟ ਦੁਆਰਾ ਜਾਰੀ ਕੀਤੀ ਭਵਿੱਖਬਾਣੀ ਦੇ ਨਾਲ, ਈਮੇਲ ਦੁਆਰਾ ਭੇਜਿਆ ਜਾਵੇਗਾ. ਪੰਨੇ 'ਤੇ, ਅਨੁਸਾਰੀ ਸਾਰਣੀ ਉੱਪਰਲੇ ਖੱਬੇ ਕੋਨੇ ਵਿੱਚ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਇਸ ਸਾਰਣੀ ਨਾਲ ਕੰਮ ਕਰਨਾ, ਵੈਸੇ, ਸਹੀ ਤਾਰੀਖਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਖੋਜ ਕਰਨ ਵੇਲੇ ਇੱਕ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਸਾਰਣੀ ਪੰਨੇ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

def start_kayak(city_from, city_to, date_start, date_end):
    """City codes - it's the IATA codes!
    Date format -  YYYY-MM-DD"""
    
    kayak = ('https://www.kayak.com/flights/' + city_from + '-' + city_to +
             '/' + date_start + '-flexible/' + date_end + '-flexible?sort=bestflight_a')
    driver.get(kayak)
    sleep(randint(8,10))
    
    # иногда появляется всплывающее окно, для проверки на это и его закрытия можно воспользоваться блоком try
    try:
        xp_popup_close = '//button[contains(@id,"dialog-close") and contains(@class,"Button-No-Standard-Style close ")]'
        driver.find_elements_by_xpath(xp_popup_close)[5].click()
    except Exception as e:
        pass
    sleep(randint(60,95))
    print('loading more.....')
    
#     load_more()
    
    print('starting first scrape.....')
    df_flights_best = page_scrape()
    df_flights_best['sort'] = 'best'
    sleep(randint(60,80))
    
    # Возьмём самую низкую цену из таблицы, расположенной в верхней части страницы
    matrix = driver.find_elements_by_xpath('//*[contains(@id,"FlexMatrixCell")]')
    matrix_prices = [price.text.replace('$','') for price in matrix]
    matrix_prices = list(map(int, matrix_prices))
    matrix_min = min(matrix_prices)
    matrix_avg = sum(matrix_prices)/len(matrix_prices)
    
    print('switching to cheapest results.....')
    cheap_results = '//a[@data-code = "price"]'
    driver.find_element_by_xpath(cheap_results).click()
    sleep(randint(60,90))
    print('loading more.....')
    
#     load_more()
    
    print('starting second scrape.....')
    df_flights_cheap = page_scrape()
    df_flights_cheap['sort'] = 'cheap'
    sleep(randint(60,80))
    
    print('switching to quickest results.....')
    quick_results = '//a[@data-code = "duration"]'
    driver.find_element_by_xpath(quick_results).click()  
    sleep(randint(60,90))
    print('loading more.....')
    
#     load_more()
    
    print('starting third scrape.....')
    df_flights_fast = page_scrape()
    df_flights_fast['sort'] = 'fast'
    sleep(randint(60,80))
    
    # Сохранение нового фрейма в Excel-файл, имя которого отражает города и даты
    final_df = df_flights_cheap.append(df_flights_best).append(df_flights_fast)
    final_df.to_excel('search_backups//{}_flights_{}-{}_from_{}_to_{}.xlsx'.format(strftime("%Y%m%d-%H%M"),
                                                                                   city_from, city_to, 
                                                                                   date_start, date_end), index=False)
    print('saved df.....')
    
    # Можно следить за тем, как прогноз, выдаваемый сайтом, соотносится с реальностью
    xp_loading = '//div[contains(@id,"advice")]'
    loading = driver.find_element_by_xpath(xp_loading).text
    xp_prediction = '//span[@class="info-text"]'
    prediction = driver.find_element_by_xpath(xp_prediction).text
    print(loading+'n'+prediction)
    
    # иногда в переменной loading оказывается эта строка, которая, позже, вызывает проблемы с отправкой письма
    # если это прозошло - меняем её на "Not Sure"
    weird = '¯_(ツ)_/¯'
    if loading == weird:
        loading = 'Not sure'
    
    username = '[email protected]'
    password = 'YOUR PASSWORD'

    server = smtplib.SMTP('smtp.outlook.com', 587)
    server.ehlo()
    server.starttls()
    server.login(username, password)
    msg = ('Subject: Flight Scrapernn
Cheapest Flight: {}nAverage Price: {}nnRecommendation: {}nnEnd of message'.format(matrix_min, matrix_avg, (loading+'n'+prediction)))
    message = MIMEMultipart()
    message['From'] = '[email protected]'
    message['to'] = '[email protected]'
    server.sendmail('[email protected]', '[email protected]', msg)
    print('sent email.....')

ਮੈਂ ਇੱਕ ਆਉਟਲੁੱਕ ਖਾਤੇ (hotmail.com) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਸਕ੍ਰਿਪਟ ਦੀ ਜਾਂਚ ਕੀਤੀ। ਮੈਂ ਇੱਕ ਜੀਮੇਲ ਖਾਤੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇਸਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਹੈ, ਇਹ ਈਮੇਲ ਸਿਸਟਮ ਕਾਫ਼ੀ ਮਸ਼ਹੂਰ ਹੈ, ਪਰ ਬਹੁਤ ਸਾਰੇ ਸੰਭਵ ਵਿਕਲਪ ਹਨ. ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ 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