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

ആമുഖം

പൈത്തണ്‍ പാഠങ്ങളില്‍ ഇതുവരെ ചരങ്ങള്‍ (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()

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

1. range(10) , len("Thiruvananthapuram") എന്നീ ഏകദപ്രയോഗങ്ങളുടെ വിലകള്‍ യഥാക്രമം r , length എന്നീ ചരങ്ങളില്‍ സൂക്ഷിച്ച് വെച്ചിരിക്കുന്നു.
2. 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] എന്ന ലിസ്റ്റ് കിട്ടുന്നത്.
3. ആദ്യത്തെ ഉദാഹരണങ്ങളില്‍നിന്ന് ഒരുപക്ഷേ മനസ്സിലായേക്കാവുന്ന ഒരു കാര്യം തെറ്റാണെന്ന് ഇവിടെ കാണാം. ഒരു ഏകദത്തെ പ്രയോഗിക്കുമ്പോള്‍ അതിന്റെ മൂല്യം പ്രിന്റ് ചെയ്യപ്പെടുക എന്നത് ഏകദത്തിന്റെ സ്വഭാവം അല്ല . ഈ ഉദാഹരണത്തിലെ range(10) , len("Thiruvananthapuram") എന്നീ പ്രയോഗങ്ങളും len("Pathanamthitta") എന്ന പ്രയോഗവും ഇത് വ്യക്തമാക്കുന്നു. തന്നിരിക്കുന്ന വ്യഞ്ജകത്തിന്റെ (expression) മൂല്യം പ്രിന്റ് ചെയ്യുക എന്നത് ഷെല്ലിന്റെ പ്രത്യേകത ആയതുകൊണ്ടാണ് ഇതിന് മുമ്പുള്ള ഉദാഹരണങ്ങളില്‍ ഓരോ ഏകദപ്രയോഗത്തിന്റെയും വില പ്രിന്റ് ചെയ്യപ്പെട്ടത്.

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

ഏകദങ്ങളെ നിര്‍‌വചിക്കുന്ന വിധം. ‍

range, len എന്നിവ കൂടാതെ പൈത്തണില്‍ സ്വതവേ ലഭ്യമായ (built-in) ഒട്ടനേകം ഏകദങ്ങളുണ്ട്. ഇതുകൂടാതെ ആവശ്യമുള്ള ഏകദങ്ങളെ നമുക്ക് സ്വയം നിര്‍‌വചിച്ച് (define) ഉപയോഗിക്കുകയും ചെയ്യാം. ഇതെങ്ങനെയാണ് ചെയ്യുന്നതെന്ന് നോക്കാം. ആദ്യമായി, രണ്ട് സംഖ്യകളെ സ്വീകരിച്ച് അവയുടെ തുക തിരിച്ചുതരുന്ന, ലളിതമായ ഒരു ഏകദം എഴുതാം. ഏകദത്തിന് പേരുകൊടുക്കുമ്പോള്‍ ഏകദം ചെയ്യുന്നതെന്താണെന്ന് സൂചിപ്പിക്കുന്ന തരത്തിലുള്ള പേര് കൊടുക്കുന്നതാണ് നല്ല രീതി. നമ്മുടെ ഏകദത്തിന് നമുക്ക് add എന്ന് പേരുകൊടുക്കാം. ഈ പ്രോഗ്രാം ഒരു ഫയലില്‍ (ഉദാ: add.py) സേവ് ചെയ്യുക. IDLE-ല്‍ ഈ ഫയല്‍ തുറന്ന് (File -> Open), തുറന്ന ഫയല്‍ പ്രവര്‍ത്തിപ്പിക്കുക (Run -> Run Module, അല്ലെങ്കില്‍ F5 അമര്‍ത്തുക). അപ്പോള്‍ പുതിയ ഒരു ഷെല്‍ തുറന്നുവരും. ഈ ഷെല്ലില്‍ നാം ഫയലില്‍ നിര്‍‌വചിച്ച ഏകദം നമുക്ക് പ്രയോഗിക്കാനായി ലഭ്യമാണ്. 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. നിര്‍‌വചനത്തിന്റെ ആദ്യത്തെ വരി (നമ്മുടെ പ്രോഗ്രാമിലെ മൂന്നാമത്തെ വരി) ഏകദത്തിന്റെ ശീര്‍ഷകമാണ്. ഏകദത്തിന്റെ പേരും അതിന് കൊടുക്കുന്ന വാക്യങ്ങളുടെ പേരുകളും ഈ വരിയില്‍ വ്യക്തമാക്കുന്നു. ഈ വരിയുടെ വ്യാകരണം ഇതാണ്: def function_name ( argument_names ) : .
   • def എന്നത് ഏകദം നിര്‍‌വചിക്കാന്‍ (define) ഉപയോഗിക്കുന്ന പ്രത്യേകവാക്ക് (keyword) ആണ്. define എന്നതിന്റെ ചുരുക്കമാണ് ഇത്.
   • def കഴിഞ്ഞ് അതേ വരിയില്‍ ഏകദത്തിന്റെ (നമുക്ക് ഇഷ്ടമുള്ള) പേര് (function name) കൊടുത്തിരിക്കുന്നു. നമ്മുടെ ഉദാഹരണത്തില്‍ ഇത് add എന്നാണ്.
   • ഏകദത്തിന്റെ പേരിനുശേഷം '(', ')' എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി ഏകദത്തിന്റെ വാക്യങ്ങളുടെ (arguments) പേര്(കള്‍) പറയുന്നു. ഒന്നിലധികം വാക്യങ്ങളുണ്ടെങ്കില്‍ അവയെ കോമയുപയോഗിച്ച് വേര്‍തിരിക്കുന്നു. വാക്യങ്ങളുടെ പേരും നമുക്ക് ഇഷ്ടമുള്ളത് കൊടുക്കാം. ഇവിടെ a, b എന്നിവയാണ് നമ്മുടെ ഏകദത്തിന്റെ വാക്യങ്ങള്‍. ഈ വരിയുടെ അവസാനമുള്ള : പ്രത്യേകം ശ്രദ്ധിക്കുക. ഏകദത്തിന്റെ പേരും വാക്യങ്ങളുടെ പേരും പറഞ്ഞുകഴിഞ്ഞു എന്ന് പൈത്തണിന് മനസ്സിലാകുന്നത് ഈ : കാണുമ്പോഴാണ്.
