പൈത്തണിൽ കണ്ടീഷണൽ if സ്റ്റേറ്റ്മെന്റ്. വാക്യഘടന, else/elif ബ്ലോക്കുകൾ, ഉദാഹരണങ്ങൾ

പ്രോഗ്രാമിലേക്ക് പഠിക്കുന്ന പ്രക്രിയയിൽ, യഥാർത്ഥ ജീവിതത്തിൽ പ്രയോഗിക്കാൻ അത്ര എളുപ്പമല്ലാത്ത പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കേണ്ടത് പലപ്പോഴും ആവശ്യമാണ്. എല്ലാത്തിനുമുപരി, കാലാകാലങ്ങളിൽ നിങ്ങൾ ചില വ്യവസ്ഥകളിൽ മാത്രം നിർദ്ദേശങ്ങൾ പാലിക്കണം. പ്രോഗ്രാമിൽ ഇത് നടപ്പിലാക്കാൻ, എല്ലാ ഭാഷകൾക്കും നിയന്ത്രണ പ്രസ്താവനകൾ ഉണ്ട്. അവരുടെ സഹായത്തോടെ, നിങ്ങൾക്ക് കോഡ് നിർവ്വഹണത്തിന്റെ ഒഴുക്ക് നിയന്ത്രിക്കാനും ലൂപ്പുകൾ സൃഷ്ടിക്കാനും അല്ലെങ്കിൽ ഒരു നിശ്ചിത വ്യവസ്ഥ ശരിയാണെങ്കിൽ മാത്രം ചില പ്രവർത്തനങ്ങൾ നടത്താനും കഴിയും.

ഇന്ന് നമ്മൾ if സ്റ്റേറ്റ്മെന്റിനെക്കുറിച്ച് സംസാരിക്കും, അത് ഒരു നിശ്ചിത അവസ്ഥയ്ക്കായി നിലവിലെ സാഹചര്യം പരിശോധിക്കുന്നു, ഈ വിവരങ്ങളെ അടിസ്ഥാനമാക്കി, തുടർന്നുള്ള പ്രവർത്തനങ്ങളെക്കുറിച്ച് തീരുമാനങ്ങൾ എടുക്കുന്നു.

നിയന്ത്രണ പ്രസ്താവനകളുടെ തരങ്ങൾ

പൊതുവേ, ഒരു പ്രോഗ്രാമിന്റെ ഒഴുക്ക് നിയന്ത്രിക്കുന്ന ഒരേയൊരു പ്രസ്താവന എങ്കിൽ. അതുപോലെ തന്നെ ഒരു വലിയ ഓപ്പറേറ്റർമാരുടെ ശൃംഖലയുടെ ഒരു ഘടകമാകാൻ അദ്ദേഹത്തിന് കഴിയും.

അതിന്റെ നിർവ്വഹണ പ്രക്രിയയെ നിയന്ത്രിക്കുന്ന ലൂപ്പുകളും പ്രസ്താവനകളും ഉണ്ട്. ഇന്ന് നമ്മൾ സോപാധിക ഓപ്പറേറ്ററെക്കുറിച്ചും അതിൽ പങ്കെടുക്കാൻ കഴിയുന്ന ചങ്ങലകളെക്കുറിച്ചും മാത്രമേ സംസാരിക്കൂ.

പ്രോഗ്രാമിംഗിൽ, ബ്രാഞ്ചിംഗ് പോലെയുള്ള ഒരു കാര്യമുണ്ട്. ഒരു നിശ്ചിത വ്യവസ്ഥ ശരിയാണെങ്കിൽ മാത്രം എക്സിക്യൂട്ട് ചെയ്യുന്ന കമാൻഡുകളുടെ ഒരു ശ്രേണി എന്നാണ് ഇത് അർത്ഥമാക്കുന്നത്. മാനദണ്ഡങ്ങൾ തന്നെ വ്യത്യസ്തമായിരിക്കാം:

1. ഒരു നിശ്ചിത മൂല്യത്തിലേക്കുള്ള വേരിയബിളിന്റെ തുല്യത.
2. ഒരു നിർദ്ദിഷ്ട പ്രവർത്തനം നടത്തുന്നു.
3. ആപ്ലിക്കേഷന്റെ അവസ്ഥ (തകർച്ചയിലോ ഇല്ലയോ).

