Python માં if સ્ટેટમેન્ટ સાથે શરતી શાખાઓ કેવી રીતે લખવી

Python માં 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.`

“એલિફ” એ C અને અન્ય ભાષાઓમાં “else if” ને અનુરૂપ છે, અને “elifs” ની કોઈપણ સંખ્યા હોઈ શકે છે.

જો માત્ર એક જ શરતી અભિવ્યક્તિ હોય અથવા ખોટાની આવશ્યકતા ન હોય ત્યારે પ્રોસેસિંગ હોય, તો “એલિફ” અને “બીજું” બ્લોક્સ અવગણી શકાય છે.

સરખામણી ઓપરેટરો વગેરે સાથે શરતોનો ઉલ્લેખ કરો.

ઓપરેશન સાથે શરતનો ઉલ્લેખ કરો જે બૂલ પ્રકાર (સાચું, ખોટું) આપે છે, જેમ કે સરખામણી ઓપરેટર.

પાયથોન સરખામણી ઓપરેટરો નીચે મુજબ છે

• 6.10. Comparisons — 6. Expressions — Python 3.10.4 Documentation

ઓપરેટર	પરિણામ
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 સ્ટેટમેન્ટની શરતી અભિવ્યક્તિ એ સંખ્યા, સૂચિ અથવા અન્ય ઑબ્જેક્ટ હોઈ શકે છે જે બુલ (સાચું, ખોટું) પ્રકારનું નથી.

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

નોંધ કરો કે શબ્દમાળા ‘ફોલ્સ’ પણ સાચી હશે, કારણ કે ઉપરના ઉદાહરણમાં બતાવ્યા પ્રમાણે, સ્ટ્રિંગમાં ખાલી ન હોય તેવી કોઈપણ સ્ટ્રિંગ સાચી હશે.’ ચોક્કસ સ્ટ્રિંગ જેમ કે ‘True’ અથવા ‘False’ ને 1,0 માં કન્વર્ટ કરવા માટે, distutils.util મોડ્યુલમાં strtobool() નો ઉપયોગ કરો.

લોજિકલ ઓપરેટર્સ (અને, અથવા, નહીં) સાથે બહુવિધ શરતો અથવા નકારનો ઉલ્લેખ કરો

લોજિકલ ઓપરેટરો (અને, અથવા, નહીં) નો ઉપયોગ તાર્કિક જોડાણ, તાર્કિક વિસંવાદ અને બહુવિધ શરતોને નકારવા માટે કરી શકાય છે.

• Boolean Operations — and, or, not — Built-in Types — Python 3.10.4 Documentation

ઓપરેટર	(પરિણામ (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 સ્ટેટમેન્ટમાં નહીં.

• સંબંધિત:Python માં બહુવિધ રેખાઓ પર લાંબી તાર લખવી