2. ഏകദത്തിന്റെ ശീര്‍ഷകം കഴിഞ്ഞുള്ള വരികളില്‍ ഏകദത്തിന്റെ ഉള്ളടക്കം എഴുതണം. നമ്മുടെ ഉദാഹരണത്തില്‍ ഏകദത്തിന്റെ ഉള്ളടക്കം sum = a + b , return sum എന്നീ രണ്ടു വരികളാണ്. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ശീര്‍ഷകത്തെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. കൂടാതെ if .. else, while എന്നിവ ഉള്ളടക്കത്തില്‍ ഉപയോഗിക്കുന്നുണ്ടെങ്കില്‍ നിരപ്പിനെ (indentation) സംബന്ധിച്ച അവയുടെ നിയമങ്ങളും പാലിക്കണം. ഇനിയുള്ള ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഇത് മനസ്സിലാകും.
3. മുകളിലെ ഉദാഹരണത്തില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത് (നാലാമത്തെ വരി). ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
4. IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍ ശീര്‍ഷകത്തിന്റെ അവസാനമുള്ള : എഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കപ്പോഴും ഇത് അവസാനം കൊടുക്കേണ്ടതായ : വിട്ടുപോയതുകൊണ്ടാവും.
5. ഏകദം തിരിച്ചുതരേണ്ടതായ മൂല്യം നിര്‍മ്മിക്കാന്‍ ആവശ്യമായ പൈത്തണ്‍ കോഡ് ഏകദത്തിന്റെ ഉള്ളടക്കത്തില്‍ എഴുതണം. ഇങ്ങനെ എഴുതുമ്പോള്‍ ഏകദത്തിന്റെ വാക്യങ്ങളെ ചരങ്ങളായി ഉപയോഗിക്കാം. നമ്മുടെ ഉദാഹരണത്തിലെ ഉള്ളടക്കത്തില്‍ sum എന്ന ചരത്തിന് ഏകദത്തിന്റെ വാക്യങ്ങളായ a, b എന്നീ ചരങ്ങളുടെ തുക വിലയായി കൊടുത്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക.
6. ഏകദം തിരിച്ചുതരേണ്ടതായ വില കണ്ടുപിടിച്ചുകഴിഞ്ഞാല്‍ അത് return എന്ന പ്രത്യേകവാക്ക് (keyword) ഉപയോഗിച്ച് ഏകദത്തില്‍നിന്ന് തിരിച്ചുകൊടുക്കാം. നമ്മുടെ ഉദാഹരണത്തില്‍ return sum എന്ന് എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക.
7. ഇങ്ങനെ return എന്ന പ്രയോഗം കണ്ടാല്‍ ആ വില ഏകദത്തില്‍നിന്ന് തിരിച്ചുകൊടുക്കും. കൂടാതെ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം ഏകദത്തിന് പുറത്ത് (പ്രോഗ്രാമില്‍ ഏകദത്തിനെ പ്രയോഗിച്ച സ്ഥലത്ത്) എത്തിച്ചേരുകയും ചെയ്യും.
8. ഏകദത്തിന്റെ ഉള്ളടക്കം എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരി ഏകദത്തിന്റെ ശീര്‍ഷകം തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം. ഏകദത്തിന്റെ നിര്‍‌വചനം പൂര്‍ത്തിയായി എന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത് ഇത് കാണുമ്പോഴാണ്. ഇനിയുള്ള ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഇത് മനസ്സിലാകും.
9. ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.

