പൈത്തണ്‍: പാഠം മൂന്ന്

ഈ പാഠത്തില്‍: പൈത്തണ്‍ ഷെല്‍, IDLE, ചരങ്ങളും പ്രോഗ്രാമിലേക്ക് ഇന്‍പുട്ട് എടുക്കാനുള്ള ഒരു രീതിയും.

ആമുഖം

കഴിഞ്ഞ രണ്ടു പാഠങ്ങളിലായി കണ്ട ചെറിയ പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിക്കാണുമല്ലോ. ഒരു എഡിറ്റര്‍ (ഉദാ: gedit) ഉപയോഗിച്ച് പ്രോഗ്രാം ഒരു ഫയലില്‍ എഴുതി സൂക്ഷിച്ച്, ടെര്‍മിനലില്‍ python filename എന്ന കമാന്റുപയോഗിച്ച് പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ് ഈ പ്രോഗ്രാമുകള്‍ക്ക് നാമവലംബിച്ച രീതി. ഇത് തികച്ചും ശരിയായ രീതിതന്നെയാണെങ്കിലും ഇതിന് ഒരു പോരായ്മയുണ്ട്. ഗണിതക്രിയകളുടെ പ്രോഗ്രാം ഉപയോഗിച്ച് പരീക്ഷണങ്ങള്‍ നടത്തുമ്പോഴാണ് ഈ കുറവ് നമുക്ക് ശരിക്കു ബോധ്യപ്പെടുക. ഇതെന്താണെന്നുവച്ചാല്‍, പുതിയ ഓരോ കാര്യം പരീക്ഷിച്ചുനോക്കാനും നാം രണ്ടു കാര്യങ്ങള്‍ ചെയ്യണം. ഉദാഹരണത്തിന്, 2 ** 1/2 എന്നെഴുതിയാല്‍ രണ്ടിന്റെ വര്‍ഗമൂലം കിട്ടുമോ എന്നറിയാന്‍ താഴെപ്പറയുന്ന കാര്യങ്ങള്‍ ചെയ്യണം:

1. gedit-ല്‍ print "The square root of 2 is ", 2 ** 1/2 എന്ന വരി പ്രോഗ്രാമില്‍ ചേര്‍ത്ത് ഫയല്‍ സേവ് ചെയ്യുക.
2. ടെര്‍മിനലിലേക്ക് മാറി python calc.py എന്ന കമാന്റ് കൊടുക്കുക.

കിട്ടിയ ഉത്തരം -- 1 -- തെറ്റാണെന്ന് കാണുമ്പോള്‍ ഘാതത്തിന് (കൃതിക്ക്) ഹരണത്തെക്കാള്‍ മുന്‍ഗണനയുള്ളതുകൊണ്ടാവാം ഇതു സംഭവിച്ചത് എന്നു നാം സംശയിക്കുന്നു. അങ്ങനെയാണെങ്കില്‍ 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-ആം പതിപ്പ് എടുക്കുന്നതാവും നല്ലത്.).

ലിനക്സില്‍

• സ്കൂള്‍ ലിനക്സില്‍:
  
  • 3.0/3.2 എന്നീ പതിപ്പുകള്‍ക്ക് ഈ ഫയല്‍ ഡൗണ്‍ലോഡ് ചെയ്യുക.
  • 3.8 പതിപ്പിന് ഈ ഫയല്‍ ഡൗണ്‍ലോഡ് ചെയ്യുക.
  1. ഡൗണ്‍ലോഡ് ചെയ്ത ഫയല്‍ GDebi (3.8-ല്‍ Gdeb) ഉപയോഗിച്ച് തുറക്കുക. ഇതിനായി ഫയലില്‍ റൈറ്റ്-ക്ളിക്ക് ചെയ്ത് "Open with GDebi package installer" (3.8-ല്‍ "Open with GDeb package installer")എന്നത് തെരഞ്ഞെടുക്കുക.
  2. 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

IDLE തുറക്കുമ്പോള്‍ ആദ്യം കാണുക ഒരു പൈത്തണ്‍ ഷെല്‍ ആണ്:

മുമ്പുപറഞ്ഞതുപോലെ ഈ ഷെല്‍ നമുക്ക് പ്രോഗ്രാം ശകലങ്ങള്‍ പരീക്ഷിക്കാനായി ഉപയോഗിക്കാം. IDLE-ല്‍ ഈ ഷെല്ലിനു പുറമേ ഒരു പൈത്തണ്‍ എഡിറ്റര്‍ കൂടിയുണ്ട്. നാം മുമ്പെഴുതി സൂക്ഷിച്ച calc.py എന്ന പ്രോഗ്രാം ഈ എഡിറ്ററിലൊന്ന് തുറന്നുനോക്കാം. ഇതിനായി ചെയ്യേണ്ടത്:

1. IDLE-ല്‍ File-> Open എന്നത് തെരഞ്ഞെടുക്കുക. (ഇതിനുള്ള എളുപ്പവഴി: Ctrl-O. അതായത് Control, O എന്നീ കീകള്‌ ഒരുമിച്ചമര്‍ത്തുക)
2. calc.py എന്ന ഫയല്‍ സൂക്ഷിച്ചുവെച്ച MyPrograms എന്ന ഡയറക്ടറിയില്‍ച്ചെന്ന് ആ ഫയല്‍ തെരഞ്ഞെടുത്ത് Open അമര്‍‌ത്തുക . ഈ ഫയല്‍ ഒരു എഡിറ്ററില്‍ തുറന്നുവരുന്നതുകാണാം.

മറ്റ് ഏത് എഡിറ്ററിലുമെന്നതുപോലെ (ഉദാ: gedit) ഈ എഡിറ്ററുപയോഗിച്ചും നമുക്ക് പ്രോഗ്രാമില്‍ മാറ്റങ്ങള്‍ വരുത്തുകയും വരുത്തിയ മാറ്റങ്ങള്‍ ഫയലിലേക്ക് സേവ് ചെയ്തുവെക്കുകയും ചെയ്യാം. സേവ് ചെയ്യാനായി എഡിറ്ററില്‍ File -> Save അല്ലെങ്കില്‍ Ctrl-S ഉപയോഗിക്കുക. gedit പോലെയുള്ള, പൊതുവായ ഉപയോഗത്തിനുള്ള എഡിറ്ററുകളില്‍ (എഡിറ്റര്‍മാരില്‍?) കാണുന്ന സൗകര്യങ്ങള്‍ കൂടാതെ ഈ എഡിറ്ററില്‍ പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിക്കാന്‍ പ്രത്യേകം സഹായിക്കുന്ന ഒട്ടനവധി സൗകര്യങ്ങളുണ്ട്. ഇവയില്‍ മിക്കതിനേയും‌ നമുക്ക് വഴിയേ പരിചയപ്പെടാം. ഇക്കൂട്ടത്തില്‌ ഏറ്റവും പ്രധാനപ്പെട്ട, ഏറ്റവും ഉപകാരപ്രദമായ ഒന്നാണ് ടെര്‍മിനല്‍ ഉപയോഗിക്കാതെ, എഡിറ്ററിനുള്ളില്‍ നിന്നുകൊണ്ടുതന്നെ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനുള്ള സംവിധാനം. ഇതിനായി പ്രോഗ്രാം തുറന്നുവെച്ച എഡിറ്ററില്‍ച്ചെന്ന് Run -> Run Module എന്നത് തെരഞ്ഞെടുക്കുക (എളുപ്പവഴി: കീബോര്‍ഡില്‍ F5 എന്നടയാളപ്പെടുത്തിയ കീ അമര്‍‌ത്തുക.). പ്രോഗ്രാമിന്റെ ഔട്പുട്ട് ആദ്യം തുറന്നുവന്ന ഷെല്ലില്‍ വരുന്നതുകാണാം.

