പൈത്തണ്‍: പാഠം അഞ്ച്

ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കുന്നതെങ്ങനെ?

കഴിഞ്ഞ പാഠത്തിന്റെ കമന്റുകളില്‍ "Free" എന്ന വായനക്കാരി (രന്‍?) അവതരിപ്പിച്ച പ്രവര്‍ത്തനം ഒന്നു നോക്കാം. ചോദ്യം ഇതാണ്: " ഒരാളുടെ പേരും വയസും ഇന്‍പുട്ട് ആയി എടുത്ത് അയാള്‍ ജനിച്ച വര്‍ഷം ഔട്പുട്ട് തരുന്ന പ്രോഗ്രാം എഴുതുക." ഈ പ്രവര്‍ത്തനത്തിന് "digitaleye" എന്ന വായനക്കാരന്‍ (രി?) തന്ന ഉത്തരം കുറച്ചുകൂടി വിശദമാക്കി എഴുതിയ ഒരു പ്രോഗ്രാം ഇതാ. പ്രോഗ്രാം ഒരു ഫയലിലേക്ക് സേവ് ചെയ്ത് പല പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ. ഇതിനുള്ള എളുപ്പവഴി IDLE ഉപയോഗിക്കുക എന്നതാണ്, ഇവിടെ പറഞ്ഞിരിക്കുന്നതുപോലെ.


പ്രോഗ്രാമിന്റെ അഞ്ചാമത്തെ വരിയില്‍ ഉപയോക്താവിന്റെ പേര് raw_input() ഉപയോഗിച്ച് പ്രോഗ്രാമിലെ name എന്ന ചരത്തിലേക്ക് എത്തിക്കുന്നു. ഇവിടെ ഉപയോക്താവിനോട് ചോദിക്കേണ്ട ചോദ്യം ഒരു string ആയി തയ്യാറാക്കിയിരിക്കുന്ന രീതി പ്രത്യേകം ശ്രദ്ധിക്കുക. + എന്ന സംകാരകം (operator) സംഖ്യകളുടെ തുക കാണാന്‍ മാത്രമല്ല, string-കളെ കൂട്ടിച്ചേര്‍ത്ത് ഒറ്റ string ആക്കാനും പൈത്തണില്‍ ഉപയോഗിക്കാം. ഉദാഹരണം:

Python 2.6.5 (r265:79063, Apr 16 2010, 13:09:56) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+1
2
>>> "1" + "1"
'11'
>>> 

മുകളിലെ പ്രോഗ്രാമില്‍ ഉപയോക്താവിനെ പേരുള്‍പ്പടെ സംബോധന ചെയ്യാനായി ഈ വിദ്യ പ്രയോഗിച്ചിരിക്കുന്നു. ഏഴാമത്തെ വരിയില്‍ ഇന്‍പുട്ട് ആയി കിട്ടിയ പേരും ചോദിക്കേണ്ട ചോദ്യവും + എന്ന സംകാരകം ഉപയോഗിച്ച് ഒറ്റ string ആക്കി question എന്ന ചരത്തില്‍ സൂക്ഷിക്കുന്നു. ഒന്‍പതാമത്തെ വരിയില്‍ ഉപയോക്താവിനോട് വയസ് ചോദിച്ച് age എന്ന ചരത്തില്‍ സൂക്ഷിക്കുന്നു. ഇതിനു വേണ്ടി മുമ്പത്തെ പാഠത്തില്‍ കണ്ടതുപോലെ input() ഉപയോഗിക്കുന്നു. input() -ന്റെ ബ്രായ്ക്കറ്റിനുള്ളില്‍ ഉപയോക്താവിനോട് ചോദിക്കേണ്ട ചോദ്യം കൊടുക്കേണ്ടിടത്ത് question എന്ന ചരം കൊടുത്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ ചരത്തിന്റെ വില (മൂല്യം, value) നാം ഏഴാമത്തെ വരിയില്‍ + ഉപയോഗിച്ച് തയ്യാറാക്കിയ string ആണ്. പ്രോഗ്രാമില്‍ ഏതെങ്കിലും വില വേണ്ടതായ സ്ഥലങ്ങളിലൊക്കെ അതിനു പകരം അതേ വിലയുള്ള ചരം ഉപയോഗിക്കാം. ഇവിടെ നാം ചെയ്തിരിക്കുന്നതും ഇതുതന്നെ.

പ്രോഗ്രാമിന്റെ പതിനൊന്നാമത്തെ വരിയില്‍ നടപ്പുവര്‍ഷം ഏതെന്ന് current_year എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെയ്ക്കുന്നു. അര്‍ത്ഥവത്തായ പേരുകളുള്ള ചരങ്ങളുടെ ഉപയോഗം പ്രോഗ്രാം വായന സുകരമാക്കാന്‍ സഹായിക്കുന്നു. നമ്മുടെ പ്രോഗ്രാം വളരെ ചെറിയ ഒന്നായതുകൊണ്ട് ഇങ്ങനെ ചെയ്യുന്നതുകൊണ്ട് — 2010 എന്ന് നേരിട്ട് പറയുന്നതിനു പകരം current_year എന്ന ചരത്തില്‍ ഈ വില സൂക്ഷിച്ചുവെച്ച് നടപ്പുവര്‍ഷം വേണ്ടിടത്തെല്ലാം ഈ ചരം ഉപയോഗിക്കുന്നതുകൊണ്ട് — ഉള്ള പ്രയോജനം എന്താണെന്നത് അത്രകണ്ട് വ്യക്തമല്ല. എന്നാല്‍ കുറച്ചു വലിയ ഒരു പ്രോഗ്രാമിലോ? പേരില്ലാത്ത കുറെയേറെ സംഖ്യകള്‍ പ്രോഗ്രാമില്‍ ഉണ്ടെങ്കില്‍ അത് പ്രോഗ്രാം വായിക്കുന്ന ആളെ കുഴക്കാനേ ഉപകരിക്കൂ. ഓരോ സംഖ്യയും എന്തര്‍ത്ഥത്തിലാണ് ഉപയോഗിച്ചിരിക്കുന്നത് എന്നറിയാന്‍ ആ സംഖ്യ എവിടെയൊക്കെയാണ് ഉപയോഗിച്ചിരിക്കുന്നതെന്ന് കണ്ടുപിടിച്ച് തല പുകയ്ക്കേണ്ടിവരും. അതുകൊണ്ടുതന്നെ ഇങ്ങനെയുള്ള സംഖ്യക്ളെ അര്‍ത്ഥം വ്യക്തമാകുന്ന രീതിയിലുള്ള പേരുകള്‍ കൊടുത്ത് പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്നതാണ് മെച്ചം, ഇവിടെ ചെയ്തതുപോലെ.

പ്രോഗ്രാമിന്റെ പതിമൂന്നാമത്തെ വരിയില്‍ ഉപയോക്താവ് ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കാനായി നടപ്പുവര്‍ഷത്തില്‍നിന്ന് വയസ് കുറയ്ക്കുന്നു. അവസാനത്തെ രണ്ടു വരികളില്‍ ഇങ്ങനെ കിട്ടിയ ഉത്തരം ഔട്പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

ബഗ്!

ഇത് താരതമ്യേന വളരെ ചെറിയതായ, ലളിതമായ ഒരു പ്രോഗ്രാം ആണ്. "Free" അവതരിപ്പിച്ച പ്രവര്‍ത്തനത്തിന് ഈ പ്രോഗ്രാം മതിയായ ഉത്തരവും ആണ്. എന്നാല്‍ ഈ പ്രോഗ്രാമിന് അത്ര ചെറുതല്ലാത്ത ഒരു പ്രശ്നം ഉണ്ട്. ഈ പ്രശ്നം കാരണം ഒട്ടേറെപ്പേരുടെ കാര്യത്തില്‍ ഈ പ്രോഗ്രാം തെറ്റായ ഉത്തരം തരും! ഒന്നാന്തരം ഒരു ബഗ് (കീടം?) നമ്മുടെ പ്രോഗ്രാമില്‍ ഉണ്ട് എന്നര്‍ത്ഥം. ഇതുപോലെയുള്ള പ്രശ്നങ്ങള്‍ പ്രോഗ്രാമിന്റെ ലോജിക്കില്‍ നുഴഞ്ഞുകയറാതെ ശ്രദ്ധിക്കാന്‍ പഠിക്കുക എന്നത് നല്ല രീതിയില്‍ പ്രോഗ്രാം എഴുതാന്‍ പഠിക്കുന്നതിന്റെ അതിപ്രധാനമായ ഭാഗമാണ്. ഒരാള്‍ ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കാനുള്ള മുകളില്‍ക്കൊടുത്ത പ്രോഗ്രാം എപ്പോഴൊക്കെയാണ് തെറ്റായ ഉത്തരം തരുന്നത് എന്ന് ആലോചിച്ചു നോക്കൂ. ഒരു പത്തുമിനിട്ട് മനസ്സിരുത്തി ആലോചിച്ച്, പ്രോഗ്രാമിന് കിട്ടാവുന്ന പല തരത്തിലുള്ള (ശരിയായ) ഇന്‍പുട്ടുകള്‍ ഏതൊക്കെയാണ്, അവയ്ക്കെല്ലാം പ്രോഗ്രാം ശരിയായ മറുപടി തരുമോ എന്നൊക്കെ തിരിച്ചും മറിച്ചും ചിന്തിച്ചുനോക്കി പ്രശ്നം പിടികിട്ടുന്നില്ലെങ്കില്‍ മാത്രം അടുത്ത ഖണ്ഡിക നോക്കുക.

...
...
...
...
...
...

നാം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുന്നത് 2010 ഓഗസ്റ്റ് തുടക്കത്തില്‍ ആണെന്ന് കരുതുക. പ്രോഗ്രാമിലെ പ്രശ്നം എന്താണെന്ന് മനസ്സിലാക്കാന്‍ ഹരി, ജോണ്‍ എന്ന രണ്ടു സുഹൃത്തുക്കളുടെ കാര്യമെടുക്കാം. ഹരിക്ക് പ്രായം 15 വയസും 10 മാസവും. ജോണിന് 15 വയസും 2 മാസവും (അതുകൊണ്ടു തന്നെ മാത്സ് ബ്ളോഗിനു പിന്നിലെ ഹരി, ജോണ്‍ സാറന്മാരല്ല ഇവരെന്ന് മനസ്സിലായല്ലോ.). നമ്മുടെ പ്രോഗ്രാമിന്റെ ചോദ്യത്തിന് രണ്ടുപേരും 15 എന്ന് ഉത്തരം കൊടുക്കും. രണ്ടുപേരും ജനിച്ചത് 1995-ല്‍ ആണെന്ന് പ്രോഗ്രാം പറയുകയും ചെയ്യും. ജോണിന്റെ കാര്യത്തില്‍ ഇത് ശരിയാണ്. ഹരിയുടെ കാര്യത്തില്‍ ശരിയല്ലതാനും! ഹരി ജനിച്ചത് 1994 സെപ്റ്റംബര്‍ അവസാനം ആണ്.

ഈ കീടത്തെ എങ്ങനെ ശരിപ്പെടുത്താം?

ബഗ് ഉണ്ടെന്ന് മനസ്സിലായ സ്ഥിതിക്ക് അത് ഒഴിവാക്കുന്ന തരത്തില്‍ പ്രോഗ്രാം തിരുത്തി എഴുതേണ്ടത് നമ്മുടെ കടമയാണ് (ഈ പ്രക്രിയയെ "കീടോച്ഛാടനം" എന്നു വിളിക്കാമോ?). ഹരിയുടെ കാര്യത്തില്‍ പ്രോഗ്രാമില്‍നിന്ന് തെറ്റായ ഉത്തരം കിട്ടാന്‍ എന്താണ് കാരണം? പ്രോഗ്രാമിന് ശരിയായ ഉത്തരം കണ്ടുപിടിക്കാന്‍ ആവശ്യമായ വിവരങ്ങള്‍ എല്ലാം ഇന്‍പുട്ട് ആയി നാം കൊടുക്കാത്തതുതന്നെ. വയസിന്റെ കുറച്ചുകൂടി കൃത്യമായ വിവരം — എത്ര വര്‍ഷം എന്നതിന് പുറമേ എത്ര മാസം എന്നതുകൂടി — ഇന്‍പുട്ട് ആയി പ്രോഗ്രാമിന് കിട്ടിയാല്‍ മേല്‍പ്പറഞ്ഞ തെറ്റ് ഒഴിവാക്കുന്ന പ്രോഗ്രാം നമുക്കെഴുതാം. ഇങ്ങനെയുള്ള ഒരു പ്രോഗ്രാമിന്റെ ലോജിക് ഏകദേശം ഇതുപോലെയിരിക്കും:

