PYTHON
>> Sunday, May 30, 2010
കംപ്യൂട്ടര്‍ പ്രോഗ്രാമിംഗ് എന്ത്/എങ്ങനെ
കംപ്യൂട്ടര്‍ എന്താണെന്ന്
നമുക്കെല്ലാം ഇന്നറിയാം -- നമ്മില്‍ ചിലരെങ്കിലും കംപ്യൂട്ടര്‍ നിത്യേനയോ
നിത്യേനയെന്നോണമോ ഉപയോഗിക്കുന്നവരാണ്. കംപ്യൂട്ടര്‍ പ്രോഗ്രാമിംഗ് പക്ഷേ
ഇന്നും കുറെയൊക്കെയെങ്കിലും നമുക്കൊരു അപരിചിതവസ്തുവാണ്. ഈ അവസ്ഥ ഇതാ
മാറാന്‍ പോകുന്നു!ലളിതമായി പറഞ്ഞാല്‍ കംപ്യൂട്ടറിന് നിര്‍ദ്ദേശങ്ങള്‍ കൊടുത്ത്, അതിനെക്കൊണ്ട് നമുക്കുവേണ്ട കാര്യങ്ങള്‍ ചെയ്യിക്കാനുള്ള ഉപാധിയാണ് കംപ്യൂട്ടര്‍ പ്രോഗ്രാമിംഗ് . കംപ്യൂട്ടര്‍ വെറും യന്ത്രമായതുകൊണ്ടും, അതിനാല്‍ത്തന്നെ അതിന് നമുക്കുള്ളതുപോലെ ബുദ്ധിയോ ചിന്താശക്തിയോ വിവേചനശേഷിയോ ഒന്നും ഇല്ലാത്തതുകൊണ്ടും, വളരെ കൃത്യമായി കാര്യങ്ങള്‍ പറഞ്ഞുകൊടുത്താലേ അത് എന്തും വേണ്ടരീതിയില്‍ ചെയ്യൂ (ഇതൊക്കെയുണ്ടെങ്കിലും ഒന്നും വേണ്ടരീതിയില്‍ ചെയ്യാത്ത മനുഷ്യരുണ്ടെന്നുള്ളത് വേറേകാര്യം). അതുകൊണ്ടുതന്നെ പ്രോഗ്രാമിംഗില്‍ പ്രധാനമായും വേണ്ടത്, നമുക്കെന്താണ് ചെയ്തുകിട്ടേണ്ടത് എന്നു കൃത്യമായി മനസ്സിലാക്കാനും, മനസ്സിലാക്കിയതിനെ ലളിതമായ ഭാഷയില്‍ കംപ്യൂട്ടറിന് പറഞ്ഞുകൊടുക്കാനും പഠിക്കുക എന്നതാണ്. ഇതത്ര ബുദ്ധിമുട്ടുള്ളതാണെന്നു തോന്നുന്നുണ്ടോ? അടിസ്ഥാന നിലവാരത്തിലുള്ള പ്രോഗ്രാമിംഗ് (നമ്മുടെ സ്കൂള്‍ സിലബസിലെ പ്രോഗ്രാമിംഗ് നിശ്ചയമായും ഇതില്‍പ്പെടും) വലിയ പ്രയാസമൊന്നുമില്ലാത്ത, ശ്രദ്ധയോടെ കാര്യങ്ങള്‍ ചെയ്യാനുള്ള ക്ഷമ മാത്രം ആവശ്യമുള്ള ഒന്നാണ്.
എന്താണ് പൈത്തണ്‍?
കംപ്യൂട്ടര്‍ പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള അനേകായിരം ഭാഷകളില്‍ ഒന്നാണ് പൈത്തണ്‍. ഇത് തുടക്കക്കാര്‍ക്ക് പഠിക്കാന്‍ എളുപ്പമുള്ള ഒരു ഭാഷയാണ്. എന്നാല്‍ കംപ്യൂട്ടര്‍ ഭാഷകളില്‍വച്ച് ഒട്ടും പിന്നിലല്ലതാനും. ഒരുദാഹരണം: ഗൂഗിളിന്റെ ആദ്യത്തെ ക്രൗളര്‍ (ഇന്റര്‍നെറ്റിലൊക്കെ പോയി പുതിയ പേജുകള്‍ വന്നിട്ടുണ്ടോ, പഴയ പേജുകള്‍ക്ക് മാറ്റങ്ങള്‍ വന്നിട്ടുണ്ടോ എന്നൊക്കെ പരതുന്ന സോഫ്ട് വെയര്‍ ) എഴുതിയത് പൈത്തണ്‍ ഉപയോഗിച്ചാണെന്ന് പറയപ്പെടുന്നു.ഈ പാഠനപദ്ധതി ആര്‍ക്കൊക്കെ ഉപയോഗപ്പെടും?
ഒരുവിധം എല്ലാവര്‍ക്കും. അഞ്ചാംക്ളാസ് മുതല്‍ മുകളിലേക്കുള്ള പ്രായക്കാര്‍ക്ക് ഇതില്‍ മിക്കഭാഗവും മനസ്സിലാക്കാന്‍ സാധിക്കേണ്ടതാണ്. അഞ്ചാംക്ളാസുകാരിയാണെങ്കില്‍ മുതിര്‍ന്ന ഒരാളുടെ സഹായവും നല്ല ഇച്ഛാശക്തിയും വേണ്ടിവന്നേക്കാമെന്നത് വേറേകാര്യം. പ്രത്യേകം എടുത്തുപറയേണ്ട ഒരു കാര്യം, ഇതുപഠിക്കാന്‍ ഗണിതശാസ്ത്ര സംബന്ധിയായ അഭിരുചിയോ താത്പര്യമോ വേണമെന്നില്ല എന്നതാണ്: "ലോജിക്കും" സാമാന്യബുദ്ധിയും മതി; പുതിയ കാര്യങ്ങള്‍ പഠിക്കാനുള്ള താത്പര്യവും. നമ്മുടെ പഠനം പ്രധാനമായും പ്രശ്നനിര്‍ദ്ധാരണത്തെ (Problem Solving) അവലംബിച്ചായിരിക്കും. ചില "തറ പറ" ബാലപാഠങ്ങള്‍ കഴിഞ്ഞാല്‍, പ്രോഗ്രാമിംഗ് പസിലുകളുടെ ഒരു ഉത്സവമായിരിക്കും അരങ്ങേറുക എന്നര്‍ത്ഥം. പ്രോഗ്രാമുകള്‍ ചെയ്തുപഠിക്കുന്നതിലൂടെ, പൈത്തണ്‍ എന്ന ഭാഷയുടെ വ്യാകരണം പഠിക്കുക എന്നതിലുപരി പ്രോഗ്രാമിംഗ് എന്ന കല നമുക്കു പഠിക്കാം.ഇതിന് എന്തൊക്കെ സജ്ജീകരണങ്ങളാണു വേണ്ടത്?
നമ്മുടെ സ്കൂളുകളില്‍ ലഭ്യമായ ലിനക്സ് സിസ്റ്റങ്ങളില്‍ പൈത്തണ്‍ പ്രോഗ്രാമിംഗ് ചെയ്തുതുടങ്ങുന്നതിന് വേണ്ടതെല്ലാം സ്വതവേതന്നെ ലഭ്യമാണ്:- പ്രോഗ്രാമുകള്‍ എഴുതാന്‍ വേണ്ടി ഏതെങ്കിലും ഒരു എഡിറ്റര്‍ . ഉദാ: gedit.
- പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിക്കാന്‍ വേണ്ടി Python എന്ന പേരില്‍ത്തന്നെ അറിയപ്പെടുന്ന സോഫ്ട് വെയര്‍ . ഇത് ടെര്‍മിനല്‍ ഉപയോഗിച്ച് പ്രവര്‍ത്തിപ്പിക്കാം.
പ്രോഗ്രാമിംഗ് കുറച്ചുകൂടി എളുപ്പമാക്കുന്ന, Integrated Development Environment (IDE) എന്നറിയപ്പെടുന്ന സോഫ്ട് വെയറുകള്‍ ലഭ്യമാണ്. ഇവയേപ്പറ്റി വഴിയേ പറയാം.
ഇനി നമുക്ക് നമ്മുടെ ആദ്യത്തെ പൈത്തണ്‍ പ്രോഗ്രാം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാം.
നമ്മുടെ ആദ്യത്തെ പൈത്തണ്‍ പ്രോഗ്രാം
പ്രോഗ്രാമുകള്‍ക്കു വേണ്ടി ഒരു ഡയറക്ടറി
നമ്മുടെ പ്രോഗ്രാമുകളൊക്കെ സൂക്ഷിച്ചുവെക്കാന്‍ നമുക്കൊരു ഫോള്‍ഡര്‍ (ഡയറക്ടറി) ഉണ്ടാക്കാം. ഒരിക്കലെഴുതിയ പ്രോഗ്രാമുകള്‍ പിന്നീടെപ്പോഴെങ്കിലും എടുത്തുനോക്കാനും മറ്റും ഇത് ഉപകാരപ്പെടും. ഈ ഡയറക്ടറിക്ക് ഇഷ്ടമുള്ള (പിന്നീട് ഓര്‍ക്കാന്‍ എളുപ്പമുള്ള) എന്തു പേരുവേണമെങ്കിലും ഇടാം. MyPrograms എന്നാണ് ഞാനിട്ട പേര്. ഈ ഡയറക്ടറി എവിടെയാണെന്നതും ഓര്‍ത്തുവയ്ക്കുക. Home അഥവാ Desktop എന്നിവിടങ്ങളിലാണെങ്കില്‍ ഓര്‍ക്കാന്‍ എളുപ്പമുണ്ട് : എവിടെവേണമെങ്കിലും ആകാം.രണ്ടു വഴികള്‍
സ്കൂള്‍ ലിനക്സ് കംപ്യൂട്ടറുകളില്‍ ഈ ഡയറക്ടറി ഉണ്ടാക്കാനുള്ള രണ്ടു വഴികള്‍ ഇനി പറയാം. രണ്ടിനും ഫലം ഒന്നുതന്നെ. ആദ്യത്തെ വഴിയാണ് കൂടുതല്‍ എളുപ്പം. രണ്ടാമത്തേതിനാണ് കൂടുതല്‍ ശക്തിയും മഹത്വവും (more general and powerful എന്നതിന്റെ സ്വതന്ത്ര പരിഭാഷ). വിശന്നിരിക്കുന്ന (നോണ്‍വെജിറ്റേറിയനായ) ഒരാള്‍ക്ക് ഒരു മീന്‍ കൊടുക്കുന്നതും മീന്‍ പിടിക്കാന്‍ പഠിപ്പിച്ചുകൊടുക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസം തന്നെ.ലിനക്സിലെ ഹോം ഡയറക്ടറി
ലിനക്സില്‍ ഓരോ ആള്‍ക്കും (user) ഒരു Home Directory ഉണ്ട്. സാധാരണ ഈ ഡയറക്ടറിയുടെ പേര് /home/username എന്നായിരിക്കും. ഇവിടെ username എന്നുള്ളത് നാം ലിനക്സിലേക്ക് log in ചെയ്യാന്‍ ഉപയോഗിക്കുന്ന പേരാണ്. എന്റെ കംപ്യൂട്ടറില്‍ എന്റെ username gphilip എന്നായതുകൊണ്ട് എന്റെ Home Directory യുടെ പേര് /home/gphilip എന്നതാണ്.എളുപ്പവഴി
നമ്മുടെ Home Directory യില്‍ MyPrograms എന്നപേരില്‍ ഒരു ഡയറക്ടറി ഉണ്ടാക്കാനുള്ള എളുപ്പ വഴി:- File Browser-ല്‍ Home Folder തുറക്കുക: Places -> Home Folder .
- അവിടെ File -> Create Folder എന്നത് തെരഞ്ഞെടുക്കുക.
- "untitled folder" എന്ന പേരില്‍ ഒരു പുതിയ ഡയറക്ടറി ഉണ്ടായി വരും. ഇതില്‍ right-click ചെയ്ത് "Rename..." എന്നത് തെരഞ്ഞെടുക്കുക. ഡയറക്ടറിക്കുള്ള പുതിയ പേരായി MyPrograms എന്നു കൊടുത്ത് Enter അമര്ത്തുക.
ടെര്‍മിനല്‍ ഉപയോഗിച്ച്
ഇതേ ഡയറക്ടറി ടെര്‍മിനല്‍ ഉപയോഗിച്ച് ഉണ്ടാക്കുന്ന വിധം:- ടെര്‍മിനല്‍ തുറക്കുക: Applications -> Accessories -> Terminal.
- ടെര്‍മിനലില്‍ ഒരു ഡോളര്‍ ചിഹ്നവും (
)അതിനുതൊട്ടുവലതുവശത്തായിമിന്നുന്ന(blinking)ഒരുസൂചകവുംകാണാം.ഈസൂചകത്തിന്cursorഎന്നാണ്പേര്. -ഉം cursor-ഉം ചേര്‍ന്നതിനെ "command prompt" അഥവാ (ചുരുക്കത്തില്‍) "prompt" എന്നു വിളിക്കുന്നു."ഇവിടെ കമാന്റ് എഴുതിത്തുടങ്ങിക്കോളൂ" എന്നാണ് prompt സൂചിപ്പിക്കുന്നത്. കമാന്റ് എഴുതി Enter അമര്‍ത്തുമ്പോള്‍ ടെര്‍മിനല്‍ കമാന്റിനെ പ്രവര്‍ത്തിപ്പിക്കും. ഇങ്ങനെ ഒരു കമാന്റ് ടെര്‍മിനലില്‍ എഴുതി Enter അമര്‍ത്തുന്നതിന് "കമാന്റ് കൊടുക്കുക" എന്നു പറയുന്നു. - ടെര്‍മിനല്‍ എപ്പോഴും ഏതെങ്കിലും ഒരു ഡയറക്ടറിയിലായിരിക്കും
നിലകൊള്ളുന്നത്. ഇതിനെ "current working directory" (ഇപ്പോഴുള്ള ഡയറക്ടറി)
എന്നു വിളിക്കുന്നു. ടെര്‍മിനല്‍ തുറക്കുമ്പോള്‍ അതു തുറന്നയാളുടെ (user)
ഹോം ഡയറക്ടറിയിലായിരിക്കും ആദ്യം ടെര്‍മിനല്‍ നിലകൊള്ളുന്നത്. ഇപ്പോഴുള്ള
ഡയറക്ടറി ഏതെന്നറിയാന്‍
pwdഎന്ന കമാന്റ് കൊടുക്കുക (Print Working Directory. Public Works Department അല്ല!). അടുത്ത വരിയില്‍ ഇപ്പോഴുള്ള ഡയറക്ടറിയുടെ പേരും (ഉദാ: /home/gphilip) അതിനടുത്ത വരിയില്‍ അടുത്ത കമാന്റ് സ്വീകരിക്കാന്‍ തയ്യാറായി prompt-ഉം വരുന്നതുകാണാം. - ഇപ്പോഴുള്ള ഡയറക്ടറിക്കുള്ളില്‍ (ടെര്‍മിനല്‍ ആദ്യമായി
തുറന്നതായതുകൊണ്ട് ഇത് നമ്മുടെ Home Directory ആണ്) MyPrograms എന്ന
പേരില്‍ പുതിയ ഒരു ഡയറക്ടറി ഉണ്ടാക്കാന്‍ നമുക്ക്
mkdirഎന്ന കമാന്റ് ഉപയോഗിക്കാം (Make Directory). പുതുതായുണ്ടാക്കേണ്ട ഡയറക്ടറിയുടെ പേരും കൂടെ ചേര്‍ത്ത്mkdir MyProgramsഎന്നാണ് കമാന്റ് കൊടുക്കേണ്ടത്. കമാന്റ് തെറ്റൊന്നുമില്ലാതെ പ്രവര്‍ത്തിച്ചാല്‍ അടുത്തവരിയില്‍ prompt തയ്യാറായി നില്‍ക്കുന്നതുകാണാം. കമാന്റ് പ്രവര്‍ത്തിപ്പിക്കുന്നതില്‍ തെറ്റെന്തെങ്കിലും സംഭവിച്ചാല്‍ അതിനെപ്പറ്റിയുളള സംക്ഷിപ്തമായ വിവരണത്തിനുശേഷം prompt വീണ്ടും കാണാം. ഇപ്പറഞ്ഞ സംക്ഷിപ്തമായ വിവരണം കാണാന്‍ കൗതുകമുണ്ടെങ്കില്‍ (ഉണ്ടെങ്കില്‍ മാത്രം) താഴെപ്പറയുന്നവ ചെയ്തുനോക്കുക:
-
mkdirകമാന്റിന് പുതുതായുണ്ടാക്കേണ്ട ഡയറക്ടറിയുടെ പേരു കൊടുക്കാതെയിരിക്കുക. അതായത്,mkdirഎന്നുമാത്രം കമാന്റ് കൊടുക്കുക. "പുതിയ ഡയറക്ടറിയുടെ പേര് എവിടെ?" എന്നര്‍ത്ഥം വരുന്ന ഒരു പരാതി കിട്ടുന്നതുകാണാം. - MyPrograms എന്ന ഡയറക്ടറി ഒരു പ്രാവശ്യം ഉണ്ടാക്കിയതിനുശേഷം വീണ്ടും
അതേപേരില്‍ അതേ സ്ഥലത്ത് ഒരു ഡയറക്ടറികൂടെ ഉണ്ടാക്കാന്‍ ശ്രമിക്കുക.
അതായത്,
mkdir MyProgramsഎന്ന കമാന്റ് വീണ്ടും കൊടുക്കുക. ടെര്‍മിനല്‍ "സാധ്യമല്ല!" എന്ന് പറയുന്നത് കാണാം.
-
- മേല്‍പ്പറഞ്ഞ കമാന്റുപയോഗിച്ച് പുതുതായുണ്ടാക്കിയ ഡയറക്ടറി ശരിക്കും അവിടെയുണ്ടോ എന്നു കാണാന്‍
lsഎന്ന കമാന്റുപയോഗിക്കാം (ലിനക്സിന്റെ പൂര്‍വികരിലൊന്നായ മള്‍ട്ടിക്സ് (1964-2000) എന്ന ഒരു മുന്‍കാല ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിലെ "list segments" എന്ന ഇതേ ആവശ്യത്തിനുള്ള കമാന്റിന്റെ ചുരുക്കപ്പേരില്‍ നിന്നാണ് ഈ പേര് വന്നത്.).lsഎന്ന കമാന്റ് കൊടുക്കുക. ഹോം ഡയറക്ടറിയിലുള്ള ഫയലുകളുടെയും ഡയറക്ടറികളുടെയും ഒരു ലിസ്റ്റ് ഉത്തരമായി കാണാം; അക്കൂട്ടത്തില്‍ MyPrograms എന്ന പുതിയ ഡയറക്ടറിയെയും.
പ്രോഗ്രാം എഴുതി സേവ് ചെയ്യുക
ഇനി നമുക്ക് നമ്മുടെ ആദ്യത്തെ പൈത്തണ്‍ പ്രോഗ്രാം എഴുതി പുതുതായുണ്ടാക്കിയ MyPrograms ഡയറക്ടറിയില്‍ സേവ് ചെയ്യാം.- gedit തുറക്കുക (Applications -> Accessories -> Text Editor).
- പുതിയ ഒരു ഫയലില്‍ താഴെപ്പറയുന്നവ എഴുതുക (കോപ്പി-പേസ്റ്റ് ചെയ്താലും മതി). ഇതാണ് നമ്മുടെ (അതിലളിതമായ) ആദ്യത്തെ പൈത്തണ്‍ പ്രോഗ്രാം :
- ഈ ഫയലിനെ hello.py എന്നപേരില്‍ മുന്‍പുണ്ടാക്കിയ ഡയറക്ടറിയില്‍ സേവ് ചെയ്യുക. ഇതിനായി gedit-ല്‍ File -> Save തെരഞ്ഞെടുത്ത് MyPrograms എന്ന ഡയറക്ടറിയുടെമേല്‍ double-click ചെയ്യുക. Name: എന്ന് കാണുന്ന വരിയില്‍ hello.py എന്നുകൊടുത്ത് Save എന്ന ബട്ടണ്‍ അമര്ത്തുക. ഫയലിന്റെ പേരെന്തായാലും കുഴപ്പമില്ല, .py എന്നവസാനിക്കണമെന്നേയുള്ളൂ -- കുത്ത് പ്രത്യേകം ശ്രദ്ധിക്കുക! നമ്മുടെ പ്രോഗ്രാം സേവ് ചെയ്തുകഴിഞ്ഞ gedit കണ്ടാല്‍ ഏകദേശം ഇങ്ങനെയിരിക്കും.
# The first program that learners write in any language is, by # convention, a program that outputs "Hello, World!". So here is # our first program in Python. print "Hello, World!" # Coming next: A Malayalam version of this program!
1
2
3
4
5
6
7
| # The first program that learners write in any language is, by# convention, a program that outputs "Hello, World!". So here is # our first program in Python.print "Hello, World!"# Coming next: A Malayalam version of this program! |
പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കാന്‍
നാമെഴുതി hello.py എന്ന പേരില്‍ സേവ് ചെയ്ത പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ച് അതിന്റെ ഫലം (output) കാണാന്‍ നമുക്ക് ടെര്‍മിനല്‍ ഉപയോഗിക്കാം. ആദ്യമായി ചെയ്യേണ്ടത് ഈ പ്രോഗ്രാം സൂക്ഷിച്ചിരിക്കുന്ന ഡയറക്ടറിയില്‍ ടെര്‍മിനല്‍ ഉപയോഗിച്ച് എത്തിപ്പറ്റുക എന്നതാണ്. ഇതിന് താഴെപ്പറയുന്നവയില്‍ ഒന്ന് ചെയ്യുക:
- എളുപ്പ(?) വഴി
- File Browser-ല്‍ Home Folder തുറക്കുക: Places -> Home Folder .
- തുറന്നുവരുന്ന ഫയലുകളുടെയും ഡയറക്ടറികളുടെയും ലിസ്റ്റില്‍ MyPrograms എന്ന ഡയറക്ടറിയുടെ പേരുള്ള ചിത്രത്തില്‍ (icon) right-click ചെയ്യുക. തെളിഞ്ഞുവരുന്ന പുതിയ ലിസ്റ്റില്‍ "Open in Terminal" എന്നത് തെരഞ്ഞെടുക്കുക. MyPrograms എന്ന ഡയറക്ടറിയില്‍ കമാന്റുകള്‍ കൊടുക്കാന്‍ സജ്ജമായി ഒരു ടെര്‍മിനല്‍ തുറന്നുവരുന്നതു കാണാം.
- ടെര്‍മിനല്‍ ഉപയോഗിച്ച്
- മുമ്പു തുറന്ന ടെര്‍മിനലില്‍ ചെല്ലുക (പുതിയ ടെര്‍മിനല്‍ തുറന്നാലും മതി).
- ഹോം ഡയറക്ടറിയിലേക്ക് മാറുക. ഇതിനായി
cdഎന്ന കമാന്റ് കൊടുക്കുക (Change Directory). ടെര്‍മിനല്‍ നിലകൊള്ളുന്ന ഡയറക്ടറി എന്തുതന്നെ ആയാലുംcdഎന്ന കമാന്റിനു ശേഷം അത് ഹോം ഡയറക്ടറിയിലേക്ക് മാറും. - ഹോം ഡയറക്ടറിക്കുള്ളിലെ MyPrograms ഡയറക്ടറിയിലേക്ക് മാറുക. ഇതിനായി
cdഎന്ന കമാന്റ് തന്നെ ഉപയോഗിക്കാം. ഹോം ഡയറക്ടറിയല്ലാത്ത ഒരു ഡയറക്ടറിയിലേക്ക് മാറാന്‍വേണ്ടിയായതുകൊണ്ട് കമാന്റിന് ഡയറക്ടറിയുടെ പേരും പറഞ്ഞുകൊടുക്കണം. അതായത്,cd MyProgramsഎന്നാണ് കമാന്റ് കൊടുക്കേണ്ടത്. ഈ കമാന്റിനുശേഷം ടെര്‍മിനല്‍ MyPrograms എന്ന ഡയറക്ടറിയിലായിരിക്കും. - (ബോണസ്) നാം എഴുതി സേവ് ചെയ്ത hello.py എന്ന ഫയല്‍ ഈ ഡയറക്ടറിയില്‍ ഉണ്ടെന്ന് കാണാന്‍
lsഎന്ന കമാന്റ് കൊടുക്കുക.
python hello.py Hello, World!
എന്നു വരുന്നതു കാണാം. ഇതാണ് ഈ ലളിതമായ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം (output). ഇനി ഇതല്ല മറ്റെന്തെങ്കിലുമാണ് കാണുന്നതെങ്കില്‍ അത് രണ്ടുകാര്യം കൊണ്ടാകാം:
- സിസ്റ്റത്തില്‍ python ഇന്സ്റ്റാള് ചെയ്തിട്ടില്ല. സ്കൂള്‍ സിസ്റ്റമാണെങ്കില്‍ ഇതാവില്ല കാരണം, മറിച്ച്:
- പ്രോഗ്രാം എടുത്തെഴുതിയതില്‍ എവിടെയോ പിഴവു പറ്റി. ഇതെവിടെയാണെന്ന് മനസ്സിലാക്കി തിരുത്തുക.
ഈ പ്രോഗ്രാമിന്റെ സമഗ്രമായ വിശദീകരണവും, ഇതിന്റെതന്നെ മലയാളം പതിപ്പും, മറ്റുകാര്യങ്ങളും അടുത്ത പാഠത്തില്‍. മേല്‍പ്പറഞ്ഞ കാര്യങ്ങള്‍ ചെയ്തുനോക്കി, പറഞ്ഞതുപോലെയൊക്കെ സംഭവിച്ചെങ്കില്‍ അതും, അതല്ല പ്രശ്നങ്ങള്‍ ഉണ്ടായെങ്കില്‍ അതും കമന്റായിടുക; കൂടെ മറ്റു സംശയങ്ങളും ചോദ്യങ്ങളും നിര്‍ദ്ദേശങ്ങളും.
തയ്യാറാക്കാന്‍ സഹായിച്ചവര്‍: നിസാര്‍ വി കെ, ഹസൈനാര്‍ മങ്കട, ശ്രീനാഥ് എച്ച്, ഹരികുമാര്‍ കെ ജി, ഹോംസ്.
നമ്മുടെ കംപ്യൂട്ടറില്‍ സൂക്ഷിച്ചുവെക്കാനും മറ്റുള്ളവര്‍ക്ക് പകര്‍ത്തി കൊടുക്കാനും പാകത്തില്‍ ഈ പാഠത്തിന്റെ പി.ഡി.എഫ് പതിപ്പ് ഇവിടെ.
പൈത്തണ്‍: പാഠം രണ്ട്
>> Wednesday, June 16, 2010
കംപ്യൂട്ടറില്‍ സംഭവിക്കുന്നതെന്തെന്നാല്‍ ...
നമ്മുടെ മാതൃഭാഷ മലയാളമാണെന്നതുപോലെ കംപ്യൂട്ടറിന്റെ "മാതൃഭാഷ" Machine Language (യന്ത്രഭാഷ) എന്ന പേരുള്ള, 0,1 എന്നീ രണ്ട് "അക്ഷരങ്ങള്‍" മാത്രമുപയോഗിച്ചെഴുതുന്ന ഒരുതരം ഭാഷയാണ്. ഈ ഭാഷ പഠിച്ച് അതുപയോഗിച്ച് കംപ്യൂട്ടറിന് നിര്‍ദ്ദേശങ്ങള്‍ കൊടുക്കുക എന്നത് സാധ്യമാണെങ്കിലും ദുഷ്കരമാണ്. പൈത്തണ്‍ പോലെയുള്ള, ഒരു മനുഷ്യഭാഷയോട് (അതായത്, ഇംഗ്ളീഷിനോട്) കുറച്ചൊക്കെ സാമ്യമുള്ള ഭാഷകള്‍ ഉപയോഗിച്ച് പ്രോഗ്രാമുകള്‍ എഴുതുക എന്നത് ഇതിനെ അപേക്ഷിച്ച് വളരെ സുകരമാണ്.
നമ്മുടെ പൈത്തണ്‍ പ്രോഗ്രാം വായിച്ചുനോക്കി നാം എഴുതിയ പൈത്തണ്‍ ഭാഷയില്‍ തെറ്റുകളെന്തെങ്കിലുമുണ്ടെങ്കില്‍ അതു പറയുകയും, തെറ്റുകളൊന്നുമില്ലെങ്കില്‍ പ്രോഗ്രാമില്‍ നിര്‍ദ്ദേശിച്ചിരിക്കുന്ന കാര്യങ്ങള്‍ നടപ്പിലാക്കുകയും ചെയ്യുന്നത് പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്റര്‍ (Python Interpreter) എന്നു വിളിക്കപ്പെടുന്ന, അനേകം ആളുകള്‍ ചേര്‍ന്ന് എഴുതിയുണ്ടാക്കിയ ഒരു പ്രോഗ്രാമാണ്. Interpreter എന്ന വാക്കിന് "അര്‍ത്ഥം വിശദമാക്കുന്നയാള്‍", "ദ്വിഭാഷി" എന്നൊക്കെ അര്‍ത്ഥം പറയാം (ഉദാ:- An interpreter of dreams, French interpreter). നാം പൈത്തണ്‍ ഭാഷയിലെഴുതിയ പ്രോഗ്രാമിനെ കംപ്യൂട്ടറിനു മനസ്സിലാകുന്ന യന്ത്രഭാഷയിലേക്ക് മൊഴിമാറ്റം ചെയ്യുക എന്നതാണല്ലോ പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്റര്‍ ചെയ്യുന്നത്? അതുകൊണ്ട് പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്റര്‍ അഥവാ പൈത്തണ്‍ ദ്വിഭാഷി എന്ന പേര് ഈ പ്രോഗ്രാമിന് തികച്ചും ചേര്‍ന്നത് തന്നെ.
ലിനക്സില്‍ പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്ററുടെ പേര് python എന്നാണ്. നാം കഴിഞ്ഞ പാഠത്തില്‍ ഉപയോഗിച്ച
python hello.py
എന്ന കമാന്റ് ചെയ്യുന്നത്, ഈ ഇന്റര്‍പ്രെറ്ററിന് നാമെഴുതിയ hello.py എന്ന്
പ്രോഗ്രാം ഇന്‍പുട്ട് ആയി കൊടുക്കുക എന്നതാണ്. python (ഇന്റര്‍പ്രെറ്റര്‍)
ആകട്ടെ, hello.py എന്ന ഈ പ്രോഗ്രാം വായിച്ച് അതില്‍ പറഞ്ഞ കാര്യങ്ങള്‍
ചെയ്യുന്നു. പൈത്തണ്‍ ഭാഷയിലെഴുതിയ ഒരു പ്രോഗ്രാം
പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍ സംഭവിക്കുന്നത്, ചുരുക്കത്തില്‍ പറഞ്ഞാല്‍
ഇത്രയുമൊക്കെയാണ്. ഇനിയുള്ള പാഠങ്ങളില്‍ പൈത്തണ്‍ ഭാഷ, പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്റര്‍ എന്നീ രണ്ടുകാര്യങ്ങളേയും "പൈത്തണ്‍" എന്ന ഒറ്റ വാക്ക് ഉപയോഗിച്ചാവും സൂചിപ്പിക്കുക. എഴുതാനും വായിക്കാനും ഇതാണ് എളുപ്പം; അര്‍ത്ഥശങ്ക ഉണ്ടാവാന്‍ തീരെ സാധ്യതയില്ലതാനും.
ആദ്യപ്രോഗ്രാം: വിശദമായ വായന.
കഴിഞ്ഞ പാഠത്തില്‍ കണ്ട ചെറിയ പൈത്തണ്‍ പ്രോഗ്രാം വിജയകരമായി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിക്കാണുമല്ലോ. ഇപ്പോള്‍ നമുക്ക് ഇതിന്റെ ഭാഗങ്ങള്‍ അടയാളപ്പെടുത്തി വിശദീകരിക്കാം.പ്രോഗ്രാം ഇവിടെ എടുത്തെഴുതുന്നു:
1
2
3
4
5
6
7
| # The first program that learners write in any language is,# by convention, a program that outputs "Hello, World!". So# here is our first program in Python.print "Hello, World!"# Coming next: A Malayalam version of this program! |
ഈ പ്രോഗ്രാമില്‍ മൂന്നുതരം വരികളാണുള്ളത്:
- # എന്ന ചിഹ്നം തുടക്കത്തില്‍ വരുന്ന വരികള്‍ പൈത്തണില്‍ # എന്ന ചിഹ്നം കമന്റുകളെ വേറിട്ടുകാണിക്കാന്‍ ഉപയോഗിക്കുന്ന മാര്‍ഗ്ഗമാണ്. പ്രോഗ്രാം വായിയ്ക്കുന്ന മറ്റു മനുഷ്യര്‍ക്കുവേണ്ടി പ്രോഗ്രാം എഴുതുന്നയാള്‍ ഉള്‍പ്പെടുത്തുന്ന കുറിപ്പുകളെയാണ് കമന്റ് എന്നു പറയുന്നത് . # എന്ന ചിഹ്നം കണ്ടാല്‍ പിന്നെ ആ വരിയില്‍ ബാക്കിയുള്ള കാര്യങ്ങളെ പൈത്തണ്‍ അവഗണിക്കും. അതായത്, "ഈ വരിയില്‍ ഇനിയുള്ള കാര്യങ്ങള്‍ അവഗണിച്ചോളൂ" എന്ന് പൈത്തണോട് പറയാനുള്ള ഉപാധിയാണ് # എന്ന ചിഹ്നം. കമന്റുകളുടെ പ്രാധാന്യത്തെപ്പറ്റി വഴിയേ പറയാം.
- ശൂന്യമായ വരികള്‍ ഒരക്ഷരവും ഇല്ലാത്ത വരികളുടെ പ്രോഗ്രാമിലെ ഉപയോഗം സാധാരണ എഴുത്തുഭാഷയിലെ ഉപയോഗം പോലെതന്നെയാണ്: വായനക്കാരന്റെ കണ്ണുകളുടെ ആയാസം കുറയ്ക്കലും, പുതിയ ഒരു കാര്യം പറഞ്ഞുതുടങ്ങുമ്പോള്‍ അതിനെ മുമ്പുപറഞ്ഞതില്‍നിന്ന് വേറിട്ടുകാണിക്കലും. ഈ രണ്ടുകാര്യങ്ങളും പൈത്തണ്‍ ഇന്റര്‍പ്രെറ്റര്‍ക്കു പ്രധാനമല്ലാത്തതുകൊണ്ട്, ഇങ്ങനെയുള്ള വരികളെ പൈത്തണ്‍ അവഗണിക്കുന്നു. ചുരുക്കത്തില്‍: ഒരക്ഷരവും ഇല്ലാത്ത ശൂന്യമായ ഒരു വരി കണ്ടാല്‍ പൈത്തണ്‍ ആ വരിയെ അവഗണിക്കുന്നു.
- print എന്ന വാക്കില്‍ തുടങ്ങുന്ന വരി ഈ പ്രോഗ്രാമില്‍ പൈത്തണ്‍ ഭാഷയിലുള്ള ഒരേ ഒരു വരി ഇതാണെന്ന് പറയാം; മറ്റുള്ളതൊക്കെ ഇംഗ്ളീഷ് തന്നെയാണല്ലോ? print എന്നുള്ളത് പ്രോഗ്രാമിന്റെ output --- പുറത്തുകാണേണ്ട പ്രവര്‍ത്തനഫലം --- പുറത്തുകാണിക്കാന്‍ ഉപയോഗിക്കുന്ന ഒരു പൈത്തണ്‍ കീവേഡ് (keyword) ആണ്. പൈത്തണില്‍ ഇരുപതോളം വാക്കുകളെ ഇങ്ങനെ keyword അഥവാ പ്രധാനവാക്ക് /പ്രത്യേകവാക്ക് എന്ന് പേരിട്ട് വേര്‍തിരിച്ചിട്ടുണ്ട്. പ്രോഗ്രാമുകളില്‍ ചില പ്രത്യേക ആവശ്യങ്ങള്‍ക്കായി ഉപയോഗിക്കുന്നതുകൊണ്ടാണ് ഇവയെ കീവേഡ് എന്നു വിളിക്കുന്നത്. ഇവയില്‍ മിക്കതിനേയും നമുക്ക് വഴിയേ പരിചയപ്പെടാം. print എന്ന കീവേഡ് ചെയ്യുന്നത്, തനിക്കുശേഷം അതേ വരിയില്‍ കാണുന്ന കാര്യങ്ങളെ ഔട്ട്പുട്ട് ചെയ്യുക എന്നതാണ്. print ഇങ്ങനെ ചെയ്തതാണ് നാം പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് ആയി കണ്ടത്.
പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതാന്‍ കീവേഡുകള്‍ ഏതൊക്കെ എന്നത് കാണാതെ പഠിക്കേണ്ട കാര്യമൊന്നുമില്ല. print എന്നത് കീവേഡ് ആണോ മറ്റെന്തെങ്കിലും ആണോ എന്ന് എനിക്ക് ഉറപ്പൊന്നുമില്ലായിരുന്നു. ഈ പാഠം എഴുതാനിരുന്നപ്പോള്‍ വായിച്ചു നോക്കി കണ്ടുപിടിച്ചതാണ്.
പ്രോഗ്രാമിന്റെ മലയാളം പതിപ്പ്
മുകളില്‍ക്കൊടുത്ത പ്രോഗ്രാമിന്റെ മലയാളത്തിലുള്ള പതിപ്പാണ് താഴെയുള്ളത്. ഇത് പ്രവര്‍ത്തിപ്പിക്കാന്‍ മുമ്പുചെയ്തതുപോലെ gedit-ല്‍ ഒരു പുതിയ ഫയല്‍ തുറന്ന്, പ്രോഗ്രാം അതിലേക്ക് പകര്‍ത്തി, ml_helloworld.py എന്ന പേരില്‍ സേവ് ചെയ്യുക. മുമ്പുപറഞ്ഞതുപോലെ ഈ പേര് എന്തുവേണമെങ്കിലുമാകാം, .py എന്ന് അവസാനിക്കണമെന്നേയുള്ളൂ. ഒരു കാര്യം പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടത്, ഫയലിന്റെ ആദ്യത്തെ വരിയില്‍ത്തന്നെ "...coding..." എന്നത് വരണം എന്നുള്ളതാണ്. പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുന്നവിധവും നേരത്തേതുപോലെതന്നെ: പ്രോഗ്രാം സേവ് ചെയ്തിരിക്കുന്ന ഡയറക്ടറിയില്‍ ടെര്‍മിനല്‍ ഉപയോഗിച്ച്python ml_helloworld.py എന്ന കമാന്റ് കൊടുക്കുക. ഈ പ്രോഗ്രാമിനെപ്പറ്റിയുള്ള വിവരണം കമന്റുകളായി പ്രോഗ്രാമില്‍ത്തന്നെ ചേര്‍ത്തിട്ടുണ്ട്. # coding=utf-8 # (ഹാവൂ! ഇനി മലയാളത്തില്‍ കമന്റുകള്‍ എഴുതാം!) # ഏറ്റവും മുകളില്‍ക്കാണുന്ന കോഡ് (coding എന്നുംമറ്റുമുള്ള ലൈന്‍) # ഇംഗ്ളീഷിതര അക്ഷരങ്ങള്‍ പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്താന്‍ വേണ്ടിയുള്ളതാണ്. ഈ # പ്രോഗ്രാമില്‍ കമെന്റിലും പിന്നെ പ്രോഗ്രാമില്‍ ഒരിടത്തും മലയാള # അക്ഷരങ്ങള്‍ ഉപയോഗിക്കാന്‍വേണ്ടിയാണ് ആ ലൈന്‍ ചേര്‍ത്തത്. # പൈത്തണ്‍ ഭാഷയില്‍ പ്രത്യേക ആവശ്യങ്ങള്‍ക്കായി ഉപയോഗിക്കുന്ന, keyword # (കീവേഡ്: പ്രത്യേകവാക്ക്/പ്രധാനവാക്ക്) എന്ന് വിളിക്കുന്ന ഇരുപതോളം # വാക്കുകളുണ്ട്. അടുത്ത കാലത്തിറങ്ങിയ പൈത്തണ്‍ മൂന്നാം പതിപ്പില്‍ ഈ # പ്രത്യേകവാക്കുകള്‍ ഒഴികെ മറ്റെല്ലാം മലയാളത്തിലോ മറ്റു ഭാഷകളിലോ # എഴുതാം; പ്രത്യേകവാക്കുകള്‍ ഇംഗ്ളീഷ് അക്ഷരങ്ങള്‍ ഉപയോഗിച്ചു മാത്രമേ # എഴുതാന്‍ കഴിയൂ. # നാം പഠനത്തിനായി തെരഞ്ഞെടുത്ത പൈത്തണ്‍ രണ്ടാം പതിപ്പില്‍ പക്ഷേ # മലയാളത്തിന്റെ ഉപയോഗം ഒരു കൗതുകം മാത്രമായേ കാണാന്‍ പറ്റൂ: # പ്രോഗ്രാമില്‍ ഒരേ ഒരു തരം കാര്യം (ഇതിന്റെ ഒരുദാഹരണം താഴത്തെ # പ്രോഗ്രാമില്‍ ഉണ്ട്) ഒഴികെ ബാക്കിയെല്ലാം ഇംഗ്ളീഷ് അക്ഷരങ്ങള്‍ ഉപയോഗിച്ചേ # ഈ പതിപ്പില്‍ എഴുതാവൂ. കമന്റുകളും ഇംഗ്ളീഷില്‍ത്തന്നെ എഴുതുന്നതാണ് # നിലവിലുള്ള രീതി. കമന്റുകള്‍ മറ്റു മനുഷ്യര്‍ക്കു വായിക്കുവാന്‍വേണ്ടി # മാത്രമുള്ളതായതുകൊണ്ട്, അതെഴുതുമ്പോള്‍ വ്യാകരണത്തെറ്റോ മറ്റോ # വന്നാലും പ്രോഗ്രാം ഭംഗിയായി ഓടിക്കൊള്ളൂം. # കമന്റ് എന്നു പറയുന്നത് ദാ ഇതുപോലെ "#" എന്നുതുടങ്ങുന്ന ലൈനുകളാണ്. ഇവ # മറ്റു മനുഷ്യര്‍ക്ക് വായിക്കുവാന്‍വേണ്ടി ഉള്ളതാണ്: പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തെ # ഇവ ഒരുവിധത്തിലും ബാധിക്കുന്നില്ല. # ഇനി പ്രോഗ്രാമിലേക്ക് : പ്രോഗ്രാമിംഗ് പഠിക്കുമ്പോള്‍ സാധാരണ ആദ്യം # എഴുതാറുള്ള "Hello, World!" പ്രോഗ്രാമിന്റെ മലയാള "ഭാഷ്യം": print "സ്വാഗതം!"
ഈസ്റ്റ്മാന്‍ കളറില്‍:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| # coding=utf-8# (ഹാവൂ! ഇനി മലയാളത്തില്‍ കമന്റുകള്‍ എഴുതാം!)# ഏറ്റവും മുകളില്‍ക്കാണുന്ന കോഡ് (coding എന്നുംമറ്റുമുള്ള ലൈന്‍)# ഇംഗ്ളീഷിതര അക്ഷരങ്ങള്‍ പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്താന്‍ വേണ്ടിയുള്ളതാണ്. ഈ# പ്രോഗ്രാമില്‍ കമെന്റിലും പിന്നെ പ്രോഗ്രാമില്‍ ഒരിടത്തും മലയാള# അക്ഷരങ്ങള്‍ ഉപയോഗിക്കാന്‍വേണ്ടിയാണ് ആ ലൈന്‍ ചേര്‍ത്തത്.# പൈത്തണ്‍ ഭാഷയില്‍ പ്രത്യേക ആവശ്യങ്ങള്‍ക്കായി ഉപയോഗിക്കുന്ന, keyword# (കീവേഡ്: പ്രത്യേകവാക്ക്/പ്രധാനവാക്ക്) എന്ന് വിളിക്കുന്ന ഇരുപതോളം# വാക്കുകളുണ്ട്. അടുത്ത കാലത്തിറങ്ങിയ പൈത്തണ്‍ മൂന്നാം പതിപ്പില്‍ ഈ# പ്രത്യേകവാക്കുകള്‍ ഒഴികെ മറ്റെല്ലാം മലയാളത്തിലോ മറ്റു ഭാഷകളിലോ# എഴുതാം; പ്രത്യേകവാക്കുകള്‍ ഇംഗ്ളീഷ് അക്ഷരങ്ങള്‍ ഉപയോഗിച്ചു മാത്രമേ# എഴുതാന്‍ കഴിയൂ.# നാം പഠനത്തിനായി തെരഞ്ഞെടുത്ത പൈത്തണ്‍ രണ്ടാം പതിപ്പില്‍ പക്ഷേ# മലയാളത്തിന്റെ ഉപയോഗം ഒരു കൗതുകം മാത്രമായേ കാണാന്‍ പറ്റൂ:# പ്രോഗ്രാമില്‍ ഒരേ ഒരു തരം കാര്യം (ഇതിന്റെ ഒരുദാഹരണം താഴത്തെ# പ്രോഗ്രാമില്‍ ഉണ്ട്) ഒഴികെ ബാക്കിയെല്ലാം ഇംഗ്ളീഷ് അക്ഷരങ്ങള്‍ ഉപയോഗിച്ചേ# ഈ പതിപ്പില്‍ എഴുതാവൂ. കമന്റുകളും ഇംഗ്ളീഷില്‍ത്തന്നെ എഴുതുന്നതാണ്# നിലവിലുള്ള രീതി. കമന്റുകള്‍ മറ്റു മനുഷ്യര്‍ക്കു വായിക്കുവാന്‍വേണ്ടി# മാത്രമുള്ളതായതുകൊണ്ട്, അതെഴുതുമ്പോള്‍ വ്യാകരണത്തെറ്റോ മറ്റോ# വന്നാലും പ്രോഗ്രാം ഭംഗിയായി ഓടിക്കൊള്ളൂം.# കമന്റ് എന്നു പറയുന്നത് ദാ ഇതുപോലെ "#" എന്നുതുടങ്ങുന്ന ലൈനുകളാണ്. ഇവ# മറ്റു മനുഷ്യര്‍ക്ക് വായിക്കുവാന്‍വേണ്ടി ഉള്ളതാണ്: പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തെ# ഇവ ഒരുവിധത്തിലും ബാധിക്കുന്നില്ല.# ഇനി പ്രോഗ്രാമിലേക്ക് : പ്രോഗ്രാമിംഗ് പഠിക്കുമ്പോള്‍ സാധാരണ ആദ്യം# എഴുതാറുള്ള "Hello, World!" പ്രോഗ്രാമിന്റെ മലയാള "ഭാഷ്യം":print "സ്വാഗതം!" |
പ്രോഗ്രാം കോപ്പി ചെയ്യാനുള്ള എളുപ്പവഴി: മൗസ് സൂചിക പ്രോഗ്രാമിന്റെ ആദ്യത്തെ വരിയില്‍ കൊണ്ടു പോകുക (പ്രോഗ്രാമില്‍ എവിടെയാണെങ്കിലും മതി). ഒരു പ്രിന്ററിന്റെ ചിത്രം ഉള്‍പ്പടെ നാലു ചെറിയ ചിത്രങ്ങള്‍ (icons) ഉള്ള ഒരു ചതുരം പ്രോഗ്രാമിന്റെ മുകളിലായി പ്രത്യക്ഷപ്പെടുന്നതുകാണാം. ഇതില്‍ രണ്ടാമത്തെ ചിത്രത്തില്‍ (രണ്ടു കടലാസുകള്‍ ഒന്നിനുമീതെ ഒന്നായി വച്ചിരിക്കുന്നതിന്റെ ചിത്രം) അമര്ത്തുക. പ്രോഗ്രാമിന്റെ ശുദ്ധരൂപം (ലൈന്‍ നമ്പറുകളും വര്‍ണ്ണങ്ങളും മറ്റുമില്ലാത്തത്) കോപ്പി ചെയ്തു കഴിഞ്ഞു. ഇനി എഡിറ്ററില്‍ (ഉദാ: gedit) ഇതു പേസ്റ്റു ചെയ്യാം. പേസ്റ്റു ചെയ്തു നോക്കൂ! ഇതേപോലെ കാണുന്ന ഏതു പ്രോഗ്രാമും ഈ രീതിയില് കോപ്പി ചെയ്യാം.
ഈ പ്രോഗ്രാമില്‍ കമന്റുകളിലല്ലാതെ മലയാളം വരുന്നത് print എന്നതിനുശേഷം വരുന്ന "സ്വാഗതം!" എന്ന string-ല്‍ മാത്രമാണല്ലോ. നാം പഠനത്തിനായി തെരഞ്ഞെടുത്ത പൈത്തണ്‍ രണ്ടാം പതിപ്പില്‍ ഈ രണ്ടിടങ്ങളില്‍ മാത്രമേ ഇംഗ്ലീഷിതര അക്ഷരങ്ങള്‍ പ്രോഗ്രാമില്‍ ഉപയോഗിക്കാന്‍ പറ്റൂ. ഏറ്റവും പുതിയതായ മൂന്നാം പതിപ്പില്‍ പ്രധാനവാക്കുകള്‍ ഒഴികെയുള്ളത് മലയാളത്തില്‍ (മറ്റു ഭാഷകളിലും) എഴുതാം. മുകളില്‍ മലയാളത്തില്‍ പ്രോഗ്രാമെഴുതിയത് ഒരു കൗതുകത്തിന് മാത്രം. മുമ്പോട്ടുള്ള പാഠങ്ങളിലെ പ്രോഗ്രാമുകള്‍ ഇംഗ്ളീഷില്‍ത്തന്നെ ആയിരിക്കും എഴുതുക: താത്പര്യമുള്ളവര്‍ക്ക് പ്രോഗ്രാമിനെ മലയാളീകരിക്കാനുള്ള വിദ്യ മനസ്സിലായല്ലോ.
കൂട്ടലും കുറയ്ക്കലും (മറ്റു ക്രിയകളും)
പൈത്തണ്‍ ഉപയോഗിച്ച് ഗണിതക്രിയകള്‍ ചെയ്യുന്നതെങ്ങനെ എന്നു നോക്കാം. കൂട്ടല്‍, കുറയ്ക്കല്‍ എന്നിവയ്ക്ക് നാം സാധാരണ ഉപയോഗിച്ചുവരുന്ന +, - എന്നീ ചിഹ്നങ്ങളാണ് പൈത്തണിലും ഉപയോഗിക്കുന്നത്. ഗുണനത്തിന് പക്ഷേ x അല്ല, * ആണ് ഉപയോഗിക്കേണ്ടത്. ഹരണത്തിന് / ഉം ഘാതത്തിന് (കൃതിക്ക്) ** ഉം ശിഷ്ടം കാണാന്‍ % ഉമാണ് ചിഹ്നങ്ങള്‍. ക്രിയകള്‍ ചെയ്യേണ്ടുന്ന ക്രമം വ്യക്തമാക്കാന്‍ (വായിച്ചു മനസ്സിലാക്കാനുള്ള എളുപ്പത്തിനും) ഒരേ ഒരുതരം ബ്രായ്ക്കറ്റേ ഉപയോഗിക്കാവൂ: () മാത്രം. ഈ ആവശ്യത്തിന് നാം സാധാരണ ഉപയോഗിക്കുന്ന {}, [] എന്നീ തരം ബ്രായ്ക്കറ്റുകള്‍ക്ക് പൈത്തണില്‍ മറ്റ് അര്‍ത്ഥങ്ങളുള്ളതുകൊണ്ട് ഇവ ഗണിതക്രിയകളില്‍ ഈ ആവശ്യത്തിന് ഉപയോഗിച്ചുകൂടാ.
പ്രോഗ്രാമില്‍ ഗണിതക്രിയകള്‍ ചെയ്യുന്നതെങ്ങനെ എന്നുകാണാന്‍ താഴെയുള്ള പ്രോഗ്രാം നോക്കുക. വായിക്കുന്നയാളെ സഹായിക്കാനായി പ്രോഗ്രാമില്‍ യഥേഷ്ടം കമന്റുകള്‍ കൊടുത്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക; പ്രോഗ്രാം വ്യക്തമായി മനസ്സിലാക്കാന്‍ സഹായിക്കുന്ന കമന്റുകള്‍ നല്ല പ്രോഗ്രാമിന്റെ ലക്ഷണമാണ്.
# We can do simple numerical calculations easily with # Python. # # Use: # + for addition # - for subtraction # * for multiplication # / for division # ** for exponentiation # % for remainder after division # Examples: print 5 + 3 print 5 - 3 print 5 * 3 print 5 / 2 # Since the operands are integers, the result # is also an integer print 5 ** 3 print 5 % 3 # We can make the output easier to understand by printing # out the expression along with the result. Here is how to # use the comma (,) to do this: print "5 + 3 = ", 5 + 3 print "5 ** 3 = ", 5 ** 3 # To get fractional values in the result, include a decimal # point in at least one operand: print "5 / 2 = ", 5.0 / 2 print "5 / 3 = ", 5 / 3.0 print "Here is one approximation to Pi: ", 22.0/7 print "And here is a better approximation : ", 355/113.0 # We can do more complicated calculations as well. Notice # how a long line is split across two lines using the # backslash ( \ ): print "Here is a big negative integer: ",\ (17 ** 21 + 5)*(36 % 11 + 76 * 43)-(712 + 5243 ** 32) # Try doing different calculations and see what you get!
കളര്‍ പതിപ്പ്:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
| # We can do simple numerical calculations easily with# Python.# # Use:# + for addition# - for subtraction# * for multiplication# / for division# ** for exponentiation# % for remainder after division# Examples:print 5 + 3 print 5 - 3 print 5 * 3print 5 / 2 # Since the operands are integers, the result # is also an integerprint 5 ** 3print 5 % 3# We can make the output easier to understand by printing# out the expression along with the result. Here is how to# use the comma (,) to do this:print "5 + 3 = ", 5 + 3print "5 ** 3 = ", 5 ** 3# To get fractional values in the result, include a decimal# point in at least one operand:print "5 / 2 = ", 5.0 / 2print "5 / 3 = ", 5 / 3.0print "Here is one approximation to Pi: ", 22.0/7print "And here is a better approximation : ", 355/113.0# We can do more complicated calculations as well. Notice# how a long line is split across two lines using the# backslash ( \ ):print "Here is a big negative integer: ",\ (17 ** 21 + 5)*(36 % 11 + 76 * 43)-(712 + 5243 ** 32)# Try doing different calculations and see what you get! |
ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കേണ്ടതെങ്ങനെ എന്ന് നമുക്കറിയാം: ഒന്നാം പാഠത്തില്‍ ചെയ്തതുപോലെ ഒരു ഫയലില്‍ (ഉദാ: calc.py) പ്രോഗ്രാം എഴുതുക (കോപ്പി-പേസ്റ്റ് ചെയ്താലും മതി), അതുകഴിഞ്ഞ് ടെര്‍മിനലില്‍ ഫയല്‍ സൂക്ഷിച്ചിരിക്കുന്ന ഡയറക്ടറിയില്‍ ചെന്ന്
python calc.py എന്ന കമാന്റ് കൊടുക്കുക. ഈ പ്രോഗ്രാമില്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങള്‍:
- ഹരണക്രിയയില്‍ ഉള്‍പ്പെട്ടിരിക്കുന്ന രണ്ടു സംഖ്യകളൂം ദശാംശ ചിഹ്നം ഇല്ലാത്തവയാണെങ്കില് ഉത്തരവും ദശാംശ ചിഹ്നം ഇല്ലാതെ ശരിക്കുള്ള ഉത്തരത്തിന്റെ പൂര്‍ണ്ണസംഖ്യാഭാഗം മാത്രമായിരിക്കും. കൂടുതല്‍ കൃത്യമായ ഉത്തരം കിട്ടാന്‍ ഒരു സംഖ്യയിലെങ്കിലും ഒരു ദശാംശ ചിഹ്നം ഇടുക.
-
printഉപയോഗിച്ച് ഒന്നിലധികം കാര്യങ്ങള്‍ കാണിക്കാന്‍ കോമ ഉപയോഗിക്കുക. print "5 + 3 = ", 5 + 3എന്നതിലെ string-നെ അതേപടിയും, string അല്ലാത്ത 5 + 3 എന്നതിന്റെ മൂല്യം കണ്ടുപിടിച്ച് അതും output ആയി കിട്ടുന്നത് ശ്രദ്ധിക്കുക.- വായിക്കാനുള്ള സൗകര്യത്തിനായി ദൈര്‍ഘ്യമേറിയ ഒരു വരിയെ backslash (\) ഉപയോഗിച്ച് രണ്ടായി മുറിച്ച് എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ ചിഹ്നമില്ലാതെ ഈ വരിയെ രണ്ടായി മുറിച്ചാല്‍ എന്തു സംഭവിക്കും? പരീക്ഷിച്ചുനോക്കുക!
പ്രോഗ്രാമിംഗ് പഠിക്കാന്‍ വേണ്ട ഒരു ഗുണം പരീക്ഷണങ്ങള്‍ നടത്തിനോക്കാനുള്ള താത്പര്യ്മാണ്: സ്വന്തമായി പലതരം ക്രിയകള്‍ പൈത്തണ്‍ ഉപയോഗിച്ച് ചെയ്തുനോക്കുക. നിങ്ങള്‍ പ്രതീക്ഷിക്കുന്ന ഉത്തരങ്ങള്‍തന്നെയാണോ കിട്ടുന്നത്? ഉദാഹരണത്തിന്: നിങ്ങള്‍ കൊടുത്ത ക്രിയയില്‍ പൂജ്യം കൊണ്ടുള്ള ഹരണം വേണ്ടിവന്നാല്‍ എന്തു സംഭവിക്കും? ഏതെങ്കിലും ക്രിയയ്ക്ക് മറുപടിയായി പൈത്തണ്‍ പരാതി പറഞ്ഞാല്‍ (error message) അതെന്തുകൊണ്ടാണെന്ന് മനസ്സിലാക്കാന്‍ ശ്രമിക്കുക. മനസ്സിലായില്ലെങ്കില്‍ കൊടുത്ത ക്രിയയും കിട്ടിയ പരാതിയും ഇവിടെ പറയുക: നമുക്കു ചര്‍ച്ച ചെയ്യാം.
ഗണിതത്തില്‍ താത്പര്യമുള്ളവര്‍ക്കായി ഒരു പൈത്തണ്‍ പസില്‍ (അല്ലാത്തവര്‍ക്കും ശ്രമിക്കാം!) : ഈ പാഠത്തില്‍ പരിചയപ്പെട്ട പൈത്തണ്‍ മാത്രമുപയോഗിച്ച് ഒരു സംഖ്യയുടെ വര്‍ഗമൂലം എങ്ങനെ കാണാം? ഉദാഹരണത്തിന്, നാലിന്റെ വര്‍ഗമൂലം രണ്ടാണെന്ന് നമുക്കറിയാം. ഇത് പൈത്തണെക്കൊണ്ട് എങ്ങനെ പറയിപ്പിക്കും? രണ്ടിന്റെ (ഏകദേശ) വര്‍ഗമൂലം കാണാനോ? മൂന്നാം മൂലമാണെങ്കിലോ?
അടുത്ത പാഠത്തില്‍: പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ അനായാസം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനുള്ള പുതിയ രണ്ടു വഴികള്‍.
പൈത്തണ്‍: പാഠം മൂന്ന്
>> Monday, June 28, 2010
ആമുഖം
കഴിഞ്ഞ രണ്ടു പാഠങ്ങളിലായി കണ്ട ചെറിയ പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിക്കാണുമല്ലോ. ഒരു എഡിറ്റര്‍ (ഉദാ: gedit) ഉപയോഗിച്ച് പ്രോഗ്രാം ഒരു ഫയലില്‍ എഴുതി സൂക്ഷിച്ച്, ടെര്‍മിനലില്‍
python filename എന്ന
കമാന്റുപയോഗിച്ച് പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ് ഈ
പ്രോഗ്രാമുകള്‍ക്ക് നാമവലംബിച്ച രീതി. ഇത് തികച്ചും ശരിയായ
രീതിതന്നെയാണെങ്കിലും ഇതിന് ഒരു പോരായ്മയുണ്ട്. ഗണിതക്രിയകളുടെ പ്രോഗ്രാം
ഉപയോഗിച്ച് പരീക്ഷണങ്ങള്‍ നടത്തുമ്പോഴാണ് ഈ കുറവ് നമുക്ക് ശരിക്കു
ബോധ്യപ്പെടുക. ഇതെന്താണെന്നുവച്ചാല്‍, പുതിയ ഓരോ കാര്യം
പരീക്ഷിച്ചുനോക്കാനും നാം രണ്ടു കാര്യങ്ങള്‍ ചെയ്യണം. ഉദാഹരണത്തിന്, 2 ** 1/2 എന്നെഴുതിയാല്‍ രണ്ടിന്റെ വര്‍ഗമൂലം കിട്ടുമോ എന്നറിയാന്‍ താഴെപ്പറയുന്ന കാര്യങ്ങള്‍ ചെയ്യണം:- gedit-ല്‍
print "The square root of 2 is ", 2 ** 1/2എന്ന വരി പ്രോഗ്രാമില്‍ ചേര്‍ത്ത് ഫയല്‍ സേവ് ചെയ്യുക. - ടെര്‍മിനലിലേക്ക് മാറി
python calc.pyഎന്ന കമാന്റ് കൊടുക്കുക.
2 ** (1/2)
എന്നുചെയ്താല്‍ ശരിയുത്തരം കിട്ടണം. ഇതുപരീക്ഷിച്ചുനോക്കാന്‍ നാം
മേല്‍പ്പറഞ്ഞ രണ്ടു കാര്യങ്ങള്‍ --- ഫയലില്‍ നമുക്കുവേണ്ട മാറ്റങ്ങള്‍
വരുത്തി സേവ് ചെയ്യുക, ടെര്‍മിനലില്‍ പൈത്തണ്‍ ദ്വിഭാഷിയെ ഫയല്‍
ഏല്‍പ്പിക്കുക --- വീണ്ടും ചെയ്യണം. ഇത്തവണയും ഉത്തരം തെറ്റാണെങ്കില്‍
ഇനിയൊരു മാറ്റം വരുത്താനും ഇതേപോലെ രണ്ടുകാര്യങ്ങള്‍ ചെയ്യണം. ഇത് വലിയ
ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലെങ്കിലും ചെറിയ ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്. ഒരു
ദിവസം നൂറുകണക്കിനു തവണ ഇതു ചെയ്യേണ്ടി വരുമ്പോള്‍ (പ്രോഗ്രാമിംഗ് ജോലിക്കോ
ഹോബിയായോ ചെയ്യുമ്പോള്‍ ഇത് ഒട്ടും വിരളമല്ല) ഈ ചെറിയ ബുദ്ധിമുട്ടൊരു വലിയ
ബുദ്ധിമുട്ടാകും. ഈ ബുദ്ധിമുട്ട് ഒഴിവാക്കാനുള്ള ഒരു ഉപായമാണ് "പൈത്തണ്‍
ഷെല്‍".പൈത്തണ്‍ ദ്വിഭാഷിയുടെ മറ്റൊരു മുഖം
പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിക്കാന്‍ നാം ഇതുവരെ ചെയ്തത് പ്രോഗ്രാം ഒരു ഫയലിലെഴുതി ആ ഫയല്‍ പൈത്തണ്‍ ദ്വിഭാഷിക്ക് കൈമാറുക എന്നതാണല്ലോ. പൈത്തണ്‍ ദ്വിഭാഷിയുമായി സംവദിക്കാന്‍ മറ്റൊരു രീതികൂടി നിലവിലുണ്ട്. ഫയല്‍ ഉപയോഗിച്ചുള്ള രീതിയെക്കാള്‍ ജീവത്തായ, ചുറുചുറുക്കുള്ള രീതിയാണിത്. ഇവിടെ നാം ചോദിക്കുന്ന ചോദ്യത്തിന് പൈത്തണ്‍ ഉടനടി ഉത്തരം തരും; അടുത്ത ചോദ്യം കേ‌ള്‍ക്കാന്‍ തയ്യാറായി നില്‍ക്കുകയും ചെയ്യും. പൈത്തണുമായി ഒരു സല്ലാപം എന്നുവേണമെങ്കില്‍ ഈ രീതിയെ വിശേഷിപ്പിക്കാം. ചെറിയ ചോദ്യങ്ങള്‍ക്ക് (ഉദാ:
2 ** (1/2) എന്നതിന്റെ വിലയെത്ര)
പെട്ടെന്ന് ഉത്തരം കിട്ടും എന്നതാണ് ഈ രീതിയുടെ ഒരു പ്രധാന ഗുണം.
പ്രോഗ്രാം എഴുതുമ്പോള്‍ ഉണ്ടാകുന്ന ചെറിയ സംശയങ്ങള്‍ പെട്ടെന്ന്
തീര്‍ക്കാനും, താരതമ്യേന വലുതായ ഒരു പ്രോഗ്രാമെഴുതുമ്പോള്‍ ചെറിയ ചെറിയ
പ്രോഗ്രാം "കഷണങ്ങള്‍" ശരിയാണോ എന്ന് പരീക്ഷിച്ചുനോക്കാനും ഈ രീതി വളരെ
ഫലവത്താണ്. പൈത്തണുമായി സല്ലപിക്കാന്‍ ചെയ്യേണ്ടത് ഇത്രമാത്രം: ടെര്‍മിനല്‍ തുറന്ന്
python എന്ന കമാന്റ് കൊടുക്കുക. ഇതിനുമുമ്പ് ചെയ്തതില്‍നിന്ന് വ്യത്യസ്തമായി ഫയലിന്റെ പേര് കൊടുത്തിട്ടില്ല
എന്നത് ശ്രദ്ധിക്കുക.താഴെക്കാണുന്നതുപോലെ >>> എന്ന ഒരു
പ്രോംപ്റ്റ് (കമാന്റുകള്‍ കൊടുക്കാനുള്ള സൂചകം) തുറന്നുവരുന്നതുകാണാം.
ഇതാണ് പൈത്തണ്‍ ഷെല്‍ (Python shell):$ python 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. >>>
>>> എന്നു കാണുന്നിടത്ത് പൈത്തണ്‍ ഭാഷയിലുള്ള പ്രോഗ്രാം ശകലങ്ങള്‍ കൊടുക്കാം. Enter അമര്‍ത്തിയാല്‍ ഉടനടി ഉത്തരവും കിട്ടും. ഉദാഹരണത്തിന്, കഴിഞ്ഞ പാഠത്തില്‍ക്കണ്ട ചില ക്രിയകള്‍ ഷെല്‍ ഉപയോഗിച്ച് ചെയ്യുമ്പോള്‍:
$ python 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. >>> 5 + 3 8 >>> 5 - 3 2 >>> 5 * 3 15 >>> 5 / 2 2 >>> 5 ** 3 125 >>> print 5 ** 3 125 >>> print "5 + 3 = ", 5 + 3 5 + 3 = 8 >>> 5 / 2.0 2.5 >>> 355 / 113.0 3.1415929203539825 >>> quit() $
ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങള്‍:
- ഫയലില്‍ പ്രോഗ്രാമെഴുതിയതില്‍നിന്ന് വ്യത്യസ്തമായി,
- ഷെല്ലില്‍ ഔട്പുട്ട് കാണാന്‍
printഎന്ന് പറയേണ്ട കാര്യം മിക്കയിടത്തുമില്ല. ഒരു പൈത്തണ്‍ ശകലം കൊടുത്താല്‍ അതിന്റെ വില (അത് പ്രവര്‍ത്തിപ്പിച്ചുകിട്ടുന്ന ഫലം) അടുത്ത വരിയില്‍ തനിയെ വരും. - ഷെല്ലിലെഴുതിയ പ്രോഗ്രാം സ്ഥായിയല്ല; ഒരു ഫയലിലും അത് തനിയെ സേവ് ചെയ്യപ്പെടുന്നില്ല.വേണമെങ്കില്‍ നമുക്ക് എഡിറ്ററിലേക്ക് കോപ്പി-പേസ്റ്റ് ചെയ്ത് സൂക്ഷിക്കാം എന്നുമാത്രം.
- ഷെല്ലില്‍ ഔട്പുട്ട് കാണാന്‍
- ഷെല്ലില്‍നിന്ന് പുറത്തുകടക്കാന്‍
quit()എന്ന് ഒരു പുതിയ വരിയില്‍ എഴുതി Enter അമര്ത്തുക.
സമഗ്ര പൈത്തണ്‍ പ്രോഗ്രാം വികസന പദ്ധതി
പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനുള്ള രണ്ടു വഴികള്‍ നാം കണ്ടു: ഫയല്‍/ടെര്‍മിനല്‍ എന്നിവ ഉപയോഗിക്കുന്ന രീതിയും ഷെല്‍ ഉപയോഗിക്കുന്ന രീതിയും. ഇനി ഇതു രണ്ടും ചേര്‍ന്ന, പ്രോഗ്രാം എഴുതാനും പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനും വളരെ എളുപ്പമുള്ള, പ്രോഗ്രാമിന്റെ സമഗ്ര വികസനത്തിന് സഹായകമായ ഒരു സോഫ്ട് വെയറിനെ പരിചയപ്പെടാം. IDLE എന്നുപേരുള്ള ഈ സോഫ്ട് വെയര്‍ തുടക്കക്കാര്‍ക്ക് പൈത്തണ്‍ പഠിക്കാന്‍ വിശേഷിച്ചും നല്ലതാണെന്ന് പൈത്തണ്‍ ഭാഷയുടെ ഔദ്യോഗിക വെബ്സൈറ്റായ python.org ശുപാര്‍ശ ചെയ്യുന്നു. IDLE വിന്‍ഡോസിലും ലിനക്സിലും ലഭ്യമാണ്. ഫയല്‍/ടെര്‍മിനല്‍ രീതിയും പൈത്തണ്‍ ഷെല്ലും കണ്ടുകഴിഞ്ഞ ഒരാള്‍ക്ക് മറ്റൊരാളുടെ സഹായമൊന്നുമില്ലാതെതന്നെ IDLE അനായാസം ഉപയോഗിച്ചുതുടങ്ങാം. എന്നിരുന്നാലും IDLE ഉപയോഗിച്ച് പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതുന്ന രീതി നമുക്ക് വിശദമായിത്തന്നെ പഠിക്കാം. ഏതു പൈത്തണ്‍ പ്രോഗ്രാമും ഫയല്‍/ടെര്‍മിനല്‍ രീതിയില് എഴുതി പ്രവര്‍ത്തിപ്പിക്കാമെങ്കിലും, മുമ്പോട്ടുള്ള പഠനത്തില്‍ പ്രോഗ്രാമുകള്‍ ചെയ്തുനോക്കാന്‍ IDLE ഉപയോഗിക്കുന്നതാവും ഏറ്റവും എളുപ്പം. IDLE ഉപയോഗിക്കാന്‍ പഠിക്കുക എന്നത് വളരെ എളുപ്പമാണുതാനും. പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള സര്‍വവിധ സഹായങ്ങളും ഒരുമിച്ച് നല്‍കുന്ന സോഫ്ട് വെയറുകള്‍ Integrated Development Environment (IDE) എന്ന പേരിലാണ് അറിയപ്പെടുന്നത്. "സമഗ്ര വികസന സാഹചര്യം" എന്നോ മറ്റോ ഇതിനെ പരിഭാഷപ്പെടുത്താം. IDLE (Integrated DeveLopment Environment എന്നതിന്റെ വിചിത്രമായ ചുരുക്കെഴുത്ത്) എന്നത് പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ക്കുള്ള ഒരു IDE ആണ്.IDLE ഇന്സ്റ്റാള് ചെയ്യുന്ന വിധം
വിന്‍ഡോസില്‍
വിന്‍ഡോസില്‍ പൈത്തണ്‍ ഇന്സ്റ്റാള് ചെയ്യുമ്പോള്‍ കൂടെ IDLE-ഉം തനിയെ ഇന്സ്റ്റാള് ആവും (വിന്‍ഡോസ് ഇന്‍സ്റ്റാളര്‍ ഇവിടെയുണ്ട്. അവിടെ സൂചിപ്പിക്കുന്നതുപോലെ 2.6.5-ആം പതിപ്പ് എടുക്കുന്നതാവും നല്ലത്.).ലിനക്സില്‍
- സ്കൂള്‍ ലിനക്സില്‍:
- ഡൗണ്‍ലോഡ് ചെയ്ത ഫയല്‍ GDebi (3.8-ല്‍ Gdeb) ഉപയോഗിച്ച് തുറക്കുക. ഇതിനായി ഫയലില്‍ റൈറ്റ്-ക്ളിക്ക് ചെയ്ത് "Open with GDebi package installer" (3.8-ല്‍ "Open with GDeb package installer")എന്നത് തെരഞ്ഞെടുക്കുക.
- GDebi തുറന്ന് കുറച്ചുകഴിഞ്ഞ് "Install package" എന്ന ബട്ടണ്‍ തെളിഞ്ഞുവരുമ്പോള്‍ അതമര്‍ത്തുക, തുടര്‍ന്നുള്ള നിര്‍ദ്ദേശങ്ങള്‍ അനുസരിക്കുക. ("Install" എന്നതിനുപകരം "Reinstall" എന്നാണ് കാണുന്നതെങ്കില്‍ അതിനര്‍ത്ഥം IDLE നേരത്തേതന്നെ ഇന്സ്റ്റാള് ചെയ്തിട്ടുണ്ട് എന്നാണ്; അങ്ങനെയാണെങ്കില്‍ വീണ്ടും ഇന്സ്റ്റാള് ചെയ്യേണ്ട കാര്യമില്ല, GDebi അടയ്കാം.)
- ഉബുണ്ടുവില്‍ (ഇന്റര്‍നെറ്റ് കണക്ഷന്‍ ഉണ്ടായിരിക്കണം): ടെര്‍മിനല്‍ തുറന്ന്
sudo apt-get install idleഎന്ന കമാന്റ് കൊടുക്കുക. തുടര്‍ന്നുള്ള നിര്‍ദ്ദേശങ്ങള്‍ അനുസരിക്കുക. "[Y/n]?" എന്ന് (Yes/No?) ചോദിക്കുന്നിടത്ത് "Y" എന്ന് ഉത്തരം കൊടുത്ത് Enter അമര്ത്തുക. (ചില സിസ്റ്റങ്ങളില്‍ കമാന്റില്‍ അവസാനം കണ്ടidleഎന്നതിനുപകരംidle-python2.6എന്ന് കൊടുക്കേണ്ടി വന്നേക്കാം.)
IDLE ഉപയോഗിക്കുന്നതെങ്ങനെ?
ഇന്സ്റ്റാള് ചെയ്തുകഴിഞ്ഞ് IDLE തുറക്കാന്‍ ചെയ്യേണ്ടത്:- വിന്‍ഡോസില്‍: All Programs -> Python 2.6 -> Python IDLE
- ലിനക്സില്‍: Applications -> Programming -> IDLE
calc.py എന്ന പ്രോഗ്രാം ഈ എഡിറ്ററിലൊന്ന് തുറന്നുനോക്കാം. ഇതിനായി ചെയ്യേണ്ടത്:
- IDLE-ല്‍ File-> Open എന്നത് തെരഞ്ഞെടുക്കുക. (ഇതിനുള്ള എളുപ്പവഴി: Ctrl-O. അതായത് Control, O എന്നീ കീകള്‌ ഒരുമിച്ചമര്‍ത്തുക)
calc.pyഎന്ന ഫയല്‍ സൂക്ഷിച്ചുവെച്ചMyProgramsഎന്ന ഡയറക്ടറിയില്‍ച്ചെന്ന് ആ ഫയല്‍ തെരഞ്ഞെടുത്ത് Open അമര്ത്തുക . ഈ ഫയല്‍ ഒരു എഡിറ്ററില്‍ തുറന്നുവരുന്നതുകാണാം.
ഒരു ശരാശരി പ്രോഗ്രാം
ഹൈസ്കൂള്‍ കുട്ടികള്‍ക്കായി ഒരു ക്യാമ്പ് നടത്തുന്നു എന്നു കരുതുക. ജില്ലയിലെ പല സ്കൂളുകളില്‍നിന്നുള്ള കുട്ടികള്‍ ക്യാമ്പില്‍ പങ്കെടുക്കുന്നു. ക്യാമ്പില്‍ വന്നിട്ടുള്ള കുട്ടികളുടെ ശരാശരി പ്രായം കണ്ടുപിടിക്കാനുള്ള ലളിതമായ ഒരു പ്രോഗ്രാം നമുക്കെഴുതാം. പ്രോഗ്രാമിലേക്ക് ഇന്‍പുട്ട് കൊടുക്കുന്നവിധം, ചരങ്ങളുടെ (variables) പ്രോഗ്രാമിലെ ഉപയോഗം എന്നിവ ഇതിലൂടെ നമുക്ക് പഠിക്കാം. ഈ പ്രോഗ്രാമിലേക്ക് ഇന്‍പുട്ട് ആയി കൊടുക്കേണ്ടത് ഓരോ പ്രായത്തിലുമുള്ള എത്ര കുട്ടികള്‍ വീതം ക്യാമ്പില്‍ വന്നിട്ടുണ്ട് എന്നതാണ്. ഹൈസ്കൂള്‍ കുട്ടികളായതിനാല്‍ പ്രായം പന്ത്രണ്ടിനും പതിനാറിനുമിടയ്ക്കായിരിക്കും എന്ന് (മിക്കവാറും എല്ലാവരും എങ്ങനെയെങ്കിലുമൊക്കെ പാസായിപ്പോകുന്ന ഇക്കാലത്തെങ്കിലും) ന്യായമായും കരുതാം. പ്രോഗ്രാം താഴെ കൊടുക്കുന്നു. (കഴിയുമെങ്കില്‍ IDLE ഉപയോഗിച്ച്) പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. സംശയങ്ങളും പ്രശ്നങ്ങളും കമന്റിലൂടെ അറിയിക്കുക. നിങ്ങള്‍ ചോദിക്കുന്ന സംശയങ്ങള്‍ക്കുള്ള മറുപടികള്‍ കൂടി ഉള്‍‍പ്പെടുത്തി പ്രോഗ്രാമിനെപ്പറ്റിയുള്ള വിശദീകരണം അടുത്ത പാഠത്തില്‍.# This program calculates the average age of a group of students # whose ages range from twelve to sixteen. The program takes as # input the numbers of students of each age and outputs the # average. # # The goal of this program is to show how to read input into the # program, and to introduce the use of variables. num_12 = input("How many 12 year old students in the group? ") num_13 = input("How many 13 year old students in the group? ") num_14 = input("How many 14 year old students in the group? ") num_15 = input("How many 15 year old students in the group? ") num_16 = input("How many 16 year old students in the group? ") total_num = num_12 + num_13 + num_14 + num_15 + num_16 total_age = (12.0 * num_12) + (13 * num_13) + (14 * num_14) + \ (15 * num_15) + (16 * num_16) average = total_age/total_num print "The average age of all the students is ", average
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| # This program calculates the average age of a group of students# whose ages range from twelve to sixteen. The program takes as# input the numbers of students of each age and outputs the# average.# # The goal of this program is to show how to read input into the# program, and to introduce the use of variables.num_12 = input("How many 12 year old students in the group? ")num_13 = input("How many 13 year old students in the group? ")num_14 = input("How many 14 year old students in the group? ")num_15 = input("How many 15 year old students in the group? ")num_16 = input("How many 16 year old students in the group? ")total_num = num_12 + num_13 + num_14 + num_15 + num_16total_age = (12.0 * num_12) + (13 * num_13) + (14 * num_14) + \ (15 * num_15) + (16 * num_16)average = total_age/total_numprint "The average age of all the students is ", average |
- IDLE തുറക്കുക (നേരത്തേതന്നെ തുറന്നുവച്ചിട്ടുണ്ടെങ്കില്‍ അത് ഉപയോഗിച്ചാല്‍ മതി; പുതുതായി തുറക്കേണ്ട കാര്യമില്ല.).
- പുതിയ ഒരു (ഒഴിഞ്ഞ) ഫയല്‍ IDLE-ല്‍ തുറക്കുക. ഇതിനായി File -> New Window അല്ലെങ്കില് Ctrl-N എന്ന കുറുക്കുവഴി ഉപയോഗിക്കുക.
- പുതിയ ഫയല്‍ ഒരു എഡിറ്ററിലായാണ് തുറന്നുവരുന്നത്; ഇവിടെ നമുക്ക് ഇഷ്ടമുള്ളതൊക്കെ എഴുതാനുള്ള സൗകര്യമുണ്ട്. ഈ ഫയലിലേക്ക് നമ്മുടെ പ്രോഗ്രാം എഴുതുക അല്ലെങ്കില് പകര്‍ത്തിവെക്കുക.
- എഴുതിയ പ്രോഗ്രാമിനെ File -> Save അല്ലെങ്കില് Ctrl-S ഉപയോഗിച്ച് (ഒന്നാം പാഠത്തില്‍ gedit ഉപയോഗിച്ച് സേവ് ചെയ്തപ്പോഴുള്ള നിബന്ധനകള്‍ പാലിച്ചുകൊണ്ട് )സേവ് ചെയ്യുക.
- ഇപ്പോള്‍ നമ്മുടെ എഡിറ്ററുടെ തലക്കെട്ട് "Untitled" എന്നതുമാറി സേവ് ചെയ്ത ഡയറക്ടറിയുടെ പേരുള്‍പ്പടെയുള്ള ഫയലിന്റെ പേരായി മാറിയിരിക്കും. ഇനി ഈ എഡിറ്ററില്‍ നിന്നുകൊണ്ട് (ഇതില്‍ സംശയമുണ്ടെങ്കില്‍ എഡിറ്റര്‍ വിന്‍ഡോയില്‍ എവിടെയെങ്കിലും മൌസ് ഒന്നു ക്ളിക്ക് ചെയ്താല്‍ മതി) F5 അമര്ത്തുക.
പൈത്തണ്‍: പാഠം നാല്
>> Monday, July 19, 2010
1
| num_12 = input("How many 12 year old students in the group? ") |
ഈ വരിയില്‍ മൂന്നു കാര്യങ്ങളാണുള്ളത്:
-
num_12എന്ന വേരിയബിള്‍ (variable) അഥവാ ചരം.
- = എന്ന സംകാരകം (operator).
-
input()എന്ന, ഡേറ്റ സ്വീകരിക്കാനുള്ള ഉപാധി.
ഇവയോരോന്നും എന്താണെന്നു നോക്കാം.
input()
പ്രോഗ്രാമിലേക്ക് പുറത്തുനിന്ന് ഡേറ്റ എത്തിക്കാനുള്ള ഒരു മാര്‍ഗമാണ് input().
കൃത്യമായി പറഞ്ഞാല്‍, ടെര്‍മിനല്‍ ഉപയോഗിച്ച് പ്രോഗ്രാം
പ്രവര്‍ത്തിപ്പിക്കുന്ന ആളിനോട് ഒരു ചോദ്യം ചോദിച്ച്, ആ
ചോദ്യത്തിനുകിട്ടുന്ന ഉത്തരം പ്രോഗ്രാമിലേക്ക് എത്തിക്കുക എന്നതാണ് input() ചെയ്യുന്നത്. ഉപയോക്താവിനോട് ചോദിക്കേണ്ട ചോദ്യം input എന്നതിനു ശേഷം ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി ഒരു string ആയി കൊടുക്കണം — ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കിടയിലായി (ഉദാ: "How many 12 year old students in the group? " ) കൊടുക്കണമെന്നര്‍ത്ഥം. input()
പ്രവര്‍ത്തിക്കുമ്പോള്‍ ഇങ്ങനെ കൊടുത്ത string-നെ അത് ടെര്‍മിനലില്‍ അഥവാ
ഷെല്ലില്‍ പ്രിന്റ് ചെയ്യുകയും, ഉപയോക്താവ് തരുന്ന ഉത്തരത്തിനായി
കാത്തുനില്‍ക്കുകയും ചെയ്യും. പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുന്ന ആള്‍
എന്തെങ്കിലുമൊക്കെ എഴുതി Enter അമര്‍ത്തുമ്പോള്‍, Enter-നു മുമ്പുവരെ
എഴുതിയ കാര്യങ്ങള്‍ വായിച്ചെടുത്ത് input() അത് പ്രോഗ്രാമിലേക്കെത്തിക്കുന്നു. നമ്മുടെ പ്രോഗ്രാമില്‍
input() ഉപയോഗിച്ച് വായിച്ചെടുത്തതെല്ലാം സംഖ്യകളാണല്ലോ? സംഖ്യകളല്ലാതെ പേരുകളും മറ്റും പ്രോഗ്രാമിലേക്ക് input()
ഉപയോഗിച്ച് വായിച്ചെടുക്കാന്‍ ശ്രമിച്ചാല്‍ പൈത്തണ്‍ പരാതി
പറയുന്നതുകാണാം. ഈ പരാതിക്കു കാരണമെന്താണെന്ന് നമുക്കു വഴിയേ കാണാം. പരാതി
പരിഹരിക്കാനായി താഴെപ്പറയുന്നതില്‍ ഏതെങ്കിലും ചെയ്യുക:- പേരുകള്‍, വാചകങ്ങള്‍ മുതലായ string-കള്‍ ഇന്‍പുട്ട് ആയി കൊടുക്കുമ്പോള്‍ (അതായത്, ടെര്‍മിനലില്‍,
input()-ന്റെ കാത്തുനില്‍പ്പ് അവസാനിപ്പിക്കാനായി കൊടുക്കുമ്പോള്‍) അവയെ ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കുള്ളിലാക്കി, string ആയിത്തന്നെ കൊടുക്കുക. അതായത്, വെറുതെPhilipഎന്ന് കൊടുക്കുന്നതിനുപകരം"Philip"എന്നു കൊടുക്കുക. അല്ലെങ്കില്
- പ്രോഗ്രാമില്‍
input()എന്നതിനുപകരംraw_input()ഉപയോഗിക്കുക. ഇങ്ങനെയാണെങ്കില്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്ന സമയത്ത് string-കള്‍ ഇന്‍പുട്ടായി കൊടുക്കുമ്പോള്‍ " " എന്നതിനുള്ളിലായി കൊടുക്കണമെന്നില്ല.
നമ്മുടെ ആദ്യത്തെ പ്രോഗ്രാം ഓര്‍മ്മയില്ലേ? "Hello, World!" എന്ന് എഴുതുന്ന പ്രോഗ്രാമായിരുന്നു അത്.
input() എന്ന ഇന്‍പുട്ട് എടുക്കുന്ന ഉപാധിയെപ്പറ്റി മനസ്സിലാക്കിയ സ്ഥിതിക്ക് നമുക്ക് ഈ പ്രോഗ്രാമിനെ ഒന്ന് മെച്ചപ്പെടുത്താം:ഒരു പ്രവര്‍ത്തനം
- പ്രവ. 1.
- ഉപയോക്താവിനോട് പേരു ചോദിക്കുകയും, പേരു കിട്ടിക്കഴിഞ്ഞാല്‍ ആ പേരുവച്ച് ഹലോ പറയുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം എഴുതുക.
num_12
num_12 എന്നത് ഒരു ചരം (variable - വേരിയബിള്‍) ആണ്. ലളിതമായിപ്പറഞ്ഞാല്‍ മൂല്യങ്ങളെ (values) സൂക്ഷിച്ചുവെക്കാനുള്ള പേരെഴുതിയ പെട്ടികളാണ്
ചരങ്ങള്‍. ഒരു പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തിന്റെ ഭാഗമായി സാധാരണഗതിയില്‍
കുറെയേറെ വിലകള്‍ അഥവാ മൂല്യങ്ങള്‍ ഉപയോഗിക്കേണ്ടതായിവരും.
പ്രോഗ്രാമിനുപുറത്തുനിന്ന് (ഉദാ: input() വഴിയായി) കിട്ടുന്ന
ഡേറ്റയും, പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുമ്പോളുണ്ടാകുന്ന മറ്റു മൂല്യങ്ങളും
ഇതില്‍ ഉള്‍പ്പെടും. ഇവയില്‍ ചിലതിനെയൊക്കെ നമുക്ക് പേരിട്ടു വിളിക്കേണ്ട
ആവശ്യവുമുണ്ടാകും. ഇങ്ങനെ വിലകളെ പേരിട്ടു വിളിക്കാനുള്ള ഉപാധിയാണ്
ചരങ്ങള്‍. പ്രോഗ്രാമിംഗില്‍ ചരങ്ങള്‍ക്ക് വളരെയേറെ പ്രാധാന്യമുണ്ട്. പ്രോഗ്രാമുകള്‍ ശരിയായി എഴുതാന്‍ ചരങ്ങള്‍ എന്താണെന്ന് കൃത്യമായി മനസ്സിലാക്കുകയും അവയെ ശരിയായി ഉപയോഗിക്കുവാന്‍ അറിയുകയും വേണം. ചരങ്ങളുടെ പിന്നിലുള്ള ആശയം ലളിതമായതുകൊണ്ട് ഇതത്ര പ്രയാസമുള്ള കാര്യമൊന്നുമല്ല. ചരങ്ങളുടെ ഉപയോഗത്തില്‍ വളരെ പ്രാധാന്യമുള്ള = എന്ന സംകാരകത്തിനെ പരിചയപ്പെട്ടതിനുശേഷം ചരങ്ങളെപ്പറ്റി നമുക്ക് വിശദമായി ഈ പാഠത്തില്‍ത്തന്നെ പഠിക്കാം.
= എന്ന സംകാരകം (operator)
നമ്മുടെ ശരാശരി പ്രോഗ്രാമിന്റെ ആദ്യത്തെ വരി ഒരിക്കല്‍ക്കൂടി എടുത്തെഴുതുന്നു:
1
| num_12 = input("How many 12 year old students in the group? ") |
ഇതില്‍
num_12, input() എന്നിവയെ ബന്ധിപ്പിക്കുന്ന = എന്ന ചിഹ്നം ചെയ്യുന്നത് വലതുവശത്തുള്ള input() എന്നതിന്റെ വില (മൂല്യം) എടുത്ത് ഇടതുവശത്തുള്ള num_12 എന്ന ചരത്തിന് കൊടുക്കുക എന്നതാണ്. അതായത്, = എന്നത് ഒരു "വിലകൊടുക്കല്‍ സംകാരകം" (assignment operator എന്ന് ഇംഗ്ളീഷില്‍) യാണ്. ഗണിത സമവാക്യങ്ങളില്‍ ഉപയോഗിക്കുന്നതുപോലെ തുല്യത കാണിക്കുന്നതിനുവേണ്ടി അല്ല = എന്നത് പൈത്തണില്‍ ഉപയോഗിക്കുന്നത് എന്നത് പ്രത്യേകം ശ്രദ്ധിക്കേണ്ട കാര്യമാണ് . ഉദാഹരണത്തിന്, ഗണിതത്തില്‍ വെറും പൊട്ടത്തെറ്റായ x = x + 1 എന്നത് പൈത്തണില്‍ സാധുതയുള്ള പ്രസ്താവമാണ്! ഇതെങ്ങനെയാണ് ശരിയാകുന്നത് എന്നുകാണാന്‍
= എന്ന് പ്രോഗ്രാമില്‍ കാണുന്നിടത്ത് അതിനുപകരം ← ആണ് എന്ന് സങ്കല്‍പ്പിക്കുക. അപ്പോള്‍ x = x + 1 എന്നത് x ← x + 1 എന്നാകും (സങ്കല്‍പ്പത്തില്‍). ഇതിനെ വായിക്കേണ്ടത് ഇങ്ങനെയാണ്: " ←-ന്റെ വലതുവശത്തുകാണുന്ന വ്യഞ്ജകത്തിന്റെ (expression) വില കണ്ടുപിടിച്ച് അത് ←-ന്റെ ഇടതുവശത്തുകാണുന്ന ചരത്തിന് കൊടുക്കുക." ഇങ്ങനെയാകുമ്പോള്‍ x ← x + 1 എന്നതിന്റെ അര്‍ത്ഥം ഇനിപ്പറയുന്നതാണ്: "x എന്ന ചരത്തിന്റെ ഇനിയുള്ള വില എന്നത് x-ന് മുമ്പുണ്ടായിരുന്ന വിലയുടെ കൂടെ 1 കൂട്ടിയാല്‍ കിട്ടുന്ന മൂല്യമാണ്". ഇതുതന്നെയാണ് x = x + 1
എന്നു പറയുമ്പോള്‍ സംഭവിക്കുന്നതും. ഇതു നമുക്കൊന്ന് പരീക്ഷിച്ചുനോക്കാം.
ഇതിനായി IDLE-ലെ പൈത്തണ്‍ ഷെല്ലില്‍ പോകുക (ടെര്‍മിനലില്‍ പൈത്തണ്‍ ഷെല്‍
തുറന്നാലും മതി). താഴെക്കാണുന്നവ പരീക്ഷിക്കുക:Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) [GCC 4.4.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> x = 5 >>> x 5 >>> x = x + 1 >>> x 6 >>>
-
xഎന്ന ചരത്തിന്5എന്ന വില കൊടുക്കാന്‍x = 5എന്ന് കൊടുത്ത് Enter അമര്‍ത്തുന്നു.
-
x-ന്റെ വില കാണാന്‍ വെറുതെxഎന്ന് കൊടുത്ത് Enter അമര്‍ത്തുന്നു. ഷെല്ലിലായതുകൊണ്ടാണ് ഇത് മതിയാകുന്നത്. ഫയലിലെഴുതിയ പ്രോഗ്രാമിലാണെങ്കില്‍print xഎന്ന് എഴുതണം.
-
x-ന്റെ വില ഒന്നു കൂട്ടാന്‍x = x + 1എന്ന് കൊടുക്കുന്നു.
-
x-ന്റെ വില മാറിയോ എന്നു കാണാന്‍ വീണ്ടുംxഎന്ന് കൊടുക്കുന്നു.
ഇതുതന്നെ ഒരു ചെറിയ പ്രോഗ്രാമാക്കി എഴുതിയാല്‍ ഇതുപോലെയിരിക്കും:
1
2
3
4
5
6
7
8
9
| # A short program to show the assignment operator in action.x = 5print xx = x + 1print x |
ഇത്തരം ചെറിയ കാര്യങ്ങള്‍ ചെയ്തുനോക്കാന്‍ ഷെല്‍ തന്നെയാണ് സൗകര്യം.
പ്രോഗ്രാമില്‍ കാണുന്ന=എന്ന ചിഹ്നത്തിന് ഗണിതത്തില്‍ കാണുന്ന = എന്ന ചിഹ്നത്തിന്റെ അതേ അര്‍ത്ഥം അല്ല എന്ന ബോധം ഉറയ്ക്കാന്‍വേണ്ടി കുറേക്കാലത്തേക്കെങ്കിലും പ്രോഗ്രാമില്‍=എന്ന് കാണുന്നിടത്തെല്ലാം←എന്ന ചിഹ്നം മനസ്സില്‍ക്കാണുക .
പ്രവര്‍ത്തനങ്ങള്‍
(എല്ലാം ഷെല്ലില്‍ (IDLE-ലോ ടെര്‍മിനലിലോ) ചെയ്യേണ്ടവ.)- പ്രവ. 2.
-
മുകളില്‍പ്പറഞ്ഞ കാര്യങ്ങള്‍ ഷെല്ലില്‍ ചെയ്യുക. അതിനു തുടര്‍ച്ചയായി
x-ന്റെ വില ഇരട്ടിപ്പിക്കുക:x-ന്റെ വിലയെ രണ്ടുകൊണ്ട് ഗുണിച്ച്x-ലേക്കുതന്നെ കൊടുക്കുക. ഇതുകഴിഞ്ഞുള്ളx-ന്റെ വില കാണുക, ഇരട്ടിച്ചു എന്ന് ഉറപ്പുവരുത്തുക. - പ്രവ. 3.
-
yഎന്ന ചരത്തിന്10എന്ന വില കൊടുക്കുക.zഎന്ന ചരത്തിന്x,yഎന്നിവയുടെ തുക വിലയായി കൊടുക്കുക.z-ന്റെ വില കാണുക. - പ്രവ. 4.
-
aഎന്ന ചരത്തിന്"silsila "എന്ന വില കൊടുക്കുക.bഎന്ന ചരത്തിന്"hai "എന്ന വില കൊടുക്കുക (ഉദ്ധരണചിഹ്നങ്ങളും സ്പേസും ശ്രദ്ധിക്കുക).cഎന്ന ചരത്തിന്a + b + aഎന്ന വില കൊടുക്കുക. ഇപ്പോള്‍c-യുടെ വില എന്താണ്? - പ്രവ. 5.
-
c-യുടെ വില ഇരട്ടിപ്പിക്കുക:c-യുടെ വിലയെ രണ്ടുകൊണ്ട് ഗുണിച്ച് (അതെ!)c-ലേക്കുതന്നെ കൊടുക്കുക. ഇതുകഴിഞ്ഞുള്ളc-യുടെ വില കാണുക.
ശരാശരി പ്രോഗ്രാമിന്റെ വിവരണം
കഴിഞ്ഞ പാഠത്തിലെ ശരാശരി കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മനസ്സിലാക്കാനുള്ളതെല്ലാം നാം പഠിച്ചുകഴിഞ്ഞു. പ്രോഗ്രാം എടുത്തെഴുതുന്നു.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| # This program calculates the average age of a group of# students whose ages range from twelve to sixteen. The# program takes as input the numbers of students of each age# and outputs the average.# # The goal of this program is to show how to read input into# the program, and to introduce the use of variables.num_12 = input("How many 12 year old students in the group? ")num_13 = input("How many 13 year old students in the group? ")num_14 = input("How many 14 year old students in the group? ")num_15 = input("How many 15 year old students in the group? ")num_16 = input("How many 16 year old students in the group? ")total_num = num_12 + num_13 + num_14 + num_15 + num_16total_age = (12.0 * num_12) + (13 * num_13) + (14 * num_14) + \ (15 * num_15) + (16 * num_16)average = total_age/total_numprint "The average age of all the students is ", average |
പ്രോഗ്രാമിന്റെ ആദ്യത്തെ ഏഴു വരികള്‍ കമന്റുകളും പിന്നെയുള്ള രണ്ടു വരികള്‍ ശൂന്യവുമാണല്ലോ. പത്തു മുതല്‍ പതിനെട്ടു വരെ വരികളില്‍ ചെയ്യുന്നത് ഉപയോക്താവിന്റെ പക്കല്‍നിന്ന് അഞ്ച് വിലകള്‍ (ഇവ പൂര്‍ണ്ണ സംഖ്യകളാണെന്നാണ് സങ്കല്‍പം) വാങ്ങി അഞ്ച് ചരങ്ങളിലേക്ക് (
num_12, num_13, num_14, num_15, num_16 ) സൂക്ഷിച്ചു വെക്കുക (store) എന്നതാണ്. ഇതിനായി നാം മുകളില്‍ വിവരിച്ച രീതിയില് input(), = എന്നിവ ഉപയോഗിച്ചിരിക്കുന്നു. ഇരുപതാം വരിയില്‍ ചെയ്യുന്നത്
total_num എന്ന ചരത്തിലേക്ക്
മറ്റ് അഞ്ച് ചരങ്ങളുടേയും തുക (ഇത് കുട്ടികളുടെ എണ്ണമാണ്)
സൂക്ഷിച്ചുവെക്കുക എന്നതാണ്. ഇരുപത്തിരണ്ടാം വരിയിലാകട്ടെ കുട്ടികളുടെ
വയസുകളുടെയെല്ലാം തുക total_age എന്ന ചരത്തിലേക്ക് സൂക്ഷിച്ചുവെക്കുന്നു. ഇതിയായി =
ചിഹ്നത്തിന്റെ വലതുഭാഗത്ത് ഈ തുക തരുന്ന ഒരു വ്യഞ്ജകം (expression)
എഴുതിയിരിക്കുന്നു. ഇവിടെ വലത്തേക്ക് നീണ്ടുപോകുമായിരുന്ന വ്യഞ്ജകത്തെ \
എന്ന ചിഹ്നത്തിന്റെ സഹായത്തോടെ രണ്ടു വരികളിലാക്കിയിരിക്കുന്നത്
ശ്രദ്ധിക്കുക: പ്രോഗ്രാം കാണുമ്പോഴുള്ള ഭംഗിക്കുവേണ്ടിയും വായിക്കാനുള്ള
സൗകര്യത്തിനുവേണ്ടിയും മാത്രമാണ് ഇങ്ങനെ ചെയ്യുന്നത്. \
ഒഴിവാക്കി ഒരേ വരിയില്‍ വ്യഞ്ജകം മുഴുവന്‍ എഴുതിയാലും പ്രോഗ്രാം ഒരു
വ്യത്യാസവുമില്ലാതെ പ്രവര്‍ത്തിച്ചുകൊള്ളും (ഇങ്ങനെയാക്കി നോക്കൂ). ഇരുപത്തിയഞ്ചാം വരിയില്‍
total_age എന്ന ചരത്തിന്റെ വിലയെ total_num എന്ന ചരത്തിന്റെ വിലകൊണ്ട് ഹരിച്ചുകിട്ടുന്ന ഫലത്തെ average
എന്ന ചരത്തിലേക്ക് സൂക്ഷിച്ചു വെക്കുന്നു. പ്രോഗ്രാമിലെ അവസാനത്തെ
വരിയില്‍ ഇങ്ങനെ കിട്ടിയ ശരാശരി ഒരു വാചകത്തിന്റെ ഒടുവിലായി
പുറത്തേക്കെഴുതുമ്പോള്‍ പ്രോഗ്രാം വിജയകരമായി പൂര്‍ത്തിയാകുന്നു.ചരങ്ങള്‍
മൂല്യങ്ങളെ (values) പേരിട്ടു വിളിക്കാനായി പ്രോഗ്രാമില്‍ ചരങ്ങള്‍ (variables) ഉപയോഗിക്കുന്നത് നാം കണ്ടു. ഇനി നമുക്ക് ചരങ്ങളെപ്പറ്റി കുറച്ചുകൂടി വിശദമായി പഠിക്കാം. ചരങ്ങളുടെ പിന്നിലെ ആശയം മനസ്സിലാക്കാന്‍ എളുപ്പമുള്ളതാണ്. ഇതു ശരിയായി മനസ്സിലാക്കാതിരുന്നാലോ, പ്രോഗ്രാമെഴുത്ത് ദുഷ്കരമാകുകയും ചെയ്യും.ഒരു ചരത്തിന് രണ്ട് ഭാഗങ്ങളുണ്ട് — പേരും, മൂല്യവും:
ചരത്തിന്റെ പേര് (name അല്ലെങ്കില് label)
- ശരാശരി കാണാനുള്ള പ്രോഗ്രാമില്‍ നാമുപയോഗിച്ച് ചരങ്ങളുടെ പേരുകള്‍
num_12, num_13, num_14, num_15, num_16, total_num, total_age, averageഎന്നിവയാണ്. ചരങ്ങള്‍ക്ക് പേരുകൊടുക്കുമ്പോള്‍ പാലിക്കേണ്ട ചില നിയമങ്ങളുണ്ട്. അവ ഇവിടെ ചുരുക്കി പറയുന്നു:- പേരുകള്‍ക്ക് എത്രവേണമെങ്കിലും നീളം ആകാം.
- പേരിന്റെ ആദ്യത്തെ അക്ഷരം ഇംഗ്ളീഷ് അക്ഷരമാലയിലെ ഏതെങ്കിലും അക്ഷരം (ചെറിയതോ വലിയതോ) അല്ലെങ്കില് "_"-ഓ (underscore) ആയിരിക്കണം.
- പേരിന്റെ രണ്ടാമത്തേതും തുടര്‍ന്നുമുള്ള സ്ഥാനങ്ങളില്‍ മേല്‍പ്പറഞ്ഞ അക്ഷരങ്ങളും "_"-ഉം കൂടാതെ അക്കങ്ങളും ആകാം.
- പേരുകളില്‍ വലിയക്ഷരവും ചെറിയക്ഷരവും (capital and small letters) തമ്മില്‍ വ്യത്യാസമുണ്ട്. ഉദാ:
average, Averageഎന്നിവ രണ്ടു വ്യത്യസ്ത ചരങ്ങളാണ്; ഒന്നിനു പകരം മറ്റേത് ഉപയോഗിച്ചാല്‍ പ്രോഗ്രാം തെറ്റിപ്പോകും.
- താഴെക്കാണുന്ന പേരുകള്‍ വിലക്കപ്പെട്ടവയാണ്. ഇവ ചരങ്ങളുടെ പേരുകളായി ഉപയോഗിച്ചുകൂടാ .
ഇതിനുകാരണം ഇവയ്ക്ക് പൈത്തണ്‍ ഭാഷയില്‍ പ്രത്യേക അര്‍ത്ഥങ്ങള്‍ ഉണ്ട്
എന്നതാണ്. ഇവയെ കീവേഡുകള്‍ (keywords) –
പ്രത്യേകവാക്കുകള്‍/പ്രധാനവാക്കുകള്‍ – എന്നു വിളിക്കുന്നു.
and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try
- "_" പേരിന്റെ തുടക്കത്തില്‍ അനുവദനീയമാണെങ്കിലും തുടക്കക്കാരായ
നമ്മള്‍ ഈ സൗകര്യം ഉപയോഗിക്കാതെയിരിക്കുന്നതാണ് നല്ലത്. പേരിന്റെ
തുടക്കത്തിലെ "_" വിട്ടുപോകാനും കാണാതെയിരിക്കാനും നല്ല
സാധ്യതയുള്ളതുകൊണ്ടാണ് ഇങ്ങനെ പറഞ്ഞത്.
- മേല്‍ക്കൊടുത്ത നിയമങ്ങളനുസരിക്കുന്ന ഏതു പേരും
ചരങ്ങള്‍ക്കിടാമെങ്കിലും ചരത്തിനെ എന്ത് സൂചിപ്പിക്കാനാണോ പ്രോഗ്രാമില്‍
ഉപയോഗിക്കുന്നത്, ആ അര്‍ത്ഥം വരുന്ന പേരുകള്‍ ഇടുന്നതാണ് നല്ലത്. ഇത്
പ്രോഗ്രാം വായന സുകരമാക്കും. ശരാശരി കാണാനുള്ള നമ്മുടെ പ്രോഗ്രാമില്‍
ഉപയോഗിച്ചിരിക്കുന്ന ചരങ്ങളുടെ പേരുകള്‍ ശ്രദ്ധിക്കുക.
- ഒറ്റനോട്ടത്തില്‍ ഒന്നാണെന്ന് തോന്നിക്കുന്ന പേരുകള്‍ കൊടുക്കാതെയിരിക്കുക.
average, Averageഎന്നീ രണ്ടു പേരുകളും ഒരേ പ്രോഗ്രാമില്‍ ഉപയോഗിച്ചാല്‍ ചിന്താക്കുഴപ്പവും അതുമൂലമുള്ള തെറ്റുകളും വരാന്‍ കാരണം വേറെയൊന്നും വേണ്ട.
- പേരുകള്‍ക്ക് എത്രവേണമെങ്കിലും നീളം ആകാം.
ചരത്തിന്റെ മൂല്യം (value)
-
ഒരു ചരത്തിന് പ്രോഗ്രാമിലെ ആവശ്യമനുസരിച്ച് പല തരത്തിലുള്ള — സംഖ്യ,
string, മുതലായ — വിലകള്‍ ആകാം. ചരങ്ങളെപ്പറ്റി ചിന്തിക്കാനുള്ള എളുപ്പവഴി
അവയെ വിലകള്‍ സൂക്ഷിക്കാനുള്ള കള്ളികളായി (cells) സങ്കല്‍പ്പിക്കുക
എന്നതാണ്. ഇതനുസരിച്ച് നമ്മുടെ പ്രോഗ്രാമിലെ പത്താമത്തെ വരി
പ്രവര്‍ത്തിക്കുന്നതിനുമുമ്പ്
num_12എന്ന ചരം ഇങ്ങനെയിരിക്കും:ചരത്തിന്റെ വില (value) സൂക്ഷിക്കുന്ന ഭാഗത്ത് ഒന്നുമില്ല എന്നത് ശ്രദ്ധിക്കുക. പ്രോഗ്രാമിലെ പത്താമത്തെ വരി പ്രവര്‍ത്തിക്കുമ്പോഴുണ്ടാകുന്ന ചോദ്യത്തിന് ഉത്തരമായി നിങ്ങള്‍ 10 എന്ന സംഖ്യ കൊടുത്ത് Enter അമര്‍ത്തി എന്ന് കരുതുക. അപ്പോള്‍ ഇതേ ചരത്തിന്റെ അവസ്ഥ ഇങ്ങനെയായി മാറും:
പ്രോഗ്രാം പതിനെട്ടാമത്തെ വരി വരെ പ്രവര്‍ത്തിച്ചുകഴിയുമ്പോള്‍ ചരങ്ങളുടെ അവസ്ഥ (ഈ സംഖ്യകളൊക്കെ ഇന്‍പുട്ട് ആയി കിട്ടിയാല്‍):
ഇരുപതാമത്തെ വരി കഴിയുമ്പോള്‍:
ഇങ്ങനെ തുടര്‍ന്ന്, പ്രോഗ്രാമിന്റെ അവസാനമാകുമ്പോഴേക്കും:
ചരങ്ങളും
= -ഉം ഉള്‍പ്പെടുന്ന ഒരു പൈത്തണ്‍ വരി വായിക്കേണ്ട രീതി:-
=-ന് വലതുവശത്ത് (ഒറ്റയ്കോ ഒരു വ്യഞ്ജകത്തിന്റെ ഭാഗമായോ) കാണുന്ന ചരങ്ങള്‍ താന്താങ്ങളുടെ വിലകളെ ആണ് സൂചിപ്പിക്കുന്നത്. അതുകൊണ്ട് ഇങ്ങനെയുള്ള ഓരോ ചരത്തിനും പകരമായി അതിന്റെ ഇപ്പോഴത്തെ വില അതേ സ്ഥാനത്ത് സങ്കല്‍പ്പിക്കുക.
-
=-ന്റെ ഇടതുവശത്ത് ഒരേ ഒരു ചരമേ ആകാവൂ. ഒന്നിലധികം ചരങ്ങളുള്ള വ്യഞ്ജകങ്ങള്‍ പാടില്ല (ഇതിന് അപവാദങ്ങളുണ്ട്, വഴിയേ കാണാം).=-ന്റെ ഇടതുവശത്ത് കാണുന്ന ചരം അതിന്റെ വിലയെ അല്ല സൂചിപ്പിക്കുന്നത്, മറിച്ച് അതിന്റെ കള്ളിയെ (cell, location) ആണ്. ഈ കള്ളിയിലേക്ക്=-ന്റെ വലതുവശത്തുള്ള വ്യഞ്ജകത്തിന്റെ വില എഴുതുന്നതായി സങ്കല്‍പ്പിക്കുക.
x എന്ന ഒരു ചരത്തിന്റെ വില പല തരത്തില്‍ മാറ്റുന്ന ഒരു കൂട്ടം പൈത്തണ്‍ ശകലങ്ങള്‍ ഇതാ. ഓരോ പ്രാവശ്യവും x -ന്റെ വില മാറുമ്പോള്‍ x -ന്റെ
വില സൂക്ഷിച്ചിരിക്കുന്ന പേരിട്ട പെട്ടിക്ക് എന്ത് സംഭവിക്കുന്നു എന്ന്
കാണിക്കുന്ന ചിത്രങ്ങള്‍ താഴെ. ഈ പെട്ടി കംപ്യൂട്ടറിന്റെ മെമ്മറിയില്‍
(RAM) ആണ് നിലകൊള്ളുന്നത്. ഒരു പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നിടത്തോളം സമയം ആ
പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന ചരങ്ങളുടെ പെട്ടികള്‍ മെമ്മറിയില്‍ കാണും.
പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം നിലയ്ക്കുമ്പോള്‍ ഈ പെട്ടികളും
അപ്രത്യക്ഷമാവും; അവ ഉപയോഗിച്ച മെമ്മറി മറ്റു പ്രോഗ്രാമുകള്‍ക്ക്
ഉപയോഗിക്കാന്‍ വിട്ടുകിട്ടുകയും ചെയ്യും. Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) [GCC 4.4.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> x = 5 >>> x 5 >>> x = "Maths" >>> x 'Maths' >>> x = 2 * x >>> x 'MathsMaths' >>> x = x + x >>> x 'MathsMathsMathsMaths' >>> x = 10 >>> x 10 >>>
(കൂടുതല്‍ വ്യക്തമായ ചിത്രം കാണാന്‍ ചിത്രത്തില്‍ ക്ളിക്ക് ചെയ്യുക.)
ഒരു പ്രവര്‍ത്തനം
- പ്രവ. 6.
- പ്രോഗ്രാമില്‍ വിട്ടുപോയ വരികള്‍ പൂരിപ്പിക്കുക
# .......... എന്നു കാണുന്ന ഭാഗത്ത് ) പൂരിപ്പിച്ച് a, b എന്നീ ചരങ്ങളുടെ മൂല്യം പരസ്പരം മാറുന്ന രീതിയില് ആക്കുക. പ്രോഗ്രാമിന്റെ മറ്റുഭാഗങ്ങളില്‍ മാറ്റം വരുത്താതെ വേണം ഇത് ചെയ്യേണ്ടത്.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| # A progam that exchanges the values of two variables.a = raw_input("Please enter a value for the first variable: ")b = raw_input("Please enter a value for the second variable: ")print "The value of the first variable is: ", aprint "The value of the second variable is: ", bprint "Going to exchange the values of the two variables..."print "............................."print "............................."# Write code below that will exchange the values of the two# variables a and b.# ..........# ..........# ..........# ..........print "Successfully exchanged the values of the two variables."print "The value of the first variable is: ", aprint "The value of the second variable is: ", b |
ഇങ്ങനെ ചെയ്തുകഴിയുമ്പോള്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നത് ഇതുപോലെയായിരിക്കണം (വ്യക്തമായ ചിത്രത്തിന് ക്ളിക്ക് ചെയ്യുക):
ഉത്തരങ്ങളും സംശയങ്ങളും നിര്‍ദ്ദേശങ്ങളും കമന്റായിടുക.
പൈത്തണ്‍: പാഠം അഞ്ച്
>> Tuesday, August 3, 2010
ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കുന്നതെങ്ങനെ?
കഴിഞ്ഞ പാഠത്തിന്റെ കമന്റുകളില്‍ "Free" എന്ന വായനക്കാരി (രന്‍?) അവതരിപ്പിച്ച പ്രവര്‍ത്തനം ഒന്നു നോക്കാം. ചോദ്യം ഇതാണ്: " ഒരാളുടെ പേരും വയസും ഇന്‍പുട്ട് ആയി എടുത്ത് അയാള്‍ ജനിച്ച വര്‍ഷം ഔട്പുട്ട് തരുന്ന പ്രോഗ്രാം എഴുതുക." ഈ പ്രവര്‍ത്തനത്തിന് "digitaleye" എന്ന വായനക്കാരന്‍ (രി?) തന്ന ഉത്തരം കുറച്ചുകൂടി വിശദമാക്കി എഴുതിയ ഒരു പ്രോഗ്രാം ഇതാ. പ്രോഗ്രാം ഒരു ഫയലിലേക്ക് സേവ് ചെയ്ത് പല പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ. ഇതിനുള്ള എളുപ്പവഴി IDLE ഉപയോഗിക്കുക എന്നതാണ്, ഇവിടെ പറഞ്ഞിരിക്കുന്നതുപോലെ.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| # This program asks for the name and age (in number of# years) of the user, and outputs the year when the user was# born.name = raw_input("Hello, what is your name? ")question = name + ", please tell me your age in years: "age = input(question)current_year = 2010year_of_birth = current_year - ageprint name, ", you were born in ", year_of_birthprint "Goodbye!" |
പ്രോഗ്രാമിന്റെ അഞ്ചാമത്തെ വരിയില്‍ ഉപയോക്താവിന്റെ പേര്
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 സെപ്റ്റംബര്‍ അവസാനം ആണ്.
ഈ കീടത്തെ എങ്ങനെ ശരിപ്പെടുത്താം?
ബഗ് ഉണ്ടെന്ന് മനസ്സിലായ സ്ഥിതിക്ക് അത് ഒഴിവാക്കുന്ന തരത്തില്‍ പ്രോഗ്രാം തിരുത്തി എഴുതേണ്ടത് നമ്മുടെ കടമയാണ് (ഈ പ്രക്രിയയെ "കീടോച്ഛാടനം" എന്നു വിളിക്കാമോ?). ഹരിയുടെ കാര്യത്തില്‍ പ്രോഗ്രാമില്‍നിന്ന് തെറ്റായ ഉത്തരം കിട്ടാന്‍ എന്താണ് കാരണം? പ്രോഗ്രാമിന് ശരിയായ ഉത്തരം കണ്ടുപിടിക്കാന്‍ ആവശ്യമായ വിവരങ്ങള്‍ എല്ലാം ഇന്‍പുട്ട് ആയി നാം കൊടുക്കാത്തതുതന്നെ. വയസിന്റെ കുറച്ചുകൂടി കൃത്യമായ വിവരം — എത്ര വര്‍ഷം എന്നതിന് പുറമേ എത്ര മാസം എന്നതുകൂടി — ഇന്‍പുട്ട് ആയി പ്രോഗ്രാമിന് കിട്ടിയാല്‍ മേല്‍പ്പറഞ്ഞ തെറ്റ് ഒഴിവാക്കുന്ന പ്രോഗ്രാം നമുക്കെഴുതാം. ഇങ്ങനെയുള്ള ഒരു പ്രോഗ്രാമിന്റെ ലോജിക് ഏകദേശം ഇതുപോലെയിരിക്കും:
- ഉപയോക്താവിന്റെ പ്രായം എത്ര വര്‍ഷം, എത്ര മാസം എന്നത് ചോദിച്ച് മനസ്സിലാക്കുക.
- വര്‍ഷത്തിനെ
yearsഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക. - മാസത്തിനെ
monthsഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക. - നടപ്പുവര്‍ഷവും മാസവും
current_year,current_monthഎന്ന ചരങ്ങളില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക. -
monthsഎന്നതിന്റെ വിലcurrent_monthഎന്നതിന്റെ വിലയേക്കാള്‍ കുറവാണെങ്കില്‍ -
current_year - yearsഎന്നതാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം; ഈ വിലയെyear_of_birthഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക. - മറിച്ച്,
monthsഎന്നതിന്റെ വിലcurrent_monthഎന്നതിന്റെ വിലയ്ക്ക് തുല്യമോ അതില്‍ കൂടുതലോ ആണെങ്കില്‍ -
current_year - years - 1എന്നതാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം; ഈ വിലയെyear_of_birthഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചു വെയ്ക്കുക. year_of_birthഎന്ന ചരത്തിന്റെ വിലയാണ് ഉപയോക്താവ് ജനിച്ച വര്‍ഷം എന്ന് ഉത്തരം പറയുക.
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 1.
- ഈ ലോജിക് ശ്രദ്ധിച്ച് വായിക്കുക. ഇത് ഹരി ജനിച്ച വര്‍ഷം ശരിയായി കണ്ടുപിടിക്കുമോ എന്ന് ചിന്തിക്കുക.
- പ്രവ. 2.
- ഇപ്പറഞ്ഞ ലോജിക് എങ്ങനെ ഒരു പ്രോഗ്രാം ആയി എഴുതാം എന്ന് ആലോചിക്കുക.
if ... else
മുകളിലുള്ള ലോജിക്കിന് ആകെ അഞ്ചു ഭാഗങ്ങള്‍ ഉള്ളതില്‍ ആദ്യത്തെ രണ്ടു ഭാഗങ്ങള്‍ പ്രോഗ്രാമില്‍ എഴുതേണ്ടതെങ്ങനെ എന്ന് നമുക്കറിയാം – മുമ്പു കണ്ട പ്രോഗ്രാമുകളില്‍ നാം ഇതേപോലെയുള്ള കാര്യങ്ങള്‍ ചെയ്തിട്ടുണ്ട്. ലോജിക്കിന്റെ അഞ്ചാമത്തെ ഭാഗവും — കണ്ടുപിടിച്ച ഉത്തരം ഉപയോക്താവിന് പറഞ്ഞുകൊടുക്കുക എന്നുള്ളത് — ഇപ്പോള്‍ നമുക്ക് നിഷ്പ്രയാസം ചെയ്യാന്‍ അറിയാം.
പ്രശ്നക്കാരായിട്ട് ഉള്ളത് മൂന്നും നാലും ഭാഗങ്ങളാണ്: ഒരു പ്രത്യേക കാര്യം —
months എന്നതിന്റെ വില current_month
എന്നതിന്റെ വിലയേക്കാള്‍ കുറവാണോ എന്നത് — ശരിയാണോ എന്ന് പരിശോധിച്ച്, ഇത്
ശരിയാണെങ്കില്‍ ഒരു കാര്യവും, തെറ്റാണെങ്കില്‍ വേറൊരു കാര്യവും ചെയ്യുക
എന്നതാണ് ഈ രണ്ട് ഭാഗങ്ങളില്‍ സംഭവിക്കുന്നത്. ഇത് എങ്ങനെയാണ്
പ്രോഗ്രാമില്‍ എഴുതുക എന്ന് നാം ഇതുവരെയുള്ള പാഠങ്ങളില്‍ പഠിച്ചിട്ടില്ല.
ഇക്കാര്യം ഈ പാഠത്തില്‍ പഠിക്കാം.നാം ഇതുവരെ കണ്ട പൈത്തണ്‍ പ്രോഗ്രാമുകളെല്ലാം ഒരു നേര്‍രേഖാ സ്വഭാവം ഉള്ളവയാണ്: പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം തുടങ്ങിയാല്‍പ്പിന്നെ പ്രോഗ്രാമിലെ ഓരോ വരിയും പ്രോഗ്രാമില്‍ എഴുതിയിരിക്കുന്ന ക്രമത്തില്‍ പ്രവര്‍ത്തിച്ചുപോകുക എന്ന രീതിയാണ് അവയ്ക്കൊക്കെ ഉള്ളത്. ഇങ്ങനെ "നേര്‍ബുദ്ധി" മാത്രമുള്ള പ്രോഗ്രാമുകളെക്കൊണ്ട് വളരെ പരിമിതങ്ങളായ കാര്യങ്ങളേ ചെയ്യാന്‍ കഴിയൂ. ഇങ്ങനെയല്ലാത്ത — രേഖീയമല്ലാത്ത — രീതിയില് പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കാനുള്ള പൈത്തണ്‍ ഭാഷാരൂപങ്ങളില്‍ ഏറ്റവും ലളിതമായതാണ്
if ... else എന്ന പ്രയോഗം.ഒരു വ്യവസ്ഥ (condition) ശരിയാണോ എന്ന് പരിശോധിച്ച്, ശരിയാണെങ്കില്‍ ഒരു കൂട്ടം കാര്യങ്ങളും, തെറ്റാണെങ്കില്‍ മറ്റൊരുകൂട്ടം കാര്യങ്ങളും ചെയ്യാന്‍ പൈത്തണില്‍ (മറ്റു പ്രോഗ്രാമിംഗ് ഭാഷകളിലും) ഉള്ള ഉപാധിയാണ്
if ... else എന്ന പ്രയോഗം. ഉദാഹരണമായി, if ... else ഉപയോഗിച്ച് ഒരു സംഖ്യ ഒറ്റസംഖ്യയോ ഇരട്ടസംഖ്യയോ എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം ഇതാ. രണ്ടാം പാഠത്തില്‍ നാം പരിചയപ്പെട്ട ശിഷ്ടം കാണാനുള്ള % എന്ന സംകാരകവും (operator) ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്നു:
1
2
3
4
5
6
7
8
9
10
11
| # This program finds if a given number is odd or even. The# program demonstrates the use of the "if ... else" program# construct. It is assumed that the input number is an# integer!number = input("Please input an integer: ")if (number % 2) == 0 : print number, " is an even number"else : print number, " is an odd number" |
ഈ പ്രോഗ്രാമില്‍ എട്ടു മുതല്‍ പതിനൊന്നു വരെയുള്ള വരികളിലാണ്
if ... else ഉള്ളത്. ഈ വരികളില്‍ എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് വിശദമായി നോക്കാം:- എട്ടും ഒന്‍പതും വരികളില്‍ ചെയ്യുന്നത് ഇതാണ്:
numberഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചിരിക്കുന്ന സംഖ്യയെ രണ്ടു കൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍numberഇരട്ടസംഖ്യയാണെന്ന് പറയുക. - എട്ടാമത്തെ വരിയില്‍ ശരിയാണോ എന്ന് പരിശോധിക്കേണ്ട വ്യവസ്ഥ
ifഎന്നതിനു ശേഷവും:എന്നതിനു മുമ്പായും കൊടുത്തിരിക്കുന്നു. -
%എന്ന ചിഹ്നം പൈത്തണില്‍ ശിഷ്ടം കാണാനുള്ള സംകാരകത്തെ സൂചിപ്പിക്കുന്നു.(number % 2)എന്ന വ്യഞ്ജകത്തിന്റെ വിലnumber-നെ രണ്ടുകൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം കിട്ടുന്ന സംഖ്യയാണ്. ഇത് പൂജ്യമോ ഒന്നോ ആയിരിക്കും (എന്തുകൊണ്ട്?). -
==എന്ന ചിഹ്നം (രണ്ടു സമചിഹ്നങ്ങള്‍ അടുപ്പിച്ച് എഴുതിയത്) പൈത്തണില്‍ തുല്യത പരിശോധിക്കുന്ന സംകാരകത്തെ സൂചിപ്പിക്കുന്നു. - എട്ടാമത്തെ വരി വായിക്കേണ്ടത് " number-നെ രണ്ടുകൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ " എന്നാണ്.
- വ്യവസ്ഥ ശരിയാണെങ്കില്‍ ചെയ്യേണ്ട കാര്യങ്ങള്‍ —
numberഇരട്ടസംഖ്യയാണെന്ന് പറയുക എന്നുള്ളത് —if ... :കഴിഞ്ഞുള്ള വരിയില്‍ വലതുവശത്തേക്ക് കുറച്ച് മാറ്റി കൊടുത്തിരിക്കുന്നു. - പത്തും പതിനൊന്നും വരികളില്‍ ചെയ്യുന്നത് ഇതാണ്: എട്ടാമത്തെ വരിയില്‍ പരിശോധിച്ച വ്യവസ്ഥ —
numberഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചിരിക്കുന്ന സംഖ്യയെ രണ്ടു കൊണ്ടു ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണോ എന്നത് — തെറ്റാണെങ്കില്‍numberഒറ്റസംഖ്യയാണെന്ന് പറയുക. - "എട്ടാമത്തെ വരിയിലെ
if-ല്‍ പരിശോധിച്ച വ്യവസ്ഥ തെറ്റാണെങ്കില്‍" എന്ന് പ്രോഗ്രാമില്‍ ചുരുക്കിപ്പറയാനായിelse :എന്ന് പ്രയോഗിക്കുന്നു. - ഈ വ്യവസ്ഥ തെറ്റുമ്പോള്‍ ചെയ്യേണ്ട കാര്യങ്ങള്‍ —
numberഒറ്റസംഖ്യയാണെന്ന് പറയുക എന്നുള്ളത് —else :കഴിഞ്ഞുള്ള വരിയില്‍ വലതുവശത്തേക്ക് കുറച്ച് മാറ്റി കൊടുത്തിരിക്കുന്നു.
if ... else : വിശദമായി
if ... else പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം:-
ifവരിയുടെ വ്യാകരണം ഇതാണ്:if condition :. ഇവിടെconditionഎന്നത് നമുക്ക് ശരിയോ തെറ്റോ എന്ന് അറിയേണ്ടതായ വ്യവസ്ഥ ആണ്. മുകളിലെ ഉദാഹരണത്തില്‍ ഈ വ്യവസ്ഥ(number % 2) == 0എന്നതാണ്.conditionകഴിഞ്ഞുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക . -
ifവരി കഴിഞ്ഞുള്ള വരികളില്‍conditionഎന്ന വ്യവസ്ഥ ശരിയാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതണം. ഇത് ഒന്നിലധികം വരികളും ആവാം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈifവരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. - മുകളിലെ ഉദാഹരണത്തില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (ഒന്‍പതാമത്തെ വരി). ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍
if condition :എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. -
if-ല്‍ പരിശോധിച്ച വ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരിifവരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം.ifവ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത്if-നു ശേഷംif-ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പായി നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. - മുകളിലെ ഉദാഹരണത്തില്‍
ifവ്യവസ്ഥ ശരി ആണെങ്കില്‍ ചെയ്യേണ്ടതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ —numberഇരട്ടസംഖ്യയാണെന്ന് പറയുക എന്നത്. ഈ ഒരു വരി മാത്രം (ഒന്‍പതാമത്തെ വരി) അതുകൊണ്ട് നാലു സ്പേസ് വലത്തേക്ക് തള്ളി എഴുതിയിരിക്കുന്നു. -
elseവരിയുടെ വ്യാകരണം ഇതാണ്:else :.elseകഴിഞ്ഞുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക . -
else-ന്റെ അതേ നിരപ്പില്‍ എഴുതിയിട്ടുള്ള, തൊട്ടു മുന്‍പുള്ളifവരിയുടെ വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങളാണ്elseവരി കഴിഞ്ഞ് എഴുതേണ്ടത്. ഇത് ഒന്നിലധികം വരികളും ആവാം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈelseവരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. - മുകളിലെ ഉദാഹരണത്തില്‍ പൈത്തണ്‍ മാനകത്തിനനുസരിച്ച് നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (പതിനൊന്നാമത്തെ വരി).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍
else :എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. പരീക്ഷിച്ചു നോക്കുക. ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കപ്പോഴും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. -
if-ല്‍ പരിശോധിച്ച വ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരിifവരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലതേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം.ifവ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ കാര്യങ്ങള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത്else-നു ശേഷവുംelse-ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. - മുകളിലെ ഉദാഹരണത്തില്‍
ifവ്യവസ്ഥ തെറ്റാണെങ്കില്‍ ചെയ്യേണ്ടതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ —numberഒറ്റസംഖ്യയാണെന്ന് പറയുക എന്നത്. ഈ ഒരു വരി മാത്രം (പതിനൊന്നാമത്തെ വരി) അതുകൊണ്ട് നാലു സ്പേസ് വലത്തേക്ക് തള്ളി എഴുതിയിരിക്കുന്നു. - ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
-
if ... else-ലെelseആവശ്യമില്ലെങ്കില്‍ വിട്ടുകളയാവുന്നതാണ് (optional). (തികച്ചും കൃത്രിമമായ ഒരു) ഉദാഹരണമായി, തന്നിരിക്കുന്ന സംഖ്യ ഇരട്ടസംഖ്യയാണെങ്കില്‍ അത് വിളിച്ചുപറയുകയും ഒറ്റസംഖ്യയാണെങ്കില്‍ ഒന്നും പറയാതിരിക്കുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഇതാ:
123456789# When the given number is even, this program reports that# fact. Otherwise it does not report anything. Used to# demonstrate an "if" without a corresponding "else" part.# It is assumed that the input number is an integer!number=input("Please input an integer: ")if(number%2)==0:printnumber," is an even number"
ഒറ്റയും ഇരട്ടയും സംഖ്യകള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുമ്പോള്‍ എന്താണ് സംഭവിക്കുന്നത് എന്ന് പ്രവര്‍ത്തിപ്പിച്ചു കണ്ടുപിടിക്കൂ.
തുലന സംകാരകങ്ങള്‍
ഒരു സംഖ്യ ഒറ്റയോ ഇരട്ടയോ എന്ന് കണ്ടുപിടിക്കാനുള്ള പ്രോഗ്രാമില്‍ നാം
== എന്ന തുല്യത പരിശോധിക്കാനുള്ള സംകാരകം (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) കടന്നു വരുമെന്ന് ഉറപ്പിക്കാം. അതുകൊണ്ടു തന്നെ ഇനി നാം എഴുതുന്ന പ്രോഗ്രാമുകളിലെല്ലാം ഒരു തുലനസംകാരകമെങ്കിലും ഉപയോഗിക്കേണ്ടി വരും എന്ന് നിസ്സംശയം പറയാം. തുലനസംകാരകങ്ങള്‍ ശരിയായി പ്രയോഗിക്കേണ്ടതെങ്ങനെ എന്ന് അനവധി ഉദാഹരണങ്ങളിലൂടെ നമുക്ക് പഠിച്ചെടുക്കാം.
ഒരു സംഖ്യ ന്യൂനസംഖ്യയാണോ, അധിസംഖ്യയാണോ, ഇനി ഇതു രണ്ടുമല്ല പൂജ്യമാണോ എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം നമുക്കൊന്ന് എഴുതി നോക്കാം:
1
2
3
4
5
6
7
8
9
10
11
12
13
| # This program tells if a given number is negative, zero, or# positive. The program demonstrates the use of the "if# ... else" program construct.number = input("Please input a number: ")if number < 0 : print number, " is a negative number"else : if number == 0 : print number, " is zero" else : print number, " is a positive number" |
ഈ പ്രോഗ്രാമില്‍ പല അളവില്‍ സ്പേസ് വിട്ട് വരികള്‍ എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. മുകളില്‍ക്കൊടുത്ത വിശദീകരണം അനുസരിച്ച് ഇത് മനസ്സിലാക്കാന്‍ ശ്രമിക്കുക. സംശയമുണ്ടെങ്കില്‍ ചോദിക്കുക.
ജനിച്ച വര്‍ഷം കണ്ടുപിടിക്കുന്നതെങ്ങനെ? രണ്ടാം പതിപ്പ്
ജോണ്‍, ഹരിമാരുടെ പ്രശ്നം പരിഹരിക്കുന്ന പ്രോഗ്രാം എഴുതാന്‍ വേണ്ടത്ര പൈത്തണ്‍ നാം പഠിച്ചുകഴിഞ്ഞു. പാഠത്തിന്റെ മൂന്നാം ഭാഗത്ത് കൊടുത്ത ലോജിക് ഒരു പ്രോഗ്രാമാക്കി ഒന്ന് എഴുതി നോക്കിയാലോ? ലോജിക് വിശദമായിത്തന്നെ നാം എഴുതിയതുകൊണ്ട് ഇത് പ്രോഗ്രാമാക്കുക എന്നത് തികച്ചും അനായാസം തന്നെ. കുറച്ചു വലിയ പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള ഏറ്റവും എളുപ്പ വഴിയും ഇതു തന്നെയാണ്: ആദ്യം പ്രോഗ്രാമിന്റെ ലോജിക് നമുക്കിഷ്ടമുള്ള ഭാഷയില്‍ എഴുതുക. പിന്നെ അതിന്റെ ഓരോ ഭാഗവും പൈത്തണിലേക്ക് മൊഴിമാറ്റം നടത്തുക. ഒരു വലിയ പ്രോഗ്രാം ഒറ്റയടിക്ക് പൈത്തണില്‍ എഴുതുന്നതിലും എളുപ്പം — തെറ്റുകള്‍ കുറയ്ക്കാനുള്ള എളുപ്പ വഴിയും — ഇങ്ങനെ ചെയ്യുന്നതാണ്.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| # This program asks for the name and age in years and months# of the user, and outputs the year when the user was born.name = raw_input("Hello, what is your name? ")print name, ", please tell me your age in years and months."years = input("How many years? ")months = input("And how many months? ")current_year = 2010current_month = 8if months < current_month : year_of_birth = current_year - yearselse : year_of_birth = current_year - years - 1print name, ", you were born in ", year_of_birthprint "Goodbye!" |
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 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 ഇവ മൂന്നിന്റേയും ഗുണിതമാണോ എന്ന് പരിശോധിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതി നോക്കാം:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| # This program tells if a given number is a multiple of 2,# 3, and 5. The program demonstrates the use of the "if# ... else" program construct.number = input("Please input a number: ")if (number % 2) == 0 : if (number % 3) == 0 : if (number % 5) == 0 : print number, " is a multiple of 2, 3, and 5" else : print number, " is not a multiple of 2, 3, and 5" else : print number, " is not a multiple of 2, 3, and 5"else : print number, " is not a multiple of 2, 3, and 5" |
പ്രവര്‍ത്തനം
- പ്രവ. 6.
-
ഈ പ്രോഗ്രാം ശ്രദ്ധിച്ച് വായിക്കുക. ഇവിടെ സ്പേസ് ഉപയോഗിച്ചിരിക്കുന്ന രീതി ശരിക്ക് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. ഓരോ
if-ന്റെയുംelseഏതാണ്? ഈ പ്രോഗ്രാമിന്റെ ലോജിക് എന്താണ്?
ഇതേ പ്രശ്നത്തിന് ഉത്തരം തരുന്ന മറ്റൊരു പ്രോഗ്രാം നോക്കൂ. പല പ്രാവശ്യം "if ..." എന്നെഴുതുന്നതിനു പകരം ഇവിടെ "and" ഉപയോഗിച്ചിരിക്കുന്നു. ഫലമോ? മുമ്പത്തെ പ്രോഗ്രാമിന്റെയത്ര ദൈര്‍ഘ്യമില്ലാത്തതും വായിച്ചു മനസ്സിലാക്കാന്‍ അത്രതന്നെ പ്രയാസപ്പെടേണ്ടാത്തതുമായ ഒരു പ്രോഗ്രാം. പ്രോഗ്രാമിലെ ഏഴാമത്തെ വരി അധികം വലത്തേക്ക് നീണ്ടു പോകാതിരിക്കാനായി (ബ്രൗസറില്‍ വായിക്കാനുള്ള സൗകര്യത്തിനായി മാത്രം) "\" ഉപയോഗിച്ച് രണ്ടായി മുറിച്ചിരിക്കുന്നു:
1
2
3
4
5
6
7
8
9
10
11
| # This program tells if a given number is a multiple of 2,# 3, and 5. The program demonstrates the use of the "and"# boolean operator.number = input("Please input a number: ")if (number % 2) == 0 and (number % 3) == 0 \ and (number % 5) == 0 : print number, " is a multiple of 2, 3, and 5"else : print number, " is not a multiple of 2, 3, and 5" |
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 7.
- തന്നിരിക്കുന്ന സംഖ്യ 2, 3, 5 ഇവയില്‍ ഒന്നിന്റെയെങ്കിലും ഗുണിതമാണോ എന്ന് പരിശോധിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതുക. ഇതിനായി "or" എന്ന ബൂളിയന്‍ സംകാരകം ഉപയോഗിക്കുക.
- പ്രവ. 8.
- ഏഴാം പ്രവര്‍ത്തനത്തിലെ അതേ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം "or" ഉപയോഗിക്കാതെ എഴുതുക.
ദ്വിമാന സമവാക്യത്തിന്റെ മൂലം കാണാനുള്ള ഒരു പ്രോഗ്രാം binudigitaleye എന്ന വായനക്കാരന്‍ കമന്റായിട്ടത് ചെറിയ മാറ്റങ്ങളോടെ താഴെ എടുത്തെഴുതുന്നു. IDLE ഉപയോഗിച്ച് ഇത് പല പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കുക, a, b, c എന്നിവയ്ക്ക് പല വിലകള്‍ (ന്യൂനസംഖ്യകളും ദശാംശ സംഖ്യകളും ഉള്‍പ്പടെ) കൊടുത്തു നോക്കൂ. ശരിയായ ഉത്തരം കിട്ടുന്നുണ്ടോ?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| # This program finds the roots of a quadratic equation using# the famous quadratic formula. It takes as input the# coefficients a, b, and c of the equation ax^2 + bx + c = 0print " A program that finds the roots of the quadratic \ equation"print " ax^2+bx+c=0 where a is not 0"a = input("a = ")b = input("b = ")c = input("c = ")# Find the value of the discriminant.d = b**2 - 4*a*cif d < 0 : print "The equation does not have real roots."else : if d == 0 : print " The two roots of the equation coincide." print " The single value of the roots is: " , \ -b/(2*a) else : # Find the square root of d (how?) sqrt_d = d ** (1.0/2) print " One root of the equation is: " , \ (-b + sqrt_d)/(2*a) print " The other root is: " , (-b - sqrt_d)/(2*a) |
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 9.
- (മിശ്ര സംഖ്യകളെ പരിചയമുള്ളവര്‍ക്ക് മാത്രം) ഈ പ്രോഗ്രാം രേഖീയ സംഖ്യകള്‍ (real numbers) മൂലങ്ങളായി വരുന്ന ദ്വിമാന സമവാക്യങ്ങളെ മാത്രമെ ശരിയായി പരിഗണിക്കുന്നുള്ളൂ; മിശ്ര സംഖ്യകള്‍ (complex numbers) മൂലങ്ങളായി വരുന്ന ദ്വിമാന സമവാക്യങ്ങളെ ഒഴുക്കന്‍മട്ടില്‍ അവഗണിച്ചിരിക്കുകയാണ്. ഈ കുറവ് പരിഹരിക്കുക; (ഉദാഹരണമായി) a = 1, b = -2, c = 2 എന്ന ഇന്‍പുട്ട് കിട്ടിയാല്‍ 1 + 1.0 i, 1 - 1.0 i എന്നീ ഉത്തരങ്ങള്‍ തരുന്ന രീതിയില് പ്രോഗ്രാമിനെ മാറ്റുക.
കൂടുതല്‍ പ്രവര്‍ത്തനങ്ങള്‍
if -നെ പരിചയപ്പെട്ട നിലയ്ക്ക് ഇനി നമുക്ക് കൂടുതല്‍
രസകരങ്ങളായ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തു തുടങ്ങാം. പ്രോഗ്രാമിംഗ്
പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്യുമ്പോള്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടതായ ഒരു
കാര്യമുണ്ട്: വെറുതേ പ്രോഗ്രാം എഴുതിയതുകൊണ്ടു മാത്രം പ്രവര്‍ത്തനത്തിന്റെ ഫലം നമുക്ക് കിട്ടുന്നില്ല.
എഴുതിയ പ്രോഗ്രാമിന് ശരിയായ എന്ത് ഇന്‍പുട്ട് കൊടുത്താലും അത് ശരിയായ
ഉത്തരം തരും എന്ന് ഉറപ്പു വരുത്തണം. ഇതിനായി രണ്ടു കാര്യങ്ങള്‍ ചെയ്യണം:- പ്രോഗ്രാം വളരെ ശ്രദ്ധയോടെ, വിമര്‍ശനബുദ്ധ്യാ വായിച്ചുനോക്കണം. നാമെഴുതിയ പ്രോഗ്രാം എന്തുകൊണ്ട് ശരിയാണ് എന്നല്ല നോക്കേണ്ടത്, മറിച്ച് അതിലെ തെറ്റ് എവിടെയാണ് എന്നാണ്. ഇങ്ങനെ കണിശതയോടെ സ്വന്തം പ്രോഗ്രാം വായിക്കാന്‍ പഠിക്കുക എന്നത് തെറ്റില്ലാതെ പ്രോഗ്രാം എഴുതാന്‍ ഒഴിച്ചുകൂടാനാവാത്ത ഒന്നാണ്.
- പ്രോഗ്രാമിന് പല തരത്തിലുള്ള ഇന്‍പുട്ടുകള്‍ കൊടുത്ത് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കണം. നാം തന്നെ എഴുതിയ പ്രോഗ്രാം ആയതുകൊണ്ട് അത് ശരിയായ ഉത്തരം തരുന്ന മട്ടിലുള്ള ഇന്‍പുട്ടുകള്‍ കൊടുക്കാനാണ് നമുക്ക് സ്വതവേ തോന്നുക. എന്നാല്‍ ഇങ്ങനെയല്ലാത്ത, പ്രോഗ്രാം തെറ്റിപ്പോകാന്‍ സാധ്യതയുള്ള തരം ഇന്‍പുട്ടുകളും ആലോചിച്ചെടുത്ത് അവ പ്രോഗ്രാമിന് കൊടുത്തുനോക്കണം.
ഇതു വരെ പഠിച്ച പൈത്തണ്‍ ഉപയോഗിച്ച് ചെയ്യാവുന്ന കുറച്ച് പ്രവര്‍ത്തനങ്ങള്‍ ഇതാ:
പ്രവര്‍ത്തനങ്ങള്‍
താഴെപ്പറയുന്ന തരം പ്രോഗ്രാമുകള്‍ എഴുതുക:- പ്രവ. 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.
-
- ഇന്‍പുട്ട്: മൂന്നു സംഖ്യകള്‍.
- ഔട്പുട്ട്: തന്നിരിക്കുന്നതില്‍വെച്ച് ഏറ്റവും ചെറിയ സംഖ്യ.
പൈത്തണ്‍: പാഠം ആറ്
>> Thursday, September 2, 2010
ആമുഖം
1, 2, 3, ... മുതലായ, എണ്ണാനുപയോഗിക്കുന്ന സംഖ്യകളെയാണല്ലോ എണ്ണല്‍സംഖ്യകള്‍ എന്നു വിളിക്കുന്നത്? "സംഖ്യ" എന്ന് വിളിക്കപ്പെടുന്നവയില്‍ ഏറ്റവും ലളിതവും സുഗ്രാഹ്യവുമായവ എണ്ണല്‍സംഖ്യകളാണ്. എണ്ണല്‍സംഖ്യകളെ പരിചയമില്ലാത്ത മുതിര്‍ന്ന ഒരാള്‍പോലും ഉണ്ടാവില്ല; അക്ഷരമറിയാത്തവര്‍ക്കുപോലും എണ്ണല്‍ അറിയുമായിരിക്കും. നമ്മുടെ സമൂഹത്തില്‍ ജീവിച്ചുപോകണമെങ്കില്‍ എണ്ണല്‍ അറിയാതെ നിവൃത്തിയില്ല. നന്നേ ചെറുപ്രായത്തില്‍ത്തന്നെ മറ്റുള്ളവര്‍ നമ്മെ എണ്ണാന്‍ പഠിപ്പിക്കുന്നു. എന്തിന്റെയെങ്കിലുമൊക്കെ എണ്ണം ചോദിക്കുന്നത് കുട്ടികളോടുള്ള കൊഞ്ചലിന്റെതന്നെ ഭാഗമാണ്.
എണ്ണുന്നതിന്റെ അത്രത്തോളം തന്നെ ലളിതവും സ്വാഭാവികവുമാണ് നമ്മില്‍ മിക്കവര്‍ക്കും സങ്കലനം — രണ്ടു സംഖ്യകള്‍ കൂട്ടി ഒരു സംഖ്യയാക്കുക — എന്ന ക്രിയയും. സ്കൂളില്‍ നന്നേ ചെറിയ ക്ളാസില്‍ത്തന്നെ ഇത് പഠിപ്പിക്കുന്നു. സംഖ്യകള്‍ ശരിക്കു കൂട്ടാന്‍ അറിയാതെ സ്കൂളില്‍ "പഠിച്ച്" ഇറങ്ങുന്നവരും പുറംലോകത്ത് എന്തെങ്കിലുമൊക്കെ ജോലിചെയ്തു ജീവിച്ചുതുടങ്ങുമ്പോള്‍ കൂട്ടലും കിഴിക്കലുമൊക്കെ തനിയേ പഠിച്ചുപോകുന്നു. എന്നാല്‍ സങ്കലനത്തിന്റെ അത്രതന്നെ എളുപ്പമല്ല അടുത്ത ക്രിയയായ ഗുണനം — ചെറുപ്പത്തില്‍ ഗുണനപ്പട്ടിക കാണാതെ പഠിക്കാന്‍ പെട്ട പാടും കിട്ടിയ ശിക്ഷകളുമൊക്കെ നമ്മില്‍ ചിലര്‍ക്കെങ്കിലും ഓര്‍മ്മകാണും. സംഖ്യകളെടുത്ത് പെരുമാറി — സ്കൂളിലെന്നതിലുപരി പുറത്ത്: മിക്കവാറും ക്രിക്കറ്റില്‍ സ്കോര്‍ ഗണിച്ചെടുത്തും മറ്റും — കുറേ പരിചയം വരുമ്പോള്‍ ഗുണനത്തെ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമായി കാണാന്‍ നാം അറിയാതെ പഠിക്കുന്നു.
ഗുണനമെന്നാല്‍ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമാണെങ്കിലും രണ്ടിന്റെയും സ്വഭാവങ്ങള്‍തമ്മില്‍ കാതലായ വ്യത്യാസങ്ങളുണ്ട്. ഉദാഹരണമായി, നാലോ അതിലധികമോ ആയ ഏത് എണ്ണല്‍സംഖ്യയെയും മറ്റുരണ്ട് എണ്ണല്‍സംഖ്യകളുടെ തുകയായി ഒന്നിലധികം രീതിയില് എഴുതാം. അതായത്,
- 4 = 1 + 3 = 2 + 2
- 5 = 1 + 4 = 2 + 3
- 10 = 1 + 9 = 2 + 8 = 3 + 7 = 4 + 6 = 5 + 5
അഭാജ്യസംഖ്യകള്‍
16-നെ 16 = 1 x 16 = 2 x 8 = 4 x 4 എന്നിങ്ങനെ ഗുണിതങ്ങളായി എഴുതാമല്ലോ. 1, 2, 4, 8, 16 എന്നിവയെ 16-ന്റെ ഘടകങ്ങള്‍ (factors) എന്ന് വിളിക്കുന്നു. ഇതുപോലെ 21-നെ 21 = 1 x 21 = 3 x 7 എന്നിങ്ങനെ എഴുതാം; 1, 3, 7, 21 എന്നിവയാണ് 21-ന്റെ ഘടകങ്ങള്‍. ഏത് എണ്ണല്‍സംഖ്യയുടെയും ഘടകമായി 1-ഉം ആ സംഖ്യതന്നെയും ഉണ്ടാവും എന്ന് കുറച്ചൊന്നാലോചിച്ചാല്‍ മനസ്സിലാകും — 1-നെ അതിനോടുതന്നെ പല പ്രാവശ്യം കൂട്ടി ഏത് എണ്ണല്‍സംഖ്യയിലും എത്തിക്കാം; ഏത് എണ്ണല്‍സംഖ്യയും "ഒരു പ്രാവശ്യം കൂട്ടിയാല്‍" ആ സംഖ്യതന്നെയാണുതാനും.
കൃത്യം രണ്ടു ഘടകങ്ങള്‍ ഉള്ള സംഖ്യകളെ — മേല്‍പ്പറഞ്ഞതില്‍നിന്ന് ഈ ഘടകങ്ങള്‍ 1-ഉം ആ സംഖ്യതന്നെയും ആയിരിക്കും എന്നത് വ്യക്തമാണ് — അഭാജ്യസംഖ്യകള്‍ അല്ലെങ്കില് അഭാജ്യങ്ങള്‍ എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന് 2, 3, 5, 7 എന്നിവ അഭാജ്യങ്ങളാണ്. 2 = 1 x 2, 3 = 1 x 3, 5 = 1 x 5, 7 = 1 x 7 എന്നിങ്ങനെ നിസ്സാരമായ (trivial) ഒരേ ഒരു രീതിയിലല്ലാതെ ഈ സംഖ്യകളെ ഗുണനഫലങ്ങളായി എഴുതാന്‍ പറ്റില്ലല്ലോ. വേറൊരു രീതിയില് നോക്കിയാല്‍, ഇവയെ നിസ്സാരമായ രീതിയിലല്ലാതെ ഒരേ പൂര്‍ണ്ണസംഖ്യാവലുപ്പമുള്ള ഭാഗങ്ങളായി "മുറിക്കാന്‍" പറ്റില്ല. ഉദാഹരണത്തിന്, അഞ്ച് മാങ്ങകളെ ഒരു മാങ്ങ വീതമുള്ള അഞ്ച് കൂട്ടങ്ങളാക്കാം; ഒരേ എണ്ണം വീതമുള്ള പല കൂട്ടങ്ങളാക്കാന്‍ മറ്റൊരു രീതിയിലും പറ്റില്ല. "അഭാജ്യം" എന്ന പേരിന് കാരണവും ഇതുതന്നെ. നൂറിനെക്കാള്‍ ചെറുതായ അഭാജ്യങ്ങളെ താഴെ എടുത്തെഴുതുന്നു.
നൂറില്‍ താഴെയുള്ള അഭാജ്യങ്ങള്‍ 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
ഇങ്ങനെയൊരു പട്ടിക നമുക്കെങ്ങനെയുണ്ടാക്കാം? 1 മുതല്‍ 100 വരെയുള്ള സംഖ്യകള്‍ ഓരോന്നും അഭാജ്യമാണോ എന്ന് നോക്കിയാല്‍ മതി. 2 ഒഴികെയുള്ള ഇരട്ടസംഖ്യകളൊന്നും തന്നെ അഭാജ്യങ്ങളല്ലാത്തതുകൊണ്ട് 1 മുതല്‍ 100 വരെയുള്ളതില്‍ പകുതി സംഖ്യകളെപ്പറ്റി അധികം പ്രയാസപ്പെടാതെതന്നെ നമുക്കൊരു തീരുമാനമുണ്ടാക്കാം : 2-നെ പട്ടികയില്‍ പെടുത്തണം, മറ്റ് ഇരട്ടസംഖ്യകളൊന്നുംതന്നെ പട്ടികയില്‍ വേണ്ട. ഇനി ബാക്കിയുള്ള അമ്പത് ഒറ്റ സംഖ്യകളെപ്പറ്റി മാത്രം ആലോചിച്ചാല്‍ മതി. ഇവയില്‍ 1-നെ പട്ടികയില്‍ വേണ്ട, 3, 5, 7 എന്നിവയെ വേണം. അവശേഷിക്കുന്ന ഒറ്റസംഖ്യകളില്‍ 3-ന്റെയും 5-ന്റെയും ഗുണിതങ്ങളെ നമുക്ക് വേഗം തിരിച്ചറിഞ്ഞ് ഒഴിവാക്കാം (എങ്ങനെ?). ബാക്കിയുള്ള ഒറ്റസംഖ്യകളുടെ കാര്യമാണ് അത്ര എളുപ്പം കിട്ടാത്തത്. ഉദാഹരണത്തിന്, 67-നെ അതിനെക്കാള്‍ ചെറിയ ഏതെങ്കിലും സംഖ്യകൊണ്ട് പൂര്‍ണ്ണമായും ഹരിക്കാമോ എന്ന് എങ്ങനെ കണ്ടുപിടിക്കും? ഹരിച്ചുനോക്കുകയേ നിവൃത്തിയുള്ളൂ (എനിക്കറിയാവുന്നിടത്തോളം). ഇങ്ങനെ കുറച്ചു കഷ്ടപ്പെട്ടാല്‍ മേല്‍ക്കൊടുത്ത പട്ടികയുണ്ടാക്കാം.
ഇനി 100 മുതല്‍ 200 വരെയുള്ള അഭാജ്യങ്ങളേതാണെന്ന് ചോദിച്ചാലോ? 1000 വരെയുള്ളതാണെങ്കിലോ? ഇതേ രീതിയില്‍ത്തന്നെ കണ്ടുപിടിക്കണം. ഓരോ പുതിയ സംഖ്യയും അഭാജ്യമാണോ എന്ന് നോക്കാനുള്ള ബുദ്ധിമുട്ട് ഏറിയേറി വരും. എവിടെയെങ്കിലും ഒരു തെറ്റുവരുത്താനുള്ള സാധ്യത നല്ലതുപോലെയുണ്ടുതാനും. ചുരുക്കിപ്പറഞ്ഞാല്‍, ലളിതമായ എന്നാല്‍ മടുപ്പിക്കുന്ന പണിക്കുള്ള നല്ല ഒരുദാഹരണം. കംപ്യൂട്ടറിന് ഏറ്റവും ശോഭിക്കാവുന്നതും ഇങ്ങനെയുള്ള കാര്യങ്ങളിലാണ്. മുകളിലെ പട്ടിക ഞാന്‍ മെനക്കെട്ട് കണ്ടുപിടിച്ചതല്ല. മുകളില്‍ വിവരിച്ച അതേ ലോജിക് അനുസരിച്ചുള്ള ഒരു പ്രോഗ്രാം എഴുതി കംപ്യൂട്ടറിനെക്കൊണ്ട് ചെയ്യിച്ചതാണ്. ഈ പ്രോഗ്രാം ഉപയോഗിച്ച് അഭാജ്യങ്ങളുടെ പട്ടികയുണ്ടാക്കാന്‍ കംപ്യൂട്ടര്‍ വളരെക്കുറച്ച് സമയമേ എടുത്തുള്ളൂ: സെക്കന്റിന്റെ പത്തിലൊരംശമോ മറ്റോ. അതായത്, നാം ഈ പട്ടിക വായിക്കാന്‍ എടുക്കുന്ന സമയത്തിന്റെ നൂറിലൊരംശമോ അതില്‍ കുറവോ മാത്രം.
ഇതേ പ്രോഗ്രാമില്‍ ചെറിയ മാറ്റങ്ങള്‍ വരുത്തി 100 മുതല്‍ 200 വരെയുള്ള അഭാജ്യങ്ങള്‍ കണ്ടുപിടിച്ചത് ഇതാ:
നൂറിനും ഇരുനൂറിനും ഇടയ്ക്കുള്ള അഭാജ്യങ്ങള്‍ 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
ഒരു പൂര്‍ണ്ണസംഖ്യ അഭാജ്യമാണോ എന്ന് പ്രോഗ്രാമെഴുതി എങ്ങനെ കണ്ടുപിടിക്കാം? ഏറ്റവും ലളിതമായ വഴി ആ സംഖ്യയെക്കാള്‍ ചെറുതും 1-നെക്കാള്‍ വലുതുമായ ഏതെങ്കിലും പൂര്‍ണ്ണസംഖ്യകൊണ്ട് അതിനെ നിശ്ശേഷം (നിശ്ശിഷ്ടം?) ഹരിക്കാമോ എന്ന് നോക്കുക എന്നതാണ്. ഉദാഹരണത്തിന് 5 അഭാജ്യമാണോ എന്ന് നോക്കുന്ന പ്രോഗ്രാം ഇതാ:
1234if5%2==0or5%3==0or5%4==0:print"5 is not a prime"else:print"5 is a prime"
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 1.
- ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. ഇത് ശരിയായ ഉത്തരം തരുന്നുണ്ടോ? ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നതെങ്ങനെ എന്ന് മനസ്സിലാക്കുക.
- പ്രവ. 2.
- ഇതേ രീതിയില് 15 അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.
ഈ പ്രോഗ്രാമിന് എന്താണു കുഴപ്പം?
രണ്ടു പ്രവര്‍ത്തനങ്ങളും ചെയ്തുനോക്കിയാല്‍ മുകളിലെ ഉദാഹരണത്തിന് എന്താണ് കുഴപ്പമെന്ന് മനസ്സിലാകും. ഒരു വലിയ സംഖ്യ (ഉദാ: 1234787) അഭാജ്യമാണോ എന്ന് ഈ രീതിയില് പ്രോഗ്രാമെഴുതി കണ്ടുപിടിക്കുന്ന കാര്യം ആലോചിച്ചുനോക്കൂ. പേജുകണക്കിന് വരുന്ന വളരെ വലിയ ഒരു പ്രോഗ്രാമായിരിക്കും അത്. ചില സംഖ്യകളൊക്കെ എഴുതാന്‍ വിട്ടുപോകുന്നതുവഴി പ്രോഗ്രാമില്‍ തെറ്റുവരാനുള്ള സാധ്യതയും കൂടുതലാണ്. 101 മുതല്‍ 200 വരെയുള്ള അഭാജ്യസംഖ്യകള്‍ ഏതൊക്കെയാണെന്ന് കണ്ടുപിടിക്കാന്‍ ഇങ്ങനെ പ്രോഗ്രാമെഴുതണമെങ്കില്‍ ഒരു ദിവസം മുഴുവന്‍ ഇരുന്നെഴുതേണ്ടിവരും; എഴുതിക്കഴിഞ്ഞാലും അത് ശരിയാണോ എന്ന് നമുക്ക് വലിയ ഉറപ്പൊന്നും കാണുകയുമില്ല — ഏതെങ്കിലുമൊക്കെ സംഖ്യകള്‍കൊണ്ട് ഹരിച്ചാലുള്ള ശിഷ്ടം പൂജ്യമാണോ എന്നുനോക്കാന്‍ ഇടയ്ക്കെങ്ങാനും വിട്ടുപോയിട്ടില്ല എന്ന് എങ്ങനെ ഉറപ്പിക്കും?
1234787 അഭാജ്യമാണ്. ഈ പാഠം പഠിച്ച് ഇതിലെ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുകഴിയുമ്പോഴേക്കും ഏതു സംഖ്യയും അഭാജ്യമാണോ എന്ന് പരിശോധിക്കുന്ന പ്രോഗ്രാമെഴുതാന്‍ നാം പഠിച്ചിരിക്കും.
നമ്മുടെ പ്രോഗ്രാമിന്റെ ലോജിക്കിനെപ്പറ്റി നമുക്ക് ഒന്നുകൂടി ഒന്ന് ആലോചിച്ചുനോക്കാം. 1-നെക്കാള്‍ വലുതും, തന്നിരിക്കുന്ന സംഖ്യയെക്കാള്‍ ചെറുതുമായ ഓരോ പൂര്‍ണ്ണസംഖ്യയെക്കൊണ്ടും തന്നിരിക്കുന്ന സംഖ്യയെ ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം പൂജ്യമാണോ എന്ന് നോക്കുക എന്നതാണ് പ്രോഗ്രാം ചെയ്യുന്നത്. ഇങ്ങനെ വലിയൊരുകൂട്ടം സംഖ്യകളെടുത്ത് പെരുമാറേണ്ടതുകൊണ്ടാണ് പ്രോഗ്രാമിന്റെ വലുപ്പം (അതെഴുതാനെടുക്കുന്ന സമയവും) തന്നിരിക്കുന്ന സംഖ്യ വലുതാകുന്തോറും വലുതായിക്കൊണ്ടേയിരിക്കുന്നത്. ഈ പ്രശ്നം പരിഹരിക്കാന്‍ (മറ്റനേകം ഉപയോഗങ്ങള്‍ക്കും) പൈത്തണില്‍ ലഭ്യമായ ഒരു ഉപാധിയാണ്
range() .range()
പൈത്തണില്‍ സംഖ്യകളുടെ സമാന്തരശ്രേണികള്‍ (arithmetic progressions) നിര്‍മ്മിക്കാനുള്ള ഒരു ഉപാധിയാണ് range() .
ഇതെന്താണെന്ന് മനസ്സിലാക്കാനുള്ള ഏറ്റവും എളുപ്പ വഴി (പ്രോഗ്രാമിംഗില്‍
മറ്റു മിക്ക കാര്യങ്ങള്‍ക്കുമെന്നതുപോലെ) ഇതിന്റെ പെരുമാറ്റം എങ്ങനെയാണ്
എന്ന് നോക്കുകയാണ്. പൈത്തണ്‍ ഷെല്‍ (IDLE-ലോ അല്ലാതെയോ) തുറന്ന്
താഴെക്കാണുന്ന പ്രോഗ്രാം ശകലങ്ങള്‍ ഓരോന്നായി പരീക്ഷിച്ചുനോക്കുക:range(10) |
range(25) |
range(1027) |
range() -ന്റെ ഒരു ഉപയോഗം മനസ്സിലായല്ലോ. പൂജ്യം മുതല്‍ സൂചിപ്പിച്ച സംഖ്യയ്ക്ക് തൊട്ടുമുമ്പുവരെയുള്ള പൂര്‍ണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണി range()
നമുക്ക് [, ] എന്നീ ചതുര ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി തരുന്നു. ഇങ്ങനെ
ചതുര ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളില്‍ അര്‍ധവിരാമം (കോമ : , ) ഉപയോഗിച്ച്
വേര്‍തിരിച്ച് മൂല്യങ്ങള്‍ എഴുതുന്നതിന് ലിസ്റ്റ് – list – എന്നതാണ്
പൈത്തണിലെ സാങ്കേതികപദം. range() മേല്‍ക്കാണിച്ചതുപോലെ ഉപയോഗിച്ച് പൂജ്യം മുതല്‍ ഏത് നിശ്ചിത സംഖ്യ വരെയുമുള്ള പൂര്‍ണ്ണസംഖ്യകളുടെ ലിസ്റ്റുകള്‍ നമുക്കുണ്ടാക്കാം. range() -ന് വേറെയും ചില കഴിവുകളുണ്ട്. ഇവയെന്താണെന്ന് മനസ്സിലാക്കാന്‍ താഴെക്കാണുന്നവ പരീക്ഷിച്ചുനോക്കുക: range(1, 10) |
range(7, 25) |
range(1, 10, 2) |
range(7, 25, 3) |
range(-100, 100, 2) |
range(99, -100, -3) |
ഓരോ പ്രാവശ്യവും ഏറ്റവും അവസാനം വരുന്ന സംഖ്യ ഏതാണെന്ന് പ്രത്യേകം ശ്രദ്ധിക്കുക.
പ്രവര്‍ത്തനം
- പ്രവ. 3.
- താഴെക്കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം ശകലങ്ങളുടെ ഔട്പുട്ട്
എന്തായിരിക്കും എന്ന് ഊഹിച്ചുനോക്കുക. ഊഹം കൃത്യമാണോ എന്ന്
പരീക്ഷിച്ചുനോക്കുക.
range(17)range(0,-10,-1)range(0,-10,1)range(0,65,7)range(10,10)
ഒരു സംഖ്യ — ഉദാഹരണത്തിന് 67 — അഭാജ്യമാണോ എന്നറിയാന്‍ നമ്മുടെ പ്രോഗ്രാം 2 മുതല്‍ 66 വരെയുള്ള ഏതെങ്കിലും പൂര്‍ണ്ണസംഖ്യകൊണ്ട് 67-നെ നിശ്ശിഷ്ടം ഹരിക്കാന്‍ പറ്റുമോ എന്ന് നോക്കുന്നു. അതായത്
range(2, 67) തരുന്ന ലിസ്റ്റിലുള്ള ഓരോ സംഖ്യകൊണ്ടും 67-നെ ഹരിച്ചുനോക്കുന്നു. range(2, 67) എന്ന് പ്രോഗ്രാമില്‍ പറഞ്ഞാല്‍ [2,3, ... , 66]
എന്ന ഈ ലിസ്റ്റ് നമുക്ക് കിട്ടും. എന്നാല്‍ ഈ ലിസ്റ്റിലുള്ള സംഖ്യകള്‍
ഓരോന്നായി എങ്ങനെ കൈയ്യില്‍ക്കിട്ടും? ഇങ്ങനെ ഓരോന്നായി കിട്ടിയാലല്ലേ
ഓരോന്നുകൊണ്ടും ഹരിച്ചുനോക്കാന്‍ കഴിയൂ? ഒരു ലിസ്റ്റിലുള്ള മൂല്യങ്ങളെ
ഓരോന്നായി എടുത്ത് പ്രയോഗിക്കാന്‍ പാകത്തില്‍ നമുക്കു തരുന്ന പൈത്തണ്‍
ഭാഷാപ്രയോഗമാണ് for .ലിസ്റ്റുകളും for-ഉം
മുമ്പു പറഞ്ഞതുപോലെ, [, ] എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി മൂല്യങ്ങളെ കോമയിട്ട് വേര്‍തിരിച്ച് എഴുതുന്നതിനെയാണ് പൈത്തണില്‍ ലിസ്റ്റ് എന്ന് വിളിക്കുന്നത്. വളരെ ലളിതമായ ഒരു ആശയമാണ് ഇതെങ്കിലും പ്രോഗ്രാം എഴുതുന്നതില്‍ വളരെയധികം ഉപയോഗപ്പെടുന്ന ഒന്നാണ് ലിസ്റ്റ്. ഒന്നാലോചിച്ചാല്‍ ഇതില്‍ വലിയ അത്ഭുതമൊന്നുമില്ല: ദൈനംദിന ജീവിതത്തിലും വിവരങ്ങള്‍ സൂക്ഷിച്ചുവെയ്ക്കാന്‍ നാമുപയോഗിക്കുന്ന ചുരുക്കം ചില ഉപാധികളില്‍ പ്രധാനപ്പെട്ടതാണ് ലിസ്റ്റ്. കടയില്‍ നിന്ന് വാങ്ങേണ്ട സാധനങ്ങള്‍, ഫോണ്‍ നമ്പരുകള്‍ (ഡയറിയിലായാലും മൊബൈല്‍ ഫോണിലായാലും), കല്ല്യാണത്തിനു വിളിക്കേണ്ട ആളുകളുടെ വിവരങ്ങള്‍, എന്നിങ്ങനെ ഒന്നിലധികം വിവരങ്ങള്‍ ഉള്ള മിക്കയിടത്തും അവയെ നാം ലിസ്റ്റായി ആണ് രേഖപ്പെടുത്താറ്. ലിസ്റ്റല്ലാതെ ഈ ആവശ്യത്തിന് ഉപയോഗിച്ച് കണ്ടുവരുന്ന ഏക ഉപാധി പട്ടിക (table) ആണ്. ഇതാകട്ടെ ഓഫീസുകളിലോ പഠനസംബന്ധിയായ പ്രമാണങ്ങളിലോ മാത്രമേ കാണാറുള്ളൂ: ഔപചാരികമല്ലാത്ത കാര്യങ്ങള്‍ക്ക് പട്ടികകള്‍ ഉപയോഗിക്കാറില്ലെന്നുതന്നെ പറയാം.
പൈത്തണില്‍ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കാന്‍ ചെയ്യേണ്ടത് ഇത്രമാത്രം: ലിസ്റ്റില്‍ വരേണ്ട മൂല്യങ്ങളെ കോമകൊണ്ട് വേര്‍തിരിച്ച് [, ] എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി എഴുതുക. കുറച്ച് ഉദാഹരണങ്ങള്‍:
-
['Bhama', 'Hari', 'Nizar', 'John',] -
[1, 'Thiruvananthapuram', 2, 'Kollam', 3, 'Pathanamthitta'] -
[1, ['a', 'b', 'c'], 'd'] -
range()സമാന്തരശ്രേണികളെ ഇങ്ങനെ ലിസ്റ്റ് രൂപത്തില്‍ തരുന്നത് മുകളില്‍ കണ്ടല്ലോ.
for . ഇതിന്റെ ഉപയോഗം എങ്ങനെയാണെന്നറിയാന്‍ താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പരീക്ഷിച്ചുനോക്കുക.
1
2
3
4
| print range(0,10)for number in range(0, 10) : print 'Hello!' |
1
2
| for number in range(0, 10) : print number |
1
2
3
4
5
6
| for name in ['John', 'Vijayan', 'Muraleekrishnan', \ 'Muraleedharan', 'Lalitha', 'Sathyabhama', 'Shemi',\ 'Sreenadh', 'Sankaran', 'Ramanunni', 'Revi', 'Nidhin',\ 'Hari', 'Nizar', 'Janardanan', 'Jomon'] : print name, ' is a member of the Maths Blog Team' |
1
2
3
| for number in range(1, 50) : if (number % 2) == 0 : print number, " is an even number." |
1
2
3
4
5
| sum = 0for number in range(1, 100) : sum = sum + numberprint 'The sum of the integers from 1 to 99 is ', sum |
1
2
3
4
5
6
| sum = 0for number in range(1, 100) : if (number % 2) == 1 : sum = sum + numberprint 'The sum of the odd integers from 1 to 99 is ', sum |
for-നെപ്പറ്റി വിശദമായി
for പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം: -
forവരിയുടെ (ലഘുവായ) വ്യാകരണം ഇതാണ്:for variable in list :. പേരുസൂചിപ്പിക്കുന്നതുപോലെ ഇവിടെvariableഎന്നത് ഒരു ചരവുംlistഎന്നത് ഒരു ലിസ്റ്റുമാണ്. ഉദാഹരണങ്ങളില്‍ കാണുന്നതുപോലെ ലിസ്റ്റ് എന്നത് ഇവിടെ [, ] എന്നിവ ഉപയോഗിക്കുന്ന അക്ഷരാര്‍ത്ഥത്തിലുള്ള ഒരു ലിസ്റ്റോ, അതല്ലെങ്കില്‍ ഒരു ലിസ്റ്റ് മൂല്യമായി കിട്ടുന്ന ഒരു വ്യഞ്ജകമോ (expression) — ഉദാഹരണം:range()-ന്റെ ഏതെങ്കിലും പ്രയോഗം — ആകാം.listകഴിഞ്ഞുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക. -
forവരി കഴിഞ്ഞുവരുന്ന വരികളില്‍for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ (ഒന്നോ അതിലധികമോ) എഴുതണം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈforവരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. - മുകളിലെ ഉദാഹരണങ്ങളില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത്. ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍
:എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. -
listഎന്ന ലിസ്റ്റില്‍ എത്ര അംഗങ്ങളുണ്ടോ, അത്രയും തവണfor-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളെല്ലാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ്for-ന്റെ അടിസ്ഥാന സ്വഭാവം. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയാല്‍ ഇത് വ്യക്തമായി മനസ്സിലാകും. - ഇങ്ങനെ
for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഓരോ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോഴുംvariableഎന്ന ചരത്തിന്റെ വിലlistഎന്ന ലിസ്റ്റിലെ ഓരോ അംഗത്തിന്റെയും വിലയായി ക്രമത്തില്‍ തനിയെ മാറുന്നു:
- ആദ്യത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ ആദ്യത്തെ അംഗത്തിന്റെ വിലയാണ്. - രണ്ടാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ രണ്ടാമത്തെ അംഗത്തിന്റെ വിലയാണ്. - മൂന്നാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ മൂന്നാമത്തെ അംഗത്തിന്റെ വിലയാണ്. - അങ്ങനെയങ്ങനെ ...
- ആദ്യത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
-
for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളില്‍variableഎന്ന ചരത്തിനെ ക്രിയകളിലും മറ്റും ചരങ്ങള്‍ സാധാരണ ഉപയോഗിക്കുന്നതുപോലെ ഉപയോഗിക്കാം. നാലു മുതല്‍ ആറു വരെ ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും. -
for-ന്റെ പരിധിയില്‍ വരേണ്ടുന്ന — ലിസ്റ്റിലെ അംഗങ്ങളുടെ എണ്ണത്തിന്റെ അത്രതവണ പ്രവര്‍ത്തിപ്പിക്കേണ്ടുന്ന — വരികള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരിforവരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം.for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത്for-നു ശേഷവുംfor-ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. അഞ്ചും ആറും ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും. - ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
- ഇക്കാര്യങ്ങളിലെല്ലാം മുമ്പത്തെ പാഠത്തില്‍ നാം പരിചയപ്പെട്ട
if-ന്റെ ഘടനയുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക. - നാലും ആറും ഉദാഹരണങ്ങളില്‍
for-ന്റെ പരിധിക്കുള്ളില്‍ifഉപയോഗിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക. പൊതുവേ പറഞ്ഞാല്‍if, forഎന്നിവയുടെ പരിധിക്കുള്ളില്‍ ഇങ്ങനെ എന്തുവേണമെങ്കിലും എത്രവേണമെങ്കിലും "ആഴത്തില്‍" എഴുതാം. ഇങ്ങനെ എഴുതുമ്പോള്‍ സ്പേസ് കൊടുക്കുന്ന കാര്യത്തില്‍ ഇതുവരെ പറഞ്ഞ (ലളിതങ്ങളായ) നിയമങ്ങള്‍ പാലിച്ചിരിക്കണമെന്ന് മാത്രം : പുതിയ ഒരു പരിധി തുടങ്ങുമ്പോള്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതിത്തുടങ്ങുക. ഈ പരിധി അവസാനിക്കുമ്പോള്‍ ഇങ്ങനെ വലത്തേക്ക് മാറുന്നതും നിര്‍ത്തുക. നാലും ആറും ഉദാഹരണങ്ങള്‍ ശ്രദ്ധിച്ചു വായിച്ച് ഇത് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. സംശയമുണ്ടെങ്കില്‍ ചോദിക്കുക.
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 4.
- ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍
ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം
ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന
പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന
ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക).
- പ്രവ. 5.
- ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍
ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം
ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ എണ്ണം ഔട്പുട്ട് ആയി തരുന്ന
പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന
ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം മൂന്നുതവണ
പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 മൂന്നു തവണ
അമര്‍ത്തിയിരിക്കുന്നു).
- പ്രവ. 6.
- ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍
ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം
ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന
പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന
ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം മൂന്നുതവണ
പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 മൂന്നു തവണ
അമര്‍ത്തിയിരിക്കുന്നു).
ഈ മൂന്നു പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുകഴിയുമ്പോഴേക്കും നിങ്ങള്‍ പ്രൊജക്റ്റ് ഓയ്ലറിലെ (Project Euler) ആദ്യത്തെ പ്രശ്നത്തിന്റെ ഉത്തരം കണ്ടെത്തിക്കഴിഞ്ഞു!
അഭാജ്യസംഖ്യകള്‍ - പ്രോഗ്രാം
ഒരു സംഖ്യ അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കാനുള്ള ലളിതമായ പ്രോഗ്രാം എഴുതാന്‍ വേണ്ടത്ര പൈത്തണ്‍ നാം പഠിച്ചുകഴിഞ്ഞു. മുമ്പു പറഞ്ഞതുപോലെ, തന്നിരിക്കുന്ന സംഖ്യ അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കാനുള്ള ഒരു വഴി 1-നെക്കാള്‍ വലുതും ആ സംഖ്യയെക്കാള്‍ ചെറുതുമായ ഏതെങ്കിലും സംഖ്യകൊണ്ട് അതിനെ പൂര്‍ണ്ണമായി ഹരിക്കാന്‍ പറ്റുമോ എന്നു നോക്കുക എന്നതാണ്. ഇത് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഇതാ. ഈ പ്രോഗ്രാമില്‍ ഒരു ചെറിയ സൂത്രപ്പണി ഉപയോഗിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| # This program checks if a given number is prime or not. To# do this, it checks whether the number is divisible by any# number greater than 1 and less than the input number.# Get the number to check, from the user.number = input("Input the number to check : ")# 1 is a special case.if number == 1 : print number, "is not prime"else : # We use this boolean variable to remember whether # the input number is divisible by at least one # number in the range 2, 3, ..., number . number_is_prime = True # Check if at least one smaller number properly # divides the given number. If it does, remember # this fact using the boolean variable. for i in range(2, number) : if (number % i) == 0 : number_is_prime = False # If no smaller number divides the input number, # declare that it is a prime number. Otherwise say # that it is not prime. if number_is_prime == True : print number, " is prime." else : print number, "is not prime." |
ഈ പ്രോഗ്രാമില്‍ നാം ഇതുവരെ കാണാത്തതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ :
number_is_prime എന്ന പേരുള്ള ബൂളിയന്‍ (ശരി അല്ലെങ്കില് തെറ്റ് എന്നീ രണ്ടു വിലകള്‍ മാത്രമെടുക്കുന്ന) ചരത്തിന്റെ പ്രത്യേക രീതിയിലുള്ള പ്രയോഗം. പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 7.
- ഈ പ്രോഗ്രാമില്‍
number_is_primeഎന്ന ചരത്തിന്റെ ഉപയോഗം എന്താണെന്ന് ആലോചിച്ച് കണ്ടുപിടിക്കുക. എന്തിനാണ് ഇതിന്Trueഎന്ന വില ആദ്യമേ കൊടുക്കുന്നത്? - പ്രവ. 8.
- രണ്ടു സംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത്, ആ രണ്ടു
സംഖ്യകള്‍ക്കിടയ്ക്കുള്ള എല്ലാ അഭാജ്യ സംഖ്യകളെയും ഔട്പുട്ട് ആയി തരുന്ന
പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന
ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക). സൂചന: ഒരു സംഖ്യ അഭാജ്യമാണോ എന്ന് പരിശോധിക്കുന്ന (ഈ പാഠത്തിലുള്ള) പ്രോഗ്രാമിനെ അനുയോജ്യമായ ഒരു
for-ന്റെ പരിധിക്കകത്താക്കുക. - പ്രവ. 9.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ഒന്നു മുതല്‍ ആ സംഖ്യ വരെയുള്ള ഒറ്റ സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
- പ്രവ. 10.
- രണ്ടു പൂര്‍ണ്ണസംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത്, ആ രണ്ടു സംഖ്യകള്‍ക്കിടയ്ക്കുള്ള മൂന്നുകൊണ്ട് ഹരിക്കാവുന്ന എന്നാല്‍ അഞ്ചുകൊണ്ട് ഹരിക്കാന്‍ സാധിക്കാത്ത എല്ലാ പൂര്‍ണ്ണ സംഖ്യകളുടെയും ശരാശരി ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
- പ്രവ. 11.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യ ഒരു വശമായി
വരുന്ന, പൂര്‍ണ്ണസംഖ്യകള്‍ വശങ്ങളായുള്ള എല്ലാ മട്ടത്രികോണങ്ങളുടെയും
മറ്റു രണ്ട് വശങ്ങള്‍ കണ്ടുപിടിക്കുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം
താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആകാം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം
കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ പ്രോഗ്രാം നാലു പ്രാവശ്യം
പ്രവര്‍ത്തിപ്പിച്ചിട്ടുണ്ട്.
- പ്രവ. 12.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര
വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന
ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക).
- പ്രവ. 13.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര
വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന
ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക).
- പ്രവ. 14.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര
വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന
ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക).
- പ്രവ. 15.
- ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര
വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന
ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ
ചിത്രത്തില്‍ അമര്ത്തുക).
പൈത്തണ്‍ : പാഠം ഏഴ്
>> Thursday, April 7, 2011
ആമുഖം
എണ്ണല്‍സംഖ്യകളുടെ ഘടകങ്ങള്‍ എന്ന ആശയത്തെ കഴിഞ്ഞ പാഠത്തില്‍ പരിചയപ്പെട്ടിരുന്നല്ലോ. രണ്ടേരണ്ട് ഘടകങ്ങള്‍ മാത്രമുള്ള അഭാജ്യസംഖ്യകളെ പൈത്തണ്‍ ഉപയോഗിച്ച് തിരിച്ചറിയുന്നത് എങ്ങനെയെന്നും, ഇവയുടെ ഒരു പട്ടിക എങ്ങനെ ഉണ്ടാക്കാമെന്നതും കഴിഞ്ഞ പാഠത്തില്‍ നാം കണ്ടു. ഈ പാഠത്തില്‍ ഘടകങ്ങളെപ്പറ്റി കൂടുതല്‍ ചില കാര്യങ്ങള്‍ നമുക്ക് കാണാം. ഇതോടൊപ്പം പൈത്തണിലെ ബലവത്തായ ഒരു ഉപാധിയെ പരിചയപ്പെടുകയും ചെയ്യാം.ഘടകങ്ങളും പൊതുഘടകങ്ങളും
കഴിഞ്ഞ പാഠത്തില്‍ ഘടകങ്ങളെ പരിചയപ്പെട്ടത് മറന്നുപോയെങ്കില്‍: 16-നെ 16 = 1 x 16 = 2 x 8 = 4 x 4 എന്നിങ്ങനെ ഗുണിതങ്ങളായി എഴുതാമല്ലോ. 1, 2, 4, 8, 16 എന്നിവയെ 16-ന്റെ ഘടകങ്ങള്‍ (factors) എന്ന് വിളിക്കുന്നു. ഇതുപോലെ 21-നെ 21 = 1 x 21 = 3 x 7 എന്നിങ്ങനെ എഴുതാം; 1, 3, 7, 21 എന്നിവയാണ് 21-ന്റെ ഘടകങ്ങള്‍. ഏത് എണ്ണല്‍സംഖ്യയുടെയും ഘടകമായി 1-ഉം ആ സംഖ്യതന്നെയും ഉണ്ടാവും എന്ന് കുറച്ചൊന്നാലോചിച്ചാല്‍ മനസ്സിലാകും — 1-നെ അതിനോടുതന്നെ പല പ്രാവശ്യം കൂട്ടി ഏത് എണ്ണല്‍സംഖ്യയിലും എത്തിക്കാം; ഏത് എണ്ണല്‍സംഖ്യയും "ഒരു പ്രാവശ്യം കൂട്ടിയാല്‍" ആ സംഖ്യതന്നെയാണുതാനും.
രണ്ട് സംഖ്യകള്‍ക്ക് പൊതുവായുള്ള ഘടകങ്ങളെ അവയുടെ പൊതുഘടകങ്ങള്‍ (common factors) എന്ന് വിളിക്കുന്നു. ഏതു രണ്ട് എണ്ണല്‍സംഖ്യകളെടുത്താലും അവയ്ക്ക് പൊതുവായി ഒരു ഘടകമെങ്കിലും ഉണ്ടാവും (എന്തുകൊണ്ട്?). ചില സംഖ്യാജോടികള്‍ക്ക് ഏറെ പൊതുഘടകങ്ങള്‍ കാണും. മറ്റു ചിലവയ്ക്ക് വളരെ കുറച്ച് പൊതുഘടകങ്ങളേ കാണൂ. ചില ഉദാഹരണങ്ങള്‍ ഇതാ:
| ആദ്യത്തെ സംഖ്യ | രണ്ടാമത്തെ സംഖ്യ | ആദ്യത്തെ സംഖ്യയുടെ ഘടകങ്ങള്‍ | രണ്ടാമത്തെ സംഖ്യയുടെ ഘടകങ്ങള്‍ | പൊതു ഘടകങ്ങള്‍ |
|---|---|---|---|---|
| 36 | 16 | 1, 2, 3, 4, 6, 9, 12, 18, 36 | 1, 2, 4, 8, 16 | 1, 2, 4 |
| 78 | 24 | 1, 2, 3, 6, 13, 26, 39, 78 | 1, 2, 3, 4, 6, 8, 12, 24 | 1, 2, 3, 6 |
| 120 | 35581 | 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 | 1, 7, 13, 17, 23, 91, 119, 161, 221, 299, 391, 1547, 2093, 2737, 5083, 35581 | 1 |
| 48 | 210 | 1, 2, 3, 4, 6, 8, 12, 16, 24, 48 | 1, 2, 3, 5, 6, 7, 10, 14, 15, 21, 30, 35, 42, 70, 105, 210 | 1, 2, 3, 6 |
| 402 | 245 | 1, 2, 3, 6, 67, 134, 201, 402 | 1, 5, 7, 35, 49, 245 | 1 |
ലിസ്റ്റുകളെപ്പറ്റി രണ്ടുകാര്യങ്ങള്‍
കഴിഞ്ഞ പാഠത്തില്‍
for, range() എന്നിവയോടനുബന്ധിച്ച് നാം
ലിസ്റ്റുകളെ പരിചയപ്പെട്ടിരുന്നല്ലോ? അവിടെ സൂചിപ്പിച്ചതുപോലെ പൈത്തണ്‍
ഉപയോഗിച്ച് പ്രോഗ്രാമുകള്‍ എഴുതുമ്പോള്‍ വളരെയധികം ഉപയോഗപ്പെടുന്ന ഒന്നാണ്
ലിസ്റ്റ്. ലിസ്റ്റുകളെ കൈകാര്യം ചെയ്യുവാനുള്ള ഒട്ടേറെ ഉപാധികള്‍
പൈത്തണില്‍ ലഭ്യമാണ്. ഇവയില്‍ ലളിതമായ രണ്ട് ഉപാധികളെ ഈ പാഠത്തില്‍ നമുക്ക്
പരിചയപ്പെടാം.ആദ്യമായി നമ്മുടെ കൈയ്യിലുള്ള ഒരു ലിസ്റ്റില്‍ പുതിയ അംഗങ്ങളെ ചേര്‍ക്കുന്നതെങ്ങനെ എന്ന് നോക്കാം. ഒരു ലിസ്റ്റിലേക്ക് പുതിയ അംഗങ്ങളെ ചേര്‍ക്കാനുള്ള ഏറ്റവും ലളിതമായ വഴി ആ ലിസ്റ്റിന്റെ
append()
എന്ന ഏകദം ഉപയോഗിക്കുക എന്നതാണ്. കേള്‍ക്കുന്നയത്ര പ്രയാസമുള്ള കാര്യമല്ല
ഇത്; താഴെക്കാണുന്ന ചെറിയ പ്രോഗ്രാമുകള്‍ പരീക്ഷിച്ചുനോക്കൂ:
1
2
3
4
5
6
7
8
9
10
11
| print "Starting to make a list of the districts in Kerala ..."districts = ["Thiruvananthapuram", "Kollam"]print "Districts added to the list till now : ", districtsprint "Going to add Kannur to the list ..."districts.append("Kannur")print "Districts added to the list till now : ", districts |
1
2
3
4
5
6
7
8
9
10
11
12
| # This program makes a list of all the odd numbers from 1 to# 100.odd_numbers = [ ]for number in range(1,101): if (number % 2 == 1) : # If the number is odd odd_numbers.append(number) # We are now out of the "for" loop.print "The odd numbers from 1 to 100 are : ", odd_numbers |
ലിസ്റ്റിലേക്ക് ആളെക്കൂട്ടുന്ന വഴി മനസ്സിലായല്ലോ?
myList എന്ന ലിസ്റ്റിലേക്ക് new_item എന്ന വസ്തു ചേര്‍ക്കാനായി myList.append(new_item) എന്ന് പ്രയോഗിക്കുക. ഇവിടെ new_item എന്നത് 5, "name" എന്നിങ്ങനെയുള്ള മൂല്യങ്ങളോ number, name എന്നിങ്ങനെ ചരങ്ങളോ ആകാം; ചരമാണെങ്കില്‍ അതിന്റെ വിലയാവും ലിസ്റ്റില്‍ കയറിക്കൂടുന്നത്. പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 1.
- ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയുടെ ഘടകങ്ങളുടെ
ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ
പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ
വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം
മൂന്നു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 മൂന്നു തവണ
അമര്‍ത്തിയിരിക്കുന്നു).
- പ്രവ. 2.
- രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, ഈ സംഖ്യകളുടെ പൊതു
ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം
(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ
ഈ പ്രോഗ്രാം മൂന്നു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5
മൂന്നു തവണ അമര്‍ത്തിയിരിക്കുന്നു).
ഒരു ലിസ്റ്റിന്റെ നീളം (അതില്‍ എത്ര അംഗങ്ങള്‍ ഉണ്ടെന്നുള്ളത്) കാണാനുള്ള വിദ്യയാണ് അടുത്തത്. ഇതിനുള്ള ലളിതമായ വഴി പൈത്തണിലെ
len() എന്ന ഏകദം ഉപയോഗിക്കുക എന്നതാണ്. ഇത് എങ്ങനെയാണ് ചെയ്യുന്നതെന്ന് താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പരീക്ഷിച്ചാല്‍ മനസ്സിലാകും.
1
2
3
4
5
6
7
8
| # This is a list of the districts in Kerala.districts = ["Kasaragod", "Kannur", "Wayanad", "Kozhikode", \ "Malappuram", "Palakkad", "Thrissur", "Ernakulam", "Idukki", \ "Kottayam", "Alappuzha", "Pathanamthitta", "Kollam", \ "Thiruvananthapuram"]print "There are ", len(districts), " districts in Kerala." |
1
2
3
4
5
6
7
8
9
10
11
12
13
| # This program finds the number of odd numbers from 1# to 100.odd_numbers = [ ]for number in range(1,101): if (number % 2 == 1) : # If the number is odd odd_numbers.append(number) # We are now out of the "for" loop.print "There are ", len(odd_numbers), " odd numbers \ from 1 to 100." |
രണ്ടാമത്തെ പ്രോഗ്രാമില്‍ ഒറ്റസംഖ്യകളുടെ എണ്ണം കാണുക മാത്രം ചെയ്യാന്‍ അവയുടെ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കേണ്ട കാര്യമില്ല എന്നത് ശ്രദ്ധിക്കുക: ഒരു ചരത്തില്‍ ഈ എണ്ണം സൂക്ഷിച്ചാല്‍ മാത്രം മതിയാകും.
len() എന്ന ഉപാധിയുടെ പ്രയോഗം ഉദാഹരിക്കാന്‍ മാത്രമാണ് ഇവിടെ odd_numbers എന്ന ലിസ്റ്റ് ഉണ്ടാക്കിയത്. len() ഉപയോഗിച്ച് ലിസ്റ്റുകളുടെ മാത്രമല്ല, string-കളുടെയും നീളം (string-ല്‍ ഉള്ള സ്പേസും മറ്റു ചിഹ്നങ്ങളും ഉള്‍പ്പടെയുള്ള
അക്ഷരങ്ങളുടെ എണ്ണം) കാണാം. പ്രയോഗരീതി മുകളിലത്തേതുപോലെ തന്നെ. ഈ സൗകര്യം
ഉപയോഗിച്ച് കേരളത്തിലെ ഏത് ജില്ലയുടെ പേരിനാണ് ഇംഗ്ളീഷില്‍ എഴുതിയാല്‍
ഏറ്റവും നീളം എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം ഇതാ:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| # This program finds the "longest" district in Kerala, and# its length when written in English.# This is a list of the districts in Kerala.districts = ["Kasaragod", "Kannur", "Wayanad", "Kozhikode", \ "Malappuram", "Palakkad", "Thrissur", "Ernakulam", \ "Idukki", "Kottayam", "Alappuzha", "Pathanamthitta",\ "Kollam", "Thiruvananthapuram"]longest_district = ""max_length = 0for dist in districts : length = len(dist) if length > max_length : # We have found a new district # whose name is longer than all # that we have seen so far. longest_district = dist max_length = length# We are now out of the "for" loopprint "The district with the longest name is: ", \ longest_district, "."print "Its name has ", max_length, " letters." |
പ്രവര്‍ത്തനം
- പ്രവ. 3.
- ഈ ഉദാഹരണങ്ങള്‍ മനസ്സിരുത്തി വായിക്കുക. ഇവ പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. പ്രത്യേകിച്ച് മൂന്നാമത്തെ ഉദാഹരണത്തിന്റെ 13 മുതല്‍ 19 വരെയുള്ള വരികളില്‍ എന്താണ് സംഭവിക്കുന്നതെന്ന് കൃത്യമായി മനസ്സിലാക്കുക.
ഉത്തമ സാധാരണ ഘടകം
രണ്ട് പൂര്‍ണ്ണസംഖ്യകളുടെ ഏറ്റവും വലിയ പൊതുഘടകത്തെ അവയുടെ ഉത്തമ സാധാരണ ഘടകം (highest common factor, greatest common divisor) എന്ന് വിളിക്കുന്നു: ചുരുക്കത്തില്‍ ഉസാഘ (hcf, gcd) എന്നും. മുകളിലുള്ള പട്ടികയില്‍നിന്ന് നമുക്ക് കിട്ടുന്ന ഉദാഹരണങ്ങള്‍:
- ഉസാഘ(16, 36) = 4
- ഉസാഘ(78, 24) = 6
- ഉസാഘ(120, 35581) = 1
- ഉസാഘ(210, 48) = 6
- ഉസാഘ(402, 245) = 1
രണ്ട് പൂര്‍ണ്ണസംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത് അവയുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം നമുക്ക് എങ്ങനെ എഴുതാം? മുകളിലെ രണ്ടു പ്രവര്‍ത്തനങ്ങളും ചെയ്താല്‍ ഇതിനുള്ള ആശയം കിട്ടും. ലളിതമായ ഒരു രീതി ഇതാ:
- ഇന്‍പുട്ട് ആയി കിട്ടിയ സംഖ്യകള്‍
num1, num2എന്നിവയാണെന്നിരിക്കട്ടെ. -
1മുതല്‍num1വരെയുള്ള ഓരോ സംഖ്യയും ക്രമത്തില്‍num1, num2എന്നിവ രണ്ടിനേയും നിശ്ശേഷം ഹരിക്കുന്നുണ്ടോ എന്ന് നോക്കുക. - ഇങ്ങനെ രണ്ടിനേയും ഹരിക്കുന്ന സംഖ്യ കാണുമ്പോള്‍ അത് ഒരു ചരത്തില്‍ (ഇതിനെ നമുക്ക്
gcdഎന്ന് വിളിക്കാം) സൂക്ഷിച്ചുവെക്കുക. -
gcd-ന്റെ അവസാനമുള്ള വിലയാണ്num1, num2എന്നിവയുടെ ഉസാഘ.
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 4.
- രണ്ട് സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍ മുകളില്‍ കൊടുത്ത രീതി ശരിയാകുന്നത് എന്തുകൊണ്ടാണെന്ന് ആലോചിച്ച് മനസ്സിലാക്കുക.
- പ്രവ. 5.
- രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, ഈ
സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മുകളില്‍ കൊടുത്ത രീതിയില്
എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ
ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍
അമര്ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം നാലു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു
(IDLE-ല്‍ F5 നാലു തവണ അമര്‍ത്തിയിരിക്കുന്നു).
യൂക്ളിഡിന്റെ അല്‍ഗോരിതം
ഉസാഘ കണ്ടുപിടിക്കാന്‍ മുകളില്‍ വിവരിച്ച രീതി — രണ്ട് സംഖ്യകളെയും നിശ്ശേഷം ഹരിക്കുന്ന സംഖ്യകള്‍ എല്ലാം കണ്ടുപിടിച്ച് ഇവയില്‍വച്ച് ഏറ്റവും വലുത് ഉത്തരമായി നല്‍കുക എന്നത് — തികച്ചും ശരിയായ രീതി തന്നെയാണ്. ഉസാഘയുടെ നിര്‍വചനത്തിനോട് ഏറെ അടുത്തുനില്‍ക്കുന്ന രീതിയുമാണിത്. എന്നാല്‍ ഈ രീതിക്ക് ഒരു വലിയ പരിമിതിയുണ്ട്. അതെന്താണെന്നറിയാന്‍ പ്രവ. 4-ല്‍ എഴുതിയ പ്രോഗ്രാമിന് താഴെപ്പറയുന്ന ജോടികള്‍ ഇന്‍പുട്ട് ആയി കൊടുക്കുക (മുന്നറിയിപ്പ്: കംപ്യൂട്ടറില്‍ തുറന്നിരിക്കുന്ന പ്രമാണങ്ങളൊക്കെ സേവ് ചെയ്തതിനുശേഷം മാത്രം ഇത് പരീക്ഷിക്കുക) :
- 287503, 646609
- 4143937, 6487923
- 55596155, 73187552
ഈ രീതിയുടെ പരിമിതി എന്താണെന്ന് മനസ്സിലായല്ലോ? ഇന്‍പുട് സംഖ്യകള്‍ വലുതാകുന്തോറും പ്രോഗ്രാം പൂര്‍ത്തിയാകാനെടുക്കുന്ന സമയവും ആനുപാതികമായി കൂടുന്നു. (സംഖ്യകളുടെ വലുപ്പം കുറച്ച് കൂടുമ്പോഴേക്കും ചിലപ്പോള്‍ കംപ്യൂട്ടര്‍ നിശ്ചലമായി എന്നും വരാം; ഇത് നാം ഉപയോഗിക്കുന്ന
range() എന്ന ഏകദത്തിന്റെ പ്രവര്‍ത്തനരീതി കാരണമാണ്. range()-നു പകരം xrange()
എന്ന് പ്രയോഗിച്ചാല്‍ ഈ പ്രശ്നം ഒഴിവാക്കാം. ഇപ്പോള്‍ കൂടുതല്‍
വിശദീകരിക്കുന്നില്ല.). ഇതു തന്നെയാണ് ഈ രീതിയുടെ വലിയ പരിമിതിയും.
കുറച്ചൊന്നാലോചിച്ചാല്‍ ഇങ്ങനെ സംഭവിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് നമുക്ക്
മനസ്സിലാക്കാം. തന്നിരിക്കുന്ന സംഖ്യകളിലൊന്നിന്റെ ഓരോ ഘടകത്തിനെക്കൊണ്ടും
മറ്റേ സംഖ്യയെ ഹരിച്ചുനോക്കുക എന്നതാണല്ലോ ഇവിടെ ചെയ്യുന്നത്? ഇതിനായി
ഒന്നു മുതല്‍ ആദ്യത്തെ സംഖ്യ വരെയുള്ള എല്ലാ സംഖ്യകളെക്കൊണ്ടും ആദ്യത്തെ
സംഖ്യയെ ഹരിച്ചു നോക്കുന്നു. ആദ്യത്തെ സംഖ്യ വലുതാകുന്തോറും പ്രോഗ്രാം
പ്രവര്‍ത്തിക്കാനെടുക്കുന്ന സമയം ആനുപാതികമായി കൂടുന്നത് ഇതുകൊണ്ടാണ്. ഈ പരിമിതി ഒഴിവാക്കാനാകുന്നതാണോ? ഉസാഘയുടെ നിര്‍വചനത്തെ അതേപടി പകര്‍ത്തുകയാണ് ഈ രീതി ചെയ്യുന്നത്: ആദ്യത്തെ സംഖ്യയുടെ ഘടകങ്ങളില്‍വച്ച് രണ്ടാമത്തെ സംഖ്യയുടെ ഏറ്റവും വലിയ ഘടകത്തെ കണ്ടുപിടിക്കുക എന്നതാണ് ഇവിടെ സംഭവിക്കുന്നത്. ഇതുതന്നെയാണല്ലോ ഉസാഘയുടെ നിര്‍വചനവും? അങ്ങനെയിരിക്കെ ഇതിലും വേഗത്തില്‍ എങ്ങനെ ഈ പ്രശ്നത്തിന് ഉത്തരം കാണാന്‍ കഴിയും? ഇത് സാധ്യമല്ല എന്ന് ന്യായമായും സംശയിക്കാം.
ഇതിലും മികച്ച — താരതമ്യേന വളരെ കുറച്ച് സമയം മാത്രമെടുക്കുന്ന — രീതികള്‍ നിലവിലുണ്ട് എന്നതാണ് അത്ഭുതകരമായ വസ്തുത. ഇവയില്‍ ഏറ്റവും പ്രശസ്തമായ രീതിക്ക് രണ്ടായിരത്തിമുന്നൂറിലേറെ വര്‍ഷം പഴക്കമുണ്ട് എന്നതും അത്ഭുതകരം തന്നെ. ബി. സി. 300-നോടടുപ്പിച്ച് എഴുതപ്പെട്ട യുക്ളിഡിന്റെ 'എലമെന്റ്സ്' എന്ന പുസ്തകസഞ്ചയത്തില്‍ രണ്ട് സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാനുള്ള മനോഹരമായ ഒരു രീതി വിവരിച്ചിട്ടുണ്ട്. "യൂക്ളിഡിന്റെ അല്‍ഗോരിതം" എന്ന പേരില്‍ ഈ രീതി പ്രശസ്തമാണ്. "അല്‍ഗോരിതം" എന്നതിന് "പ്രശ്നപരിഹാരത്തിനുള്ള വഴി" എന്ന് ഏകദേശം അര്‍ത്ഥം പറയാം. ഇനി നമുക്ക് യൂക്ളിഡിന്റെ അല്‍ഗോരിതം എന്താണെന്ന് മനസ്സിലാക്കാന്‍ ശ്രമിക്കാം.
യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തിന്റെ അടിസ്ഥാനം ഇതാണ്: a, b എന്നീ പൂര്‍ണ്ണസംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കണമെന്ന് കരുതുക.
- a = b ആണെങ്കില്‍ ഉസാഘ (a, b) = a. (എന്തുകൊണ്ട്?) ഇനി a < b ആണെന്ന് കരുതുക (b < a ആണെങ്കില്‍ ഇനിയുള്ള വാദങ്ങളില്‍ aയും bയും തലതിരിച്ചിട്ടാല്‍ മതി.).
- b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ ഉസാഘ (a, b) = a. (എന്തുകൊണ്ട്?)
- b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം r എന്ന അധിസംഖ്യയാണെന്ന് കരുതുക. ഇങ്ങനെയാണെങ്കില്‍ ഉസാഘ(a, b) = ഉസാഘ(r, a).
ഇവയില്‍ ആദ്യത്തെ രണ്ട് കാര്യങ്ങളും ശരിയാണെന്ന് കാണാന്‍ വലിയ പ്രയാസമില്ല (ആലോചിച്ചുനോക്കൂ). മൂന്നാമത്തെ കാര്യം ശരിയാണോ എന്നത് ഒറ്റനോട്ടത്തില്‍ വ്യക്തമല്ല. ഇത് എന്തുകൊണ്ട് ശരിയാകുന്നു എന്ന് നമുക്കൊന്നു നോക്കാം.
മൂന്നാമത്തെ പിരിവില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം r എന്ന അധിസംഖ്യയാണല്ലോ? അപ്പോള്‍ b = ma + r എന്ന് എഴുതാന്‍ കഴിയുന്ന m എന്ന ഒരു അധിസംഖ്യ നിലവിലുണ്ട് : b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ഉത്തരത്തിന്റെ പൂര്‍ണ്ണസംഖ്യാഭാഗമാണ് m. ഈ സമവാക്യത്തെ നമുക്ക് r = b - ma എന്നൊന്ന് മാറ്റി എഴുതാം.
a, b എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് f എന്ന് കരുതുക. അപ്പോള്‍ a = pf, b = qf എന്നിങ്ങനെ എഴുതാവുന്ന p,q എന്ന രണ്ട് അധിസംഖ്യകള്‍ ഉണ്ട്. അതുകൊണ്ട് r = b - ma = qf - mpf = f(q - mp). ഇതില്‍നിന്ന് f എന്നത് r-ന്റെയും ഘടകമാണ് എന്ന് കിട്ടുന്നു. അതുകൊണ്ട് r, a എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് f എന്ന് വരുന്നു.
ഇനി r, a എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് g എന്ന് കരുതുക. അപ്പോള്‍ r = sg, a = tg എന്നിങ്ങനെ എഴുതാവുന്ന s,t എന്ന രണ്ട് അധിസംഖ്യകള്‍ ഉണ്ട്. അതുകൊണ്ട് b = ma + r = mtg + sg = g (mt + s). ഇതില്‍നിന്ന് g എന്നത് b-യുടെയും ഘടകമാണ് എന്ന് കിട്ടുന്നു. അതുകൊണ്ട് a,b എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് g എന്ന് വരുന്നു.
ഇപ്പറഞ്ഞതില്‍നിന്ന് നമുക്ക് കിട്ടുന്നത്: a, b എന്നിവയുടെ ഏത് പൊതുഘടകവും r, a എന്നിവയുടെകൂടി പൊതുഘടകമാണ്. മറിച്ച് r, a എന്നിവയുടെ ഏത് പൊതുഘടകവും a, b എന്നിവയുടെ പൊതുഘടകവുമാണ്. അതുകൊണ്ട് a, b എന്നിവയുടെ പൊതുഘടകങ്ങള്‍ തന്നെയാണ് r, a എന്നിവയുടെ പൊതുഘടകങ്ങളും. a, b എന്നിവയുടെ ഏറ്റവും വലിയ പൊതുഘടകവും r, a എന്നിവയുടെ ഏറ്റവും വലിയ പൊതുഘടകവും ഒന്നുതന്നെയാണെന്ന് ഇതില്‍നിന്ന് വ്യക്തം. അതായത് ഉസാഘ(a,b) = ഉസാഘ(r, a).
അപ്പോള്‍ മുകളിലുള്ള മൂന്നാമത്തെ പിരിവും ശരിയാണ്. യൂക്ളിഡിന്റെ അല്‍ഗോരിതവും ഇതുതന്നെയാണ്: a, b എന്നീ സംഖ്യകളുടെ ഉസാഘ കാണാന്‍:
യൂക്ളിഡിന്റെ അല്‍ഗോരിതം
- a = b ആണെങ്കില്‍ ഉസാഘ(a, b) = a
- a < b എങ്കില്‍: b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം കണ്ടുപിടിക്കുക. ഇത് r ആണെന്നിരിക്കട്ടെ.
- r = 0 ആണെങ്കില്‍ ഉസാഘ(a, b) = a
- അല്ലെങ്കില് r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കുക; ഇതുതന്നെയാണ് a, b എന്നിവയുടെ ഉസാഘ.
- അതല്ല a > b ആണെങ്കില്‍: a-യെ b കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം കണ്ടുപിടിക്കുക. ഇത് r ആണെന്നിരിക്കട്ടെ.
- r = 0 ആണെങ്കില്‍ ഉസാഘ(a, b) = b
- അല്ലെങ്കില് r, b എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കുക; ഇതുതന്നെയാണ് a, b എന്നിവയുടെ ഉസാഘ.
- പ്രവ. 5.
- യൂക്ളിഡിന്റെ അല്‍ഗോരിതം മനസ്സിരുത്തി വായിക്കുക. ഇതിന്റെ പ്രവര്‍ത്തനരീതി മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്താന്‍:
- a, b എന്നിവയ്ക്ക് പല വിലകള്‍ കൊടുത്ത് ഈ രീതിയില് (കടലാസും പേനയും ഉപയോഗിച്ച്) അവയുടെ ഉസാഘ കാണുക.
- ഈ പാഠഭാഗത്തിന്റെ ആദ്യം കാണുന്ന മൂന്ന് ജോടി സംഖ്യകളുടെ ഉസാഘയും ഈ രീതി ഉപയോഗിച്ച് കണ്ടുപിടിക്കുക. മൂന്നാമത്തെ ജോടിയുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍ നിങ്ങളെടുത്ത സമയം കംപ്യൂട്ടര്‍ ഇതു ചെയ്യാന്‍ എടുത്ത സമയവുമായി താരതമ്യം ചെയ്യുക.
- വളരെ വലിയ സംഖ്യകള്‍ (ഉദാ: പത്തക്ക സംഖ്യകള്‍) ഉള്‍പ്പെടുന്ന ഒരു ഉദാഹരണമെങ്കിലും യൂക്ളിഡിന്റെ രീതി ഉപയോഗിച്ച് ചെയ്തു നോക്കുക.
- ഈ രീതിയില് ഉസാഘ കണ്ടുപിടിക്കാന്‍ നോക്കിയാല്‍ അത് എപ്പോഴെങ്കിലും അവസാനിക്കുമെന്ന് എന്താണുറപ്പ്? ചില ജോടി സംഖ്യകള്‍ക്ക് ഇത് അനന്തമായി നീണ്ടുപോയെങ്കിലോ?
- ഈ രീതി ശരിയാണോ? ഏതു ജോടി പൂര്‍ണ്ണസംഖ്യകളുടെ ഉസാഘയും ഇതുവഴി കിട്ടുമോ?
- നാം ഇതിനുമുമ്പ് കണ്ട ലളിതമായ രീതിയെക്കാള്‍ വളരെ വേഗത്തില്‍ യൂക്ളിഡിന്റെ രീതി ഉത്തരം തരുമോ?
-
whileവരിയുടെ (ലഘുവായ) വ്യാകരണം ഇതാണ്:while condition :. പേരുസൂചിപ്പിക്കുന്നതുപോലെ ഇവിടെconditionഎന്നത് ഒരു വ്യവസ്ഥ ആണ്. ഉദാഹരണങ്ങളിലെ വ്യവസ്ഥകളെല്ലാം സംഖ്യകളെ അധികരിച്ചാണെങ്കിലും, പൊതുവേ ഇത് എന്തുതരത്തിലുള്ള വ്യവസ്ഥ വേണമെങ്കിലും ആകാം. കൂടുതല്‍ വൈവിധ്യമുള്ള ഉദാഹരണങ്ങള്‍ നമുക്ക് വഴിയേ കാണാം.conditionകഴിഞ്ഞുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക. -
whileവരി കഴിഞ്ഞുവരുന്ന വരികളില്‍while-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ (ഒന്നോ അതിലധികമോ) എഴുതണം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈwhileവരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. - മുകളിലെ ഉദാഹരണങ്ങളില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത്. ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍
:എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. -
conditionഎപ്പോള്‍ വരെ ശരിയായിരിക്കുന്നോ, അത്ര വരെwhile-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളെല്ലാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ്while-ന്റെ അടിസ്ഥാന സ്വഭാവം. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയാല്‍ ഇത് വ്യക്തമായി മനസ്സിലാകും. ഒരിക്കലും തെറ്റാത്ത ഒരു വ്യവസ്ഥയാണെങ്കില്‍ (ഉദാ: 1 == 1) ഈ വരികളെല്ലാം അനന്തകാലത്തേക്ക് (അല്ലെങ്കില് പ്രോഗ്രാം പുറത്തുനിന്ന് നിര്‍ത്തുന്നതുവരെ) പ്രവര്‍ത്തിച്ചുകൊണ്ടേയിരിക്കും. -
while-ന്റെ പരിധിയില്‍ വരേണ്ടുന്ന — വ്യവസ്ഥ ശരിയായിരിക്കുന്നിടത്തോളം കാലം പ്രവര്‍ത്തിപ്പിക്കേണ്ടുന്ന — വരികള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരിwhileവരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം.while-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത്while-നു ശേഷവുംwhile-ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. ഉദാഹരണങ്ങളില്‍while-ന്റെ പരിധിക്ക് പുറത്തുള്ള വരികള്‍ എഴുതുന്ന വിലകള്‍ നോക്കിയാല്‍ ഇത് വ്യക്തമാകും. - ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
- ഇക്കാര്യങ്ങളിലെല്ലാം മുമ്പത്തെ പാഠത്തില്‍ നാം പരിചയപ്പെട്ട
if, forഎന്നിവയുടെ ഘടനയുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക. -
if, for, whileഎന്നിവയുടെ പരിധിക്കുള്ളില്‍ എന്തുവേണമെങ്കിലും എത്രവേണമെങ്കിലും "ആഴത്തില്‍" എഴുതാം. ഇങ്ങനെ എഴുതുമ്പോള്‍ സ്പേസ് കൊടുക്കുന്ന കാര്യത്തില്‍ ഇതുവരെ പറഞ്ഞ (ലളിതങ്ങളായ) നിയമങ്ങള്‍ പാലിച്ചിരിക്കണമെന്ന് മാത്രം : പുതിയ ഒരു പരിധി തുടങ്ങുമ്പോള്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതിത്തുടങ്ങുക. ഈ പരിധി അവസാനിക്കുമ്പോള്‍ ഇങ്ങനെ വലത്തേക്ക് മാറുന്നതും നിര്‍ത്തുക. ഇങ്ങനെയുള്ള അനേകം ഉദാഹരണങ്ങള്‍ വഴിയേ കാണാം. - പ്രവ. 6.
-
while-ല്‍ പറയുന്ന വ്യവസ്ഥ (condition) എപ്പോള്‍ വരെ ശരിയായിരിക്കുന്നോ, അപ്പോള്‍ വരെwhile-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണല്ലോwhile-ന്റെ സ്വഭാവം? ഇതുകൊണ്ടുതന്നെwhile-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഓരോ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോഴും ഈ വ്യവസ്ഥയെ (നേരിട്ടോ അല്ലാതെയോ)ബാധിക്കുന്ന എന്തെങ്കിലും മാറ്റം വരേണ്ടത് സാധാരണ ഗതിയില്‍ പ്രോഗ്രാം ശരിയാകാന്‍ ആവശ്യമാണ്. മുകളിലെ ഉദാഹരണങ്ങളില്‍ ഇങ്ങനെയുള്ളതരം മാറ്റം വരുത്തുന്ന വരികള്‍ ഏതാണെന്ന് കണ്ടുപിടിക്കുക.
യൂക്ളിഡിന്റെ അല്‍ഗോരിതം : പൈത്തണില്‍ വീണ്ടും
ഇനി നമുക്ക്whileഉപയോഗിച്ച് യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തിനെ എങ്ങനെ മുഴുമിപ്പിക്കാം എന്ന് നോക്കാം. നമ്മുടെ രണ്ടാമത്തെ പ്രോഗ്രാം ഒന്നുകൂടെ എടുത്തെഴുതുന്നു. പറയാനുള്ള സൗകര്യത്തിനായി a, b-യെക്കാള്‍ വലുതല്ല എന്ന് സങ്കല്‍പ്പിച്ചിരിക്കുന്നു എന്ന് ഓര്‍ക്കുക:
12345678910111213141516171819202122232425262728# A first attempt at writing Euclid's Algorithm in Python.# We assume that a, b are the two input numbers, and that a# is not larger than b. We want the GCD of a and b to be# stored in the variable gcd.ifa==b :gcd=aelse:# Now we know that a is less than b.r=b%a# Find the remainder after division.ifr==0:gcd=aelse:# We now write out the code to find the gcd# of r and a# First we rename r and a so that we can just# copy the remaining code from above.b=aa=r# Now we just copy the code from above.r=b%a# Find the remainder after division.ifr==0:gcd=aelse:# Find the gcd of r and a. This is the gcd# of a and b.
whileഉപയോഗിച്ച് ഈ കോഡിനെ എങ്ങനെ മുഴുമിപ്പിക്കാം? ഇവിടെrഎന്ന ചരത്തിന്റെ വില പൂജ്യം ആകുന്നതുവരെയാണ് നമുക്ക് ശിഷ്ടം കാണുകയും മറ്റും വേണ്ടത്. ഇത്whileഉപയോഗിച്ച് എഴുതുമ്പോള്‍ ഇങ്ങനെയാകും:
12345678910111213141516171819202122# A second attempt at writing Euclid's Algorithm in Python,# using the while loop. We assume that a, b are the two# input numbers, and that a is not larger than b. We want# the GCD of a and b to be stored in the variable gcd.ifa==b :gcd=aelse:# Now we know that a is less than b.r=b%a# Find the remainder after division.whilenot(r==0) :# First we rename r and a.b=aa=r# Now we find the remainder for the new values of a# and b.r=b%a# We are now out of the while loop. This means that# r == 0, and so the current value of a is the gcdgcd=a
ഇവിടെ ചെയ്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒമ്പതാമത്തെ വരിയില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം r എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെക്കുന്നു. r-ന്റെ വില പൂജ്യമാണെങ്കില്‍ നമുക്കുവേണ്ടതായ ഉസാഘ a-യുടെ വില തന്നെയാണെന്ന് നാം കണ്ടു. r-ന്റെ വില പൂജ്യം അല്ലെങ്കില് ഈ വില പൂജ്യം ആകുന്നതുവരെ ഒരുകൂട്ടം കാര്യങ്ങള്‍ ചെയ്യണം. ഇത് സംഭവിക്കുന്നത് 11 മുതല്‍ 18 വരെയുള്ള വരികളിലാണ്. പതിനൊന്നാം വരിയില്‍while-ന് തുടക്കമിട്ടിരിക്കുന്നു. ഈwhile-ന്റെ പരിധി പതിനെട്ടാം വരി വരെയാണ്. പന്ത്രണ്ടുമുതല്‍ പതിനെട്ടുവരെയുള്ള വരികള്‍ എത്രത്തോളം ആവര്‍ത്തിക്കണം എന്നത് പതിനൊന്നാം വരിയില്‍ പറഞ്ഞിരിക്കുന്നു: "r-ന്റെ വില പൂജ്യം അല്ലാത്തിടത്തോളം".
മുകളിലത്തെ പ്രോഗ്രാമിനെ നമുക്ക് കുറച്ചുകൂടെ ചെറുതാക്കാം.a == bആണെങ്കില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണല്ലോ? ഇക്കാര്യം മുതലെടുത്ത് ആദ്യത്തെ വ്യവസ്ഥ പരിശോധിക്കുന്നത് നമുക്ക് ഒഴിവാക്കാം. ഇനി a, b-യെക്കാള്‍ വലുതാണെങ്കില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം b തന്നെയാണല്ലോ? അതുകൊണ്ട്whileആദ്യത്തെ തവണ പ്രവര്‍ത്തിക്കുമ്പോള്‍ a, b എന്നിവയുടെ വിലകള്‍ തമ്മില്‍ വെച്ചുമാറുകയും a,b-യെക്കാള്‍ ചെറുതാകുകയും ചെയ്യും. ഫലം : a, b-യെക്കാള്‍ വലുതായാല്‍ പോലും ഇതേ കോഡ് ശരിയായി പ്രവര്‍ത്തിക്കും. ഈ മാറ്റങ്ങളൊക്കെ വരുത്തിയ കോഡ് ഇതാ:
123456789101112131415161718# Euclid's Algorithm in Python, version 3. This works for# all positive numbers a and b. We want the GCD of a and b# to be stored in the variable gcd.r=b%a# Find the remainder after division.whilenot(r==0) :# First we rename r and a.b=aa=r# Now we find the remainder for the new values of a and# b.r=b%a# We are now out of the while loop. This means that r == 0,# and so the current value of a is the gcdgcd=a
പ്രവര്‍ത്തനം
- പ്രവ. 7.
-
- മുകളിലത്തെ പ്രോഗ്രാമും അതിന് തൊട്ടുമുമ്പ് കൊടുത്തിട്ടുള്ള പ്രോഗ്രാമും തമ്മിലുള്ള വ്യത്യാസങ്ങള്‍ എന്തൊക്കെയാണ്? ഈ വ്യത്യാസങ്ങളൊക്കെ ഉണ്ടായിട്ടും രണ്ടു പ്രോഗ്രാമും എന്തുകൊണ്ടാണ് ഒരേപോലെ പ്രവര്‍ത്തിക്കുന്നത്?
- രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, യൂക്ളിഡിന്റെ അല്‍ഗോരിതം ഉപയോഗിച്ച് ഈ സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മുകളില്‍ കൊടുത്ത രീതിയില് എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം നാലു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 നാലു തവണ അമര്‍ത്തിയിരിക്കുന്നു).
- മുകളില്‍ "യൂക്ളിഡിന്റെ അല്‍ഗോരിതം" എന്ന ഭാഗത്തിന്റെ തുടക്കത്തില്‍ കാണുന്ന മൂന്ന് ജോടി സംഖ്യകള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുക. ഈ പ്രോഗ്രാം ഇവയുടെ ഉത്തരം കണ്ടുപിടിക്കാന്‍ ഏറെ സമയം എടുക്കുന്നുണ്ടോ?
- വളരെ വലിയ സംഖ്യകള്‍ ഉള്‍പ്പെടുന്ന ജോടികള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുക. സംഖ്യകള്‍ വലുതാകുന്ന അതേ തോതില്‍ പ്രോഗ്രാം എടുക്കുന്ന സമയവും കൂടുന്നതായി തോന്നുന്നുണ്ടോ?
പ്രവര്‍ത്തനം
യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തെക്കുറിച്ച് ന്യായമായി ഉണ്ടാകാവുന്ന ചില സംശയങ്ങള്‍:
ആദ്യത്തെ സംശയത്തിന് പ്രധാന കാരണം ഇതാകാം: ഒരു ജോടി സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍വേണ്ടി നാം മറ്റൊരു ജോടി സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കേണ്ടി വരുന്നു. ഇത് ഇങ്ങനെ അനന്തമായി നീണ്ടുപോയാലോ? ഇങ്ങനെ നീണ്ടുപോകില്ല എന്ന് കാണാന്‍ ഒരു കാര്യം ശ്രദ്ധിച്ചാല്‍ മതി: രണ്ടാമത്തെ ജോടിയിലെ ഒരു സംഖ്യ (r) ആദ്യത്തെ ജോടിയിലെ രണ്ടു സംഖ്യകളെക്കാളും ചെറുതാണ് (എന്തുകൊണ്ട്?). എല്ലാ സംഖ്യകളും അധിസംഖ്യകളുമാണ്. അധിസംഖ്യകളുടെ കുറഞ്ഞുവരുന്ന ഒരു ശ്രേണി അനന്തമായി നീളുകയില്ലല്ലോ? അതുകൊണ്ടുതന്നെ ഈ രീതിയുടെ പ്രവര്‍ത്തനവും അനന്തമായി നീളുകയില്ല.
രണ്ടാമത്തെ സംശയത്തിന്റെ ഉത്തരം നാം മുകളില്‍ കണ്ടുകഴിഞ്ഞു: ഏത് ജോടി പൂര്‍ണ്ണസംഖ്യകളുടെയും ഉസാഘ ഈ രീതിയില് കണ്ടുപിടിക്കാനാകും.
ഈ രീതിയുടെ വേഗത്തെപ്പറ്റി ഒരു ഏകദേശ രൂപം കിട്ടാന്‍ പ്രവര്‍ത്തനം 5 സഹായിക്കും. ഇതുകൂടാതെ നാം പൈത്തണില്‍ ഈ രീതി എഴുതി പ്രവര്‍ത്തിപ്പിച്ച് നോക്കുമ്പോഴും ഇത് നമുക്ക് കൂടുതല്‍ ബോധ്യം വരും. യൂക്ളിഡിന്റെ അല്‍ഗോരിതം ഉസാഘ കണ്ടുപിടിക്കാനായി എത്ര സമയം വരെ എടുക്കാം എന്നതിന് (ഈ സമയം ഇന്‍പുട്ട് ആയി കിട്ടുന്ന സംഖ്യകളെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന് വ്യക്തമാണല്ലോ?) കൃത്യമായ കണക്കുകളുണ്ട്. ഇവിടെ ഇതിനെപ്പറ്റി കൂടുതല്‍ വിശദീകരിക്കുന്നില്ല; ഈ സമയപരിധി ഫിബോനാച്ചി സംഖ്യകളുമായി നേരിട്ട് ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന അതിശയകരമായ കാര്യം മാത്രം സൂചിപ്പിക്കുന്നു.
യൂക്ളിഡിന്റെ അല്‍ഗോരിതം : പൈത്തണില്‍
ഇനി നമുക്ക് യൂക്ളിഡിന്റെ അല്‍ഗോരിതം പൈത്തണിലേക്ക് മൊഴിമാറ്റം നടത്താന്‍ ശ്രമിക്കാം. ഇതിന് ഒരു തുടക്കമായി ഈ അല്‍ഗോരിതത്തിലെ എളുപ്പമുള്ള ഭാഗങ്ങള്‍ പൈത്തണിലേക്ക് പകര്‍ത്തിനോക്കാം. പറയാനുള്ള സൗകര്യത്തിനായി a, b-യെക്കാള്‍ വലുതല്ല എന്ന് സങ്കല്‍പ്പിക്കാം:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| # A first attempt at writing Euclid's Algorithm in Python.# We assume that a, b are the two input numbers, and that a# is not larger than b. We want the GCD of a and b to be# stored in the variable gcd.if a == b : gcd = aelse : # Now we know that a is less than b. r = b % a # Find the remainder after division. if r == 0 : gcd = a else : # Find the gcd of r and a. This is the gcd of a # and b. |
ഈ പ്രോഗ്രാമില്‍ b -യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന r എന്ന ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ നമുക്ക് വേണ്ട ഉസാഘ കിട്ടുന്നു. r പൂജ്യത്തെക്കാള്‍ വലുതാണെങ്കില്‍ r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കണമല്ലോ? ഇതിനുള്ള കോഡ് നാം എഴുതിയിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക; ഇതിനുപകരം ഇങ്ങനെ ചെയ്യണം എന്ന് നമ്മെത്തന്നെ ഓര്‍മ്മിപ്പിക്കാനുള്ള ഒരു കമന്റ് മാത്രം യഥാസ്ഥാനത്ത് എഴുതിയിട്ടുണ്ട്.
ഈ കോഡ് നമുക്ക് എങ്ങനെ എഴുതാം? ഇത് മനസ്സിലാക്കാനായി പ്രവര്‍ത്തനം 5-ല്‍ ഈ ഭാഗം എങ്ങനെയാണ് ചെയ്തതെന്ന് ആലോചിച്ചു നോക്കുക. തുടക്കത്തില്‍ കൊടുത്ത a, b എന്നിവയ്ക്ക് പകരം r, a എന്നീ വിലകള്‍ പകരം വെച്ച് ആദ്യം മുതല്‍ ചെയ്താല്‍ മതിയാകും: കടലാസും പേനയും ഉപയോഗിച്ച് ചെയ്തപ്പോഴും ഇങ്ങനെയാണല്ലോ ചെയ്തത്? ഇങ്ങനെ രണ്ടാമതും ചെയ്യുമ്പോള്‍ a == b ആവുകയില്ലല്ലോ (എന്തുകൊണ്ട്?) അതുകൊണ്ട് ഇക്കാര്യം പരിശോധിക്കുന്ന വരി ഒഴിവാക്കാം. ഇങ്ങനെ ഒന്നുകൂടി വിസ്തരിച്ചെഴുതിയ പ്രോഗ്രാം ഇതാ:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| # A first attempt at writing Euclid's Algorithm in Python.# We assume that a, b are the two input numbers, and that a# is not larger than b. We want the GCD of a and b to be# stored in the variable gcd.if a == b : gcd = aelse : # Now we know that a is less than b. r = b % a # Find the remainder after division. if r == 0 : gcd = a else : # We now write out the code to find the gcd # of r and a # First we rename r and a so that we can just # copy the remaining code from above. b = a a = r # Now we just copy the code from above. r = b % a # Find the remainder after division. if r == 0 : gcd = a else : # Find the gcd of r and a. This is the gcd # of a and b. |
ഈ പ്രോഗ്രാമില്‍ നാം എന്താണ് ചെയ്തത് എന്ന് ശ്രദ്ധിക്കുക. ആദ്യത്തെ പ്രോഗ്രാമില്‍ "r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കൂ" എന്ന് കമന്റായി എഴുതിയ സ്ഥാനത്ത് നാം ഇക്കാര്യം ചെയ്യാനുള്ള കോഡ് എഴുതി. ഇതിനായി ആദ്യം r, a എന്നിവയെ യഥാക്രമം a, b എന്നിങ്ങനെ പേരുമാറ്റി; ഇങ്ങനെയാകുമ്പോള്‍ a, b എന്നിവയുടെ ഉസാഘ കാണാന്‍ മുകളില്‍ എഴുതിയ കോഡ് അതേപടി പകര്‍ത്തിയാല്‍ മതിയാകുമല്ലോ. പിന്നെ നാം ഈ കോഡ് മുകളില്‍നിന്ന് പകര്‍ത്തിയെഴുതി. ഇവിടെ രണ്ടാമത്തെ തവണ ഹരിക്കുമ്പോള്‍ കിട്ടുന്ന ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ നമുക്കുവേണ്ടതായ ഉസാഘ കിട്ടും; ഇല്ലെങ്കിലാണ് പ്രശ്നം. ഇവിടെയും ശിഷ്ടം കിട്ടുന്ന r പൂജ്യമല്ലെങ്കില്‍ r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കൂ എന്ന് കമന്റായി മാത്രം വീണ്ടും എഴുതിയത് ശ്രദ്ധിക്കുക.
ഈ രീതിയില് പ്രോഗ്രാം വികസിച്ചുവന്നാലുള്ള കുഴപ്പം മനസ്സിലായല്ലോ? സ്ക്രീനിന്റെ വലതുവശത്തേക്ക് പ്രോഗ്രാം അടിവച്ച് നീങ്ങിപ്പോകുന്നതു പോകട്ടെ, എത്രതവണ ശിഷ്ടം കണ്ടാലാണ് ഉസാഘ കിട്ടുക എന്നത് പ്രോഗ്രാം എഴുതുന്ന സമയത്ത് നമുക്കറിഞ്ഞുകൂടാ എന്ന ഒരു വലിയ പ്രശ്നം ഈ രീതിക്കുണ്ട്: ഇന്‍പുട്ട് കിട്ടുന്ന സംഖ്യകള്‍ക്കനുസരിച്ച് ഇത് എത്രവേണമെങ്കിലും വരെ ആകാം. ഈ പ്രശ്നം എങ്ങനെ പരിഹരിക്കാം? ഇവിടെ നമ്മുടെ കോഡ് എത്ര വരെ പ്രവര്‍ത്തിക്കണം എന്നത് ഒരു വ്യവസ്ഥയെ (condition) ആശ്രയിച്ചിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക: ശിഷ്ടമായി കിട്ടുന്ന r എപ്പോള്‍ പൂജ്യമാകുന്നോ അപ്പോള്‍ നമുക്ക് പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം നിര്‍ത്താം — ഈ സമയത്തെ a-യുടെ വിലയാണ് നമുക്കുവേണ്ട ഉസാഘ.
വ്യവസ്ഥ ശരിയാകുന്നതുവരെ ആവര്‍ത്തിക്കാന്‍: while
ഇങ്ങനെ, ഒരു വ്യവസ്ഥ ശരിയാകുന്നതുവരെ കുറേക്കാര്യങ്ങള്‍ ആവര്‍ത്തിച്ച് ചെയ്യാന്‍ പൈത്തണിലും മറ്റ് മിക്ക കംപ്യൂട്ടര്‍ ഭാഷകളിലുമുള്ള ഉപാധിയാണ്
while . ഇതിനുമുമ്പ് നാം പരിചയപ്പെട്ട if, for എന്നിവയുടെ സമ്മിശ്ര സ്വഭാവമുള്ള ഒരു ഉപാധിയാണ് ഇത്. ഇനി നമുക്ക് while -നെ പരിചയപ്പെടാം. ഇതിനായി താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.
1
2
3
4
5
6
7
8
| number = 0while number < 10 : print 'Hello, the number is now ', number number = number + 1print 'Now we are out of the while loop.\ The number is now ', number |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| first = 10second = 0count = 1# How many times will the print statment be executed?while (first >= second) : print "This is round ", count first = first - 1 second = second + 1 count = count + 1 print 'Now we are out of the while loop. first is now ', \ first, ' and second is now ', second. |
while-നെപ്പറ്റി വിശദമായി
while പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം:പ്രവര്‍ത്തനം
അടിക്കുറിപ്പ്
ഈ പാഠത്തില്‍ നാം കുറെയേറെ പുതിയ കാര്യങ്ങള്‍ കണ്ടു. സാവധാനം മനസ്സിരുത്തി വായിച്ച് ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുകയും പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുനോക്കുകയും ചെയ്താല്‍ അധികം പ്രയാസമില്ലാതെ ഈ പാഠത്തിലെ കാര്യങ്ങള്‍ മനസ്സിലാക്കാം. സംശയങ്ങള്‍ ഉണ്ടാകുമ്പോള്‍ കമന്റുകളിലൂടെ ചോദിക്കുക. മുമ്പ് പലതവണ പറഞ്ഞിട്ടുള്ളതുപോലെ, പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ച് തെറ്റുതിരുത്തി പരിശീലിച്ചാല്‍ അനായാസം സ്വായത്തമാക്കാവുന്ന ഒന്നാണ് പ്രോഗ്രാമിംഗ്.പൈത്തണ്‍ : പാഠം എട്ട്
>> Tuesday, November 8, 2011
ആമുഖം
പൈത്തണ്‍ പാഠങ്ങളില്‍ ഇതുവരെ ചരങ്ങള്‍ (variables),
if .. else , for , while
എന്നിവയെപ്പറ്റി പഠിച്ചല്ലോ. ഈ പാഠത്തില്‍ നമുക്ക് പൈത്തണിലെ ഏകദങ്ങളെ
(functions) പരിചയപ്പെടാം. "ഏകദം" എന്ന സംസ്കൃത വാക്കിന്റെ അര്‍ത്ഥം
"ഒന്നിനെ (ഒരു കാര്യത്തെ) തരുന്നത്" എന്നാണ്. പൈത്തണിലെ ഏകദങ്ങളും "ഒരു കാര്യത്തെ
തരുന്ന"വയാണ്. ഇത് എങ്ങനെയാണെന്ന് വഴിയേ മനസ്സിലാകും. പൈത്തണിലെ function
എന്നതിന് "ഏകദം" എന്ന് മൊഴിമാറ്റം ചെയ്യാനുള്ള കാരണം ഇതാണ്. പൈത്തണിലെ
ഏകദങ്ങള്‍ എന്താണെന്നും നമുക്ക് ആവശ്യമുള്ള ഏകദങ്ങളെ സ്വന്തമായി എങ്ങനെ എഴുതാം എന്നും
ഈ പാഠത്തില്‍ മനസ്സിലാക്കാം.
ഏകദങ്ങള്‍ (functions)
പൈത്തണില്‍ സ്വതവേ ലഭ്യമായ (built-in) കുറച്ച് ഏകദങ്ങളെ നാം ഇതുവരെയുള്ള പാഠങ്ങളില്‍ ഉപയോഗിച്ചുകണ്ടു. range എന്ന ഏകദം ഒരു
എണ്ണല്‍സംഖ്യയെ സ്വീകരിച്ച് പൂജ്യം മുതല്‍ ആ സംഖ്യയ്ക്ക് മുമ്പുവരെയുള്ള
എണ്ണല്‍സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് തിരിച്ചുതരുന്നു. $ python Python 2.7.2 (default, Jun 29 2011, 11:10:00) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> range(15) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> quit()
ഇതേ ഏകദത്തിന് മറ്റ് കഴിവുകളുമുണ്ട്:
$python Python 2.7.2 (default, Jun 29 2011, 11:10:00) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(5, 30) [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] >>> range(5, 30, 3) [5, 8, 11, 14, 17, 20, 23, 26, 29] >>> quit()
ഏകദം സ്വീകരിക്കുന്ന വിലകളെ ഏകദത്തിന്റെ "വാക്യങ്ങള്‍" (arguments) എന്ന് വിളിക്കുന്നു [1]. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണത്തില്‍ 15 എന്ന സംഖ്യയാണ്
range എന്ന ഏകദത്തിന്റെ വാക്യം. രണ്ടാമത്തെ ഉദാഹരണത്തില്‍ range -ന്റെ
വാക്യം 10 എന്ന സംഖ്യയാണ്; മൂന്നാമത്തെ ഉദാഹരണത്തില്‍ ഇത് 5, 30 എന്നീ
രണ്ടു സംഖ്യകളും, അവസാനത്തെ ഉദാഹരണത്തില്‍ 5, 30, 3 എന്നീ മൂന്നു
സംഖ്യകളുമാണ്.
ഒരു ലിസ്റ്റ് അല്ലെങ്കില് സ്ട്രിംഗിന്റെ നീളം (അതിലുള്ള അംഗങ്ങളുടെ/ചിഹ്നങ്ങളുടെ എണ്ണം) കാണാന്‍ ഉപയോഗിക്കാവുന്ന
len ആണ് നാം പരിചയപ്പെട്ട മറ്റൊരു പൈത്തണ്‍ ഏകദം.
$ python Python 2.7.2 (default, Jun 29 2011, 11:10:00) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> len([1, 2, 'a', 3, 'b', 'c', 4]) 7 >>> len("Thiruvananthapuram") 18 >>> quit()
ഇവിടെ ആദ്യത്തെ തവണ
len -ന്റെ വാക്യം [1, 2, 'a', 3, 'b', 'c', 4] എന്ന ലിസ്റ്റാണ്, രണ്ടാമത്തെ തവണ "Thiruvananthapuram" എന്ന സ്ട്രിംഗും.
ഒരു ഏകദത്തെ നമ്മുടെ പ്രോഗ്രാമില്‍ പ്രയോഗിക്കാന്‍ (invoke അല്ലെങ്കില് call എന്ന് ഇംഗ്ലീഷില്‍) ചെയ്യേണ്ടത് ആ ഏകദത്തിന്റെ പേരും, തുടര്‍ന്ന് '(', ')' എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കിടയിലായി ഏകദത്തിന് കൊടുക്കേണ്ടതായ വാക്യവും എഴുതുക എന്നതാണ്. അതായത്
function_name(argument) എന്ന്
പ്രോഗ്രാമില്‍ എഴുതുക. മുകളിലെ ഉദാഹരണങ്ങളിലും ഇങ്ങനെയാണല്ലോ ചെയ്തിട്ടുള്ളത്?
പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുമ്പോള്‍
function_name(argument) എന്ന് കാണുന്നയിടത്ത് ഏകദം അതിന്
കൊടുത്തിരിക്കുന്ന വാക്യത്തിനുമേല്‍ പ്രവര്‍ത്തിച്ചാല്‍ കിട്ടുന്ന മൂല്യം
പകരമായി വരും. ഇത് കുറച്ചുകൂടെ വ്യക്തമാകാന്‍ ഇനിയുള്ള ഉദാഹരണം നോക്കുക:
$ python Python 2.7.2 (default, Jun 29 2011, 11:10:00) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> a = 5 >>> a 5 >>> r = range(10) >>> length = len("Thiruvananthapuram") >>> r [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> length 18 >>> range( 14 ) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] >>> range( len("Pathanamthitta") ) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] >>> quit()
ഈ ഉദാഹരണത്തില്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടതായ കാര്യങ്ങള്‍:
-
range(10),len("Thiruvananthapuram")എന്നീ ഏകദപ്രയോഗങ്ങളുടെ വിലകള്‍ യഥാക്രമംr,lengthഎന്നീ ചരങ്ങളില്‍ സൂക്ഷിച്ച് വെച്ചിരിക്കുന്നു. -
range( (len("Pathanamthitta") )എന്ന പ്രയോഗത്തില്‍rangeഎന്ന ഏകദത്തിന് വാക്യമായിlen("Pathanamthitta")എന്ന ഏകദപ്രയോഗമാണ് കൊടുത്തിരിക്കുന്നത്. പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുമ്പോള്‍ ആദ്യംlen("Pathanamthitta")എന്ന പ്രയോഗത്തിന്റെ മൂല്യം --- 14 എന്ന സംഖ്യ --- കണ്ടുപിടിച്ച്len("Pathanamthitta")എന്ന് പ്രോഗ്രാമില്‍ കാണുന്നതിന് പകരമായി വെയ്ക്കുന്നു. ഇതുകഴിഞ്ഞ്range(14)എന്ന ഏകദപ്രയോഗത്തിന്റെ മൂല്യം കാണുമ്പോഴാണ്[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]എന്ന ലിസ്റ്റ് കിട്ടുന്നത്. - ആദ്യത്തെ ഉദാഹരണങ്ങളില്‍നിന്ന് ഒരുപക്ഷേ മനസ്സിലായേക്കാവുന്ന ഒരു കാര്യം തെറ്റാണെന്ന് ഇവിടെ കാണാം. ഒരു ഏകദത്തെ പ്രയോഗിക്കുമ്പോള്‍ അതിന്റെ മൂല്യം പ്രിന്റ് ചെയ്യപ്പെടുക എന്നത് ഏകദത്തിന്റെ സ്വഭാവം അല്ല . ഈ ഉദാഹരണത്തിലെ
range(10),len("Thiruvananthapuram")എന്നീ പ്രയോഗങ്ങളുംlen("Pathanamthitta")എന്ന പ്രയോഗവും ഇത് വ്യക്തമാക്കുന്നു. തന്നിരിക്കുന്ന വ്യഞ്ജകത്തിന്റെ (expression) മൂല്യം പ്രിന്റ് ചെയ്യുക എന്നത് ഷെല്ലിന്റെ പ്രത്യേകത ആയതുകൊണ്ടാണ് ഇതിന് മുമ്പുള്ള ഉദാഹരണങ്ങളില്‍ ഓരോ ഏകദപ്രയോഗത്തിന്റെയും വില പ്രിന്റ് ചെയ്യപ്പെട്ടത്.
ഏകദങ്ങളെ നിര്‍‌വചിക്കുന്ന വിധം.
range, len എന്നിവ കൂടാതെ പൈത്തണില്‍ സ്വതവേ ലഭ്യമായ
(built-in) ഒട്ടനേകം ഏകദങ്ങളുണ്ട്. ഇതുകൂടാതെ ആവശ്യമുള്ള ഏകദങ്ങളെ നമുക്ക് സ്വയം
നിര്‍‌വചിച്ച് (define) ഉപയോഗിക്കുകയും ചെയ്യാം. ഇതെങ്ങനെയാണ് ചെയ്യുന്നതെന്ന്
നോക്കാം. ആദ്യമായി, രണ്ട് സംഖ്യകളെ സ്വീകരിച്ച് അവയുടെ തുക തിരിച്ചുതരുന്ന,
ലളിതമായ ഒരു ഏകദം എഴുതാം. ഏകദത്തിന് പേരുകൊടുക്കുമ്പോള്‍ ഏകദം
ചെയ്യുന്നതെന്താണെന്ന് സൂചിപ്പിക്കുന്ന തരത്തിലുള്ള പേര് കൊടുക്കുന്നതാണ് നല്ല രീതി. നമ്മുടെ
ഏകദത്തിന് നമുക്ക് add എന്ന് പേരുകൊടുക്കാം.
1
2
3
4
5
| # This function takes two numbers as arguments and returns their sum.def add (a, b) : sum = a + b return sum |
add
(a, b) എന്നതില്‍ a , b എന്നിവയ്ക്ക് പകരം സംഖ്യകള്‍
കൊടുത്ത് നമുക്കിത് പരീക്ഷിക്കാം. താഴെക്കാണുന്ന ചിത്രം നോക്കുക (ചിത്രം
വ്യക്തമായി കാണാന്‍ അതില്‍ അമര്ത്തുക).
add എന്ന ഏകദം കൃത്യം രണ്ട് വാക്യങ്ങളേ
സ്വീകരിക്കൂ എന്ന് ചിത്രത്തിലെ അവസാനത്തെ രണ്ട് സന്ദേശങ്ങളില്‍നിന്ന് മനസ്സിലാക്കാം.
IDLE-നെ കൂടാതെ പൈത്തണ്‍ ഷെല്‍ വഴിയായും (വേണമെങ്കില്‍) ഈ ഏകദം പ്രയോഗിച്ചുനോക്കാന്‍ കഴിയും. ഇതിനായി ടെര്‍മിനല്‍ തുറന്ന് add.py എന്ന ഫയല്‍ സേവ് ചെയ്ത ഡയറക്ടറിയിലേക്ക് മാറുക. അവിടെ
python -i add.py എന്ന കമാന്റ്
കൊടുക്കുക. ഇനി വരുന്ന ഷെല്ലില്‍ നാമെഴുതിയ add എന്ന ഏകദം
ലഭ്യമാണ് :
$ python -i add.py >>> add (10, 100) 110 >>> add (-2, 5) 3 >>> quit() $ exit
add എന്ന ഏകദം നാം നിര്‍‌വചിച്ചത് എങ്ങനെയാണെന്ന് ഒന്നുകൂടി നോക്കാം:
1
2
3
4
5
| # This function takes two numbers as arguments and returns their sum.def add (a, b) : sum = a + b return sum |
- നിര്‍‌വചനത്തിന്റെ ആദ്യത്തെ വരി (നമ്മുടെ പ്രോഗ്രാമിലെ മൂന്നാമത്തെ
വരി) ഏകദത്തിന്റെ ശീര്‍ഷകമാണ്. ഏകദത്തിന്റെ പേരും അതിന് കൊടുക്കുന്ന
വാക്യങ്ങളുടെ പേരുകളും ഈ വരിയില്‍ വ്യക്തമാക്കുന്നു. ഈ വരിയുടെ വ്യാകരണം
ഇതാണ്:
def function_name ( argument_names ) :.-
defഎന്നത് ഏകദം നിര്‍‌വചിക്കാന്‍ (define) ഉപയോഗിക്കുന്ന പ്രത്യേകവാക്ക് (keyword) ആണ്. define എന്നതിന്റെ ചുരുക്കമാണ് ഇത്. -
defകഴിഞ്ഞ് അതേ വരിയില്‍ ഏകദത്തിന്റെ (നമുക്ക് ഇഷ്ടമുള്ള) പേര് (function name) കൊടുത്തിരിക്കുന്നു. നമ്മുടെ ഉദാഹരണത്തില്‍ ഇത്addഎന്നാണ്. - ഏകദത്തിന്റെ പേരിനുശേഷം '(', ')' എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി
ഏകദത്തിന്റെ വാക്യങ്ങളുടെ (arguments) പേര്(കള്‍) പറയുന്നു. ഒന്നിലധികം
വാക്യങ്ങളുണ്ടെങ്കില്‍ അവയെ കോമയുപയോഗിച്ച് വേര്‍തിരിക്കുന്നു. വാക്യങ്ങളുടെ
പേരും നമുക്ക് ഇഷ്ടമുള്ളത് കൊടുക്കാം. ഇവിടെ
a, bഎന്നിവയാണ് നമ്മുടെ ഏകദത്തിന്റെ വാക്യങ്ങള്‍. ഈ വരിയുടെ അവസാനമുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക. ഏകദത്തിന്റെ പേരും വാക്യങ്ങളുടെ പേരും പറഞ്ഞുകഴിഞ്ഞു എന്ന് പൈത്തണിന് മനസ്സിലാകുന്നത് ഈ:കാണുമ്പോഴാണ്.
-
- ഏകദത്തിന്റെ ശീര്‍ഷകം കഴിഞ്ഞുള്ള വരികളില്‍ ഏകദത്തിന്റെ ഉള്ളടക്കം
എഴുതണം. നമ്മുടെ ഉദാഹരണത്തില്‍ ഏകദത്തിന്റെ ഉള്ളടക്കം
sum = a + b,return sumഎന്നീ രണ്ടു വരികളാണ്. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ശീര്‍ഷകത്തെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. കൂടാതെif .. else, whileഎന്നിവ ഉള്ളടക്കത്തില്‍ ഉപയോഗിക്കുന്നുണ്ടെങ്കില്‍ നിരപ്പിനെ (indentation) സംബന്ധിച്ച അവയുടെ നിയമങ്ങളും പാലിക്കണം. ഇനിയുള്ള ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഇത് മനസ്സിലാകും. - മുകളിലെ ഉദാഹരണത്തില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (നാലാമത്തെ വരി). ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍ ശീര്‍ഷകത്തിന്റെ
അവസാനമുള്ള
:എഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കപ്പോഴും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. - ഏകദം തിരിച്ചുതരേണ്ടതായ മൂല്യം നിര്‍മ്മിക്കാന്‍ ആവശ്യമായ പൈത്തണ്‍ കോഡ്
ഏകദത്തിന്റെ ഉള്ളടക്കത്തില്‍ എഴുതണം. ഇങ്ങനെ എഴുതുമ്പോള്‍ ഏകദത്തിന്റെ വാക്യങ്ങളെ
ചരങ്ങളായി ഉപയോഗിക്കാം. നമ്മുടെ ഉദാഹരണത്തിലെ ഉള്ളടക്കത്തില്‍
sumഎന്ന ചരത്തിന് ഏകദത്തിന്റെ വാക്യങ്ങളായa, bഎന്നീ ചരങ്ങളുടെ തുക വിലയായി കൊടുത്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക. - ഏകദം തിരിച്ചുതരേണ്ടതായ വില കണ്ടുപിടിച്ചുകഴിഞ്ഞാല്‍ അത്
returnഎന്ന പ്രത്യേകവാക്ക് (keyword) ഉപയോഗിച്ച് ഏകദത്തില്‍നിന്ന് തിരിച്ചുകൊടുക്കാം. നമ്മുടെ ഉദാഹരണത്തില്‍return sumഎന്ന് എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. - ഇങ്ങനെ
returnഎന്ന പ്രയോഗം കണ്ടാല്‍ ആ വില ഏകദത്തില്‍നിന്ന് തിരിച്ചുകൊടുക്കും. കൂടാതെ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം ഏകദത്തിന് പുറത്ത് (പ്രോഗ്രാമില്‍ ഏകദത്തിനെ പ്രയോഗിച്ച സ്ഥലത്ത്) എത്തിച്ചേരുകയും ചെയ്യും. - ഏകദത്തിന്റെ ഉള്ളടക്കം എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരി ഏകദത്തിന്റെ ശീര്‍ഷകം തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം. ഏകദത്തിന്റെ നിര്വചനം പൂര്‍ത്തിയായി എന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത് ഇത് കാണുമ്പോഴാണ്. ഇനിയുള്ള ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഇത് മനസ്സിലാകും.
- ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
larger എന്ന് വിളിക്കാം. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരും.
1
2
3
4
5
6
7
8
9
| # This function takes two numbers as arguments and returns the # larger of the two. If both the numbers are the same, the # function returns this number.def larger (first, second) : if first >= second : return first else : return second |
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 1.
- മുകളില്‍ കൊടുത്ത ഏകദം വായിച്ചു മനസ്സിലാക്കുക. ഇത് എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.
- പ്രവ. 2.
- ഈ പ്രോഗ്രാം larger.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് (larger.py
എന്നതിനു പകരം നിങ്ങള്‍ക്ക് ഇഷ്ടമുള്ള .py എന്ന് അവസാനിക്കുന്ന
പേരുകൊടുക്കാം) IDLE-ല്‍ (അല്ലെങ്കില് ഷെല്ലില്‍) ലഭ്യമാക്കുക.
largerഎന്ന ഏകദത്തിന് പല ജോടി സംഖ്യകള്‍ വാക്യങ്ങളായി കൊടുത്ത് അത് ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക. - പ്രവ. 3.
- രണ്ട് സംഖ്യകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ ചെറുതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഈ ഏകദത്തിന്
smallerഎന്ന് പേരുകൊടുക്കുക. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരണം. ഈ പ്രോഗ്രാം smaller.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE (അല്ലെങ്കില് ഷെല്‍) വഴിയായി അതിന്റെ പ്രവര്‍ത്തനം പരീക്ഷിച്ചുനോക്കുക.
ഇനി നമുക്ക് രണ്ട് സ്ട്രിംഗുകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ കൂടുതല്‍ നീളമുള്ളതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. രണ്ട് സ്ട്രിംഗുകള്‍ക്കും ഒരേ നീളമാണെങ്കില്‍ ഏകദം ആദ്യത്തെ സ്ട്രിംഗിനെ തിരിച്ചുതരും. ഈ ഏകദത്തിന് നമുക്ക്
longer എന്ന് പേരിടാം. ഈ ഏകദത്തിന് larger എന്ന ഏകദത്തിനോടുള്ള സാമ്യം ശ്രദ്ധിക്കുക.
1
2
3
4
5
6
7
8
9
| # This function takes two strings as arguments and returns the# longer of the two. If both strings are of the same length, the# function returns the first string.def longer (first, second) : if len(first) >= len(second) : return first else : return second |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| # This program finds the "longest" district in Kerala, and# its length when written in English.# This is a list of the districts in Kerala.districts = ["Kasaragod", "Kannur", "Wayanad", "Kozhikode", \ "Malappuram", "Palakkad", "Thrissur", "Ernakulam", \ "Idukki", "Kottayam", "Alappuzha", "Pathanamthitta",\ "Kollam", "Thiruvananthapuram"]longest_district = ""max_length = 0for dist in districts : length = len(dist) if length > max_length : # We have found a new district # whose name is longer than all # that we have seen so far. longest_district = dist max_length = length# We are now out of the "for" loopprint "The district with the longest name is: ", \ longest_district, "."print "Its name has ", max_length, " letters." |
longer എന്ന ഏകദമുപയോഗിച്ച് എഴുതിയാല്‍ ഇങ്ങനെയാകും:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| # This program finds the "longest" district in Kerala, and# its length when written in English.# This function takes two strings as arguments and returns the# longer of the two. If both strings are of the same length, the# function returns the first string.def longer (first, second) : if len(first) >= len(second) : return first else : return second# This is a list of the districts in Kerala.districts = ["Kasaragod", "Kannur", "Wayanad", "Kozhikode", \ "Malappuram", "Palakkad", "Thrissur", "Ernakulam", \ "Idukki", "Kottayam", "Alappuzha", "Pathanamthitta",\ "Kollam", "Thiruvananthapuram"]# At first we don't know which is the longest district, # so we assume it is the first one in the list.longest_district = districts[0]# Go over each district and compare it with the current# longest district.for district in districts : longest_district = longer(longest_district, district) # We are now out of the "for" loopprint "The district with the longest name is: ", \ longest_district, "."print "Its name has ", len(longest_district), " letters." |
longer
എന്ന ഏകദത്തിന്റെ നിര്വചനം ഇങ്ങനെ ഉപയോഗിക്കുന്നതിന് മുമ്പായി (8 മുതല്‍ 12
വരെയുള്ള വരികളിലായി) എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒരു ഏകദം ഉപയോഗിക്കുന്നതിന്
മുമ്പ് അതിന്റെ നിര്വചനം എഴുതിയിരിക്കണം. ഇത് മറ്റൊരു ഫയലില്‍ എഴുതാനുള്ള
സംവിധാനവുമുണ്ട്. അതായത്, ഏകദത്തിന്റെ നിര്വചനം ഒരു ഫയലിലും, അതിന്റെ പ്രയോഗം
വേറൊരു ഫയലിലും വേണമെങ്കില്‍ ആകാം. ഇത് എങ്ങനെയാണ് ചെയ്യേണ്ടതെന്ന് വഴിയേ
കാണാം. ഈ പാഠത്തില്‍ നമുക്ക് ഏകദത്തിന്റെ നിര്‍വചനവും അത് പ്രയോഗിക്കുന്ന
പ്രോഗ്രാമും ഒരേ ഫയലില്‍ത്തന്നെ എഴുതാം.
പ്രവര്‍ത്തനങ്ങള്‍
- പ്രവ. 4.
- മുകളില്‍ കൊടുത്ത പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.
- പ്രവ. 5.
- ഈ പ്രോഗ്രാം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലാക്കുക. ഇതില്‍
longerഎന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് (27-ആം വരിയില്‍ )എങ്ങനെയാണെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.
ഇനി സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. ഇതിന്
largest എന്ന്
പേരിടാം. ഈ ഏകദത്തിന് മുകളിലത്തെ പ്രോഗ്രാമുമായുള്ള സാമ്യം
ശ്രദ്ധിക്കുക. largest എന്ന ഏകദത്തില്‍
larger എന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് കാണുക. ഇങ്ങനെ
ഉപയോഗിക്കുവാന്‍‌വേണ്ടി, largest എന്ന ഏകദത്തിന്
മുമ്പായി larger എന്ന ഏകദത്തിന്റെ നിര്വചനം
എടുത്തെഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ പാഠത്തിലുടനീളം ഇങ്ങനെയാവും നാം
പ്രോഗ്രാമുകളെഴുതുക.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| # This function takes two numbers as arguments and returns the # larger of the two. If both the numbers are the same, the # function returns this number.def larger (first, second) : if first >= second : return first else : return second# This function takes a list of numbers as arguments and returns # the largest number in the list. def largest (numbers) : # At first we don't know which is the largest number, # so we assume it is the first one in the list. largest = numbers[0] # Go over each number and compare it with the current # largest. for n in numbers : largest = larger (largest, n) return largest |
largest
എന്ന ഏകദം ലഭ്യമാണ്. സംഖ്യകളുടെ പല ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്ത്
ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ട് എന്ന് ഉറപ്പുവരുത്തുക.
ഉദാഹരണങ്ങള്‍ക്കായി ചിത്രം കാണുക(ചിത്രം
വ്യക്തമായി കാണാന്‍ അതില്‍ അമര്ത്തുക).
പ്രവര്‍ത്തനം
- പ്രവ. 6.
- സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഇതിന്
smallestഎന്ന് പേരിടുക. ഈ ഏകദം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് ഫയല്‍ IDLE-ലോ ഷെല്ലിലോ പ്രവര്‍ത്തിപ്പിക്കുക. ഇനി ഈ ഏകദത്തിന് താഴെക്കൊടുത്തിരിക്കുന്ന ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്തുനോക്കുക. ഉത്തരം ശരിയാകുന്നുണ്ടോ?- [1, 0]
- [1, 1, 1, 1, 0]
- [1, 1, 1, 1, 0, 1]
- [1, 2, 3, 4, 5]
- [5, 4, 3, 2, 1]
ക്രമീകരണം (Sorting)
ഒരു കൂട്ടം സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത് അവയെ അവരോഹണക്രമത്തില്‍ (ഏറ്റവും വലുത് ആദ്യം വരുന്ന ക്രമത്തില്‍ --- ഇംഗ്ളീഷില്‍ descending order) ക്രമപ്പെടുത്തുന്ന ഒരു പ്രോഗ്രാം ഇനി നമുക്ക് എഴുതാം. ഇതിന് നാം എഴുതിയ largest എന്ന ഏകദം ചെറിയ മാറ്റങ്ങളോടെ ഉപയോഗിക്കാം.
ഇങ്ങനെയോ മറിച്ചുള്ള (ആരോഹണ) ക്രമത്തിലോ സംഖ്യകളെ (മറ്റ് വിവരങ്ങളേയും) അടുക്കുന്നതിന് ക്രമീകരണം (Sorting) എന്നു പറയുന്നു. ഇത് കംപ്യൂട്ടര്‍ പ്രോഗ്രാമുകളില്‍ (അല്ലാതെയും) വളരെയധികം ആവശ്യമുള്ള ഒരു പ്രവര്‍ത്തനമാണ്. ക്രമീകരിച്ച വിവരങ്ങളില്‍ പരതാനും മറ്റും വളരെ എളുപ്പമാണ്: നൂറുകണക്കിന് പേജുകളിലായി പതിനായിരക്കണക്കിന് വാക്കുകളുടെ അര്‍ത്ഥങ്ങള്‍ കൊടുത്തിരിക്കുന്ന ഒരു നിഘണ്ടുവില്‍ നമുക്ക് ആവശ്യമുള്ള വാക്കിന്റെ അര്‍ത്ഥം കണ്ടുപിടിക്കാന്‍ എത്ര എളുപ്പമാണ് എന്നത് ഓര്‍ക്കുക. അതുപോലെ, ആയിരക്കണക്കിന് ആളുകളുടെ പേരും ഫോണ്‍ നമ്പരും കൊടുത്തിട്ടുള്ള ഫോണ്‍ ഡയറക്ടറിയില്‍ നിന്ന് ഒരാളുടെ ഫോണ്‍ നമ്പര്‍ കണ്ടുപിടിക്കാന്‍ കുറച്ചു സമയമല്ലേ വേണ്ടൂ? നിഘണ്ടുവിലെ വാക്കുകളും ഫോണ്‍ ഡയറക്ടറിയിലെ പേരുകളും (അക്ഷരമാലാ ക്രമത്തില്‍) ക്രമീകരിച്ചിരിക്കുന്നതുകൊണ്ടാണ് ഇത് സാധ്യമാകുന്നത്. ക്രമീകരണത്തിനായി പലതരം അ‍ല്‍ഗോരിതങ്ങള്‍ (പ്രവര്‍ത്തനരീതികള്‍) ലഭ്യമാണ്. ഇവയില്‍ ലളിതമായ ഒരു രീതി നമുക്ക് ഈ പാഠത്തില്‍ പ്രോഗ്രാമായി എഴുതാം. ഈ രീതിയുടെ പേര് "തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം" (Selection sort) എന്നാണ്. ഇതിന്റെ ആശയം മനസ്സിലാക്കാന്‍ വളരെ എളുപ്പമാണ്. ഈ രീതിയുടെ പ്രവര്‍ത്തനം ഇങ്ങനെയാണ്:
- ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍, അഥവാ ലിസ്റ്റില്‍ ഒരേ ഒരു അംഗം (സംഖ്യ) മാത്രമേയുള്ളൂ എങ്കില്‍ ലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ഇങ്ങനെയാണെങ്കില്‍ തന്നിരിക്കുന്ന ലിസ്റ്റിനെത്തന്നെ ഉത്തരമായി തിരിച്ചുകൊടുക്കുക. ഇങ്ങനെ അല്ലെങ്കില് (ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍):
- ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതെന്ന് കണ്ടുപിടിക്കുക. ഇത് a എന്ന സംഖ്യ ആണെന്നിരിക്കട്ടെ :
- a എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരിക. ഇതിനായി a-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറുക. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില്‍ ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
- ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില് ക്രമീകരിക്കുക.
- ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല്‍ അവസാനത്തതു വരെയുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
- ശുഭം!
നമുക്ക് ക്രമീകരിക്കേണ്ട ലിസ്റ്റ് ഇതാണ്:
ഇനി പടി (2.ii)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗം ഇതേ രീതിയില് ക്രമീകരിക്കണം. ഇതിനായി നാം ഈ പ്രവര്‍ത്തനരീതി തുടക്കം മുതല്‍
[15, 1, 7] എന്ന ലിസ്റ്റിന്റെമേല്‍ പ്രയോഗിക്കണം. ഈ ലിസ്റ്റിലും ഒന്നിലധികം അംഗങ്ങളുള്ളതുകൊണ്ട് രീതിയുടെ ഒന്നാം പടി ഇവിടെ ബാധകമല്ല. അതുകൊണ്ട് നാം പടി 2 പ്രകാരം ഈ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടുപിടിക്കുന്നു. ഇത് 15 ആണ്.
[1, 7] എന്ന ലിസ്റ്റ് ക്രമീകരിക്കുന്നു.
പ്രവര്‍ത്തനം
- പ്രവ. 7.
- തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായെന്ന് ഉറപ്പുവരുത്താന്‍ [35, 2, 3, 56, 5, 7, 9] എന്ന ലിസ്റ്റിന്റെ കടലാസും പേനയുമുപയോഗിച്ച് ഈ രീതിയില് അവരോഹണക്രമത്തില്‍ — ഏറ്റവും വലിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില്‍ — ക്രമീകരിക്കുക.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം നടപ്പിലാക്കുന്ന ഒരു പൈത്തണ്‍ ഏകദം എഴുതുക എന്നതാണ് ഈ പാഠത്തില്‍ ഇനി നാം ചെയ്യാന്‍ പോകുന്നത്. അതിനുമുമ്പ് ഈ രീതി പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് നന്നായി മനസ്സിലാക്കണം. ഈ രീതിയുടെ ഒന്നാമത്തെ പടി ശരിയാണെന്ന് നിസ്സംശയം പറയാമല്ലോ? ഒരേ ഒരംഗം മാത്രമുള്ള ലിസ്റ്റ് തീര്‍ച്ചയായും ക്രമീകരിക്കപ്പെട്ടതുതന്നെയാണ്.
ഈ രീതിയുടെ കാതലായ ഭാഗം അതിന്റെ രണ്ടാമത്തെ പടിയാണ്. ഇവിടെ ലിസ്റ്റിലെ ഏറ്റവും വലിയ അംഗത്തിനെ കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ക്രമീകരിക്കപ്പെട്ട ലിസ്റ്റില്‍ ഈ അംഗം ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ത്തന്നെയാണല്ലോ വരേണ്ടത്? അപ്പോള്‍ ഇങ്ങനെ ചെയ്യുന്നതുവഴി നാം ഉത്തരത്തിലേക്ക് ഒരു ചെറിയ പടി മുന്നേറുന്നു.ഇനി ബാക്കിയുള്ള ലിസ്റ്റ് ക്രമീകരിച്ചാല്‍ മാത്രം മതി. ഇതിന് ഇതേ രീതി ആ ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിച്ചാല്‍ മതിയെന്ന് പറയുന്നത് ബോധ്യപ്പെട്ടോ? "ഇതേ രീതി" ആ (ഉപ)ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിക്കുമ്പോള്‍ എന്താണ് സംഭവിക്കുന്നതെന്ന് ആലോചിച്ചുനോക്കൂ.
- ഉപലിസ്റ്റില്‍ ഒരംഗമേയുള്ളൂവെങ്കില്‍ ഉപലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ( കൂടാതെ ഈ സംഖ്യ മൊത്തം ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയുമാണ് — ഇതെന്തുകൊണ്ടാണെന്ന് ആലോചിച്ചുനോക്കൂ.) അപ്പോള്‍ ലിസ്റ്റ് മുഴുവനായും ക്രമത്തില്‍ ആയിക്കഴിഞ്ഞു.
- ഉപലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍ നമ്മുടെ പ്രവര്‍ത്തനരീതി അതില്‍ ഏറ്റവും വലിയ സംഖ്യയെ കണ്ടുപിടിച്ച് ഉപലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ഇത് ശരിയായ നടപടി തന്നെയല്ലേ? ഇനി ഈ ഉപലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ലിസ്റ്റിനെ ("ഉപൗപ" ലിസ്റ്റിനെ) ക്രമീകരിച്ചാല്‍ മൊത്തം ലിസ്റ്റും ക്രമത്തിലാകും. നമ്മുടെ രീതിയും ഇതുതന്നെയാണ് ചെയ്യുന്നത്.
പ്രവര്‍ത്തനം
- പ്രവ. 8.
- തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ ആശയം — പ്രത്യേകിച്ച്, "ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗത്തിനെ ഇതേ രീതിയില് കൈകാര്യം ചെയ്യുക" എന്നുള്ളത് — ശരിയാണെന്ന് വ്യക്തമായി ബോധ്യപ്പെട്ടാലേ ഈ പാഠത്തിന്റെ ബാക്കിയുള്ള ഭാഗം നന്നായി മനസ്സിലാകൂ. അതുകൊണ്ട് ഈ രീതിയുടെ വിവരണവും വിശദീകരണവും പല പ്രാവശ്യം വായിക്കുക. തന്നിരിക്കുന്ന ഉദാഹരണം പ്രവര്‍ത്തിക്കുന്നത് ഇതേപോലെയാണെന്ന് ഉറപ്പുവരുത്തുക. പ്രവര്‍ത്തനം 6 ചെയ്തുനോക്കി അതും മുകളില്‍ പറഞ്ഞതും തമ്മില്‍ പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് നോക്കുക.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 1
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ ആശയം മനസ്സിലായല്ലോ? ഇനി നമുക്ക് ഈ ആശയം പൈത്തണുപയോഗിച്ച് പ്രാവര്‍ത്തികമാക്കുന്ന ഒരു പ്രോഗ്രാമെഴുതാം, പല ഘട്ടങ്ങളായി.ഒന്നാമതായി നമുക്ക് ഈ പ്രവര്‍ത്തനരീതിയുടെ പടി 2.ii-ന് ആവശ്യമുള്ള ഒരു കാര്യം ചെയ്യുന്നത് എങ്ങനെയാണെന്ന് നോക്കാം. രണ്ടോ അതിലധികമോ അംഗങ്ങളുള്ള ഒരു ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഉപലിസ്റ്റ് എടുക്കുന്നതെങ്ങനെ എന്നതാണ് ഇത്. ഇങ്ങനെയുള്ള ഉപലിസ്റ്റിനെയാണല്ലോ പടി 2.ii പ്രകാരം "ഇതേ രീതിയില്" ക്രമീകരിക്കേണ്ടത്?
ഇങ്ങനെയുള്ള ഒരു ഉപലിസ്റ്റ് എടുക്കല്‍ വളരെ എളുപ്പമുള്ള കാര്യമാണ്:
myList ഒരു ലിസ്റ്റാണെന്നിരിക്കട്ടെ. ലിസ്റ്റിന്റെ ആദ്യത്തെ
അംഗത്തിന്റെ സ്ഥാനം (index) പൂജ്യം ആണല്ലോ. ലിസ്റ്റിന്റെ രണ്ടാമത്തെ
അംഗത്തിന്റെ സ്ഥാനം 1 ആണ്. ഈ ലിസ്റ്റിന്റെ രണ്ടുമുതലുള്ള അംഗങ്ങള്‍ മാത്രമുള്ള ഒരു
ഉപലിസ്റ്റ് കിട്ടാന്‍ myList[1:] എന്ന് പറഞ്ഞാല്‍
മതി. ഇവിടെ 1: എന്നതിനെ "ഒന്നുമുതല്‍" എന്ന്
വായിക്കാം. ലിസ്റ്റിലെ സ്ഥാനങ്ങള്‍ പൂജ്യം മുതല്‍
എണ്ണിത്തുടങ്ങുന്നതുകൊണ്ട്, സ്ഥാനം
ഒന്നുമുതല്‍ എന്ന് പറയുമ്പോള്‍ രണ്ടാമത്തെ അംഗം മുതല്‍ എന്നാണല്ലോ
അര്‍ത്ഥം. ഈ രീതിയില് ഉപലിസ്റ്റ് എടുക്കുന്ന രീതി വ്യക്തമാക്കുന്ന ചില
ഉദാഹരണങ്ങള്‍ ഇതാ:
$ python Python 2.7.2 (default, Jun 29 2011, 11:10:00) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> list1 = [10, 20, 30, 40, 50, 60] >>> list2 = list1[1:] >>> list2 [20, 30, 40, 50, 60] >>> list3 = list2[1:] >>> list3 [30, 40, 50, 60] >>> list4 = list3[1:] >>> list4 [40, 50, 60] >>> quit() $
നമുക്ക് ഒന്നുമുതലല്ലാതെ "പൂജ്യം മുതല്‍" എണ്ണി പരിചയമില്ലാത്തതുകൊണ്ട് ലിസ്റ്റിന്റെ കാര്യത്തില്‍ ഇങ്ങനെ ചെയ്യേണ്ടിവരുമ്പോള്‍ കുറച്ച് അപരിചിതത്വം തോന്നും. ഇത് അല്‍പകാലത്തെ പരിചയം കൊണ്ട് മാറിക്കൊള്ളും.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 2
ലിസ്റ്റിലെ വലിയ സംഖ്യ കണ്ടുപിടിച്ചുകഴിഞ്ഞാല്‍ (പടി 2) അത് ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരണമല്ലോ. ഇതിനായി വലിയ സംഖ്യയും ലിസ്റ്റിന്റെ തുടക്കത്തിലെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറണം (പടി 2.i). ഇത് ചെയ്യാനായി വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയാണ് എന്നറിയണം. സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിച്ച് അതില്‍ ഏറ്റവും വലുത് കണ്ടുപിടിച്ചുതരുന്ന ഒരു ഏകദം ( largest ) നാം എഴുതിയല്ലോ. ഈ ഏകദം
പക്ഷേ വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയായിരുന്നു എന്ന് പറഞ്ഞുതരുന്നില്ല. ഇനി ഈ ഏകദത്തില്‍
ചെറിയ മാറ്റം വരുത്തി, ഏറ്റവും വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയാണ് എന്നതുകൂടി
തിരിച്ചുതരുന്ന ഒരു ഏകദം നമുക്കെഴുതാം. ഈ ഏകദത്തിനെ നമുക്ക്
largest2 എന്ന് വിളിക്കാം.
largest എന്ന ഏകദത്തിനുള്ളില്‍ larger എന്ന
ഏകദം ഉപയോഗിച്ചല്ലോ? രണ്ട് സംഖ്യകള്‍ സ്വീകരിച്ച് അവയില്‍ വലുതിനെ തിരിച്ചുതരിക
എന്നതാണ് ഈ ഏകദം ചെയ്യുന്നത്. largest2 എന്ന ഏകദത്തില്‍
പ്രയോഗിക്കാനായി larger -ല്‍ ചെറിയൊരു മാറ്റം
വേണം. മുമ്പത്തേതുപോലെ, ഈ ഏകദം രണ്ട് സംഖ്യകളെ വാക്യങ്ങളായി സ്വീകരിച്ച്
അവയില്‍ വലുത് ഏതാണെന്ന് പറയണം. ഇതു കൂടാതെ ഒരു കാര്യം കൂടി നമുക്ക് അറിയണം :
ഏകദത്തിന് വാക്യങ്ങളായി കൊടുത്ത രണ്ട് സംഖ്യകളില്‍ രണ്ടാമത്തേതാണോ വലിയത് എന്ന
കാര്യമാണ് അറിയേണ്ടത്. (ഇതറിയുന്നത് എന്തിനാണെന്ന് വഴിയേ മനസ്സിലാകും.) ഈ
മാറ്റങ്ങളോടുകൂടിയ larger -നെ നമുക്ക്
larger2 എന്ന് വിളിക്കാം. larger2 നമുക്ക്
തിരിച്ചുതരുന്നത് രണ്ടംഗങ്ങളുള്ള ഒരു ലിസ്റ്റാണ്. ഈ ലിസ്റ്റില്‍ ആദ്യത്തെ അംഗം ഈ ഏകദത്തിന്റെ
വാക്യങ്ങളി‌ലെ വലിയ സംഖ്യയാണ്. രണ്ടാമത്തെ അംഗം ഒരു ബൂളിയന്‍ മൂല്യം (ശരി
അല്ലെങ്കില് തെറ്റ്) ആണ്. രണ്ടു വാക്യങ്ങളില്‍ രണ്ടാമത്തേതാണ് വലുതെങ്കില്‍
ഈ മൂല്യം True ആണ്. അല്ലെങ്കില്
False -ഉം. larger2 നമുക്ക് ഇങ്ങനെയെഴുതാം:
1
2
3
4
5
6
7
8
9
10
| # This function takes two numbers as arguments and returns a list# with two values. The first member of the list is the larger of# the two arguments. The second member is True if the second# argument is larger than the first, and False otherwise.def larger2(first, second) : if first >= second : return [first, False] else : return [second, True] |
$ python -i larger2.py >>> larger2(1, 10) [10, True] >>> larger2(10, 1) [10, False] >>> quit()
പ്രവര്‍ത്തനം
- പ്രവ. 9.
- പലപല സംഖ്യാജോടികള്‍ വാക്യങ്ങളായി കൊടുത്ത്
larger2എന്ന ഏകദം പ്രവര്‍ത്തിപ്പിക്കുക. ഏകദത്തിന്റെ പ്രവര്‍ത്തനം മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.
ഇനി നമുക്ക് ഈ ഏകദമുപയോഗിച്ച് നമുക്കുവേണ്ട
largest2 എന്ന ഏകദം എഴുതാം:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| # This function takes two numbers as arguments and returns a list# with two values. The first member of the list is the larger of# the two arguments. The second member is True if the second# argument is larger than the first, and False otherwise.def larger2(first, second) : if first >= second : return [first, False] else : return [second, True]# This function takes a list of numbers as arguments and finds # the largest number in the list. It returns a list of two numbers:# the largest number in the list, and the index of the largest number.def largest2(numbers) : # At first we don't know which is the largest number, # so we assume it is the first one in the list. largest = numbers[0] index = 0 # Go over each number and compare it with the current # largest. i = 0 for n in numbers : [largest, flipped] = larger2(largest, n) if flipped : index = i i = i + 1 return [largest, index] |
മുകളിലെ പ്രോഗ്രാം നമുക്കൊന്ന് വിശദമായി വായിക്കാം. ഒന്നു മുതല്‍ പത്തുവരെയുള്ള വരികളില്‍
larger2 എന്ന ഏകദത്തിന്റെ നിര്‍വചനമാണ്. 12 മുതല്‍
31 വരെയുള്ള വരികളിലാണ് largest2 എന്ന ഏകദം
നിര്‍വചിച്ചിരിക്കുന്നത്. ഇതില്‍ത്തന്നെ 12 മുതല്‍ 14 വരെയുള്ള വരികള്‍ ഏകദം എന്താണ്
ചെയ്യുന്നത് (ചെയ്യേണ്ടത്!) എന്ന് വിശദമാക്കുന്ന കമന്റാണ്. ഇങ്ങനെ കമന്റ് എഴുതുന്നതിന്റെ
ഒരു പ്രധാന ഉദ്ദേശം ഇതാണ് : മറ്റൊരാള്‍ക്കോ (കുറച്ചുകാലം കഴിഞ്ഞാല്‍
നമുക്കുതന്നെയോ) ഏകദത്തിന്റെ ഉള്ളടക്കം വായിക്കാതെതന്നെ അത് എന്താണ് ചെയ്യുന്നതെന്ന്
മനസ്സിലാക്കാന്‍ സാധിക്കണം. ഇങ്ങനെ കമന്റ് എഴുതുന്നത് സമയനഷ്ടവും തെറ്റിദ്ധാരണകളും
ഒഴിവാക്കാന്‍ സഹായിക്കുന്നു.
പതിനാറാം വരിയില്‍ ഏകദത്തിന്റെ ശീര്‍ഷകമാണ്. ഏകദത്തിന്റെ പേര്
largest2 എന്നാണെന്നും, അത് numbers എന്ന് പേരുള്ള ഒരു
വാക്യത്തെ സ്വീകരിക്കുന്നുവെന്നും ഇവിടെ പറഞ്ഞിരിക്കുന്നു.
largest, index എന്നിങ്ങനെ രണ്ട് അംഗങ്ങളുള്ള ഒരു ലിസ്റ്റിനെയാണ്
ഈ ഏകദം തിരിച്ചുകൊടുക്കുന്നതെന്ന് 31-ആം വരിയില്‍ കാണാം. ഏകദത്തിന്റെ കമന്റ്
പ്രകാരം ഇതില്‍ ആദ്യത്തെ അംഗം ( largest ) ഏകദത്തിന്റെ
വാക്യമായ numbers എന്ന ലിസ്റ്റിലെ ഏറ്റവും വലിയ
സംഖ്യയാണ്; index ആകട്ടെ, ഈ വലിയ സംഖ്യ
numbers -ല്‍ എവിടെ വരുന്നു എന്ന് പറയുന്നു.
ഈ രണ്ടു കാര്യങ്ങള്‍ കണ്ടുപിടിക്കാന്‍ ഏകദം ചെയ്യുന്നത്
numbers
എന്ന ലിസ്റ്റിന്റെ തുടക്കം മുതല്‍ അവസാനം വരെ ക്രമത്തില്‍ നോക്കുക എന്നതാണ് (വരികള്‍
25 – 29). ഓരോ സമയത്തും അതുവരെ കണ്ട ഏറ്റവും വലിയ സംഖ്യയെ
largest എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെയ്ക്കുന്നു; അതിന്റെ സ്ഥാനത്തിനെ
index എന്ന ചരത്തിലും. ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യ കാണുന്ന സമയത്ത് ആ സംഖ്യ
തന്നെയാണ് അതുവരെ കണ്ടതില്‍വച്ച് ഏറ്റവും വലുത്. അതുകൊണ്ട് തുടക്കത്തില്‍ത്തന്നെ
largest എന്നതിന്റെ വില numbers എന്ന ലിസ്റ്റിലെ
ആദ്യസംഖ്യയായും ( numbers[0] ) index
എന്നത് അതിന്റെ സ്ഥാനമായും (പൂജ്യം) നിജപ്പെടുത്തുന്നു (വരികള്‍ 19, 20). പൈത്തണില്‍
ലിസ്റ്റിലെ സ്ഥാനങ്ങള്‍ എണ്ണിത്തുടങ്ങുന്നത് 0, 1, 2, ... എന്നിങ്ങനെയാണെന്നത് ഓര്‍ക്കുക.
ഇനി നമുക്ക് ഏകദത്തിന്റെ പ്രധാനപ്പെട്ട ഭാഗമായ
for -ന്റെ കാര്യം
നോക്കാം (വരികള്‍ 25 — 29). ലിസ്റ്റിലെ ഓരോ അംഗത്തേയും ക്രമമായി
എടുത്തുനോക്കുക എന്നതാണ് ഈ for ചെയ്യുന്നത്. വിശദമായി പറഞ്ഞാല്‍,
ആദ്യത്തെ തവണ ഈ for -ന്റെ ഉള്ളടക്കം (26 മുതല്‍ 29 വരെയുള്ള
വരികള്‍ ) പ്രവര്‍ത്തിക്കുമ്പോള്‍ n എന്ന ചരത്തിന്റെ
വില numbers എന്ന ലിസ്റ്റിലെ ആദ്യത്തെ (സ്ഥാനം പൂജ്യം
ആയിട്ടുള്ള, അതായത് numbers[0]) അംഗത്തിന്റെ വിലയാണ്. രണ്ടാമത്തെ
തവണ ഇത് രണ്ടാമത്തെ അംഗത്തിന്റെ (സ്ഥാനം 1, numbers[1])
വിലയാണ്. ഇങ്ങനെ തുടര്‍ന്നുപോകുന്നു.
ഇങ്ങനെ പോകുമ്പോള്‍ ഇതുവരെ കണ്ട ഏറ്റവും വലിയ സംഖ്യയെക്കാള്‍ (ഇതിനെ
largest എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെച്ചിട്ടുണ്ട് എന്നോര്‍ക്കുക) വലിയ ഒരു
സംഖ്യ കണ്ടാല്‍ രണ്ടു കാര്യങ്ങളാണ് ചെയ്യേണ്ടത്:
- പുതുതായി കണ്ട വലിയ സംഖ്യയെ
largestഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെയ്ക്കുക. - ഈ വലിയ സംഖ്യയുടെ സ്ഥാനം
indexഎന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെയ്ക്കുക.
i എന്ന ചരത്തില്‍ ഈ സ്ഥാനം
സൂക്ഷിക്കുന്നു. തുടക്കത്തില്‍ i -യുടെ വില പൂജ്യമാണ് (വരി
24). for -ന്റെ ഉള്ളടക്കം ഓരോ തവണ പ്രവര്‍ത്തിക്കുമ്പോഴും
( numbers -ലെ ഓരോ പുതിയ അംഗത്തെ കാണുമ്പോഴും)
i -യുടെ വില ഒന്നുവീതം കൂട്ടുന്നു (വരി 29).
for -ന്റെ ഉള്ളടക്കത്തിലെ ആദ്യത്തെ വരിയില്‍ (വരി 26) നാം മുമ്പ്
നിര്വചിച്ച larger2 എന്ന ഏകദം പ്രയോഗിക്കുന്നു. ഈ ഏകദത്തിന്
ഇതുവരെ കണ്ട ഏറ്റവും വലിയ സംഖ്യയും ( largest ) ലിസ്റ്റില്‍
പുതുതായി കണ്ട സംഖ്യയുമാണ് ( n ) വാക്യങ്ങളായി കൊടുക്കുന്നത്. ഏകദം
തിരികെത്തരുന്ന രണ്ടംഗ ലിസ്റ്റിനെ [largest, flipped] എന്ന
ലിസ്റ്റിലേക്ക് സൂക്ഷിച്ചുവെയ്ക്കുന്നത് ശ്രദ്ധിക്കുക. ഇങ്ങനെ ചെയ്യുമ്പോള്‍ ഏകദത്തിന്റെ
മറുപടിയിലെ ആദ്യ അംഗത്തിന്റെ വില — { largest -ന്റെ
മുമ്പുണ്ടായിരുന്ന വില, n -ന്റെ വില} എന്നിവയില്‍ വലിയ സംഖ്യ
— largest എന്ന ചരത്തില്‍ വരുന്നു. കൂടാതെ ഏകദത്തിന്റെ
മറുപടിയിലെ രണ്ടാമത്തെ അംഗത്തിന്റെ വില — { largest -ന്റെ
മുമ്പുണ്ടായിരുന്ന വില, n -ന്റെ വില} എന്നിവയില്‍ രണ്ടാമത്തേതാണ്
വലിയതെങ്കില്‍ True , അല്ലെങ്കില് False
— flipped എന്ന (ബൂളിയന്‍) ചരത്തില്‍ വരുന്നു.
27-ആമത്തെ വരിയില്‍
flipped എന്ന ബൂളിയന്‍ ചരത്തിന്റെ
വില True ആണോ എന്ന് പരിശോധിക്കുന്നു. ആണെങ്കില്‍
അതിനര്‍ത്ഥം numbers എന്ന ലിസ്റ്റിലെ ഇപ്പോള്‍ നാം പരിഗണിക്കുന്ന
സംഖ്യ (അതായത് n -ന്റെ വില ) ലിസ്റ്റില്‍ ഇതിന് മുമ്പുവരെയുള്ള എല്ലാ
സംഖ്യകളെക്കാളും വലുതാണ് എന്നാണ് (എന്തുകൊണ്ട്?). അപ്പോള്‍ ഈ സംഖ്യ
largest എന്ന ചരത്തിലും, അതിന്റെ ലിസ്റ്റിലുള്ള സ്ഥാനം
index എന്ന ചരത്തിലും സൂക്ഷിച്ചുവെയ്ക്കണം. ഇതില്‍ ആദ്യത്തെ കാര്യം 26-ആം
വരിയില്‍ ചെയ്തുകഴിഞ്ഞു. 27-ആം വരിയില്‍ ഇപ്പോള്‍ പരിഗണിക്കുന്ന സംഖ്യയുടെ
ലിസ്റ്റിലുള്ള സ്ഥാനം (ഇത് i എന്ന ചരത്തിലുണ്ടല്ലോ?)
index -ലേക്ക് സൂക്ഷിച്ചുവെയ്ക്കുന്നു.
31-ആമത്തെ വരിയില്‍
largest, index എന്നീ ചരങ്ങളുടെ വിലകള്‍
ഒരു ലിസ്റ്റിലാക്കി ഏകദത്തില്‍നിന്ന് തിരിച്ചുകൊടുക്കുന്നു. ഇത് for -ന്റെ
പരിധിക്ക് പുറത്താണ് എന്നത് ശ്രദ്ധിക്കുക. അതുകൊണ്ട് numbers എന്ന
ലിസ്റ്റിലെ എല്ലാ അംഗങ്ങളേയും പരിഗണിച്ച് അവയില്‍ ഏറ്റവും വലുതിന്റെ വില
largest എന്ന ചരത്തിലും അതിന്റെ ലിസ്റ്റിലുള്ള സ്ഥാനം
index എന്ന ചരത്തിലും സൂക്ഷിച്ചുവെച്ചതിന് ശേഷമാണ് ഈ തിരിച്ചുകൊടുക്കല്‍.
ഈ പാഠ്യപദ്ധതിയില്‍ ഇതുവരെ കണ്ടതില്‍വച്ച് ഏറ്റവും സങ്കീര്‍ണ്ണമായ ലോജിക്കാണ്
largest2 എന്ന ഏകദത്തിലേത്. അതുകൊണ്ട്:
- പ്രോഗ്രാം IDLE-ലോ ഷെല്ലിലോ പലതവണ (പല സംഖ്യാ ലിസ്റ്റുകളെ വാക്യങ്ങളായി കൊടുത്ത്) പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. പറഞ്ഞതുപോലെയൊക്കെ സംഭവിക്കുന്നുണ്ടോ?
- പ്രോഗ്രാം എങ്ങനെയാണ് ഇക്കാര്യങ്ങളൊക്കെ ചെയ്യുന്നതെന്ന് ആലോചിക്കുക. ഒരുപക്ഷേ ഇതിന്റെ പ്രവര്‍ത്തനം അതിശയകരമാണെന്ന് തോന്നിയേക്കാം. ഇതില്‍ അതിശയകരമായി അത്രയ്ക്കൊന്നുമില്ല. ഈ പ്രോഗ്രാമും അതിന്റെ വിശദീകരണവും കുറച്ചുപ്രാവശ്യം ശ്രദ്ധിച്ച് വായിക്കുക. മനസ്സിലാകാത്ത കാര്യങ്ങള്‍ ചോദിക്കുക. ഇതേരീതിയിലുള്ള പല ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഈ രീതിയില് ചിന്തിക്കാന്‍ നിങ്ങളും പഠിക്കും.
- കുറെയേറെ വര്‍ഷത്തെ പ്രോഗ്രാമിംഗ് സംബന്ധമായ പരിചയം (പ്രോഗ്രാമുകള്‍ എഴുതിയും വായിച്ചും, പ്രോഗ്രാമിംഗിനെപ്പറ്റിയുള്ള ലേഖനങ്ങളും മറ്റും വായിച്ചുമുള്ളത്) അടിസ്ഥാനപ്പെടുത്തിയാണ് ഈ പ്രോഗ്രാം എഴുതിയത്. അതുകൊണ്ട് ഇതേപോലെയൊരു പ്രോഗ്രാം എങ്ങനെ എഴുതും എന്നാലോചിച്ച് നിങ്ങള്‍ വിഷമിക്കരുത്. നിങ്ങള്‍ സ്വയം ഇതേ കാര്യത്തിനുള്ള പ്രോഗ്രാമെഴുതിയാല്‍ മറ്റൊരു രീതിയിലായിരിക്കും അത് വരിക. പ്രോഗ്രാമിന്റെ ലോജിക് ശരിയായിരിക്കുന്നിടത്തോളം ഇതൊരു പ്രശ്നമല്ല തന്നെ. അതുപോലെ തന്നെ, എന്നെക്കാള്‍ പ്രോഗ്രാമിംഗ് വൈദഗ്ധ്യമുള്ള/വ്യത്യസ്തമായ രീതിയില് പ്രോഗ്രാമിംഗ് പരിശീലിച്ച ഒരാള്‍ എഴുതുന്ന പ്രോഗ്രാം മറ്റൊരു രീതിയിലായിരിക്കും. ഇക്കാര്യത്തില്‍ പ്രോഗ്രാമിംഗ് ഭാഷ, മനുഷ്യഭാഷ പോലെതന്നെയാണ്. നമ്മുടേതിനെക്കാള്‍ വളരെ ലളിതമായ ഭാഷയാണല്ലോ നാലു വയസുള്ള ഒരു കുട്ടിയുടേത്. എന്നാല്‍പ്പോലും തനിക്ക് ആവശ്യമുള്ള കാര്യങ്ങളൊക്കെ പ്രകടിപ്പിക്കാന്‍ നാലു വയസുള്ള കുട്ടിക്കും കഴിയുന്നുമുണ്ടല്ലോ. അതുപോലെ തന്നെയാണ് പ്രോഗ്രാമിംഗിലും. നമുക്കറിയാവുന്ന ഭാഷ ഉപയോഗിച്ച് പ്രോഗ്രാമുകള്‍ എഴുതി ശീലിക്കുക. നല്ലതെന്ന് തോന്നുന്ന ശൈലികള്‍ കാണുമ്പോള്‍ മനസ്സിലാക്കി വയ്ക്കുക. പരിചയം കൂടുന്തോറും ഭാഷയും മാറിക്കൊണ്ടിരിക്കും.
പ്രവര്‍ത്തനം
- പ്രവ. 10.
- സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച്, ലിസ്റ്റിലെ ഏറ്റവും
ചെറിയ സംഖ്യയും അതിന്റെ ലിസ്റ്റിലെ സ്ഥാനവും തിരിച്ചുതരുന്ന ഒരു ഏകദം
എഴുതുക. ഏകദത്തിന്
smallest2എന്ന് പേരിടുക.largest2എന്ന ഏകദം ചെയ്തതുപോലെ, ഈ രണ്ട് സംഖ്യകളെ ഒരു ലിസ്റ്റായി വേണംsmallest2തിരിച്ചുതരേണ്ടത്. പല പല ലിസ്റ്റുകള്‍ വാക്യമായി കൊടുത്ത് ഈ ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തുക.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 3
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ പ്രവര്‍ത്തനരീതി ഒന്നുകൂടെ എടുത്തെഴുതാം :- ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍, അഥവാ ലിസ്റ്റില്‍ ഒരേ ഒരു അംഗം (സംഖ്യ) മാത്രമേയുള്ളൂ എങ്കില്‍ ലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ഇങ്ങനെയാണെങ്കില്‍ തന്നിരിക്കുന്ന ലിസ്റ്റിനെത്തന്നെ ഉത്തരമായി തിരിച്ചുകൊടുക്കുക. ഇങ്ങനെ അല്ലെങ്കില് (ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍):
- ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതെന്ന് കണ്ടുപിടിക്കുക. ഇത് a എന്ന സംഖ്യ ആണെന്നിരിക്കട്ടെ :
- a എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരിക. ഇതിനായി a-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറുക. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില്‍ ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
- ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില് ക്രമീകരിക്കുക.
- ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല്‍ അവസാനത്തതു വരെയുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
- ശുഭം!
larger2, largest2 എന്നീ ഏകദങ്ങള്‍ നാം നേരത്തെ കണ്ടവ തന്നെയാണ്. ഇവയുപയോഗിച്ച് എഴുതിയ selection_sort എന്ന ഏകദമാണ് ക്രമീകരണം നടപ്പിലാക്കുന്നത്.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
| # This function takes two numbers as arguments and returns a list# with two values. The first member of the list is the larger of# the two arguments. The second member is True if the second# argument is larger than the first, and False otherwise.def larger2(first, second) : if first >= second : return [first, False] else : return [second, True]# This function takes a list of numbers as arguments and finds # the largest number in the list. It returns a list of two numbers:# the largest number in the list, and the index of the largest number.def largest2(numbers) : # At first we don't know which is the largest number, # so we assume it is the first one in the list. largest = numbers[0] i = 0 index = 0 # Go over each number and compare it with the current # largest. for n in numbers : [largest, flipped] = larger2(largest, n) if flipped : index = i i = i + 1 return [largest, index]# The following function performs Selection Sort on its argument,# which is a list of numbers. It returns the sorted list.def selection_sort(numberlist) : # Step 1 : If numberlist contains at most one element, then it # is already sorted. So return the list without any change. if len(numberlist) <= 1 : return numberlist # If we reach this point, then numberlist contains more than # one element. # Step 2 : Find the largest element in numberlist, and its # position in the list. [a, index_of_a] = largest2(numberlist) # Step 2.i : Exchange the positions of the number 'a' and the # first number in the list. numberlist[index_of_a] = numberlist[0] numberlist[0] = a # Step 2.ii : Sort the sublist numberlist[1:] "in the same # way". numberlist[1:] = selection_sort(numberlist[1:]) # The list is now sorted! Return it. return numberlist |
ഈ പ്രോഗ്രാമിലെ ആദ്യത്തെ രണ്ട് ഏകദങ്ങള്‍ (
larger2,
largest2 എന്നിവ ) നാം മുമ്പുകണ്ടവ തന്നെയാണ്.
selection_sort എന്നു പേരായ പുതിയ ഏകദം 33 മുതല്‍ 65 വരെയുള്ള
വരികളിലാണ്. ഇതില്‍ ആദ്യത്തെ രണ്ട് വരികളില്‍ ഈ ഏകദം എന്താണ് ചെയ്യുന്നതെന്ന്
സൂചിപ്പിക്കുന്ന കമന്റാണ്.
selection_sort എന്ന ഏകദം സംഖ്യകളുടെ ഒരു ലിസ്റ്റിനെ
വാക്യമായി സ്വീകരിക്കുന്നു. വാക്യത്തിന്റെ പേര് numberlist
എന്നാണ്. ഈ ഏകദത്തിന്റെ ഉള്ളടക്കത്തില്‍ തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ
പ്രവര്‍ത്തനരീതിയെ അതേപടിയെന്നോണം പകര്‍ത്തിയിരിക്കുന്നു.
ഏകദത്തില്‍ ആദ്യം ചെയ്യുന്നത്
numberlist എന്ന ലിസ്റ്റില്‍ ഒന്നോ
അതില്‍ കുറവോ അംഗങ്ങളേ ഉള്ളോ എന്ന് നോക്കുക എന്നതാണ് (വരി
41). ഇങ്ങനെയാണെങ്കില്‍ ഇതേ ലിസ്റ്റിന്റെ മാറ്റങ്ങളൊന്നുമില്ലാതെ തിരിച്ചുകൊടുത്ത്,
ഏകദത്തിന്റെ പ്രവര്‍ത്തനം അവസാനിപ്പിക്കുന്നു (വരി 42).
ഇങ്ങനെ അല്ലെങ്കില് — ലിസ്റ്റില്‍ രണ്ടോ അതില്‍ കൂടുതലോ അംഗങ്ങളുണ്ടെങ്കില്‍ — 42-ആം വരി പ്രവര്‍ത്തിക്കുകയില്ല. ഇതിനു പകരം ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യയും ഈ സംഖ്യയുടെ ലിസ്റ്റിലെ സ്ഥാനവും
largest2 എന്ന
ഏകദമുപയോഗിച്ച് കണ്ടുപിടിച്ച്, a, index_of_a എന്നീ
ചരങ്ങളിലായി സൂക്ഷിക്കുന്നു (വരി 50). ഇതുകഴിഞ്ഞ് a -യെ —
ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യയെ — ലിസ്റ്റിന്റെ തുടക്കത്തില്‍
കൊണ്ടുവരുന്നു. ഇതിനായി ലിസ്റ്റിന്റെ തുടക്കത്തിലുള്ള സംഖ്യയെ a
ഇരുന്നയിടത്തും, a -യെ ലിസ്റ്റിന്റെ തുടക്കത്തിലും കൊണ്ടുവയ്ക്കുന്നു
(വരികള്‍ 55, 56).
ഇനി ആകെ ചെയ്യാനുള്ളത് ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില് ക്രമീകരിക്കുക എന്നതാണ്. ഇതിനായി ചെയ്യുന്നത് (വരി 61):
-
numberlist[1:]എന്ന ഈ ഉപലിസ്റ്റിനെselection_sortഎന്ന (ഇതേ!) ഏകദത്തിന് വാക്യമായി കൊടുക്കുക. ഏകദം ഈ ഉപലിസ്റ്റിനെ ക്രമീകരിച്ച് തിരിച്ചുതരും. - ഇങ്ങനെ ക്രമീകരിച്ച് കിട്ടിയ ഉപലിസ്റ്റിനെ അത് ഇരിക്കേണ്ട സ്ഥാനത്ത്
—
numberlistഎന്ന ലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ഉപലിസ്റ്റായി — വയ്ക്കുക.
selection_sort എന്ന ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടോ
എന്ന് പരിശോധിക്കാന്‍ ഈ പ്രോഗ്രാം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE-ലോ ഷെല്ലിലോ
പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാം. ഷെല്ലില്‍ പ്രവര്‍ത്തിപ്പിച്ചതിന്റെ ഉദാഹരണം ഇതാ
(selectionsort.py എന്ന ഫയലിലാണ് സേവ് ചെയ്തത്).
അവരോഹണക്രമത്തിലാണ് (വലിയ സംഖ്യകള്‍ ആദ്യം വരുന്ന ക്രമത്തില്‍) നമ്മുടെ
പ്രോഗ്രാം ലിസ്റ്റിനെ ക്രമീകരിക്കുന്നതെന്ന് ഓര്‍ക്കുക : $ python -i selectionsort.py >>> selection_sort ([1]) [1] >>> selection_sort ([1, 2, 3, 4, 5]) [5, 4, 3, 2, 1] >>> selection_sort ([12, 45, 23, 54, 78, 3, 100]) [100, 78, 54, 45, 23, 12, 3] >>> selection_sort ([2, 1]) [2, 1] >>> selection_sort ([1, 2]) [2, 1] >>> quit() $
പ്രവര്‍ത്തനം
- പ്രവ. 11.
- സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച്, ലിസ്റ്റിനെ
ആരോഹണക്രമത്തില്‍ (ഏറ്റവും ചെറിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില്‍)
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം ഉപയോഗിച്ച് ക്രമപ്പെടുത്തുന്ന ഒരു ഏകദം
എഴുതുക. ഇതിന്
selection_sort2എന്ന് പേരുകൊടുക്കുക. മുമ്പെഴുതിയsmallest2എന്ന ഏകദം ഇതിനായി ഉപയോഗിക്കുക. പല പല ലിസ്റ്റുകള്‍ വാക്യമായി കൊടുത്ത് ഈ ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തുക.
ഉപസംഹാരം
for, while എന്നിവ ഉപയോഗിച്ച് പ്രവര്‍ത്തനങ്ങള്‍ ആവര്‍ത്തിച്ച്
ചെയ്യുന്നതിന് iteration (ആവര്‍ത്തനം എന്നര്‍ത്ഥം) എന്നാണ് പറയുന്നത്.
നാമെഴുതിയ selection_sort എന്ന ഏകദത്തില്‍ അതേ
ഏകദത്തിനെത്തന്നെ പ്രയോഗിച്ചല്ലോ? (വരി 61). ഇങ്ങനെ ഒരു ഏകദത്തിന്റെ
നിര്‍വചനത്തില്‍ അതേ ഏകത്തിന്റെ പ്രയോഗം വരുന്നതിന്
പര്യാവര്‍ത്തനം (recursion) എന്ന് പറയുന്നു. ഇത് പ്രോഗ്രാമിംഗ് ചെയ്യുന്ന
ഒട്ടേറെപ്പേര്‍ അതിശയത്തോടെ (ഭയബഹുമാനങ്ങളോടെ!) മാത്രം നോക്കിക്കാണുന്ന ഒരു
കാര്യമാണ്. ഈ സ്ഥിതിവിശേഷത്തെ ആസ്പദമാക്കി "To iterate is human; to
recurse, divine." എന്ന ഒരു ചൊല്ലുതന്നെയുണ്ട് ("ആവര്‍ത്തനം മാനുഷികമാണ്;
പര്യാവര്‍ത്തനമോ, ദൈവീകവും.").
പര്യാവര്‍ത്തനത്തിന്റെ ആശയം ശരിയായി മനസ്സിലാക്കിയില്ലെങ്കില്‍ അത് ഉപയോഗിച്ച് എഴുതുന്ന പ്രോഗ്രാം അത്യതിശയകരമാണെന്ന് തോന്നാം ( മുകളിലത്തെ
selection_sort എന്ന ഏകദത്തില്‍ "ശരിക്കും" എവിടെയാണ് ക്രമപ്പെടുത്തല്‍
നടക്കുന്നത്? എന്നത് വളരെ സാധാരണമായ ഒരു സംശയമാണ്.). എന്നാല്‍ പല
പ്രവര്‍ത്തനരീതികളും (അല്‍ഗോരിതങ്ങളും) വിശദീകരിക്കാനും മനസ്സിലാക്കാനും ഏറ്റവും
ലളിതമായ വഴി അവ പര്യാവര്‍ത്തന രീതിയില് എഴുതുകയെന്നതാണ്. ഈ പാഠത്തില്‍
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം നടപ്പിലാക്കാന്‍ എഴുതിയ
selection_sort എന്ന ഏകദവും അതിന്റെ വിശദീകരണവും നന്നായി
മനസ്സിലാക്കിയാല്‍ ഒട്ടേറെ പ്രോഗ്രാമര്‍മാര്‍ക്ക് ബാലികേറാമലയായ
പര്യാവര്‍ത്തനത്തെ മനസ്സിലാക്കുന്നതില്‍ നിങ്ങള്‍ നല്ല തുടക്കമിട്ടു എന്നര്‍ത്ഥം.
അതുകൊണ്ട് സംശയങ്ങളുണ്ടെങ്കില്‍ കമന്റുകളായി ചോദിക്കാന്‍ മടിക്കരുത്.
കുറിപ്പ്
1. "Argument" എന്ന ഇംഗ്ളീഷ് വാക്കിന്റെ ഈ അര്‍ത്ഥത്തിലുള്ള പ്രയോഗം
ലാറ്റിന്‍ ഭാഷയിലെ "to put in clear light; to declare" എന്നര്‍ത്ഥം വരുന്ന
"arguere" എന്ന പദത്തില്‍നിന്നാണെന്ന് കാണുന്നു . സംസ്കൃതത്തിലെ वाक्य्: ശബ്ദത്തിന് ഈ അര്‍ത്ഥങ്ങളും ഉള്ളതുകൊണ്ട് — മോണിയര്‍-വില്യംസ് നിഘണ്ടു കാണുക — function argument എന്നതിന് "ഏകദത്തിന്റെ വാക്യം" എന്ന് പ്രയോഗിച്ചിരിക്കുന്നു. ↩
0 comments: