ਜਦਕਿ ਪਾਈਥਨ ਵਿੱਚ ਲੂਪ. ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਵਰਤੋਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ

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

ਇੱਕ ਚੱਕਰ ਦੀ ਧਾਰਨਾ

ਇੱਕ ਲੂਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਖਾਸ ਕਾਰਵਾਈ ਨੂੰ ਕਈ ਵਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਬਹੁਤ ਸਰਲ ਹੈ, ਕਿਉਂਕਿ ਅਸਲ ਵਿੱਚ ਸਾਈਕਲਾਂ ਲਈ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਰੇਂਜ ਬਹੁਤ ਵਿਆਪਕ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਦੋ ਮੁੱਖ ਕਿਸਮ ਦੇ ਲੂਪ ਹਨ: for ਅਤੇ while. ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਸਿੱਧ ਹੈ.

ਖਾਸ ਕਾਰਵਾਈਆਂ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਬਿੰਦੂ ਤੱਕ ਕੋਡ ਦੇ ਵੱਖ-ਵੱਖ ਟੁਕੜਿਆਂ ਨੂੰ ਲੂਪ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਵਾਰ ਹੋ ਸਕਦਾ ਹੈ, ਜਾਂ ਜਦੋਂ ਤੱਕ ਕੋਈ ਖਾਸ ਸਥਿਤੀ ਸਹੀ ਹੈ।

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਲੂਪਸ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ ਸ਼ੁਰੂ ਕਰੀਏ ਅਤੇ ਜਦੋਂ ਕਿ, ਖਾਸ ਤੌਰ 'ਤੇ, ਸਾਨੂੰ ਅਜੇ ਵੀ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਦੁਹਰਾਓ ਕੀ ਹੈ। ਇਹ ਵਰਤਮਾਨ ਐਪਲੀਕੇਸ਼ਨ ਰਨ ਦੇ ਅੰਦਰ ਮੌਜੂਦਾ ਚੱਕਰ ਦੇ ਦੌਰਾਨ ਇੱਕ ਕਿਰਿਆ ਜਾਂ ਕਿਰਿਆਵਾਂ ਦੇ ਕ੍ਰਮ ਦਾ ਇੱਕ ਦੁਹਰਾਓ ਹੈ।

ਲਈ ਸਾਈਕਲ

ਸਾਡਾ ਫਾਰ ਲੂਪ ਇੱਕ ਕਾਊਂਟਰ ਨਹੀਂ ਹੈ, ਜਿਵੇਂ ਕਿ ਹੋਰ ਬਹੁਤ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ। ਇਸਦਾ ਕੰਮ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਨਿਸ਼ਚਿਤ ਕ੍ਰਮ ਦੀ ਗਿਣਤੀ ਕਰਨਾ ਹੈ। ਇਸਦਾ ਕੀ ਮਤਲਬ ਹੈ? ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਤੱਤਾਂ ਦੀ ਸੂਚੀ ਹੈ। ਪਹਿਲਾਂ, ਲੂਪ ਪਹਿਲੀ, ਦੂਜੀ, ਤੀਜੀ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੋਰ ਲੈਂਦਾ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ ਇਸ ਲੂਪ ਦਾ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਹ ਜਾਣਨ ਲਈ ਤੱਤ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ ਕਿ ਲੂਪ ਤੋਂ ਕਦੋਂ ਬਾਹਰ ਜਾਣਾ ਹੈ। ਸਭ ਕੁਝ ਆਪਣੇ ਆਪ ਹੀ ਹੋ ਜਾਵੇਗਾ।

>>> ਸਪਿਸੋਕ = [10, 40, 20, 30]

>>> ਸਪਿਸੋਕ ਵਿੱਚ ਤੱਤ ਲਈ:

… ਪ੍ਰਿੰਟ (ਤੱਤ + 2)

...

12

42

22