1. ഉപയോക്താവിന്റെ പ്രായം എത്ര വര്‍ഷം, എത്ര മാസം എന്നത് ചോദിച്ച് മനസ്സിലാക്കുക.
• വര്‍ഷത്തിനെ years എന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക.
• മാസത്തിനെ months എന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക.
2. നടപ്പുവര്‍ഷവും മാസവും current_year , current_month എന്ന ചരങ്ങളില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക.
3. months എന്നതിന്റെ വില current_month എന്നതിന്റെ വിലയേക്കാള്‍ കുറവാണെങ്കില്‍
• current_year - years എന്നതാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം; ഈ വിലയെ year_of_birth എന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക.
4. മറിച്ച്, months എന്നതിന്റെ വില current_month എന്നതിന്റെ വിലയ്ക്ക് തുല്യമോ അതില്‍ കൂടുതലോ ആണെങ്കില്‍
• current_year - years - 1 എന്നതാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം; ഈ വിലയെ year_of_birth എന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക.
5. year_of_birth എന്ന ചരത്തിന്റെ വിലയാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം എന്ന് ഉത്തരം പറയുക.

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 1.

ഈ ലോജിക് ശ്രദ്ധിച്ച് വായിക്കുക. ഇത് ഹരി ജനിച്ച വര്‍ഷം ശരിയായി കണ്ടുപിടിക്കുമോ എന്ന് ചിന്തിക്കുക.

പ്രവ. 2.

ഇപ്പറഞ്ഞ ലോജിക് എങ്ങനെ ഒരു പ്രോഗ്രാം ആയി എഴുതാം എന്ന് ആലോചിക്കുക.

if ... else

മുകളിലുള്ള ലോജിക്കിന് ആകെ അഞ്ചു ഭാഗങ്ങള്‍ ഉള്ളതില്‍ ആദ്യത്തെ രണ്ടു ഭാഗങ്ങള്‍ പ്രോഗ്രാമില്‍ എഴുതേണ്ടതെങ്ങനെ എന്ന് നമുക്കറിയാം – മുമ്പു കണ്ട പ്രോഗ്രാമുകളില്‍ നാം ഇതേപോലെയുള്ള കാര്യങ്ങള്‍ ചെയ്തിട്ടുണ്ട്. ലോജിക്കിന്റെ അഞ്ചാമത്തെ ഭാഗവും — കണ്ടുപിടിച്ച ഉത്തരം ഉപയോക്താവിന് പറഞ്ഞുകൊടുക്കുക എന്നുള്ളത് — ഇപ്പോള്‍ നമുക്ക് നിഷ്പ്രയാസം ചെയ്യാന്‍ അറിയാം.

പ്രശ്നക്കാരായിട്ട് ഉള്ളത് മൂന്നും നാലും ഭാഗങ്ങളാണ്: ഒരു പ്രത്യേക കാര്യം — months എന്നതിന്റെ വില current_month എന്നതിന്റെ വിലയേക്കാള്‍ കുറവാണോ എന്നത് — ശരിയാണോ എന്ന് പരിശോധിച്ച്, ഇത് ശരിയാണെങ്കില്‍ ഒരു കാര്യവും, തെറ്റാണെങ്കില്‍ വേറൊരു കാര്യവും ചെയ്യുക എന്നതാണ് ഈ രണ്ട് ഭാഗങ്ങളില്‍ സംഭവിക്കുന്നത്. ഇത് എങ്ങനെയാണ് പ്രോഗ്രാമില്‍ എഴുതുക എന്ന് നാം ഇതുവരെയുള്ള പാഠങ്ങളില്‍ പഠിച്ചിട്ടില്ല. ഇക്കാര്യം ഈ പാഠത്തില്‍ പഠിക്കാം.

നാം ഇതുവരെ കണ്ട പൈത്തണ്‍ പ്രോഗ്രാമുകളെല്ലാം ഒരു നേര്‍രേഖാ സ്വഭാവം ഉള്ളവയാണ്: പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം തുടങ്ങിയാല്‍പ്പിന്നെ പ്രോഗ്രാമിലെ ഓരോ വരിയും പ്രോഗ്രാമില്‍ എഴുതിയിരിക്കുന്ന ക്രമത്തില്‍ പ്രവര്‍ത്തിച്ചുപോകുക എന്ന രീതിയാണ് അവയ്ക്കൊക്കെ ഉള്ളത്. ഇങ്ങനെ "നേര്‍ബുദ്ധി" മാത്രമുള്ള പ്രോഗ്രാമുകളെക്കൊണ്ട് വളരെ പരിമിതങ്ങളായ കാര്യങ്ങളേ ചെയ്യാന്‍ കഴിയൂ. ഇങ്ങനെയല്ലാത്ത — രേഖീയമല്ലാത്ത — രീതിയില്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കാനുള്ള പൈത്തണ്‍ ഭാഷാരൂപങ്ങളില്‍ ഏറ്റവും ലളിതമായതാണ് if ... else എന്ന പ്രയോഗം.
ഒരു വ്യവസ്ഥ (condition) ശരിയാണോ എന്ന് പരിശോധിച്ച്, ശരിയാണെങ്കില്‍ ഒരു കൂട്ടം കാര്യങ്ങളും, തെറ്റാണെങ്കില്‍ മറ്റൊരുകൂട്ടം കാര്യങ്ങളും ചെയ്യാന്‍ പൈത്തണില്‍ (മറ്റു പ്രോഗ്രാമിംഗ് ഭാഷകളിലും) ഉള്ള ഉപാധിയാണ് if ... else എന്ന പ്രയോഗം. ഉദാഹരണമായി, if ... else ഉപയോഗിച്ച് ഒരു സംഖ്യ ഒറ്റസംഖ്യയോ ഇരട്ടസംഖ്യയോ എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം ഇതാ. രണ്ടാം പാഠത്തില്‍ നാം പരിചയപ്പെട്ട ശിഷ്ടം കാണാനുള്ള % എന്ന സംകാരകവും (operator) ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്നു:





ഈ പ്രോഗ്രാമില്‍ എട്ടു മുതല്‍ പതിനൊന്നു വരെയുള്ള വരികളിലാണ് if ... else ഉള്ളത്. ഈ വരികളില്‍ എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് വിശദമായി നോക്കാം:

1. എട്ടും ഒന്‍പതും വരികളില്‍ ചെയ്യുന്നത് ഇതാണ്: number എന്ന ചരത്തില്‍ സൂക്ഷിച്ചിരിക്കുന്ന സംഖ്യയെ രണ്ടു കൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ number ഇരട്ടസംഖ്യയാണെന്ന് പറയുക.
• എട്ടാമത്തെ വരിയില്‍ ശരിയാണോ എന്ന് പരിശോധിക്കേണ്ട വ്യവസ്ഥ if എന്നതിനു ശേഷവും : എന്നതിനു മുമ്പായും കൊടുത്തിരിക്കുന്നു.
• % എന്ന ചിഹ്നം പൈത്തണില്‍ ശിഷ്ടം കാണാനുള്ള സംകാരകത്തെ സൂചിപ്പിക്കുന്നു. (number % 2) എന്ന വ്യഞ്ജകത്തിന്റെ വില number -നെ രണ്ടുകൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം കിട്ടുന്ന സംഖ്യയാണ്. ഇത് പൂജ്യമോ ഒന്നോ ആയിരിക്കും (എന്തുകൊണ്ട്?).
• == എന്ന ചിഹ്നം (രണ്ടു സമചിഹ്നങ്ങള്‍ അടുപ്പിച്ച് എഴുതിയത്) പൈത്തണില്‍ തുല്യത പരിശോധിക്കുന്ന സംകാരകത്തെ സൂചിപ്പിക്കുന്നു.
• എട്ടാമത്തെ വരി വായിക്കേണ്ടത് " number-നെ രണ്ടുകൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ " എന്നാണ്.
• വ്യവസ്ഥ ശരിയാണെങ്കില്‍ ചെയ്യേണ്ട കാര്യങ്ങള്‍ — number ഇരട്ടസംഖ്യയാണെന്ന് പറയുക എന്നുള്ളത് — if ... : കഴിഞ്ഞുള്ള വരിയില്‍ വലതുവശത്തേക്ക് കുറച്ച് മാറ്റി കൊടുത്തിരിക്കുന്നു.
2. പത്തും പതിനൊന്നും വരികളില്‍ ചെയ്യുന്നത് ഇതാണ്: എട്ടാമത്തെ വരിയില്‍ പരിശോധിച്ച വ്യവസ്ഥ — number എന്ന ചരത്തില്‍ സൂക്ഷിച്ചിരിക്കുന്ന സംഖ്യയെ രണ്ടു കൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണോ എന്നത് — തെറ്റാണെങ്കില്‍ number ഒറ്റസംഖ്യയാണെന്ന് പറയുക.
• "എട്ടാമത്തെ വരിയിലെ if -ല്‍ പരിശോധിച്ച വ്യവസ്ഥ തെറ്റാണെങ്കില്‍" എന്ന് പ്രോഗ്രാമില്‍ ചുരുക്കിപ്പറയാനായി else : എന്ന് പ്രയോഗിക്കുന്നു.
• ഈ വ്യവസ്ഥ തെറ്റുമ്പോള്‍ ചെയ്യേണ്ട കാര്യങ്ങള്‍ — number ഒറ്റസംഖ്യയാണെന്ന് പറയുക എന്നുള്ളത് — else : കഴിഞ്ഞുള്ള വരിയില്‍ വലതുവശത്തേക്ക് കുറച്ച് മാറ്റി കൊടുത്തിരിക്കുന്നു.

if ... else : വിശദമായി

if ... else പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം:

1. if വരിയുടെ വ്യാകരണം ഇതാണ്: if condition : . ഇവിടെ condition എന്നത് നമുക്ക് ശരിയോ തെറ്റോ എന്ന് അറിയേണ്ടതായ വ്യവസ്ഥ ആണ്. മുകളിലെ ഉദാഹരണത്തില്‍ ഈ വ്യവസ്ഥ (number % 2) == 0 എന്നതാണ്. condition കഴിഞ്ഞുള്ള : പ്രത്യേകം ശ്രദ്ധിക്കുക .
2. if വരി കഴിഞ്ഞുള്ള വരികളില്‍ condition എന്ന വ്യവസ്ഥ ശരിയാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതണം. ഇത് ഒന്നിലധികം വരികളും ആവാം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈ if വരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്.
3. മുകളിലെ ഉദാഹരണത്തില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (ഒന്‍പതാമത്തെ വരി). ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
4. IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍ if condition : എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ : വിട്ടുപോയതുകൊണ്ടാവും.
5. if -ല്‍ പരിശോധിച്ച വ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരി if വരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം. if വ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത് if -നു ശേഷം if -ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പായി നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്.
6. മുകളിലെ ഉദാഹരണത്തില്‍ if വ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ — number ഇരട്ടസംഖ്യയാണെന്ന് പറയുക എന്നത്. ഈ ഒരു വരി മാത്രം (ഒന്‍പതാമത്തെ വരി) അതുകൊണ്ട് നാലു സ്പേസ് വലത്തേക്ക് തള്ളി എഴുതിയിരിക്കുന്നു.
7. else വരിയുടെ വ്യാകരണം ഇതാണ്: else : . else കഴിഞ്ഞുള്ള : പ്രത്യേകം ശ്രദ്ധിക്കുക .
8. else -ന്റെ അതേ നിരപ്പില്‍ എഴുതിയിട്ടുള്ള, തൊട്ടു മുന്‍പുള്ള if വരിയുടെ വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങളാണ് else വരി കഴിഞ്ഞ് എഴുതേണ്ടത്. ഇത് ഒന്നിലധികം വരികളും ആവാം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈ else വരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്.
9. മുകളിലെ ഉദാഹരണത്തില്‍ പൈത്തണ്‍ മാനകത്തിനനുസരിച്ച് നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (പതിനൊന്നാമത്തെ വരി).
10. IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍ else : എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. പരീക്ഷിച്ചു നോക്കുക. ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കപ്പോഴും ഇത് അവസാനം കൊടുക്കേണ്ടതായ : വിട്ടുപോയതുകൊണ്ടാവും.
11. if -ല്‍ പരിശോധിച്ച വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരി if വരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലതേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം. if വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത് else -നു ശേഷവും else -ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്.
12. മുകളിലെ ഉദാഹരണത്തില്‍ if വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ — number ഒറ്റസംഖ്യയാണെന്ന് പറയുക എന്നത്. ഈ ഒരു വരി മാത്രം (പതിനൊന്നാമത്തെ വരി) അതുകൊണ്ട് നാലു സ്പേസ് വലത്തേക്ക് തള്ളി എഴുതിയിരിക്കുന്നു.
13. ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
14. if ... else -ലെ else ആവശ്യമില്ലെങ്കില്‍ വിട്ടുകളയാവുന്നതാണ് (optional). (തികച്ചും കൃത്രിമമായ ഒരു) ഉദാഹരണമായി, തന്നിരിക്കുന്ന സംഖ്യ ഇരട്ടസംഖ്യയാണെങ്കില്‍ അത് വിളിച്ചുപറയുകയും ഒറ്റസംഖ്യയാണെങ്കില്‍ ഒന്നും പറയാതിരിക്കുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഇതാ:
    
    
    
    ഒറ്റയും ഇരട്ടയും സംഖ്യകള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുമ്പോള്‍ എന്താണ് സംഭവിക്കുന്നത് എന്ന് പ്രവര്‍ത്തിപ്പിച്ചു കണ്ടുപിടിക്കൂ.
    