ഇനി നമുക്ക് ഈ നിയമങ്ങള്‍ നന്നായി മനസ്സിലാകാനായി കുറച്ച് ഉദാഹരണങ്ങള്‍ കാണാം. രണ്ട് സംഖ്യകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ വലുതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. ഈ ഏകദത്തിനെ നമുക്ക് larger എന്ന് വിളിക്കാം. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരും.

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

പ്രവ. 1.

മുകളില്‍ കൊടുത്ത ഏകദം വായിച്ചു മനസ്സിലാക്കുക. ഇത് എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.

പ്രവ. 2.

ഈ പ്രോഗ്രാം larger.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് (larger.py എന്നതിനു പകരം നിങ്ങള്‍ക്ക് ഇഷ്ടമുള്ള .py എന്ന് അവസാനിക്കുന്ന പേരുകൊടുക്കാം) IDLE-ല്‍ (അല്ലെങ്കില്‍ ഷെല്ലില്‍) ലഭ്യമാക്കുക. larger എന്ന ഏകദത്തിന് പല ജോടി സംഖ്യകള്‍ വാക്യങ്ങളായി കൊടുത്ത് അത് ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക.

പ്രവ. 3.

രണ്ട് സംഖ്യകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ ചെറുതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഈ ഏകദത്തിന് smaller എന്ന് പേരുകൊടുക്കുക. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരണം. ഈ പ്രോഗ്രാം smaller.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE‍ (അല്ലെങ്കില്‍ ഷെല്‍) വഴിയായി അതിന്റെ പ്രവര്‍ത്തനം പരീക്ഷിച്ചുനോക്കുക.

ഇനി നമുക്ക് രണ്ട് സ്ട്രിംഗുകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ കൂടുതല്‍ നീളമുള്ളതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. രണ്ട് സ്ട്രിംഗുകള്‍ക്കും ഒരേ നീളമാണെങ്കില്‍ ഏകദം ആദ്യത്തെ സ്ട്രിംഗിനെ തിരിച്ചുതരും. ഈ ഏകദത്തിന് നമുക്ക് longer എന്ന് പേരിടാം. ഈ ഏകദത്തിന് larger എന്ന ഏകദത്തിനോടുള്ള സാമ്യം ശ്രദ്ധിക്കുക. കഴിഞ്ഞ പാഠത്തില്‍ എഴുതിയ ഒരു പ്രോഗ്രാം ഈ ഏകദമുപയോഗിച്ച് എഴുതി നോക്കാം. കേരളത്തിലെ ഏത് ജില്ലയുടെ പേരിനാണ് ഇംഗ്ളീഷില്‍ എഴുതിയാല്‍ ഏറ്റവും നീളം എന്ന് കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം കഴിഞ്ഞ പാഠത്തില്‍ എഴുതിയത് ഇങ്ങനെയാണ്: ഇതേ പ്രോഗ്രാം നമ്മുടെ longer എന്ന ഏകദമുപയോഗിച്ച് എഴുതിയാല്‍ ഇങ്ങനെയാകും: ഈ പ്രോഗ്രാമിന്റെ 27-ആം വരിയില്‍ ഉപയോഗിക്കുന്ന longer എന്ന ഏകദത്തിന്റെ നിര്‍വചനം ഇങ്ങനെ ഉപയോഗിക്കുന്നതിന് മുമ്പായി (8 മുതല്‍ 12 വരെയുള്ള വരികളിലായി) എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒരു ഏകദം ഉപയോഗിക്കുന്നതിന് മുമ്പ് അതിന്റെ നിര്‍വചനം എഴുതിയിരിക്കണം. ഇത് മറ്റൊരു ഫയലില്‍ എഴുതാനുള്ള സംവിധാനവുമുണ്ട്. അതായത്, ഏകദത്തിന്റെ നിര്‍വചനം ഒരു ഫയലിലും, അതിന്റെ പ്രയോഗം വേറൊരു ഫയലിലും വേണമെങ്കില്‍ ആകാം. ഇത് എങ്ങനെയാണ് ചെയ്യേണ്ടതെന്ന് വഴിയേ കാണാം. ഈ പാഠത്തില്‍ നമുക്ക് ഏകദത്തിന്റെ നിര്‍വചനവും അത് പ്രയോഗിക്കുന്ന പ്രോഗ്രാമും ഒരേ ഫയലില്‍ത്തന്നെ എഴുതാം.

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

പ്രവ. 4.

മുകളില്‍ കൊടുത്ത പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.

പ്രവ. 5.

ഈ പ്രോഗ്രാം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലാക്കുക. ഇതില്‍ longer എന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് (27-ആം വരിയില്‍ )എങ്ങനെയാണെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.

