ਪਾਈਥਨ ਦੇ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰ ਅਤੇ, ਜਾਂ, ਅਤੇ ਨਹੀਂ (ਲਾਜ਼ੀਕਲ ਜੋੜ, ਵਿਛੋੜਾ, ਨਕਾਰਾਤਮਕ)

ਪਾਈਥਨ ਲਾਜ਼ੀਕਲ (ਬੂਲੀਅਨ) ਓਪਰੇਸ਼ਨ ਕਰਨ ਲਈ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।(and,or,not)
ਇਹ ਇੱਕ if ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਮਲਟੀਪਲ ਸ਼ਰਤਾਂ ਵਿਚਕਾਰ ਸਬੰਧਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਭਾਗ ਹੇਠ ਲਿਖੇ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।

• ਚੌਰਾਹੇ:and
• ਲਾਜ਼ੀਕਲ ਐਡ:or
• ਇਨਕਾਰ:not
• and,or,notਆਪਰੇਟਰ ਦੀ ਤਰਜੀਹ

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹੇਠਾਂ ਦਿੱਤੇ ਨੁਕਤਿਆਂ ਨੂੰ ਸਾਵਧਾਨੀ ਵਜੋਂ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

• ਬੂਲ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕਿਸਮ ਦੀਆਂ ਵਸਤੂਆਂ ਲਈ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰ
• and,orਇਹ ਵਾਪਸੀ ਮੁੱਲ ਜ਼ਰੂਰੀ ਤੌਰ ‘ਤੇ ਬੂਲ ਕਿਸਮ ਦੇ ਨਹੀਂ ਹਨ।
• ਸ਼ਾਰਟ ਸਰਕਟ (ਸ਼ਾਰਟ ਸਰਕਟ ਮੁਲਾਂਕਣ)

ਚੌਰਾਹੇ:and

ਅਤੇ ਦੋ ਮੁੱਲਾਂ ਦਾ ਲਾਜ਼ੀਕਲ ਉਤਪਾਦ ਵਾਪਸ ਕਰਦਾ ਹੈ।

print(True and True)
# True

print(True and False)
# False

print(False and True)
# False

print(False and False)
# False

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

• <
• >

a = 10
print(0 < a)
# True

print(a < 100)
# True

print(0 < a and a < 100)
# True

ਅਤੇ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

print(0 < a < 100)
# True

ਲਾਜ਼ੀਕਲ ਐਡ:or

ਜਾਂ ਦੋ ਮੁੱਲਾਂ ਦਾ ਲਾਜ਼ੀਕਲ OR ਵਾਪਸ ਕਰਦਾ ਹੈ।

print(True or True)
# True

print(True or False)
# True

print(False or True)
# True

print(False or False)
# False

ਇਨਕਾਰ:not

“ਨਹੀਂ” ਮੁੱਲ ਦੀ ਨਕਾਰਾਤਮਕਤਾ ਵਾਪਸ ਕਰਦਾ ਹੈ; ਸੱਚਾ ਅਤੇ ਗਲਤ ਉਲਟਾ ਹੁੰਦਾ ਹੈ।

print(not True)
# False

print(not False)
# True

and,or,notਆਪਰੇਟਰ ਦੀ ਤਰਜੀਹ

ਇਹਨਾਂ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰਾਂ ਦੀ ਤਰਜੀਹ ਦਾ ਕ੍ਰਮ ਇਸ ਤਰ੍ਹਾਂ ਹੈ: ਸਭ ਤੋਂ ਉੱਚਾ ਨਹੀਂ ਹੈ।

1. not
2. and
3. or

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

print(True or True and False)
# True

print(True or (True and False))
# True

ਜੇਕਰ ਤੁਸੀਂ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਪਹਿਲਾਂ ਅਤੇ, ਬਰੈਕਟਾਂ () ਦੀ ਵਰਤੋਂ ਕਰੋ।

print((True or True) and False)
# False

<,>ਇਹਨਾਂ ਤੁਲਨਾ ਆਪਰੇਟਰਾਂ ਦੀ ਨਾ ਨਾਲੋਂ ਵੀ ਵੱਧ ਤਰਜੀਹ ਹੈ। ਇਸ ਲਈ, ਹਰੇਕ ਤੁਲਨਾ ਕਾਰਵਾਈ ਲਈ ਬਰੈਕਟ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ ਸੀ।

print(0 < a and a < 100)
# True

ਪਾਈਥਨ ਵਿੱਚ ਓਪਰੇਟਰ ਤਰਜੀਹ ਦੇ ਸੰਖੇਪ ਲਈ ਹੇਠਾਂ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ।

• 6.17. Operator precedence — Expressions — Python 3.10.1 Documentation

ਬੂਲ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕਿਸਮ ਦੀਆਂ ਵਸਤੂਆਂ ਲਈ ਲਾਜ਼ੀਕਲ ਓਪਰੇਟਰ

With these logical operators, not only bool types (true, false), but also numbers, strings, lists, etc. are processed as boolean values.

ਪਾਈਥਨ ਦੇ ਲਾਜ਼ੀਕਲ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

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

ਬਾਕੀ ਸਾਰੇ ਮੁੱਲ ਸਹੀ ਮੰਨੇ ਜਾਂਦੇ ਹਨ।