തുലന സംകാരകങ്ങള്‍

ഒരു സംഖ്യ ഒറ്റയോ ഇരട്ടയോ എന്ന് കണ്ടുപിടിക്കാനുള്ള പ്രോഗ്രാമില്‍ നാം == എന്ന തുല്യത പരിശോധിക്കാനുള്ള സംകാരകം (operator) ഉപയോഗിച്ചല്ലോ. == -നു പുറമേ മറ്റ് തുലനസംകാരകങ്ങളും (comparison operators) പൈത്തണില്‍ ലഭ്യമാണ്. ഈ സംകാരകങ്ങള്‍ എല്ലാംതന്നെ True, False എന്നീ രണ്ടു പ്രത്യേക മൂല്യങ്ങള്‍ ഉത്തരമായി തരുന്നവയാണ്. പേര് സൂചിപ്പിക്കുന്നതുപോലെ തന്നെ ശരി, തെറ്റ് എന്നീ അര്‍ത്ഥങ്ങളാണ് യഥാക്രമം True, False എന്ന മൂല്യങ്ങള്‍ക്ക് പൈത്തണില്‍ ഉള്ളത്. == എന്ന സംകാരകം നമുക്ക് ഒറ്റനോട്ടത്തില്‍ തോന്നുന്നതുപോലെ തന്നെയാണ് പെരുമാറുന്നതും: a, b എന്നിവ സ്ഥിരാങ്കങ്ങളോ (constants) ചരങ്ങളോ ആയിക്കൊള്ളട്ടെ. a == b എന്നതിന്റെ വില

• a, b എന്നിവയുടെ വിലകള്‍ രണ്ടും തുല്യമാണെങ്കില്‍ True ആയിരിക്കും.
• a, b എന്നിവയുടെ വിലകള്‍ രണ്ടും തുല്യമല്ലെങ്കില്‍ False ആയിരിക്കും.

പൈത്തണ്‍ പ്രോഗ്രാമുകളില്‍ ധാരാളമായി ഉപയോഗിക്കുന്ന ചില തുലനസംകാരകങ്ങളുടെ പ്രയോഗം വ്യക്തമാക്കുന്ന പട്ടിക. ഇവിടെ a, b എന്നിവ സ്ഥിരാങ്കങ്ങളോ (constants) ചരങ്ങളോ (variables) ആകാം:

പൈത്തണിലെ ചില തുലനസംകാരകങ്ങള്‍

തുലന സംകാരകം	പ്രയോഗം	രണ്ടാം കോളത്തിലെ വ്യഞ്ജകത്തിന്റെ വില
		True ആകുന്നത്	False ആകുന്നത്
==	a == b	a, b എന്നിവയുടെ വിലകള്‍ തുല്യമാണെങ്കില്‍	a, b എന്നിവയുടെ വിലകള്‍ തുല്യമല്ലെങ്കില്‍
!=	a != b	a, b എന്നിവയുടെ വിലകള്‍ തുല്യമല്ലെങ്കില്‍	a, b എന്നിവയുടെ വിലകള്‍ തുല്യമാണെങ്കില്‍
<	a < b	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കുറവാണെങ്കില്‍	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കുറവല്ലെങ്കില്‍
>	a > b	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കൂടുതലാണെങ്കില്‍	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കൂടുതലല്ലെങ്കില്‍
<=	a <= b	a -യുടെ വില b -യുടെ വിലയ്ക്ക് തുല്യമോ അതില്‍ കുറവോ ആണെങ്കില്‍	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കൂടുതലാണെങ്കില്‍
>=	a >= b	a -യുടെ വില b -യുടെ വിലയ്ക്ക് തുല്യമോ അതില്‍ കൂടുതലോ ആണെങ്കില്‍	a -യുടെ വില b -യുടെ വിലയെക്കാള്‍ കുറവാണെങ്കില്‍

== എന്ന സംകാരകത്തെ പ്രോഗ്രാമില്‍ കാണുമ്പോള്‍ ഇംഗ്ളീഷില്‍ വായിക്കുന്നത് "equals" അല്ലെങ്കില്‍ "equal to" എന്നാണ്. != -നെ വായിക്കുന്നത് "not equal to" എന്നും. ഇങ്ങനെയോ തത്തുല്യങ്ങളായ മലയാള വാക്കുകളായോ (ഏതാണ് നമുക്ക് കൂടുതല്‍ സ്വാഭാവികമായി തോന്നുന്നത് എന്നതനുസരിച്ച്) ഈ ചിഹ്നങ്ങളെ വായിക്കാം.

മുമ്പു പറഞ്ഞതുപോലെ, "നേര്‍രേഖാ" പ്രോഗ്രാമുകളെക്കൊണ്ട് കുറച്ചു കാര്യങ്ങളേ ചെയ്യാന്‍ കഴിയൂ. മറ്റു പ്രോഗ്രാമുകളിലൊക്കെ ഒന്നല്ലെങ്കില്‍ മറ്റൊരു രീതിയില്‍ തുലനം (comparison) കടന്നു വരുമെന്ന് ഉറപ്പിക്കാം. അതുകൊണ്ടു തന്നെ ഇനി നാം എഴുതുന്ന പ്രോഗ്രാമുകളിലെല്ലാം ഒരു തുലനസംകാരകമെങ്കിലും ഉപയോഗിക്കേണ്ടി വരും എന്ന് നിസ്സംശയം പറയാം. തുലനസംകാരകങ്ങള്‍ ശരിയായി പ്രയോഗിക്കേണ്ടതെങ്ങനെ എന്ന് അനവധി ഉദാഹരണങ്ങളിലൂടെ നമുക്ക് പഠിച്ചെടുക്കാം.

