പൈത്തണ്‍: പാഠം നാല്

കഴിഞ്ഞ പാഠത്തില്‍ നാം കണ്ട ശരാശരി പ്രോഗ്രാം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് നമുക്കു നോക്കാം. പ്രോഗ്രാമിന്റെ കമന്റല്ലാത്ത ആദ്യത്തെ വരി താഴെ എഴുതുന്നു:



ഈ വരിയില്‍ മൂന്നു കാര്യങ്ങളാണുള്ളത്:

1. num_12 എന്ന വേരിയബിള്‍ (variable) അഥവാ ചരം.
   
2. = എന്ന സംകാരകം (operator).
   
3. 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.

ഉപയോക്താവിനോട് പേരു ചോദിക്കുകയും, പേരു കിട്ടിക്കഴിഞ്ഞാല്‍ ആ പേരുവച്ച് ഹലോ പറയുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം എഴുതുക.

പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലേതുപോലെ ആയിരിക്കണം. ചിത്രത്തില്‍ പ്രോഗ്രാം മൂന്നു പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചിട്ടുണ്ട് (മൂന്നു പ്രാവശ്യം പ്രോഗ്രാം ഉള്ള വിന്‍ഡോയില്‍ F5 അമര്‍ത്തിയിട്ടുണ്ട്). പ്രോഗ്രാമിന്റെ ഔട്പുട്ട് നീലയിലും ഞാന്‍ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുത്ത കാര്യങ്ങള്‍ കറുപ്പിലുമായി കാണിച്ചിരിക്കുന്നു.

num_12

num_12 എന്നത് ഒരു ചരം (variable - വേരിയബിള്‍) ആണ്. ലളിതമായിപ്പറഞ്ഞാല്‍ മൂല്യങ്ങളെ (values) സൂക്ഷിച്ചുവെക്കാനുള്ള പേരെഴുതിയ പെട്ടികളാണ് ചരങ്ങള്‍. ഒരു പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തിന്റെ ഭാഗമായി സാധാരണഗതിയില്‍ കുറെയേറെ വിലകള്‍ അഥവാ മൂല്യങ്ങള്‍ ഉപയോഗിക്കേണ്ടതായിവരും. പ്രോഗ്രാമിനുപുറത്തുനിന്ന് (ഉദാ: input() വഴിയായി) കിട്ടുന്ന ഡേറ്റയും, പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുമ്പോളുണ്ടാകുന്ന മറ്റു മൂല്യങ്ങളും ഇതില്‍ ഉള്‍പ്പെടും. ഇവയില്‍ ചിലതിനെയൊക്കെ നമുക്ക് പേരിട്ടു വിളിക്കേണ്ട ആവശ്യവുമുണ്ടാകും. ഇങ്ങനെ വിലകളെ പേരിട്ടു വിളിക്കാനുള്ള ഉപാധിയാണ് ചരങ്ങള്‍.

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

= എന്ന സംകാരകം (operator)

നമ്മുടെ ശരാശരി പ്രോഗ്രാമിന്റെ ആദ്യത്തെ വരി ഒരിക്കല്‍ക്കൂടി എടുത്തെഴുതുന്നു:



ഇതില്‍ 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
>>> 

ഇവിടെ സംഭവിക്കുന്നത്:

1. x എന്ന ചരത്തിന് 5 എന്ന വില കൊടുക്കാന്‍ x = 5 എന്ന് കൊടുത്ത് Enter അമര്‍ത്തുന്നു.
   
2. x-ന്റെ വില കാണാന്‍ വെറുതെ x എന്ന് കൊടുത്ത് Enter അമര്‍ത്തുന്നു. ഷെല്ലിലായതുകൊണ്ടാണ് ഇത് മതിയാകുന്നത്. ഫയലിലെഴുതിയ പ്രോഗ്രാമിലാണെങ്കില്‍ print x എന്ന് എഴുതണം.
   
3. x-ന്റെ വില ഒന്നു കൂട്ടാന്‍ x = x + 1 എന്ന് കൊടുക്കുന്നു.
   
4. x-ന്റെ വില മാറിയോ എന്നു കാണാന്‍ വീണ്ടും 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-യുടെ വില കാണുക.

ശരാശരി പ്രോഗ്രാമിന്റെ വിവരണം

കഴിഞ്ഞ പാഠത്തിലെ ശരാശരി കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മനസ്സിലാക്കാനുള്ളതെല്ലാം നാം പഠിച്ചുകഴിഞ്ഞു. പ്രോഗ്രാം എടുത്തെഴുതുന്നു.