32

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

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਸੂਚੀ 10,40,20,30 ਨੰਬਰਾਂ ਦਾ ਕ੍ਰਮ ਹੈ। ਹਰੇਕ ਦੁਹਰਾਅ ਤੇ, ਅਨੁਸਾਰੀ ਮੁੱਲ ਵੇਰੀਏਬਲ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜਿਵੇਂ ਹੀ ਲੂਪ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਵੇਰੀਏਬਲ ਤੱਤ ਮੁੱਲ 10 ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਅਗਲੀ ਦੁਹਰਾਓ 'ਤੇ, ਦਸ ਨੰਬਰ 40 ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ, ਤੀਜੀ ਵਾਰ ਇਹ ਸੰਖਿਆ 20 ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅੰਤ ਵਿੱਚ, ਲੂਪ ਦੀ ਆਖਰੀ ਦੁਹਰਾਓ 'ਤੇ, ਇਹ 30 ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ।

ਚੱਕਰ ਦੇ ਅੰਤ ਲਈ ਸੰਕੇਤ ਸੂਚੀ ਵਿੱਚ ਤੱਤ ਦਾ ਅੰਤ ਹੈ.

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

>>> ਸਪਿਸੋਕ = [1,2,3,4,5]

ਜਾਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ len(), ਸੂਚੀ ਦੀ ਲੰਬਾਈ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ. ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ ਜਦਕਿ, ਕਿਉਂਕਿ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।

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

ਜਦੋਂ ਕਿ ਲੂਪ

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

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

ਜੇਕਰ ਅਸੀਂ ਇੱਕ ਚੱਕਰ ਖਿੱਚਦੇ ਹਾਂ ਜਦਕਿ ਸਧਾਰਨ ਰੂਪ ਵਿੱਚ, ਇਹ ਅਜਿਹੀ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

ਚੱਕਰ ਜਦਕਿ ਨਤੀਜੇ ਵਜੋਂ ਦੋ ਅਪਵਾਦ ਹੋ ਸਕਦੇ ਹਨ:

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

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

ਜਦਕਿ ਲੂਪ ਉਦਾਹਰਨਾਂ

ਇੱਥੇ ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜੋ ਇਸ ਕੇਸ ਵਿੱਚ ਇੱਕ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।

n = ਇੰਪੁੱਟ ("ਇੱਕ ਪੂਰਨ ਅੰਕ ਦਰਜ ਕਰੋ: ") 

ਜਦਕਿ ਟਾਈਪ(n) != int:

    ਕੋਸ਼ਿਸ਼ ਕਰੋ:

        n = int(n)

    ਵੈਲਯੂਅਰਰ ਨੂੰ ਛੱਡ ਕੇ:

        ਪ੍ਰਿੰਟ ("ਗਲਤ ਐਂਟਰੀ!")

        n = ਇੰਪੁੱਟ ("ਇੱਕ ਪੂਰਨ ਅੰਕ ਦਰਜ ਕਰੋ: ") 

ਜੇਕਰ n % 2 == 0:

    ਪ੍ਰਿੰਟ ("ਵੀ")

ਹੋਰ:

    ਪ੍ਰਿੰਟ ("ਅਜੀਬ")

ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਪਾਇਥਨ ਗੁੰਝਲਦਾਰ ਕੋਡ ਨਿਰਮਾਣ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਕੋਲੋਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

ਉਪਰੋਕਤ ਕੋਡ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸ਼ਰਤ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ਕਿ ਸਾਨੂੰ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਕਿ ਕੀ ਨੰਬਰ ਇੱਕ ਪੂਰਨ ਅੰਕ ਹੈ। ਜੇਕਰ ਹਾਂ, ਤਾਂ ਗਲਤ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ ਨਹੀਂ, ਤਾਂ ਸੱਚ.

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

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

ਭਾਵ, ਲੂਪ ਨਿਯਮਤ ਤੌਰ 'ਤੇ ਉਦੋਂ ਤੱਕ ਚਲਾਇਆ ਜਾਵੇਗਾ ਜਦੋਂ ਤੱਕ ਸਥਿਤੀ ਨਹੀਂ ਆਉਂਦੀ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ. 

ਭਾਵ, ਤੁਸੀਂ ਇਸਦੇ ਉਲਟ ਜਾ ਸਕਦੇ ਹੋ: ਇੱਕ ਖਾਸ ਕਾਰਵਾਈ ਨੂੰ ਉਦੋਂ ਤੱਕ ਲੂਪ ਕਰੋ ਜਦੋਂ ਤੱਕ ਘਟਨਾ ਗਲਤ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।