ഒരു സംഖ്യ ന്യൂനസംഖ്യയാണോ, അധിസംഖ്യയാണോ, ഇനി ഇതു രണ്ടുമല്ല പൂജ്യമാണോ എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം നമുക്കൊന്ന് എഴുതി നോക്കാം:



ഈ പ്രോഗ്രാമില്‍ പല അളവില്‍ സ്പേസ് വിട്ട് വരികള്‍ എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. മുകളില്‍ക്കൊടുത്ത വിശദീകരണം അനുസരിച്ച് ഇത് മനസ്സിലാക്കാന്‍ ശ്രമിക്കുക. സംശയമുണ്ടെങ്കില്‍ ചോദിക്കുക.

ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കുന്നതെങ്ങനെ? രണ്ടാം പതിപ്പ്

ജോണ്‍, ഹരിമാരുടെ പ്രശ്നം പരിഹരിക്കുന്ന പ്രോഗ്രാം എഴുതാന്‍ വേണ്ടത്ര പൈത്തണ്‍ നാം പഠിച്ചുകഴിഞ്ഞു. പാഠത്തിന്റെ മൂന്നാം ഭാഗത്ത് കൊടുത്ത ലോജിക് ഒരു പ്രോഗ്രാമാക്കി ഒന്ന് എഴുതി നോക്കിയാലോ? ലോജിക് വിശദമായിത്തന്നെ നാം എഴുതിയതുകൊണ്ട് ഇത് പ്രോഗ്രാമാക്കുക എന്നത് തികച്ചും അനായാസം തന്നെ. കുറച്ചു വലിയ പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള ഏറ്റവും എളുപ്പ വഴിയും ഇതു തന്നെയാണ്: ആദ്യം പ്രോഗ്രാമിന്റെ ലോജിക് നമുക്കിഷ്ടമുള്ള ഭാഷയില്‍ എഴുതുക. പിന്നെ അതിന്റെ ഓരോ ഭാഗവും പൈത്തണിലേക്ക് മൊഴിമാറ്റം നടത്തുക. ഒരു വലിയ പ്രോഗ്രാം ഒറ്റയടിക്ക് പൈത്തണില്‍ എഴുതുന്നതിലും എളുപ്പം — തെറ്റുകള്‍ കുറയ്ക്കാനുള്ള എളുപ്പ വഴിയും — ഇങ്ങനെ ചെയ്യുന്നതാണ്.

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 3.

ഈ പ്രോഗ്രാം ശ്രദ്ധിച്ച് വായിക്കുക. ഇത് പാഠത്തിന്റെ മൂന്നാം ഭാഗത്ത് കൊടുത്ത ലോജിക്കുമായി യോജിച്ചുപോകുന്നുണ്ടോ എന്ന് തിട്ടപ്പെടുത്തുക.

പ്രവ. 4.

ഈ പ്രോഗ്രാം പല തവണ പ്രവര്‍ത്തിപ്പിക്കുക. പല (വര്‍ഷം, മാസം) ജോടികള്‍ക്ക് ഇത് ശരിയായ ഉത്തരം തരുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക.

പ്രവ. 5.

ഈ പ്രോഗ്രാം എപ്പോഴാണ് തെറ്റായ ഉത്തരം തരുന്നത്? മുന്‍പുള്ള പ്രോഗ്രാമിനെ അപേക്ഷിച്ച് ഈ പ്രോഗ്രാം തെറ്റായ ഉത്തരം തരുന്ന അവസരങ്ങള്‍ കൂടുതലോ കുറവോ? ഈ തെറ്റിനെ ഒഴിവാക്കുന്ന രീതിയില്‍ പ്രോഗ്രാം തിരുത്തിയെഴുതുക.

ബൂളിയന്‍ സംകാരകങ്ങള്‍

ശരി, തെറ്റ് ( True, False ) എന്നീ രണ്ട് സ്ഥിരാങ്കങ്ങളെ ബൂളിയന്‍ മൂല്യങ്ങള്‍ (Boolean values)എന്ന് പറയുന്നു. ഈ രണ്ടു വിലകളെ അടിസ്ഥാനപ്പെടുത്തിയുള്ള ലോജിക് വികസിപ്പിച്ചെടുത്ത ഇംഗ്ളീഷ് ഗണിതശാസ്ത്രജ്ഞനായ ജോര്‍ജ് ബൂളിന്റെ ബഹുമാനാര്‍ത്ഥമാണ് ഇത്. തുലന സംകാരകങ്ങള്‍ പ്രയോഗിക്കുമ്പോള്‍ കിട്ടുന്നത് ബൂളിയന്‍ മൂല്യങ്ങളാണല്ലോ. ഇത്തരത്തിലുള്ള മൂല്യങ്ങളെ സംയോജിപ്പിക്കാന്‍ ഉപയോഗിക്കുന്ന സംകാരകങ്ങളാണ് ബൂളിയന്‍ സംകാരകങ്ങള്‍ (Boolean operators). പേരുകേട്ടാല്‍ ഭയം തോന്നാമെങ്കിലും ഇവ വളരെ ലളിതങ്ങളായ സംഭവങ്ങളാണ്; ഈ പേരിലല്ലെങ്കിലും ഇവയെ നമുക്കെല്ലാവര്‍ക്കും കുട്ടിക്കാലം മുതല്‍ക്കേ പരിചയമുള്ളതാണുതാനും!

പൈത്തണ്‍ പ്രോഗ്രാമുകളില്‍ ധാരാളമായി ഉപയോഗിക്കുന്ന ചില ബൂളിയന്‍ സംകാരകങ്ങളുടെ പ്രയോഗം വ്യക്തമാക്കുന്ന പട്ടിക. ഇവിടെ a, b എന്നിവ True, False എന്നീ വിലകളുള്ള സ്ഥിരാങ്കങ്ങളോ ചരങ്ങളോ ആകാം:

പൈത്തണിലെ ചില ബൂളിയന്‍ സംകാരകങ്ങള്‍

ബൂളിയന്‍ സംകാരകം	പ്രയോഗം	രണ്ടാം കോളത്തിലെ വ്യഞ്ജകത്തിന്റെ വില
		True ആകുന്നത്	False ആകുന്നത്
not	not a	a യുടെ വില False ആണെങ്കില്‍	a യുടെ വില True ആണെങ്കില്‍
and	a and b	a, b രണ്ടിന്റെയും വിലകള്‍ True ആണെങ്കില്‍	a, b എന്നിവയില്‍ ഒന്നിന്റെയെങ്കിലും വില False ആണെങ്കില്‍
or	a or b	a, b എന്നിവയില്‍ ഒന്നിന്റെയെങ്കിലും വില True ആണെങ്കില്‍	a, b രണ്ടിന്റെയും വിലകള്‍ False ആണെങ്കില്‍