ഇനി സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. ഇതിന് largest എന്ന് പേരിടാം. ഈ ഏകദത്തിന് മുകളിലത്തെ പ്രോഗ്രാമുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക. largest എന്ന ഏകദത്തില്‍ larger എന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് കാണുക. ഇങ്ങനെ ഉപയോഗിക്കുവാന്‍‌വേണ്ടി, largest എന്ന ഏകദത്തിന് മുമ്പായി larger എന്ന ഏകദത്തിന്റെ നിര്‍വചനം എടുത്തെഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ പാഠത്തിലുടനീളം ഇങ്ങനെയാവും നാം പ്രോഗ്രാമുകളെഴുതുക. ഈ പ്രോഗ്രാം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE-ല്‍ തുറക്കുക. തുറന്ന ഫയല്‍ പ്രവര്‍ത്തിപ്പിക്കുക (Run -> Run Module, അല്ലെങ്കില്‍ F5 അമര്‍ത്തുക). ഇനി തുറന്നുവരുന്ന ഷെല്ലില്‍ largest എന്ന ഏകദം ലഭ്യമാണ്. സംഖ്യകളുടെ പല ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്ത് ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ട് എന്ന് ഉറപ്പുവരുത്തുക. ഉദാഹരണങ്ങള്‍ക്കായി ചിത്രം കാണുക(ചിത്രം വ്യക്തമായി കാണാന്‍ അതില്‍ അമര്‍ത്തുക).

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

പ്രവ. 6.

സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഇതിന് smallest എന്ന് പേരിടുക. ഈ ഏകദം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് ഫയല്‍ IDLE-ലോ ഷെല്ലിലോ പ്രവര്‍ത്തിപ്പിക്കുക. ഇനി ഈ ഏകദത്തിന് താഴെക്കൊടുത്തിരിക്കുന്ന ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്തുനോക്കുക. ഉത്തരം ശരിയാകുന്നുണ്ടോ?

1. [1, 0]
2. [1, 1, 1, 1, 0]
3. [1, 1, 1, 1, 0, 1]
4. [1, 2, 3, 4, 5]
5. [5, 4, 3, 2, 1]

ക്രമീകരണം (Sorting)

ഒരു കൂട്ടം സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത് അവയെ അവരോഹണക്രമത്തില്‍ (ഏറ്റവും വലുത് ആദ്യം വരുന്ന ക്രമത്തില്‍ --- ഇംഗ്ളീഷില്‍ descending order) ക്രമപ്പെടുത്തുന്ന ഒരു പ്രോഗ്രാം ഇനി നമുക്ക് എഴുതാം. ഇതിന് നാം എഴുതിയ largest എന്ന ഏകദം ചെറിയ മാറ്റങ്ങളോടെ ഉപയോഗിക്കാം.

ഇങ്ങനെയോ മറിച്ചുള്ള (ആരോഹണ) ക്രമത്തിലോ സംഖ്യകളെ (മറ്റ് വിവരങ്ങളേയും) അടുക്കുന്നതിന് ക്രമീകരണം (Sorting) എന്നു പറയുന്നു. ഇത് കംപ്യൂട്ടര്‍ പ്രോഗ്രാമുകളില്‍ (അല്ലാതെയും) വളരെയധികം ആവശ്യമുള്ള ഒരു പ്രവര്‍ത്തനമാണ്. ക്രമീകരിച്ച വിവരങ്ങളില്‍ പരതാനും മറ്റും വളരെ എളുപ്പമാണ്: നൂറുകണക്കിന് പേജുകളിലായി പതിനായിരക്കണക്കിന് വാക്കുകളുടെ അര്‍ത്ഥങ്ങള്‍ കൊടുത്തിരിക്കുന്ന ഒരു നിഘണ്ടുവില്‍ നമുക്ക് ആവശ്യമുള്ള വാക്കിന്റെ അര്‍ത്ഥം കണ്ടുപിടിക്കാന്‍ എത്ര എളുപ്പമാണ് എന്നത് ഓര്‍ക്കുക. അതുപോലെ, ആയിരക്കണക്കിന് ആളുകളുടെ പേരും ഫോണ്‍ നമ്പരും കൊടുത്തിട്ടുള്ള ഫോണ്‍ ഡയറക്ടറിയില്‍ നിന്ന് ഒരാളുടെ ഫോണ്‍ നമ്പര്‍ കണ്ടുപിടിക്കാന്‍ കുറച്ചു സമയമല്ലേ വേണ്ടൂ? നിഘണ്ടുവിലെ വാക്കുകളും ഫോണ്‍ ഡയറക്ടറിയിലെ പേരുകളും (അക്ഷരമാലാ ക്രമത്തില്‍) ക്രമീകരിച്ചിരിക്കുന്നതുകൊണ്ടാണ് ഇത് സാധ്യമാകുന്നത്. ക്രമീകരണത്തിനായി പലതരം അ‍ല്‍ഗോരിതങ്ങള്‍ (പ്രവര്‍ത്തനരീതികള്‍) ലഭ്യമാണ്. ഇവയില്‍ ലളിതമായ ഒരു രീതി നമുക്ക് ഈ പാഠത്തില്‍ പ്രോഗ്രാമായി എഴുതാം. ഈ രീതിയുടെ പേര് "തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം" (Selection sort) എന്നാണ്. ഇതിന്റെ ആശയം മനസ്സിലാക്കാന്‍ വളരെ എളുപ്പമാണ്. ഈ രീതിയുടെ പ്രവര്‍ത്തനം ഇങ്ങനെയാണ്:

1. ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍, അഥവാ ലിസ്റ്റില്‍ ഒരേ ഒരു അംഗം (സംഖ്യ) മാത്രമേയുള്ളൂ എങ്കില്‍ ലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ഇങ്ങനെയാണെങ്കില്‍ തന്നിരിക്കുന്ന ലിസ്റ്റിനെത്തന്നെ ഉത്തരമായി തിരിച്ചുകൊടുക്കുക. ഇങ്ങനെ അല്ലെങ്കില്‍ (ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍):
2. ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതെന്ന് കണ്ടുപിടിക്കുക. ഇത് a എന്ന സംഖ്യ ആണെന്നിരിക്കട്ടെ :
   1. a എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരിക. ഇതിനായി a-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറുക. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില്‍ ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
   2. ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില്‍ ക്രമീകരിക്കുക.
   3. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല്‍ അവസാനത്തതു വരെയുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
3. ശുഭം!

ഈ രീതി പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് മനസ്സിലാക്കാന്‍ ഇങ്ങനെ ക്രമീകരിക്കുന്നതിന്റെ ഒരു ഉദാഹരണം നമുക്ക് കാണാം.

നമുക്ക് ക്രമീകരിക്കേണ്ട ലിസ്റ്റ് ഇതാണ്:

ഈ ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങള്‍ ഉള്ളതുകൊണ്ട് രീതിയുടെ പടി 1 ബാധകമല്ല. അതുകൊണ്ട് നാം പടി 2 പ്രകാരം ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടുപിടിക്കുന്നു. ഇത് 23 ആണ്.

ഇനി പടി (2.i)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ 23 എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരുന്നു.

ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യയാണ് ഉള്ളത്. അതായത് ലിസ്റ്റിന്റെ തുടക്കം "ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു". ഇനി ലിസ്റ്റിന്റെ രണ്ടാമത്തേത് മുതലുള്ള ഭാഗം ക്രമീകരിച്ചാല്‍ മതി. ഇത് സൂചിപ്പിക്കാനായി ലിസ്റ്റിലെ ആദ്യത്തെ അംഗത്തിന് — ഇപ്പോള്‍ ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞ ഭാഗത്തിന് — ചാര നിറം കൊടുത്ത് ചിത്രത്തില്‍ കാണിച്ചിരിക്കുന്നു.

ഇനി പടി (2.ii)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗം ഇതേ രീതിയില്‍ ക്രമീകരിക്കണം. ഇതിനായി നാം ഈ പ്രവര്‍ത്തനരീതി തുടക്കം മുതല്‍ [15, 1, 7] എന്ന ലിസ്റ്റിന്റെമേല്‍ പ്രയോഗിക്കണം. ഈ ലിസ്റ്റിലും ഒന്നിലധികം അംഗങ്ങളുള്ളതുകൊണ്ട് രീതിയുടെ ഒന്നാം പടി ഇവിടെ ബാധകമല്ല. അതുകൊണ്ട് നാം പടി 2 പ്രകാരം ഈ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടുപിടിക്കുന്നു. ഇത് 15 ആണ്.

ഇനി പടി (2.i)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ 15 എന്ന സംഖ്യ ഈ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരുന്നു. 15 സ്വതവേതന്നെ ഈ ലിസ്റ്റിന്റെ തുടക്കത്തിലായതുകൊണ്ട് അതിന്റെ സ്ഥാനത്തിന് മാറ്റമൊന്നുമില്ല.

ഇനി ഇതേ രീതിയില്‍ [1, 7] എന്ന ലിസ്റ്റ് ക്രമീകരിക്കുന്നു.

ഇപ്പോള്‍ ക്രമീകരിക്കാനായി ബാക്കിയുള്ള ലിസ്റ്റില്‍ ഒരേ ഒരംഗം മാത്രമേയുള്ളൂ. ഈ ഏകാംഗ ലിസ്റ്റിനെ നമ്മുടെ രീതിയില്‍ ക്രമീകരിക്കാന്‍ ശ്രമിക്കുമ്പോള്‍ രീതിയുടെ ഒന്നാം പടി ബാധകമാകുന്നു: ഈ ഏകാംഗ ലിസ്റ്റ് സ്വതവേതന്നെ ക്രമീകരിക്കപ്പെട്ടതാണ്. ഇപ്പോള്‍ നമ്മുടെ ലിസ്റ്റ് പൂര്‍ണ്ണമായും ക്രമീകരിച്ചുകഴിഞ്ഞു.

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

