ਸਮੱਗਰੀ
ਪ੍ਰੋਗਰਾਮ ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, ਅਕਸਰ ਅਜਿਹੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ ਜੋ ਅਸਲ ਜੀਵਨ ਵਿੱਚ ਲਾਗੂ ਕਰਨਾ ਇੰਨਾ ਆਸਾਨ ਨਹੀਂ ਹੁੰਦਾ। ਆਖ਼ਰਕਾਰ, ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਤੁਹਾਨੂੰ ਕੁਝ ਸ਼ਰਤਾਂ ਅਧੀਨ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨੀ ਪੈਂਦੀ ਹੈ. ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਾਂ ਹਨ। ਉਹਨਾਂ ਦੀ ਮਦਦ ਨਾਲ, ਤੁਸੀਂ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰ ਸਕਦੇ ਹੋ, ਲੂਪਸ ਬਣਾ ਸਕਦੇ ਹੋ ਜਾਂ ਕੁਝ ਕਿਰਿਆਵਾਂ ਕਰ ਸਕਦੇ ਹੋ ਜਦੋਂ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਸਹੀ ਹੋਵੇ।
ਅੱਜ ਅਸੀਂ if ਸਟੇਟਮੈਂਟ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ, ਜੋ ਕਿਸੇ ਖਾਸ ਸਥਿਤੀ ਲਈ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਅਧਾਰ ਤੇ, ਅਗਲੀਆਂ ਕਾਰਵਾਈਆਂ ਬਾਰੇ ਫੈਸਲੇ ਕਰਦਾ ਹੈ।
ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਾਂ ਦੀਆਂ ਕਿਸਮਾਂ
ਆਮ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਇਕੋ ਇਕ ਬਿਆਨ ਨਹੀਂ ਹੈ ਜੋ ਪ੍ਰੋਗਰਾਮ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ. ਨਾਲ ਹੀ ਉਹ ਆਪ ਆਪਰੇਟਰਾਂ ਦੀ ਇੱਕ ਵੱਡੀ ਲੜੀ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੋ ਸਕਦਾ ਹੈ।
ਲੂਪ ਅਤੇ ਸਟੇਟਮੈਂਟਸ ਵੀ ਹਨ ਜੋ ਇਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹਨ। ਅੱਜ ਅਸੀਂ ਸਿਰਫ ਕੰਡੀਸ਼ਨਲ ਓਪਰੇਟਰ ਅਤੇ ਉਹਨਾਂ ਚੇਨਾਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ ਜਿਸ ਵਿੱਚ ਇਹ ਹਿੱਸਾ ਲੈ ਸਕਦਾ ਹੈ.
ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ, ਬ੍ਰਾਂਚਿੰਗ ਵਰਗੀ ਇੱਕ ਚੀਜ਼ ਹੈ. ਇਹ ਬਿਲਕੁਲ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕਮਾਂਡਾਂ ਦਾ ਇੱਕ ਕ੍ਰਮ ਜੋ ਸਿਰਫ ਤਾਂ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਸਹੀ ਹੈ। ਮਾਪਦੰਡ ਆਪਣੇ ਆਪ ਵਿੱਚ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ:
- ਕਿਸੇ ਖਾਸ ਮੁੱਲ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਸਮਾਨਤਾ।
- ਇੱਕ ਖਾਸ ਕਾਰਵਾਈ ਕਰਨਾ.
- ਐਪਲੀਕੇਸ਼ਨ ਸਥਿਤੀ (ਸਮੇਟਿਆ ਜਾਂ ਨਹੀਂ)।
ਸਪੈਕਟ੍ਰਮ ਬਹੁਤ ਵੱਡਾ ਹੋ ਸਕਦਾ ਹੈ। ਸ਼ਰਤੀਆ ਬਿਆਨ ਕਈ ਕਿਸਮਾਂ ਵਿੱਚ ਆਉਂਦੇ ਹਨ:
- ਇੱਕ ਸ਼ਾਖਾ ਦੇ ਨਾਲ. ਭਾਵ, ਇੱਕ ਸਿੰਗਲ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕੁਝ ਕਿਰਿਆਵਾਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ.
- ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਸ਼ਾਖਾਵਾਂ ਦੇ ਨਾਲ. ਜੇਕਰ ਮਾਪਦੰਡ 1 ਸਹੀ ਹੈ, ਤਾਂ ਮਾਪਦੰਡ 2 ਦੀ ਜਾਂਚ ਕਰੋ। ਜੇਕਰ ਇਹ ਸਹੀ ਹੈ, ਤਾਂ 3 ਦੀ ਜਾਂਚ ਕਰੋ। ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ, ਲੋੜ ਅਨੁਸਾਰ ਜਿੰਨੀਆਂ ਵੀ ਜਾਂਚਾਂ ਕਰੋ।
- ਕਈ ਸ਼ਰਤਾਂ ਦੇ ਨਾਲ. ਇੱਥੇ ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ. ਦੁਭਾਸ਼ੀਏ ਕਈ ਸ਼ਰਤਾਂ ਜਾਂ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।
ਜੇਕਰ ਬਿਆਨ
if ਸਟੇਟਮੈਂਟ ਦੀ ਬਣਤਰ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਸਮਾਨ ਹੈ। ਹਾਲਾਂਕਿ, ਪਾਈਥਨ ਵਿੱਚ, ਇਸਦਾ ਸੰਟੈਕਸ ਬਾਕੀ ਸਾਰੇ ਨਾਲੋਂ ਕੁਝ ਵੱਖਰਾ ਹੈ:
ਜੇਕਰ ਹਾਲਤ:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
ਪਹਿਲਾਂ, ਆਪਰੇਟਰ ਨੂੰ ਖੁਦ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਕਿਸ ਸਥਿਤੀ ਦੇ ਅਧੀਨ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ. ਸਥਿਤੀ ਸਹੀ ਜਾਂ ਗਲਤ ਹੋ ਸਕਦੀ ਹੈ।
ਇਸ ਤੋਂ ਬਾਅਦ ਕਮਾਂਡਾਂ ਵਾਲਾ ਬਲਾਕ ਆਉਂਦਾ ਹੈ। ਜੇਕਰ ਇਹ ਤੁਰੰਤ ਇੱਕ ਮਾਪਦੰਡ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਕਮਾਂਡਾਂ ਦੇ ਅਨੁਸਾਰੀ ਕ੍ਰਮ ਨੂੰ ਇੱਕ if ਬਲਾਕ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਕਈ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
ਧਿਆਨ! ਸਭ ਦੇ ਅੰਦਰ ਇੰਡੈਂਟੇਸ਼ਨ ਜੇਕਰ ਬਲਾਕ ਕਮਾਂਡਾਂ ਦਾ ਆਕਾਰ ਇੱਕੋ ਜਿਹਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਬਲਾਕ ਦੀਆਂ ਹੱਦਾਂ ਇੰਡੈਂਟਸ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
ਭਾਸ਼ਾ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਅਨੁਸਾਰ, ਇੰਡੈਂਟੇਸ਼ਨ 4 ਸਪੇਸ ਹੈ।
ਇਹ ਆਪਰੇਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ? ਜਦੋਂ ਦੁਭਾਸ਼ੀਏ if ਸ਼ਬਦ ਨੂੰ ਵੇਖਦਾ ਹੈ, ਤਾਂ ਇਹ ਤੁਰੰਤ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਮਾਪਦੰਡ ਦੇ ਵਿਰੁੱਧ ਸਮੀਕਰਨ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਜੇ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਹ ਹਦਾਇਤਾਂ ਲੱਭਣ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲੱਗ ਪੈਂਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, ਇਸ ਬਲਾਕ ਤੋਂ ਸਾਰੀਆਂ ਕਮਾਂਡਾਂ ਛੱਡ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
ਜੇਕਰ ਸਥਿਤੀ ਤੋਂ ਬਾਅਦ ਇੱਕ ਸਟੇਟਮੈਂਟ ਇੰਡੈਂਟ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਤਾਂ ਇਸਨੂੰ ਇੱਕ if ਬਲਾਕ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਸਾਡੀ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਲਾਈਨ ਹੈ
ਇਹ ਓਪਰੇਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦੀ ਉਦਾਹਰਨ ਲਈ ਇੱਥੇ ਇੱਕ ਕੋਡ ਸਨਿੱਪਟ ਹੈ।
ਨੰਬਰ = ਇੰਟ (ਇਨਪੁਟ ("ਇੱਕ ਨੰਬਰ ਦਰਜ ਕਰੋ: "))
ਜੇਕਰ ਨੰਬਰ > 10:
ਪ੍ਰਿੰਟ ("ਨੰਬਰ 10 ਤੋਂ ਵੱਧ ਹੈ")
ਇਹ ਪ੍ਰੋਗਰਾਮ ਉਪਭੋਗਤਾ ਨੂੰ ਇੱਕ ਨੰਬਰ ਲਈ ਪੁੱਛਦਾ ਹੈ ਅਤੇ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇਹ 10 ਤੋਂ ਵੱਧ ਹੈ। ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਹ ਉਚਿਤ ਜਾਣਕਾਰੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਉਪਭੋਗਤਾ ਨੰਬਰ 5 ਦਾਖਲ ਕਰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਬਸ ਖਤਮ ਹੋ ਜਾਵੇਗਾ, ਅਤੇ ਬੱਸ.
ਪਰ ਜੇ ਤੁਸੀਂ 100 ਨੰਬਰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਦੁਭਾਸ਼ੀਏ ਸਮਝੇਗਾ ਕਿ ਇਹ ਦਸ ਤੋਂ ਵੱਧ ਹੈ, ਅਤੇ ਇਸਦੀ ਰਿਪੋਰਟ ਕਰੋ।
ਧਿਆਨ! ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਜੇਕਰ ਸ਼ਰਤ ਗਲਤ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਹਦਾਇਤਾਂ ਤੋਂ ਬਾਅਦ ਕੋਈ ਕਮਾਂਡ ਨਹੀਂ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।
ਉਪਰੋਕਤ ਕੋਡ ਵਿੱਚ ਸਿਰਫ ਇੱਕ ਕਮਾਂਡ ਹੈ। ਪਰ ਉਹਨਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਹੋਰ ਵੀ ਹਨ. ਸਿਰਫ ਲੋੜ ਇੰਡੈਂਟ ਦੀ ਹੈ।
ਹੁਣ ਕਮਾਂਡਾਂ ਦੇ ਇਸ ਕ੍ਰਮ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ।
ਨੰਬਰ = ਇੰਟ (ਇਨਪੁਟ ("ਇੱਕ ਨੰਬਰ ਲਿਖੋ: "))
ਜੇਕਰ ਨੰਬਰ > 10:
ਪ੍ਰਿੰਟ ("ਪਹਿਲੀ ਲਾਈਨ")
ਪ੍ਰਿੰਟ ("ਦੂਜੀ ਲਾਈਨ")
ਪ੍ਰਿੰਟ ("ਤੀਜੀ ਲਾਈਨ")
ਪ੍ਰਿੰਟ ਕਰੋ ("ਉਹ ਲਾਈਨ ਜੋ ਚਲਾਈ ਜਾਂਦੀ ਹੈ, ਦਾਖਲ ਕੀਤੇ ਨੰਬਰ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ")
ਪ੍ਰਿੰਟ ("ਐਪਲੀਕੇਸ਼ਨ ਸਮਾਪਤ ਕਰੋ")
ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਮੁੱਲ 2, 5, 10, 15, 50 ਦਰਜ ਕਰਦੇ ਹੋ ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗੀ।
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਜੇਕਰ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਦਰਜ ਕੀਤੀ ਗਈ ਸੰਖਿਆ ਦਸ ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਤਿੰਨ ਲਾਈਨਾਂ ਆਉਟਪੁੱਟ ਹਨ + ਇੱਕ "ਹਰ ਵਾਰ ਚਲਾਓ ..." ਅਤੇ ਇੱਕ "ਐਂਡ" ਟੈਕਸਟ ਦੇ ਨਾਲ, ਅਤੇ ਜੇਕਰ ਦਸ ਤੋਂ ਘੱਟ ਹੈ, ਤਾਂ ਕੇਵਲ ਇੱਕ, ਨਾਲ। ਇੱਕ ਵੱਖਰਾ ਟੈਕਸਟ। ਜੇਕਰ ਸਹੀ ਹੋਵੇ ਤਾਂ ਸਿਰਫ਼ ਲਾਈਨਾਂ 3,4,5 ਨੂੰ ਹੀ ਚਲਾਇਆ ਜਾਵੇਗਾ। ਹਾਲਾਂਕਿ, ਆਖਰੀ ਦੋ ਲਾਈਨਾਂ ਲਿਖੀਆਂ ਜਾਣਗੀਆਂ, ਭਾਵੇਂ ਉਪਭੋਗਤਾ ਕੋਈ ਵੀ ਨੰਬਰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ.
ਜੇਕਰ ਤੁਸੀਂ ਕਨਸੋਲ ਵਿੱਚ ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਨਤੀਜਾ ਵੱਖਰਾ ਹੋਵੇਗਾ। ਦੁਭਾਸ਼ੀਏ ਤੁਰੰਤ ਮਲਟੀ-ਲਾਈਨ ਮੋਡ ਨੂੰ ਚਾਲੂ ਕਰ ਦਿੰਦਾ ਹੈ ਜੇਕਰ, ਤਸਦੀਕ ਮਾਪਦੰਡ ਨਿਰਧਾਰਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਐਂਟਰ ਦਬਾਓ।
ਮੰਨ ਲਓ ਅਸੀਂ ਕਮਾਂਡਾਂ ਦਾ ਹੇਠ ਲਿਖਿਆ ਕ੍ਰਮ ਲਿਖਿਆ ਹੈ।
>>>
>>> n = 100
>>> ਜੇਕਰ n > 10:
...
ਉਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ >>> ਨੂੰ ਅੰਡਾਕਾਰ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮਲਟੀਲਾਈਨ ਇਨਪੁਟ ਮੋਡ ਸਮਰੱਥ ਹੈ। ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਐਂਟਰ ਦਬਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹਦਾਇਤ ਦੇ ਦੂਜੇ ਪੜਾਅ ਦੇ ਇਨਪੁਟ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ।
ਅਤੇ ਇਸ ਬਲਾਕ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਲਈ, ਤੁਹਾਨੂੰ ਬਲਾਕ ਵਿੱਚ ਇੱਕ ਹੋਰ ਉਸਾਰੀ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ if.
>>>
>>> n = 100
>>> ਜੇਕਰ n > 10:
… ਪ੍ਰਿੰਟ(«nv 10»)
...
ਜੇਕਰ ਸਥਿਤੀ ਸਹੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਖਤਮ ਹੋ ਜਾਵੇਗਾ। ਇਹ ਇੱਕ ਸਮੱਸਿਆ ਹੈ, ਕਿਉਂਕਿ ਉਪਭੋਗਤਾ ਅਜਿਹੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅਸਫਲਤਾ ਦੇ ਕਾਰਨ ਬੰਦ ਹੋਣ ਦੇ ਰੂਪ ਵਿੱਚ ਸਮਝ ਸਕਦਾ ਹੈ। ਇਸ ਲਈ, ਉਪਭੋਗਤਾ ਨੂੰ ਫੀਡਬੈਕ ਦੇਣਾ ਜ਼ਰੂਰੀ ਹੈ. ਇਸਦੇ ਲਈ, ਇੱਕ ਲਿੰਕ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੇ-ਹੋਰ.
ਸਮੀਕਰਨ ਆਪਰੇਟਰ ਜੇ-ਹੋਰ
ਇਹ ਆਪਰੇਟਰ ਤੁਹਾਨੂੰ ਇੱਕ ਲਿੰਕ ਲਾਗੂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ: ਜੇਕਰ ਸਮੀਕਰਨ ਕਿਸੇ ਖਾਸ ਨਿਯਮ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਾਰਵਾਈਆਂ ਕਰੋ, ਅਤੇ ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਹੋਰ। ਭਾਵ, ਇਹ ਤੁਹਾਨੂੰ ਪ੍ਰੋਗਰਾਮ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਦੋ ਸੜਕਾਂ ਵਿੱਚ ਵੰਡਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਸੰਟੈਕਸ ਅਨੁਭਵੀ ਹੈ:
ਜੇਕਰ ਹਾਲਤ:
# ਜੇਕਰ ਬਲਾਕ ਕਰੋ
ਸਟੇਟਮੈਂਟ 1
ਸਟੇਟਮੈਂਟ 2
ਇਤਆਦਿ
ਹੋਰ:
# ਹੋਰ ਬਲਾਕ
ਸਟੇਟਮੈਂਟ 3
ਸਟੇਟਮੈਂਟ 4
ਇਤਆਦਿ:
ਆਉ ਦੱਸੀਏ ਕਿ ਇਹ ਓਪਰੇਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਪਹਿਲਾਂ, ਸਟੈਂਡਰਡ ਸਟੇਟਮੈਂਟ ਨੂੰ ਥਰਿੱਡ ਵਿੱਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਯੂ, ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ ਕਿ ਕੀ ਇਹ ਮੇਲ ਖਾਂਦਾ ਹੈ ਹਾਲਤ "ਸੱਚ" ਜਾਂ "ਗਲਤ"। ਅਗਲੀਆਂ ਕਾਰਵਾਈਆਂ ਜਾਂਚ ਦੇ ਨਤੀਜਿਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ। ਜੇਕਰ ਸਹੀ ਹੈ, ਤਾਂ ਹਦਾਇਤ ਜੋ ਕਿ ਸ਼ਰਤ ਤੋਂ ਬਾਅਦ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਹੈ, ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਯੂ, ਜੇਕਰ ਇਹ ਝੂਠ ਹੈ, ਤਾਂ ਹੋਰ.
ਇਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਉਪਭੋਗਤਾ ਨੂੰ ਇੱਕ ਘੇਰੇ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਇਹ ਕੇਵਲ ਇੱਕ ਪਲੱਸ ਚਿੰਨ੍ਹ ਵਾਲੀ ਸੰਖਿਆ ਹੋ ਸਕਦੀ ਹੈ, ਜਾਂ ਇਹ ਇੱਕ ਖਾਲੀ ਮੁੱਲ ਹੈ। ਜੇਕਰ ਇਹ 0 ਤੋਂ ਘੱਟ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਸਕਾਰਾਤਮਕ ਨੰਬਰ ਦਰਜ ਕਰਨ ਲਈ ਕਹਿਣ ਲਈ ਇੱਕ ਸੁਨੇਹਾ ਜਾਰੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਇੱਥੇ ਉਹ ਕੋਡ ਹੈ ਜੋ ਇਸ ਕੰਮ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਪਰ ਇੱਥੇ ਇੱਕ ਗਲਤੀ ਹੈ. ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕਿ ਕਿਹੜਾ ਹੈ.
ਰੇਡੀਅਸ = ਇੰਟ (ਇਨਪੁਟ ("ਐਂਟਰ ਰੇਡੀਅਸ: "))
ਜੇਕਰ ਰੇਡੀਅਸ >= 0:
ਪ੍ਰਿੰਟ ("ਘਿਰਾਓ = ", 2 * 3.14 * ਘੇਰੇ)
ਪ੍ਰਿੰਟ ("ਖੇਤਰ = ", 3.14 * ਰੇਡੀਅਸ ** 2)
ਹੋਰ:
ਛਾਪੋ ("ਕਿਰਪਾ ਕਰਕੇ ਇੱਕ ਸਕਾਰਾਤਮਕ ਨੰਬਰ ਦਾਖਲ ਕਰੋ")
ਇੰਡੈਂਟੇਸ਼ਨ ਬੇਮੇਲ ਗਲਤੀ। ਜੇਕਰ ਅਤੇ ਹੋਰ ਉਹਨਾਂ ਤੋਂ ਬਿਨਾਂ ਜਾਂ ਉਹਨਾਂ ਦੀ ਇੱਕੋ ਜਿਹੀ ਸੰਖਿਆ ਦੇ ਨਾਲ ਸਥਿਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਉਹ ਨੇਸਟਡ ਹਨ ਜਾਂ ਨਹੀਂ)।
ਚਲੋ ਇੱਕ ਹੋਰ ਵਰਤੋਂ ਦਾ ਕੇਸ (ਜਿੱਥੇ ਓਪਰੇਟਰ ਅਲਾਈਨਮੈਂਟ ਨਾਲ ਸਭ ਕੁਝ ਸਹੀ ਹੋਵੇਗਾ) ਦਿਓ - ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਐਲੀਮੈਂਟ ਜੋ ਪਾਸਵਰਡ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।
ਪਾਸਵਰਡ = ਇਨਪੁਟ ("ਪਾਸਵਰਡ ਦਰਜ ਕਰੋ: ")
ਜੇਕਰ ਪਾਸਵਰਡ == «sshh»:
ਪ੍ਰਿੰਟ ("ਜੀ ਆਇਆਂ ਨੂੰ")
ਹੋਰ:
ਪ੍ਰਿੰਟ ("ਪਹੁੰਚ ਅਸਵੀਕਾਰ")
ਜੇਕਰ ਪਾਸਵਰਡ sshh ਹੈ ਤਾਂ ਇਹ ਹਦਾਇਤ ਵਿਅਕਤੀ ਨੂੰ ਅੱਗੇ ਛੱਡ ਦਿੰਦੀ ਹੈ। ਜੇਕਰ ਅੱਖਰਾਂ ਅਤੇ ਸੰਖਿਆਵਾਂ ਦਾ ਕੋਈ ਹੋਰ ਸੁਮੇਲ ਹੈ, ਤਾਂ ਇਹ "ਪਹੁੰਚ ਇਨਕਾਰ" ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ।
ਸਟੇਟਮੈਂਟ-ਐਪ੍ਰੈਸ਼ਨ if-elif-else
ਕੇਵਲ ਜੇਕਰ ਕਈ ਸ਼ਰਤਾਂ ਸਹੀ ਨਹੀਂ ਹਨ, ਤਾਂ ਸਟੇਟਮੈਂਟ ਜੋ ਕਿ ਬਲਾਕ ਵਿੱਚ ਹੈ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਹੋਰ. ਇਹ ਪ੍ਰਗਟਾਵਾ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਜੇਕਰ ਸ਼ਰਤ_1:
# ਜੇਕਰ ਬਲਾਕ ਕਰੋ
ਬਿਆਨ '
ਬਿਆਨ '
ਹੋਰ ਬਿਆਨ
elif ਸ਼ਰਤ_2:
# ਪਹਿਲਾ ਏਲੀਫ ਬਲਾਕ
ਬਿਆਨ '
ਬਿਆਨ '
ਹੋਰ ਬਿਆਨ
elif ਸ਼ਰਤ_3:
# ਦੂਜਾ ਏਲੀਫ ਬਲਾਕ
ਬਿਆਨ '
ਬਿਆਨ '
ਹੋਰ ਬਿਆਨ
...
ਹੋਰ
ਬਿਆਨ '
ਬਿਆਨ '
ਹੋਰ ਬਿਆਨ
ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਵਾਧੂ ਸ਼ਰਤਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ.
ਨੇਸਟਡ ਬਿਆਨ
ਮਲਟੀਪਲ ਸ਼ਰਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ if ਬਲਾਕ ਵਿੱਚ ਵਾਧੂ ਸਥਿਤੀ ਜਾਂਚਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ।
ਓਪਰੇਟਰ if ਇੱਕ ਹੋਰ ਕੰਡੀਸ਼ਨ ਬਲਾਕ ਦੇ ਅੰਦਰ
gre_score = int(ਇਨਪੁਟ("ਆਪਣੀ ਮੌਜੂਦਾ ਕ੍ਰੈਡਿਟ ਸੀਮਾ ਦਰਜ ਕਰੋ"))
per_grad = int(ਇਨਪੁਟ("ਆਪਣੀ ਕ੍ਰੈਡਿਟ ਰੇਟਿੰਗ ਦਰਜ ਕਰੋ: "))
ਜੇਕਰ ਪ੍ਰਤੀ_ਗਰੇਡ > 70:
# ਬਾਹਰੀ ਜੇ ਬਲਾਕ
ਜੇਕਰ gre_score > 150:
# ਅੰਦਰੂਨੀ ਜੇ ਬਲਾਕ
ਛਾਪੋ ("ਵਧਾਈਆਂ, ਤੁਹਾਨੂੰ ਕਰਜ਼ਾ ਮਿਲ ਗਿਆ ਹੈ")
ਹੋਰ:
ਪ੍ਰਿੰਟ ("ਮਾਫ਼ ਕਰਨਾ, ਤੁਸੀਂ ਕਰਜ਼ੇ ਲਈ ਯੋਗ ਨਹੀਂ ਹੋ")
ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਕ੍ਰੈਡਿਟ ਰੇਟਿੰਗ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਇਹ 70 ਤੋਂ ਘੱਟ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਕ੍ਰੈਡਿਟ ਲਈ ਯੋਗ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਇਹ ਵੱਧ ਹੈ, ਤਾਂ ਇੱਕ ਦੂਜੀ ਜਾਂਚ ਇਹ ਦੇਖਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕ੍ਰੈਡਿਟ ਸੀਮਾ 150 ਤੋਂ ਵੱਧ ਹੈ। ਜੇਕਰ ਹਾਂ, ਤਾਂ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ ਕਿ ਕਰਜ਼ਾ ਜਾਰੀ ਕੀਤਾ ਗਿਆ ਹੈ।
ਜੇਕਰ ਦੋਵੇਂ ਮੁੱਲ ਗਲਤ ਹਨ, ਤਾਂ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਕੋਲ ਕਰਜ਼ਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ।
ਹੁਣ ਆਉ ਉਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਥੋੜਾ ਜਿਹਾ ਦੁਬਾਰਾ ਕੰਮ ਕਰੀਏ।
gre_score = int(ਇਨਪੁਟ("ਮੌਜੂਦਾ ਸੀਮਾ ਦਰਜ ਕਰੋ: "))
per_grad = int(ਇਨਪੁਟ("ਕ੍ਰੈਡਿਟ ਸਕੋਰ ਦਰਜ ਕਰੋ: "))
ਜੇਕਰ ਪ੍ਰਤੀ_ਗਰੇਡ > 70:
ਜੇਕਰ gre_score > 150:
ਛਾਪੋ ("ਵਧਾਈਆਂ, ਤੁਹਾਨੂੰ ਕਰਜ਼ਾ ਮਿਲ ਗਿਆ ਹੈ")
ਹੋਰ:
ਪ੍ਰਿੰਟ ("ਤੁਹਾਡੀ ਕ੍ਰੈਡਿਟ ਸੀਮਾ ਘੱਟ ਹੈ")
ਹੋਰ:
ਪ੍ਰਿੰਟ ("ਮਾਫ਼ ਕਰਨਾ, ਤੁਸੀਂ ਕ੍ਰੈਡਿਟ ਲਈ ਯੋਗ ਨਹੀਂ ਹੋ")
ਕੋਡ ਆਪਣੇ ਆਪ ਵਿੱਚ ਬਹੁਤ ਸਮਾਨ ਹੈ, ਪਰ ਨੇਸਟਡ ਹੈ if ਇੱਕ ਐਲਗੋਰਿਦਮ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇਸ ਤੋਂ ਸਥਿਤੀ ਗਲਤ ਨਿਕਲਦੀ ਹੈ। ਯਾਨੀ, ਕਾਰਡ 'ਤੇ ਸੀਮਾ ਨਾਕਾਫ਼ੀ ਹੈ, ਪਰ ਕ੍ਰੈਡਿਟ ਹਿਸਟਰੀ ਵਧੀਆ ਹੈ, "ਤੁਹਾਡੇ ਕੋਲ ਘੱਟ ਕ੍ਰੈਡਿਟ ਰੇਟਿੰਗ ਹੈ" ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ।
ਜੇਕਰ-ਹੋਰ ਸਥਿਤੀ ਦੇ ਅੰਦਰ ਬਿਆਨ ਹੋਰ
ਆਉ ਇੱਕ ਹੋਰ ਪ੍ਰੋਗਰਾਮ ਬਣਾਈਏ ਜੋ ਟੈਸਟ ਦੇ ਅੰਕਾਂ ਦੇ ਅਧਾਰ ਤੇ ਵਿਦਿਆਰਥੀ ਦਾ ਗ੍ਰੇਡ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।
ਸਕੋਰ = ਇੰਟ (ਇਨਪੁਟ ("ਆਪਣਾ ਸਕੋਰ ਦਰਜ ਕਰੋ: "))
ਜੇਕਰ ਸਕੋਰ >= 90:
ਪ੍ਰਿੰਟ ("ਬਹੁਤ ਵਧੀਆ! ਤੁਹਾਡਾ ਗ੍ਰੇਡ A ਹੈ")
ਹੋਰ:
ਜੇਕਰ ਸਕੋਰ >= 80:
ਪ੍ਰਿੰਟ ("ਬਹੁਤ ਵਧੀਆ! ਤੁਹਾਡਾ ਗ੍ਰੇਡ B ਹੈ")
ਹੋਰ:
ਜੇਕਰ ਸਕੋਰ >= 70:
ਪ੍ਰਿੰਟ ("ਚੰਗਾ! ਤੁਹਾਡਾ ਗ੍ਰੇਡ C ਹੈ")
ਹੋਰ:
ਜੇਕਰ ਸਕੋਰ >= 60:
ਪ੍ਰਿੰਟ ("ਤੁਹਾਡਾ ਗ੍ਰੇਡ D ਹੈ। ਇਹ ਸਮੱਗਰੀ ਨੂੰ ਦੁਹਰਾਉਣ ਦੇ ਯੋਗ ਹੈ।")
ਹੋਰ:
ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਇਮਤਿਹਾਨ ਵਿੱਚ ਅਸਫਲ ਰਹੇ")
ਐਪਲੀਕੇਸ਼ਨ ਪਹਿਲਾਂ ਇਹ ਦੇਖਣ ਲਈ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਸਕੋਰ 90 ਤੋਂ ਵੱਧ ਜਾਂ ਬਰਾਬਰ ਹੈ। ਜੇਕਰ ਹਾਂ, ਤਾਂ ਇਹ A ਗ੍ਰੇਡ ਦਿੰਦਾ ਹੈ। ਜੇ ਇਹ ਸਥਿਤੀ ਗਲਤ ਹੈ, ਤਾਂ ਬਾਅਦ ਦੀਆਂ ਜਾਂਚਾਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਐਲਗੋਰਿਦਮ ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ ਲਗਭਗ ਇੱਕੋ ਜਿਹਾ ਹੈ। ਇਸ ਲਈ ਅੰਦਰ ਜਾਂਚ ਕਰਨ ਦੀ ਬਜਾਏ ਹੋਰ ਇੱਕ ਸੁਮੇਲ ਵਰਤਣ ਲਈ ਬਿਹਤਰ ਹੈ if-elif-ਹੋਰ.
ਇਸ ਲਈ ਆਪਰੇਟਰ if ਇੱਕ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਫੰਕਸ਼ਨ ਕਰਦਾ ਹੈ - ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਕੋਡ ਦੇ ਕੁਝ ਟੁਕੜਿਆਂ ਨੂੰ ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇਸਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਕਲਪਨਾ ਕਰਨਾ ਅਸੰਭਵ ਹੈ, ਕਿਉਂਕਿ ਸਭ ਤੋਂ ਸਰਲ ਐਲਗੋਰਿਦਮ ਲਈ ਵੀ ਕਾਂਟੇ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ "ਜੇ ਤੁਸੀਂ ਖੱਬੇ ਪਾਸੇ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਮਿਲੇਗਾ, ਅਤੇ ਜੇ ਤੁਸੀਂ ਸੱਜੇ ਪਾਸੇ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਅਤੇ ਉਹ ਕਰਨ ਦੀ ਲੋੜ ਹੈ."