സ്പെക്ട്രം വളരെ വലുതായിരിക്കും. സോപാധിക പ്രസ്താവനകൾ പല തരത്തിലാണ് വരുന്നത്:

1. ഒരു ശാഖയോടെ. അതായത്, ഒരു പരിശോധന നടത്തുന്നു, അതിന്റെ ഫലമായി ചില പ്രവർത്തനങ്ങൾ നടത്തുന്നു.
2. രണ്ടോ അതിലധികമോ ശാഖകളോടെ. മാനദണ്ഡം 1 ശരിയാണെങ്കിൽ, മാനദണ്ഡം 2 പരിശോധിക്കുക. അത് ശരിയാണെങ്കിൽ, 3 പരിശോധിക്കുക. അതിനാൽ, ആവശ്യമുള്ളത്ര പരിശോധനകൾ നടത്തുക.
3. നിരവധി നിബന്ധനകളോടെ. ഇവിടെ എല്ലാം ലളിതമാണ്. വ്യാഖ്യാതാവ് ഒന്നിലധികം വ്യവസ്ഥകൾ അല്ലെങ്കിൽ അവയിലൊന്ന് പരിശോധിക്കുന്നു.

പ്രസ്താവന എങ്കിൽ

if പ്രസ്താവനയുടെ ഘടന എല്ലാ ഭാഷകളിലും സമാനമാണ്. എന്നിരുന്നാലും, പൈത്തണിൽ, അതിന്റെ വാക്യഘടന മറ്റെല്ലാതിൽ നിന്നും വ്യത്യസ്തമാണ്:

എങ്കിൽ വ്യവസ്ഥ:

    <входящее выражение 1>

    <входящее выражение 2>

<не входящее выражение>

ആദ്യം, ഓപ്പറേറ്റർ തന്നെ പ്രഖ്യാപിച്ചു, അതിനുശേഷം അത് പ്രവർത്തിക്കാൻ തുടങ്ങുന്ന അവസ്ഥ എഴുതപ്പെടുന്നു. വ്യവസ്ഥ ശരിയോ തെറ്റോ ആകാം.

ഇതിന് ശേഷം കമാൻഡുകൾ ഉള്ള ഒരു ബ്ലോക്ക് വരുന്നു. ഇത് ഉടനടി പാലിക്കേണ്ട ഒരു മാനദണ്ഡം പിന്തുടരുകയാണെങ്കിൽ, കമാൻഡിന്റെ അനുബന്ധ ശ്രേണിയെ if ബ്ലോക്ക് എന്ന് വിളിക്കുന്നു. നിങ്ങൾക്ക് അതിൽ എത്ര കമാൻഡുകൾ വേണമെങ്കിലും ഉപയോഗിക്കാം.

മുന്നറിയിപ്പ്! ഇഫ് ബ്ലോക്ക് കമാൻഡുകൾക്കെല്ലാം ഉള്ളിലെ ഇൻഡന്റേഷൻ ഒരേ വലുപ്പമായിരിക്കണം. ബ്ലോക്ക് അതിരുകൾ ഇൻഡന്റുകളാൽ നിർണ്ണയിക്കപ്പെടുന്നു. 

ഭാഷാ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, ഇൻഡന്റേഷൻ 4 സ്പെയ്സുകളാണ്. 

ഈ ഓപ്പറേറ്റർ എങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്? വ്യാഖ്യാതാവ് if വാക്ക് കാണുമ്പോൾ, അത് ഉപയോക്താവ് വ്യക്തമാക്കിയ മാനദണ്ഡങ്ങൾക്കെതിരായ എക്‌സ്‌പ്രഷൻ ഉടൻ പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, അവൻ നിർദ്ദേശങ്ങൾ തേടാനും അവ പിന്തുടരാനും തുടങ്ങുന്നു. അല്ലെങ്കിൽ, ഈ ബ്ലോക്കിൽ നിന്നുള്ള എല്ലാ കമാൻഡുകളും ഒഴിവാക്കപ്പെടും.

അവസ്ഥയ്ക്ക് ശേഷമുള്ള ഒരു പ്രസ്താവന ഇൻഡന്റ് ചെയ്തിട്ടില്ലെങ്കിൽ, അത് ഒരു if ബ്ലോക്കായി കണക്കാക്കില്ല. ഞങ്ങളുടെ സാഹചര്യത്തിൽ, ഈ വരി . അതിനാൽ, ചെക്കിന്റെ ഫലം പരിഗണിക്കാതെ തന്നെ, ഈ ലൈൻ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.

