Python
(ਪਾਈਥਨ ਨਾਲ ਜਾਣ ਪਛਾਣ)
ਜਾਣ ਪਛਾਣ
ਹੁਣ ਤੱਕ ਅਸੀਂ ਇਸ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹਾਸਿਲ ਕਰ ਚੁੱਕੇ ਹਾਂ ਕਿ ਪਾਇਥਨ ਇੰਟਰਪ੍ਰੈਟਰ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ ਅਤੇ ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ। ਹੁਣ ਅਸੀਂ ਪਾਈਥਨ ਭਾਸ਼ਾ ਦੇ ਹੋਰ ਵੇਰਵਿਆਂ ਬਾਰੇ ਡਿਟੇਲ ਵਿਚ ਜਾਣਕਾਰੀ ਹਾਸਿਲ ਕਰਾਂਗੇ। ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਪਾਇਥਨ ਵਿੱਚ ਬਣੇ ਬੁਨਿਆਦੀ ਡਾਟਾ ਟਾਈਪਸ, ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਆਪਰੇਟਰਾਂ, ਐਕਸਪ੍ਰੈਸ਼ਨਜ਼ ਅਤੇ ਵੱਖ-ਵੱਖ ਤਰ੍ਹਾਂ ਦੀਆਂ ਡਾਟਾ ਕਨਵਰਜ਼ਨ ਤਕਨੀਕਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹਾਸਿਲ ਕਰਾਂਗੇ। ਪਾਈਥਨ ਡਾਟਾ ਟਾਈਪਸ ਅਤੇ ਆਪਰੇਟਰਾਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਅਸੀਂ ਇਸ ਭਾਸ਼ਾ ਦੇ ਡਿਜ਼ਾਈਨ ਅਤੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਹੋਰ ਪ੍ਰਭਾਵੀ ਢੰਗ ਨਾਲ ਸਮਝਣਯੋਗ ਬਣ ਸਕਾਂਗੇ
ਪਾਇਥਨ ਵਿਚ ਡਾਟਾ ਟਾਈਪਸ
ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਡਾਟਾ ਟਾਈਪ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੰਕਲਪ (Concept) ਹੈ। ਵੇਰੀਏਬਲਾਂ ਵਿਚ ਮੁੱਲ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਮੁੱਲ ਦਾ ਇੱਕ ਡਾਟਾ-ਟਾਈਪ ਹੁੰਦਾ ਹੈ। ਡਾਟਾ-ਟਾਈਪ ਡਾਟਾ ਦੀ ਕਿਸਮ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਅੰਦਰ ਸਟੋਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇੰਟੀਜ਼ਰ ਅੰਕ (+ve ਜਾਂ -ve ਚਿੰਨ੍ਹ ਦੇ ਨਾਲ ਜਾਂ ਇਹਨਾਂ ਤੋਂ ਬਿਨਾਂ ਸੰਪੂਰਨ ਸੰਖਿਆਵਾਂ (Whole Numbers)), ਸਟ੍ਰਿੰਗ (ਕੁਟੇਸ਼ਨ ਚਿੰਨ੍ਹਾਂ ਵਿੱਚ ਬੰਦ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ) ਅਤੇ ਰੀਅਲ (real values) ਮੁੱਲ (ਦਸ਼ਮਲਵ ਬਿੰਦੂ (Decimal Point) ਦੇ ਨਾਲ ਨੁਮੇਰਿੱਕ ਮੁੱਲ) ਆਮ ਵਰਤੇ ਜਾਂਦੇ ਮੁੱਲ ਹਨ ਜੋ ਅਸੀਂ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਦੇ ਹਾਂ।
ਪਾਇਥਨ ਵਿਚ ਡਾਟਾ ਟਾਈਪਸ
ਪਾਈਥਨ ਇੱਕ ਡਾਇਨਾਮਿੱਕਲੀ ਟਾਈਪਡ (Dynamically Typed) ਭਾਸ਼ਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਨੂੰ ਵੇਰੀਏਬਲ ਨੂੰ ਡਿਕਲੇਅਰ ਕਰਦੇ ਸਮੇਂ ਉਸ ਦੀ ਡਾਟਾ-ਟਾਈਪ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਜਰੂਰਤ ਨਹੀਂ ਪੈਂਦੀ। ਇੰਟਰਪ੍ਰੈਟਰ ਆਪਣੇ ਆਪ ਮੁੱਲ ਨੂੰ ਉਸਦੀ ਟਾਈਪ ਨਾਲ ਜੋੜ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ:
z = 10.5
ਇੱਸ ਉਦਾਹਰਣ ਵਿਚ ਵੇਰੀਏਬਲ z ਵਿੱਚ ਫਲੋਟ ਮੁੱਲ 10.5 ਸਟੋਰ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਅਸੀਂ ਇਸਦੀ ਡਾਟਾ ਟਾਈਪ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਹੈ। ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੈਟਰ ਆਪਣੇ ਆਪ ਵੇਰੀਏਬਲ z ਨੂੰ ਫਲੋਟਿੰਗ ਟਾਈਪ ਦੇ ਤੌਰ 'ਤੇ ਇੰਟਰਪ੍ਰੈਟ (interpret) ਕਰੇਗਾ।
type() ਦੀ ਵਰਤੋਂ
type() ਦੀ ਵਰਤੋਂ
type() ਫੰਕਸ਼ਨ ਨਾਲ ਵੇਰੀਏਬਲਾਂ ਦੇ ਡਾਟਾ-ਟਾਈਪ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ (types.py)
ਪ੍ਰੋਗਰਾਮ (types.py) ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਦਿੱਤੀ ਆਉਟਪੁੱਟ ਮਿਲੇਗੀ:
ਪਾਈਥਨ ਵਿਚ ਸਟੈਂਡਰਡ ਡਾਟਾ ਟਾਈਪਸ
ਸਟੈਂਡਰਡ ਡਾਟਾ ਟਾਈਪਸ ਨੂੰ ਬਿਲਟ-ਇਨ ਡਾਟਾ ਟਾਈਪਸ ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਡਾਟਾ ਟਾਈਪਸ ਨੂੰ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਕਈ ਸਟੈਂਡਰਡ ਡਾਟਾ ਟਾਈਪਸ ਹਨ ਅਤੇ ਹਰੇਕ ਟਾਈਪ ਲਈ ਓਪਰੇਸ਼ਨਾਂ ਅਤੇ ਸਟੋਰੇਜ ਵਿਧੀਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।
ਪਾਈਥਨ ਵਿਚ ਨੁਮੇਰਿੱਕ ਡਾਟਾ ਟਾਈਪਸ
ਨੁਮੇਰਿੱਕ ਡਾਟਾ ਟਾਈਪਸ ਉਹ ਟਾਈਪਸ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ (Numeric Values) ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਨੁਮੇਰਿੱਕ ਟਾਈਸਪਸ ਵਿੱਚ ਇੰਟੀਜ਼ਰਸ (ਪੂਰਨ ਅੰਕ), ਫਲੋਟਿੰਗ ਟਾਈਪ ਨੰਬਰਸ (ਜਾਂ ਫਲੋਟਸ), ਅਤੇ ਕੰਪਲੈਕਸ ਨੰਬਰ ਆਉਂਦੇ ਹਨ:
ਪਾਈਥਨ ਵਿਚ ਬੂਲੀਅਨ ਡਾਟਾ ਟਾਈਪ
ਬੂਲੀਅਨ ਡਾਟਾ ਟਾਈਪ ਦੀ ਵਰਤੋਂ ਐਕਸਪ੍ਰੈਸ਼ਨ ਦੀ ਟਰੁੱਥ ਵੈਲੀਉ (Truth Value) ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਐਕਸਪ੍ਰੈਸ਼ਨ 5 <= 10 ਸਹੀ (True) ਹੈ, ਜਦੋਂ ਕਿ ਐਕਸਪ੍ਰੈਸ਼ਨ 5 > 10 ਗਲਤ (False) ਹੈ। ਬੂਲੀਅਨ ਡਾਟਾ ਟਾਈਪ ਦੇ ਸਿਰਫ਼ ਦੋ ਸੰਭਵ ਮੁੱਲ ਹੁੰਦੇ ਹਨ: ਸਹੀ (True) ਅਤੇ ਗਲਤ (False)। ਬੁਲੀਅਨ ਟਾਈਪ ਲਈ ਕੋਈ ਹੋਰ ਮੁੱਲ ਸੰਭਵ ਨਹੀਂ ਹੈ। ਪਾਈਥਨ ਦੇ bool() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਦਿਤੇ ਗਏ ਮੁੱਲ ਨੂੰ ਬੂਲੀਅਨ ਮੁੱਲ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਕੋਈ ਵੀ ਇੰਟੀਜ਼ਰ, ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ, ਜਾਂ ਕੰਪਲੈਕਸ ਨੰਬਰ ਜਿਸਦਾ ਮੁੱਲ ਜ਼ੀਰੋ ਹੈ, ਨੂੰ ਗਲਤ (False) ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕਿਸੇ ਵੀ ਸਕਾਰਾਤਮਕ (Positive) ਜਾਂ ਨਕਾਰਾਤਮਕ (Negative) ਨੰਬਰ ਨੂੰ ਸਹੀ (True) ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ: bool(4.5) ਸਹੀ (True) ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ, ਜਦੋਂ ਕਿ bool(0+0j) ਗਲਤ (False) ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ।
ਪਾਈਥਨ ਵਿਚ ਸਿਕੁਐਂਸ ਡਾਟਾ ਟਾਈਪ
ਸਿਕੁਐਂਸ (Sequence) ਇਕੋ (Similar) ਟਾਈਪ ਜਾਂ ਵੱਖ-ਵੱਖ ਟਾਈਪ ਦੇ ਮੁੱਲਾਂ ਦਾ ਇੱਕ ਕ੍ਰਮਬੱਧ ਸੰਗ੍ਰਹਿ (Ordered Collection) ਹੁੰਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਕਈ ਸਿਕੁਐਂਸ ਡਾਟਾ ਟਾਈਪਸ ਹਨ। ਪਾਈਥਨ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਸਿਕੁਐਂਸ ਟਾਈਪਸ ਦਾ ਵਰਨਣ ਹੇਠਾਂ ਕੀਤਾ ਗਿਆ ਹੈ:
ਪਾਈਥਨ ਵਿਚ ਸਿਕੁਐਂਸ ਡਾਟਾ ਟਾਈਪ
ਪਾਈਥਨ ਵਿਚ ਸਿਕੁਐਂਸ ਡਾਟਾ ਟਾਈਪ
range() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇਸਦੇ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਆਰਗੂਮੈਂਟਾਂ ਅਨੁਸਾਰ ਸੰਖਿਆਵਾਂ ਦਾ ਕ੍ਰਮ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। range() ਫੰਕਸ਼ਨ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹੋਏ ਸੰਖਿਆਵਾਂ ਦਾ ਇੱਕ ਕ੍ਰਮ (sequence of numbers) ਵਾਪਸ ਕਰਦਾ ਹੈ; ਇਹ ਕ੍ਰਮ ਮੂਲ ਰੂਪ ਵਿੱਚ 1-1 ਅੰਕ ਦੁਆਰਾ ਵਧਦਾ ਹੈ ਅਤੇ ਇੱਕ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਕ੍ਰਮ ਰੁਕ ਜਾਂਦਾ ਹੈ। range() ਫੰਕਸ਼ਨ ਦਾ ਸਿੰਟੈਕਸ ਹੈ:
range(start, stop, step)
ਇੱਥੇ start ਇੱਕ ਆਪਸ਼ਨਲ ਪੈਰਾਮੀਟਰ ਹੈ ਜੋ ਸੰਖਿਆਵਾਂ ਦੇ ਕ੍ਰਮ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਤੈਅ ਕਰਦਾ ਹੈ, stop ਪੈਰਾਮੀਟਰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਸੰਖਿਆ ਤੱਕ ਪਹੁੰਚਣ ਉਪਰ ਕ੍ਰਮ ਨੂੰ ਰੋਕਣਾ ਹੈ (stop ਮੁੱਲ ਤਿਆਰ ਕੀਤੇ ਗਏ ਕ੍ਰਮ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ), ਅਤੇ step ਵੀ ਇੱਕ ਆਪਸ਼ਨਲ ਪੈਰਾਮੀਟਰ ਹੈ ਜੋ range() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਤਿਆਰ ਕ੍ਰਮ ਵਿੱਚ ਕਿਸੇ ਵੀ ਦੋ ਲਗਾਤਾਰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
ਪਾਈਥਨ ਵਿਚ ਸਿਕੁਐਂਸ ਡਾਟਾ ਟਾਈਪ
ਉਦਾਹਰਣ ਲਈ:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9
2, 4, 6, 8, 10, 12, 14
10, 9, 8, 7, 6
ਪਾਈਥਨ ਵਿਚ ਸਟ੍ਰਿੰਗ ਟਾਈਪ
ਪਾਈਥਨ ਵਿੱਚ ਸਟ੍ਰਿੰਗਸ ਨੂੰ ਯੂਨੀਕੋਡ ਕਰੈਕਟਰ (Unicode character) ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਕਰੈਕਟਰ (character) ਡਾਟਾ ਟਾਈਪ ਮੌਜੂਦ ਨਹੀਂ ਹੈ। ਇੱਕ ਸਿੰਗਲ ਅੱਖਰ (character) ਨੂੰ ਵੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਮੁੱਲ ਨੂੰ ਸਿੰਗਲ, ਡਬਲ ਜਾਂ ਟ੍ਰਿਪਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਨਾਲ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਉਦਾਹਰਣ ਲਈ: ‘Hi’, “Hello”, “““Welcome”””
ਪਾਈਥਨ ਵਿਚ ਵੱਖ ਵੱਖ ਡਾਟਾ ਟਾਈਪ
ਲਿਸਟ ਆਬਜੈਕਟ ਦੀ ਆਊਟਪੁੱਟ
ਟਪਲ ਆਬਜੈਕਟ ਦੀ ਆਊਟਪੁੱਟ
ਲਿਸਟ ਰੂਪ ਵਿਚ ਰੇਂਜ਼ ਆਬਜੈਕਟ ਦੀ ਆਊਟਪੁੱਟ
ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟ ਦੀ ਆਊਟਪੁੱਟ
ਪਾਈਥਨ ਵਿਚ ਸੈੱਟ ਡਾਟਾ ਟਾਈਪ
ਇੱਕ ਸੈੱਟ ਤੱਤਾਂ ਦਾ ਇੱਕ ਅਨਆਰਡਰਡ ਸੰਗ੍ਰਹਿ (unordered collection) ਹੁੰਦਾ ਹੈ। ਸੈੱਟ ਦੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਸਾਨੂੰ ਕਰਲੀ ਬਰੈਕਟਾਂ ({ }) ਵਿੱਚ ਕਾਮਿਆਂ (commas) ਨਾਲ ਵੱਖ ਕੀਤੇ ਮੁੱਲ ਲਿਖਣੇ ਪੈਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ: {10, 20, 30 ,40, 50}। ਸੈੱਟ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲ ਨਹੀਂ ਹੁੰਦੇ। ਜੇਕਰ ਅਸੀਂ ਸੈੱਟ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਲਿਖਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਕੋਈ ਐਰਰ (error) ਨਹੀਂ ਦਿਖਾਵੇਗਾ, ਪਰੰਤੂ ਇਹ ਆਉਟਪੁੱਟ ਵਿੱਚ ਸਿਰਫ਼ ਵੱਖਰੇ (distinct) ਮੁੱਲ ਹੀ ਦਿਖਾਏਗਾ, ਭਾਵ ਸੈੱਟ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਵੇਗਾ। ਕਿਉਂਕਿ ਸੈੱਟ ਵਿੱਚ ਆਈਟਮਾਂ ਅਨਆਰਡਰਡ (ਬਿਨਾਂ ਕ੍ਰਮਬੱਧ) ਹੁੰਦੀਆਂ ਹਨ, ਇਸਲਈ ਸੈੱਟ ਦੀਆਂ ਆਈਟਮਾਂ ਬੇਤਰਤੀਬ ਕ੍ਰਮ (random order) ਵਿੱਚ ਦਿਖਾਈ ਦੇਣਗੀਆਂ।
ਪਾਈਥਨ ਵਿਚ ਸੈੱਟ ਡਾਟਾ ਟਾਈਪ
ਸੈੱਟ ਦਾ ਸਾਧਾਰਣ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:
ਇਹ ਜਰੂਰੀ ਨਹੀਂ ਹੈ ਕਿ ਇੱਕ ਸੈੱਟ ਦੇ ਸਾਰੇ ਤੱਤ ਇੱਕੋ ਡਾਟਾ ਟਾਈਪ ਦੇ ਹੋਣ। ਸੈੱਟ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮਿਕਸਡ (mixed) ਡਾਟਾ ਟਾਈਪਸ ਦੇ ਮੁੱਲ ਵੀ ਲਿਖੇ ਜਾ ਸਕਦੇ ਹਨ। ਬਿਲਟ-ਇਨ set() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੀ ਸੈੱਟ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ:
ਸੈੱਟ ਵਿਚ ਡੂਪਲੀਕੇਟ ਮੁੱਲ
ਰੈਂਡਮ ਆਰਡਰ ਵਿਚ ਸੈੱਟ ਦੇ ਨਿਵੇਕਲੇ (unique) ਮੁੱਲ
ਪਾਈਥਨ ਵਿਚ ਮੈਪਿੰਗ ਡਾਟਾ ਟਾਈਪ
ਮੈਪਿੰਗ ਡਾਟਾ ਟਾਈਪਸ ਉਹ ਟਾਈਪਸ ਹੁੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕੁੰਜੀਆਂ (keys) ਨੂੰ ਆਰਬਿਟਰੇਰੀ (arbitrary) ਮੁੱਲਾਂ/ਆਬਜੈਕਟਾਂ ਨਾਲ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ ਅਸੀਂ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਿ ਮੈਪਿੰਗ ਟਾਈਪਸ ਵਿੱਚ ਤੱਤਾਂ (elements) ਨੂੰ key: value ਜੋੜਿਆਂ (pairs) ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਸਿਰਫ ਡਿਕਸ਼ਨਰੀ ਹੀ ਮੈਪਿੰਗ ਕਿਸਮ ਦੀ ਡਾਟਾ-ਟਾਈਪ ਹੈ:
ਪਾਈਥਨ ਵਿਚ ਮੈਪਿੰਗ ਡਾਟਾ ਟਾਈਪ
ਡਿਕਸ਼ਨਰੀ ਡਾਟਾ ਟਾਈਪ ਦੀਆਂ ਉਦਾਹਰਣਾ:
ਡਿਕਸ਼ਨਰੀ ਕੀਅਜ਼ ਕੇਸ ਸੰਵੇਦਨਸ਼ੀਲ (case sensitive) ਹੁੰਦੀਆਂ ਹਨ, ਇੱਕੋ ਨਾਮ ਪਰ ਕੀਅ ਮੁੱਲ ਦੇ ਵੱਖੋ-ਵੱਖਰੇ ਕੇਸਾਂ ਨੂੰ ਵੱਖਰਾ ਸਮਝਿਆ ਜਾਵੇਗਾ।
ਡਿਕਸ਼ਨਰੀ ਵਿਚ Key: Value ਪੇਅਰ
ਡਿਕਸ਼ਨਰੀ ਆਈਟਮ ਦੀ ਕੀਅ ਨਾਲ ਵਰਤੋਂ ਕਰਨਾ
ਪਾਈਥਨ ਵਿਚ None ਡਾਟਾ ਟਾਈਪ
ਪਾਈਥਨ ਵਿੱਚ None ਇਕ ਵਿਸ਼ੇਸ਼ ਡਾਟਾ ਟਾਈਪ ਹੈ। ਇਹ ਟਾਈਪ ਸਿਰਫ਼ ਮੁੱਲ ਦੀ ਅਣਹੋਂਦ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। None ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਜਾਂ ਤਾਂ null ਮੁੱਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਾਂ ਇਸਦੀ ਵਰਤੋਂ ਉਸ ਸਮੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਵੇਰੀਏਬਲ ਨੂੰ ਅਸਾਈਨ ਕਰਨ ਲਈ ਕੋਈ ਮੁੱਲ ਨਾ ਹੋਵੇ। None ਮੁੱਲ 0, False, ਜਾਂ ਖਾਲੀ ਸਟ੍ਰਿੰਗ ਦੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਹੁੰਦਾ। None ਆਪਣੇ ਆਪ ਵਿਚ ਡਾਟਾ ਦੀ ਇਕ ਕਿਸਮ (NoneType) ਹੈ। ਅਸੀਂ ਕਿਸੇ ਵੀ ਵੇਰੀਏਬਲ ਨੂੰ None ਮੁੱਲ ਅਸਾਈਨ ਕਰ ਸਕਦੇ ਹਾਂ।
ਪਾਈਥਨ ਵਿਚ ਆਪਰੇਟਰਜ਼
ਆਪਰੇਟਰ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਬੁਨਿਆਦ ਹੁੰਦੇ ਹਨ। ਇਹ ਉਹ ਵਿਸ਼ੇਸ਼ ਚਿੰਨ੍ਹ ਹੁੰਦੇ ਹਨ ਜੋ ਆਪਰੇਡਾਂ 'ਤੇ ਆਮ ਆਪਰੇਸ਼ਨ (ਪ੍ਰੋਸੈਸਿੰਗ) ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਇਹ ਆਪਰੇਟਰ ਆਮ ਤੌਰ 'ਤੇ ਅੰਕਗਣਿਤ (arithmetic) ਜਾਂ ਲਾਜ਼ੀਕਲ (logical) ਆਪਰੇਸ਼ਨ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਇਕੱਲਾ ਆਪਰੇਟਰ ਆਪਣੇ ਆਪ ਵਿਚ ਕੋਈ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਇਸਨੂੰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਆਪਰੇਂਡਾਂ ਦੀ ਜਰੂਰਤ ਪੈਂਦੀ ਹੈ। ਆਪਰੇਂਡ ਉਹ ਮੁੱਲ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਉਪਰ ਆਪਰੇਟਰ ਆਪਣਾ ਕੰਮ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ:
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ ਚਿੰਨ੍ਹ + ਇੱਕ ਆਪਰੇਟਰ ਹੈ ਜੋ 3 ਅਤੇ 2 ਮੁੱਲਾਂ 'ਤੇ ਆਪਣਾ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। ਇਹਨਾਂ ਮੁੱਲਾਂ (3 ਅਤੇ 2) ਨੂੰ ਆਪਰੇਂਡ ਕਿਹਾ ਜਾਵੇਗਾ। ਆਪਰੇਟਰਾਂ ਅਤੇ ਆਪਰੇਡਾਂ ਦੇ ਅਜਿਹੇ ਵੈਧ ਸੁਮੇਲ (valid combination) ਨੂੰ ਐਕਸਪ੍ਰੈਸ਼ਨ (Expression) ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਵੀ ਅਸੀਂ ਮੁੱਲਾਂ/ਆਪਰੇਂਡਾਂ 'ਤੇ ਕੋਈ ਕਾਰਵਾਈ ਕਰਦੇ ਹਾਂ, ਸਾਨੂੰ ਇੱਕ ਨਵਾਂ ਮੁੱਲ ਮਿਲਦਾ ਹੈ (ਜਿਸ ਨੂੰ ਆਪਰੇਸ਼ਨ ਦਾ ਨਤੀਜਾ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ)।
ਪਾਈਥਨ ਵਿਚ ਆਪਰੇਟਰਜ਼
ਪਾਈਥਨ ਵਿਚ ਬਹੁਤ ਸਾਰੇ ਆਪਰੇਟਰ ਮੌਜੂਦ ਹਨ। ਆਮ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਆਪਰੇਟਰਾਂ ਨੂੰ ਅੱਗੇ ਲਿਖੀਆਂ ਸ਼੍ਰੇਣੀਆਂ ਵਿਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ:
ਅਰਿੱਥਮੈਟਿਕ ਆਪਰੇਟਰਜ਼
ਅਰਿੱਥਮੈਟਿਕ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਨੂਮੇਰਿੱਕ ਮੁੱਲਾਂ (numerical values) ਉਪਰ ਅਰਿੱਥਮੈਟਿਕ (ਗਣਿਤਿਕ/ mathematical) ਆਪਰੇਸ਼ਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਟੇਬਲ ਅਰਿੱਥਮੈਟਿਕ ਆਪਰੇਟਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਆਪਰੇਸ਼ਨਾਂ ਅਤੇ ਢੁਕਵੀਂਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲ ਦਰਸਾ ਰਿਹਾ ਹੈ:
ਆਪਰੇਟਰ ਦਾ ਚਿੰਨ੍ਹ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ |
+ | ਜੋੜ ਕਰਨ ਲਈ (Addition) | 5 + 10 = 15 |
- | ਘਟਾਓ ਕਰਨ ਲਈ (Subtraction) | 5 – 10 = -5 |
* | ਗੁਣਾ ਕਰਨ ਲਈ (Multiplication) | 5 * 10 = 50 |
/ | ਰੀਅਲ ਡਿਵੀਜ਼ਨ ਕਰਨ ਲਈ (Real Division) | 19 / 5 = 3.8 |
// | ਇੰਟੀਜ਼ਰ ਡਿਵੀਜ਼ਨ ਕਰਨ ਲਈ (Integer Division) | 19 // 5 = 4 |
% | ਮਾਡੂਲਸ (ਸ਼ੇਸ਼ਫਲ) ਪਤਾ ਕਰਨ ਲਈ (Modulus) | 19 % 5 = 4 |
** | ਐਕਸਪੋਨੈਂਟ ਪਤਾ ਕਰਨ ਲਈ (Exponent) | 5 ** 2 = 25 |
ਰਿਲੇਸ਼ਨਲ (ਤੁਲਨਾਤਮਕ) ਆਪਰੇਟਰਜ਼
ਰਿਲੇਸ਼ਨਲ ਆਪਰੇਟਰਾਂ ਨੂੰ ਤੁਲਨਾਤਮਕ (Comparison) ਆਪਰੇਟਰ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਆਪਰੇਟਰ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਤੁਲਨਾ ਦੌਰਾਨ, ਖੱਬੇ ਆਪਰੇਂਡ ਦੇ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਸੱਜੇ ਆਪਰੇਂਡ ਦੇ ਮੁੱਲ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਤੁਲਨਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਓਪਰੇਟਰ ਸਹੀ (True) ਜਾਂ ਗਲਤ (False) ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ।
ਆਪਰੇਟਰ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ |
== | ਬਰਾਬਰ ਹੈ (Equal) | 4 == 5 ਗਲਤ (False) ਹੈ। |
!= | ਬਰਾਬਰ ਨਹੀਂ ਹੈ (Not Equal) | 4 != 5 ਸਹੀ(true) ਹੈ। |
> | ਵੱਡਾ ਹੈ (Greater Than) | 4 > 5 ਗਲਤ (False) ਹੈ। |
< | ਛੋਟਾ ਹੈ (Less Than) | 4 < 5 ਸਹੀ(true) ਹੈ। |
>= | ਵੱਡਾ ਹੈ ਜਾਂ ਬਰਾਬਰ ਹੈ (Greater than or Equal to) | 4 >= 5 ਗਲਤ (False) ਹੈ। |
<= | ਛੋਟਾ ਹੈ ਜਾਂ ਬਰਾਬਰ ਹੈ (Less than or Equal to) | 4 <= 5 ਸਹੀ(true) ਹੈ। |
ਲਾਜੀਕਲ (ਬੂਲੀਅਨ) ਆਪਰੇਟਰਜ਼
ਲਾਜ਼ੀਕਲ ਆਪਰੇਟਰਾਂ ਨੂੰ ਬੂਲੀਅਨ ਓਪਰੇਟਰ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਆਪਰੇਟਰ ਆਪਰੇਡਾਂ 'ਤੇ ਲਾਜ਼ੀਕਲ ਆਪਰੇਸ਼ਨ ਕਰਵਾਉਣ ਤੋਂ ਬਾਅਦ ਨਤੀਜੇ ਦੇ ਅਧਾਰ 'ਤੇ ਬੂਲੀਅਨ ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਇਹਨਾਂ ਆਪਰੇਟਰਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਸਾਨੂੰ ਕਈ ਟੈਸਟ-ਕੰਡੀਸ਼ਨਾਂ (multiple test conditions) ਦੀ ਤੁਲਨਾ ਕਰਨ ਦੀ ਜਰੂਰਤ ਪੈਂਦੀ ਹੈ।
ਆਪਰੇਟਰ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ |
and | ਇਹ ਆਪਰੇਟਰ ਉਸ ਸਮੇਂ true ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਦੋਂ ਦੋਵੇਂ ਆਪਰੇਂਡ true ਜਾਂ ਨਾਨ-ਜ਼ੀਰੋ ਹੋਣ। | (5>4 and 5>2) ਸਹੀ (true) ਵਾਪਿਸ ਕਰੇਗਾ |
or | ਇਹ ਆਪਰੇਟਰ ਉਸ ਸਮੇਂ true ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਦੋਂ ਦੋਵਾਂ ਵਿਚੋਂ ਕੋਈ ਇਕ ਆਪਰੇਂਡ true ਜਾਂ ਨਾਨ-ਜ਼ੀਰੋ ਹੋਵੇ। | (5>4 or 5<2) ਸਹੀ (true) ਵਾਪਿਸ ਕਰੇਗਾ |
not | ਇਹ ਆਪਰੇਟਰ ਆਪਣੇ ਆਪਰੇਂਡ ਦੀ ਲਾਜ਼ੀਕਲ ਸਟੇਟ ਨੂੰ ਉਲਟਾਉਂਦਾ ਹੈ। | Not (5>4) ਗਲਤ (false) ਵਾਪਿਸ ਕਰੇਗਾ। |
ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰਜ਼
ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਮੁੱਲ ਅਸਾਈਨ (assign) ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਭਾਵ ਇਹ ਆਪਰੇਟਰ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਐਲੋਕੇਟ (allocate) ਕੀਤੀ ਗਈ ਮੈਮੋਰੀ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਵਾਉਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਮੰਤਵ ਲਈ = ਚਿੰਨ੍ਹ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਅਸਾਈਨ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਮੁੱਲ = ਆਪਰੇਟਰ ਦੇ ਸੱਜੇ ਪਾਸੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਅਤੇ ਉਹ ਵੇਰੀਏਬਲ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਮੁੱਲ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਉਹ = ਆਪਰੇਟਰ ਦੇ ਖੱਬੇ ਪਾਸੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰਾਂ ਦੀਆਂ ਕੁੱਝ ਉਦਾਹਰਣਾਂ ਹੇਠਾਂ ਦਿਤੀਆਂ ਗਈਆਂ ਹਨ:
ਉਦਾਹਰਣ 1: a = 5
ਉਦਾਹਰਣ 2: x = y
ਉਦਾਹਰਣ 3: x=y=6
ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰਜ਼
ਉਦਾਹਰਣ 4: x, y, z = 2, 4, 6
ਇਸ ਉਦਾਹਰਣ ਵਿਚ ਅਸੀਂ ਤਿੰਨ ਮੁੱਲਾਂ 2, 4 ਅਤੇ 6 ਨੂੰ ਤਿੰਨ ਵੇਰੀਏਬਲਾਂ x, y ਅਤੇ z ਨੂੰ ਕ੍ਰਮਵਾਰ ਅਸਾਈਨ ਕੀਤਾ ਹੈ, ਭਾਵ x=2, y=4 and z=6 ਅਸਾਈਨਮੈਂਟ ਕੀਤੀ ਗਈ ਹੈ।
ਉਦਾਹਰਣ 5: a = b + c
ਐਕਸਪ੍ਰੈਸ਼ਨ (b+c) ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਸਦਾ ਨਤੀਜਾ ਵੇਰੀਏਬਲ 'a' ਵਿੱਚ ਸਟੋਰ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ।
ਉਦਾਹਰਣ 6: x=x+5
ਅਜਿਹੀਆਂ ਅਸਾਈਨਮੈਂਟਾਂ ਨੂੰ ਸੈਲਫ-ਅਸਾਈਨਮੈਂਟ ਸਟੇਟਮੈਂਟਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰਜ਼
ਸੈਲਫ-ਅਸਾਈਨਮੈਂਟ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਲਿਖਣ ਦੇ ਅਜਿਹੇ ਤਰੀਕੇ ਨੂੰ ਔਗਮੈਂਟਡ ਅਸਾਈਨਮੈਂਟ (Augmented Assignment) ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਔਗਮੈਂਟਡ ਅਸਾਈਨਮੈਂਟ ਅਸਲ ਵਿੱਚ ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ ਦੇ ਕੰਮ ਨੂੰ ਕਿਸੇ ਹੋਰ ਆਪਰੇਟਰ ਨਾਲ ਜੋੜ ਕੇ ਅਸਾਈਨਮੈਂਟ ਸਟੇਟਮੈਂਟ ਨੂੰ ਹੋਰ ਸੰਖੇਪ (concise) ਬਣਾਉਂਦਾ ਹੈ।
ਉਦਾਹਰਣ 7: x+=5
ਉਪਰੋਕਤ ਉਦਾਹਰਣ ਵਿਚ += ਆਪਰੇਟਰ ਅਰਿੱਥਮੈਟਿਕ ਜੋੜ ਅਤੇ ਅਸਾਈਨਮੈਂਟ ਦੇ ਕੰਮ ਨੂੰ ਇਕੱਠਾ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਆਪਰੇਟਰਾਂ ਨੂੰ ਔਗਮੈਂਟੇਡ ਆਪਰੇਟਰ ਇਸ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਆਪਰੇਟਰ ਆਪਣੇ ਕੰਮ ਨੂੰ ਇਕੋ ਸਮੇਂ ਦੋ ਆਪਰੇਸ਼ਨਾਂ ਤੱਕ ਵਧਾ ਕੇ (extended or augmented) ਅੰਜਾਮ ਦਿੰਦੇ ਹਨ।
ਔਗਮੈਂਟਡ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਮੂਲ ਸਿੰਟੈਕਸ ਹੇਠਾਂ ਦਿਤਾ ਗਿਆ ਹੈ:
variable op = expression
ਇੱਥੇ op ਇੱਕ ਆਮ ਓਪਰੇਟਰ ਲਈ ਇੱਕ ਪਲੇਸਹੋਲਡਰ ਹੈ, ਜਿਸਨੂੰ ਔਗਮੈਂਟਡ ਆਪਰੇਟਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਔਗਮੈਂਟਡ ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਟੇਟਮੈਂਟ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ:
variable = variable op expression
ਔਗਮੈਂਟਡ ਆਈਨਮੈਂਟ ਆਪ੍ਰੇਟਰ
ਹੇਠਾਂ ਦਿੱਤਾ ਟੇਬਲ ਅਰਿੱਥਮੈਟਿਕ ਆਪਰੇਟਰਾਂ ਨਾਲ ਔਗਮੈਂਟਡ ਆਪਰੇਟਰਾਂ ਦੀ ਲਿਸਟ ਦਿਖਾ ਰਿਹਾ ਹੈ:
ਆਪਰੇਟਰ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ | ਬਰਾਬਰ ਹੈ |
+= | ਜੋੜ ਅਸਾਈਨਮੈਂਟ (Addition Assignment) | a += 5 | a = a + 5 |
-= | ਘਟਾਓ ਅਸਾਈਨਮੈਂਟ (Subtraction Assignment) | a -= 5 | a = a - 5 |
*= | ਗੁਣਾ ਅਸਾਈਨਮੈਂਟ (Multiplication Assignment) | a *= 5 | a = a * 5 |
/= | ਇੰਟੀਜ਼ਰ ਡਿਵੀਜ਼ਨ ਅਸਾਈਨਮੈਂਟ (Division Assignment) | a /= 5 | a = a / 5 |
%= | ਮਾਡੂਲਸ ਅਸਾਈਨਮੈਂਟ (Modulus Assignment) | a %= 5 | a = a % 5 |
**= | ਐਕਸਪੋਨੈਂਟ ਅਸਾਈਨਮੈਂਟ (Exponent Assignment) | a **= 2 | a = a ** 5 |
//= | ਫਲੋਰ ਡਿਵੀਜ਼ਨ ਅਸਾਈਨਮੈਂਟ (Floor Division Assignment) | a //= 3 | a = a // 5 |
ਆਈਡੈਂਟਿਟੀ ਆਪਰੇਟਰਜ਼
ਆਈਡੈਂਟਿਟੀ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਆਪਰੇਡਾਂ ਦੀ ਤੁਲਨਾ (compare) ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਤੁਲਨਾ ਦੌਰਾਨ ਇਹ ਆਪਰੇਟਰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਟੈਸਟ ਕਰਦਾ ਹੈ:
ਤੁਲਨਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਇਹ ਆਪਰੇਟਰ ਸਹੀ (True) ਜਾਂ ਗਲਤ (False) ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ।
ਆਪਰੇਟਰ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ |
is | ਜੇਕਰ ਦੋਵੇਂ ਆਪਰੇਂਡ ਇੱਕ ਹੀ ਆਬਜੈਕਟ (same object) ਹਨ ਤਾਂ ਇਹ ਆਪਰੇਟਰ True ਵਾਪਸ ਕਰਦਾ ਹੈ। | x=y=5 print(x is y) ਇਹ True ਦਿਖਾਏਗਾ z=10 print(x is z) ਇਹ False ਦਿਖਾਏਗਾ |
is not | ਜੇਕਰ ਦੋਵੇਂ ਆਪਰੇਂਡ ਇੱਕ ਹੀ ਆਬਜੈਕਟ (same object) ਨਹੀਂ ਹਨ ਤਾਂ ਇਹ ਆਪਰੇਟਰ True ਵਾਪਸ ਕਰਦਾ ਹੈ। | x=y=5 print(x is not y) ਇਹ False ਦਿਖਾਏਗਾ z=10 print(x is not z) ਇਹ True ਦਿਖਾਏਗਾ |
ਆਈਡੈਂਟਿਟੀ ਆਪਰੇਟਰਜ਼
ਮੈਂਬਰਸ਼ਿੱਪ ਆਪਰੇਟਰਜ਼
ਇਹਨਾਂ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਦਿੱਤੇ ਗਏ ਸਿਕੁਐਂਸ (sequence) ਟਾਈਪਸ, ਜਿਵੇਂ ਕਿ ਸਟ੍ਰਿੰਗ, ਲਿਸਟਾਂ, ਜਾਂ ਟੂਪਲਜ਼ ਆਦਿ ਵਿੱਚ ਇੱਕ ਮੁੱਲ ਸਰਚ (search) ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਸਰਚ ਨਤੀਜੇ ਦੇ ਆਧਾਰ 'ਤੇ, ਇਹ ਆਪਰੇਟਰ ਸਹੀ (True) ਜਾਂ ਗਲਤ (False) ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਪਾਈਥਨ ਵਿੱਚ ਦੋ ਮੈਂਬਰਸ਼ਿਪ ਆਪਰੇਟਰ ਹਨ, ਜਿਵੇਂ ਕਿ: ਹੇਠਾਂ ਦਿੱਤੇ ਟੇਬਲ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:
ਆਪਰੇਟਰ | ਆਪਰੇਟਰ ਦੀ ਵਿਆਖਿਆ | ਉਦਾਹਰਣ |
in | ਜੇਕਰ ਦਿੱਤੇ ਗਏ ਸਿਕੁਐਂਸ ਵਿੱਚ ਨਿਰਧਾਰਤ ਮੁੱਲ ਮੌਜੂਦ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਪਰੇਟਰ True ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ ਨਹੀਂ ਤਾਂ ਇਹ False ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ। | s=[2,4,8,10] print(8 in s) ਇਹ True ਦਿਖਾਵੇਗਾ। |
not in | ਜੇਕਰ ਦਿੱਤੇ ਗਏ ਸਿਕੁਐਂਸ ਵਿੱਚ ਨਿਰਧਾਰਤ ਮੁੱਲ ਮੌਜੂਦ ਨਹੀਂ ਹੁੰਦਾ, ਤਾਂ ਇਹ ਆਪਰੇਟਰ True ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ ਨਹੀਂ ਤਾਂ ਇਹ False ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ। | s=[2,4,8,10] print(8 not in s) ਇਹ False ਦਿਖਾਵੇਗਾ |
ਆਪਰੇਟਰ ਪ੍ਰੈਸੀਡੇਂਸ
ਆਪਰੇਟਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਮੁਲਾਂਕਣ ਕ੍ਰਮ ਅਨੁਸਾਰ ਲੜੀਵਾਰ ਤੌਰ 'ਤੇ (hierarchically) ਸਮੂਹਬੱਧ (grouped) ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸਨੂੰ ਪ੍ਰੈਸੀਡੇਂਸ (Precedence) ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਉੱਚ ਤਰਜੀਹ ਵਾਲੇ ਆਪਰੇਟਰ ਉਪਰ ਘੱਟ ਤਰਜੀਹ ਵਾਲੇ ਆਪਰੇਟਰਾਂ ਤੋਂ ਪਹਿਲਾਂ ਕੰਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਆਪਰੇਟਰ ਪ੍ਰੈਸੀਡੇਂਸ ਉਸ ਕ੍ਰਮ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿੱਚਲੇ ਆਪਰੇਡਾਂ ਉੱਤੇ ਆਪਰੇਸ਼ਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਦਰਤੀ ਕ੍ਰਮ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਮਾਨ ਤਰਜੀਹ ਵਾਲੇ ਆਪਰੇਟਰ ਵੀ ਮੌਜੂਦ ਹੋ ਸਕਦੇ ਹਨ। ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿੱਚ ਇੱਕੋ ਤਰਜੀਹ ਵਾਲੇ ਆਪਰੇਟਰਾਂ ਦਾ ਖੱਬੇ-ਤੋਂ-ਸੱਜੇ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ
ਆਪਰੇਟਰ ਪ੍ਰੈਸੀਡੇਂਸ
ਹੇਠਾਂ ਦਿੱਤਾ ਟੇਬਲ ਪਾਈਥਨ ਦੇ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਆਪਰੇਟਰਾਂ ਦੀ ਉੱਚ ਤਰਜੀਹ (High Precedence) ਤੋਂ ਘੱਟ ਤਰਜੀਹ (Low Precedence) ਤੱਕ ਦੀ ਸੂਚੀ ਦਿਖਾ ਰਿਹਾ ਹੈ:
ਆਪਰੇਟਰ ਅਤੇ ਵਿਆਖਿਆ (Operator & Description) | ਪ੍ਰੈਸੀਡੇਂਸ |
( ) (Parenthesis) | Highest |
** (Exponentiation) | High to Low Precedence |
+, - (unary plus and minus, as a +ve or –ve number) |
|
*, /, %, // (Multiply, divide, modulo and floor division) |
|
+, - (Addition and subtraction) |
|
<=, <, >, >= (Comparison operators) |
|
==, != (Equality operators) |
|
=, %=, /=, //=, -=, +=, *=, **= (Assignment operators) |
|
is, is not (Identity operators) |
|
in, not in (Membership operators) |
|
not, or, and (Logical operators) | Lowest |
High to Low Precedence
High to Low Precedence
ਪਾਈਥਨ ਵਿਚ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਅਸੀਂ ਕੰਟਰੋਲ ਫਲੋ ਸਟੇਟਮੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋਅ (execution flow) ਨੂੰ ਕੰਟਰੋਲ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਢੁਕਵੀਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲ ਅਜਿਹੇ ਕੰਟਰੋਲ ਫਲੋਅ (control flow) ਸਟੇਟਮੈਂਟਸ ਦੀ ਚਰਚਾ ਕਰਾਂਗੇ ਜੋ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋਅ ਉਪਰ ਵਧੇਰੇ ਕੰਟਰੋਲ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰਦੇ ਹਨ। ਪਰ ਇਹਨਾਂ ਕੰਟਰੋਲ ਫਲੋਅ ਸਟੇਟਮੈਂਟਾਂ 'ਤੇ ਚਰਚਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਕੰਟਰੋਲ ਫਲੋਅ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਬਲਾਕਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਇੰਡੈਂਟੇਸ਼ਨ ਦੇ ਮਹੱਤਵ ਨੂੰ ਸਮਝਣਾ ਪਵੇਗਾ।
ਇੰਡੈਂਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ : ਕੋਡ ਲਾਈਨ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਛੱਡੀਆਂ ਗਈਆਂ ਖਾਲੀ ਥਾਂਵਾਂ (spaces) ਨੂੰ ਇੰਡੈਂਟੇਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਬਲਾਕ ਦੇ ਅੰਦਰ ਸਾਰੀਆਂ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਇਕੋ ਜਿੰਨ੍ਹੀ ਮਾਤਰਾ ਵਿੱਚ ਇੰਡੈਂਟ ਕੀਤਾ ਜਾਣਾ ਜਰੂਰੀ ਹੁੰਦਾ ਹੈ।
Following is the correct example of indentation:
if True:
print "Hello"
else:
print "Hi"
Following block generates an error due to incorrect example of indentation:
if True:
print "Hello"
else:
print "Hi"
ਬਲਾਕ-1
ਬਲਾਕ-2
ਪਾਈਥਨ ਵਿਚ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਫਲੋਅ ਕੰਟਰੋਲ ਦਾ ਅਰਥ ਹੈ ਉਹ ਕ੍ਰਮ (sequence) ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਲਿਖੇ ਸਟੇਟਮੈਂਟਸ ਜਾਂ ਹਦਾਇਤਾਂ (instructions) ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਪ੍ਰੋਗਰਾਮ ਦੇ ਫਲੋਅ (ਪ੍ਰਵਾਹ) ਨੂੰ ਸਮਝਣਾ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਕਿਸੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਬਿਹਤਰ ਸਮਝ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸਾਨੂੰ ਇਸ ਗੱਲ ਬਾਰੇ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਕਦੋਂ ਲਾਗੂ ਕੀਤਾ ਜਾਣਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾਣਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਤਿੰਨ ਤਰੀਕਿਆਂ ਨਾਲ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:
ਸੀਕੁਐਂਸ਼ੀਅਲ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਕ੍ਰਮਵਾਰ (sequential) ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਤੱਕ ਲਾਈਨ-ਦਰ-ਲਾਈਨ ਉਸੇ ਕ੍ਰਮ ਵਿਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਨੂੰ ਸੀਕੁਐਂਸ਼ੀਅਲ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸਦੀ ਉਦਾਹਰਣ ਦਰਸਾਉਂਦਾ ਪ੍ਰੋਗਰਾਮ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:
ਕੰਡੀਸ਼ਨਲ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਇਹਨਾਂ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਬ੍ਰਾਂਚਿੰਗ (Branching) ਜਾਂ ਫੈਸਲੇ ਲੈਣ (Decision-Making) ਵਾਲੇ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਫਲੋਅ ਕੰਟਰੋਲਸ ਵਿੱਚ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋ (Execution flow) ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਸਹੀ (TRUE) ਹੈ ਜਾਂ ਗਲਤ (FALSE)। ਜੇਕਰ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਸਹੀ (TRUE) ਹੁੰਦਾ ਹੈ ਤਾਂ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਇੱਕ ਸੈੱਟ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਜਾਵੇਗਾ, ਨਹੀਂ ਤਾਂ (ਜੇ ਦਿੱਤੀ ਕੰਡੀਸ਼ਨ ਗਲਤ (FALSE) ਹੁੰਦੀ ਹੈ) ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਦੂਜੇ ਸੈੱਟ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਜਾਵੇਗਾ।
ਕੰਡੀਸ਼ਨਲ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਆਉ ਕੁੱਝ ਢੁਕਵੀਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟਸ ਦੀ ਵਿਸਥਾਰ ਵਿੱਚ ਚਰਚਾ ਕਰੀਏ। ਪਾਈਥਨ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟਸ ਦੀਆਂ ਕਿਸਮਾਂ ਹੇਠ ਲਿਖੀਆਂ ਹਨ:
if ਸਟੇਟਮੈਂਟ (if statement)
ਇਹ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰਦਾ ਹੈ, ਪਰ ਕੇਵਲ ਉਸ ਸਮੇਂ ਜਦੋਂ ਇੱਕ ਖਾਸ ਕੰਡੀਸ਼ਨ ਸਹੀ (True) ਹੁੰਦੀ ਹੈ। ਕੰਡੀਸ਼ਨ ਇੱਕ BOOL ਕਿਸਮ ਦੇ ਰੂਪ ਵਿੱਚ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ - ਸਹੀ (True) ਜਾਂ ਗਲਤ (False)। ਜੇਕਰ ਕੰਡੀਸ਼ਨ ਦਾ ਨਤੀਜਾ ਸਹੀ (True) ਆਉਂਦਾ ਹੈ, ਤਾਂ "if ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਬਲਾਕ" ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ। ਜੇਕਰ ਕੰਡੀਸ਼ਨ ਦਾ ਨਤੀਜਾ ਗਲਤ (False) ਹੁੰਦਾ ਹੈ, ਤਾਂ "if ਸਟੇਟਮੈਂਟਾਂ ਦਾ ਬਲਾਕ" ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ।
if ਸਟੇਟਮੈਂਟ (if statement)
ਇਕ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਰਾਹੀਂ ਪਾਈਥਨ ਵਿਚ if ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਨੂੰ ਹੇਠਾਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ:
if ਸਟੇਟਮੈਂਟ (if statement)
ਪ੍ਰੋਗਰਾਮ test1.py ਨੂੰ ਦੂਜੀ ਵਾਰ ਚਲਾਉਣ ਸਮੇਂ ਮੁੱਲ 2 ਇਨਪੁੱਟ ਕਰਕੇ ਵੇਰੀਏਬਲ 'a' ਨੂੰ ਅਸਾਈਨ ਕੀਤਾ ਗਿਆ। ਇਸ ਲਈ, if ਸਟੇਟਮੈਂਟ ਦੀ ਕੰਡੀਸ਼ਨ a == “1” (ਜੋ ਕਿ “2” == “1” ਹੈ) ਦਾ ਮੁਲਾਂਕਣ False ਵਿੱਚ ਕੀਤਾ ਗਿਆ, ਜਿਸ ਕਾਰਨ “if condition:” ਦੇ ਬਲਾਕ ਵਾਲੇ print ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਅਤੇ if ਬਲਾਕ ਤੋਂ ਬਾਅਦ ਵਾਲੀ ਸਟੇਟਮੈਂਟ ਨੂੰ ਚਲਾਇਆ ਗਿਆ।
if-else ਸਟੇਟਮੈਂਟ (if-else statement)
ਇਹ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦਾ ਇੱਕ ਹੋਰ ਰੂਪ ਹੈ। if-else ਸਟੇਟਮੈਂਟ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੀ ਹੈ ਅਤੇ ਮੁਲਾਂਕਣ ਤੋਂ ਬਾਅਦ ਜੇਕਰ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਸਹੀ (True) ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ if ਬਲਾਕ ਦੇ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਕੰਡੀਸ਼ਨ ਦੇ ਮੁਲਾਂਕਣ ਦਾ ਨਤੀਜਾ ਗਲਤ (False) ਆਉਂਦਾ ਹੈ, ਤਾਂ ਇਹ else ਬਲਾਕ ਦੇ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ। ਇਸ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋਅ ਨੂੰ if-else ਸਟੇਟਮੈਂਟ ਦੇ ਫਲੋਅ-ਗ੍ਰਾਫ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ if-else ਸਟੇਟਮੈਂਟ ਦਾ ਸਿੰਟੈਕਸ ਚਿੱਤਰ 7.8 ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
if-else ਸਟੇਟਮੈਂਟ (if-else statement)
ਇਹ ਪ੍ਰੋਗਰਾਮ ਦੋ ਦਿੱਤੇ ਗਏ ਮੁੱਲਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡਾ (largest) ਮੁੱਲ ਪਤਾ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ:
ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਅਸੀਂ ਯੂਜ਼ਰ ਤੋਂ ਦੋ ਨੰਬਰ (num1 ਅਤੇ num2) ਇਨਪੁੱਟ ਕਰਵਾ ਰਹੇ ਹਾਂ । ਜੇਕਰ ਇਸ ਕੰਡੀਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਸਹੀ (True) ਆਉਂਦਾ ਹੈ, ਤਾਂ if ਸਟੇਟਮੈਂਟ ਦਾ ਬਲਾਕ ਐਗਜ਼ੀਕਿਊਟ ਹੋ ਜਾਵੇਗਾ, ਨਹੀਂ ਤਾਂ else ਭਾਗ ਵਾਲਾ ਬਲਾਕ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਜਾਵੇਗਾ।
if-elif-else ਸਟੇਟਮੈਂਟ (if-elif-else Statement)
ਇਹ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦਾ ਇੱਕ ਹੋਰ ਰੂਪ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਕਈ ਕੰਡੀਸ਼ਨਾਂ ਦੀ ਟੈਸਟ/ਜਾਂਚ (test multiple conditions) ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਟੇਟਮੈਂਟ ਵਿਚ ਵਰਤਿਆ ਜਾਂਦਾ elif "else if" ਦਾ ਛੋਟਾ ਰੂਪ ਹੈ। ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦੇ ਇਸ ਰੂਪ ਵਿੱਚ if condition: ਸਟੇਟਮੈਂਟ ਨੂੰ elif condition: ਅਤੇ else: ਸਟੇਟਮੈਂਟਸ ਨਾਲ ਟੈਸਟਾਂ ਦੀ ਇੱਕ ਲੜੀ (series of test) ਨੂੰ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਟੇਟਮੈਂਟ ਵਿਚ ਅਸੀਂ elif ਦਾ ਅਰਥ ਇਸ ਤਰ੍ਹਾਂ ਸਮਝ ਸਕਦੇ ਹਾਂ, "ਜੇ ਪਿਛਲੀ ਕੰਡੀਸ਼ਨ ਸਹੀ ਨਹੀਂ (not true) ਸੀ, ਤਾਂ ਇਸ if condition ਦੀ ਜਾਂਚ ਕਰੋ"। ਚਿੱਤਰ: 7.10 ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਸਿੰਟੈਕਸ ਅਨੁਸਾਰ ਹਰੇਕ condition ਅਤੇ else ਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਅਦ ਕੋਲਨ (:) ਲਗਾਉਣਾ ਜਰੂਰੀ ਹੁੰਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ ਪਾਈਥਨ ਇੱਕ ਸਿੰਟੈਕਸ ਐਰਰ ਦਿਖਾਵੇਗਾ।
if-elif-else ਸਟੇਟਮੈਂਟ (if-elif-else Statement)
ਅਸੀਂ ਆਪਣੀ ਜਰੂਰਤ ਅਨੁਸਾਰ ਜਿੰਨੇ ਮਰਜੀ ਵਾਰ ਇਸ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦੇ if ਅਤੇ else ਭਾਗਾਂ ਵਿਚਕਾਰ elif ਸਟੇਟਮੈਂਟਾਂ ਰੱਖ ਸਕਦੇ ਹਾਂ। ਇੱਕ if ਤੋਂ ਬਾਅਦ elif ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਕਈ ਵਾਰ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ else ਭਾਗ ਵੱਧ ਤੋਂ ਵੱਧ ਇੱਕ ਵਾਰ ਹੀ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। C, C++ ਅਤੇ Java ਵਰਗੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੀ ਤਰ੍ਹਾਂ ਕੋਰ ਪਾਈਥਨ switch-case ਸਟੇਟਮੈਂਟ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਪਰ ਅਸੀਂ switch-case ਸਟੇਟਮੈਂਟ ਦੀ ਦੀ ਜਗ੍ਹਾ if-elif-else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਚਿੱਤਰ if-elif-else ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦੇ ਫਲੌਅ-ਗ੍ਰਾਫ ਨੂੰ ਦਿਖਾ ਰਿਹਾ ਹੈ:
if-elif-else ਸਟੇਟਮੈਂਟ (if-elif-else Statement)
ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਪਾਈਥਨ ਵਿੱਚ if-elif-else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾ ਰਿਹਾ ਹੈ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਤਿੰਨ ਦਿੱਤੇ ਗਏ ਮੁੱਲਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡਾ ਮੁੱਲ ਪਤਾ ਕਰ ਰਿਹਾ ਹੈ: ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਅਸੀਂ ਕੀਬੋਰਡ ਰਾਹੀਂ ਤਿੰਨ ਨੰਬਰ (num1, num2, num3) ਪ੍ਰਾਪਤ ਕਰ ਰਹੇ ਹਾਂ ਅਤੇ if-elif-else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਟੈਸਟ ਕਰਦੇ ਹਾਂ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ if condition: ਨੂੰ ਟੈਸਟ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿੱਥੇ “and” ਲਾਜ਼ੀਕਲ ਆਪਰੇਟਰ (num1>num2 and num1>num3) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੋ ਕੰਡੀਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਹੈ ਜੋ ਸਿਰਫ ਉਦੋਂ ਹੀ ਸਹੀ (true) ਨਤੀਜਾ ਪ੍ਰਦਾਨ ਕਰੇਗੀ ਜਦੋਂ ਦੋਵੇਂ ਕੰਡੀਸ਼ਨਾਂ ਸਹੀ (true) ਹੋਣਗੀਆਂ।
ਆਊਟਪੂੱਟ
ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ
ਇਹ if ਸਟੇਟਮੈਂਟ ਦਾ ਇੱਕ ਹੋਰ ਰੂਪ ਹੈ ਜੋ ਉਸ ਸਮੇਂ ਉਪਯੋਗੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਫੈਸਲਿਆਂ ਦੀ ਇੱਕ ਲੜੀ (series of decisions) ਬਨਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ ਵਿਚ ਇੱਕ if-else ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਇੱਕ ਹੋਰ if-else ਸਟੇਟਮੈਂਟ ਲਿਖੀ ਜਾਂਦੀ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਅਸੀਂ ਇੱਕ if-else ਸਟੇਟਮੈਂਟ ਅੰਦਰ ਕਿੰਨ੍ਹੀਆਂ ਮਰਜੀ if-else ਸਟੇਟਮੈਂਟਸ ਲਗਾ ਕੇ ਨੈਸਟਿੰਗ ਕਰ ਸਕਦੇ ਹਾਂ। ਨੈਸਟਿੰਗ ਦੇ ਲੇਵਲ ਨੂੰ ਵੱਖ ਕਰਨ ਦਾ ਇੱਕੋ ਇੱਕ ਤਰੀਕਾ ਹੈ ਇੰਡੈਂਟੇਸ਼ਨ। ਅੱਗੇ ਦਿਤਾ ਗਿਆ ਫਲੋਅ-ਗ੍ਰਾਫ ਪਾਈਥਨ ਵਿੱਚ ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋਅ ਨੂੰ ਦਰਸਾ ਰਿਹਾ ਹੈ:
ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ
ਨੈਸਟਡ if ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਅਸੀਂ ਇੱਕ if-elif-else ਸਟੇਟਮੈਂਟ ਵਿਚ ਹੋਰ if-elif-else ਸਟੇਟਮੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵੀ ਨੈਸਟਿੰਗ ਕਰ ਸਕਦੇ ਹਾਂ।
ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ
ਅੱਗੇ ਦਿੱਤਾ ਗਿਆ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਪਾਈਥਨ ਵਿੱਚ ਨੈਸਟਡ if-else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾ ਰਿਹਾ ਹੈ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿਚ ਅਸੀਂ ਸਿਰਫ if ਬਲਾਕ ਦੇ ਅੰਦਰ “if-else” ਬਲਾਕ ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ। ਅਸੀਂ “else” ਬਲਾਕ ਦੇ ਅੰਦਰ ਵੀ ਜਰੂਰਤ ਅਨੁਸਾਰ ਹੋਰ “if-else” ਬਲਾਕ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਾਂ।
ਆਊਟਪੁੱਟ
ਮਹੱਤਵਪੂਰਨ ਨੋਟ
ਜਦੋਂ ਵੀ ਅਸੀਂ ਕੋਡ ਦੇ ਇੱਕ ਬਲਾਕ ਵਿਚ ਮਲਟੀਪਲ ਸਟੇਟਮੈਂਟਸ ਲਿਖਦੇ ਹਾਂ, ਤਾਂ ਇੰਡੈਂਟੇਸ਼ਨ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੀ ਹੈ। ਪਰ ਕਈ ਵਾਰ, ਅਜਿਹੀ ਸਥਿਤੀ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਬਲਾਕ ਵਿੱਚ ਸਿਰਫ਼ ਸਿੰਗਲ ਲਾਈਨ ਸਟੇਟਮੈਂਟ ਹੁੰਦੀ ਹੈ। ਕੋਲਨ ਦੇ ਬਾਅਦ ਇੱਕ ਬਲਾਕ ਲਿਖਣ ਦੀ ਬਜਾਏ ਅਸੀਂ ਕੋਲਨ ਦੇ ਤੁਰੰਤ ਬਾਅਦ ਵੀ ਇਹ ਸਿੰਗਲ ਸਟੇਟਮੈਂਟ ਲਿਖ ਸਕਦੇ ਹਾਂ। ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਉਦਾਹਰਨ ਦਿੱਤੀ ਗਈ ਹੈ:
ਉਪਰੋਕਤ ਪ੍ਰੋਗਰਾਮ ਦੀ ਆਊਟਪੁੱਟ
ਆਈਟ੍ਰੇਟਿਵ ਫਲੋਅ ਕੰਟਰੋਲ ਸਟੇਟਮੈਂਟਸ
ਆਈਟ੍ਰੇਟਿਵ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਲੂਪਿੰਗ (Looping) ਜਾਂ ਦੁਹਰਾਉਣ ਵਾਲੇ (repetitive) ਸਟੇਟਮੈਂਟਸ ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਇਹ ਸਟੇਟਮੈਂਟਸ ਸਾਨੂੰ ਕੋਡ ਦੇ ਇੱਕ ਬਲਾਕ ਨੂੰ ਵਾਰ-ਵਾਰ (repeatedly) ਚਲਾਉਣ ਦੀ ਸਹੁਲਤ ਦਿੰਦੀਆਂ ਹਨ। ਪਾਈਥਨ ਸਾਨੂੰ ਕਿਸੇ ਕੰਮ ਨੂੰ ਵਾਰ-ਵਾਰ ਕਰਵਾਉਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਦੋ ਲੂਪਿੰਗ ਸਟੇਟਮੈਂਟ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:
for ਲੂਪ (for loop)
for ਲੂਪ ਨੂੰ ਕਾਉਂਟਿੰਗ ਲੂਪ ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਲੂਪ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਤੱਕ (fixed number of times) ਕਿਸੇ ਕੰਮ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ ਜਦੋਂ ਵੀ ਅਸੀਂ for ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੋਵੇ ਤਾਂ ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਵੇਗੀ ਕਿ ਕੋਡ ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਦੁਹਰਾਉਣਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ: 5 ਵਾਰ, 10 ਵਾਰ, n ਵਾਰ ਆਦਿ। ਜਦੋਂ ਅਸੀਂ for ਲੂਪ ਨੂੰ ਕਿਸੇ ਖਾਸ ਸੰਖਿਆ ਤੱਕ ਚਲਾਉਣਾ ਹੋਵੇ ਤਾਂ range(lower_limit, upper_limit) ਫੰਕਸ਼ਨ ਲੂਪ ਚਲਾਉਣ ਵਿਚ ਅਹਿਮ ਭੂਮਿਕਾ ਨਿਭਾ ਸਕਦਾ ਹੈ। range() ਫੰਕਸ਼ਨ lower_limit ਤੋਂ upper_limit -1 ਤੱਕ ਮੁੱਲਾਂ ਦਾ ਇਕ ਸੈੱਟ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਇਸ ਕਿਤਾਬ ਦੇ ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ ਢੁਕਵੀਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲ range() ਫੰਕਸ਼ਨ ਬਾਰੇ ਪਹਿਲਾਂ ਹੀ ਚਰਚਾ ਕਰ ਚੁੱਕੇ ਹਾਂ।
for ਲੂਪ (for loop)
ਫਲੌਅ-ਗ੍ਰਾਫ ਦੇ ਰੂਪ ਵਿੱਚ ਲੂਪ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋ ਨੂੰ ਦਰਸਾ ਰਿਹਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ for ਲੂਪ ਦੀ ਵਰਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਸਿਕੁਐਂਸ (sequence) ਜਿਵੇਂ ਕਿ: ਲਿਸਟ, ਟੂਪਲ, ਡਿਕਸ਼ਨਰੀ, ਜਾਂ ਸੈੱਟ ਆਦਿ ਉਪਰ ਕਿਸੇ ਕੰਮ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਲਿਸਟ, ਟੂਪਲ, ਜਾਂ ਡਿਕਸ਼ਨਰੀ ਆਦਿ ਵਿੱਚ ਮੌਜੂਦ ਹਰੇਕ ਆਈਟਮ ਉਪਰ ਕੋਈ ਕੰਮ ਕਰਵਾਉਣ ਲਈ ਸਟੇਟਮੈਂਟਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਚਲਾ ਸਕਦੇ ਹਾਂ।
for ਲੂਪ (for loop)
ਹੇਠਾਂ for ਲੂਪ ਦੀ ਉਦਾਹਰਣ ਦਿੱਤੀ ਗਈ ਹੈ ਜਿਸ ਵਿਚ ਅਸੀਂ 1, 2, 3 ਅਤੇ 4 ਨੰਬਰਾਂ ਨੂੰ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪ੍ਰਿੰਟ ਕਰਵਾ ਰਹੇ ਹਾਂ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿਚ for ਲੂਪ ਚਿੱਤਰ: 7.16 ਵਿਚ ਦਰਸਾਏ ਗਏ ਫਲੋ-ਗ੍ਰਾਫ ਅਨੁਸਾਰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਕਰੇਗਾ। ਉਪਰੋਕਤ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ range(1, 5) ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ ਜੋ lower_limit (1) ਤੋਂ upper_limit-1 (5-1=4) ਤੱਕ ਸੰਖਿਆਵਾਂ ਦਾ ਇੱਕ ਕ੍ਰਮ, ਅਰਥਾਤ 1, 2, 3, 4 (ਇੱਥੇ, ਡਿਫਾਲਟ ਵਾਧਾ ਮੁੱਲ 1 ਹੈ) ਜੈਨਰੇਟ ਕਰੇਗਾ। range() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਜੈਨਰੇਟ ਕੀਤੇ ਗਏ ਕ੍ਰਮ ਦੀ ਹਰੇਕ ਸੰਖਿਆ ਨੂੰ ਫਿਰ ਹਰੇਕ ਦੁਹਰਾਓ (iteration) 'ਤੇ ਵੇਰੀਏਬਲ 'i' ਵਿੱਚ ਇੱਕ ਇੱਕ ਕਰਕੇ ਲਿਆਂਦਾ ਜਾਵੇਗਾ।
while ਲੂਪ (while loop)
while ਲੂਪ ਨੂੰ ਕੰਡੀਸ਼ਨਲ (Conditional) ਲੂਪ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਸ ਲੂਪ ਵਿੱਚ ਹਰ ਵਾਰ ਲੂਪ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਇੱਕ ਕੰਡੀਸ਼ਨ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਜੇਕਰ ਇਹ ਕੰਡੀਸ਼ਨ ਸਹੀ (true) ਹੋਵੇ, ਤਾਂ ਲੂਪ ਦੀ ਬਾਡੀ ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ; ਜਦੋਂ ਕੰਡੀਸ਼ਨ ਗਲਤ (false) ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਫਲੋਅ ਲੂਪ ਤੋਂ ਬਾਹਰ ਆ ਜਾਂਦਾ ਹੈ। ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਅਸੀਂ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਿ ਜਦੋਂ ਤੱਕ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਸੰਤੁਸ਼ਟ (satisfied) ਰਹਿੰਦੀ ਹੈ ਓਦੋਂ ਤੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਬਲਾਕ ਨੂੰ ਵਾਰ-ਵਾਰ ਚਲਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
while ਲੂਪ (while loop)
ਆਓ ਹੁਣ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ ਜਿੱਥੇ ਅਸੀਂ while ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਹਿਲੇ 5 ਨੰਬਰਾਂ ਦਾ ਜੋੜ ਕੈਲਕੁਲੇਟ ਕਰ ਰਹੇ ਹਾਂ।
while ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਅ (iteration) ਦੌਰਾਨ ਦੋ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਉਸ ਸਮੇਂ ਤੱਕ ਵਾਰ-ਵਾਰ ਚਲਾਇਆ ਜਾਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ (i <= 5) ਸੰਤੁਸ਼ਟ (satisfied) ਰਹੇਗੀ; ਭਾਵ ਜਦੋਂ ਤੱਕ ਦਿੱਤੀ ਗਈ ਕੰਡੀਸ਼ਨ ਦਾ ਨਤੀਜਾ ਸਹੀ ਰਹੇਗਾ ਉਸ ਸਮੇਂ ਤੱਕ ਲੂਪ, ਬਾਡੀ ਵਿਚਲੀਆਂ ਸਟੇਟਮੈਂਟਸ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਰਹੇਗਾ।
sum ਵੇਰੀਏਬਲ ਨੂੰ sum ਦੇ ਪਿਛਲੇ (previous) ਮੁੱਲ ਅਤੇ 'i' ਦੇ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ ਜੋੜ ਕੇ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਰਹੇਗਾ, i.e. sum = sum + i
ਕਾਊਂਟਰ (counter) ਵੇਰੀਏਬਲ 'i' ਦਾ ਮੁੱਲ ਇੱਕ ਨਾਲ ਵਧਾਇਆ (incremented by one) ਜਾਂਦਾ ਰਹੇਗਾ,
ਨੈਸਟਡ ਲੂਪਸ (Nested Loops):
ਨੈਸਟਡ ਲੂਪ ਦਾ ਅਰਥ ਹੈ ਇੱਕ ਲੂਪ ਦੇ ਅੰਦਰ ਇੱਕ ਹੋਰ ਲੂਪ। ਇਹਨਾਂ ਲੂਪਸ ਵਿਚ ਇੱਕ ਬਾਹਰੀ ਲੂਪ ਵਿੱਚ ਅੰਦਰੂਨੀ ਲੂਪ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ। ਨੈਸਟਡ ਲੂਪ ਦਾ ਸਿੰਟੈਕਸ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:
ਨੈਸਟਡ ਲੂਪਸ (Nested Loops):
ਹੇਠਾਂ ਦਿੱਤੇ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਪਾਈਥਨ ਵਿੱਚ ਲੂਪਸ ਦੀ ਨੈਸਟਿੰਗ ਕਿਵੇਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:
ਇਸ ਸੈਸ਼ਨ ਵਿੱਚ ਭਾਗ ਲੈਣ ਲਈ ਧੰਨਵਾਦ
ਵੱਲੋਂ:
ਹਰਪ੍ਰੀਤ ਸਿੰਘ
ਕੰਪਿਊਟਰ ਫੈਕਲਟੀ
ਸ.ਹ.ਸ. ਭਿੰਡਰਾਂ(ਸੰਗਰੂਰ)