പ്രവ. 7.

തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായെന്ന് ഉറപ്പുവരുത്താന്‍ [35, 2, 3, 56, 5, 7, 9] എന്ന ലിസ്റ്റിന്റെ കടലാസും പേനയുമുപയോഗിച്ച് ഈ രീതിയില്‍ അവരോഹണക്രമത്തില്‍ — ഏറ്റവും വലിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില്‍ — ക്രമീകരിക്കുക.

തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം നടപ്പിലാക്കുന്ന ഒരു പൈത്തണ്‍ ഏകദം എഴുതുക എന്നതാണ് ഈ പാഠത്തില്‍ ഇനി നാം ചെയ്യാന്‍ പോകുന്നത്. അതിനുമുമ്പ് ഈ രീതി പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് നന്നായി മനസ്സിലാക്കണം. ഈ രീതിയുടെ ഒന്നാമത്തെ പടി ശരിയാണെന്ന് നിസ്സംശയം പറയാമല്ലോ? ഒരേ ഒരംഗം മാത്രമുള്ള ലിസ്റ്റ് തീര്‍ച്ചയായും ക്രമീകരിക്കപ്പെട്ടതുതന്നെയാണ്.

ഈ രീതിയുടെ കാതലായ ഭാഗം അതിന്റെ രണ്ടാമത്തെ പടിയാണ്. ഇവിടെ ലിസ്റ്റിലെ ഏറ്റവും വലിയ അംഗത്തിനെ കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ക്രമീകരിക്കപ്പെട്ട ലിസ്റ്റില്‍ ഈ അംഗം ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ത്തന്നെയാണല്ലോ വരേണ്ടത്? അപ്പോള്‍ ഇങ്ങനെ ചെയ്യുന്നതുവഴി നാം ഉത്തരത്തിലേക്ക് ഒരു ചെറിയ പടി മുന്നേറുന്നു.ഇനി ബാക്കിയുള്ള ലിസ്റ്റ് ക്രമീകരിച്ചാല്‍ മാത്രം മതി. ഇതിന് ഇതേ രീതി ആ ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിച്ചാല്‍ മതിയെന്ന് പറയുന്നത് ബോധ്യപ്പെട്ടോ? "ഇതേ രീതി" ആ (ഉപ)ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിക്കുമ്പോള്‍ എന്താണ് സംഭവിക്കുന്നതെന്ന് ആലോചിച്ചുനോക്കൂ.

1. ഉപലിസ്റ്റില്‍ ഒരംഗമേയുള്ളൂവെങ്കില്‍ ഉപലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ( കൂടാതെ ഈ സംഖ്യ മൊത്തം ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയുമാണ് — ഇതെന്തുകൊണ്ടാണെന്ന് ആലോചിച്ചുനോക്കൂ.) അപ്പോള്‍ ലിസ്റ്റ് മുഴുവനായും ക്രമത്തില്‍ ആയിക്കഴിഞ്ഞു.
2. ഉപലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍ നമ്മുടെ പ്രവര്‍ത്തനരീതി അതില്‍ ഏറ്റവും വലിയ സംഖ്യയെ കണ്ടുപിടിച്ച് ഉപലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ഇത് ശരിയായ നടപടി തന്നെയല്ലേ? ഇനി ഈ ഉപലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ലിസ്റ്റിനെ ("ഉപൗപ" ലിസ്റ്റിനെ) ക്രമീകരിച്ചാല്‍ മൊത്തം ലിസ്റ്റും ക്രമത്തിലാകും. നമ്മുടെ രീതിയും ഇതുതന്നെയാണ് ചെയ്യുന്നത്.

ചുരുക്കത്തില്‍ പറഞ്ഞാല്‍, "ക്രമീകരിക്കേണ്ട ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതാണെന്ന് കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവന്ന് വയ്ക്കുക. ഇനി ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗത്തിനേയും ഇതേ രീതിയില്‍ കൈകാര്യം ചെയ്യുക." എന്നതാണ് തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തില്‍ ചെയ്യുന്നത്.

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

പ്രവ. 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 നമുക്ക് ഇങ്ങനെയെഴുതാം: ഈ പുതിയ ഏകദത്തിന്റെ പ്രവര്‍ത്തനം മനസ്സിലാക്കാന്‍ പ്രോഗ്രാമിനെ ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE-ലോ ഷെല്ലിലോ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാം. ഷെല്ലില്‍ പ്രവര്‍ത്തിപ്പിച്ചതിന്റെ ഉദാഹരണം ഇതാ (ഇവിടെ larger2.py എന്ന ഫയലിലാണ് സേവ് ചെയ്തത്) :