ഈ ഓപ്പറേറ്റർ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ഉദാഹരണത്തിനുള്ള ഒരു കോഡ് സ്നിപ്പറ്റ് ഇതാ.

നമ്പർ = int(ഇൻപുട്ട്("ഒരു നമ്പർ നൽകുക:"))

നമ്പർ> 10 ആണെങ്കിൽ:

    പ്രിന്റ് ("സംഖ്യ 10-ൽ കൂടുതലാണ്")

ഈ പ്രോഗ്രാം ഉപയോക്താവിനോട് ഒരു നമ്പർ ആവശ്യപ്പെടുകയും അത് 10-ൽ കൂടുതലാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. അങ്ങനെയാണെങ്കിൽ, അത് ഉചിതമായ വിവരങ്ങൾ നൽകുന്നു. ഉദാഹരണത്തിന്, ഉപയോക്താവ് നമ്പർ 5 നൽകുകയാണെങ്കിൽ, പ്രോഗ്രാം അവസാനിക്കും, അത്രമാത്രം.

എന്നാൽ നിങ്ങൾ നമ്പർ 100 വ്യക്തമാക്കുകയാണെങ്കിൽ, അത് പത്തിൽ കൂടുതലാണെന്ന് വ്യാഖ്യാതാവ് മനസ്സിലാക്കുകയും അത് റിപ്പോർട്ടുചെയ്യുകയും ചെയ്യും.

മുന്നറിയിപ്പ്! ഞങ്ങളുടെ കാര്യത്തിൽ, വ്യവസ്ഥ തെറ്റാണെങ്കിൽ, പ്രോഗ്രാം നിർത്തുന്നു, കാരണം നിർദ്ദേശത്തിന് ശേഷം കമാൻഡുകൾ ഒന്നും നൽകില്ല.

മുകളിലെ കോഡിൽ ഒരു കമാൻഡ് മാത്രമേയുള്ളൂ. എന്നാൽ അവയിൽ പലതും ഉണ്ട്. ഇൻഡന്റ് ചെയ്യുക എന്നത് മാത്രമാണ് ആവശ്യം.

ഇനി നമുക്ക് ഈ കമാൻഡുകളുടെ ക്രമം വിശകലനം ചെയ്യാം.

നമ്പർ = int(ഇൻപുട്ട്("ഒരു നമ്പർ എഴുതുക:"))

നമ്പർ> 10 ആണെങ്കിൽ:

    പ്രിന്റ് ("ആദ്യ വരി")

    പ്രിന്റ് ("രണ്ടാം വരി")

    പ്രിന്റ് ("മൂന്നാം വരി")

പ്രിന്റ് (“നൽകിയ നമ്പർ പരിഗണിക്കാതെ തന്നെ എക്സിക്യൂട്ട് ചെയ്യുന്ന ലൈൻ”)

പ്രിന്റ് ("അപ്ലിക്കേഷൻ അവസാനിപ്പിക്കുക")

നിങ്ങൾ 2, 5, 10, 15, 50 മൂല്യങ്ങൾ നൽകിയാൽ ഔട്ട്പുട്ട് എന്തായിരിക്കുമെന്ന് ഊഹിക്കാൻ ശ്രമിക്കുക.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഉപയോക്താവ് നൽകിയ സംഖ്യ പത്തിൽ കൂടുതലാണെങ്കിൽ, മൂന്ന് വരികൾ ഔട്ട്‌പുട്ട് + ഒന്ന് "ഓരോ തവണയും പ്രവർത്തിപ്പിക്കുക ...", ഒന്ന് "അവസാനം" എന്നീ വാചകങ്ങളും, പത്തിൽ കുറവാണെങ്കിൽ ഒന്ന് മാത്രം. മറ്റൊരു വാചകം. ശരിയാണെങ്കിൽ 3,4,5 വരികൾ മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യൂ. എന്നിരുന്നാലും, ഉപയോക്താവ് ഏത് നമ്പർ വ്യക്തമാക്കിയാലും അവസാന രണ്ട് വരികൾ എഴുതപ്പെടും.