ബൂളിയന്‍ സംകാരകങ്ങളെക്കുറിച്ച് പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടതായ ഒരു കാര്യം: മുകളിലെ പട്ടിക കണ്ടാല്‍ തോന്നുന്നതിന്റെ പത്തിലൊന്ന് കാഠിന്യം ഇവ പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുമ്പോള്‍ തോന്നുകയില്ല. and, or, not എന്നീ വാക്കുകള്‍ ഇംഗ്ളീഷില്‍ ഉപയോഗിക്കുന്നതുപോലെ തന്നെ പ്രോഗ്രാമിലും രണ്ടാമതൊന്ന് ആലോചിക്കാതെ ഉപയോഗിച്ചു പോവുകയാണ് പതിവ്. കുറച്ച് ഉദാഹരണങ്ങള്‍ കൊണ്ട് ഇത് വ്യക്തമാകും. എപ്പോഴെങ്കിലും സംശയം വന്നാല്‍ ഈ പട്ടിക നോക്കുകയും ചെയ്യാം.

തന്നിരിക്കുന്ന സംഖ്യ 2, 3, 5 ഇവ മൂന്നിന്റേയും ഗുണിതമാണോ എന്ന് പരിശോധിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതി നോക്കാം:

പ്രവര്‍ത്തനം

പ്രവ. 6.

ഈ പ്രോഗ്രാം ശ്രദ്ധിച്ച് വായിക്കുക. ഇവിടെ സ്പേസ് ഉപയോഗിച്ചിരിക്കുന്ന രീതി ശരിക്ക് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. ഓരോ if -ന്റെയും else ഏതാണ്? ഈ പ്രോഗ്രാമിന്റെ ലോജിക് എന്താണ്?

ഇതേ പ്രശ്നത്തിന് ഉത്തരം തരുന്ന മറ്റൊരു പ്രോഗ്രാം നോക്കൂ. പല പ്രാവശ്യം "if ..." എന്നെഴുതുന്നതിനു പകരം ഇവിടെ "and" ഉപയോഗിച്ചിരിക്കുന്നു. ഫലമോ? മുമ്പത്തെ പ്രോഗ്രാമിന്റെയത്ര ദൈര്‍ഘ്യമില്ലാത്തതും വായിച്ചു മനസ്സിലാക്കാന്‍ അത്രതന്നെ പ്രയാസപ്പെടേണ്ടാത്തതുമായ ഒരു പ്രോഗ്രാം. പ്രോഗ്രാമിലെ ഏഴാമത്തെ വരി അധികം വലത്തേക്ക് നീണ്ടു പോകാതിരിക്കാനായി (ബ്രൗസറില്‍ വായിക്കാനുള്ള സൗകര്യത്തിനായി മാത്രം) "\" ഉപയോഗിച്ച് രണ്ടായി മുറിച്ചിരിക്കുന്നു:

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 7.

തന്നിരിക്കുന്ന സംഖ്യ 2, 3, 5 ഇവയില്‍ ഒന്നിന്റെയെങ്കിലും ഗുണിതമാണോ എന്ന് പരിശോധിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതുക. ഇതിനായി "or" എന്ന ബൂളിയന്‍ സംകാരകം ഉപയോഗിക്കുക.

പ്രവ. 8.

ഏഴാം പ്രവര്‍ത്തനത്തിലെ അതേ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം "or" ഉപയോഗിക്കാതെ എഴുതുക.

ദ്വിമാന സമവാക്യത്തിന്റെ മൂലം കാണാനുള്ള ഒരു പ്രോഗ്രാം binudigitaleye എന്ന വായനക്കാരന്‍ കമന്റായിട്ടത് ചെറിയ മാറ്റങ്ങളോടെ താഴെ എടുത്തെഴുതുന്നു. IDLE ഉപയോഗിച്ച് ഇത് പല പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കുക, a, b, c എന്നിവയ്ക്ക് പല വിലകള്‍ (ന്യൂനസംഖ്യകളും ദശാംശ സംഖ്യകളും ഉള്‍പ്പടെ) കൊടുത്തു നോക്കൂ. ശരിയായ ഉത്തരം കിട്ടുന്നുണ്ടോ?

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 9.

(മിശ്ര സംഖ്യകളെ പരിചയമുള്ളവര്‍ക്ക് മാത്രം) ഈ പ്രോഗ്രാം രേഖീയ സംഖ്യകള്‍ (real numbers) മൂലങ്ങളായി വരുന്ന ദ്വിമാന സമവാക്യങ്ങളെ മാത്രമെ ശരിയായി പരിഗണിക്കുന്നുള്ളൂ; മിശ്ര സംഖ്യകള്‍ (complex numbers) മൂലങ്ങളായി വരുന്ന ദ്വിമാന സമവാക്യങ്ങളെ ഒഴുക്കന്‍മട്ടില്‍ അവഗണിച്ചിരിക്കുകയാണ്. ഈ കുറവ് പരിഹരിക്കുക; (ഉദാഹരണമായി) a = 1, b = -2, c = 2 എന്ന ഇന്‍പുട്ട് കിട്ടിയാല്‍ 1 + 1.0 i, 1 - 1.0 i എന്നീ ഉത്തരങ്ങള്‍ തരുന്ന രീതിയില്‍ പ്രോഗ്രാമിനെ മാറ്റുക.

കൂടുതല്‍ പ്രവര്‍ത്തനങ്ങള്‍

if -നെ പരിചയപ്പെട്ട നിലയ്ക്ക് ഇനി നമുക്ക് കൂടുതല്‍ രസകരങ്ങളായ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തു തുടങ്ങാം. പ്രോഗ്രാമിംഗ് പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്യുമ്പോള്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടതായ ഒരു കാര്യമുണ്ട്: വെറുതേ പ്രോഗ്രാം എഴുതിയതുകൊണ്ടു മാത്രം പ്രവര്‍ത്തനത്തിന്റെ ഫലം നമുക്ക് കിട്ടുന്നില്ല. എഴുതിയ പ്രോഗ്രാമിന് ശരിയായ എന്ത് ഇന്‍പുട്ട് കൊടുത്താലും അത് ശരിയായ ഉത്തരം തരും എന്ന് ഉറപ്പു വരുത്തണം. ഇതിനായി രണ്ടു കാര്യങ്ങള്‍ ചെയ്യണം:

1. പ്രോഗ്രാം വളരെ ശ്രദ്ധയോടെ, വിമര്‍ശനബുദ്ധ്യാ വായിച്ചുനോക്കണം. നാമെഴുതിയ പ്രോഗ്രാം എന്തുകൊണ്ട് ശരിയാണ് എന്നല്ല നോക്കേണ്ടത്, മറിച്ച് അതിലെ തെറ്റ് എവിടെയാണ് എന്നാണ്. ഇങ്ങനെ കണിശതയോടെ സ്വന്തം പ്രോഗ്രാം വായിക്കാന്‍ പഠിക്കുക എന്നത് തെറ്റില്ലാതെ പ്രോഗ്രാം എഴുതാന്‍ ഒഴിച്ചുകൂടാനാവാത്ത ഒന്നാണ്.
2. പ്രോഗ്രാമിന് പല തരത്തിലുള്ള ഇന്‍പുട്ടുകള്‍ കൊടുത്ത് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കണം. നാം തന്നെ എഴുതിയ പ്രോഗ്രാം ആയതുകൊണ്ട് അത് ശരിയായ ഉത്തരം തരുന്ന മട്ടിലുള്ള ഇന്‍പുട്ടുകള്‍ കൊടുക്കാനാണ് നമുക്ക് സ്വതവേ തോന്നുക. എന്നാല്‍ ഇങ്ങനെയല്ലാത്ത, പ്രോഗ്രാം തെറ്റിപ്പോകാന്‍ സാധ്യതയുള്ള തരം ഇന്‍പുട്ടുകളും ആലോചിച്ചെടുത്ത് അവ പ്രോഗ്രാമിന് കൊടുത്തുനോക്കണം.

ഇതു വരെ പഠിച്ച പൈത്തണ്‍ ഉപയോഗിച്ച് ചെയ്യാവുന്ന കുറച്ച് പ്രവര്‍ത്തനങ്ങള്‍ ഇതാ:

പ്രവര്‍ത്തനങ്ങള്‍

താഴെപ്പറയുന്ന തരം പ്രോഗ്രാമുകള്‍ എഴുതുക:

പ്രവ. 10.

• ഇന്‍പുട്ട്: ഒരു കുട്ടിയുടെ ഒരു വിഷയത്തിലുള്ള മാര്‍ക്ക്.
• ഔട്പുട്ട്: ആ കുട്ടിക്ക് ആ വിഷയത്തില്‍ കിട്ടിയ ഗ്രേഡ്.

മാര്‍ക്കിനെ ഗ്രേഡാക്കി മാറ്റാന്‍ നിങ്ങളുടെ സ്കൂളില്‍ (അല്ലെങ്കില്‍ പരിചയത്തില്‍) ഉപയോഗിക്കുന്ന ഏതെങ്കിലും ഒരു രീതി തെരഞ്ഞെടുക്കുക.

പ്രവ. 11.

• ഇന്‍പുട്ട്: ഒരു മാസത്തിന്റെ ക്രമസംഖ്യ : 1 മുതല്‍ 12 വരെയുള്ളത്. ഉദാ: 7
• ഔട്പുട്ട്: ആ മാസത്തിന്റെ പേര്. ഉദാ: July

പ്രവ. 12.

• ഇന്‍പുട്ട്: ദിവസങ്ങളുടെ എണ്ണം : ഒരു പൂര്‍ണ്ണസംഖ്യ. ഉദാ: 375.
• ഔട്പുട്ട്: ഒരു വര്‍ഷത്തില്‍ 365 ദിവസം എന്ന കണക്കില്‍ ഇത്രയും ദിവസമെന്നാല്‍ എത്ര വര്‍ഷം, ആഴ്ച, ദിവസം എന്നത്. ഉദാ: 375 days is 1 year, 1 week, and 3 days.

പ്രവ. 13.

• ഇന്‍പുട്ട്: ഒരു വര്‍ഷം. ഉദാ: 1967.
• ഔട്പുട്ട്: തന്നിരിക്കുന്ന വര്‍ഷം അധിവര്‍ഷമാണോ (leap year) അല്ലയോ എന്നത്. ഉദാ: 1967 is not a leap year.

ഒരു വര്‍ഷം അധിവര്‍ഷമാണോ എന്ന് കണ്ടുപിടിക്കാനുള്ള ലോജിക് ഇവിടെയുണ്ട് . ഈ പാഠം വായിച്ച ഒരാള്‍ക്ക് എളുപ്പം മനസ്സിലാകുന്ന രീതിയിലാണ് അവിടെ ഈ ലോജിക് (അല്‍ഗോരിതം എന്നതാണ് ശരിയായ വാക്ക്) കൊടുത്തിരിക്കുന്നത്. അവിടെക്കൊടുത്ത ലോജിക്കിനെ നേരിട്ടെന്നോണം പൈത്തണിലേക്ക് എടുത്തെഴുതുകയും ചെയ്യാം.

പ്രവ. 14.

• ഇന്‍പുട്ട്: ഈ വര്‍ഷത്തിലെ ഒരു ദിവസം — വര്‍ഷം, മാസം, തീയതി എന്ന രീതിയില്‍.
• ഔട്പുട്ട്: തന്നിരിക്കുന്ന ദിവസത്തിന്റെ അടുത്ത ദിവസം — വര്‍ഷം, മാസം, തീയതി എന്ന രീതിയില്‍.

പ്രവ. 15.

• ഇന്‍പുട്ട്: ഒരു ദിവസം — വര്‍ഷം, മാസം, തീയതി എന്ന രീതിയില്‍.
• ഔട്പുട്ട്: തന്നിരിക്കുന്ന ദിവസത്തിന്റെ അടുത്ത ദിവസം — വര്‍ഷം, മാസം, തീയതി എന്ന രീതിയില്‍.

പ്രവ. 16.

• ഇന്‍പുട്ട്: മൂന്നു സംഖ്യകള്‍.
• ഔട്പുട്ട്: തന്നിരിക്കുന്നതില്‍വെച്ച് ഏറ്റവും വലിയ സംഖ്യ.

പ്രവ. 17.

• ഇന്‍പുട്ട്: മൂന്നു സംഖ്യകള്‍.
• ഔട്പുട്ട്: തന്നിരിക്കുന്നതില്‍വെച്ച് ഏറ്റവും ചെറിയ സംഖ്യ.

കടപ്പാട്: കിരണം