ਕੋਡ ਪਾਰਸਿੰਗ

ਆਓ ਹੁਣ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ ਕਿ ਇਹ ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਇਸ ਦਾ ਕਦਮ-ਦਰ-ਕਦਮ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਾਂਗੇ।

1. ਪਹਿਲਾਂ, ਉਪਭੋਗਤਾ ਇੱਕ ਸਤਰ ਦਾਖਲ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਵੇਰੀਏਬਲ n ਦੁਆਰਾ ਸਵੀਕਾਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। 
2. ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਦਕਿ ਇਸ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਹੈ। ਪਹਿਲੀ ਐਂਟਰੀ 'ਤੇ, ਇਹ ਬਰਾਬਰ ਨਹੀਂ ਹੈ ਇੰਟ. ਇਸ ਲਈ, ਟੈਸਟ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹ ਸਥਿਤੀ ਸੱਚ ਹੈ. ਇਸਲਈ, ਲੂਪ ਬਾਡੀ ਨੂੰ ਦਾਖਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
3. ਇੱਕ ਆਪਰੇਟਰ ਦੀ ਮਦਦ ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਅਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਾਂ। ਜੇਕਰ ਅਜਿਹਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦੀ। ਇਸ ਅਨੁਸਾਰ, ਇਸ 'ਤੇ ਕਾਰਵਾਈ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ. ਇਸ ਲਈ, ਦੁਭਾਸ਼ੀਏ ਲੂਪ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਵਾਪਸ ਆਉਂਦਾ ਹੈ, ਅਤੇ ਜਾਂਚ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹ ਇੱਕ ਪੂਰਨ ਅੰਕ ਬਣ ਗਿਆ ਹੈ। ਤਾਂ ਆਓ ਕਦਮ 7 'ਤੇ ਚੱਲੀਏ
4. ਜੇਕਰ ਪਰਿਵਰਤਨ ਅਸਫਲ ਰਿਹਾ, ਤਾਂ ਇੱਕ ValueError ਸੁੱਟ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵਾਹ ਸਿਵਾਏ ਹੈਂਡਲਰ ਨੂੰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।
5. ਉਪਭੋਗਤਾ ਇੱਕ ਨਵਾਂ ਮੁੱਲ ਦਾਖਲ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਵੇਰੀਏਬਲ n ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ।
6. ਦੁਭਾਸ਼ੀਏ ਕਦਮ 2 'ਤੇ ਵਾਪਸ ਆਉਂਦਾ ਹੈ ਅਤੇ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਇਹ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਹੈ, ਤਾਂ ਕਦਮ 7 'ਤੇ ਜਾਓ। ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਪੜਾਅ 3 ਦੇ ਅਨੁਸਾਰ ਪਰਿਵਰਤਨ ਦੀ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
7. ਇੱਕ ਆਪਰੇਟਰ ਦੀ ਮਦਦ ਨਾਲ if ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕਿਸੇ ਸੰਖਿਆ ਨੂੰ 2 ਨਾਲ ਭਾਗ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕੋਈ ਬਾਕੀ ਬਚਦਾ ਹੈ। 
8. ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਟੈਕਸਟ "ਵੀ" ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
9. ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਟੈਕਸਟ "ਅਜੀਬ" ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਹੁਣ ਅਜਿਹੀ ਇੱਕ ਉਦਾਹਰਣ ਉੱਤੇ ਗੌਰ ਕਰੋ। ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕਿ ਇਹ ਚੱਕਰ ਕਿੰਨੀ ਵਾਰ ਲੰਘੇਗਾ?

ਕੁੱਲ = 100 

ਮੈਂ = 0

ਜਦੋਂ ਮੈਂ <5:

    n = int(ਇਨਪੁਟ())

    ਕੁੱਲ = ਕੁੱਲ — n

    i = i + 1 

ਪ੍ਰਿੰਟ ("ਬਾਕੀ", ਕੁੱਲ)

