પાયથોનના લોજિકલ ઓપરેટર્સ અને, અથવા, અને નહીં (લોજિકલ જોડાણ, વિભાજન, નકાર)

Python લોજિકલ ઓપરેટરોને લોજિકલ (બુલિયન) કામગીરી કરવા માટે પ્રદાન કરે છે.(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’ અથવા ‘False’ સાચી ગણવામાં આવે છે.

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’ અથવા ‘false’ને ખોટા તરીકે હેન્ડલ કરવા માટે, 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

જેમ તમે ઉપરના ઉદાહરણમાંથી જોઈ શકો છો, અને અને અથવા પાયથોનમાં બૂલ પ્રકારનું સાચું કે ખોટું પરત કરતું નથી, પરંતુ તે સાચું છે કે ખોટું છે તેના આધારે ડાબી કે જમણી બાજુએ મૂલ્ય પરત કરે છે. ઉદાહરણ સંખ્યાત્મક છે, પરંતુ તે જ શબ્દમાળાઓ અને સૂચિઓ જેવા અન્ય પ્રકારોને લાગુ પડે છે. સંજોગોવશાત્, બૂલ પ્રકારનું સાચું કે ખોટું પરત કરતું નથી.

અને અને અથવા ના વળતર મૂલ્યોની વ્યાખ્યાઓ નીચે મુજબ છે.

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 અથવા y માં x સાચું છે, તો વળતર મૂલ્ય 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