ਪਾਈਥਨ ਦੀ ਇੱਕ ਲਿਖਣ ਸ਼ੈਲੀ ਹੈ ਜਿਸਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰ (ਕੰਡੀਸ਼ਨਲ ਓਪਰੇਟਰ) ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜੋ ਇੱਕ ਲਾਈਨ ਵਿੱਚ if ਸਟੇਟਮੈਂਟ ਵਰਗੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਕਰ ਸਕਦਾ ਹੈ।
ਇੱਥੇ ਨਮੂਨਾ ਕੋਡ ਦੇ ਨਾਲ ਹੇਠਾਂ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ।
- ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦੀ ਮੂਲ ਲਿਖਤ
if ... elif ... else ...ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਇਸਦਾ ਵਰਣਨ ਕਰੋ- ਸੂਚੀ ਵਿਆਪਕ ਨੋਟੇਸ਼ਨ ਅਤੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨੂੰ ਜੋੜਨਾ
- ਅਗਿਆਤ ਫੰਕਸ਼ਨਾਂ (ਲਾਂਬਡਾ ਸਮੀਕਰਨ) ਅਤੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦਾ ਸੁਮੇਲ
ਆਮ ਜੇ ਸਟੇਟਮੈਂਟ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦੀ ਮੂਲ ਲਿਖਤ
ਪਾਈਥਨ ਵਿੱਚ, ਟਰਨਰੀ ਓਪਰੇਟਰ ਨੂੰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ
Expression evaluated when the conditional expression is true if conditional expression else Expression evaluated when the conditional expression is false
ਜੇਕਰ ਤੁਸੀਂ ਸ਼ਰਤਾਂ ਦੇ ਅਨੁਸਾਰ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹਰ ਇੱਕ ਮੁੱਲ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਲਿਖੋ ਜਿਵੇਂ ਇਹ ਹੈ।
Value to return if conditional expression is true if conditional expression else Value to return if conditional expression is false
a = 1
result = 'even' if a % 2 == 0 else 'odd'
print(result)
# odd
a = 2
result = 'even' if a % 2 == 0 else 'odd'
print(result)
# even
ਜੇਕਰ ਤੁਸੀਂ ਸਥਿਤੀਆਂ ਦੇ ਅਨੁਸਾਰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹਰੇਕ ਸਮੀਕਰਨ ਦਾ ਵਰਣਨ ਕਰੋ।
a = 1
result = a * 2 if a % 2 == 0 else a * 3
print(result)
# 3
a = 2
result = a * 2 if a % 2 == 0 else a * 3
print(result)
# 4
ਸਮੀਕਰਨ ਜੋ ਮੁੱਲ ਵਾਪਸ ਨਹੀਂ ਕਰਦੇ ਹਨ (ਸਮੀਕਰਨ ਜੋ ਕੋਈ ਨਹੀਂ ਵਾਪਸ ਕਰਦੇ ਹਨ) ਵੀ ਸਵੀਕਾਰਯੋਗ ਹਨ। ਸਥਿਤੀ ‘ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਸਮੀਕਰਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।
a = 1
print('even') if a % 2 == 0 else print('odd')
# odd
ਇੱਕ ਸਧਾਰਨ if ਸਟੇਟਮੈਂਟ ਨਾਲ ਲਿਖੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੇ ਬਰਾਬਰ।
a = 1
if a % 2 == 0:
print('even')
else:
print('odd')
# odd
ਮਲਟੀਪਲ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨਾਂ ਨੂੰ ਵੀ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰਾਂ (ਅਤੇ, ਜਾਂ, ਆਦਿ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
a = -2
result = 'negative and even' if a < 0 and a % 2 == 0 else 'positive or odd'
print(result)
# negative and even
a = -1
result = 'negative and even' if a < 0 and a % 2 == 0 else 'positive or odd'
print(result)
# positive or odd
if ... elif ... else ...ਇੱਕ-ਲਾਈਨ ਵਰਣਨ
if ... elif ... else ...ਇਸ ਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਲਿਖਣ ਦਾ ਕੋਈ ਖਾਸ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਸਮੀਕਰਨ ਵਿੱਚ ਇੱਕ ਹੋਰ ਟਰਨਰੀ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਹਿਸੂਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਟਰਨਰੀ ਓਪਰੇਟਰ ਦੀ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਗਲਤ ਹੁੰਦੀ ਹੈ। ਆਲ੍ਹਣੇ ਦੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦਾ ਚਿੱਤਰ।
ਹਾਲਾਂਕਿ, ਇਸਦੀ ਵਿਆਪਕ ਵਰਤੋਂ ਨਾ ਕਰਨਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।
a = 2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# positive
a = 0
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# zero
a = -2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# negative
ਨਿਮਨਲਿਖਤ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਪਰ ਸਾਬਕਾ (1) ਦੇ ਰੂਪ ਵਿੱਚ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
A if condition 1 else B if condition 2 else C
1. A if condition 1 else ( B if condition 2 else C )
2. ( A if condition 1 else B ) if condition 2 else C
ਇੱਕ ਠੋਸ ਉਦਾਹਰਨ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ। ਪਹਿਲੇ ਸਮੀਕਰਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਦੂਜਾ ਸੀ.
a = -2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# negative
result = 'negative' if a < 0 else ('positive' if a > 0 else 'zero')
print(result)
# negative
result = ('negative' if a < 0 else 'positive') if a > 0 else 'zero'
print(result)
# zero
ਸੂਚੀ ਵਿਆਪਕ ਨੋਟੇਸ਼ਨ ਅਤੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨੂੰ ਜੋੜਨਾ
ਟਰਨਰੀ ਓਪਰੇਟਰ ਦੀ ਇੱਕ ਉਪਯੋਗੀ ਵਰਤੋਂ ਹੈ ਜਦੋਂ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਸੂਚੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਟਰਨਰੀ ਓਪਰੇਟਰ ਅਤੇ ਲਿਸਟ ਕੰਪਰੀਹੈਂਸ਼ਨ ਨੋਟੇਸ਼ਨ ਨੂੰ ਜੋੜ ਕੇ, ਸ਼ਰਤਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਸੂਚੀ ਦੇ ਤੱਤਾਂ ਨੂੰ ਬਦਲਣਾ ਜਾਂ ਕੁਝ ਹੋਰ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨਾ ਸੰਭਵ ਹੈ।
l = ['even' if i % 2 == 0 else i for i in range(10)]
print(l)
# ['even', 1, 'even', 3, 'even', 5, 'even', 7, 'even', 9]
l = [i * 10 if i % 2 == 0 else i for i in range(10)]
print(l)
# [0, 1, 20, 3, 40, 5, 60, 7, 80, 9]
ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਅਗਿਆਤ ਫੰਕਸ਼ਨਾਂ (ਲਾਂਬਡਾ ਸਮੀਕਰਨ) ਅਤੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦਾ ਸੁਮੇਲ
ਟਰਨਰੀ ਓਪਰੇਟਰ, ਜਿਸਨੂੰ ਇੱਕ ਅਗਿਆਤ ਫੰਕਸ਼ਨ (ਲੈਂਬਡਾ ਸਮੀਕਰਨ) ਵਿੱਚ ਵੀ ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਪਯੋਗੀ ਹੈ।
get_odd_even = lambda x: 'even' if x % 2 == 0 else 'odd'
print(get_odd_even(1))
# odd
print(get_odd_even(2))
# even
ਨੋਟ ਕਰੋ ਕਿ, ਭਾਵੇਂ ਕਿ ਟਰਨਰੀ ਓਪਰੇਟਰ ਨਾਲ ਕੋਈ ਸੰਬੰਧ ਨਹੀਂ ਹੈ, ਉੱਪਰ ਦਿੱਤੀ ਉਦਾਹਰਨ lambda ਸਮੀਕਰਨ ਲਈ ਇੱਕ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ। ਇਸ ਲਈ, ਆਟੋਮੈਟਿਕ ਚੈਕਿੰਗ ਟੂਲ ਜਿਵੇਂ ਕਿ ਪਾਈਥਨ ਕੋਡਿੰਗ ਕਨਵੈਨਸ਼ਨ PEP8 ਇੱਕ ਚੇਤਾਵਨੀ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ।
ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ PEP8 ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਨ ਵੇਲੇ def ਦੀ ਵਰਤੋਂ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹੈ।
PEP8 ਦੀ ਧਾਰਨਾ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ
- ਲਾਂਬਡਾ ਸਮੀਕਰਨਾਂ ਨੂੰ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਕਾਲ ਕਰਨ ਯੋਗ ਵਸਤੂਆਂ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਉਹਨਾਂ ਦਾ ਨਾਮ ਦਿੱਤੇ ਬਿਨਾਂ
- ਲਾਂਬਡਾ ਸਮੀਕਰਨ ਵਿੱਚ, ਨਾਮ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ def ਦੀ ਵਰਤੋਂ ਕਰੋ
