ਜ਼ਿਆਦਾਤਰ ਲੋਕ ਜੋ ਆਪਣਾ ਪਹਿਲਾ Python ਟਿਊਟੋਰਿਅਲ ਖੋਲ੍ਹਦੇ ਹਨ, ਉਹ ਸਿੱਧਾ ਵੇਰੀਏਬਲਜ਼ (variables), ਲੂਪਸ (loops) ਅਤੇ ਕੁਝ ਮਹੱਤਵਪੂਰਨ ਬਣਾਉਣ ਵੱਲ ਵਧਣਾ ਚਾਹੁੰਦੇ ਹਨ। ਇਹ ਇੱਛਾ ਸਮਝਣਯੋਗ ਹੈ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਇਹ ਸਮਝਣ ਲਈ ਰੁਕਦੇ ਹੋ ਕਿ Python ਅਸਲ ਵਿੱਚ ਕੀ ਹੈ ਅਤੇ ਇਹ ਇਸਦੇ ਹੇਠਾਂ ਮੌਜੂਦ ਮਸ਼ੀਨ ਨਾਲ ਕਿਵੇਂ ਸਬੰਧਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਭਵਿੱਖ ਦੇ ਕੋਡ ਨੂੰ ਬਹੁਤ ਘੱਟ ਉਲਝਣ ਨਾਲ ਡੀਬੱਗ (debug) ਕਰ ਸਕੋਗੇ। ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਸਾਰੀਆਂ ਇੱਕੋ ਜਿਹੀਆਂ ਨਹੀਂ ਹੁੰਦੀਆਂ। ਉਹ ਅਬਸਟਰੈਕਸ਼ਨ (abstraction) ਦੇ ਵੱਖ-ਵੱਖ ਪੱਧਰਾਂ 'ਤੇ ਹੁੰਦੀਆਂ ਹਨ, ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਸਹੂਲਤ ਲਈ ਕੰਟਰੋਲ ਦਾ ਤਿਆਗ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਵੱਖ-ਵੱਖ ਮਾਰਗਾਂ ਰਾਹੀਂ ਪ੍ਰੋਸੈਸਰ ਤੱਕ ਪਹੁੰਚਦੀਆਂ ਹਨ। Python ਉਸ ਈਕੋਸਿਸਟਮ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਖਾਸ ਸਥਾਨ 'ਤੇ ਹੈ। ਉਸ ਸਥਾਨ ਨੂੰ ਸਮਝਣਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਿੱਖਣ ਵੱਲ ਪਹਿਲਾ ਅਸਲੀ ਕਦਮ ਹੈ।
ਭਾਸ਼ਾ ਦਾ ਪੌੜੀ-ਦਰਜਾ (Hierarchy): Python ਕਿੱਥੇ ਹੈ
ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਹਾਰਡਵੇਅਰ ਨਾਲ ਉਹਨਾਂ ਦੀ ਨੇੜਤਾ ਦੇ ਅਧਾਰ 'ਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਤਿੰਨ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।
High-level languages ਸਿਲੀਕਾਨ ਤੋਂ ਸਭ ਤੋਂ ਦੂਰ ਹੁੰਦੀਆਂ ਹਨ। Python ਇੱਥੇ Java ਅਤੇ JavaScript ਦੇ ਨਾਲ ਰਹਿੰਦਾ ਹੈ। ਇਹ ਭਾਸ਼ਾਵਾਂ ਅਜਿਹੀ ਸਿੰਟੈਕਸ (syntax) ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ ਜੋ ਮਨੁੱਖੀ ਭਾਸ਼ਾ ਵਰਗੀ ਹੁੰਦੀ ਹੈ। ਤੁਸੀਂ ਮੈਮੋਰੀ ਐਡਰੈੱਸਾਂ ਅਤੇ ਬਾਈਨਰੀ ਨਿਰਦੇਸ਼ਾਂ ਨਾਲ ਜੂਝਣ ਦੀ ਬਜਾਏ user_count = 5 ਜਾਂ print("Hello") ਲਿਖਦੇ ਹੋ। ਕਿਉਂਕਿ ਇਹ CPU, ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਅਤੇ ਚਿਪਸੈੱਟ ਦੇ ਅੰਤਰਾਂ ਨੂੰ ਅਬਸਟਰੈਕਟ (abstract) ਕਰ ਦਿੰਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਉਹੀ ਹਾਈ-ਲੈਵਲ ਕੋਡ ਅਕਸਰ ਬਹੁਤ ਘੱਟ ਜਾਂ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਅ ਦੇ Mac, Windows PC, ਜਾਂ Linux ਸਰਵਰ 'ਤੇ ਚੱਲ ਸਕਦਾ ਹੈ।
ਉਹ ਪੋਰਟੇਬਿਲਟੀ (portability) ਇੱਕ ਕੀਮਤ 'ਤੇ ਆਉਂਦੀ ਹੈ। High-level ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਇੱਕ ਅਨੁਵਾਦਕ (translator) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਹ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਨਹੀਂ ਚੱਲ ਸਕਦੀਆਂ। ਤੁਹਾਨੂੰ ਆਪਣੇ ਪੜ੍ਹਨਯੋਗ ਕੋਡ ਅਤੇ ਮਸ਼ੀਨ ਦੇ ਬਿਜਲੀ ਦੇ ਸੰਕੇਤਾਂ (electrical signals) ਵਿਚਕਾਰ ਪਾੜੇ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਇੱਕ ਕੰਪਾਈਲਰ (compiler) ਜਾਂ ਇੰਟਰਪ੍ਰੀਟਰ (interpreter) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸਦਾ ਫਾਇਦਾ ਵਿਕਾਸ ਦੀ ਰਫ਼ਤਾਰ ਹੈ। ਤੁਸੀਂ ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਹੀ ਉਪਯੋਗੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਣ ਲਈ ਸਿੱਧੇ ਹਾਰਡਵੇਅਰ ਕੰਟਰੋਲ ਦਾ ਤਿਆਗ ਕਰਦੇ ਹੋ।
Low-level languages ਦੂਜੇ ਪਾਸੇ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਅਸਲ ਵਿੱਚ ਮਸ਼ੀਨ ਕੋਡ ਹਨ — ਇੱਕ ਅਤੇ ਸਿਫ਼ਰ (ones and zeros) ਦੀਆਂ ਉਹ ਕੱਚੀਆਂ ਲੜੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸਰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸਮਝਦਾ ਹੈ। ਮਸ਼ੀਨ ਕੋਡ ਲਿਖਣ ਦਾ ਮਤਲਬ ਹੈ ਚਿੱਪ ਵਾਂਗ ਸੋਚਣਾ। ਤੁਸੀਂ ਇਹ ਫੈਸਲਾ ਕਰਦੇ ਹੋ ਕਿ ਕਿਹੜਾ ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਵਰਤਿਆ ਜਾਵੇਗਾ ਅਤੇ ਕਿਹੜਾ CPU ਰਜਿਸਟਰ ਕਿਸੇ ਖਾਸ ਮੁੱਲ (value) ਨੂੰ ਰੱਖੇਗਾ। ਹਾਰਡਵੇਅਰ ਤੁਰੰਤ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਅਨੁਵਾਦ ਦੇ ਆਗਿਆਕਾਰੀ ਹੁੰਦਾ ਹੈ।
ਇਸਦੀ ਕੀਮਤ ਭਿਆਨਕ ਜਟਿਲਤਾ ਹੈ। ਇੱਕ ਸਧਾਰਨ ਜੋੜ (addition) ਲਈ ਕਈ ਰਜਿਸਟਰਾਂ ਦੇ ਮੈਨੂਅਲ ਪ੍ਰਬੰਧਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ। ਇੱਕ ਗਲਤ ਬਿੱਟ ਪੂਰੇ ਸਿਸਟਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਮਦਦਗਾਰ ਐਰਰ ਮੈਸੇਜ ਦੇ ਕ੍ਰੈਸ਼ ਕਰ ਸਕਦਾ ਹੈ। ਸ਼ੁੱਧ ਮਸ਼ੀਨ ਕੋਡ ਹੁਣ ਲਗਭਗ ਕਦੇ ਵੀ ਹੱਥ ਨਾਲ ਨਹੀਂ ਲਿਖਿਆ ਜਾਂਦਾ, ਪਰ ਇਹ ਅਜੇ ਵੀ ਉਹ ਅੰਤਿਮ ਭਾਸ਼ਾ ਹੈ ਜੋ ਹਰ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬੋਲਣੀ ਪੈਂਦੀ ਹੈ।
Assembly languages ਇੱਕ ਤੰਗ ਵਿਚਕਾਰਲਾ ਰਾਹ ਲੈਂਦੀਆਂ ਹਨ। ਉਹ ਬਾਈਨਰੀ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ 'ਮਨੀਮੋਨਿਕਸ' (mnemonics) ਕੀਹਾ ਜਾਣ ਵਾਲੇ ਛੋਟੇ ਮਨੁੱਖੀ-ਪੜ੍ਹਨਯੋਗ ਪ੍ਰਤੀਕਾਂ ਨਾਲ ਬਦਲ ਦਿੰਦੀਆਂ ਹਨ। ਇੱਕ ਅਤੇ ਸਿਫ਼ਰ ਦੀ ਲੜੀ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਡਾਟਾ ਨੂੰ ਹਿਲਾਉਣ ਲਈ MOV ਜਾਂ ਜੋੜ ਕਰਨ ਲਈ ADD ਲਿਖ ਸਕਦੇ ਹੋ। ਇਹ ਪ੍ਰਤੀਕ ਕੱਚੇ ਬਾਈਨਰੀ ਨਾਲੋਂ ਯਾਦ ਰੱਖਣ ਵਿੱਚ ਆਸਾਨ ਹਨ, ਪਰ ਉਹ ਇੱਕ ਖਾਸ ਪ੍ਰੋਸੈਸਰ ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਮਜ਼ਬੂਤੀ ਨਾਲ ਜੁੜੇ ਰਹਿੰਦੇ ਹਨ। Intel x86 ਚਿੱਪ ਲਈ ਲਿਖਿਆ ਗਿਆ ਐਸੇਮਬਲੀ ਪ੍ਰੋਗਰਾਮ ARM ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਨਹੀਂ ਚੱਲੇਗਾ।
ਇੱਕ ਐਸੇਮਬਲਰ (assembler) ਇਹਨਾਂ ਮਨੀਮੋਨਿਕਸ ਨੂੰ ਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਐਸੇਮਬਲੀ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ Python ਨਾਲੋਂ ਕਿਤੇ ਜ਼ਿਆਦਾ ਕੰਟਰੋਲ ਦਿੰਦੀ ਹੈ, ਪਰ ਇਸ ਲਈ ਪ੍ਰੋਸੈਸਰ ਦੇ ਅੰਦਰੂਨੀ ਕੰਮਕਾਜ ਦੇ ਡੂੰਘੇ ਗਿਆਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਬਾਈਨਰੀ ਨਾਲੋਂ ਮਨੁੱਖੀ ਵਿਚਾਰਾਂ ਦੇ ਨੇੜੇ ਹੈ, ਫਿਰ ਵੀ ਪ੍ਰੋਸੈਸਰ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਗੱਲ ਕਰਦਾ ਹੈ।
ਕੋਡ ਕਾਰਵਾਈ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਦਾ ਹੈ
ਹਰ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅੰਤ ਵਿੱਚ ਮਸ਼ੀਨ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ ਬਦਲਣਾ ਪੈਂਦਾ ਹੈ। ਸੋਰਸ ਕੋਡ ਤੋਂ ਲੈ ਕੇ ਚੱਲ ਰਹੀ ਐਪਲੀਕੇਸ਼ਨ ਤੱਕ ਦਾ ਰਾਹ ਦੋ ਵਿੱਚੋਂ ਇੱਕ ਰਣਨੀਤੀ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ।
ਇੱਕ compiler ਤੁਹਾਡੇ ਪੂਰੇ ਕੋਡਬੇਸ ਨੂੰ ਇੱਕੋ ਵਾਰ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਸੌ ਲਾਈਨਾਂ ਵਾਲੀ ਫਾਈਲ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਕੁਝ ਵੀ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰੀਆਂ ਸੌ ਲਾਈਨਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ। ਇਹ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਪੰਜਾਹਵੀਂ ਲਾਈਨ 'ਤੇ ਕੋਈ ਗਲਤੀ ਮਿਲ ਗਈ? ਕੰਪਾਈਲਰ ਰੁਕ ਜਾਂਦਾ ਹੈ, ਸਮੱਸਿਆ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਦੋਂ ਤੱਕ ਚੱਲਣਯੋਗ ਪ੍ਰੋਗਰਾਮ ਬਣਾਉਣ ਤੋਂ ਇਨਕਾਰ ਕਰ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਸਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰ ਲੈਂਦੇ।
C ਅਤੇ C++ ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਇਸ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ। ਇਸਦਾ ਨਤੀਜਾ ਆਮ ਤੌਰ 'ਤੇ ਰਫ਼ਤਾਰ ਲਈ ਅਨੁਕੂਲਿਤ (optimized) ਇੱਕ ਸਟੈਂਡਅਲੋਨ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਕੰਪਾਈਲਰ ਪਹਿਲਾਂ ਹੀ ਪੂਰੇ ਕੋਡਬੇਸ ਦੀ ਬਾਰੀਕੀ ਨਾਲ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਪ੍ਰੋਗਰਾਮ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਗਲਤੀਆਂ ਦੀਆਂ ਪੂਰੀਆਂ ਸ਼੍ਰੇਣੀਆਂ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ। ਇਸਦਾ ਨੁ
ਇਹ ਡੀਬੱਗਿੰਗ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਇੰਟਰਪ੍ਰੀਟਰ ਦੇ ਨਾਲ, ਗਲਤੀਆਂ ਉਦੋਂ ਸਾਹਮਣੇ ਆਉਂਦੀਆਂ ਹਨ ਜਦੋਂ ਇੰਟਰਪ੍ਰੀਟਰ ਸਮੱਸਿਆ ਵਾਲੀ ਲਾਈਨ 'ਤੇ ਪਹੁੰਚਦਾ ਹੈ, ਉਸ ਤੋਂ ਪਹਿਲਾਂ ਨਹੀਂ। ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਅੱਸੀ ਲਾਈਨਾਂ ਤੱਕ ਬਿਲਕੁਲ ਸਹੀ ਚੱਲ ਸਕਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਕਾਸੀਵੀਂ ਲਾਈਨ 'ਤੇ ਕ੍ਰੈਸ਼ ਹੋ ਸਕਦਾ ਹੈ। ਉਹ ਤੁਰੰਤ ਪ੍ਰਤੀਕਿਰਿਆ ਇੰਟਰਪ੍ਰੀਟਰਾਂ ਨੂੰ ਸਿੱਖਣ ਲਈ ਵਧੇਰੇ ਸੁਖਾਲਾ ਬਣਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਪ੍ਰਯੋਗ ਕਰਦੇ ਹੋ, ਨਤੀਜੇ ਦੇਖਦੇ ਹੋ, ਅਤੇ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੇ ਹੋ। Python ਦਾ ਮਿਆਰੀ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ, CPython, ਅਸਲ ਵਿੱਚ ਇੱਕ ਹਾਈਬ੍ਰਿਡ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: ਇਹ ਤੁਹਾਡੇ ਸੋਰਸ ਨੂੰ bytecode ਵਿੱਚ ਕੰਪਾਈਲ ਕਰਦਾ ਹੈ, ਫਿਰ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਰਾਹੀਂ ਉਸ bytecode ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਭਾਵੇਂ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਇੱਕ ਟ੍ਰਾਂਸਲੇਸ਼ਨ ਸਟੈਪ ਹੁੰਦਾ ਹੈ, ਫਿਰ ਵੀ ਇਸਦਾ ਪ੍ਰਭਾਵ ਇੰਟਰਐਕਟਿਵ ਅਤੇ ਲਾਈਨ-ਦਰ-ਲਾਈਨ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।
Python ਨੂੰ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਕਿਉਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ
Python ਨੂੰ ਅਕਸਰ ਇੱਕ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਲੇਬਲ ਇਸਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਆਮ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਛੋਟੀ ਫਾਈਲ — ਇੱਕ ਸਕ੍ਰਿਪਟ — ਲਿਖਦੇ ਹੋ ਜੋ ਕਿਸੇ ਕੰਮ ਨੂੰ ਆਟੋਮੇਟ ਕਰਦੀ ਹੈ, ਟੈਕਸਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ, ਜਾਂ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਆਪਸ ਵਿੱਚ ਜੋੜਦੀ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਸਿੱਧਾ ਚਲਾਉਂਦੇ ਹੋ। ਇੰਟਰਪ੍ਰੀਟਰ ਇਸਨੂੰ ਤੁਰੰਤ ਟ੍ਰਾਂਸਲੇਟ ਕਰ ਦਿੰਦਾ ਹੈ। ਪ੍ਰਬੰਧ ਕਰਨ ਲਈ ਕੋਈ ਵੱਖਰਾ ਕੰਪਲੀਏਸ਼ਨ ਸਟੈਪ ਨਹੀਂ ਹੁੰਦਾ, ਅਤੇ ਨਾ ਹੀ ਟ੍ਰੈਕ ਕਰਨ ਲਈ ਕੋਈ ਬਿਲਡ ਆਰਟੀਫੈਕਟਸ ਹੁੰਦੇ ਹਨ।
ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਜਨਰਲ-ਪਰਪਜ਼ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿਚਕਾਰਲੀ ਲਕੀਰ ਕਾਫ਼ੀ ਧੁੰਦਲੀ ਹੋ ਗਈ ਹੈ। Python ਹੁਣ ਵੱਡੇ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ, ਡਾਟਾ ਸਾਇੰਸ ਪਾਈਪਲਾਈਨਾਂ ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਸਿਸਟਮਾਂ ਨੂੰ ਚਲਾ ਰਿਹਾ ਹੈ। ਫਿਰ ਵੀ, ਮੁੱਖ ਵਿਚਾਰ ਉਹੀ ਰਹਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਬਿਲਡ ਸਿਸਟਮ ਨੂੰ ਪ੍ਰਬੰਧ ਕਰਨ ਦੀ ਬਜਾਏ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦੇ ਹੋ। ਜਿਵੇਂ ਹੀ ਤੁਸੀਂ ਕਹਿੰਦੇ ਹੋ, ਇੰਟਰਪ੍ਰੀਟਰ ਤੁਹਾਡੀਆਂ ਹਦਾਇਤਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਰਹਿੰਦਾ ਹੈ।
ਇੱਕ ਮਜ਼ਬੂਤ ਨੀਂਹ ਬਣਾਉਣਾ ਜੋ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲੇ
ਇਹ ਅੰਤਰ ਸਿਰਫ਼ ਕਿਤਾਬੀ ਗਿਆਨ ਨਹੀਂ ਹਨ। ਇਹ ਉਸ ਵਿਵਹਾਰ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹਨ ਜਿਸਦਾ ਸਾਹਮਣਾ ਤੁਸੀਂ Python ਲਿਖਣ ਦੇ ਆਪਣੇ ਪਹਿਲੇ ਹਫ਼ਤੇ ਦੌਰਾਨ ਕਰੋਗੇ। ਜਦੋਂ Python ਚਾਲੂ ਹੋਣ ਦੌਰਾਨ SyntaxError ਦਿੰਦਾ ਹੈ, ਤਾਂ ਹੁਣ ਤੁਸੀਂ ਸਮਝਦੇ ਹੋ ਕਿ ਇੰਟਰਪ੍ਰੀਟਰ ਅਜਿਹੀ ਲਾਈਨ 'ਤੇ ਪਹੁੰਚ ਗਿਆ ਹੈ ਜਿਸਨੂੰ ਉਹ ਟ੍ਰਾਂਸਲੇਟ ਨਹੀਂ ਕਰ ਸਕਿਆ। ਜਦੋਂ ਤੁਸੀਂ ਪੜ੍ਹਦੇ ਹੋ ਕਿ ਕੁਝ ਖਾਸ ਕੰਮਾਂ ਲਈ Python, C ਨਾਲੋਂ ਹੌਲੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇੰਟਰਪ੍ਰੀਟੇਸ਼ਨ ਅਤੇ ਹਾਈ-ਲੈਵਲ ਐਬਸਟਰੈਕਸ਼ਨ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਸਮਝਦੇ ਹੋ। ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਨਾਲ .pyc ਫਾਈਲਾਂ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪਛਾਣਦੇ ਹੋ ਕਿ Python ਕੰਪਾਈਲਡ bytecode ਨੂੰ ਕੈਸ਼ ਕਰ ਰਿਹਾ ਹੈ ਤਾਂ ਜੋ ਹਰ ਵਾਰ ਤੁਹਾਡੀ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਦੁਬਾਰਾ ਇੰਟਰਪ੍ਰੀਟ ਨਾ ਕਰਨਾ ਪਵੇ।
ਭਾਸ਼ਾ ਦੇ ਪੱਧਰ ਵਿੱਚ Python ਕਿੱਥੇ ਹੈ, ਇਹ ਜਾਣਨਾ ਤੁਹਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਸਹੀ ਟੂਲ ਚੁਣਨ ਵਿੱਚ ਵੀ ਮਦਦ ਕਰਦਾ ਹੈ। ਕੀ ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ ਜਿੱਥੇ ਹਰ CPU ਸਾਈਕਲ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇ? ਤੁਸੀਂ ਸ਼ਾਇਦ C ਜਾਂ assembly ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ। ਕੀ ਤੁਹਾਨੂੰ ਇੱਕ ਦੁਪਹਿਰ ਵਿੱਚ CSV ਫਾਈਲ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਜਾਂ ਵੈੱਬ API ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ? Python ਦਾ ਇੰਟਰਪ੍ਰੀਟਰ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਸਿੰਟੈਕਸ ਬਿਲਕੁਲ ਇਸੇ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ।
ਅਸਲ ਸਿੱਖਿਆ
Python ਦੀ ਤਾਕਤ ਇਸਦੀ ਸਥਿਤੀ ਤੋਂ ਆਉਂਦੀ ਹੈ। ਇਹ ਹਾਰਡਵੇਅਰ ਤੋਂ ਕਾਫ਼ੀ ਉੱਪਰ ਹੈ, ਜਿਸ ਨੂੰ ਇੱਕ ਅਜਿਹੇ ਇੰਟਰਪ੍ਰੀਟਰ ਦੁਆਰਾ ਟ੍ਰਾਂਸਲੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਮਸ਼ੀਨ ਦੀ ਗਤੀ ਨਾਲੋਂ ਪ੍ਰੋਗਰਾਮਰ ਦੀ ਗਤੀ ਨੂੰ ਮਹੱਤਵ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਇਸ ਪਿਛੋਕੜ ਨੂੰ ਜਾਣੇ ਬਿਨਾਂ ਵੀ ਸਿੰਟੈਕਸ ਸਿੱਖ ਸਕਦੇ ਹੋ, ਪਰ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਅੰਦਰੂਨੀ ਮਸ਼ੀਨਰੀ ਨੂੰ ਨਹੀਂ ਸਮਝਦੇ, ਉਦੋਂ ਤੱਕ ਤੁਸੀਂ ਚਲਾਕੀ ਨਾਲ ਡੀਬੱਗ ਜਾਂ ਅਨੁਭਵ ਅਨੁਸਾਰ ਆਪਟੀਮਾਈਜ਼ ਨਹੀਂ ਕਰ ਸਕਦੇ। ਇਹਨਾਂ ਮੂਲ ਤੱਥਾਂ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੋ। ਜਦੋਂ ਤੁਸੀਂ ਆਪਣਾ ਪਹਿਲਾ ਅਸਲੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋਗੇ, ਤਾਂ ਤੁਸੀਂ ਸਿਰਫ਼ ਕਮਾਂਡਾਂ ਟਾਈਪ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋਵੋਗੇ। ਤੁਸੀਂ ਜਾਣੋਗੇ ਕਿ ਉਹ ਬਿਲਕੁਲ ਕਿਵੇਂ ਮਸ਼ੀਨ ਤੱਕ ਪਹੁੰਚਦੀਆਂ ਹਨ।