IDLE ഉപയോഗിക്കേണ്ടതെങ്ങനെ എന്ന് നാം പഠിച്ചുകഴിഞ്ഞു! IDLE-ല്‍ മറ്റു പല സൗകര്യങ്ങളുമുണ്ട് (ഉദാ: പ്രോഗ്രാമിന്റെ കുറേ ഭാഗം ഒറ്റയടിക്ക് കമന്റ് ചെയ്യാനുള്ള സൗകര്യം). ഇവയില്‍ ചിലതിനെയൊക്കെ പാഠങ്ങളുടെ ഭാഗമായി പിന്നീട് പരിചയപ്പെടാം. കൗതുകം തോന്നുമ്പോള്‍ തനിയെ പരീക്ഷണങ്ങള്‍ ചെയ്ത് പഠിക്കുന്നതാണ് ഏറ്റവും നല്ലത്; സംശയങ്ങളുണ്ടാകുമ്പോള്‍ (പോസ്റ്റിന്റെ) കമന്റായി ചോദിച്ചോളൂ.

ഒരു ശരാശരി പ്രോഗ്രാം

ഹൈസ്കൂള്‍ കുട്ടികള്‍ക്കായി ഒരു ക്യാമ്പ് നടത്തുന്നു എന്നു കരുതുക. ജില്ലയിലെ പല സ്കൂളുകളില്‍നിന്നുള്ള കുട്ടികള്‍ ക്യാമ്പില്‍ പങ്കെടുക്കുന്നു. ക്യാമ്പില്‍ വന്നിട്ടുള്ള കുട്ടികളുടെ ശരാശരി പ്രായം കണ്ടുപിടിക്കാനുള്ള ലളിതമായ ഒരു പ്രോഗ്രാം നമുക്കെഴുതാം. പ്രോഗ്രാമിലേക്ക് ഇന്‍പുട്ട് കൊടുക്കുന്നവിധം, ചരങ്ങളുടെ (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

കളറില്‍... IDLE ഉപയോഗിച്ച് ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കാന്‍ നാം ചെയ്യേണ്ടത്:

1. IDLE തുറക്കുക (നേരത്തേതന്നെ തുറന്നുവച്ചിട്ടുണ്ടെങ്കില്‍ അത് ഉപയോഗിച്ചാല്‍ മതി; പുതുതായി തുറക്കേണ്ട കാര്യമില്ല.).
2. പുതിയ ഒരു (ഒഴിഞ്ഞ) ഫയല്‍ IDLE-ല്‍ തുറക്കുക. ഇതിനായി File -> New Window അല്ലെങ്കില്‍ Ctrl-N എന്ന കുറുക്കുവഴി ഉപയോഗിക്കുക.
3. പുതിയ ഫയല്‍ ഒരു എഡിറ്ററിലായാണ് തുറന്നുവരുന്നത്; ഇവിടെ നമുക്ക് ഇഷ്ടമുള്ളതൊക്കെ എഴുതാനുള്ള സൗകര്യമുണ്ട്. ഈ ഫയലിലേക്ക് നമ്മുടെ പ്രോഗ്രാം എഴുതുക അല്ലെങ്കില്‍ പകര്‍ത്തിവെക്കുക.
4. എഴുതിയ പ്രോഗ്രാമിനെ File -> Save അല്ലെങ്കില്‍ Ctrl-S ഉപയോഗിച്ച് (ഒന്നാം പാഠത്തില്‍ gedit ഉപയോഗിച്ച് സേവ് ചെയ്തപ്പോഴുള്ള നിബന്ധനകള്‍ പാലിച്ചുകൊണ്ട് )സേവ് ചെയ്യുക.
5. ഇപ്പോള്‍ നമ്മുടെ എഡിറ്ററുടെ തലക്കെട്ട് "Untitled" എന്നതുമാറി സേവ് ചെയ്ത ഡയറക്ടറിയുടെ പേരുള്‍പ്പടെയുള്ള ഫയലിന്റെ പേരായി മാറിയിരിക്കും. ഇനി ഈ എഡിറ്ററില്‍ നിന്നുകൊണ്ട് (ഇതില്‍ സംശയമുണ്ടെങ്കില്‍ എഡിറ്റര്‍ വിന്‍ഡോയില്‍ എവിടെയെങ്കിലും മൌസ് ഒന്നു ക്ളിക്ക് ചെയ്താല്‍ മതി) F5 അമര്‍ത്തുക.

IDLE-ല്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കാന്‍ എഡിറ്ററില്‍ F5 എന്ന കീ അമര്‍ത്തിയാല്‍ മതിയല്ലോ? F5 അമര്‍ത്തുമ്പോള്‍ (മറ്റൊരു വിന്‍ഡോയിലുള്ള) Python shell-ല്‍ ആണ് പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നത്. പ്രോഗ്രാമിന് ഇന്‍പുട്ട് കൊടുക്കേണ്ടത് അവിടെയാണ്; ഔട്ട്പുട്ട് കാണുന്നതും അവിടെത്തന്നെ. എഡിറ്ററില്‍ F5 അമര്‍ത്തിയിട്ടും ഒന്നും സംഭവിക്കുന്നില്ല എന്നു തോന്നുന്നുണ്ടെങ്കില്‍ Python shell ഉള്ള രണ്ടാമത്തെ വിന്‍ഡോയില്‍ നോക്കുക!

നന്ദി: ഹസൈനാര്‍ മങ്കട, അഞ്ജന.

പൈത്തണ്‍: പാഠം രണ്ട്

ഈ പാഠത്തില്‍ ഉള്ളത്: കംപ്യൂട്ടറില്‍ സംഭവിക്കുന്നതെന്ത്?, ഒന്നാം പാഠത്തിലെ ചെറിയ പ്രോഗ്രാമിന്റെ വിശദമായ വായന, ഇതേ പ്രോഗ്രാമിന്റെ മലയാളം പതിപ്പ്, പൈത്തണുപയോഗിച്ച് അല്‍പം ഗണിതം.

കംപ്യൂട്ടറില്‍ സംഭവിക്കുന്നതെന്തെന്നാല്‍ ...

നമ്മുടെ മാതൃഭാഷ മലയാളമാണെന്നതുപോലെ കംപ്യൂട്ടറിന്റെ "മാതൃഭാഷ" 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. print എന്ന വാക്കില്‍ തുടങ്ങുന്ന വരി
ഈ പ്രോഗ്രാമില്‍ പൈത്തണ്‍ ഭാഷയിലുള്ള ഒരേ ഒരു വരി ഇതാണെന്ന് പറയാം; മറ്റുള്ളതൊക്കെ ഇംഗ്ളീഷ് തന്നെയാണല്ലോ? print എന്നുള്ളത് പ്രോഗ്രാമിന്റെ output --- പുറത്തുകാണേണ്ട പ്രവര്‍ത്തനഫലം --- പുറത്തുകാണിക്കാന്‍ ഉപയോഗിക്കുന്ന ഒരു പൈത്തണ്‍ കീവേഡ് (keyword) ആണ്. പൈത്തണില്‍ ഇരുപതോളം വാക്കുകളെ ഇങ്ങനെ keyword അഥവാ പ്രധാനവാക്ക് /പ്രത്യേകവാക്ക് എന്ന് പേരിട്ട് വേര്‍തിരിച്ചിട്ടുണ്ട്. പ്രോഗ്രാമുകളില്‍ ചില പ്രത്യേക ആവശ്യങ്ങള്‍ക്കായി ഉപയോഗിക്കുന്നതുകൊണ്ടാണ് ഇവയെ കീവേഡ് എന്നു വിളിക്കുന്നത്. ഇവയില്‍ മിക്കതിനേയും നമുക്ക് വഴിയേ പരിചയപ്പെടാം. print എന്ന കീവേഡ് ചെയ്യുന്നത്, തനിക്കുശേഷം അതേ വരിയില്‍ കാണുന്ന കാര്യങ്ങളെ ഔട്ട്പുട്ട് ചെയ്യുക എന്നതാണ്. print ഇങ്ങനെ ചെയ്തതാണ് നാം പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് ആയി കണ്ടത്.

പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതാന്‍ കീവേഡുകള്‍ ഏതൊക്കെ എന്നത് കാണാതെ പഠിക്കേണ്ട കാര്യമൊന്നുമില്ല. print എന്നത് കീവേഡ് ആണോ മറ്റെന്തെങ്കിലും ആണോ എന്ന് എനിക്ക് ഉറപ്പൊന്നുമില്ലായിരുന്നു. ഈ പാഠം എഴുതാനിരുന്നപ്പോള്‍ വായിച്ചു നോക്കി കണ്ടുപിടിച്ചതാണ്.

print-നു ശേഷം Hello, World! എന്നത് ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കിടയിലായി കൊടുത്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക. രണ്ടുവാക്കുകളും ഒരു കോമയും ഒരു ആശ്ചര്യചിഹ്നവും ചേര്‍ന്ന ഈ വാചകത്തിനെ ഒരു ഏകകമായി -- ഭാഗങ്ങളായി മുറിക്കാതെ -- പരിഗണിക്കാന്‍വേണ്ടിയാണിത്. അക്ഷരങ്ങളും അക്കങ്ങളും ഉള്‍പ്പടെ എഴുതാനുപയോഗിക്കുന്ന എല്ലാ ചിഹ്നങ്ങളെയും (സ്പേസും മറ്റുമടക്കം) character എന്നു വിളിക്കുന്നു. ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കിടയിലായി character-കള്‍ എഴുതുന്നതിന് string (ചരട്? സൂത്രം? ...?) എന്നു പറയുന്നു. ഉദാഹരണത്തിന്, നമ്മുടെ പ്രോഗ്രാമില്‍ക്കണ്ട "Hello, World!" ഒരു string ആണ്. അതേസമയം print ഒരു string അല്ല. കാരണം അത് ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കിടയിലല്ല. ഇവിടെ ശ്രദ്ധിക്കേണ്ടതായ കാര്യം, print എന്നതിന്റെ അര്‍ത്ഥം പ്രോഗ്രാമില്‍ പ്രധാനമാണ്, എന്നാല്‍ "Hello, World!" എന്നതിന്റെ അര്‍ത്ഥത്തിന് പ്രാധാന്യമില്ല --- അതിനെ വെറുതെ എടുത്തെഴുതുക മാത്രമാണ് പ്രോഗ്രാം ചെയ്യുന്നത് --- എന്നുള്ളതാണ്. string-കളെപ്പറ്റി കൂടുതല്‍ നമുക്ക് വഴിയേ പഠിക്കാം.

പ്രോഗ്രാമിന്റെ മലയാളം പതിപ്പ്

മുകളില്‍ക്കൊടുത്ത പ്രോഗ്രാമിന്റെ മലയാളത്തിലുള്ള പതിപ്പാണ് താഴെയുള്ളത്. ഇത് പ്രവര്‍ത്തിപ്പിക്കാന്‍ മുമ്പുചെയ്തതുപോലെ gedit-ല്‍ ഒരു പുതിയ ഫയല്‍ തുറന്ന്, പ്രോഗ്രാം അതിലേക്ക് പകര്‍ത്തി, ml_helloworld.py എന്ന പേരില്‍ സേവ് ചെയ്യുക. മുമ്പുപറഞ്ഞതുപോലെ ഈ പേര് എന്തുവേണമെങ്കിലുമാകാം, .py എന്ന് അവസാനിക്കണമെന്നേയുള്ളൂ. ഒരു കാര്യം പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടത്, ഫയലിന്റെ ആദ്യത്തെ വരിയില്‍ത്തന്നെ "...coding..." എന്നത് വരണം എന്നുള്ളതാണ്. പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുന്നവിധവും നേരത്തേതുപോലെതന്നെ: പ്രോഗ്രാം സേവ് ചെയ്തിരിക്കുന്ന ഡയറക്ടറിയില്‍ ടെര്‍മിനല്‍ ഉപയോഗിച്ച് python ml_helloworld.py എന്ന കമാന്റ് കൊടുക്കുക. ഈ പ്രോഗ്രാമിനെപ്പറ്റിയുള്ള വിവരണം കമന്റുകളായി പ്രോഗ്രാമില്‍ത്തന്നെ ചേര്‍ത്തിട്ടുണ്ട്.

# 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!

കളര്‍ പതിപ്പ്:




ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കേണ്ടതെങ്ങനെ എന്ന് നമുക്കറിയാം: ഒന്നാം പാഠത്തില്‍ ചെയ്തതുപോലെ ഒരു ഫയലില്‍ (ഉദാ: calc.py) പ്രോഗ്രാം എഴുതുക (കോപ്പി-പേസ്റ്റ് ചെയ്താലും മതി), അതുകഴിഞ്ഞ് ടെര്‍മിനലില്‍ ഫയല്‍ സൂക്ഷിച്ചിരിക്കുന്ന ഡയറക്ടറിയില്‍ ചെന്ന് python calc.py എന്ന കമാന്റ് കൊടുക്കുക.

ഈ പ്രോഗ്രാമില്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങള്‍:

• ഹരണക്രിയയില്‍ ഉള്‍പ്പെട്ടിരിക്കുന്ന രണ്ടു സംഖ്യകളൂം ദശാംശ ചിഹ്നം ഇല്ലാത്തവയാണെങ്കില് ഉത്തരവും ദശാംശ ചിഹ്നം ഇല്ലാതെ ശരിക്കുള്ള ഉത്തരത്തിന്റെ പൂര്‍ണ്ണസംഖ്യാഭാഗം മാത്രമായിരിക്കും. കൂടുതല്‍ കൃത്യമായ ഉത്തരം കിട്ടാന്‍ ഒരു സംഖ്യയിലെങ്കിലും ഒരു ദശാംശ ചിഹ്നം ഇടുക.
• print ഉപയോഗിച്ച് ഒന്നിലധികം കാര്യങ്ങള്‍ കാണിക്കാന്‍ കോമ ഉപയോഗിക്കുക.
• print "5 + 3 = ", 5 + 3 എന്നതിലെ string-നെ അതേപടിയും, string അല്ലാത്ത 5 + 3 എന്നതിന്റെ മൂല്യം കണ്ടുപിടിച്ച് അതും output ആയി കിട്ടുന്നത് ശ്രദ്ധിക്കുക.
• വായിക്കാനുള്ള സൗകര്യത്തിനായി ദൈര്‍ഘ്യമേറിയ ഒരു വരിയെ backslash (\) ഉപയോഗിച്ച് രണ്ടായി മുറിച്ച് എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ ചിഹ്നമില്ലാതെ ഈ വരിയെ രണ്ടായി മുറിച്ചാല്‍ എന്തു സംഭവിക്കും? പരീക്ഷിച്ചുനോക്കുക!

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

ഗണിതത്തില്‍ താത്പര്യമുള്ളവര്‍ക്കായി ഒരു പൈത്തണ്‍ പസില്‍ (അല്ലാത്തവര്‍ക്കും ശ്രമിക്കാം!) : ഈ പാഠത്തില്‍ പരിചയപ്പെട്ട പൈത്തണ്‍ മാത്രമുപയോഗിച്ച് ഒരു സംഖ്യയുടെ വര്‍ഗമൂലം എങ്ങനെ കാണാം? ഉദാഹരണത്തിന്, നാലിന്റെ വര്‍ഗമൂലം രണ്ടാണെന്ന് നമുക്കറിയാം. ഇത് പൈത്തണെക്കൊണ്ട് എങ്ങനെ പറയിപ്പിക്കും? രണ്ടിന്റെ (ഏകദേശ) വര്‍ഗമൂലം കാണാനോ? മൂന്നാം മൂലമാണെങ്കിലോ?

അടുത്ത പാഠത്തില്‍: പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ അനായാസം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനുള്ള പുതിയ രണ്ടു വഴികള്‍.

കടപ്പാട്: സന്തോഷ് തോട്ടിങ്ങല്‍