ਸਹੀ ਜਵਾਬ 5 ਹੈ। ਸ਼ੁਰੂ ਵਿੱਚ, ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ i - ਜ਼ੀਰੋ। ਦੁਭਾਸ਼ੀਏ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵੇਰੀਏਬਲ ਬਰਾਬਰ ਹੈ i 4 ਜਾਂ ਘੱਟ। ਜੇਕਰ ਹਾਂ, ਤਾਂ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸੱਚ ਹੈ,, ਅਤੇ ਲੂਪ ਉਸ ਅਨੁਸਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਮੁੱਲ ਇੱਕ ਦੁਆਰਾ ਵਧਾਇਆ ਗਿਆ ਹੈ.

ਪਹਿਲੀ ਦੁਹਰਾਓ ਤੋਂ ਬਾਅਦ, ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ 1 ਬਣ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਸਮਝਦਾ ਹੈ ਕਿ ਇਹ ਸੰਖਿਆ ਦੁਬਾਰਾ 5 ਤੋਂ ਘੱਟ ਹੈ। ਇਸ ਅਨੁਸਾਰ, ਲੂਪ ਬਾਡੀ ਨੂੰ ਦੂਜੀ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਕਿਉਂਕਿ ਸਟੈਪਸ ਸਮਾਨ ਹਨ, ਮੁੱਲ ਵੀ ਇੱਕ ਨਾਲ ਵਧਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਵੇਰੀਏਬਲ ਹੁਣ 2 ਦੇ ਬਰਾਬਰ ਹੈ।

ਇਹ ਮੁੱਲ ਵੀ ਪੰਜ ਤੋਂ ਘੱਟ ਹੈ। ਫਿਰ ਲੂਪ ਨੂੰ ਤੀਜੀ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਵੇਰੀਏਬਲ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ i 1 ਅਤੇ ਇਸ ਨੂੰ ਮੁੱਲ 3 ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਹ ਦੁਬਾਰਾ ਪੰਜ ਤੋਂ ਘੱਟ ਹੈ। ਅਤੇ ਇਸ ਲਈ ਇਹ ਲੂਪ ਦੇ ਛੇਵੇਂ ਦੁਹਰਾਅ 'ਤੇ ਆਉਂਦਾ ਹੈ, ਜਿਸ 'ਤੇ ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ i ਬਰਾਬਰ 5 (ਆਖ਼ਰਕਾਰ, ਇਹ ਅਸਲ ਵਿੱਚ ਜ਼ੀਰੋ ਸੀ, ਜਿੱਥੋਂ ਤੱਕ ਸਾਨੂੰ ਯਾਦ ਹੈ)। ਇਸ ਅਨੁਸਾਰ, ਇਹ ਸਥਿਤੀ ਟੈਸਟ ਪਾਸ ਨਹੀਂ ਕਰਦੀ ਹੈ, ਅਤੇ ਲੂਪ ਆਪਣੇ ਆਪ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਤਬਦੀਲੀ, ਜੋ ਕਿ ਇਸ ਤੋਂ ਬਾਹਰ ਹੈ (ਜਾਂ ਪ੍ਰੋਗਰਾਮ ਸਮਾਪਤੀ, ਜੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤੇ ਗਏ ਹਨ), ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਚੱਕਰ ਉਲਟ ਦਿਸ਼ਾ ਵਿੱਚ ਵੀ ਹੋ ਸਕਦਾ ਹੈ. ਇੱਥੇ ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜਿੱਥੇ, ਹਰੇਕ ਬਾਅਦ ਦੇ ਦੁਹਰਾਓ ਦੇ ਨਾਲ, ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੌਜੂਦਾ ਮੁੱਲ ਤੋਂ ਘਟਾਇਆ ਜਾਂਦਾ ਹੈ। 

ਕੁੱਲ = 100 

ਜਦੋਂ ਕਿ ਕੁੱਲ > 0:

    n = int(ਇਨਪੁਟ())

    ਕੁੱਲ = ਕੁੱਲ — n 

ਪ੍ਰਿੰਟ ("ਸਰੋਤ ਖਤਮ")

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

ਅਤੇ ਹੁਣ ਹੋਮਵਰਕ. ਉਪਰੋਕਤ ਕੋਡ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਤਾਂ ਜੋ ਵੇਰੀਏਬਲ ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਨਕਾਰਾਤਮਕ ਨਾ ਬਣ ਸਕੇ।