ਪਾਈਥਨ ਵਿੱਚ if ਸਟੇਟਮੈਂਟਾਂ ਨਾਲ ਕੰਡੀਸ਼ਨਲ ਬ੍ਰਾਂਚਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ

ਕਾਰੋਬਾਰ

ਪਾਈਥਨ ਵਿੱਚ if ਸਟੇਟਮੈਂਟਾਂ ਨਾਲ ਕੰਡੀਸ਼ਨਲ ਬ੍ਰਾਂਚਿੰਗ ਦੀ ਵਿਆਖਿਆ ਕਰੋ।

  • if ਸਟੇਟਮੈਂਟਾਂ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ (if, elif, else)
  • ਤੁਲਨਾ ਆਪਰੇਟਰਾਂ ਆਦਿ ਦੇ ਨਾਲ ਸ਼ਰਤਾਂ ਨਿਰਧਾਰਤ ਕਰੋ।
  • ਨੰਬਰ, ਸੂਚੀ, ਆਦਿ ਦੁਆਰਾ ਸ਼ਰਤਾਂ ਨਿਸ਼ਚਿਤ ਕਰੋ।
  • ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰਾਂ (ਅਤੇ, ਜਾਂ, ਨਹੀਂ) ਨਾਲ ਕਈ ਸ਼ਰਤਾਂ ਜਾਂ ਨੈਗੇਸ਼ਨਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ
  • ਨਵੀਆਂ ਲਾਈਨਾਂ ਅਤੇ ਮਲਟੀਪਲ ਲਾਈਨਾਂ ‘ਤੇ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ

ਇੱਥੇ ਇੱਕ ਟਰਨਰੀ ਓਪਰੇਟਰ ਵੀ ਹੈ ਜੋ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਇੱਕ ਕੰਡੀਸ਼ਨਲ ਬ੍ਰਾਂਚ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ। ਅਗਲਾ ਲੇਖ ਦੇਖੋ।

if ਸਟੇਟਮੈਂਟਾਂ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ (if, elif, else)

if ਸਟੇਟਮੈਂਟ ਦਾ ਮੂਲ ਰੂਪ ਇਸ ਪ੍ਰਕਾਰ ਹੈ

if Conditional expression 1:
    `Processing to be performed if Expression 1 is True.`
elif Conditional expression 2:
    `Processing to be performed when expression 1 is false and expression 2 is true.`
elif Expression 3:
    `Process when expression 1 and 2 are false and expression 3 is true.`
...
else:
    `Processing when all conditionals are false.`

“elif” C ਅਤੇ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ “else if” ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਅਤੇ “elifs” ਦੀ ਕੋਈ ਵੀ ਗਿਣਤੀ ਹੋ ਸਕਦੀ ਹੈ।

ਜੇਕਰ ਗਲਤ ਨਾ ਹੋਣ ‘ਤੇ ਸਿਰਫ਼ ਇੱਕ ਸ਼ਰਤ ਸਮੀਕਰਨ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਹੈ, ਤਾਂ “elif” ਅਤੇ “ਹੋਰ” ਬਲਾਕਾਂ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਤੁਲਨਾ ਆਪਰੇਟਰਾਂ ਆਦਿ ਦੇ ਨਾਲ ਸ਼ਰਤਾਂ ਨਿਰਧਾਰਤ ਕਰੋ।

ਇੱਕ ਓਪਰੇਸ਼ਨ ਨਾਲ ਸ਼ਰਤ ਨਿਸ਼ਚਿਤ ਕਰੋ ਜੋ ਇੱਕ ਬੂਲ ਕਿਸਮ (ਸੱਚਾ, ਗਲਤ) ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਤੁਲਨਾ ਆਪਰੇਟਰ।

ਪਾਈਥਨ ਤੁਲਨਾ ਆਪਰੇਟਰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹਨ

ਆਪਰੇਟਰਨਤੀਜਾ
x < yਸਹੀ ਜੇਕਰ x y ਤੋਂ ਘੱਟ ਹੈ
x <= yਸਹੀ ਜੇਕਰ x y ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ ਹੈ
x > yਸਹੀ ਜੇਕਰ x y ਤੋਂ ਵੱਡਾ ਹੈ
x >= yਸਹੀ ਜੇਕਰ x y ਤੋਂ ਵੱਡਾ ਜਾਂ ਬਰਾਬਰ ਹੈ
x == yਸਹੀ ਜੇਕਰ x ਅਤੇ y ਮੁੱਲ ਬਰਾਬਰ ਹਨ
x != yਸਹੀ ਜੇਕਰ x ਅਤੇ y ਮੁੱਲ ਬਰਾਬਰ ਨਹੀਂ ਹਨx is yਸਹੀ ਜੇਕਰ x ਅਤੇ y ਇੱਕੋ ਵਸਤੂ ਹਨx is not yਸਹੀ ਜੇਕਰ x ਅਤੇ y ਇੱਕੋ ਵਸਤੂ ਨਹੀਂ ਹਨx in yਸਹੀ ਜੇਕਰ x y ਵਿੱਚ ਸ਼ਾਮਲ ਹੈx not in yਸਹੀ ਜੇਕਰ x y ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ

ਉਦਾਹਰਨ. ਸਹੂਲਤ ਲਈ, ਇਸਨੂੰ def ਸਟੇਟਮੈਂਟ ਦੇ ਨਾਲ ਇੱਕ ਫੰਕਸ਼ਨ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

def if_test(num):
    if num > 100:
        print('100 < num')
    elif num > 50:
        print('50 < num <= 100')
    elif num > 0:
        print('0 < num <= 50')
    elif num == 0:
        print('num == 0')
    else:
        print('num < 0')

if_test(1000)
# 100 < num

if_test(70)
# 50 < num <= 100

if_test(0)
# num == 0

if_test(-100)
# num < 0

ਹੇਠ ਲਿਖੇ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਪਾਈਥਨ ਲਈ ਵਿਲੱਖਣ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
a < x < b

def if_test2(num):
    if 50 < num < 100:
        print('50 < num < 100')
    else:
        print('num <= 50 or num >= 100')

if_test2(70)
# 50 < num < 100

if_test2(0)
# num <= 50 or num >= 100
  • #ERROR!
  • !=

ਉਪਰੋਕਤ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਹੈ; ਵਸਤੂ ਪਛਾਣਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੀ ਵਰਤੋਂ ਕਰੋ

  • is
  • is not

ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਪੂਰਨ ਅੰਕ ਅਤੇ ਇੱਕ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਸਮੇਂ, “==” ਸਹੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਮੁੱਲ ਬਰਾਬਰ ਹਨ, ਪਰ “is” ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹ ਵੱਖ-ਵੱਖ ਵਸਤੂਆਂ ਹਨ।

i = 10
print(type(i))
# <class 'int'>

f = 10.0
print(type(f))
# <class 'float'>

print(i == f)
# True

print(i is f)
# False

ਇਹ ਸਥਿਤੀ ਬਣਾਉਣਾ ਵੀ ਸੰਭਵ ਹੈ ਕਿ ਕੀ ਇੱਕ ਸੂਚੀ ਜਾਂ ਸਤਰ ਵਿੱਚ ਇੱਕ ਖਾਸ ਤੱਤ (ਅੱਖਰ) ਸ਼ਾਮਲ ਹੈ।

  • in:ਸ਼ਾਮਲ ਹਨ
  • not in:ਸ਼ਾਮਲ ਨਹੀਂ
def if_test_in(s):
    if 'a' in s:
        print('a is in string')
    else:
        print('a is NOT in string')

if_test_in('apple')
# a is in string

if_test_in('melon')
# a is NOT in string