നിങ്ങൾ കൺസോളിൽ നേരിട്ട് പ്രസ്താവനകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, ഫലം വ്യത്യസ്തമായിരിക്കും. സ്ഥിരീകരണ മാനദണ്ഡം വ്യക്തമാക്കിയ ശേഷം, എന്റർ അമർത്തുകയാണെങ്കിൽ ഇന്റർപ്രെറ്റർ ഉടൻ തന്നെ മൾട്ടി-ലൈൻ മോഡ് ഓണാക്കുന്നു.

താഴെ പറയുന്ന കമാൻഡുകളുടെ ക്രമം നമ്മൾ എഴുതിയിട്ടുണ്ടെന്ന് കരുതുക.

>>>

>>> n = 100

>>> എങ്കിൽ n > 10:

പങ്ക് € |

അതിനുശേഷം, >>> എന്നതിന് പകരം എലിപ്സിസ് വന്നതായി കാണാം. മൾട്ടിലൈൻ ഇൻപുട്ട് മോഡ് പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു എന്നാണ് ഇതിനർത്ഥം. ലളിതമായി പറഞ്ഞാൽ, നിങ്ങൾ എന്റർ അമർത്തുകയാണെങ്കിൽ, നിർദ്ദേശത്തിന്റെ രണ്ടാം ഘട്ടത്തിന്റെ ഇൻപുട്ടിലേക്ക് നിങ്ങളെ മാറ്റും. 

ഈ ബ്ലോക്കിൽ നിന്ന് പുറത്തുകടക്കുന്നതിന്, നിങ്ങൾ ബ്ലോക്കിലേക്ക് ഒരു നിർമ്മാണം കൂടി ചേർക്കേണ്ടതുണ്ട് if.

>>>

>>> n = 100

>>> എങ്കിൽ n > 10:

… പ്രിന്റ് ("nv 10")

പങ്ക് € |

വ്യവസ്ഥ ശരിയല്ലെങ്കിൽ, പ്രോഗ്രാം അവസാനിക്കും. ഇത് ഒരു പ്രശ്‌നമാണ്, കാരണം അത്തരമൊരു പ്രോഗ്രാം ഒരു പരാജയം കാരണം അടച്ചതായി ഉപയോക്താവ് മനസ്സിലാക്കിയേക്കാം. അതിനാൽ, ഉപയോക്താവിന് ഫീഡ്ബാക്ക് നൽകേണ്ടത് ആവശ്യമാണ്. ഇതിനായി, ഒരു ലിങ്ക് ഉപയോഗിക്കുന്നു എങ്കിൽ-ഇല്ലെങ്കിൽ.

എക്സ്പ്രഷൻ ഓപ്പറേറ്റർ എങ്കിൽ-ഇല്ലെങ്കിൽ

ഒരു ലിങ്ക് നടപ്പിലാക്കാൻ ഈ ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു: എക്‌സ്‌പ്രഷൻ ഒരു നിശ്ചിത നിയമവുമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, ഈ പ്രവർത്തനങ്ങൾ നടത്തുക, ഇല്ലെങ്കിൽ മറ്റുള്ളവ. അതായത്, പ്രോഗ്രാമിന്റെ ഒഴുക്ക് രണ്ട് റോഡുകളായി വിഭജിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. വാക്യഘടന അവബോധജന്യമാണ്:

എങ്കിൽ വ്യവസ്ഥ:

    # തടയുകയാണെങ്കിൽ

    പ്രസ്താവന 1

    പ്രസ്താവന 2

    ഇത്യാദി

വേറെ:

    # വേറെ ബ്ലോക്ക്

    പ്രസ്താവന 3

    പ്രസ്താവന 4

    ഇത്യാദി:

ഈ ഓപ്പറേറ്റർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വിശദീകരിക്കാം. ആദ്യം, സ്റ്റാൻഡേർഡ് സ്റ്റേറ്റ്മെന്റ് ത്രെഡിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു യൂ, പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു കണ്ടീഷൻ "ശരിയോ തെറ്റോ". കൂടുതൽ പ്രവർത്തനങ്ങൾ പരിശോധനയുടെ ഫലത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ശരിയാണെങ്കിൽ, വ്യവസ്ഥയെ തുടർന്നുള്ള നിർദ്ദേശങ്ങളുടെ ക്രമത്തിലുള്ള നിർദ്ദേശം നേരിട്ട് നടപ്പിലാക്കും. യൂ, അത് തെറ്റാണെങ്കിൽ, പിന്നെ മറ്റാരെങ്കിലും. 