$ python -i larger2.py
>>> larger2(1, 10)
[10, True]
>>> larger2(10, 1)
[10, False]
>>> quit()

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

പ്രവ. 9.

പലപല സംഖ്യാജോടികള്‍ വാക്യങ്ങളായി കൊടുത്ത് larger2 എന്ന ഏകദം പ്രവര്‍ത്തിപ്പിക്കുക. ഏകദത്തിന്റെ പ്രവര്‍ത്തനം മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.

ഇനി നമുക്ക് ഈ ഏകദമുപയോഗിച്ച് നമുക്കുവേണ്ട largest2 എന്ന ഏകദം എഴുതാം:

മുകളിലെ പ്രോഗ്രാം നമുക്കൊന്ന് വിശദമായി വായിക്കാം. ഒന്നു മുതല്‍ പത്തുവരെയുള്ള വരികളില്‍ 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 എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെച്ചിട്ടുണ്ട് എന്നോര്‍ക്കുക) വലിയ ഒരു സംഖ്യ കണ്ടാല്‍ രണ്ടു കാര്യങ്ങളാണ് ചെയ്യേണ്ടത്:

1. പുതുതായി കണ്ട വലിയ സംഖ്യയെ largest എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെയ്ക്കുക.
2. ഈ വലിയ സംഖ്യയുടെ സ്ഥാനം 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 എന്ന ഏകദത്തിലേത്. അതുകൊണ്ട്:

1. പ്രോഗ്രാം IDLE-ലോ ഷെല്ലിലോ പലതവണ (പല സംഖ്യാ ലിസ്റ്റുക‍ളെ വാക്യങ്ങളായി കൊടുത്ത്) പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. പറഞ്ഞതുപോലെയൊക്കെ സംഭവിക്കുന്നുണ്ടോ?
2. പ്രോഗ്രാം എങ്ങനെയാണ് ഇക്കാര്യങ്ങളൊക്കെ ചെയ്യുന്നതെന്ന് ആലോചിക്കുക. ഒരുപക്ഷേ ഇതിന്റെ പ്രവര്‍ത്തനം അതിശയകരമാണെന്ന് തോന്നിയേക്കാം. ഇതില്‍ അതിശയകരമായി അത്രയ്ക്കൊന്നുമില്ല. ഈ പ്രോഗ്രാമും അതിന്റെ വിശദീകരണവും കുറച്ചുപ്രാവശ്യം ശ്രദ്ധിച്ച് വായിക്കുക. മനസ്സിലാകാത്ത കാര്യങ്ങള്‍ ചോദിക്കുക. ഇതേരീതിയിലുള്ള പല ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഈ രീതിയില്‍ ചിന്തിക്കാന്‍ നിങ്ങളും പഠിക്കും.
3. കുറെയേറെ വര്‍ഷത്തെ പ്രോഗ്രാമിംഗ് സംബന്ധമായ പരിചയം (പ്രോഗ്രാമുകള്‍ എഴുതിയും വായിച്ചും, പ്രോഗ്രാമിംഗിനെപ്പറ്റിയുള്ള ലേഖനങ്ങളും മറ്റും വായിച്ചുമുള്ളത്) അടിസ്ഥാനപ്പെടുത്തിയാണ് ഈ പ്രോഗ്രാം എഴുതിയത്. അതുകൊണ്ട് ഇതേപോലെയൊരു‌ പ്രോഗ്രാം എങ്ങനെ എഴുതും എന്നാലോചിച്ച് ‍നിങ്ങള്‍ വിഷമിക്കരുത്. നിങ്ങള്‍ സ്വയം ഇതേ കാര്യത്തിനുള്ള പ്രോഗ്രാമെഴുതിയാല്‍ മറ്റൊരു രീതിയിലായിരിക്കും അത് വരിക. പ്രോഗ്രാമിന്റെ ലോജിക് ശരിയായിരിക്കുന്നിടത്തോളം ഇതൊരു പ്രശ്നമല്ല തന്നെ. അതുപോലെ തന്നെ, എന്നെക്കാള്‍ പ്രോഗ്രാമിംഗ് വൈദഗ്ധ്യമുള്ള/വ്യത്യസ്തമായ രീതിയില്‍ പ്രോഗ്രാമിംഗ് പരിശീലിച്ച ഒരാള്‍ എഴുതുന്ന പ്രോഗ്രാം മറ്റൊരു രീതിയിലായിരിക്കും. ഇക്കാര്യത്തില്‍ പ്രോഗ്രാമിംഗ് ഭാഷ, മനുഷ്യഭാഷ പോലെതന്നെയാണ്. നമ്മുടേതിനെക്കാള്‍ വളരെ ലളിതമായ ഭാഷയാണല്ലോ നാലു വയസുള്ള ഒരു കുട്ടിയുടേത്. എന്നാല്‍പ്പോലും തനിക്ക് ആവശ്യമുള്ള കാര്യങ്ങളൊക്കെ പ്രകടിപ്പിക്കാന്‍ നാലു വയസുള്ള കുട്ടിക്കും കഴിയുന്നുമുണ്ടല്ലോ. അതുപോലെ തന്നെയാണ് പ്രോഗ്രാമിംഗിലും. നമുക്കറിയാവുന്ന ഭാഷ ഉപയോഗിച്ച് പ്രോഗ്രാമുകള്‍ എഴുതി ശീലിക്കുക. നല്ലതെന്ന് തോന്നുന്ന ശൈലികള്‍ കാണുമ്പോള്‍ മനസ്സിലാക്കി ‍വയ്ക്കുക. പരിചയം കൂടുന്തോറും ഭാഷയും മാറിക്കൊണ്ടിരിക്കും.

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