പ്രോഗ്രാമിന്റെ ആദ്യത്തെ ഏഴു വരികള്‍ കമന്റുകളും പിന്നെയുള്ള രണ്ടു വരികള്‍ ശൂന്യവുമാണല്ലോ. പത്തു മുതല്‍ പതിനെട്ടു വരെ വരികളില്‍ ചെയ്യുന്നത് ഉപയോക്താവിന്റെ പക്കല്‍നിന്ന് അഞ്ച് വിലകള്‍ (ഇവ പൂര്‍ണ്ണ സംഖ്യകളാണെന്നാണ് സങ്കല്‍പം) വാങ്ങി അഞ്ച് ചരങ്ങളിലേക്ക് ( 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 എന്നിവയാണ്. ചരങ്ങള്‍ക്ക് പേരുകൊടുക്കുമ്പോള്‍ പാലിക്കേണ്ട ചില നിയമങ്ങളുണ്ട്. അവ ഇവിടെ ചുരുക്കി പറയുന്നു:

1. പേരുകള്‍ക്ക് എത്രവേണമെങ്കിലും നീളം ആകാം.
   
2. പേരിന്റെ ആദ്യത്തെ അക്ഷരം ഇംഗ്ളീഷ് അക്ഷരമാലയിലെ ഏതെങ്കിലും അക്ഷരം (ചെറിയതോ വലിയതോ) അല്ലെങ്കില്‍ "_"-ഓ (underscore) ആയിരിക്കണം.
   
3. പേരിന്റെ രണ്ടാമത്തേതും തുടര്‍ന്നുമുള്ള സ്ഥാനങ്ങളില്‍ മേല്‍പ്പറഞ്ഞ അക്ഷരങ്ങളും "_"-ഉം കൂടാതെ അക്കങ്ങളും ആകാം.
   
4. പേരുകളില്‍ വലിയക്ഷരവും ചെറിയക്ഷരവും (capital and small letters) തമ്മില്‍ വ്യത്യാസമുണ്ട്. ഉദാ: average, Average എന്നിവ രണ്ടു വ്യത്യസ്ത ചരങ്ങളാണ്; ഒന്നിനു പകരം മറ്റേത് ഉപയോഗിച്ചാല്‍ പ്രോഗ്രാം തെറ്റിപ്പോകും.
   
5. താഴെക്കാണുന്ന പേരുകള്‍ വിലക്കപ്പെട്ടവയാണ്. ഇവ ചരങ്ങളുടെ പേരുകളായി ഉപയോഗിച്ചുകൂടാ . ഇതിനുകാരണം ഇവയ്ക്ക് പൈത്തണ്‍ ഭാഷയില്‍ പ്രത്യേക അര്‍ത്ഥങ്ങള്‍ ഉണ്ട് എന്നതാണ്. ഇവയെ കീവേഡുകള്‍ (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
   

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

1. "_" പേരിന്റെ തുടക്കത്തില്‍ അനുവദനീയമാണെങ്കിലും തുടക്കക്കാരായ നമ്മള്‍ ഈ സൗകര്യം ഉപയോഗിക്കാതെയിരിക്കുന്നതാണ് നല്ലത്. പേരിന്റെ തുടക്കത്തിലെ "_" വിട്ടുപോകാനും കാണാതെയിരിക്കാനും നല്ല സാധ്യതയുള്ളതുകൊണ്ടാണ് ഇങ്ങനെ പറഞ്ഞത്.
   
2. മേല്‍ക്കൊടുത്ത നിയമങ്ങളനുസരിക്കുന്ന ഏതു പേരും ചരങ്ങള്‍ക്കിടാമെങ്കിലും ചരത്തിനെ എന്ത് സൂചിപ്പിക്കാനാണോ പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്നത്, ആ അര്‍ത്ഥം വരുന്ന പേരുകള്‍ ഇടുന്നതാണ് നല്ലത്. ഇത് പ്രോഗ്രാം വായന സുകരമാക്കും. ശരാശരി കാണാനുള്ള നമ്മുടെ പ്രോഗ്രാമില്‍ ഉപയോഗിച്ചിരിക്കുന്ന ചരങ്ങളുടെ പേരുകള്‍ ശ്രദ്ധിക്കുക.
   
3. ഒറ്റനോട്ടത്തില്‍ ഒന്നാണെന്ന് തോന്നിക്കുന്ന പേരുകള്‍ കൊടുക്കാതെയിരിക്കുക. 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 എന്നീ ചരങ്ങളുടെ മൂല്യം പരസ്പരം മാറുന്ന രീതിയില്‍ ആക്കുക. പ്രോഗ്രാമിന്റെ മറ്റുഭാഗങ്ങളില്‍ മാറ്റം വരുത്താതെ വേണം ഇത് ചെയ്യേണ്ടത്.


ഇങ്ങനെ ചെയ്തുകഴിയുമ്പോള്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നത് ഇതുപോലെയായിരിക്കണം (വ്യക്തമായ ചിത്രത്തിന് ക്‍ളിക്ക് ചെയ്യുക):

ഉത്തരങ്ങളും സംശയങ്ങളും നിര്‍ദ്ദേശങ്ങളും കമന്റായിടുക.