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

ഈ പാഠത്തില്‍: പൈത്തണ്‍ ഷെല്‍, 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 ഉള്ള രണ്ടാമത്തെ വിന്‍ഡോയില്‍ നോക്കുക!

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