പൈത്തണ് : പാഠം എട്ട്
>> 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
എന്ന് പേരുകൊടുക്കാം.
ഈ പ്രോഗ്രാം ഒരു ഫയലില് (ഉദാ: 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
എന്ന ഏകദം നാം നിര്വചിച്ചത് എങ്ങനെയാണെന്ന് ഒന്നുകൂടി നോക്കാം:
ഏകദം നിര്വചിക്കുമ്പോള് പാലിക്കേണ്ട നിയമങ്ങള് ഇവയാണ്:
- നിര്വചനത്തിന്റെ ആദ്യത്തെ വരി (നമ്മുടെ പ്രോഗ്രാമിലെ മൂന്നാമത്തെ
വരി) ഏകദത്തിന്റെ ശീര്ഷകമാണ്. ഏകദത്തിന്റെ പേരും അതിന് കൊടുക്കുന്ന
വാക്യങ്ങളുടെ പേരുകളും ഈ വരിയില് വ്യക്തമാക്കുന്നു. ഈ വരിയുടെ വ്യാകരണം
ഇതാണ്:
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.
- ഈ പ്രോഗ്രാം 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, 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-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില് വച്ചുമാറുക. ഇപ്പോള് ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില് ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
- ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള് ഉള്പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില് ക്രമീകരിക്കുക.
- ഇപ്പോള് ലിസ്റ്റിന്റെ തുടക്കത്തില് അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല് അവസാനത്തതു വരെയുള്ള അംഗങ്ങള് ഉള്പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
- ശുഭം!
നമുക്ക് ക്രമീകരിക്കേണ്ട ലിസ്റ്റ് ഇതാണ്:
ഈ ലിസ്റ്റില് ഒന്നിലധികം അംഗങ്ങള് ഉള്ളതുകൊണ്ട് രീതിയുടെ പടി 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] എന്ന ലിസ്റ്റിന്റെ കടലാസും പേനയുമുപയോഗിച്ച് ഈ രീതിയില് അവരോഹണക്രമത്തില് — ഏറ്റവും വലിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില് — ക്രമീകരിക്കുക.
തെരഞ്ഞെടുക്കല് ക്രമീകരണം നടപ്പിലാക്കുന്ന ഒരു പൈത്തണ് ഏകദം എഴുതുക എന്നതാണ് ഈ പാഠത്തില് ഇനി നാം ചെയ്യാന് പോകുന്നത്. അതിനുമുമ്പ് ഈ രീതി പ്രവര്ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് നന്നായി മനസ്സിലാക്കണം. ഈ രീതിയുടെ ഒന്നാമത്തെ പടി ശരിയാണെന്ന് നിസ്സംശയം പറയാമല്ലോ? ഒരേ ഒരംഗം മാത്രമുള്ള ലിസ്റ്റ് തീര്ച്ചയായും ക്രമീകരിക്കപ്പെട്ടതുതന്നെയാണ്.
ഈ രീതിയുടെ കാതലായ ഭാഗം അതിന്റെ രണ്ടാമത്തെ പടിയാണ്. ഇവിടെ ലിസ്റ്റിലെ ഏറ്റവും വലിയ അംഗത്തിനെ കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില് കൊണ്ടുവയ്ക്കുന്നു. ക്രമീകരിക്കപ്പെട്ട ലിസ്റ്റില് ഈ അംഗം ലിസ്റ്റിന്റെ തുടക്കത്തില്ത്തന്നെയാണല്ലോ വരേണ്ടത്? അപ്പോള് ഇങ്ങനെ ചെയ്യുന്നതുവഴി നാം ഉത്തരത്തിലേക്ക് ഒരു ചെറിയ പടി മുന്നേറുന്നു.ഇനി ബാക്കിയുള്ള ലിസ്റ്റ് ക്രമീകരിച്ചാല് മാത്രം മതി. ഇതിന് ഇതേ രീതി ആ ലിസ്റ്റിന്മേല് പ്രയോഗിച്ചാല് മതിയെന്ന് പറയുന്നത് ബോധ്യപ്പെട്ടോ? "ഇതേ രീതി" ആ (ഉപ)ലിസ്റ്റിന്മേല് പ്രയോഗിക്കുമ്പോള് എന്താണ് സംഭവിക്കുന്നതെന്ന് ആലോചിച്ചുനോക്കൂ.
- ഉപലിസ്റ്റില് ഒരംഗമേയുള്ളൂവെങ്കില് ഉപലിസ്റ്റ് ക്രമത്തില്ത്തന്നെയാണ്. ( കൂടാതെ ഈ സംഖ്യ മൊത്തം ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയുമാണ് — ഇതെന്തുകൊണ്ടാണെന്ന് ആലോചിച്ചുനോക്കൂ.) അപ്പോള് ലിസ്റ്റ് മുഴുവനായും ക്രമത്തില് ആയിക്കഴിഞ്ഞു.
- ഉപലിസ്റ്റില് ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില് നമ്മുടെ പ്രവര്ത്തനരീതി അതില് ഏറ്റവും വലിയ സംഖ്യയെ കണ്ടുപിടിച്ച് ഉപലിസ്റ്റിന്റെ തുടക്കത്തില് കൊണ്ടുവയ്ക്കുന്നു. ഇത് ശരിയായ നടപടി തന്നെയല്ലേ? ഇനി ഈ ഉപലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ലിസ്റ്റിനെ ("ഉപൗപ" ലിസ്റ്റിനെ) ക്രമീകരിച്ചാല് മൊത്തം ലിസ്റ്റും ക്രമത്തിലാകും. നമ്മുടെ രീതിയും ഇതുതന്നെയാണ് ചെയ്യുന്നത്.
പ്രവര്ത്തനം
- പ്രവ. 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
എന്ന ചരത്തില് സൂക്ഷിച്ചുവെച്ചിട്ടുണ്ട് എന്നോര്ക്കുക) വലിയ ഒരു
സംഖ്യ കണ്ടാല് രണ്ടു കാര്യങ്ങളാണ് ചെയ്യേണ്ടത്:
- പുതുതായി കണ്ട വലിയ സംഖ്യയെ
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
എന്ന ഏകദമാണ് ക്രമീകരണം നടപ്പിലാക്കുന്നത്.
ഈ പ്രോഗ്രാമിലെ ആദ്യത്തെ രണ്ട് ഏകദങ്ങള് (
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 എന്നതിന് "ഏകദത്തിന്റെ വാക്യം" എന്ന് പ്രയോഗിച്ചിരിക്കുന്നു. ↩