ഈ രീതിയിൽ നിങ്ങൾക്ക് പിശകുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്, ഉപയോക്താവിന് ആരം നൽകേണ്ടതുണ്ട്. വ്യക്തമായും, ഇത് ഒരു പ്ലസ് ചിഹ്നമുള്ള ഒരു സംഖ്യയായിരിക്കാം, അല്ലെങ്കിൽ ഇത് ഒരു ശൂന്യ മൂല്യമാണ്. ഇത് 0-ൽ കുറവാണെങ്കിൽ, ഒരു പോസിറ്റീവ് നമ്പർ നൽകാൻ ആവശ്യപ്പെടുന്ന ഒരു സന്ദേശം നിങ്ങൾ നൽകേണ്ടതുണ്ട്. 

ഈ ടാസ്ക് നടപ്പിലാക്കുന്ന കോഡ് ഇതാ. എന്നാൽ ഇവിടെ ഒരു തെറ്റ് ഉണ്ട്. ഏതാണ് എന്ന് ഊഹിക്കാൻ ശ്രമിക്കുക. 

ആരം = int(ഇൻപുട്ട്("ആരം നൽകുക:"))

ആരം >= 0 ആണെങ്കിൽ:

    പ്രിന്റ് (“ചുറ്റളവ് = “, 2 * 3.14 * ആരം)

    പ്രിന്റ് ("ഏരിയ = ", 3.14 * ആരം ** 2)

    വേറെ:

        പ്രിന്റ് ("ദയവായി ഒരു പോസിറ്റീവ് നമ്പർ നൽകുക")

ഇൻഡന്റേഷൻ പൊരുത്തക്കേട് പിശക്. എങ്കിൽ അല്ലെങ്കിൽ അവ ഇല്ലാതെ അല്ലെങ്കിൽ അവയുടെ അതേ എണ്ണം (അവ കൂടുകൂട്ടിയിട്ടുണ്ടോ ഇല്ലയോ എന്നതിനെ ആശ്രയിച്ച്) സ്ഥിതിചെയ്യണം.

നമുക്ക് മറ്റൊരു ഉപയോഗ കേസ് നൽകാം (ഓപ്പറേറ്റർ വിന്യാസത്തിൽ എല്ലാം ശരിയാകും) - ഒരു പാസ്‌വേഡ് പരിശോധിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ ഘടകം.

പാസ്‌വേഡ് = ഇൻപുട്ട് ("പാസ്‌വേഡ് നൽകുക:")

പാസ്‌വേഡ് == «sshh» എങ്കിൽ:

    പ്രിന്റ് ("സ്വാഗതം")

വേറെ:

    പ്രിന്റ് ("ആക്സസ്സ് നിരസിച്ചു")

പാസ്‌വേഡ് sshh ആണെങ്കിൽ ഈ നിർദ്ദേശം വ്യക്തിയെ കൂടുതൽ ഒഴിവാക്കുന്നു. അക്ഷരങ്ങളുടെയും അക്കങ്ങളുടെയും മറ്റെന്തെങ്കിലും സംയോജനമുണ്ടെങ്കിൽ, അത് "ആക്സസ് നിഷേധിച്ചു" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും.

പ്രസ്താവന-പ്രകടനം if-elif-else

നിരവധി നിബന്ധനകൾ ശരിയല്ലെങ്കിൽ മാത്രം, ബ്ലോക്കിലുള്ള പ്രസ്താവന നടപ്പിലാക്കും. മറ്റാരെങ്കിലും. ഈ പദപ്രയോഗം ഇതുപോലെ പ്രവർത്തിക്കുന്നു.

വ്യവസ്ഥ_1 ആണെങ്കിൽ:

    # തടയുകയാണെങ്കിൽ

    പ്രസ്താവന

    പ്രസ്താവന

    കൂടുതൽ പ്രസ്താവന

എലിഫ് അവസ്ഥ_2:

    # ആദ്യത്തെ എലിഫ് ബ്ലോക്ക്

    പ്രസ്താവന

    പ്രസ്താവന

    കൂടുതൽ പ്രസ്താവന

എലിഫ് അവസ്ഥ_3:

    # രണ്ടാമത്തെ എലിഫ് ബ്ലോക്ക്

    പ്രസ്താവന

    പ്രസ്താവന

    കൂടുതൽ പ്രസ്താവന