ਫੰਕਸ਼ਨ bool() ਨੂੰ ਕਿਸੇ ਵਸਤੂ ਦਾ ਬੂਲੀਅਨ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਸਤਰ ‘0’ ਜਾਂ ‘ਗਲਤ’ ਨੂੰ ਸਹੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

print(bool(10))
# True

print(bool(0))
# False

print(bool(''))
# False

print(bool('0'))
# True

print(bool('False'))
# True

print(bool([]))
# False

print(bool([False]))
# True

ਸਤਰ ਵਿੱਚ ‘0’ ਜਾਂ ‘ਗਲਤ’ ਨੂੰ ਗਲਤ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈਂਡਲ ਕਰਨ ਲਈ, distutils.util.strtobool() ਦੀ ਵਰਤੋਂ ਕਰੋ।

and,orਇਹ ਵਾਪਸੀ ਮੁੱਲ ਜ਼ਰੂਰੀ ਤੌਰ ‘ਤੇ ਬੂਲ ਕਿਸਮ ਦੇ ਨਹੀਂ ਹਨ।

ਇੱਥੇ ਇੱਕ ਬੂਲ ਕਿਸਮ ਤੋਂ ਇਲਾਵਾ ਕਿਸੇ ਹੋਰ ਵਸਤੂ ਦਾ ਇੱਕ ਉਦਾਹਰਨ ਹੈ, ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ‘ਤੇ ਹਰੇਕ ਓਪਰੇਟਰ ਦਾ ਨਤੀਜਾ ਦਿਖਾ ਰਿਹਾ ਹੈ।

x = 10  # True
y = 0  # False

print(x and y)
# 0

print(x or y)
# 10

print(not x)
# False

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

ਅਤੇ ਅਤੇ ਜਾਂ ਦੇ ਵਾਪਸੀ ਮੁੱਲਾਂ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹਨ।

The expression x and y first evaluates x; if x is false, its value is returned; otherwise, y is evaluated and the resulting value is returned.

The expression x or y first evaluates x; if x is true, its value is returned; otherwise, y is evaluated and the resulting value is returned.

6.11. Boolean operations — Expressions — Python 3.10.1 Documentation

ਜਦੋਂ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਸਮੀਕਰਨ ਦੇ ਮੁੱਲ ਵੱਖਰੇ ਤੌਰ ‘ਤੇ ਸਹੀ ਅਤੇ ਗਲਤ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਵਾਪਸੀ ਮੁੱਲਾਂ ਨੂੰ ਸਮਝਣਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ਜੇਕਰ ਦੋਵੇਂ ਸਹੀ ਹਨ ਜਾਂ ਦੋਵੇਂ ਗਲਤ ਹਨ, ਤਾਂ ਵਾਪਸੀ ਦਾ ਮੁੱਲ ਆਰਡਰ ਦੇ ਆਧਾਰ ‘ਤੇ ਵੱਖਰਾ ਹੋਵੇਗਾ।

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

x = 10  # True
y = 100  # True

print(x and y)
# 100

print(y and x)
# 10

print(x or y)
# 10

print(y or x)
# 100

x = 0  # False
y = 0.0  # False

print(x and y)
# 0

print(y and x)
# 0.0

print(x or y)
# 0.0

print(y or x)
# 0

print(bool(x and y))
# False

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਨੂੰ ਸਹੀ ਜਾਂ ਗਲਤ ਮੰਨਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਖਰੀ ਉਦਾਹਰਣ ਵਾਂਗ ਕਰ ਸਕਦੇ ਹੋ।
bool(x and y)

ਦੇ ਵਾਪਸੀ ਮੁੱਲ ਅਤੇ ਅਤੇ ਜਾਂ ਹੇਠਾਂ ਦਿੱਤੀ ਸਾਰਣੀ ਵਿੱਚ ਸਾਰ ਦਿੱਤੇ ਗਏ ਹਨ।

ਸ਼ਾਰਟ ਸਰਕਟ (ਸ਼ਾਰਟ ਸਰਕਟ ਮੁਲਾਂਕਣ)

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਉੱਪਰ ਦਿੱਤੀ ਸਾਰਣੀ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਜੇਕਰ x ਅਤੇ y ਵਿੱਚ x ਗਲਤ ਹੈ, ਜਾਂ ਜੇਕਰ x x ਜਾਂ y ਵਿੱਚ ਸਹੀ ਹੈ, ਤਾਂ ਵਾਪਸੀ ਦਾ ਮੁੱਲ y ਦੇ ਮੁੱਲ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ x ਹੋਵੇਗਾ।

ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ, y ਦਾ ਮੁਲਾਂਕਣ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

and,orਨੋਟ ਕਰੋ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਸੱਜੇ ਪਾਸੇ ਕਿਸੇ ਫੰਕਸ਼ਨ ਜਾਂ ਵਿਧੀ ਨੂੰ ਕੁਝ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨ ਲਈ ਕਾਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖੱਬੇ ਪਾਸੇ ਦੇ ਨਤੀਜੇ ਦੇ ਆਧਾਰ ‘ਤੇ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

def test():
    print('function is called')
    return True

print(True and test())
# function is called
# True

print(False and test())
# False

print(True or test())
# True

print(False or test())
# function is called
# True