ਨੰਬਰ, ਸੂਚੀ, ਆਦਿ ਦੁਆਰਾ ਸ਼ਰਤਾਂ ਨਿਸ਼ਚਿਤ ਕਰੋ।

ਇੱਕ if ਸਟੇਟਮੈਂਟ ਦਾ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਇੱਕ ਨੰਬਰ, ਸੂਚੀ, ਜਾਂ ਹੋਰ ਵਸਤੂ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਕਿ bool (ਸੱਚਾ, ਗਲਤ) ਦੀ ਕਿਸਮ ਨਹੀਂ ਹੈ।

if 10:
    print('True')
# True

if [0, 1, 2]:
    print('True')
# True

Python if ਸਟੇਟਮੈਂਟ ਦੇ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਵਿੱਚ, ਹੇਠ ਲਿਖੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

  • ਅਸਥਿਰ ਹੋਣ ਲਈ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ:None,false
  • ਸੰਖਿਆਤਮਕ ਕਿਸਮ ਵਿੱਚ ਜ਼ੀਰੋ:0,0,0j,Decimal(0),Fraction(0, 1)
  • ਖਾਲੀ ਕ੍ਰਮ ਜਾਂ ਸੰਗ੍ਰਹਿ:',(),[],{},set(),range(0)Truth Value Testing — Built-in Types — Python 3.10.4 Documentation

ਜ਼ੀਰੋ, ਖਾਲੀ ਸਤਰ, ਸੂਚੀਆਂ, ਆਦਿ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੇ ਨੰਬਰਾਂ ਨੂੰ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ; ਬਾਕੀ ਸਾਰੇ ਸੱਚ ਮੰਨੇ ਜਾਂਦੇ ਹਨ।

ਆਬਜੈਕਟ ਦਾ ਨਿਰਣਾ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇਸਦੀ ਜਾਂਚ bool() ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

print(bool(10))
# True

print(bool(0.0))
# False

print(bool([]))
# False

print(bool('False'))
# True

ਇਸਦੀ ਵਰਤੋਂ ਸਿਰਫ਼ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਿਖਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ ਸੂਚੀ ਖਾਲੀ ਹੁੰਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ।

def if_test_list(l):
    if l:
        print('list is NOT empty')
    else:
        print('list is empty')

if_test_list([0, 1, 2])
# list is NOT empty

if_test_list([])
# list is empty

ਨੋਟ ਕਰੋ ਕਿ ਸਤਰ ‘False’ ਵੀ ਸਹੀ ਹੋਵੇਗੀ, ਕਿਉਂਕਿ ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਕੋਈ ਵੀ ਸਤਰ ਜੋ ਸਤਰ ਵਿੱਚ ਖਾਲੀ ਨਹੀਂ ਹੈ, ਸੱਚ ਹੋਵੇਗੀ।’ ਕਿਸੇ ਖਾਸ ਸਤਰ ਜਿਵੇਂ ਕਿ ‘ਸੱਚ’ ਜਾਂ ‘ਗਲਤ’ ਨੂੰ 1,0 ਵਿੱਚ ਬਦਲਣ ਲਈ, distutils.util ਮੋਡੀਊਲ ਵਿੱਚ strtobool() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰਾਂ (ਅਤੇ, ਜਾਂ, ਨਹੀਂ) ਨਾਲ ਕਈ ਸ਼ਰਤਾਂ ਜਾਂ ਨੈਗੇਸ਼ਨਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ

ਲਾਜ਼ੀਕਲ ਆਪਰੇਟਰਾਂ (ਅਤੇ, ਜਾਂ, ਨਹੀਂ) ਦੀ ਵਰਤੋਂ ਲਾਜ਼ੀਕਲ ਸੰਯੋਜਨ, ਲਾਜ਼ੀਕਲ ਡਿਸਜੰਕਸ਼ਨ, ਅਤੇ ਮਲਟੀਪਲ ਸ਼ਰਤਾਂ ਨੂੰ ਨਕਾਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਆਪਰੇਟਰ(ਨਤੀਜਾ (ਇੱਕ if ਸਟੇਟਮੈਂਟ ਦੇ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਵਿੱਚ)
x and yਸਹੀ ਜੇਕਰ x ਅਤੇ y ਦੋਵੇਂ ਸਹੀ ਹਨ
x or yਸਹੀ ਜੇਕਰ x ਜਾਂ y ਸੱਚ ਹੈ
not xਗਲਤ ਜੇ x ਸੱਚ ਹੈ, ਸੱਚ ਹੈ ਜੇ x ਗਲਤ ਹੈ
def if_test_and_not(num):
    if num >= 0 and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_not(5)
# num is positive odd

if_test_and_not(10)
# num is NOT positive odd

if_test_and_not(-10)
# num is NOT positive odd

ਵਾਸਤਵ ਵਿੱਚ, “x ਅਤੇ y” ਅਤੇ “x ਜਾਂ y” ਸਹੀ ਜਾਂ ਗਲਤ ਨਹੀਂ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਪਰ ਜਾਂ ਤਾਂ x ਜਾਂ y। ਜਿੰਨਾ ਚਿਰ ਉਹ if ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨਾਂ ਵਿੱਚ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਉਹਨਾਂ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਸਹੀ ਜਾਂ ਗਲਤ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਨ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।

ਇਸਦੀ ਵਰਤੋਂ ਅਤੇ ਅਤੇ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਕਰਨਾ ਸੰਭਵ ਹੈ।

def if_test_and_not_or(num):
    if num >= 0 and not num % 2 == 0 or num == -10:
        print('num is positive odd or -10')
    else:
        print('num is NOT positive odd or -10')

if_test_and_not_or(5)
# num is positive odd or -10

if_test_and_not_or(10)
# num is NOT positive odd or -10

if_test_and_not_or(-10)
# num is positive odd or -10

ਨਵੀਆਂ ਲਾਈਨਾਂ ਅਤੇ ਮਲਟੀਪਲ ਲਾਈਨਾਂ ‘ਤੇ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ

ਜਦੋਂ ਕਈ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨਾਂ ਨੂੰ “ਅਤੇ” ਜਾਂ “ਜਾਂ” ਨਾਲ ਜੋੜ ਕੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਲਾਈਨ ਲੰਬੀ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਈ ਵਾਰ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਨੂੰ ਤੋੜਨਾ ਅਤੇ ਕਈ ਲਾਈਨਾਂ ‘ਤੇ ਲਿਖਣਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ।

ਇੱਕ ਲਾਈਨ ਬ੍ਰੇਕ ਇੱਕ ਬੈਕਸਲੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਾਂ ਪੂਰੀ ਲਾਈਨ ਨੂੰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਨੱਥੀ ਕਰਕੇ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

def if_test_and_backslash(num):
    if num >= 0 \
       and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_backslash(5)
# num is positive odd

def if_test_and_brackets(num):
    if (num >= 0
        and not num % 2 == 0):
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_brackets(5)
# num is positive odd

ਤੁਸੀਂ ਜਿੰਨੀ ਵਾਰ ਚਾਹੋ ਇੱਕ ਲਾਈਨ ਨੂੰ ਤੋੜਨ ਲਈ ਬੈਕਸਲੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇਸੇ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਬਰੈਕਟਾਂ ਦੇ ਅੰਦਰ ਇੱਕ ਲਾਈਨ ਨੂੰ ਕਈ ਵਾਰ ਤੋੜ ਸਕਦੇ ਹੋ। ਕੋਈ ਇੰਡੈਂਟੇਸ਼ਨ ਸੀਮਾ ਨਹੀਂ ਹੈ।

ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਇੱਕ ਤਕਨੀਕ ਹੈ ਜੋ ਪਾਈਥਨ ਕੋਡ ਵਿੱਚ ਕਿਤੇ ਵੀ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ if ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚ।

Copied title and URL