പ്രവ. 10.

സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച്, ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയും അതിന്റെ ലിസ്റ്റിലെ സ്ഥാനവും തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഏകദത്തിന് smallest2 എന്ന് പേരിടുക. largest2 എന്ന ഏകദം ചെയ്തതുപോലെ, ഈ രണ്ട് സംഖ്യകളെ ഒരു ലിസ്റ്റായി വേണം smallest2 തിരിച്ചുതരേണ്ടത്. പല പല ലിസ്റ്റുകള്‍ വാക്യമായി കൊടുത്ത് ഈ ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തുക.

തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 3

തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ പ്രവര്‍ത്തനരീതി ഒന്നുകൂടെ എടുത്തെഴുതാം :

1. ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍, അഥവാ ലിസ്റ്റില്‍ ഒരേ ഒരു അംഗം (സംഖ്യ) മാത്രമേയുള്ളൂ എങ്കില്‍ ലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ഇങ്ങനെയാണെങ്കില്‍ തന്നിരിക്കുന്ന ലിസ്റ്റിനെത്തന്നെ ഉത്തരമായി തിരിച്ചുകൊടുക്കുക. ഇങ്ങനെ അല്ലെങ്കില്‍ (ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍):
2. ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതെന്ന് കണ്ടുപിടിക്കുക. ഇത് a എന്ന സംഖ്യ ആണെന്നിരിക്കട്ടെ :
   1. a എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരിക. ഇതിനായി a-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറുക. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില്‍ ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
   2. ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില്‍ ക്രമീകരിക്കുക.
   3. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല്‍ അവസാനത്തതു വരെയുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
3. ശുഭം!

ഇക്കാര്യങ്ങള്‍ ഓരോന്നും ചെയ്യേണ്ടവിധം നാം കണ്ടുകഴിഞ്ഞു. ഇനി ഇവയെയൊക്കെ വിധിപ്രകാരം ചേര്‍ത്തുവയ്ക്കുകയേ വേണ്ടൂ. ഇങ്ങനെ ചേര്‍ത്തുവച്ച് ഉണ്ടാക്കിയ പ്രോഗ്രാം ഇതാ. ഇതില്‍ larger2, largest2 എന്നീ ഏകദങ്ങള്‍ നാം നേരത്തെ കണ്ടവ തന്നെയാണ്. ഇവയുപയോഗിച്ച് എഴുതിയ selection_sort എന്ന ഏകദമാണ് ക്രമീകരണം നടപ്പിലാക്കുന്നത്.


ഈ പ്രോഗ്രാമിലെ ആദ്യത്തെ രണ്ട് ഏകദങ്ങള്‍ ( 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):

1. numberlist[1:] എന്ന ഈ ഉപലിസ്റ്റിനെ selection_sort എന്ന (ഇതേ!) ഏകദത്തിന് വാക്യമായി കൊടുക്കുക. ഏകദം ഈ ഉപലിസ്റ്റിനെ ക്രമീകരിച്ച് തിരിച്ചുതരും.
2. ഇങ്ങനെ ക്രമീകരിച്ച് കിട്ടിയ ഉപലിസ്റ്റിനെ അത് ഇരിക്കേണ്ട സ്ഥാനത്ത് — numberlist എന്ന ലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ഉപലിസ്റ്റായി — വയ്ക്കുക.

ഇതോടെ ലിസ്റ്റ് അവരോഹണ ക്രമത്തില്‍ ആകുന്നു. ഇങ്ങനെ ക്രമീകരിച്ച ലിസ്റ്റിനെ തിരിച്ചുകൊടുക്കുന്നതോടെ ഏകദത്തിന്റെ പ്രവര്‍ത്തനം പൂര്‍ത്തിയാകുന്നു (വരി 65).

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 എന്നതിന് "ഏകദത്തിന്റെ വാക്യം" എന്ന് പ്രയോഗിച്ചിരിക്കുന്നു. ↩