പങ്ക് € |

മറ്റാരെങ്കിലും

    പ്രസ്താവന

    പ്രസ്താവന

    കൂടുതൽ പ്രസ്താവന

നിങ്ങൾക്ക് എത്ര അധിക വ്യവസ്ഥകൾ വേണമെങ്കിലും വ്യക്തമാക്കാം.

നെസ്റ്റഡ് പ്രസ്താവനകൾ

ഒന്നിലധികം വ്യവസ്ഥകൾ നടപ്പിലാക്കുന്നതിനുള്ള മറ്റൊരു മാർഗ്ഗം if ബ്ലോക്കിൽ അധിക കണ്ടീഷനുകൾ തിരുകുക എന്നതാണ്.

ഓപ്പറേറ്റർ if മറ്റൊരു കണ്ടീഷൻ ബ്ലോക്കിനുള്ളിൽ

gre_score = int(ഇൻപുട്ട് ("നിങ്ങളുടെ നിലവിലെ ക്രെഡിറ്റ് പരിധി നൽകുക"))

per_grad = int(input("നിങ്ങളുടെ ക്രെഡിറ്റ് റേറ്റിംഗ് നൽകുക:"))

per_grad > 70 ആണെങ്കിൽ:

    # ബ്ളോക്ക് എങ്കിൽ പുറം

        ഗ്രേ_സ്കോർ > 150 ആണെങ്കിൽ:

            # അകത്തെ ആണെങ്കിൽ ബ്ലോക്ക്

    പ്രിന്റ് (“അഭിനന്ദനങ്ങൾ, നിങ്ങൾക്ക് ഒരു ലോൺ ലഭിച്ചു”)

വേറെ:

    പ്രിന്റ് ("ക്ഷമിക്കണം, നിങ്ങൾ വായ്പയ്ക്ക് യോഗ്യനല്ല")

ഈ പ്രോഗ്രാം ക്രെഡിറ്റ് റേറ്റിംഗ് പരിശോധന നടത്തുന്നു. ഇത് 70-ൽ കുറവാണെങ്കിൽ, ഉപയോക്താവിന് ക്രെഡിറ്റിന് അർഹതയില്ലെന്ന് പ്രോഗ്രാം റിപ്പോർട്ട് ചെയ്യുന്നു. ഇത് കൂടുതലാണെങ്കിൽ, നിലവിലെ ക്രെഡിറ്റ് പരിധി 150-ൽ കൂടുതലാണോ എന്നറിയാൻ രണ്ടാമത്തെ പരിശോധന നടത്തുന്നു. ഉണ്ടെങ്കിൽ, വായ്പ നൽകിയതായി ഒരു സന്ദേശം പ്രദർശിപ്പിക്കും.

രണ്ട് മൂല്യങ്ങളും തെറ്റാണെങ്കിൽ, ഉപയോക്താവിന് വായ്പ ലഭിക്കാനുള്ള സാധ്യതയില്ലെന്ന് ഒരു സന്ദേശം പ്രദർശിപ്പിക്കും. 

ഇനി നമുക്ക് ആ പ്രോഗ്രാം കുറച്ചുകൂടി പുനഃക്രമീകരിക്കാം.

gre_score = int(ഇൻപുട്ട്("നിലവിലെ പരിധി നൽകുക: "))

per_grad = int(ഇൻപുട്ട്("ക്രെഡിറ്റ് സ്കോർ നൽകുക:"))

per_grad > 70 ആണെങ്കിൽ:

    ഗ്രേ_സ്കോർ > 150 ആണെങ്കിൽ:

        പ്രിന്റ് (“അഭിനന്ദനങ്ങൾ, നിങ്ങൾക്ക് ഒരു ലോൺ ലഭിച്ചു”)

    വേറെ:

        പ്രിന്റ് ("നിങ്ങളുടെ ക്രെഡിറ്റ് പരിധി കുറവാണ്")

വേറെ:

    പ്രിന്റ് ("ക്ഷമിക്കണം, നിങ്ങൾക്ക് ക്രെഡിറ്റിന് അർഹതയില്ല")

കോഡ് തന്നെ വളരെ സാമ്യമുള്ളതാണ്, പക്ഷേ നെസ്റ്റഡ് ആണ് if അതിൽ നിന്നുള്ള വ്യവസ്ഥ തെറ്റാണെന്ന് തെളിഞ്ഞാൽ ഒരു അൽഗോരിതം നൽകുന്നു. അതായത്, കാർഡിലെ പരിധി അപര്യാപ്തമാണ്, എന്നാൽ ക്രെഡിറ്റ് ചരിത്രം നല്ലതാണ്, "നിങ്ങൾക്ക് കുറഞ്ഞ ക്രെഡിറ്റ് റേറ്റിംഗ് ഉണ്ട്" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും.

if-else ഒരു വ്യവസ്ഥയ്ക്കുള്ളിലെ പ്രസ്താവന മറ്റാരെങ്കിലും

ടെസ്റ്റ് സ്കോറുകളെ അടിസ്ഥാനമാക്കി ഒരു വിദ്യാർത്ഥിയുടെ ഗ്രേഡ് നിർണ്ണയിക്കുന്ന മറ്റൊരു പ്രോഗ്രാം ഉണ്ടാക്കാം.

സ്കോർ = int (ഇൻപുട്ട് ("നിങ്ങളുടെ സ്കോർ നൽകുക:"))

എങ്കിൽ സ്കോർ >= 90:

    പ്രിന്റ് ("മികച്ചത്! നിങ്ങളുടെ ഗ്രേഡ് എ")

വേറെ:

    എങ്കിൽ സ്കോർ >= 80:

പ്രിന്റ് ("മികച്ചത്! നിങ്ങളുടെ ഗ്രേഡ് B ആണ്")

    വേറെ:

എങ്കിൽ സ്കോർ >= 70:

    പ്രിന്റ് ("കൊള്ളാം! നിങ്ങളുടെ ഗ്രേഡ് C ആണ്")

വേറെ:

    എങ്കിൽ സ്കോർ >= 60:

പ്രിന്റ് (“നിങ്ങളുടെ ഗ്രേഡ് D ആണ്. മെറ്റീരിയൽ ആവർത്തിക്കുന്നത് മൂല്യവത്താണ്.”)

    വേറെ:

പ്രിന്റ് ("നിങ്ങൾ പരീക്ഷയിൽ പരാജയപ്പെട്ടു")

സ്കോർ 90-നേക്കാൾ വലുതാണോ അതിന് തുല്യമാണോ എന്ന് ആദ്യം ആപ്ലിക്കേഷൻ പരിശോധിക്കുന്നു. അതെ എങ്കിൽ, അത് എ ഗ്രേഡ് നൽകുന്നു. ഈ വ്യവസ്ഥ തെറ്റാണെങ്കിൽ, തുടർന്നുള്ള പരിശോധനകൾ നടത്തുന്നു. ഒറ്റനോട്ടത്തിൽ അൽഗോരിതം ഏതാണ്ട് സമാനമാണെന്ന് നമുക്ക് കാണാം. അതിനാൽ അകത്ത് പരിശോധിക്കുന്നതിന് പകരം മറ്റാരെങ്കിലും ഒരു കോമ്പിനേഷൻ ഉപയോഗിക്കുന്നതാണ് നല്ലത് if-elif- else.

അതിനാൽ ഓപ്പറേറ്റർ if വളരെ പ്രധാനപ്പെട്ട ഒരു ഫംഗ്‌ഷൻ നിർവ്വഹിക്കുന്നു - ചില കോഡ് കഷണങ്ങൾ ആവശ്യമുണ്ടെങ്കിൽ മാത്രം എക്‌സിക്യൂട്ട് ചെയ്യുന്നുവെന്ന് ഇത് ഉറപ്പാക്കുന്നു. ഇത് കൂടാതെ പ്രോഗ്രാമിംഗ് സങ്കൽപ്പിക്കുക അസാധ്യമാണ്, കാരണം ലളിതമായ അൽഗോരിതങ്ങൾക്ക് പോലും "നിങ്ങൾ ഇടത്തേക്ക് പോയാൽ, നിങ്ങൾ അത് കണ്ടെത്തും, നിങ്ങൾ വലത്തേക്ക് പോകുകയാണെങ്കിൽ, നിങ്ങൾ ഇതും അതും ചെയ്യേണ്ടതുണ്ട്" പോലുള്ള ഫോർക്കുകൾ ആവശ്യമാണ്.