ml en en en en en en en en en en en en hu ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en nl en es ml ml en ml ml ml en ml ml ml ml en ml en ml ml en ml ml en ml ml ml ml ml ml ml ml ml ru ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en el en en en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en ml ml ml ml en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en ml ml ml ml ml ml ml ml ml ml en ml ml ml ml ml ml ml ml en ml en en ml ml en en en ml ml ml ml en zh en en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en ml ml ml ml ml ml en ja zh ca zh ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en ml ml ml sv ja ml ru zh ru sv en en en en en en en en en en en en en uk en en en uk hy en en en en en en en en en en en en uk en en en en id ml ml ml en en en ml ceb en en en en ml ml en en en ml ceb en ml en en ml ml en en en ml ml ml en ml en en en en en fr ml en en en fr ml en en en en fr ml en en en en fr en en fr en en zh zh fr ja en en en hbs_lat en en en ml hbs_lat en en en ia en en en en en en en en en ceb en en en ml en ml ml ml ml ml ml en ml en fr en fr en hbs_lat fr en fr en ml ml ml ml en en en ml ml ml en zh en ru en en en en en ml en en en en fr en en en en ml en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml fr fr en fr zh ml ml ml ml ml ml en en en en en en ml ml en en ml ml ml fr en en en ru ml en ml ml ml en ml en ca en en en en en en en en en en en en en en fa en en fa en en en en ml ml en ml ml en ml ml ml ml ml en ml ml ml ml ml en fr fr ml ml ml ml ml en en en en en en en en en en en ml ml ml ml ml ml ml ml ml en ml ml ml ml ml ml ml ml en en en ml ml ml ml ml ml ml en ml ml ml ml ml ml en ml ml ml ml ml ml en ml en en en en ca en en ml ml en en ml ml en en ca en ml ml ml ml ml en en en en en en en en en en en sl en en en en en en en en en ml ml en es en ca az en ca en nb en en ml en ml ml ml ml ml en en en en en en en en en en ml ml ml ml en ml en ml en en en en pt en en ml ml ml ml ml en ml en ml fr ml fr ml ml ml ml ml fr en fr en fr en ml fr en fr en fr en en en en en en en en en en en en en en en nb en ja en ar es ko en en en es en en en en en en en en en en en en en en en en en en en en ml ml ml en ml en ml en en it en en en en en en en en min en en en ml ml ml ml ml ml ml en ml ml ml ml ml ml ml ml en ml ml ml en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en en en en en en en en en en en en en en en en en ar ja ko en en en en en es en es en en en en en en en en en en en ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml ml en en ml ml ml ml ml ml ml ml ml ml en ml ml ml en ml ml ml ml ml ml en en ml en en en en ml ml ml ml ml ml en ru en en en la he en ru ru en en es pl en pt ml ml ml ml en en en en en en en en en ml ml ml ml de ro ml ml ml en en ml sv en en ml ml ml ml ml en ml ml ml ml ml ml ml ml ml ml ml ml ml ml en en en en en fr ml en ceb ca en ca ceb pt ca en ca ceb pt ca en ca en pt ca en ca en pt ca en ca en pt ca pt ca en pt ca pt ca en en en en en ml ml ml ml ml ml ml ml ml ml ml en ml ml en ml ml ml ml ml en ml ml ml en en en ml ml en en en en ml ml ml ml ml en ml en ml ml ml ml en ml en ml ml ml ml ml ml ml ml en en en en en en en ml ml ml ml ml ml ml en en en en en en en en en la en ml ml ml ml ml en en en en en ml en en en en en en en ml en en en en fa en en zh en en en ml en ml en ml ml en en en ml ml en ml ml ml en en en en en de en en de de en en en en en en ml ceb
പൈത്തണ്‍ പാഠങ്ങള്‍: പൈത്തണ്‍ : പാഠം എട്ട്
skip to main | skip to sidebar
പാഠങ്ങൾ ഒന്ന് മുതൽ മൂന്നു വരെ
പൈത്തണിന്റെ ലോകത്തേക്ക് വായനക്കാര്‍ക്ക് സുസ്വാഗതം. പൈത്തണ്‍ എന്ന പ്രോഗ്രാമിങ്ങ് ലാങ്ഗ്വേജ് പഠിപ്പിക്കാനുള്ള ശ്രമമാണിവിടെ. ആരംഭം മുതലുള്ള പോസ്റ്റുകളുടെ ലിങ്കുകള്‍ ഇടതു വശത്തു കാണാം. ആര്‍ക്കും പഠിക്കാം. ആര്‍ക്കും സംശയങ്ങള്‍ ചോദിക്കാം. വിലക്കുകളോ മോഡറേഷനുകളോ ഇല്ല.
പൈത്തണ്‍ പാഠങ്ങളില്‍ ഇതുവരെ ചരങ്ങള്‍ (variables), if .. else , for , while എന്നിവയെപ്പറ്റി പഠിച്ചല്ലോ. ഈ പാഠത്തില്‍ നമുക്ക് പൈത്തണിലെ ഏകദങ്ങളെ (functions) പരിചയപ്പെടാം. "ഏകദം" എന്ന സംസ്കൃത വാക്കിന്റെ അര്‍ത്ഥം "ഒന്നിനെ (ഒരു കാര്യത്തെ) തരുന്നത്" എന്നാണ്. പൈത്തണിലെ ഏകദങ്ങളും "ഒരു കാര്യത്തെ തരുന്ന"വയാണ്. ഇത് എങ്ങനെയാണെന്ന് വഴിയേ മനസ്സിലാകും. പൈത്തണിലെ function എന്നതിന് "ഏകദം" എന്ന് മൊഴിമാറ്റം ചെയ്യാനുള്ള കാരണം ഇതാണ്. പൈത്തണിലെ ഏകദങ്ങള്‍ എന്താണെന്നും നമുക്ക് ആവശ്യമുള്ള ഏകദങ്ങളെ സ്വന്തമായി എങ്ങനെ എഴുതാം എന്നും ഈ പാഠത്തില്‍ മനസ്സിലാക്കാം.
പൈത്തണില്‍ സ്വതവേ ലഭ്യമായ (built-in) കുറച്ച് ഏകദങ്ങളെ നാം ഇതുവരെയുള്ള പാഠങ്ങളില്‍ ഉപയോഗിച്ചുകണ്ടു. range എന്ന ഏകദം ഒരു എണ്ണല്‍സംഖ്യയെ സ്വീകരിച്ച് പൂജ്യം മുതല്‍ ആ സംഖ്യയ്ക്ക് മുമ്പുവരെയുള്ള എണ്ണല്‍സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് തിരിച്ചുതരുന്നു.
ഏകദം സ്വീകരിക്കുന്ന വിലകളെ ഏകദത്തിന്റെ "വാക്യങ്ങള്‍" (arguments) എന്ന് വിളിക്കുന്നു [1]. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണത്തില്‍ 15 എന്ന സംഖ്യയാണ് range എന്ന ഏകദത്തിന്റെ വാക്യം. രണ്ടാമത്തെ ഉദാഹരണത്തില്‍ range -ന്റെ വാക്യം 10 എന്ന സംഖ്യയാണ്; മൂന്നാമത്തെ ഉദാഹരണത്തില്‍ ഇത് 5, 30 എന്നീ രണ്ടു സംഖ്യകളും, അവസാനത്തെ ഉദാഹരണത്തില്‍ 5, 30, 3 എന്നീ മൂന്നു സംഖ്യകളുമാണ്.
ഇവിടെ ആദ്യത്തെ തവണ len -ന്റെ വാക്യം [1, 2, 'a', 3, 'b', 'c', 4] എന്ന ലിസ്റ്റാണ്, രണ്ടാമത്തെ തവണ "Thiruvananthapuram" എന്ന സ്ട്രിംഗും.
ഒരു ഏകദത്തെ നമ്മുടെ പ്രോഗ്രാമില്‍ പ്രയോഗിക്കാന്‍ (invoke അല്ലെങ്കില്‍ call എന്ന് ഇംഗ്ലീഷില്‍) ചെയ്യേണ്ടത് ആ ഏകദത്തിന്റെ പേരും, തുടര്‍ന്ന് '(', ')' എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കിടയിലായി ഏകദത്തിന് കൊടുക്കേണ്ടതായ വാക്യവും എഴുതുക എന്നതാണ്. അതായത് function_name(argument) എന്ന് പ്രോഗ്രാമില്‍ എഴുതുക. മുകളിലെ ഉദാഹരണങ്ങളിലും ഇങ്ങനെയാണല്ലോ ചെയ്തിട്ടുള്ളത്? പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുമ്പോള്‍ function_name(argument) എന്ന് കാണുന്നയിടത്ത് ഏകദം അതിന് കൊടുത്തിരിക്കുന്ന വാക്യത്തിനുമേല്‍ പ്രവര്‍ത്തിച്ചാല്‍ കിട്ടുന്ന മൂല്യം പകരമായി വരും. ഇത് കുറച്ചുകൂടെ വ്യക്തമാകാന്‍ ഇനിയുള്ള ഉദാഹരണം നോക്കുക:
ഈ ഉദാഹരണത്തില്‍ പ്രത്യേകം ശ്രദ്ധിക്കേണ്ടതായ കാര്യങ്ങള്‍:
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 (a, b) എന്നതില്‍ a , b എന്നിവയ്ക്ക് പകരം സംഖ്യകള്‍ കൊടുത്ത് നമുക്കിത് പരീക്ഷിക്കാം. താഴെക്കാണുന്ന ചിത്രം നോക്കുക (ചിത്രം വ്യക്തമായി കാണാന്‍ അതില്‍ അമര്‍ത്തുക).
നാം നിര്‍‌വചിച്ച add എന്ന ഏകദം കൃത്യം രണ്ട് വാക്യങ്ങളേ സ്വീകരിക്കൂ എന്ന് ചിത്രത്തിലെ അവസാനത്തെ രണ്ട് സന്ദേശങ്ങളില്‍നിന്ന് മനസ്സിലാക്കാം.
IDLE-നെ കൂടാതെ പൈത്തണ്‍ ഷെല്‍ വഴിയായും (വേണമെങ്കില്‍) ഈ ഏകദം പ്രയോഗിച്ചുനോക്കാന്‍ കഴിയും. ഇതിനായി ടെര്‍മിനല്‍ തുറന്ന് add.py എന്ന ഫയല്‍ സേവ് ചെയ്ത ഡയറക്ടറിയിലേക്ക് മാറുക. അവിടെ python -i add.py എന്ന കമാന്റ് കൊടുക്കുക. ഇനി വരുന്ന ഷെല്ലില്‍ നാമെഴുതിയ add എന്ന ഏകദം ലഭ്യമാണ് :
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 എന്ന് വിളിക്കാം. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരും.
മുകളില്‍ കൊടുത്ത ഏകദം വായിച്ചു മനസ്സിലാക്കുക. ഇത് എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.
ഈ പ്രോഗ്രാം larger.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് (larger.py എന്നതിനു പകരം നിങ്ങള്‍ക്ക് ഇഷ്ടമുള്ള .py എന്ന് അവസാനിക്കുന്ന പേരുകൊടുക്കാം) IDLE-ല്‍ (അല്ലെങ്കില്‍ ഷെല്ലില്‍) ലഭ്യമാക്കുക. larger എന്ന ഏകദത്തിന് പല ജോടി സംഖ്യകള്‍ വാക്യങ്ങളായി കൊടുത്ത് അത് ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക.
രണ്ട് സംഖ്യകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ ചെറുതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഈ ഏകദത്തിന് smaller എന്ന് പേരുകൊടുക്കുക. തന്നിരിക്കുന്ന രണ്ടു സംഖ്യകളും ഒന്നുതന്നെയാണെങ്കില്‍ ഏകദം ആ സംഖ്യയെത്തന്നെ തിരിച്ചുതരണം. ഈ പ്രോഗ്രാം smaller.py എന്ന ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE‍ (അല്ലെങ്കില്‍ ഷെല്‍) വഴിയായി അതിന്റെ പ്രവര്‍ത്തനം പരീക്ഷിച്ചുനോക്കുക.
ഇനി നമുക്ക് രണ്ട് സ്ട്രിംഗുകള്‍ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ കൂടുതല്‍ നീളമുള്ളതിനെ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. രണ്ട് സ്ട്രിംഗുകള്‍ക്കും ഒരേ നീളമാണെങ്കില്‍ ഏകദം ആദ്യത്തെ സ്ട്രിംഗിനെ തിരിച്ചുതരും. ഈ ഏകദത്തിന് നമുക്ക് longer എന്ന് പേരിടാം. ഈ ഏകദത്തിന് larger എന്ന ഏകദത്തിനോടുള്ള സാമ്യം ശ്രദ്ധിക്കുക. longer എന്ന ഏകദമുപയോഗിച്ച് എഴുതിയാല്‍ ഇങ്ങനെയാകും: longer എന്ന ഏകദത്തിന്റെ നിര്‍വചനം ഇങ്ങനെ ഉപയോഗിക്കുന്നതിന് മുമ്പായി (8 മുതല്‍ 12 വരെയുള്ള വരികളിലായി) എഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒരു ഏകദം ഉപയോഗിക്കുന്നതിന് മുമ്പ് അതിന്റെ നിര്‍വചനം എഴുതിയിരിക്കണം. ഇത് മറ്റൊരു ഫയലില്‍ എഴുതാനുള്ള സംവിധാനവുമുണ്ട്. അതായത്, ഏകദത്തിന്റെ നിര്‍വചനം ഒരു ഫയലിലും, അതിന്റെ പ്രയോഗം വേറൊരു ഫയലിലും വേണമെങ്കില്‍ ആകാം. ഇത് എങ്ങനെയാണ് ചെയ്യേണ്ടതെന്ന് വഴിയേ കാണാം. ഈ പാഠത്തില്‍ നമുക്ക് ഏകദത്തിന്റെ നിര്‍വചനവും അത് പ്രയോഗിക്കുന്ന പ്രോഗ്രാമും ഒരേ ഫയലില്‍ത്തന്നെ എഴുതാം.
ഈ പ്രോഗ്രാം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലാക്കുക. ഇതില്‍ longer എന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് (27-ആം വരിയില്‍ )എങ്ങനെയാണെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക.
ഇനി സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതാം. ഇതിന് largest എന്ന് പേരിടാം. ഈ ഏകദത്തിന് മുകളിലത്തെ പ്രോഗ്രാമുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക. largest എന്ന ഏകദത്തില്‍ larger എന്ന ഏകദം ഉപയോഗിച്ചിരിക്കുന്നത് കാണുക. ഇങ്ങനെ ഉപയോഗിക്കുവാന്‍‌വേണ്ടി, largest എന്ന ഏകദത്തിന് മുമ്പായി larger എന്ന ഏകദത്തിന്റെ നിര്‍വചനം എടുത്തെഴുതിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഈ പാഠത്തിലുടനീളം ഇങ്ങനെയാവും നാം പ്രോഗ്രാമുകളെഴുതുക. largest എന്ന ഏകദം ലഭ്യമാണ്. സംഖ്യകളുടെ പല ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്ത് ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ട് എന്ന് ഉറപ്പുവരുത്തുക. ഉദാഹരണങ്ങള്‍ക്കായി ചിത്രം കാണുക(ചിത്രം വ്യക്തമായി കാണാന്‍ അതില്‍ അമര്‍ത്തുക).
സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച് ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യ തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഇതിന് smallest എന്ന് പേരിടുക. ഈ ഏകദം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് ഫയല്‍ IDLE-ലോ ഷെല്ലിലോ പ്രവര്‍ത്തിപ്പിക്കുക. ഇനി ഈ ഏകദത്തിന് താഴെക്കൊടുത്തിരിക്കുന്ന ലിസ്റ്റുകള്‍ വാക്യങ്ങളായി കൊടുത്തുനോക്കുക. ഉത്തരം ശരിയാകുന്നുണ്ടോ?
[1, 1, 1, 1, 0]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
ഒരു കൂട്ടം സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത് അവയെ അവരോഹണക്രമത്തില്‍ (ഏറ്റവും വലുത് ആദ്യം വരുന്ന ക്രമത്തില്‍ --- ഇംഗ്ളീഷില്‍ descending order) ക്രമപ്പെടുത്തുന്ന ഒരു പ്രോഗ്രാം ഇനി നമുക്ക് എഴുതാം. ഇതിന് നാം എഴുതിയ largest എന്ന ഏകദം ചെറിയ മാറ്റങ്ങളോടെ ഉപയോഗിക്കാം.
ഇങ്ങനെയോ മറിച്ചുള്ള (ആരോഹണ) ക്രമത്തിലോ സംഖ്യകളെ (മറ്റ് വിവരങ്ങളേയും) അടുക്കുന്നതിന് ക്രമീകരണം (Sorting) എന്നു പറയുന്നു. ഇത് കംപ്യൂട്ടര്‍ പ്രോഗ്രാമുകളില്‍ (അല്ലാതെയും) വളരെയധികം ആവശ്യമുള്ള ഒരു പ്രവര്‍ത്തനമാണ്. ക്രമീകരിച്ച വിവരങ്ങളില്‍ പരതാനും മറ്റും വളരെ എളുപ്പമാണ്: നൂറുകണക്കിന് പേജുകളിലായി പതിനായിരക്കണക്കിന് വാക്കുകളുടെ അര്‍ത്ഥങ്ങള്‍ കൊടുത്തിരിക്കുന്ന ഒരു നിഘണ്ടുവില്‍ നമുക്ക് ആവശ്യമുള്ള വാക്കിന്റെ അര്‍ത്ഥം കണ്ടുപിടിക്കാന്‍ എത്ര എളുപ്പമാണ് എന്നത് ഓര്‍ക്കുക. അതുപോലെ, ആയിരക്കണക്കിന് ആളുകളുടെ പേരും ഫോണ്‍ നമ്പരും കൊടുത്തിട്ടുള്ള ഫോണ്‍ ഡയറക്ടറിയില്‍ നിന്ന് ഒരാളുടെ ഫോണ്‍ നമ്പര്‍ കണ്ടുപിടിക്കാന്‍ കുറച്ചു സമയമല്ലേ വേണ്ടൂ? നിഘണ്ടുവിലെ വാക്കുകളും ഫോണ്‍ ഡയറക്ടറിയിലെ പേരുകളും (അക്ഷരമാലാ ക്രമത്തില്‍) ക്രമീകരിച്ചിരിക്കുന്നതുകൊണ്ടാണ് ഇത് സാധ്യമാകുന്നത്. ക്രമീകരണത്തിനായി പലതരം അ‍ല്‍ഗോരിതങ്ങള്‍ (പ്രവര്‍ത്തനരീതികള്‍) ലഭ്യമാണ്. ഇവയില്‍ ലളിതമായ ഒരു രീതി നമുക്ക് ഈ പാഠത്തില്‍ പ്രോഗ്രാമായി എഴുതാം. ഈ രീതിയുടെ പേര് "തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം" (Selection sort) എന്നാണ്. ഇതിന്റെ ആശയം മനസ്സിലാക്കാന്‍ വളരെ എളുപ്പമാണ്. ഈ രീതിയുടെ പ്രവര്‍ത്തനം ഇങ്ങനെയാണ്:
ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍, അഥവാ ലിസ്റ്റില്‍ ഒരേ ഒരു അംഗം (സംഖ്യ) മാത്രമേയുള്ളൂ എങ്കില്‍ ലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ഇങ്ങനെയാണെങ്കില്‍ തന്നിരിക്കുന്ന ലിസ്റ്റിനെത്തന്നെ ഉത്തരമായി തിരിച്ചുകൊടുക്കുക. ഇങ്ങനെ അല്ലെങ്കില്‍ (ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍):
ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതെന്ന് കണ്ടുപിടിക്കുക. ഇത് a എന്ന സംഖ്യ ആണെന്നിരിക്കട്ടെ :
a എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരിക. ഇതിനായി a-യും ലിസ്റ്റിലെ ആദ്യത്തെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറുക. ഇപ്പോള്‍ ലിസ്റ്റിന്റെ ആദ്യത്തെ സ്ഥാനത്ത് ശരിയായ സംഖ്യയാണ് — അതായത്, ക്രമീകരിച്ച ലിസ്റ്റില്‍ ആദ്യം വരേണ്ടതായ സംഖ്യ തന്നെയാണ് — ഉള്ളത്.
ഇനി ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഭാഗം — അതായത്, രണ്ടാമത്തേത് മുതലുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" — ഇതേ രീതിയില്‍ ക്രമീകരിക്കുക.
ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ അതിലെ ഏറ്റവും വലിയ സംഖ്യയാണ്. ലിസ്റ്റിന്റെ രണ്ടാമതു മുതല്‍ അവസാനത്തതു വരെയുള്ള അംഗങ്ങള്‍ ഉള്‍പ്പെടുന്ന "ഉപലിസ്റ്റ്" ക്രമത്തിലുമാണ്. അതായത്, ലിസ്റ്റ് ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു.
ഈ രീതി പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് മനസ്സിലാക്കാന്‍ ഇങ്ങനെ ക്രമീകരിക്കുന്നതിന്റെ ഒരു ഉദാഹരണം നമുക്ക് കാണാം.
ഈ ലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങള്‍ ഉള്ളതുകൊണ്ട് രീതിയുടെ പടി 1 ബാധകമല്ല. അതുകൊണ്ട് നാം പടി 2 പ്രകാരം ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടുപിടിക്കുന്നു. ഇത് 23 ആണ്.
ഇനി പടി (2.i)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ 23 എന്ന സംഖ്യ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരുന്നു.
ഇപ്പോള്‍ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യയാണ് ഉള്ളത്. അതായത് ലിസ്റ്റിന്റെ തുടക്കം "ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞു". ഇനി ലിസ്റ്റിന്റെ രണ്ടാമത്തേത് മുതലുള്ള ഭാഗം ക്രമീകരിച്ചാല്‍ മതി. ഇത് സൂചിപ്പിക്കാനായി ലിസ്റ്റിലെ ആദ്യത്തെ അംഗത്തിന് — ഇപ്പോള്‍ ക്രമീകരിക്കപ്പെട്ടുകഴിഞ്ഞ ഭാഗത്തിന് — ചാര നിറം കൊടുത്ത് ചിത്രത്തില്‍ കാണിച്ചിരിക്കുന്നു.
ഇനി പടി (2.ii)-ല്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗം ഇതേ രീതിയില്‍ ക്രമീകരിക്കണം. ഇതിനായി നാം ഈ പ്രവര്‍ത്തനരീതി തുടക്കം മുതല്‍ [15, 1, 7] എന്ന ലിസ്റ്റിന്റെമേല്‍ പ്രയോഗിക്കണം. ഈ ലിസ്റ്റിലും ഒന്നിലധികം അംഗങ്ങളുള്ളതുകൊണ്ട് രീതിയുടെ ഒന്നാം പടി ഇവിടെ ബാധകമല്ല. അതുകൊണ്ട് നാം പടി 2 പ്രകാരം ഈ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടുപിടിക്കുന്നു. ഇത് 15 ആണ്.
ഇനി ഇതേ രീതിയില്‍ [1, 7] എന്ന ലിസ്റ്റ് ക്രമീകരിക്കുന്നു.
ഇപ്പോള്‍ ക്രമീകരിക്കാനായി ബാക്കിയുള്ള ലിസ്റ്റില്‍ ഒരേ ഒരംഗം മാത്രമേയുള്ളൂ. ഈ ഏകാംഗ ലിസ്റ്റിനെ നമ്മുടെ രീതിയില്‍ ക്രമീകരിക്കാന്‍ ശ്രമിക്കുമ്പോള്‍ രീതിയുടെ ഒന്നാം പടി ബാധകമാകുന്നു: ഈ ഏകാംഗ ലിസ്റ്റ് സ്വതവേതന്നെ ക്രമീകരിക്കപ്പെട്ടതാണ്. ഇപ്പോള്‍ നമ്മുടെ ലിസ്റ്റ് പൂര്‍ണ്ണമായും ക്രമീകരിച്ചുകഴിഞ്ഞു.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് മനസ്സിലായെന്ന് ഉറപ്പുവരുത്താന്‍ [35, 2, 3, 56, 5, 7, 9] എന്ന ലിസ്റ്റിന്റെ കടലാസും പേനയുമുപയോഗിച്ച് ഈ രീതിയില്‍ അവരോഹണക്രമത്തില്‍ — ഏറ്റവും വലിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില്‍ — ക്രമീകരിക്കുക.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം നടപ്പിലാക്കുന്ന ഒരു പൈത്തണ്‍ ഏകദം എഴുതുക എന്നതാണ് ഈ പാഠത്തില്‍ ഇനി നാം ചെയ്യാന്‍ പോകുന്നത്. അതിനുമുമ്പ് ഈ രീതി പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് നന്നായി മനസ്സിലാക്കണം. ഈ രീതിയുടെ ഒന്നാമത്തെ പടി ശരിയാണെന്ന് നിസ്സംശയം പറയാമല്ലോ? ഒരേ ഒരംഗം മാത്രമുള്ള ലിസ്റ്റ് തീര്‍ച്ചയായും ക്രമീകരിക്കപ്പെട്ടതുതന്നെയാണ്.
ഈ രീതിയുടെ കാതലായ ഭാഗം അതിന്റെ രണ്ടാമത്തെ പടിയാണ്. ഇവിടെ ലിസ്റ്റിലെ ഏറ്റവും വലിയ അംഗത്തിനെ കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ക്രമീകരിക്കപ്പെട്ട ലിസ്റ്റില്‍ ഈ അംഗം ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ത്തന്നെയാണല്ലോ വരേണ്ടത്? അപ്പോള്‍ ഇങ്ങനെ ചെയ്യുന്നതുവഴി നാം ഉത്തരത്തിലേക്ക് ഒരു ചെറിയ പടി മുന്നേറുന്നു.ഇനി ബാക്കിയുള്ള ലിസ്റ്റ് ക്രമീകരിച്ചാല്‍ മാത്രം മതി. ഇതിന് ഇതേ രീതി ആ ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിച്ചാല്‍ മതിയെന്ന് പറയുന്നത് ബോധ്യപ്പെട്ടോ? "ഇതേ രീതി" ആ (ഉപ)ലിസ്റ്റിന്‍മേല്‍ പ്രയോഗിക്കുമ്പോള്‍ എന്താണ് സംഭവിക്കുന്നതെന്ന് ആലോചിച്ചുനോക്കൂ.
ഉപലിസ്റ്റില്‍ ഒരംഗമേയുള്ളൂവെങ്കില്‍ ഉപലിസ്റ്റ് ക്രമത്തില്‍ത്തന്നെയാണ്. ( കൂടാതെ ഈ സംഖ്യ മൊത്തം ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയുമാണ് — ഇതെന്തുകൊണ്ടാണെന്ന് ആലോചിച്ചുനോക്കൂ.) അപ്പോള്‍ ലിസ്റ്റ് മുഴുവനായും ക്രമത്തില്‍ ആയിക്കഴിഞ്ഞു.
ഉപലിസ്റ്റില്‍ ഒന്നിലധികം അംഗങ്ങളുണ്ടെങ്കില്‍ നമ്മുടെ പ്രവര്‍ത്തനരീതി അതില്‍ ഏറ്റവും വലിയ സംഖ്യയെ കണ്ടുപിടിച്ച് ഉപലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവയ്ക്കുന്നു. ഇത് ശരിയായ നടപടി തന്നെയല്ലേ? ഇനി ഈ ഉപലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ലിസ്റ്റിനെ ("ഉപൗപ" ലിസ്റ്റിനെ) ക്രമീകരിച്ചാല്‍ മൊത്തം ലിസ്റ്റും ക്രമത്തിലാകും. നമ്മുടെ രീതിയും ഇതുതന്നെയാണ് ചെയ്യുന്നത്.
ചുരുക്കത്തില്‍ പറഞ്ഞാല്‍, "ക്രമീകരിക്കേണ്ട ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ ഏതാണെന്ന് കണ്ടുപിടിച്ച് അതിനെ ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവന്ന് വയ്ക്കുക. ഇനി ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗത്തിനേയും ഇതേ രീതിയില്‍ കൈകാര്യം ചെയ്യുക." എന്നതാണ് തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തില്‍ ചെയ്യുന്നത്.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ ആശയം — പ്രത്യേകിച്ച്, "ലിസ്റ്റിന്റെ ബാക്കിയുള്ള ഭാഗത്തിനെ ഇതേ രീതിയില്‍ കൈകാര്യം ചെയ്യുക" എന്നുള്ളത് — ശരിയാണെന്ന് വ്യക്തമായി ബോധ്യപ്പെട്ടാലേ ഈ പാഠത്തിന്റെ ബാക്കിയുള്ള ഭാഗം നന്നായി മനസ്സിലാകൂ. അതുകൊണ്ട് ഈ രീതിയുടെ വിവരണവും വിശദീകരണവും പല പ്രാവശ്യം വായിക്കുക. തന്നിരിക്കുന്ന ഉദാഹരണം പ്രവര്‍ത്തിക്കുന്നത് ഇതേപോലെയാണെന്ന് ഉറപ്പുവരുത്തുക. പ്രവര്‍ത്തനം 6 ചെയ്തുനോക്കി അതും മുകളില്‍ പറഞ്ഞതും തമ്മില്‍ പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് നോക്കുക.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 1
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണത്തിന്റെ ആശയം മനസ്സിലായല്ലോ? ഇനി നമുക്ക് ഈ ആശയം പൈത്തണുപയോഗിച്ച് പ്രാവര്‍ത്തികമാക്കുന്ന ഒരു പ്രോഗ്രാമെഴുതാം, പല ഘട്ടങ്ങളായി.
ഒന്നാമതായി നമുക്ക് ഈ പ്രവര്‍ത്തനരീതിയുടെ പടി 2.ii-ന് ആവശ്യമുള്ള ഒരു കാര്യം ചെയ്യുന്നത് എങ്ങനെയാണെന്ന് നോക്കാം. രണ്ടോ അതിലധികമോ അംഗങ്ങളുള്ള ഒരു ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ഉപലിസ്റ്റ് എടുക്കുന്നതെങ്ങനെ എന്നതാണ് ഇത്. ഇങ്ങനെയുള്ള ഉപലിസ്റ്റിനെയാണല്ലോ പടി 2.ii പ്രകാരം "ഇതേ രീതിയില്‍" ക്രമീകരിക്കേണ്ടത്?
ഇങ്ങനെയുള്ള ഒരു ഉപലിസ്റ്റ് എടുക്കല്‍ വളരെ എളുപ്പമുള്ള കാര്യമാണ്: myList ഒരു ലിസ്റ്റാണെന്നിരിക്കട്ടെ. ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗത്തിന്റെ സ്ഥാനം (index) പൂജ്യം ആണല്ലോ. ലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗത്തിന്റെ സ്ഥാനം 1 ആണ്. ഈ ലിസ്റ്റിന്റെ രണ്ടുമുതലുള്ള അംഗങ്ങള്‍ മാത്രമുള്ള ഒരു ഉപലിസ്റ്റ് കിട്ടാന്‍ myList[1:] എന്ന് പറഞ്ഞാല്‍ മതി. ഇവിടെ 1: എന്നതിനെ "ഒന്നുമുതല്‍" എന്ന് വായിക്കാം. ലിസ്റ്റിലെ സ്ഥാനങ്ങള്‍ പൂജ്യം മുതല്‍ എണ്ണിത്തുടങ്ങുന്നതുകൊണ്ട്, സ്ഥാനം ഒന്നുമുതല്‍ എന്ന് പറയുമ്പോള്‍ രണ്ടാമത്തെ അംഗം മുതല്‍ എന്നാണല്ലോ അര്‍ത്ഥം. ഈ രീതിയില്‍ ഉപലിസ്റ്റ് എടുക്കുന്ന രീതി വ്യക്തമാക്കുന്ന ചില ഉദാഹരണങ്ങള്‍ ഇതാ:
നമുക്ക് ഒന്നുമുതലല്ലാതെ "പൂജ്യം മുതല്‍" എണ്ണി പരിചയമില്ലാത്തതുകൊണ്ട് ലിസ്റ്റിന്റെ കാര്യത്തില്‍ ഇങ്ങനെ ചെയ്യേണ്ടിവരുമ്പോള്‍ കുറച്ച് അപരിചിതത്വം തോന്നും. ഇത് അല്‍പകാലത്തെ പരിചയം കൊണ്ട് മാറിക്കൊള്ളും.
തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം, പൈത്തണില്‍ : ഭാഗം 2
ലിസ്റ്റിലെ വലിയ സംഖ്യ കണ്ടുപിടിച്ചുകഴിഞ്ഞാല്‍ (പടി 2) അത് ലിസ്റ്റിന്റെ തുടക്കത്തില്‍ കൊണ്ടുവരണമല്ലോ. ഇതിനായി വലിയ സംഖ്യയും ലിസ്റ്റിന്റെ തുടക്കത്തിലെ സംഖ്യയും തമ്മില്‍ വച്ചുമാറണം (പടി 2.i). ഇത് ചെയ്യാനായി വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയാണ് എന്നറിയണം. സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിച്ച് അതില്‍ ഏറ്റവും വലുത് കണ്ടുപിടിച്ചുതരുന്ന ഒരു ഏകദം ( largest ) നാം എഴുതിയല്ലോ. ഈ ഏകദം പക്ഷേ വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയായിരുന്നു എന്ന് പറഞ്ഞുതരുന്നില്ല. ഇനി ഈ ഏകദത്തില്‍ ‍ചെറിയ മാറ്റം വരുത്തി‍, ഏറ്റവും വലിയ സംഖ്യ ലിസ്റ്റില്‍ എവിടെയാണ് എന്നതുകൂടി തിരിച്ചുതരുന്ന ഒരു ഏകദം നമുക്കെഴുതാം. ഈ ഏകദത്തിനെ നമുക്ക് largest2 എന്ന് വിളിക്കാം.
largest എന്ന ഏകദത്തിനുള്ളില്‍ larger എന്ന ഏകദം ഉപയോഗിച്ചല്ലോ? രണ്ട് സംഖ്യകള്‍ സ്വീകരിച്ച് അവയില്‍ വലുതിനെ തിരിച്ചുതരിക എന്നതാണ് ഈ ഏകദം ചെയ്യുന്നത്. largest2 എന്ന ഏകദത്തില്‍ പ്രയോഗിക്കാനായി larger -ല്‍ ചെറിയൊരു മാറ്റം വേണം. മുമ്പത്തേതുപോലെ, ഈ ഏകദം രണ്ട് സംഖ്യകളെ വാക്യങ്ങളായി സ്വീകരിച്ച് അവയില്‍ വലുത് ഏതാണെന്ന് പറയണം. ഇതു കൂടാതെ ഒരു കാര്യം കൂടി നമുക്ക് അറിയണം : ഏകദത്തിന് വാക്യങ്ങളായി കൊടുത്ത രണ്ട് സംഖ്യകളില്‍ രണ്ടാമത്തേതാണോ വലിയത് എന്ന കാര്യമാണ് അറിയേണ്ടത്. (ഇതറിയുന്നത് എന്തിനാണെന്ന് വഴിയേ മനസ്സിലാകും.) ഈ മാറ്റങ്ങളോടുകൂടിയ larger -നെ നമുക്ക് larger2 എന്ന് വിളിക്കാം. larger2 നമുക്ക് തിരിച്ചുതരുന്നത് രണ്ടംഗങ്ങളുള്ള ഒരു ലിസ്റ്റാണ്. ഈ ലിസ്റ്റില്‍ ആദ്യത്തെ അംഗം ഈ ഏകദത്തിന്റെ വാക്യങ്ങളി‌ലെ വലിയ സംഖ്യയാണ്. രണ്ടാമത്തെ അംഗം ഒരു ബൂളിയന്‍ മൂല്യം (ശരി അല്ലെങ്കില്‍ തെറ്റ്) ആണ്. രണ്ടു വാക്യങ്ങളില്‍ രണ്ടാമത്തേതാണ് വലുതെങ്കില്‍ ഈ മൂല്യം True ആണ്. അല്ലെങ്കില്‍ False -ഉം. larger2 നമുക്ക് ഇങ്ങനെയെഴുതാം:
പലപല സംഖ്യാജോടികള്‍ വാക്യങ്ങളായി കൊടുത്ത് 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-ലോ ഷെല്ലിലോ പലതവണ (പല സംഖ്യാ ലിസ്റ്റുക‍ളെ വാക്യങ്ങളായി കൊടുത്ത്) പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. പറഞ്ഞതുപോലെയൊക്കെ സംഭവിക്കുന്നുണ്ടോ?
പ്രോഗ്രാം എങ്ങനെയാണ് ഇക്കാര്യങ്ങളൊക്കെ ചെയ്യുന്നതെന്ന് ആലോചിക്കുക. ഒരുപക്ഷേ ഇതിന്റെ പ്രവര്‍ത്തനം അതിശയകരമാണെന്ന് തോന്നിയേക്കാം. ഇതില്‍ അതിശയകരമായി അത്രയ്ക്കൊന്നുമില്ല. ഈ പ്രോഗ്രാമും അതിന്റെ വിശദീകരണവും കുറച്ചുപ്രാവശ്യം ശ്രദ്ധിച്ച് വായിക്കുക. മനസ്സിലാകാത്ത കാര്യങ്ങള്‍ ചോദിക്കുക. ഇതേരീതിയിലുള്ള പല ഉദാഹരണങ്ങള്‍ കാണുമ്പോള്‍ ഈ രീതിയില്‍ ചിന്തിക്കാന്‍ നിങ്ങളും പഠിക്കും.
സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച്, ലിസ്റ്റിലെ ഏറ്റവും ചെറിയ സംഖ്യയും അതിന്റെ ലിസ്റ്റിലെ സ്ഥാനവും തിരിച്ചുതരുന്ന ഒരു ഏകദം എഴുതുക. ഏകദത്തിന് 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 എന്ന ലിസ്റ്റിന്റെ രണ്ടാമത്തെ അംഗം മുതലുള്ള ഉപലിസ്റ്റായി — വയ്ക്കുക.
ഇതോടെ ലിസ്റ്റ് അവരോഹണ ക്രമത്തില്‍ ആകുന്നു. ഇങ്ങനെ ക്രമീകരിച്ച ലിസ്റ്റിനെ തിരിച്ചുകൊടുക്കുന്നതോടെ ഏകദത്തിന്റെ പ്രവര്‍ത്തനം പൂര്‍ത്തിയാകുന്നു (വരി 65).
selection_sort എന്ന ഏകദം ശരിയായി പ്രവര്‍ത്തിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കാന്‍ ഈ പ്രോഗ്രാം ഒരു ഫയലില്‍ സേവ് ചെയ്ത് IDLE-ലോ ഷെല്ലിലോ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാം. ഷെല്ലില്‍ പ്രവര്‍ത്തിപ്പിച്ചതിന്റെ ഉദാഹരണം ഇതാ (selectionsort.py എന്ന ഫയലിലാണ് സേവ് ചെയ്തത്). അവരോഹണക്രമത്തിലാണ് (വലിയ സംഖ്യകള്‍ ആദ്യം വരുന്ന ക്രമത്തില്‍) നമ്മുടെ പ്രോഗ്രാം ലിസ്റ്റിനെ ക്രമീകരിക്കുന്നതെന്ന് ഓര്‍ക്കുക :
സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് വാക്യമായി സ്വീകരിച്ച്, ലിസ്റ്റിനെ ആരോഹണക്രമത്തില്‍ (ഏറ്റവും ചെറിയ സംഖ്യ ആദ്യം വരുന്ന ക്രമത്തില്‍) തെരഞ്ഞെടുക്കല്‍ ക്രമീകരണം ഉപയോഗിച്ച് ക്രമപ്പെടുത്തുന്ന ഒരു ഏകദം എഴുതുക. ഇതിന് 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 എന്നതിന് "ഏകദത്തിന്റെ വാക്യം" എന്ന് പ്രയോഗിച്ചിരിക്കുന്നു. ↩
Labels: പാഠം എട്ട്, പൈത്തണ്‍, സാങ്കേതികം
ഫിലിപ്പ് November 8, 2011 at 12:57 PM
പാഠം ആദ്യം പ്രസിദ്ധീകരിച്ചപ്പോള്‍ ഫോര്‍മാറ്റില്‍ ചില പ്രശ്നങ്ങള്‍ വന്നു (പ്രോഗ്രാം ഒറ്റവരിയായി കാണുക, ചിത്രങ്ങള്‍ കാണാതെയിരിക്കുക തുടങ്ങി). ഇതുപോലെ ഇതിന് മുമ്പും കണ്ടിട്ടുണ്ട്, ബ്ലോഗറിന്റെ എന്തെങ്കിലും ബഗ് ആയിരിക്കാം. എന്തായാലും ഒരു തവണ കൂടി പ്രസിദ്ധീകരിച്ചപ്പോള്‍ (ഈ പോസ്റ്റ്) ഈ കുഴപ്പങ്ങളെല്ലാം മാറിയിട്ടുണ്ട്.
വി.കെ. നിസാര്‍ November 8, 2011 at 1:09 PM
ചിത്രം കാണാഞ്ഞത് ബ്ലോഗറിന്റെ ബഗ്ഗല്ല, ഞാന്‍ അത് കൊടുക്കാന്‍ വിട്ടുപോയതുകൊണ്ടാണ്. ഇപ്പോള്‍ കൊടുത്തിട്ടുണ്ട്.
ELECTA November 8, 2011 at 2:39 PM
This comment has been removed by the author.
ഫിലിപ്പ് November 8, 2011 at 4:19 PM
ഈ പാഠത്തിന്റെ പിഡിഎഫ് ഇവിടെ .
Krishnan November 8, 2011 at 4:51 PM
പാഠം നന്നായിട്ടുണ്ട്. വ്യക്തിപരമായ ചില അഭിപ്രായങ്ങള്‍ പറഞ്ഞുകൊള്ളട്ടെ:
1. functions പഠിപ്പിക്കാന്‍ കുറേക്കൂടി ഗണിതപരമായ ഉദാഹരണങ്ങള്‍ ആവാമായിരുന്നു എന്നു തോന്നി. ഉദാഹരണമായി, കൂട്ടുപലിശ, ഫിബൊണാച്ചി ശ്രേണിയിലെ നിശ്ചിതസ്ഥാനത്തെ പദം എന്നിങ്ങിനെ.
2. ഇവിടെ പരിചയപ്പെടുന്നത് പൈഥണ്‍ ഭാഷയുടെ സൗകര്യങ്ങളായതിനാല്‍, വലുതു കണ്ടുപിടിക്കാനും, ക്രമീകരിക്കാനുമെല്ലാം, max, sort തുടങ്ങിയ built-in functions ഉപയോഗിക്കുന്നതല്ലേ എളുപ്പം? ഉദാഹരണമായി, ഏറ്റവും നീളമുള്ള പേരുള്ള ജില്ല കണ്ടുപിടിക്കാനായി, ഇതില്‍ പറഞ്ഞിരിക്കുന്നതുപോലെ districts എന്ന list ഉണ്ടാക്കിക്കഴിഞ്ഞാല്‍
ഫിലിപ്പ് November 8, 2011 at 5:42 PM
"പ്രത്യേകം എടുത്തുപറയേണ്ട ഒരു കാര്യം, ഇതുപഠിക്കാന്‍ ഗണിതശാസ്ത്ര
സംബന്ധിയായ അഭിരുചിയോ താത്പര്യമോ വേണമെന്നില്ല എന്നതാണ്: "ലോജിക്കും"
സാമാന്യബുദ്ധിയും മതി; പുതിയ കാര്യങ്ങള്‍ പഠിക്കാനുള്ള താത്പര്യവും."
എന്നാണ്. എന്നാല്‍ ഇതിന് മുമ്പുവരെയുള്ള പാഠങ്ങളില്‍ ഗണിതത്തിന്റെ അളവ് കൂടിപ്പോയോ
എന്നൊരു സംശയം. ഇങ്ങനെ വരുന്നത് ഗണിതത്തില്‍ താത്പര്യമുള്ളവര്‍ക്ക് പ്രശ്നമില്ലെങ്കിലും
തോന്നിയേക്കാം. പ്രോഗ്രാമിംഗ് പഠിക്കാന്‍ ഗണിത അഭിരുചി വേണമെന്നില്ലെന്നിരിക്കേ
ഇവിടെ കൂടുതലും ഗണിതപ്രശ്നങ്ങള്‍ ഉദാഹരണങ്ങളാക്കുന്നത് അന്യായമാണെന്ന് തോന്നി.
ഫിബോനാച്ചി സംഖ്യ കണ്ടുപിടിക്കുക എന്ന പ്രശ്നത്തിനോട് ഗണിതത്തില്‍ അഭിരുചിയില്ലാത്ത
ഒരാള്‍ക്ക് ഒട്ടും താത്പര്യമുണ്ടാകുമെന്ന് തോന്നുന്നില്ല. അപ്പോള്‍ അതിനുള്ള
പ്രോഗ്രാം, പ്രത്യേകിച്ചും തുടക്കക്കാരെ സംബന്ധിച്ച് സങ്കീര്‍ണ്ണമായ
പ്രോഗ്രാം, മുഴുവന്‍ വായിച്ചുമനസ്സിലാക്കുക എന്നത് അത്ര എളുപ്പമുള്ള
കാര്യമായിരിക്കില്ല. ഇടയ്ക്കുവച്ച് പ്രചോദനം നഷ്ടപ്പെട്ടു പോകാന്‍ നല്ല
സാധ്യതയുണ്ട്. കൂട്ടുപലിശയ്ക്കുള്ള പ്രോഗ്രാമിന്റെ കാര്യവും കുറെയൊക്കെ
ഇങ്ങനെതന്നെ. ഈ പ്രോഗ്രാമുകള്‍ അടുത്ത പാഠങ്ങളിലായി പരിചയപ്പെടുത്താം.
2. പൈത്തണിലെ built-in ഏകദങ്ങള്‍ ഉപയോഗിക്കുന്നതാണ് നിശ്ചയമായും ഇക്കാര്യങ്ങള്‍
ചെയ്യാന്‍ എളുപ്പം. പക്ഷേ നമ്മുടെ ലക്ഷ്യം ഇക്കാര്യങ്ങള്‍ ചെയ്യുക എന്നതിലുപരിയായി
പ്രോഗ്രാം എഴുതാന്‍ (അത് ഏത് ഭാഷയിലായാലും) പഠിക്കുക എന്നതാണ്. ഒന്നാം പാഠത്തിലെ
"പ്രോഗ്രാമുകള്‍ ചെയ്തുപഠിക്കുന്നതിലൂടെ, പൈത്തണ്‍ എന്ന ഭാഷയുടെ വ്യാകരണം
പഠിക്കുക എന്നതിലുപരി പ്രോഗ്രാമിംഗ് എന്ന കല നമുക്കു പഠിക്കാം."
അപ്പോള്‍ "മാന്ത്രികത" കഴിയുന്നത്ര കുറച്ച്, വിസ്തരിച്ച് പ്രോഗ്രാം എഴുതുന്നതല്ലേ നല്ലത്?
Krishnan November 8, 2011 at 8:45 PM
പാഠങ്ങളുടെ ഉദ്ദേശ്യം തെറ്റിദ്ധരിച്ചു. MathsBlog ആയതിനാല്‍, ജ്യാമിതിപഠനത്തിന് സഹായകരമായി GeoGebra ഉപയോഗിക്കുന്നതുപോലെ,സംഖ്യാപരമായ ചില പ്രശ്നങ്ങള്‍ കൈകാര്യം ചെയ്യാന്‍, പൈഥണ്‍ ഉപയോഗിക്കാന്‍ ശീലിപ്പിക്കുക എന്നാണ് ഞാന്‍ കരുതിയത്.
എന്നിട്ടും, ചില സംശയങ്ങള്‍ ബാക്കി:
1. സാധാരണഗതിയില്‍ ചെയ്യാന്‍ സമയമേറെയെടുക്കുന്ന ചില കാര്യങ്ങള്‍ വേഗം ചെയ്യാന്‍ വേണ്ടിയല്ലേ കമ്പ്യൂട്ടറും, പ്രോഗ്രാമിങ്ങുമെല്ലാം? അതിനുള്ള എളുപ്പവഴികളല്ലേ പറഞ്ഞു കൊടുക്കേണ്ടത്?
2. മറ്റു പല ഭാഷകളിലും കുറേയധികം കോഡ് എഴുതി ചെയ്യേണ്ടിവരുന്ന കാര്യങ്ങള്‍ എളുപ്പം ചെയ്യാം എന്നതല്ലേ പൈഥണ്‍ ഭാഷയുടെ പ്രധാന ആകര്‍ഷണം?
3. sort നെക്കുറിച്ച് ഈ പാഠത്തില്‍ പറഞ്ഞതിനേക്കാല്‍ എത്രയോ ലളിതവും രസകരവുമല്ലേ, ഫിബോണാച്ചി ശ്രേണിയിലെ പദങ്ങള്‍ കണ്ടു പിടിക്കാനുള്ള കോഡ്?
$\qquad$ if n==1 or n==2:
ഏതായാലും നമ്മുടെ ഗണിതപാഠപുസ്തകങ്ങള്‍ക്ക് അനുബന്ധമായി ചില പൈഥണ്‍ പാഠങ്ങള്‍ ചെയ്യുന്നതും നന്നായിരിക്കുമെന്നു തോന്നുന്നു. സമയം കിട്ടുമ്പോള്‍ ശ്രമിയ്ക്കാം. ഒരേ കാര്യംതന്നെ പലകോണുകളില്‍ കാണുന്നത് നല്ലതല്ലേ?
ഫിലിപ്പ് November 8, 2011 at 10:26 PM
ഈ പാഠത്തിന്റെ ഒരു ലക്ഷ്യം ഏകദങ്ങളുടെ വ്യാകരണം അവതരിപ്പിച്ച്, ഏകദങ്ങളെ
നിര്‍വചിക്കുന്നതിന്റെയും ഉപയോഗിക്കുന്നതിന്റെയും കുറച്ച് ഉദാഹരണങ്ങള്‍ വഴി ഈ
വ്യാകരണത്തോട് കുറച്ചൊക്കെ പരിചയമുണ്ടാക്കുക എന്നതാണ്.
ഈ പാഠങ്ങള്‍ വഴി പൈത്തണ്‍ പഠിച്ചുതുടങ്ങിയ ഒരാള്‍ക്ക് കുറേക്കൂടെ കോഡ് ഉദാഹരണങ്ങള്‍
— ഇതുവരെ കണ്ടതിനെക്കാള്‍ കുറച്ചൊക്കെ സങ്കീര്‍ണ്ണമായവ — വായിക്കാന്‍
അവസരം കൊടുക്കുക എന്നതും ഈ പാഠത്തിന്റെ പ്രധാനപ്പെട്ട മറ്റൊരു ലക്ഷ്യമാണ്. പക്ഷേ
ഈ സങ്കീര്‍ണ്ണത കൂടിപ്പോയാല്‍ ശരിയാകില്ലതാനും. ഒരുദാഹരണം : പ്രവര്‍ത്തനം 5-ല്‍
പറഞ്ഞിരിക്കുന്ന കാര്യം സാറിനും എനിക്കും അതിലളിതമാണ് : അതിനെപ്പറ്റി രണ്ടാമതൊന്ന്
ആലോചിക്കുകപോലും ചെയ്യാതെ നമുക്കത് വായിച്ചുപോകാം. എന്നാല്‍ പുതുതായി പഠിക്കുന്ന
ഒരാള്‍ക്ക് ഇത് തീരെ ലളിതമാകണമെന്നില്ല. ചുരുങ്ങിയപക്ഷം, ഈ രണ്ടു വരികള്‍
മനസ്സിലാക്കാനായി ഒന്നോ രണ്ടോ മണിക്കൂര്‍ എടുക്കുമായിരുന്ന (അനതിവിദൂരമായ) ഒരു
ഭൂതകാലം എനിക്കുണ്ട്. largest2 എന്ന ഏകദത്തിലെ for ലൂപ്പാണെങ്കില്‍ ഇതിനെക്കാളും
ചിന്ത ആവശ്യമായതാണ്. ഇങ്ങനെയുള്ള — കുറച്ച് ആലോചിച്ചാല്‍ മാത്രം
മനസ്സിലാകുന്ന — കോഡ് ഉദാഹരണങ്ങള്‍ അവതരിപ്പിക്കുന്നത് പുതുതായി
പ്രോഗ്രാമിംഗ് പഠിക്കുന്ന ഒരാള്‍ക്ക് വളരെ സഹായകമാകുമെന്ന് തോന്നുന്നു.
>> 1. സാധാരണഗതിയില്‍ ചെയ്യാന്‍ സമയമേറെയെടുക്കുന്ന ചില കാര്യങ്ങള്‍ വേഗം
>>ചെയ്യാന്‍ വേണ്ടിയല്ലേ കമ്പ്യൂട്ടറും, പ്രോഗ്രാമിങ്ങുമെല്ലാം? അതിനുള്ള എളുപ്പവഴികളല്ലേ
വേഗത്തില്‍ കമ്പ്യൂട്ടറിനെക്കൊണ്ട് കാര്യങ്ങള്‍ ചെയ്യാന്‍ പഠിപ്പിക്കുക എന്നത്
ഇപ്പോഴത്തെ നിലയില്‍ ഈ പാഠങ്ങളുടെ ലക്ഷ്യമേയല്ല. പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാന
ആശയങ്ങള്‍ പഠിപ്പിക്കാനാണ് ശ്രമിക്കുന്നത്. കമ്പ്യൂട്ടറിനെ ഒരു ടൂള്‍ ആയി
ഉപയോഗിക്കാന്‍ ഇക്കാര്യങ്ങള്‍ അറിയണമെന്നില്ലല്ലോ. ഉദാ: ഫോട്ടോ
എഡിറ്റിംഗിനെപ്പറ്റി മാത്‌സ് ബ്ളോഗിലെ ചര്‍ച്ച. അതിവേഗം പ്രവര്‍ത്തിക്കുന്ന
പ്രോഗ്രാമുകള്‍ എഴുതാന്‍ വായനക്കാരെ പ്രാപ്തരാക്കുക എന്നതും ഈ പാഠങ്ങളുടെ പരിധിക്ക്
അപ്പുറമാണ് ; അതിന് കുറേക്കൂടി ഉയര്‍ന്ന തലത്തിലുള്ള പഠനം വേണ്ടിവരും.
>> 2. മറ്റു പല ഭാഷകളിലും കുറേയധികം കോഡ് എഴുതി ചെയ്യേണ്ടിവരുന്ന കാര്യങ്ങള്‍
>> എളുപ്പം ചെയ്യാം എന്നതല്ലേ പൈഥണ്‍ ഭാഷയുടെ പ്രധാന ആകര്‍ഷണം?
ഇത് വളരെ ശരിയാണ്. ഉദാഹരണത്തിന് selection_sort പ്രോഗ്രാമിലെ 61-ആം
വരിയില്‍ ചെയ്ത കാര്യം C-യില്‍ എഴുതണമെങ്കില്‍ ഇത്ര എളുപ്പമല്ല. ഇതൊക്കെക്കാരണം
പൈത്തണില്‍ എഴുതിയ പ്രോഗ്രാം പ്രവര്‍ത്തനരീതിയോട് (algorithm) വളരെ
അടുത്തുനില്‍ക്കുന്നു : സൂക്ഷ്മമായ കാര്യങ്ങള്‍ മിക്കതും (details) പൈത്തണ്‍ തനിയെ
കൈകാര്യം ചെയ്തുകൊള്ളും. പക്ഷേ ഈ ചുരുക്കെഴുത്ത് sort എന്ന ഏകദത്തെ നേരിട്ട്
പ്രയോഗിക്കുന്നതിലേക്ക് എത്തിയാല്‍ പ്രവര്‍ത്തനരീതിതന്നെ കാണാമറയത്താകില്ലേ?
"Premature optimization is the root of all evil" എന്നത് പ്രോഗ്രാമുകള്‍ക്ക്
മാത്രമല്ല, പ്രോഗ്രാമിംഗ് പാഠനത്തിനും ശരിയാണെന്ന് തോന്നുന്നു.
>> 3. sort നെക്കുറിച്ച് ഈ പാഠത്തില്‍ പറഞ്ഞതിനേക്കാല്‍ എത്രയോ ലളിതവും
>> രസകരവുമല്ലേ, ഫിബോണാച്ചി ശ്രേണിയിലെ പദങ്ങള്‍ കണ്ടു പിടിക്കാനുള്ള കോഡ്?
രസകരമാണോ എന്നുള്ളത് (ഗണിതത്തിലും പ്രോഗ്രാമിംഗിലുമുള്ള) വൈദഗ്ധ്യത്തെ
ലളിതമാണോ എന്നറിയാന്‍ ഒരു (രസകരമായ!) പരീക്ഷണം : നമ്മുടെ നാട്ടിലെ ഏതെങ്കിലും
എഞ്ചിനീയറിംഗ് കോളജില്‍ കംപ്യൂട്ടര്‍ സയന്‍സ് പഠിപ്പിക്കുന്ന ആരോടെങ്കിലും
1. നിങ്ങള്‍ക്ക് ഈ പ്രോഗ്രാം മനസ്സിലായോ? (ആയി എന്നാണുത്തരമെങ്കില്‍ അത്
പരീക്ഷിക്കാന്‍ പ്രോഗ്രാമില്‍ തക്കതായ എന്തെങ്കിലും ചെറിയ മാറ്റം വരുത്താന്‍
2. നിങ്ങളുടെ കോളജില്‍നിന്ന് ഈ വര്‍ഷം കമ്പ്യൂട്ടര്‍ സയന്‍സ് വിഷയം നല്ലനിലയില്‍
പാസാകാന്‍ പോകുന്ന എത്ര കുട്ടികള്‍ക്ക് ഈ പ്രോഗ്രാം മനസ്സിലാകും?
Krishnan November 9, 2011 at 7:57 AM
ഗണിതം പോലെ പഠിക്കുകയോ, പഠിപ്പിക്കുകയോ ചെയ്യാത്തതിനാല്‍, programming പഠിപ്പിക്കുന്നതിനെക്കുറിച്ച് അനുഭവങ്ങളുടെ വെളിച്ചത്തില്‍
ശക്തമായി പറയാനാവില്ല. സംശയരൂപത്തില്‍ ചില അഭിപ്രായങ്ങള്‍ പറയാനേ കഴിയൂ
ഇതിനിടെ മറ്റൊരു രസം തോന്നി.
എന്നു നിര്‍വചിച്ചശേഷം add(12,34) എന്നെഴുതിയാല്‍ 46 കിട്ടും. ഇനി ചുവടെപ്പറയുന്നവ പരീക്ഷിച്ചുനോക്കൂ:
Krish November 9, 2011 at 5:17 PM
With all due respect to the efforts of Mr. Philip, though recursion is supposed to be divine, in general, recursion is more difficult to understand than iteration and many-a-time poorer in performance. Recursive solutions are more beautiful to look at( once you understand them, :) ), however.
In this case, the plain iterative solution below is quite straightforward to understand. If you don't mind my saying so, I think the definitions of the functions 'larger2' and 'largest2' are unnecessarily elaborate and a trifle convoluted.
# go up to the last but one element,
# no point in going to the last element
# because there is nothing below the last element
# and so nothing to compare with the last element
for indx in range(list_length-1):
# find out the index of the largest element below the current indx
for j in range(indx+1, list_length):
if num_list[j] > num_list[indx_of_max]:
if indx_of_max != indx :
# swap the largest element with the element at the current indx
num_list[indx], num_list[indx_of_max] = num_list[indx_of_max], num_list[indx]
Krish November 9, 2011 at 5:33 PM
Sorry, the code was not properly formatted. Hope it is now.
$\qquad$# go up to the last but one element,
$\qquad$# no point in going to the last element
$\qquad$# because there is nothing below the last element
$\qquad$# and so nothing to compare with the last element
$\qquad$for indx in range(list_length-1):
$\qquad\qquad$# find out the index of the largest element below the current indx
$\qquad\qquad$for j in range(indx+1, list_length):
$\qquad\qquad\qquad$if num_list[j] > num_list[indx_of_max]:
$\qquad\qquad$if indx_of_max != indx :
$\qquad\qquad\qquad$# swap the largest element with the element at the current indx
$\qquad\qquad\qquad$num_list[indx], num_list[indx_of_max] = num_list[indx_of_max], num_list[indx]
ഫിലിപ്പ് November 9, 2011 at 6:17 PM
Krish-ന്റെ പ്രോഗ്രാമിലെ ഒരു കാര്യം ഇവിടെ മുമ്പ് കണ്ടിട്ടില്ലാത്തതാണ്. അത് വിശദീകരിക്കാം.
സമചിഹ്നം ( = ) പൈത്തണില്‍ വില കൊടുക്കാനായാണ് (ഗണിതത്തിലെപ്പോലെ തുല്യത കാണിക്കുന്നതിനുവേണ്ടി അല്ല ) എന്ന് നാലാം പാഠത്തില്‍ കണ്ടല്ലോ? പൈത്തണില്‍ ഈ സംകാരകത്തിന് (operator) സമാന്തരമായി വിലകള്‍ കൊടുക്കാനുള്ള കഴിവുണ്ട്. ഇത് മനസ്സിലാകാന്‍ ഈ കോഡ് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക:
a, b = 5, 10
ഇവിടെ വിലകള്‍ ശരിക്കും "സമാന്തരമായി"ത്തന്നെയാണ് കൊടുക്കുന്നത്. ഇത് മനസ്സിലാക്കാന്‍ ഈ കോഡ് പ്രവര്‍ത്തിപ്പിക്കൂ:
a, b = b, a
ഈ വിദ്യയാണ് Krish-ന്റെ പ്രോഗ്രാമില്‍ വിലകള്‍ തിരിച്ചിടാന്‍ ഉപയോഗിച്ചിരിക്കുന്നത്.
Krishnan November 10, 2011 at 6:12 AM
This comment has been removed by the author.
Krishnan November 10, 2011 at 6:18 AM
പൈഥണില്‍ ചരങ്ങളുടെ വിലകള്‍ പരസ്പരം മാറ്റുന്ന വിദ്യ അല്പംകൂടി വിശദീകരിക്കണമെന്നു തോന്നുന്നു. ഒരു പ്രോഗ്രാമില്‍ എവിടെയെങ്കിലും
എന്നു വിലകള്‍ കൊടുത്തിട്ടുണ്ടെന്നു കരുതുക. ഇനി ഇതില്‍ത്തന്നെ മറ്റൊരിടത്ത് ഇവ പരസ്പരം മാറ്റി, a യുടെ വില 10 ഉം b യുടെ വില 5 ഉം ആക്കണമെന്നു കരുതുക
എന്നെഴുതിയാല്‍ ശരിയാകില്ല. a = b എന്നെഴുതുമ്പോള്‍ a യുടെ വില 10 ആയി; തുടര്‍ന്ന് b = a എന്നെഴുതുമ്പോള്‍ b യുടെ വില (അപ്പോഴത്തെ a യുടെ വിലയായ) 10 ആകും. അതായത്, ഇങ്ങിനെ എഴുതിയാല്‍, a, b ഇവ രണ്ടും 10 ആകും.
സാധാരണയായി ഇതിനുപയോഗിക്കുന്ന സൂത്രം, ഒരു വില തല്‍ക്കാലം മറ്റൊരു ചരത്തിലേയ്ക്ക് മാറ്റിയെഴുതലാണ്:
എന്നെഴുതാം. ഇവിടെ ഒരു കാര്യം ശ്രദ്ധിക്കണം: x = a എന്നെഴുതുമ്പോള്‍ x ന്റെ വില (a യുടെ വിലയായ) 10 ആകും; തുടര്‍ന്ന് a = b എന്നെഴുതുമ്പോള്‍, a യുടെ വില (b യുടെ വിലയായ) 5 ആകുമെങ്കിലും, x ന്റെ വില മാറില്ല. (ഗണിതത്തില്‍ x = a എന്നും a = b എന്നും പറഞ്ഞാല്‍ x = b ആണല്ലോ. ഫിലിപ്പ് പറഞ്ഞതുപോലെ,
ഇവിടെ = എന്നത്, equality relation അല്ല, assignment operator ആണ്.)
പൈഥണിലെ ഒരു സൗകര്യം, മൂന്നാമതൊരു ചരം ഉപയോഗിക്കാതെ, ഇതു നേരിട്ട്
a, b = b, a
എന്നെഴുതാം എന്നതാണ്. ഉദാഹരണമായി, രണ്ടു സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാനുള്ള function
$\quad$ while b != 0:
$\qquad$ r = a % b
$\qquad$ a = b
$\qquad$ b = r
$\quad$ while b != 0:
$\qquad$ a, b = b, a % b
$\quad$ while b != 0:
$\qquad$ a = b
$\qquad$ b = a % b
എന്നെഴുതിയാല്‍ ശരിയാകില്ല എന്നതും ശ്രദ്ധിക്കുക.
Krishnan November 10, 2011 at 6:37 AM
Krish : "...in general, recursion is ..... many-a-time poorer in performance"
As an aside to this, I find that the iterative definition
$\quad$ for i in range(1,n+1):
$\qquad$ a = a*i
easily computes factorial(1000), but the recursive definition
returns "maximum recursion depth exceeded" run-time error for factorial(1000)
Krish November 10, 2011 at 1:45 PM
എന്നെഴുതാം. ഇവിടെ ഒരു കാര്യം ശ്രദ്ധിക്കണം: x = a എന്നെഴുതുമ്പോള്‍ x ന്റെ വില (a യുടെ വിലയായ) 10 ആകും; തുടര്‍ന്ന് a = b എന്നെഴുതുമ്പോള്‍, a യുടെ വില (b യുടെ വിലയായ) 5 ആകുമെങ്കിലും, x ന്റെ വില മാറില്ല.
Now both x and a will be [1, 2, -3, 4].
The concept of 'variables' in Python is different from the same concept in C or C++ and it has confused me often. Just to add to the explanation of variables by Mr. Philip in Lesson 4, when you have the statement
Python creates the value 10 in memory(RAM) and puts a tag( like the tags with rubber bands you see on the suitcases of your 'gulf' relatives when they come out of the airport) with the label 'x' on the value '10'. Now when you have the statement
Python creates the value 20 in memory, removes the tag with label 'x' from the value 10 and ties it around the value 20. Ok, so now the value 10 has no tag. So what happens to it ? Python keeps checking periodically for values with no tags and removes them from memory thus reclaiming the meory. So it finds that the value 10 has no tag and therefore it is not used by anybody and removes it from memory.
In C or C++ the concept is a bit different from the above.
Krish November 10, 2011 at 2:10 PM
To complete the story, when you have
the value '10' has two tags, one with label 'a' and another with label 'x' tied around it, just as your 'gulf' relative's suitcase can have more than tag tied to it( may be from different airports).
linux4schools November 10, 2011 at 4:00 PM
python പഠിക്കാന്‍ ശ്രമിച്ചെങ്കിലും എന്റെ ശ്രമം വിഫലമായി. Programming Language നോടുള്ള എന്റെ താല്പര്യമില്ലായ്മയാണ് കാരണം. Programming പഠിക്കാന്‍ താല്പര്യമുള്ളവര്‍ക്ക് ഇത്തരം പോസ്റ്റുകള്‍ വളരെ ഉപകാരപ്രധമാണ്. ഗണിതശാസ്ത്ര അധ്യാപകര്‍ക്ക് ഉപകാരപ്രഥമായ Geogebra പോലുള്ള പോസ്റ്റുകളും പ്രസിദ്ധീകരിക്കാന്‍ താല്പര്യപ്പെടുന്നു.
bhama November 13, 2011 at 6:07 PM
പര്യാവര്‍ത്തനത്തിന്റെ ആശയം ശരിയായി മനസ്സിലാക്കാന്‍ കഴിഞ്ഞുവെന്ന വിശ്വാസത്തോടെ
ഫിലിപ്പ് November 13, 2011 at 10:10 PM
കണക്കിലെപ്പോലെ പ്രോഗ്രാമിംഗിലും ആശയങ്ങള്‍ മനസ്സിലായോ എന്ന് മനസ്സിലാക്കാന്‍ ഏറ്റവും നല്ല വഴി പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുനോക്കുക എന്നതാണ്. ഒരു ലിസ്റ്റിന്റെ നീളം കണ്ടുപിടിക്കാനുള്ള ഒരു ഏകദം പര്യാവര്‍ത്തനമുപയോഗിച്ച് എഴുതാമോ?
1. നമ്മുടെ ഏകദത്തിന് length എന്ന് പേരിടുക.
2. ഒരു ക്ളൂ തരാം : A എന്ന ഒരു ലിസ്റ്റിന്റെ നീളത്തിനെ A-യിലും ചെറിയ ഒരു ലിസ്റ്റിന്റെ (ഏത് ലിസ്റ്റിന്റെ?) നീളത്തിന്റെ ഭാഷയില്‍ എഴുതാന്‍ കഴിയുമോ?
(ഇംഗ്ളീഷില്‍ : Can you express the length of a list in terms of the length of a smaller list?)
3. ഒരു ലിസ്റ്റ് കാലിയാണോ എന്ന് നോക്കാന്‍ — ലിസ്റ്റില്‍ അംഗങ്ങളൊന്നും ഇല്ലേ എന്ന് പരിശോധിക്കാന്‍ — ലിസ്റ്റിന്റെ ബൂളിയന്‍ വില False ആണോ എന്ന് നോക്കിയാല്‍ മതി. ഒരംഗം പോലുമില്ലാത്ത ലിസ്റ്റിന്റെ വില False ആയിരിക്കും. ഒരു അംഗമെങ്കിലുമുണ്ടെങ്കില്‍ True-ഉം. ഇത് മനസ്സിലാക്കാന്‍ ഈ കോഡ് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക:
print "The list is not empty"
print "The list is empty"
print "The list is not empty"
print "The list is empty"
4. കുറച്ചൊക്കെ ആലോചിച്ചിട്ടും രക്ഷയില്ലെങ്കില്‍ ചോദിക്കുക. ഇതൊരു പുതിയ ആശയമായതുകൊണ്ട് കുറേ ഉദാഹരണങ്ങള്‍ കണ്ടാലേ നന്നായി മനസ്സിലാകുകയുള്ളൂ. പാഠത്തില്‍ ഒരു ഉദാഹരണം മാത്രമാണല്ലോ കണ്ടത്?
5. ലിസ്റ്റിന്റെ (സ്ട്രിംഗിന്റെയും) നീളം കാണാന്‍ ഏറ്റവും നല്ല മാര്‍ഗം പൈത്തണില്‍ സ്വതവേ ലഭ്യമായ len() എന്ന ഏകദം ഉപയോഗിക്കുക എന്നതുതന്നെയാണ്. ഇതിലും നല്ല ഒരു ഏകദം എഴുതുക എന്നതല്ല ഈ പ്രവര്‍ത്തനത്തിന്റെ ലക്ഷ്യം!
(ചോദ്യത്തിന്റെ ആശയത്തിന് കടപ്പാട് : പ്രമോദ് സി. ഇ..)
Krishnan November 16, 2011 at 7:26 AM
This comment has been removed by the author.
Krishnan November 16, 2011 at 11:10 AM
linux4schools : "python പഠിക്കാന്‍ ശ്രമിച്ചെങ്കിലും എന്റെ ശ്രമം വിഫലമായി. Programming Language നോടുള്ള എന്റെ താല്പര്യമില്ലായ്മയാണ് കാരണം .... ഗണിതശാസ്ത്ര അധ്യാപകര്‍ക്ക് ഉപകാരപ്രഥമായ Geogebra പോലുള്ള പോസ്റ്റുകളും പ്രസിദ്ധീകരിക്കാന്‍ താല്പര്യപ്പെടുന്നു."
ആദ്യകാലത്ത് പ്രോഗ്രാമിങ്ങ് പഠിക്കുന്നതില്‍ എനിക്കും താത്പര്യമില്ലായിരുന്നു. കാരണം പുസ്തകങ്ങളിലെ പല ഉദാഹരണങ്ങളും, മനുഷ്യര്‍ക്ക് എളുപ്പം ചെയ്യാവുന്ന കാര്യങ്ങള്‍ വളരെ പ്രയാസപ്പെട്ട് കമ്പ്യൂട്ടറിനെക്കൊണ്ട് ചെയ്യിക്കാനുള്ള ശ്രമമായിട്ടാണ് തോന്നിയത് (1976ല്‍ ഐഐടി കാണ്‍പൂരിലെ എംടെക് പഠനം ഒരു സെമെസ്റ്ററില്‍ അവസാനിപ്പിക്കാനും കാരണം അതുതന്നെ.) പില്ക്കാലത്ത് മറിച്ചുള്ള ചില ഉദാഹരണങ്ങള്‍ അനുഭവിച്ചപ്പോഴാണ്, അഭിപ്രായം മാറിയത്. (പരപ്പളവും ചുറ്റളവും തുല്യമായ ചതുര-ത്രികോണ ജോടികള്‍ കണ്ടുപിടിക്കാന്‍ മുന്‍പൊരിക്കല്‍ ഭാമ റ്റീച്ചര്‍ എഴുതിയ പ്രോഗ്രാം ഓര്‍ക്കുക) മറ്റൊരു ഉദാഹരണംകൂടി. പണ്ട് കുഞ്ഞിക്കൃഷ്ണന്‍ മാഷ് ചോദിച്ചതാണ്.
1 മുതല്‍ 5 വരെയുള്ള സംഖ്യകള്‍ കൂട്ടിയാല്‍ 15; 2 മുതല്‍ 7 വരെയുള്ള സംഖ്യകള്‍ കൂട്ടിയാല്‍ 27; 4 മുതല്‍ 29 വരെയാണെങ്കില്‍ 429. ഇത്തരം മറ്റു ജോടികളുണ്ടോ എന്നാണ് ചോദ്യം. ഇതു പൈഥണില്‍ എളുപ്പം ചെയ്യാം (മറ്റു കമ്പ്യൂട്ടര്‍ഭാഷകളില്‍ അത്ര എളുപ്പവുമല്ല):
$\quad$ return(n*(n+1)/2 - m*(m-1)/2)
u = int(input("Type how far to check : "))
for m in range (1,u+1):
$\quad$ for n in range (m,u+1):
$\qquad$ if sum(m,n) == catnum(m,n):
$\qquad\quad$ print("Sum of integers from", m , "to", n, "is", catnum(m,n))
ഇത്തരം ചില ഉദാഹരണങ്ങളുംകൂടി ചര്‍ച്ച ചെയ്താല്‍, ജ്യാമിതിയില്‍ GeoGebra പോലെ, അങ്കഗണിതത്തില്‍ പൈഥണും ഗണിത അധ്യാപകര്‍ക്ക് ഉപകാരപ്രദമാകും എന്നു തോന്നുന്നു.
Krish November 16, 2011 at 5:27 PM
Just a piece of information:
sum is a built-in Python function. So, for example,
Krishnan November 16, 2011 at 5:51 PM
Krish : "sum is a built-in Python function"
Thank you Krish. This I noticed only recently, but the code posted was done sometime back
bhama November 17, 2011 at 6:23 PM
ഫിലിപ്പുസാര്‍ തന്ന ചോദ്യം കണ്ടു. പ്രോഗ്രാം എഴുതിയിട്ടില്ല. കൊച്ചുമകളെത്തിയിട്ടുണ്ട്. പഠനങ്ങളെല്ലാം മാറ്റിവച്ച് അവളുടെകൂടെ. ഒരു ചെറിയ ഇടവേള.
bhama November 29, 2011 at 9:36 PM
>>> A എന്ന ഒരു ലിസ്റ്റിന്റെ നീളത്തിനെ A-യിലും ചെറിയ ഒരു ലിസ്റ്റിന്റെ (ഏത് ലിസ്റ്റിന്റെ?) നീളത്തിന്റെ ഭാഷയില്‍ എഴുതാന്‍ കഴിയുമോ? >>> ചോദ്യം വ്യക്തമായില്ല ഒന്നുകൂടി വിശദീകരിക്കാമോ ?
ഫിലിപ്പ് November 30, 2011 at 2:02 AM
ചോദ്യം വ്യക്തമാകാഞ്ഞത് വിശദീകരിച്ചതിന്റെ പോരായ്മ തന്നെ.
ടീച്ചര്‍ എഴുതിയ പ്രോഗ്രാമില്‍ len() ഉപയോഗിച്ചിട്ടുണ്ടല്ലോ? len() ഉപയോഗിക്കാതെ ("വെറുംകൈ കൊണ്ട്") ലിസ്റ്റിന്റെ നീളം കണ്ടുപിടിക്കുന്ന ഒരു ഏകദം എഴുതുന്നത് എങ്ങനെയാണെന്ന് നോക്കാം.
1. പാഠനത്തിന്റെ ഭാഗമായാണ് ഇതെഴുതുന്നത്. വേഗതയുടെ കാര്യത്തിലും മറ്റും ഇനി എഴുതാന്‍ പോകുന്ന ഏകദത്തെക്കാള്‍ എന്തുകൊണ്ടും നല്ലത് സ്വതവേ ലഭ്യമായ len() തന്നെയാണ്.
2. പര്യാവര്‍ത്തനത്തിന്റെ ഉദാഹരണമായാണ് ഇതെഴുതുന്നത്. സാധാരണ ആവര്‍ത്തനമുപയോഗിച്ചും ഇതെഴുതാം.
പര്യാവര്‍ത്തനത്തിന്റെ പൊതുവായ സ്വഭാവം ഇതാണ്:
1. ഒരു വലിയ പ്രശ്നത്തിനെ അതിലും "ചെറിയ" പ്രശ്നങ്ങളുടെ ഭാഷയില്‍ എഴുതുക.
2. ഈ ചെറിയ പ്രശ്നങ്ങളുടെ ഉത്തരങ്ങള്‍ കണ്ടുപിടിച്ച് യഥാവിധി യോജിപ്പിച്ച് വലിയ പ്രശ്നത്തിന്റെ ഉത്തരം കണ്ടുപിടിക്കുക.
3. ഈ പരിപാടിയില്‍ ഏറ്റവും ചെറിയ (ഇനി ചെറുതാക്കുന്നതില്‍ കഥയില്ലാത്ത) പ്രശ്നങ്ങളുടെ ഉത്തരങ്ങള്‍ വേണ്ടിവരുമ്പോള്‍ അവയെ മെനക്കെട്ടുതന്നെ കണ്ടുപിടിക്കുക.
ഈ പറഞ്ഞ സൈദ്ധാന്തികവും താത്വികവുമായ സംഭവം എന്താണെന്ന് മനസ്സിലാക്കാന്‍ നമുക്ക് ഒരു ലിസ്റ്റിന്റെ നീളം കാണുക എന്ന പ്രശ്നം ഈ രീതിയില്‍ പരിഹരിക്കാന്‍ നോക്കാം.
myList എന്നത് ഒന്നോ അതിലധികമോ അംഗങ്ങളുള്ള ഒരു ലിസ്റ്റാണെങ്കില്‍ myList[1:] എന്നത് ഈ ലിസ്റ്റിന്റെ ആദ്യത്തെ അംഗം ഒഴിച്ചുള്ള ലിസ്റ്റാണെന്നത് ഓര്‍ക്കുക.
ആദ്യത്തെ പടി (പ്രശ്നത്തെ "ചെറുതാക്കല്‍") ഇങ്ങനെയാണ് :
"myList എന്ന ലിസ്റ്റിന്റെ നീളം = 1 + (myList[1:] എന്ന ലിസ്റ്റിന്റെ നീളം)"
ഇത് ശരിയാണല്ലോ? അപ്പോള്‍ myList-ന്റെ നീളം കണ്ടുപിടിക്കാന്‍ myList[1:] എന്ന ഒരംഗം കുറഞ്ഞ ലിസ്റ്റിന്റെ നീളം കണ്ടുപിടിച്ചാല്‍ മതി എന്നായി. ഇങ്ങനെയാണ് ഈ പ്രശ്നത്തെ "ചെറുത്" ആക്കിയത്.
രണ്ടാമത്തെ പടി (ചെറിയ പ്രശ്നങ്ങളുടെ ഉത്തരങ്ങളെ യോജിപ്പിച്ച് വലിയ പ്രശ്നത്തിന്റെ ഉത്തരം കണ്ടുപിടിക്കല്‍) മുകളില്‍ പറഞ്ഞതുതന്നെയാണ്. ഈ ഉദാഹരണത്തില്‍ "വലിയ" പ്രശ്നത്തിനെ ഒരേ ഒരു "ചെറിയ" പ്രശ്നമായി മാത്രമാണ് "പിരിച്ചെഴുതുന്നത്". അതുകൊണ്ട് യോജിപ്പിക്കലിന്റെ ആവശ്യമില്ല. പക്ഷേ "ചെറിയ" ഉത്തരത്തിനോട് ഒന്ന് എന്ന സംഖ്യ കൂട്ടണം. ഇതും മുകളില്‍ പറഞ്ഞിട്ടുണ്ടല്ലോ?
മൂന്നാമത്തെ പടി (ഏറ്റവും ചെറിയ പ്രശ്നങ്ങളുടെ ഉത്തരങ്ങള്‍ അങ്ങനെതന്നെ കണ്ടുപിടിക്കുക) ഇങ്ങനെയാണ് :
"myList-ല്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍ അതിന്റെ നീളം പൂജ്യമാണ്"
ഇത്രയും ചേരുവകള്‍ ചേര്‍ത്ത് എഴുതിയ ഏകദം ഇതാ:
def length( myList ) :
if not myList :
return 1 + length(myList[1:])
ഇവിടെ myList എന്നത് length എന്ന ഈ ഏകദത്തിന് "ഉള്ളില്‍ മാത്രം" ഉള്ള ഒരു ചരം ആണെന്നും, length എന്ന ഏകദത്തിന് വാക്യമായി നാം കൊടുക്കുന്ന ലിസ്റ്റിന്റെ വില ഈ ഏകദത്തിലേക്ക് പകര്‍ത്തിയിട്ടാണ് ഏകദം ബാക്കി കാര്യങ്ങളൊക്കെ ചെയ്യുന്നത് എന്നതും ഓര്‍ക്കുക.
ഈ ഏകദം ഇങ്ങനെ "വായിക്കാം" :
"myList-ല്‍ അംഗങ്ങളൊന്നുമില്ലെങ്കില്‍ അതിന്റെ നീളം പൂജ്യമാണ്. അല്ലെങ്കില്‍ അതിന്റെ നീളം myList[1:] എന്ന ലിസ്റ്റിന്റെ നീളത്തിനോട് ഒന്ന് കൂട്ടിയാല്‍ കിട്ടുന്ന സംഖ്യയാണ്."
മുകളിലെ ഉദാഹരണം പല പ്രാവശ്യം വായിച്ചും പ്രവര്‍ത്തിപ്പിച്ചും നോക്കൂ. പ്രോഗ്രാമും വിശദീകരണവും തമ്മില്‍ യോജിച്ച് പോകുന്നുണ്ടോ?
മുകളിലെ ഏകദത്തില്‍ len() ഉപയോഗിച്ചിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക. ശരിക്കും "വെറുംകൈ കൊണ്ട്" തന്നെയാണ് ലിസ്റ്റിന്റെ നീളം കണ്ടുപിടിച്ചത്.
പ്രവര്‍ത്തനം : ലിസ്റ്റിന്റെ നീളം കാണുന്ന ഒരു ഏകദം പര്യാവര്‍ത്തനം ഉപയോഗിക്കാതെ എഴുതുക (if, while, for, ചരങ്ങള്‍ മുതലായി ഇതുവരെ പഠിച്ച മറ്റ് എല്ലാ കാര്യങ്ങളും ഉപയോഗിക്കാം; മുകളിലത്തെപ്പോലെ ഏകദത്തിന്റെ നിര്‍‌വചനത്തില്‍ അതിന്റെ തന്നെ പ്രയോഗം വരരുത് എന്നേയുള്ളൂ.). len() ഉപയോഗിക്കാനും പാടില്ല.
Krish December 1, 2011 at 5:44 PM
In Google-Chrome, I am not able to see the malayalam in the titles.They appear as rectangles. For example, this text: "അതിഥികള്‍ - ഈ സമയം". I am able to see the malayalam in the content paragraphs, however.
I am also not able to see the Creative Commons license in the footer of the page in Google-Chrome.
In Firefox, there is no problem. I am able to see everything.
I am using Arch Linux and have all the necessary malayalam fonts installed, I think. Can someone suggest a solution? Thanks.
bhama December 1, 2011 at 10:13 PM
ലിസ്റ്റിന്റെ നീളം കാണുന്ന ഈ ഏകദം ശരിയായോ ??
ഫിലിപ്പ് December 2, 2011 at 12:45 AM
You are probably hitting this Chromium bug, which seems to have been fixed recently. Perhaps a pacman -Syu would help?
ഫിലിപ്പ് December 2, 2011 at 12:47 AM
ടീച്ചറുടെ പ്രോഗ്രാം തികച്ചും ശരിയാണ്. ഒരു if ഒഴിവാക്കി വേണമെങ്കില്‍ ഇങ്ങനെ എഴുതാം:
def length (my_list) :
for i in my_list :
list_length = list_length + 1
ഇത് കാലിയായ ലിസ്റ്റിന്റെമേലും ശരിയായി പ്രവര്‍ത്തിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുമല്ലോ.
Krish December 2, 2011 at 4:51 AM
നന്ദി . താങ്കള്‍ പറഞതുപോലെ ആ ബഗ് ആണു് കാരണമെന്നു തോന്നുന്നു. ആ ബഗ് റിപ്പോര്‍ട്ടില്‍ പറഞതുപോലെ bold tag ഉള്ളവടെയാണു് പ്രശ്നം. pacman -Syu എല്ലാ ദിവസവും ചെയ്യുന്നുണ്ടു് . പുതിയ versions ഇതുവരെ ഒന്നും വന്നിട്ടില്ല .
ഫിലിപ്പ് December 2, 2011 at 11:30 AM
അങ്ങനെയെങ്കില്‍ താങ്കളുടെ ~/.fonts.conf ഫയലിന്റെ ഉള്ളടക്കം ഇതുപോലെയാക്കുക:
ഇവിടെ Meera എന്ന ഫോണ്ടാണ് ഉപയോഗിച്ചിരിക്കുന്നത്. ഈ ഫോണ്ട് താങ്കളുടെ സിസ്റ്റത്തില്‍ ലഭ്യമല്ലെങ്കില്‍ അത് ഇന്‍സ്റ്റോള്‍ ചെയ്യുകയോ ലഭ്യമായ ഫോണ്ടിന്റെ പേര് കൊടുക്കുകയോ ചെയ്യുക.
ഇനി ക്രോമിയം ഓഫാക്കി ഓണാക്കി നോക്കൂ.
Krish December 2, 2011 at 8:53 PM
വളരെ ഉപകാരം. എല്ലാം ശരിയായി. Meeraക്കു പകരം AnjaliOldLipiയാണു് ഉപയോഗിക്കുന്നതു്. ഫുട്ടറിലെ CC license പക്ഷെ ഇപ്പൊഴും കാണുന്നില്ല.
bhama December 3, 2011 at 8:55 PM
പ്രോജക്ട് ഓയിലറിലെ മുപ്പതാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
ഫിലിപ്പ് December 4, 2011 at 12:34 AM
പ്രോഗ്രാമിൽ 1000000 എന്ന സംഖ്യ ഉപയോഗിച്ചിരിക്കുന്നതിന്റെ സാംഗത്യമെന്താണ്? ഇതിലും വലിയ സംഖ്യകൾ ഉത്തരത്തിൽ വരില്ല എന്ന് തെളിയിക്കേണ്ടേ? ഇല്ലെങ്കിൽ ഉത്തരം തെറ്റാമല്ലോ?
bhama December 4, 2011 at 6:09 AM
ഇതേ സംശയം എനിക്കും തോന്നാതില്ല. എന്തുകൊണ്ടാണ് ചോദ്യത്തില്‍ പരിധി നല്കാത്തതെന്നും ആലോചിച്ചു. എന്നാല്‍ range നല്കാതെ എങ്ങനെ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം നിര്‍ത്താന്‍ കഴിയും ? മറ്റുവല്ല മാര്‍ഗങ്ങളുമുണ്ടോ ?
എന്തായാലും ഇവിടെ കിട്ടിയ ഉത്തരം ശരിയാണെന്നാണ് പ്രോജക്ട് ഓയിലര്‍ പറഞ്ഞത്
ഫിലിപ്പ് December 4, 2011 at 10:51 AM
പ്രോജക്റ്റ് ഓയ്ലർ ആരാണെന്ന് സംശയിക്കുന്നവർക്കായി: പ്രോഗ്രാമിംഗ് ഉപയോഗിച്ച് ഉത്തരം കണ്ടുപിടിക്കേണ്ട കുറെയേറെ ഗണിത പസിലുകളുടെ ശേഖരമാണ് പ്രോജക്റ്റ് ഓയ്ലർ . പുതിയ ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയിൽ തഴക്കം വരാൻ (അല്ലെങ്കിൽ അറിയാവുന്ന ഭാഷ പൊടിതട്ടിയെടുക്കാൻ) ഉള്ള ഒരു എളുപ്പവഴിയാണ് ഇവിടത്തെ പസിലുകൾ ചെയ്തുനോക്കുക എന്നത്. ഭാമ ടീച്ചർ ഇവിടത്തെ മുപ്പതാമത്തെ ചോദ്യത്തിനുള്ള ഉത്തരമാണ് ഇപ്പോൾ കണ്ടുപിടിച്ചത്. ചോദ്യമിതാണ്:
തങ്ങളുടെ അക്കങ്ങളുടെ നാലാം കൃതികളുടെ തുകയായി എഴുതപ്പെടാവുന്ന മൂന്നേമൂന്ന് സംഖ്യകളേ ഉള്ളൂ:
1634 = $1^4 + 6^4 + 3^4 + 4^4$
8208 = $8^4 + 2^4 + 0^4 + 8^4$
9474 = $9^4 + 4^4 + 7^4 + 4^4$
(1 = $1^4$ ഒരു "തുക" അല്ലാത്തതുകൊണ്ട് അതിനെ കണക്കിലെടുക്കുന്നില്ല.)
ഈ മൂന്ന് സംഖ്യകളുടെ തുക 1634 + 8208 + 9474 = 19316.
ചോദ്യം : തങ്ങളുടെ അക്കങ്ങളുടെ അഞ്ചാം കൃതികളുടെ തുകയായി എഴുതപ്പെടാവുന്ന എല്ലാ സംഖ്യകളുടേയും തുക എന്താണ്?
സ്വന്തം അക്കങ്ങളുടെ അഞ്ചാം കൃതികളുടെ തുകയായി എഴുതാവുന്ന ഒരു സംഖ്യ എത്ര വലുത് വരെ ആകാം എന്നതിന് ഒരു പരിധി കണ്ടുപിടിക്കാമോ? കൃത്യമായ പരിധി വേണമെന്നില്ല, ഏകദേശമായാൽ മതി. ഈ പരിധി 1000000-യിൽ നന്നേ കുറവാണെങ്കിൽ പ്രോഗ്രാം പ്രവർത്തിക്കാനെടുക്കുന്ന സമയവും കുറയുമല്ലോ?
Krish December 4, 2011 at 2:19 PM
This is not a rigorous proof or anything but here goes:
The largest number that can be written as a sum of the 5th powers of the digits for n digits is $n \times 9^5$ , which happens when all the digits are 9.
The minimum n digit number is $10^{n - 1}$. Now
$n \times 9^5 < n \times 10^5 < 10 \times 10^5 < 10^6$
as long as n is less than 10.
If n >= 10 then instead of replacing n by 10 in the above replace it by 10^2 = 100 which will give you 100*10^5 = 10^7 which is still way smaller than the minimum n digit number for n>=10 which is 10^9.
This is why i think it is enough to restrict to 10^6 for the sum of the 5th powers.
Krish December 4, 2011 at 2:54 PM
The maximum number that can be written as the sum of the 5th powers of the digits for n digits goes as an arithmetic sequence with a common difference of 9^5: 9^5, 2*9^5, 3*9^5, 4*9^5 etc., whereas the minimum n digit number goes as a geometric sequence, 10, 100, 1000, 10000 etc.
bhama December 4, 2011 at 7:39 PM
തങ്ങളുടെ അക്കങ്ങളുടെ അഞ്ചാം കൃതികളുടെ തുകയായി എഴുതപ്പെടാവുന്ന ഏറ്റവും വലിയ സംഖ്യയില്‍ n അക്കങ്ങളുണ്ടെങ്കില്‍ തുക $n \times 9^5$
ഇത്തരത്തില്‍ സാധ്യമാകുന്ന ഏറ്റവും വലിയ സംഖ്യ 354294 ($6 \times9^5$ )അതുകൊണ്ട് ഉയര്‍ന്ന പരിധിയായി 350000 നല്കിയാലും മതി .
പരിധി നല്കുന്നതില്‍ ഇതേ പ്രശ്നം 34 ാമത്തെ ചോദ്യത്തിനുമുണ്ട്. ആ ചോദ്യത്തിനെഴുതിയ പ്രോഗ്രാം ഇങ്ങനെ.
ഫിലിപ്പ് December 5, 2011 at 10:15 PM
12 മുതൽ 14 വരെയുള്ള വരികൾ ഫാക്റ്റോറിയൽ കണ്ടുപിടിക്കുകയാണല്ലോ ചെയ്യുന്നത്. വേണമെങ്കിൽ ഇവയെ ഒരു ഏകദമായി എഴുതാം.
പല പ്രാവശ്യം ഉപയോഗപ്പെടുന്നു എന്ന് അനുഭവത്തിൽനിന്ന് മനസ്സിലാകുന്ന കാര്യങ്ങളെ ഒരു ഏകദമാക്കി എഴുതുക എന്നത് പ്രോഗ്രാമിംഗിൽ പൊതുവെ ചെയ്യുന്ന കാര്യമാണ്. ഏകദം ഒരു തവണ എഴുതി ശരിയാക്കിയാൽപ്പിന്നെ അതിനെ വെറുതെ ഉപയോഗിച്ചാൽ മതിയല്ലോ. ഓരോ പ്രാവശ്യവും പുതുതായി എഴുതുമ്പോൾ തെറ്റ് വരാനുള്ള സാധ്യത ഒഴിവാക്കുകയും ചെയ്യാം. ടീച്ചറുടെ കഴിഞ്ഞ രണ്ട് പ്രോഗ്രാമിലും‌ ഒരു ലിസ്റ്റിലെ സംഖ്യകളുടെ തുക കാണേണ്ടിവന്നല്ലോ? ഇതിന് വേണമെങ്കിൽ ഒരു ഏകദം എഴുതാം. ഇക്കാര്യം പൊതുവേ ആവശ്യം വരുന്നു എന്ന് കണ്ടതുകൊണ്ട് പൈത്തണിൽ ഇതിന് sum() എന്ന ഏകദം സ്വതവേ ലഭ്യമാക്കിയിട്ടുണ്ട്. ഉദാ: sum ([1, 3, 5, 7, 100]).
ടീച്ചറുടെ പ്രോഗ്രാം ഈ മാറ്റങ്ങളോടെ ഇവിടെ.
ഇത് വെറുതേ സൂചിപ്പിച്ചെന്നേയുള്ളൂ, ഇങ്ങനെ തന്നെ ചെയ്യണമെന്നില്ല. പ്രത്യേകിച്ച്, ഏകദം വേണോ വേണ്ടയോ എന്ന് ആലോചിച്ച് ആശയക്കുഴപ്പത്തിലാകേണ്ട കാര്യമേയില്ല. എന്തൊക്കെ ഏകദമാക്കണം എന്നത് തികച്ചും വ്യക്തിനിഷ്ഠമാണ്!
bhama December 16, 2011 at 7:53 PM
പ്രോജക്ട് ഓയിലറിലെ 23 ം ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
ഇതില്‍ 34 ം വരിയിലെ break ഒഴിവാക്കിയാല്‍ ഉത്തരം ശരിയാകുന്നില്ല. അത് എങ്ങനെ ഒഴിവാക്കി എഴുതാം ? പ്രോഗ്രാം റണ്‍ ചെയ്യുന്നതിന് പത്തുമിനിറ്റിലധികം എടുക്കുന്നു.
ഫിലിപ്പ് December 16, 2011 at 11:37 PM
1. for എന്നത് സ്വതവേ ലിസ്റ്റിലെ എല്ലാ അംഗങ്ങളേയും പരിഗണിക്കുന്നതുകൊണ്ടാണല്ലോ break വേണ്ടിവന്നത്? ഇത് ഒഴിവാക്കണമെങ്കില്‍ പകരം while ഉപയോഗിക്കാം :
26-ആം വരിയിലെ for-ന് മുമ്പായി abund_num എന്ന ലിസ്റ്റിന്റെ നീളം കണ്ടുപിടിച്ചുവെയ്ക്കുക : length = len(abund_num) .
27-ആം വരിയിലെ ab_sum = True എന്നതിന്റെ കൂടെ (മുമ്പോ പിമ്പോ) ഒരു സൂചക ചരത്തിന്റെ (index variable -- ലിസ്റ്റിലെ സ്ഥാനം സൂചിപ്പിക്കാനായി ഉപയോഗിക്കാനുള്ളത്) വില പൂജ്യമാക്കുക : j = 0 .
ഇനി 28-ആം വരിയിലെ for-ന് പകരം ഇങ്ങനെ എഴുതാം :
while (ab_sum = True) and (j < length):
j = j + 1
(ഇനി break ഒഴികെയുള്ള മറ്റു വരികള്‍ അതേപടി)
2. ഇവിടെ ഏറ്റവും കൂടുതല്‍ സമയം എടുക്കുന്നത് 26-ആം വരിയില്‍ തുടങ്ങുന്ന for ആണ്. ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്ന പ്രവര്‍ത്തനരീതി (അല്‍ഗോരിതം) ഒട്ടധികം സമയം എടുക്കുന്ന ഒന്നാണ്. ഇതേ കാര്യം ഇങ്ങനെ ചെയ്താലോ:
a) abund_num എന്ന ലിസ്റ്റിലെ ഈരണ്ടുവീതം സംഖ്യകളുടെ തുകകള്‍ എല്ലാം ഉള്‍പ്പെടുന്ന ഒരു ലിസ്റ്റ് തയ്യാറാക്കുക.
b) ഈ പുതിയ ലിസ്റ്റില്‍ ഇല്ലാത്ത സംഖ്യകളുടെ തുക കണ്ടുപിടിക്കുക.
a in list എന്നതിന്റെ വിപരീതം a not in list എന്നതാണെന്ന് ഓര്‍ത്താല്‍ ഇതില്‍ രണ്ടാമത്തെ കാര്യം എളുപ്പം ചെയ്യാം.
ഇങ്ങനെ ചെയ്താല്‍ വേഗത കൂടുന്നുണ്ടോ?
bhama December 17, 2011 at 3:48 PM
സാറു പറഞ്ഞതുപോലെ break ഒഴിവാക്കി എഴുതിയ പ്രോഗ്രാം
abund_num എന്ന ലിസ്റ്റിലെ ഈരണ്ടുവീതം സംഖ്യകളുടെ തുകകള്‍ എല്ലാം ഉള്‍പ്പെടുന്ന ഒരു ലിസ്റ്റ് തയ്യാറാക്കി ഈ പുതിയ ലിസ്റ്റില്‍ ഇല്ലാത്ത സംഖ്യകളുടെ തുക കണ്ടെത്തിയത് ഇങ്ങനെ
ഫിലിപ്പ് December 17, 2011 at 8:26 PM
ഈ മാറ്റങ്ങള്‍ വരുത്തിയതുകൊണ്ട് പ്രോഗ്രാം പ്രവര്‍ത്തിക്കാനെടുക്കുന്ന സമയത്തില്‍ (കാര്യമായ) വ്യത്യാസം (കൂടുതലോ കുറവോ) ഉണ്ടോ?
ഇതേ ആശയങ്ങള്‍ ഉപയോഗിച്ച് എഴുതിയ ഒരു പ്രോഗ്രാം ഇതാ . ഇത് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ. ഉത്തരം കിട്ടാനെടുക്കുന്ന സമയം കൂടുതലോ കുറവോ? രണ്ടായാലും പ്രോഗ്രാമില്‍ എന്തൊക്കെയാണ് വ്യത്യസ്തമായി ചെയ്തിരിക്കുന്നതെന്ന് നോക്കുമല്ലോ?
bhama December 18, 2011 at 8:21 PM
സാറെഴുതിയ പ്രോഗ്രാമുപയോഗിച്ച് ഉത്തരം കിട്ടാനെടുക്കുന്ന സമയം ഒരുമിനിറ്റില്‍ താഴെ മാത്രം !!!
sorted എന്ന ഏകദം മനസ്സിലായപ്പോള്‍ ഞാനെഴുതിയ പ്രോഗ്രാമില്‍ വീണ്ടും മാറ്റം വരുത്തി. ആകെ തുകയില്‍ നിന്നും അതിനിടയില്‍ വരുന്ന sum of abundant numbers ന്റെ തുക കുറച്ചു . ഈ പ്രോഗ്രാമുപയോഗിച്ച് ഉത്തരം കിട്ടാനെടുക്കുന്ന സമയം രണ്ടുമിനിറ്റില്‍ താഴെ
ഫിലിപ്പ് December 20, 2011 at 3:33 PM
ഈ പ്രോഗ്രാമിലെ All_Num_Sum എന്ന ഏകദം എങ്ങനെയാണ് അതിന്റെ ഉത്തരം കണ്ടുപിടിക്കുന്നതെന്ന് നോക്കൂ. ഇതിനെ മെച്ചപ്പെടുത്താന്‍ വഴിയുണ്ടോ?
bhama December 20, 2011 at 7:14 PM
വലിയ ഒരു തെറ്റ് ഒരാവശ്യവുമില്ലാത്ത ഒരു ഫോര്‍ ലൂപ്പ് . അത് ശ്രദ്ധിച്ചിരുന്നില്ല. ആ ഏകദം ഇല്ലാതെ തന്നെ പ്രോഗ്രാം മാറ്റി എഴുതി
Unnikrishnan,Valanchery December 21, 2011 at 8:13 PM
While i was testing a program, when i used for and else works is it a bug?
for i in range(15):
bhama December 22, 2011 at 7:56 AM
for ഉപയോഗിക്കുന്നത് ഒരേ പ്രവര്‍ത്തനം കൂടുതല്‍ തവണ ആവര്‍ത്തിക്കേണ്ടി വരുമ്പോഴാണ് . if ..... else കണ്ടീഷണല്‍ സ്റ്റേറ്റ് മെന്റ് ആണ് for ഉം if ഇല്ലാതെ else ഉം ഉപയോഗിച്ചതിനാലാണ് "hello" കൂടി പ്രിന്റ് ചെയ്ത്തത് .
Unnikrishnan,Valanchery December 22, 2011 at 9:39 PM
This comment has been removed by the author.
ഫിലിപ്പ് December 22, 2011 at 11:21 PM
ഉണ്ണികൃഷ്ണന്‍ സാര്‍, ഭാമ ടീച്ചര്‍,
for i in range(15):
എന്നതില്‍ വ്യാകരണത്തെറ്റ് ഇല്ല. for-ന്റെ വ്യാകരണത്തെപ്പറ്റി പാഠത്തില്‍ പറയാത്ത ഒരു നിയമമാണ് ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്നത്. ഈ നിയമം ഇങ്ങനെയാണ്: for-ന് ശേഷം else മുകളിലത്തെ ഉദാഹരണത്തിലെപ്പോലെ പ്രയോഗിക്കാം.
1. for-ന്റെ പ്രവര്‍ത്തനം സാധാരണ രീതിയില്‍ പൂര്‍ത്തിയായാല്‍: for-ന്റെ പ്രവര്‍ത്തനം കഴിഞ്ഞ് else-ന്റെ ഉള്ളടക്കം പ്രവര്‍ത്തിക്കും.
2. for-ന്റെ പ്രവര്‍ത്തനം നില്‍ക്കാനുള്ള കാരണം ഒരു break ആണെങ്കില്‍: for-ന്റെ പ്രവര്‍ത്തനം കഴിഞ്ഞ് else-ന്റെ ഉള്ളടക്കം പ്രവര്‍ത്തിക്കുകയില്ല.
3. for-ന്റെ പ്രവര്‍ത്തനം നില്‍ക്കാനുള്ള കാരണം ഒരു continue ആണെങ്കില്‍: for-ന്റെ പ്രവര്‍ത്തനം കഴിഞ്ഞ് else-ന്റെ ഉള്ളടക്കം പ്രവര്‍ത്തിക്കും.
ഇത് അത്രയധികം അറിയപ്പെടാത്ത വ്യാകരണമാണ്. ഉണ്ണികൃഷ്ണന്‍ സാറിന്റെ ചോദ്യം കാണുന്നതുവരെ എനിക്കും ഇതറിയില്ലായിരുന്നു. for-ന്റെ (മറ്റ് പ്രസ്താവങ്ങളുടെയും) വ്യാകരണം വിശദീകരിക്കുന്ന ഈ പേജില്‍നിന്നാണ് മുകളില്‍ പറഞ്ഞത് മനസ്സിലായത്. മറ്റൊരാള്‍ വായിക്കാന്‍ ഉദ്ദേശിച്ച് എഴുതുന്ന പ്രോഗ്രാമുകളിലെങ്കിലും ഇങ്ങനെ ദുര്‍ഗ്രഹമായ നിയമങ്ങള്‍ ഉപയോഗിക്കാതിരിക്കുന്നതാണ് നല്ലത്.
Krish December 23, 2011 at 1:33 AM
Actually, this is a useful Python idiom and worth remembering.
Without this feature, if you want some statement to be executed if there is no 'break' you will have to use an extra variable.
for i in range(10):
With the for...else idiom, this extra variable break_flag is not necessary.
Unnikrishnan,Valanchery December 26, 2011 at 9:21 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 26, 2011 at 9:42 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 26, 2011 at 11:02 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 26, 2011 at 11:26 PM
നന്ദി, ഫിലിപ്പ് സർ,ഭാമ ടീച്ചർ,കൃഷ് പക്ഷെ അങ്ങനെയെങ്കിൽ അഭാജ്യസംഖ്യയാണോ എന്നു പരിശോധിക്കാനുള്ള പ്രോഗ്രാം കുറേകൂടി എളുപ്പാമാണെന്ന് തോന്നുന്നു.പിന്നെ ഹരണം സംഖ്യയുടെ പകൂതി പോരെ.അതിനേക്കാൾ വലിയ ഘടകം ഉണ്ടാകില്ലല്ലോ.വെറുതെ സിസ്റ്റത്തിനെകൊണ്ട് പണിയെടുപ്പിക്കാണോ മാത്രമല്ല സമയവും പകുതി ലാഭിക്കാം
num=input("Enter the number to check prime Number :")
print "Enter a number grater than one"
print" 1 is prime or not prime"
for i in range (2,num/2):
if num% i ==0:
print num," is not prime number"
else: #ഈ else for ലൂപ്പിന്റെയണ്
print num, "is prime number"
തെറ്റുണ്ടെങ്കിൽ തിരുത്തുക ഒരു സാമൂഹ്യശാസ്ത്രാധ്യാപകനാണേ. കണക്ക് മറന്ന് പോയി.
ഫിലിപ്പ് December 27, 2011 at 9:39 PM
താങ്കളുടെ പ്രോഗ്രാമിന്‍ 4 ഇന്‍പുട്ട് ആയി കൊടുത്താല്‍ കിട്ടുന്ന ഉത്തരം എന്താണ്‍?
Unnikrishnan,Valanchery December 30, 2011 at 10:05 PM
Thank you Philip sir,I correct the problem
But is it the right way?.The problem is in for loop that is ,for loop starts in 2 and ends in 2.
Unnikrishnan,Valanchery December 30, 2011 at 10:46 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 30, 2011 at 10:50 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 30, 2011 at 11:15 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery December 30, 2011 at 11:25 PM
ഫിലിപ്പ് January 4, 2012 at 6:39 PM
Unnikrishnan,Valanchery January 9, 2012 at 8:55 PM
bhama January 15, 2012 at 9:58 PM
പ്രോജക്ട് ഓയിലറിലെ മുപ്പത്തിയഞ്ചാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
Krish January 20, 2012 at 4:42 AM
A couple of minor suggestions to the above program:
1. For testing for primes, using range(3, 1000000, 2) instead of range(2, 1000000) will avoid all even numbers which are certainly not primes.
2. Instead of using
"if is_cir_prime == True:"
you can use "if is_cir_prime:"
bhama January 20, 2012 at 6:27 AM
സാറു പറഞ്ഞപോലെ രണ്ടു മാറ്റങ്ങളും വരുത്തി.
ഒരു സംശയം " is_cir_prime = True: " എന്നു define ചെയ്തിരിക്കുന്നതുകൊണ്ടാണോ " if is_cir_prime == True : എന്നതിനു പകരം if is_cir_prime :" എന്നു മാത്രം കൊടുത്താല്‍ ശരിയാകുന്നത് ?
ഫിലിപ്പ് January 20, 2012 at 10:07 AM
എന്ന് കാണുമ്പോൾ പൈത്തൺ ചെയ്യുന്നത് conditional_expression എന്ന വ്യഞ്ജകത്തിന്റെ വില True ആണോ എന്ന് പരിശോധിക്കുക എന്നതാണ്. അതായത്, മുകളിലത്തെ വരിയുടെ “അർത്ഥം” ഇതാണ്:
if conditional_expression == True :
if 1 < 2 :
if (1 < 2) == True :
ഇതുകൊണ്ടാണ് പരിശോധിക്കേണ്ട വ്യഞ്ജകം മാത്രം എഴുതിയാലും കാര്യം നടക്കുന്നത്. “വ്യഞ്ജകത്തിന്റെ വില True ആണോ?” എന്നാണ് നാം ഉദ്ദേശിച്ചതെന്ന് പൈത്തണിന് അറിയാം.
പാഠത്തിൽ പറയാത്ത ഒരു കാര്യം : ഇങ്ങനെ വ്യവസ്ഥ പരിശോധിക്കേണ്ട സ്ഥലങ്ങളിലൊക്കെ താഴെക്കൊടുത്തിരിക്കുന്ന വിലകൾ മാത്രമാണ് “False” ആയി പരിഗണിക്കുക. മറ്റ് വിലകൾ വരുന്ന വ്യഞ്ജകങ്ങളെല്ലാം ഈ ആവശ്യത്തിന് “True” ആയി ആണ് പൈത്തൺ പരിഗണിക്കുന്നത്.
False എന്ന് ഗണിക്കപ്പെടുന്ന വിലകൾ : False, None, പൂജ്യമെന്ന സംഖ്യ, കാലിയായ സ്ട്രിംഗുകളും ലിസ്റ്റുകളും മറ്റും.
ഇത് പരീക്ഷിച്ചുനോക്കാൻ ഈ കോഡ് ഉപയോഗിക്കാം:
Krish January 20, 2012 at 5:08 PM
This comment has been removed by the author.
Krish January 20, 2012 at 5:18 PM
Recently, I came across an example of using recursion from here.
Perhaps many are aware of this puzzle or may be it has already been discussed here. The simple problem is this( quoting from the linked resource):
"By starting from the number 1 and repeatedly either adding 5 or multiplying by 3, an infinite amount of new numbers can be produced. How would you write a function that, given a number, tries to find a sequence of additions and multiplications that produce that number?"
Again, translating the recursive solution given there to Python we have the following program:
$\qquad\qquad$if start == goal :
$\qquad\qquad$elif start > goal :
$\qquad\qquad\qquad$return ( find(start + 5, "(%s + 5)" % $\qquad\qquad\qquad$history) or find(start * 3, "(%s * 3)" % history))
if __name__ == '__main__' :
$\qquad$print (findSequence(input_num) or 'No sequence in terms of 5 and 3 for %d.' % input_num)
Again, as mentioned in the resource linked above, recursion is best suited for problems that involve some sort of branching. Here, for every number generated, there is a branch produced by adding a 5 to it and another branch produced by multiplying it by 3.
For example, running this program on say 2304, gives
(((((((((((((((((((((((((((((((((((((((((((((((((((((1 + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) + 5) * 3) * 3)
I was curious to see how it could be written without recursion. Here is the version I came up with. It is longer than the recursive version and does not look very neat. May be someone can come up with a neater version.
However, performance-wise, it is quite a bit faster than the recursive version. For example, for the number 12017, here are the numbers I got on my computer:
time python five_three_iter2.py 12017
time python five_three_rec.py 12017
There is a version of python, called pypy which is supposed to be faster than the regular python. With pypy this is what I got for the iterative version:
time pypy five_three_iter2.py 12017
Yes, just about 5 seconds compared to the 1m 20 secs with the regular python.
For some reason, using pypy on the recursive version yielded much longer run times.
Krish January 20, 2012 at 5:23 PM
I forgot to link in the iterative version I came up with. Here it is.
bhama January 21, 2012 at 4:15 PM
സംശയം ദൂരീകരിച്ചു തന്നതിന് നന്ദി.
പ്രോജക്ട് ഓയിലറിലെ അമ്പതാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
bhama January 27, 2012 at 6:44 AM
പ്രോജക്ട് ഓയിലറിലെ മുപ്പത്തിയേഴാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
bhama January 27, 2012 at 6:47 AM
പ്രോജക്ട് ഓയിലറിലെ നാല്‍പത്തിയഞ്ചാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാം
Krish January 27, 2012 at 10:33 AM
The h'th hexagonal number that is equal to the p'th pentagonal number is given by
h*(2h - 1) = p*(3p-1)/2
If h is not small( therefore p is also not small) the above equation approximately is
2h * 2h = p*3p ( ignoring the minus one, since h and p are not small)
Or, p = (2/√3)h
h(2h -1) = t(t+1)/2
Even for 143, 165 and 285 this is approximately true. So for h larger than 143( that is, the next hexagonal number) this will be more true, I guess.
So, perhaps you don't have to go upto h+10000 and p+30000 in your loops.
jkcnair January 27, 2012 at 12:07 PM
ഫിലിപ്പ് സര്‍ , നല്ലൊരു സദ്യ വിളമ്പുന്നത് പാതിക്ക് നിര്‍ത്തിയത് ശരിയായില്ല .ഇതുവരെ കമന്റു ഇട്ടില്ലന്കിലും ഏകാലവ്യനെപോലെ പഠിക്കുക യായിരുന്നു.
ഫിലിപ്പ് January 27, 2012 at 1:31 PM
മുപ്പത്തഞ്ചാമത്തെ ചോദ്യത്തിനുള്ള ടീച്ചറുടെ പ്രോഗ്രാം ഇന്നാണ് ശ്രദ്ധിച്ച് വായിച്ചത്. ഒരു സ്ട്രിംഗിന്റെ rotations (ചുറ്റലുകള്‍?) എല്ലാം കണ്ടുപിടിക്കാന്‍ ടീച്ചര്‍ ഉപയോഗിച്ച ആശയം വിശേഷാല്‍ മനോഹരമായിരിക്കുന്നു.
ഒരു വലിയ സംഖ്യയില്‍ കുറവായ എല്ലാ അഭാജ്യങ്ങളുടേയും ലിസ്റ്റ് കണ്ടുപിടിക്കേണ്ടപ്പോള്‍ ഇറാറ്റോസ്തനീസിന്റെ അരിപ്പ ഉപയോഗിക്കാം. ഇതുള്‍പ്പടെയുള്ള മാറ്റങ്ങളോടെ ടീച്ചറുടെ പ്രോഗ്രാം ഇവിടെ. is_prime എന്ന ഏകദത്തില്‍ വരുത്തിയ മാറ്റം ശ്രദ്ധിക്കൂ. ഇതുകൊണ്ട് ഈ ഏകദത്തിന്റെ പ്രയോഗം കൂടുതല്‍ "സ്വാഭാവികം" ആകുന്നുണ്ടോ? (ഇക്കാര്യങ്ങളൊക്കെ ഒരളവുവരെ വ്യക്തിനിഷ്ഠമാണ്.)
ഒരു പ്രോഗ്രാം പ്രവര്‍ത്തിക്കാനെടുക്കുന്ന സമയം ലിനക്സിലെ ടെര്‍മിനല്‍ ഉപയോഗിച്ച് കണ്ടുപിടിക്കാന്‍ "time" എന്ന കമാന്റ് ഉപയോഗിക്കാം. ഉദാ:
എന്ന് കൊടുത്താല്‍ "python myprogram.py" എന്ന കമാന്റ് പ്രവര്‍ത്തിക്കാനെടുത്ത സമയം കിട്ടും.
ഓരോ സംഖ്യയും അഭാജ്യമാണോ എന്ന് നോക്കി ലിസ്റ്റ് തയ്യാറാക്കുന്ന രീതിയും (ഇത് prime_list() എന്ന പേരില്‍ പ്രോഗ്രാമിലുണ്ട്) അരിപ്പ ഉപയോഗിക്കുന്നതും (primes_via_sieve()) തമ്മില്‍ സമയത്തിലുള്ള വ്യത്യാസം അറിയാന്‍ രണ്ടു രീതിയിലും പ്രോഗ്രാം മാറ്റി time എന്ന കമാന്റ് ഈ രീതിയില്‍ പ്രയോഗിച്ചുനോക്കാം. time ഉപയോഗിക്കാനുള്ള സൌകര്യത്തിനായി ഉത്തരം പ്രിന്റ് ചെയ്യുന്ന തരത്തിലാണ് പ്രോഗ്രാം എഴുതിയിരിക്കുന്നത്.
ഫിലിപ്പ് January 27, 2012 at 1:32 PM
അന്പെയ്ത്തുപോലെ പ്രോഗ്രാമിംഗും പരിശീലനത്തിലൂടെ മാത്രമേ ശരിക്കു വഴങ്ങാറാകൂ. പാഠത്തിലെ പ്രവര്‍ത്തനങ്ങള്‍ കൂടാതെ പ്രോജക്റ്റ് ഓയ്ലറിലെ പ്രവര്‍ത്തനങ്ങളും ചെയ്തുനോക്കുന്നുണ്ടോ?
jkcnair January 28, 2012 at 10:53 AM
ഫിലിപ്പ് സര്‍, ഞാന്‍ ഒരു മറൈന്‍ എഞ്ചിനീയര്‍ ആണ്. ആദ്യം സി ++ ആണ് പഠിക്കാന്‍ ശ്രമിച്ചത് . എന്റെ ഒരു സുഹൃത്ത്‌ (അധ്യാപകന്‍ ) ആണ് python നിലേക്ക് തിരിച്ചതും താങ്കളുടെ പാഠങ്ങള്‍ കാണിച്ചു തന്നതും. എന്റെ സവിശേഷ ജോലി ക്രമങ്ങള്‍ കാരണം മുഴുവന്‍ സമയം പഠനത്തില്‍ ശ്രദ്ധിക്കാന്‍ കഴിയാറില്ല. മിക്കവാറും മൊബൈല്‍ ഫോണ്‍ ലെ python ഷെല്‍ ഉപയോഗിച്ചും PED എന്നാ IDE ഉപയോഗിച്ചും പാഠത്തിലെ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്യാറുണ്ട്. Project Euler ലെ പ്രവര്‍ത്തനങ്ങള്‍ തീര്‍ച്ചയായും ചെയ്യാം .
ഫിലിപ്പ് January 28, 2012 at 4:49 PM
കൃഷ്, നല്ല ഒരു പ്രോഗ്രാമിംഗ് പസില്‍ പരിചയപ്പെടുത്തിയതിന് നന്ദി.
(കൃഷ്-ന്റെ പസില്‍ ഇതാണ്: By starting from the number 1 and repeatedly either adding 5 or multiplying by 3, an infinite amount of new numbers can be produced. How would you write a function that, given a number, tries to find a sequence of additions and multiplications that produce that number?
അതായത്, 1 എന്ന സംഖ്യയില്‍ തുടങ്ങി 3 കൊണ്ട് ഗുണിച്ചും 5 കൂട്ടിയും തന്നിരിക്കുന്ന സംഖ്യ വരെ എത്താമോ? എങ്കില്‍ എങ്ങനെ?)
ഇങ്ങനെയൊരു പസില്‍ കിട്ടിയാല്‍ അതിന്റെ ഉത്തരത്തിനെപ്പറ്റി എങ്ങനെയാണ് ആലോചിച്ചുതുടങ്ങേണ്ടത്? ഇതുതന്നെ കുഴക്കുന്ന കാര്യമാണ്. ഇങ്ങനെയുള്ള സന്ദര്‍ഭങ്ങളില്‍ പ്രോഗ്രാമെഴുത്തിന് ഉപയോഗിക്കാവുന്ന ഒരു സൂത്രപ്പണിയുണ്ട്. അതിതാണ്:
ബുദ്ധിമുട്ടുള്ള കാര്യം പിന്നത്തേയ്ക്ക് മാറ്റിവയ്ക്കുക!
സംശയിക്കേണ്ടാ, കാര്യമായിത്തന്നെയാണ് പറഞ്ഞത്. കാര്യങ്ങള്‍ പിന്നത്തേയ്ക്ക് മാറ്റിവയ്ക്കല്‍ (procrastination) എന്നത് ജീവിതത്തില്‍ അബദ്ധമാണെങ്കിലും പ്രോഗ്രാമിംഗില്‍ നല്ല കാര്യമാണ്. "Procrastination is the thief of time." ("നാളെ നാളെ, നീളെ നീളെ") എന്നത് പ്രോഗ്രാമിംഗില്‍ "Procrastination is the saviour of time." എന്നാക്കാം. ഇത് ഈ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം എഴുതുന്ന കാര്യത്തില്‍ എങ്ങനെ പ്രയോഗിക്കാം എന്ന് നോക്കാം.
ക്രിയകളുടെ ഒരു ശ്രേണിയാണല്ലോ പസിലിന്റെ ഉത്തരമായി ആവശ്യപ്പെടുന്നത്? ഇതിന് പകരം ആദ്യം നമുക്ക് ഇതേ പ്രശ്നത്തിന്റെ തന്നെ ലളിതമായ ഒരു രൂപം നോക്കാം. ഒരു സംഖ്യ തന്നാല്‍ അതിനെ പസിലില്‍ പറയുന്ന രൂപത്തില്‍ എഴുതാന്‍ പറ്റുമോ ഇല്ലയോ എന്ന് മാത്രമാണ് ചോദ്യമെങ്കിലോ? ചില ചെറിയ സംഖ്യകളുടെ കാര്യത്തില്‍ ഈ പുതിയ ചോദ്യത്തിനുള്ള ഉത്തരം ഇങ്ങനെയാണ്:
ഒരു സംഖ്യ കിട്ടിയാല്‍ ഈ ഉത്തരം തരുന്ന ഏകദം എങ്ങനെ എഴുതാം എന്ന് മാത്രം ഇനി ആലോചിക്കാം. ക്രിയകളുടെ ശ്രേണി വേണമെന്നില്ല, True അല്ലെങ്കില്‍ False എന്നത് മാത്രം ഉത്തരമായി മതി എന്നത് കുറച്ചൊരു ആശ്വാസമല്ലേ?
ഈ "ചെറിയ" പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം ശരിയാക്കിയാല്‍ പിന്നെ അതുപയോഗിച്ച് പസിലിനുള്ള ഉത്തരം കണ്ടുപിടിക്കുന്ന കാര്യം ആലോചിക്കാം.
ഈ രീതിയില്‍ ആലോചിച്ച് ഈ പസിലിന്റെ ഉത്തരം കണ്ടുപിടിച്ചത് ഇവിടെ.
1. പ്രോഗ്രാമിന്റെ ആശയം തുടക്കത്തില്‍ കമന്റായി കൊടുത്തിട്ടുണ്ട്.
2. findSequence1() എന്ന ഏകദം True അല്ലെങ്കില്‍ False എന്ന് മാത്രം ഉത്തരം തരുന്നു.
3. findSequence2() എന്ന ഏകദം പസിലിന്റെ ഉത്തരം — ക്രിയകളുടെ ശ്രേണി — തരുന്നു.
4. പ്രോഗ്രാമില്‍ ചെറിയ ചെറിയ "സഹായക ഏകദങ്ങള്‍" എഴുതി ഉപയോഗപ്പെടുത്തിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക. "പിന്നത്തേയ്ക്ക് മാറ്റിവയ്ക്കല്‍" എന്ന വിദ്യയുടെ മറ്റൊരു ഉദാഹരണമാണ് ഇത്.
5. ഇതിലെ എല്ലാ ഏകദങ്ങളും പര്യാവര്‍ത്തന രീതിയിലാണ് (recursion) എഴുതിയിരിക്കുന്നത്. ഇതിലെ ചെറിയ ചെറിയ ഏകദങ്ങള്‍ എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നതെന്ന് നോക്കുന്നത് പര്യാവര്‍ത്തനം എന്താണെന്ന് മനസ്സിലാകാന്‍ സഹായിക്കും.
Krish January 29, 2012 at 10:19 PM
Your approach of working backwards from the given number towards 1 instead of going from 1 towards the number is very nice and makes the program super fast.
Using your approach I have rewritten the above program as given below.
$\qquad\qquad$if start < 1:
$\qquad\qquad$if start == 1:
$\qquad\qquad\qquad$return history % "1"
$\qquad\qquad$if start % 3 == 0:
$\qquad\qquad\qquad$return (find( start/3, history % "(%s * 3)") or find(start - 5, history % "(%s + 5)"))
$\qquad\qquad\qquad$return find(start - 5, history % "(%s + 5)")
if __name__ == '__main__' :
$\qquad\qquad\qquad$'No sequence in terms of 5 and 3 for $\qquad\qquad\qquad$%d.' % input_num)
I have not used the functions 'addfives' or 'multiplythrees' because I find that these are the ones that cause the maximum recursion depth to be exceeded and not the recursion in the main logic, that is, the recursion in the main function findSequence2. You have probably used them to give simple examples of recursion to the learners. Instead I have used the formatting operator, %, to build the operation sequence string from the back to the front. You have not yet introduced formatting of strings and so I will not talk about it.
To illustrate what I mean, running the above program, without changing the default recursion limit, for as large a number as 95070101011379134713929, that is a 23 digit number, almost instantly produced the result:
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((1 + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) * 3) + 5) * 3) + 5) * 3) + 5) + 5) * 3) * 3) + 5) * 3) + 5) * 3) * 3) + 5) * 3) * 3) + 5) + 5) * 3) * 3) + 5) * 3) * 3) * 3) + 5) + 5) * 3) + 5) * 3) * 3) + 5) * 3) * 3) + 5) + 5) * 3) * 3) + 5) + 5) * 3) + 5) * 3) * 3) * 3) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) * 3) * 3) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) * 3) + 5) * 3) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) * 3) + 5)
To verify this, I passed the above string to eval() in the python prompt:
>>> eval('((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((1 + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) * 3) + 5) * 3) + 5) * 3) + 5) + 5) * 3) * 3) + 5) * 3) + 5) * 3) * 3) + 5) * 3) * 3) + 5) + 5) * 3) * 3) + 5) * 3) * 3) * 3) + 5) + 5) * 3) + 5) * 3) * 3) + 5) * 3) * 3) + 5) + 5) * 3) * 3) + 5) + 5) * 3) + 5) * 3) * 3) * 3) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) * 3) * 3) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) * 3) + 5) * 3) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) + 5) * 3) + 5) * 3) + 5)')
This was amazing and great fun.
Actually your approach of working backwards produces almost instantaneous results with the above program even for much larger numbers such as 950701010113791347139291234712113112311918218.
But since eval() does not work for such large strings as the output for the above, I cannot easily verify the output.
Beyond 22, it appears that only multiples of 5 cannot be written in this manner. So if you try the above program on a multiple of 5 the recursion depth will be exceeded.
Krish January 30, 2012 at 12:42 AM
To verify the result of the program, I had used the built-in 'eval' function that evaluates a mathematical expression in the form of a string.
But if you have too many brackets in your expression, eval has a problem and gives an error.
Using Mr. Philips approach, I wrote an iterative version of the program where I have more control of the brackets and therefore has fewer brackets in the output. This program therefore allows me to use 'eval' to verify the output of the program for a number with as many as 70 digits.
This is fascinating and it is all because of the ability of python to handle arbitrarily large integers.
ഫിലിപ്പ് January 31, 2012 at 8:22 PM
അന്പതാമത്തെ ചോദ്യത്തിന് ടീച്ചറുടെ ഉത്തരം മറ്റൊരു രീതിയില്‍ എഴുതിയിരിക്കുന്നത് നോക്കൂ. പ്രോഗ്രാം പ്രവര്‍ത്തിക്കാനെടുക്കുന്ന സമയത്തില്‍ കാര്യമായ വ്യത്യാസം വരുന്നത് എന്തുകൊണ്ടാണെന്ന് നോക്കാമോ?
ഫിലിപ്പ് February 1, 2012 at 1:12 PM
മുപ്പത്തേഴാം ചോദ്യത്തില്‍ തന്നിരിക്കുന്ന "ക്ളൂ" ഉപയോഗിച്ചാല്‍ വളരെ വലിയ അഭാജ്യങ്ങളെ കണ്ടുപിടിക്കാതെ കഴിക്കാം. ആകെ പതിനൊന്ന് അഭാജ്യങ്ങള്‍ക്കാണ് ഈ ഗുണങ്ങളൊക്കെയുള്ളതെന്ന് ചോദ്യത്തില്‍ പറഞ്ഞിട്ടുണ്ടല്ലോ? ഇതാണ് ക്ളൂ. ഇത്തരത്തിലുള്ള പതിനൊന്നെണ്ണം കാണുന്നതുവരെ പുതിയ അഭാജ്യങ്ങളെ കണ്ടുപിടിച്ചാല്‍ മതി. അരിപ്പയുടെ തത്വം ഉപയോഗിച്ചാല്‍ ഇത് വളരെ വേഗം ചെയ്യാനാകും.
ഒരു സ്ട്രിംഗിന്റെ എല്ലാ കഷണങ്ങളെയും കണ്ടുപിടിക്കാന്‍ ടീച്ചര്‍ ഉപയോഗിച്ച [i:]-ക്ക് പുറമേ [:j] കൂടി ഉപയോഗിക്കാം.
ഇങ്ങനെ എഴുതിയ പ്രോഗ്രാം ഇവിടെ.
ഫിലിപ്പ് February 3, 2012 at 10:47 AM
നാല്‍പ്പത്തഞ്ചാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാമില്‍ പിശകുണ്ട്. ഇതില്‍ found എന്ന ബൂളിയൻ ചരത്തിന്റെ വില എപ്പോഴും True ആണെന്നത് ശ്രദ്ധിക്കുക. ഈ ചരം if found എന്നയിടത്ത് ഉപയോഗിക്കുന്നുമുണ്ട്. എപ്പോഴും True മാത്രം ആയിരിക്കുന്ന ചരം True ആണോ എന്ന ചോദ്യം അധികപ്പറ്റല്ലേ? ഈ ചരത്തെക്കൊണ്ട് പ്രോഗ്രാമിന് പ്രയോജനമൊന്നുമില്ല. p, t എന്നീ ചരങ്ങളുടെ റേഞ്ചുകൾ നന്നേ വലുതായതുകൊണ്ടു മാത്രമാണ് പ്രോഗ്രാം ഉത്തരത്തിലേക്ക് എത്തിയത്.
കൃഷ് പറഞ്ഞ ആശയം കുറച്ചുകൂടി വ്യക്തമാക്കിയാൽ നമുക്ക് രണ്ടുകാര്യങ്ങൾ മനസ്സിലാകും :
1. $x = P_n$ എന്നത് ഒരു പഞ്ചഭുജ സംഖ്യയാണെങ്കിൽ n-ന് $\lfloor \sqrt{2x/3}\rfloor$ എന്ന ഒരേ ഒരു വില മാത്രമേ ഉണ്ടാകൂ.
2. $x = H_n$ എന്നത് ഒരു ഷഡ്ഭുജ സംഖ്യയാണെങ്കിൽ n-ന് $\lfloor \sqrt{x/2}\rfloor$ എന്ന ഒരേ ഒരു വില മാത്രമേ ഉണ്ടാകൂ.
ഇക്കാര്യങ്ങൾ ഉപയോഗിച്ചാൽ പ്രോഗ്രാം കുറേക്കൂടി ലളിതവും — ചോദ്യത്തിലെ വിവരണത്തോട് അടുത്തുനിൽക്കുന്നതും — വേഗത്തിലുള്ളതുമാക്കാം. ഇങ്ങനെ എഴുതിയ പ്രോഗ്രാം ഇവിടെ.
Krish February 3, 2012 at 11:52 AM
An attempt to make the iterative version more readable/understandable, here.
ഫിലിപ്പ് February 5, 2012 at 11:33 AM
C++-നെക്കാള്‍ തുടക്കക്കാര്‍ക്ക് പഠിക്കാന്‍ — പ്രത്യേകിച്ച് തന്നെത്താനെ പഠിക്കാന്‍ — എളുപ്പം പൈത്തണ്‍ തന്നെയാണ്. താങ്കളുടെ പഠനത്തെ സഹായിക്കാന്‍ ഒരു വിദ്യ പറയാം:
1. പ്രോഗ്രാമുകള്‍ മൊബൈല്‍ ഫോണില്‍ എഴുതുന്നതിന് പകരം കടലാസില്‍ എഴുതുക.
2. ചെറിയ സംശയങ്ങള്‍ (ഉദാ: വ്യാകരണം ശരിയാണോ എന്നൊക്കെ) മാറ്റാന്‍ ഷെല്‍ ഉപയോഗിക്കുക.
3. കടലാസിലെ പ്രോഗ്രാം ശരിയായി എന്ന് തിരിച്ചും മറിച്ചും ആലോചിച്ച് ഉറപ്പുവന്നതിന് ശേഷം മാത്രം അത് IDE-ല്‍ ടൈപ്പു ചെയ്ത് പരീക്ഷിക്കുക.
4. ആദ്യതവണ IDE-ല്‍ ടൈപ്പ് ചെയ്ത് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുന്പോള്‍ത്തന്നെ പ്രോഗ്രാം ശരിയായി പ്രവര്‍ത്തിക്കണം എന്നതാകണം ലക്ഷ്യം. ഇത് ശരിയാകാന്‍ കടലാസിലെ പ്രോഗ്രാം എത്രതവണ തിരുത്തുന്നു എന്നത് ഗൌനിക്കരുത് : എത്രയായാലും കുഴപ്പമില്ല.
ഇങ്ങനെ ചെയ്യാന്‍ ആദ്യം കുറച്ച് ബുദ്ധിമുട്ട് തോന്നാമെങ്കിലും ഏറ്റവും വേഗത്തില്‍ ശരിയായ പ്രോഗ്രാമിലേക്ക് എത്താനുള്ള എളുപ്പവഴിയാണ് ഇത്. പല തവണ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ച്, ഓരോ തവണയും കാണുന്ന തെറ്റുകളെ തിരുത്തി മുന്പോട്ടുപോകുന്നതിനെക്കാള്‍ വളരെയേറെ കാര്യക്ഷമമാണ് ഈ രീതി.
(ഇത് കരജീവികള്‍ക്കും ബാധകമായ കാര്യമാണ്!)
ഫിലിപ്പ് February 8, 2012 at 2:26 PM
1. പൈത്തണ്‍ prompt-ല്‍ സ്വതവേ ഒരു eval() ഏകദം അടങ്ങിയിട്ടുണ്ട്. prompt-ന്റെ ശാസ്ത്രീയനാമം തന്നെ REPL അഥവാ read-eval-print loop എന്നാണ്. അതുകൊണ്ട് prompt-ല്‍ വ്യഞ്ജകങ്ങളുടെ വില കാണാനായി eval() എന്ന് പറയേണ്ടതില്ല; വ്യഞ്ജകം മാത്രം കൊടുത്താല്‍ മതി.
2. eval() എന്നത് ഒരുവിധപ്പെട്ട ഏതുതരം പൈത്തണ്‍ വ്യഞ്ജകത്തേയും സ്വീകരിച്ച് അതിന്റെ വില കണ്ടുപിടിക്കാന്‍ കഴിവുള്ള ഏകദമാണല്ലോ? ഈ സങ്കീര്‍ണ്ണത കാരണമാവണം അല്പം വലിയ വ്യഞ്ജകങ്ങള്‍ കൈകാര്യം ചെയ്യാന്‍ അതിന് കഴിയാത്തത്. നമ്മുടെ പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് — ഇത് വളരെ പരിമിതപ്പെട്ട തരത്തിലുള്ള ഗണിത വ്യഞ്ജകങ്ങള്‍ (expressions) ആണല്ലോ? — മാത്രം സ്വീകരിച്ച് അവയുടെ വില കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതിയാലോ? ഇത് നല്ലയൊരു പ്രോഗ്രാമിംഗ് പ്രവര്‍ത്തനമാകുമെന്ന് തോന്നുന്നു. കൂടാതെ നമ്മുടെ പ്രോഗ്രാം ശരിയായ ഉത്തരമാണോ തന്നതെന്ന് നോക്കുകയും ചെയ്യാം.
3. 22-ന് മേലെ അഞ്ചിന്റെ ഗുണിതങ്ങളൊന്നും ഈ രീതിയില്‍ എഴുതാന്‍ കഴിയില്ല എന്ന് തെളിയിക്കാന്‍ പറ്റിയാല്‍ ഇങ്ങനെയുള്ള സംഖ്യകളെ എളുപ്പത്തില്‍ കൈകാര്യം ചെയ്യുന്ന രീതിയില്‍ പ്രോഗ്രാമില്‍ മാറ്റം വരുത്താം.
Krish February 8, 2012 at 6:47 PM
താങ്കള് പറഞ്ഞതു് വളരെ ശരിയാണു്. :)
evalന്റെ ആവശ്യമേയില്ല. ഒരു expression നേരിട്ടു കൊടുക്കാമെന്നുളള കാര്യം, എന്തോ, എന്റെ തലയില്‍ ഉദിച്ചില്ല.
താങ്കള് 2ല്‍ പറഞ്ഞതു് പോലെ ഒരു program എഴുതാന്‍ ആലോചനയുണ്ടു്.
Jythonല്‍ വളരെ വലിയ expressions evaluate ചെയ്യാന്‍ പറ്റുന്നുണ്ടു്.
java based ആയതു കൊണ്ടായിരിക്കണം. For example, I could verify the result of running my program on a number with about 130 digits.
bhama February 9, 2012 at 2:02 PM
പ്രോഗ്രാമില്‍ വരുത്തേണ്ട മാറ്റങ്ങള്‍ വിശദീകരിച്ചു തന്നതിനു നന്ദി. ഇറാറ്റോസ്തനീസിന്റെ അരിപ്പ ഉപയോഗിക്കുന്നതിനുള്ള പ്രോഗ്രാം എഴുതാന്‍ ഇപ്പോഴാണ് മനസ്സിലായത്. ഇപ്പോള്‍ വരുത്തിയ തെറ്റുകളെല്ലാം തിരുത്തി വീണ്ടും പ്രോഗ്രാം എഴുതി നോക്കട്ടെ
Krish February 15, 2012 at 12:35 AM
This series of lessons was started in the middle of 2010, almost 2 years ago.
Perhaps we can go faster, finish the basics, and go onto more interesting things using Python such as linux desktop programming using PyGTK.
ഫിലിപ്പ് February 15, 2012 at 2:16 PM
ഈ പാഠങ്ങള്‍ ഒരു "പ്രോഗ്രാമിംഗ് സാക്ഷരതാ പരിപാടി" യായാണ് വിഭാവന ചെയ്തത്. എഴുത്തും വായനയും കൂട്ടലും കുറയ്ക്കലും (ഡ്രൈവിംഗും നീന്തലും!) പോലെ എല്ലാവര്‍ക്കും പഠിച്ചെടുക്കാവുന്ന കാര്യമായിരുന്നിട്ടും ഇത് മിക്കവര്‍ക്കും അറിഞ്ഞുകൂടാത്ത അവസ്ഥയില്‍ മാറ്റം വരുത്താനുള്ള ഒരു ചെറിയ ശ്രമം. അതുകൊണ്ട് പ്രോഗ്രാമിംഗിന്റെ ബാലപാഠങ്ങള്‍ മാത്രമേ ഇതില്‍ ഉള്‍പ്പെടുത്താന്‍ ഉദ്ദേശിക്കുന്നുള്ളൂ.
ഇതിന് അപ്പുറത്തേക്ക് പോകാന്‍ (ആഗ്രഹക്കുറവ് കൂടാതെ) മറ്റൊരു തടസ്സമുള്ളത് എന്റെ പരിമിതികളാണ്. പൈത്തണ്‍ പാഠങ്ങള്‍ മാറ്റിനിര്‍ത്തിയാല്‍ ഞാന്‍ നമ്മുടെ നാട്ടിലെ ഒരു സ്കൂള്‍ അധ്യാപകന്‍ സാധാരണഗതിയില്‍ എഴുതുന്നയത്ര പ്രോഗ്രാമുകളേ എഴുതാറുള്ളൂ -- ഒട്ടും തന്നെയില്ല എന്ന് ചുരുക്കം. ജോലിക്കോ മറ്റാവശ്യത്തിനായോ പ്രോഗ്രാമുകള്‍ എഴുതേണ്ട കാര്യം എനിക്കില്ല. ഇതൊക്കെക്കൊണ്ട് എന്റെ പ്രോഗ്രാമിംഗ് അറിവ് വളരെ പരിമിതമാണ്. താങ്കള്‍ സൂചിപ്പിച്ച PyGTK യോ desktop programming ഓ എനിക്ക് ഒട്ടും അറിയില്ല. പൈത്തണ്‍ തന്നെ, പാഠങ്ങള്‍ക്ക് ആവശ്യമുള്ളയത്ര മാത്രം പാഠം എഴുതുന്ന സമയത്ത് പഠിക്കുക എന്നതാണ് ഇതുവരെ ചെയ്തുവന്നത്. ഉദാഹരണത്തിന്, ഏകദങ്ങളുടെ പാഠം എഴുതിത്തുടങ്ങുന്നതുവരെ പൈത്തണിലെ ഏകദങ്ങളുടെ വ്യാകരണം എനിക്ക് ശരിക്കറിഞ്ഞുകൂടായിരുന്നു. ഇത് പാഠങ്ങള്‍ ശ്രദ്ധിച്ചാല്‍ മനസ്സിലാകും : ഇതേ പാഠങ്ങള്‍ പൈത്തണില്‍നിന്ന് (ഉദാ:) റൂബിയിലേക്ക് മൊഴിമാറ്റം ചെയ്യാന്‍ എത്രയെളുപ്പമാണ് എന്നത് ശ്രദ്ധിക്കുക.
ഉപരിപഠനത്തിനായുള്ള പാഠങ്ങള്‍, സംഭവം ശരിക്ക് അറിയാവുന്ന ആളുകള്‍ എഴുതുന്നതാവില്ലേ നല്ലത്?
priyadarsan February 27, 2012 at 3:25 PM
matplotlib is a python 2D plotting library used in python scripts.
To enable this module, we install the package python-matplotlib using apt-get or synaptic. After installation, you can try the following plotting to draw y=x**2 and y=sin(x)
from pylab import *
x = linspace(-10, 10,200)
You will get examples and tutorilas from the following sites
ഫിലിപ്പ് February 28, 2012 at 9:35 PM
ഗണിത ഫലനങ്ങളുടെ (functions) ഗ്രാഫുകളും മറ്റ് ചിത്രങ്ങളും പൈത്തൺ ഉപയോഗിച്ച് പ്രോഗ്രാമികമായി വരയ്ക്കാൻ സഹായിക്കുന്ന matplotlib-നെ പരിചയപ്പെടുത്തിയതിന് നന്ദി.
Unnikrishnan,Valanchery March 17, 2012 at 10:40 PM
Hai Philip Sir, This is a game I made using python .I designed in Wxglade a gui implemented for next year Xth Std IT
2 Addition I have to make in this
1. put random nos up to 16 on buttons
2.Inform player if the game finished
How can i get random nos in python?
code of the game is here
u may install wxGlade
ഫിലിപ്പ് March 18, 2012 at 10:01 AM
പ്രോഗ്രാം പങ്കുവച്ചതിന് നന്ദി. എന്റെ ഇപ്പോഴത്തെ കംപ്യൂട്ടറിൽ wxGlade ഇല്ലാത്തതുകൊണ്ട് പരീക്ഷിച്ചുനോക്കിയില്ല.
പൈത്തണിൽ റാന്‍ഡം സംഖ്യകള്‍ കിട്ടാന്‍ random എന്ന മൊഡ്യൂൾ ഉപയോഗിക്കാം. സാറിനുവേണ്ട സംഖ്യകൾ കിട്ടാൻ ഇങ്ങനെ ചെയ്താൽ മതി:
randint എന്ന ഏകദം ഓരോതവണ 1, 16 എന്നിവ വാക്യങ്ങളായി കൊടുത്ത് പ്രയോഗിക്കുന്പോഴും 1 മുതൽ 16 വരെയുള്ള ഓരോ സംഖ്യ (റാൻഡമായി) കിട്ടും.
ഈ മൊഡ്യൂളിനെപ്പറ്റി കൂടുതൽ വിവരങ്ങൾ ഇവിടെ .
ജയരാജ്‌മുരുക്കുംപുഴ May 3, 2012 at 2:24 PM
Unnikrishnan,Valanchery June 8, 2012 at 7:49 PM
ഭാമടീച്ചര്‍ ,് ഫിലിപ്പ് സാര്‍ ,,നന്ദകുമാറിന്റെ python graphic ടൂട്ടോറിയല്‍ ആരംഭിച്ചിരിക്കുന്നു
Nandakumar June 9, 2012 at 4:11 PM
This comment has been removed by the author.
ഫിലിപ്പ് June 9, 2012 at 5:42 PM
പൈത്തൺ പാഠങ്ങൾ തുടങ്ങിയ കാലം മുതലേ പൈത്തണിൽ ഗ്രാഫിക്സ് പ്രോഗ്രാമിംഗ് ചെയ്യാൻ പഠിപ്പിക്കുമോ എന്ന് പലരും കമന്റായി ചോദിച്ചിരുന്നു. ഗ്രാഫിക്സ് പ്രോഗ്രാമിംഗ് എനിക്ക് വശമില്ലാത്തതുകാരണം "ഇല്ല" എന്ന് പറയേണ്ടിവന്നു. നന്ദകുമാറിന്റെ ഗ്രാഫിക്സ് പാഠങ്ങൾ ഏറെപ്പേർക്ക് സഹായകമാകുമെന്ന് നമുക്ക് പ്രതീക്ഷിക്കാം. എല്ലാവിധ ഭാവുകങ്ങളും നേരുന്നു.
Unnikrishnan,Valanchery July 15, 2012 at 10:56 AM
ഞാനുണ്ടാക്കിയ ടിക് ടാക് ടോ എന്ന് ഗെയിം
ഇതിന് ചെറുതായ ഒരു നിര്‍മിത ബുദ്ധിയുണ്ട്
താങ്കളുടെ പൈതണ്‍ ക്ലാസ്സും നന്ദകുമാറിന്റെ ജിട്ടിക്കെ ക്ലാസ്സും
ഇതിന്റെ നിര്‍മാണത്തിന് സഹായിചിട്ടുണ്ട്, അതിന്റെ നന്ദി രണ്ട് പേരെയും അറിയിക്കട്ടെ
ഫിലിപ്പ് July 16, 2012 at 9:28 AM
ഗെയിം നന്നായിട്ടുണ്ട്. ബട്ടണുകൾക്ക് നടുവിലുള്ള x, o എന്നിവ കുറച്ചുകൂടി വലുതാക്കിയാൽ നന്നായിരിക്കുമെന്ന് തോന്നുന്നു. അക്ഷരങ്ങൾതന്നെ വലിയ ഫോണ്ട് ആക്കുകയോ. അല്ലെങ്കിൽ അക്ഷരങ്ങൾക്കു പകരം ചിത്രങ്ങൾ—നല്ല വ്യത്യാസമുള്ള ഏതെങ്കിലും രണ്ട് കാർട്ടൂൺ ചിത്രങ്ങളോ മറ്റോ മതിയാകുമല്ലോ—ഉപയോഗിച്ചാൽ കൂടുതൽ നന്നായിരിക്കുമെന്ന് തോന്നുന്നു.
സാറിന് അഭിനന്ദനങ്ങളോടൊപ്പം രണ്ട് "ലിങ്ക് നറുമലരുകളും":
1. പുതുതായി ഗെയിം പ്രോഗ്രാമിംഗ് തുടങ്ങുന്ന ഒരാൾക്ക് എഴുതിപ്പഠിക്കാൻ എളുപ്പമുള്ള ഗെയിമുകളെപ്പറ്റി ഇവിടെ കാണാം.
2. ഗെയിമുകൾ എഴുതി പൈത്തൺ പഠിക്കാൻ സഹായിക്കുന്ന രണ്ട് പുസ്തകങ്ങൾ ഇവിടെ. (ഇവ രണ്ടും ഞാൻ വായിച്ചിട്ടില്ല!)
Krish July 18, 2012 at 3:17 AM
This comment has been removed by the author.
Krish July 18, 2012 at 3:22 AM
"മിക്കവാറും തോല്പിക്കാനവില്ല സമനിലയാക്കാമെന്നലതെ ..."
does not seem to be true, if Player X plays first. Here are the steps:
o | o |
o | o | x
o | o | x
| x | o
o | o | x
| x | o
x |  | x
Unnikrishnan,Valanchery July 18, 2012 at 8:36 AM
This comment has been removed by the author.
Unnikrishnan,Valanchery July 18, 2012 at 9:11 AM
വളരെ നന്ദി ഫിലിപ്പ് സാര്‍,
താങ്കള്‍ നല്കിയതുപോലുള്ള പുസ്തകങ്ങള്‍ ഞാന്‍
അന്വേഷിച്ചുകൊണ്ടിരിക്കുകയായിരുന്നു.ശരിയായി പ്രവര്‍ത്തനം ആരംഭിച്ചതിന് ശേഷം ഭംഗിയാക്കമെന്നാണ് കരുതുന്നത്
ഇങ്ങനെ ഒരു സാധ്യത പറഞ്ഞുതന്നതിന് വളരെ നന്ദി ക്രിഷ് സാര്‍,O ക്കും ഇതു പോലൊരു സാധ്യ്തയുണ്ട്
center=O, 2,4,6or 8 button=X തുടര്‍ന്ന് കളിച്ചാല്‍ O Xനെ തോല്പിക്കും
ശരിയായ ഗെയിം പ്രോഗ്രാമിങ് ഇങനെയല്ല. ഇതില്‍ ഞാന്‍ ചില ഫങ്ഷനുകള്‍
നല്കി അത് ചെക്ക് ചെയ്യുനേയൊള്ളു അപ്പോള്‍ എന്റെ മുന്‍വിധികളും കളിരീതികളും അതില്‍ വരും
ശരിയായ രീതി അതിന്റെ ബ്രയിന്‍ (ഒരു ലിസ്റ്റില്‍) എല്ലാ സാധ്യതകളും കളിച്ചുനോക്കണം.ജയത്തിന് ഒരു പോയിന്റും തോല് വിക്ക് ഒരു മൈനസ്സ് പോയിന്റും നല്കുക അതിനുശേഷംഇവ രണ്ടുകൂടി കൂട്ടി നോക്കി ഏതാണ് കൂടുതല്‍ സ്കോര്‍ എങ്കില്‍ അത് കളിക്കുക അത്തരത്തിലൊന്നിന്റെ പണിയിലാണ് ഞാന്‍ പക്ഷെ gtk യില്‍ പൈതണ്‍ ലിസ്റ്റ് വര്‍ക്ക് ചെയ്യുന്നില്ല പണിയുണ്ട് ഫിലിപ്പ് സാറിന്റെ ക്ലാസിലെ പാഠം പ്രയോഗിക്കും
ഫിലിപ്പ് July 18, 2012 at 9:51 AM
കമ്പ്യൂട്ടറിന് കുറ്റമറ്റ രീതിയിൽ കളിക്കാൻ പറ്റുന്ന കളികളിലൊന്നാണ് റ്റിക്-റ്റാക്-റ്റോ. (ചെസ്സും തത്വത്തിൽ ഇങ്ങനെയാണെങ്കിലും പ്രയോഗത്തിൽ അല്ല.) രണ്ട് കളിക്കാരും കൃത്യമായ നീക്കങ്ങൾ മാത്രം നടത്തിയാൽ സമനിലയിലേ ഇതവസാനിക്കൂ. ഈ കളിയുടെ ഓരോ ഘട്ടത്തിലും അടുത്ത നീക്കം കണ്ടുപിടിക്കാനുള്ള മാർഗം വിക്കിപ്പീഡിയയിലുണ്ട്. എട്ട് വെവ്വേറെ വിഭക്തികളേ (cases) പരിഗണിക്കേണ്ടൂ. ഇത് പ്രോഗ്രാം ചെയ്യൽ എളുപ്പമാണല്ലോ.
Unnikrishnan,Valanchery July 18, 2012 at 9:58 PM
ഫിലിപ്പ് സാർ, ഞാൻ വിക്കി പീഡിയയിൽ ടിക് ടാക് ടോ യെ പറ്റി നോക്കിയിരുന്നില്ല,എങ്കിൽ കൃഷ് സാർ സൂചിപ്പിച്ച കുഴപ്പം ഉണ്ടാവില്ലായിരുന്നു.അതിൽ പറയുന്ന ഒരു case capture corner ആണ് ഞാൻ അതിനുപകരം ഞാൻ കൊടുത്തത് side ആയിരുന്നു അതാണുകാരണം.ഒരു ai function ഉണ്ടായിരുന്നെങ്കിൽ ഈ പ്രശ്നം ഉണ്ടാവില്ലയിരുന്നു.
വിക്കിപീഡിയയിൽ വായിച്ചപ്പോഴാണ് ടിക് ടാക് ടോ വിചാരിച്ചതിനെക്കാളും സംഭവമാണെന്ന് മൻസ്സിലായത്
Unnikrishnan,Valanchery July 18, 2012 at 10:03 PM
മാറ്റിയ Tic Tac Toe
ഫിലിപ്പ് July 24, 2012 at 9:42 AM
പുതിയ ഗെയിം ഇന്നാണ് കളിച്ചുനോക്കിയത്. നന്നായിട്ടുണ്ട്.
bhama August 1, 2012 at 7:19 PM
Tic Tac Toe കളിച്ചുനോക്കി. നന്നായിട്ടുണ്ട്
നന്ദകുമാറിന്റെ python graphics പാഠങ്ങള്‍ കണ്ടിരുന്നു. പഠിക്കണം.
Unnikrishnan,Valanchery August 1, 2012 at 10:30 PM
This comment has been removed by the author.
Unnikrishnan,Valanchery August 1, 2012 at 10:32 PM
അഭിപ്രായം പങ്കുവെച്ചതിന് നന്ദി ഫിലിപ്പ് സാർ ,ഭാമടീച്ചർ
pygtk തീർച്ചയായും നോക്കണം ടീച്ചർക്കത് വേഗം ദഹിക്കും
Krish August 22, 2012 at 11:24 PM
Here is a modern pygtk tutorial.
Apparently, the older ways of doing gtk programming using python is outdated and people just beginning to learn gui programming in python are advised to follow the gtk+ 3 version given above.
Krish November 11, 2012 at 1:24 AM
മാത്സ് ബ്ളോഗില്‍ രണ്ടു് പോസ്റ്റുകള്ക്കു മുമ്പ് പത്താം ക്ലാസിലെ ഫിസിക്സ് വിഷയവുമായി beatsനെ പറ്റി പറയുകയുണ്ടായി.
Beatsന്റെ ഒരു python program (with sound ) ഞാനുണ്ടാക്കിയിട്ടുണ്ടു്.
ഇതൊരു Gtk+ 3 program ആണു്. ഇവിടെ download ചെയ്യാം.
Download packageന്റെ READMEല്‍ പറഞ്ഞതുപോലെ, ഇതു് റണ്‍ ചെയ്യുന്നതിനു മുമ്പു് pyaudio യും numpy യും install ചെയ്യണം.
റണ്‍ ചെയ്തു് work ചെയ്യുന്നുണ്ടോ ഇല്ലയോ എന്നു പറഞ്ഞാല്‍ നന്നായിരിന്നു. Thanks.
Sreenilayam November 11, 2012 at 9:26 AM
ഞാന്‍ ഉബുണ്ടു 10.04 ആണ് ഉപയോഗിക്കുന്നത്. Read Me ഫയലില്‍ പറഞ്ഞിരിക്കുന്ന സൈറ്റില്‍ PyAudio v0.2.7 വിന്‍ഡോസിനു മാത്രമേ ഉള്ളു. തൊട്ടു താഴെയുള്ള Debian/Ubuntu നില്‍ നിന്നും പാക്കേജ് മാനേജര്‍ വഴി ഇന്‍സ്റ്റാള്‍ ചെയ്യാന്‍ നോക്കിയപ്പോള്‍ ഡിപ്പന്‍ഡന്‍സി പ്രോബ്ളം. എന്തായാലും സമാധാനമായിരുന്നു ചെയ്തു നോക്കണം.
Krish November 11, 2012 at 1:24 PM
Mint 13, Arch Linux ലുമാണു് ഞാന്‍ നോക്കിയതു്. ഇവയില്‍ ഈ പ്രോഗ്രാം പ്രവര്ത്തിക്കുന്നുണ്ടു്.
beatsapplet.py ആണു് റണ്‍ ചെയ്യേണ്ടതു്.
ഉബുണ്ടു 10.04ല്‍ ഗ്നോം 2 ആണോ ഗ്നോം 3 ആണോ എന്നറിയില്ല. അതുകൊണ്ടുതന്നെ Gtk+ 3 programs റണ്‍ ചെയ്യുമോ എന്നറിയില്ല. ഇതിന്റെ ഒരു Gtk2 version ഉണ്ടാക്കാന്‍ ശ്രമിക്കാം. പക്ഷെ pyaudio എന്തുകൊണ്ടാണു് install ചെയ്യാന്‍ പറ്റാത്തതെന്നു് എനിക്കു മനസ്സിലാവുന്നില്ല.
ഫിലിപ്പ് November 11, 2012 at 6:00 PM
ബീറ്റ് പ്രോഗ്രാമിന് നന്ദി. എന്റെ കന്പ്യൂട്ടറിൽ GTK+3 പ്രവർത്തിപ്പിക്കാൻ നിർവാഹമില്ലാത്തതുകൊണ്ട് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ കഴിഞ്ഞില്ല. അധ്യാപകരോ വിദ്യാർത്ഥികളോ ഇത് പ്രവർത്തിപ്പിച്ച് നോക്കി അഭിപ്രായം പറഞ്ഞെങ്കിൽ നന്നായിരുന്നു.
Krish November 11, 2012 at 8:27 PM
ഞാന്‍ ഇപ്പോള്‍ അറിഞ്ഞടത്തോളം ഉബുണ്ടു 10.04 Gtk-2 based ആണു്. ഉബുണ്ടു 12.04 Gtk-3 based ആണു്.
അതുകോണ്ടു് ഞാന്‍ ഇപ്പോള്‍ രണ്ടിനും( Gtk2, Gtk3) പ്രോഗ്രാമുകള്‍ download packageല്‍ ചേര്ത്തിട്ടുണ്ടു് : beatsapplet.py ( for Gtk3) beatsapplet_gtk2.py( for Gtk2).
pyaudio( preferably version 0.2.7), numpy install ചെയ്തതിനു ശേഷം, പ്രവര്ത്തിപ്പിക്കുവാന്‍ നോക്കുക. നന്ദി.
ഫിലിപ്പ് November 12, 2012 at 8:20 AM
പുതിയ പ്രോഗ്രാമിന് നന്ദി. beatsapplet_gtk2.py പ്രവർത്തിപ്പിക്കുന്പോൾ പ്രോഗ്രാമിന്റെ വിൻഡോ തുറന്ന് വരുന്നുണ്ട്. സ്ലൈഡറുകൾ ഉപയോഗിച്ച് തരംഗങ്ങളുടെ ആവൃത്തി മാറുന്നത് കാണാൻ (മാത്രം) കഴിയുന്നുണ്ട്. Start ബട്ടൺ അമർത്തുന്പോൾ രണ്ട് (മൂന്ന്!) തരംഗങ്ങളും വലതുവശത്തേക്ക് നീങ്ങുന്നതും കാണാം. എന്നാൽ ശബ്ദമൊന്നും കേൾക്കാനില്ല. എന്റെ കന്പ്യൂട്ടറിലെ pyAudio-യുടെ പ്രശ്നമാകാനാണ് സാധ്യത. ആകെ കിട്ടുന്ന എറർ സന്ദേശം അത്ര ഉപയോഗമുള്ളതല്ല: "Fontconfig warning: ignoring UTF-8: not a valid region tag"
ഇത് കൂടാതെ: ഒരിക്കൽ Stop അമർത്തിയാൽ അത് അമർന്നുതന്നെ ഇരിക്കുന്നു. തരംഗങ്ങൾ നീങ്ങുന്നത് നിൽക്കുമെങ്കിലും ബട്ടൺ നിവർന്ന് വരുന്നില്ല. വിൻഡോ അടയ്ക്കാനും കഴിയുന്നില്ല. Stop അമർത്തിയാൽ എല്ലാം നിശ്ചലമാകും. പിന്നെ Ctrl-C ഉപയോഗിച്ചേ പ്രോഗ്രാം നിർത്താൻ കഴിയൂ.
Krish November 12, 2012 at 12:50 PM
This comment has been removed by the author.
Krish November 12, 2012 at 2:00 PM
Information I just gathered from the home page of pyaudio:
The minimum version of python for pyaudio 0.2.7 is python 2.6.
Perhaps, Sreenilayam, this is the dependency problem that you came across when you tried to install pyaudio 0.2.7.
Krish November 12, 2012 at 5:55 PM
പ്രോഗ്രാം പ്രവര്ത്തിപ്പിച്ചു നോക്കാന്‍ ശ്രമിച്ചതിനു് നന്ദി. താന്കളുടെ pyaudio version 0.2.7 തന്നെയാണൊ? അല്ലെന്‍കില്‍ 0.2.7 install ചെയ്തു് പ്രവര്ത്തിപ്പിച്ചു നോക്കാമോ ?
താന്‍കള്‍ പറഞ്ഞതുപോലെ വേറെ errors ഒന്നും കാണിക്കത്ത്തുകൊണ്ടു് pyaudioടെ പ്രശ്നമാകാനാണു് സാധ്യത.
pyaudio യുടെ പഴയ versionsല്‍ audio backgroundല്‍ play ചെയ്യാന്‍ പറ്റില്ലായിരുന്നുവെന്നാണു് എന്റെ അറിവു്. പുതിയ versions( 0.2.7, 0.2.6)ല്‍ ഇതു് പറ്റും( using a callback mechanism).
ഫിലിപ്പ് November 12, 2012 at 10:34 PM
എന്റെ കന്പ്യൂട്ടറിലെ pyaudio പതിപ്പ് 0.2.3 ആണ്. ഇതു തന്നെയായിരിക്കണം പ്രശ്നം. നിർഭാഗ്യവശാൽ ഇത് പുതുക്കാൻ വകുപ്പില്ല.
P V Ariel December 8, 2012 at 2:34 PM
Thanks for sharing this
Master Philip I Appreciate your talent and time you spent for the
Keep Doing the Good Works
Krish November 23, 2013 at 2:33 PM
ഒരു ചങ്ങാതിയോടുകൂടി കുറച്ചു പൈത്തണ്‍ ഗ്രാഫിക്സ് പ്രോഗ്രാമിങ് പാഠങ്ങള്‍ തയ്യാറാക്കിയിട്ടുണ്ടു്. Gtk3, PyGObject എന്നിവയാണു് ലക്ഷ്യമിട്ടിരിക്കുന്നതു്, കാരണം PyGtkയുടെ വികസനം ഇപ്പോള്‍ നിറ്ത്തിവെച്ചിരിക്കുകയാണു്. GUI വിഷയങ്ങളെകാട്ടിലും ഗ്രാഫിക്സ് വിഷയങ്ങളിലാണു് ഞങ്ങള്‍ക്കു് താല്‍പ്പര്യം. ഇതുവരെ 5 പാഠങ്ങള്‍ തയ്യാറാക്കിയിട്ടുണ്ടു്.
ലിനക്സ് ഉപയോക്താക്കള്‍ക്കുള്ളതാണു് ഈ പാഠങ്ങള്‍. പാഠങ്ങള്‍ കാണുവാന്‍ Google-chrome അല്ലെങ്കില്‍ Firefox ഉപയോഗിക്കുക.
പാഠങ്ങളിലെ വിഷയങ്ങള്‍ ഞങ്ങളും പഠിച്ചുവരികയാണു്. തെറ്റുകള്‍ ഉണ്ടാവാന്‍ സാധ്യതയുണ്ടു്.
ചിലര്‍ക്കെങ്കിലും ഈ പാഠങ്ങള്‍ ഉപയോഗപ്പെട്ടാല്‍ സന്തോഷം. അഭിപ്രായങ്ങള്‍ കിട്ടിയാലും സന്തോഷം.
Krish December 4, 2013 at 3:32 AM
New tutorial: Drawing rounded rectangles in python gtk+. There will be a new tutorial every 2 weeks. Feedback welcome.
Thomas Sebastian A December 11, 2013 at 5:03 PM
Thank you very much... :)
Krish December 22, 2013 at 5:30 PM
പൈത്തണ്‍ ഗ്രാഫിക്സ് പാഠം 7:അതിവ്യാപനമില്ലാതെ നിറഞ്ഞുനില്‍ക്കുന്ന ദീര്‍ഘചതുരങ്ങള്‍. ഗ്രാഫിക്സിനോടു കൂടി key-press events എങ്ങിനെ കൈകാര്യം ചെയ്യാമെന്നും, statusbar എങ്ങിനെ ചേര്‍ക്കാമെന്നും ഇതില്‍ പറയുന്നു.
pradeek k February 15, 2014 at 11:54 AM
Hi am pradeek,I am software developer and a technical enthusiastic.I have developed applications in most of the mainstream languages,my skill includes c,c++,java,Python,Ruby,perl,php,mysql,javascript,regular expression and bash
WebTechnologies : J2EE,Rails,Django,Dancer or CGI,NodeJS,Hadoop,ASP
I started creating screen cast for these programming languages in Malayalam
Nandakumar February 15, 2014 at 2:31 PM
midhunwonders February 27, 2014 at 11:37 AM
sir one help please?
can you give a pythin programme that finds the no. of days in between two dates
Krish February 27, 2014 at 3:10 PM
date_1 = datetime.date(2014, 2, 27)
date_2 = datetime.date(2013, 12, 14)
print (date_1 - date_2).days
Krish March 21, 2014 at 4:29 PM
python graphics lesson 12: Image display with clipping
Nandakumar March 27, 2014 at 8:57 AM
പൈത്തണ്‍ നുറുങ്ങുകള്‍ ഈ യൂട്യൂബ് ചാനലില്‍ ഒരു പ്ലേലിസ്റ്റായി പ്രസിദ്ധീകരിയ്ക്കുന്നുണ്ട്:
പൈത്തണിന് പുറമെയുള്ള വിഷയങ്ങളും ചാനലിലുണ്ട്. കാണാം, സബ്സ്ക്രൈബ് ചെയ്യാം.
Krish May 3, 2014 at 3:48 AM
പൈത്തൺ വിഭാഗത്തിൽ വലുതായി ഒന്നും സംഭവിക്കുന്നില്ല, എന്നാലും ഇരിക്കട്ടെ: പൈത്തൺ ഗ്രാഫിക്സിന്റെ അടുത്ത പാഠം:
Krish August 16, 2014 at 12:00 AM
This comment has been removed by the author.
Krish August 16, 2014 at 12:06 AM
പൈത്തൺ ഗ്രാഫിക്സിലെ അടുത്ത പാഠം:
ഫലനങ്ങളുടെ ഗ്രാഫ് വരയ്ക്കാം(Plotting functions) - 1
Devadath R October 24, 2015 at 10:30 AM
ഞാന്‍ ഈ പേജ് കാണുന്നത് ഈ അടുത്താണ്. അതിനാല്‍ത്തന്നെയാണ് ഇത്തരത്തില്‍ ഒരു കമന്റ് ഇടാന്‍ വൈകിയതും. 8 മുതല്‍ 10 വരെയുള്ള ക്ലാസുകളിലെ IT പാഠപുസ്തകങ്ങള്‍ വാങ്ങിയും ഇന്റര്‍നെറ്റില്‍ പരതിയും പല പല പ്രോഗ്രാമുകള്‍ പൈത്തണില്‍ ഉണ്ടാക്കി. അങ്ങനെയിരിക്കെയാണ് ഞാന്‍ ഈ പേജ് കാണുന്നത്. ഇത്തരത്തില്‍ പ്രാഥമിക പരീശീലനം ലഭിച്ചതിനാല്‍ എനിക്ക് പൈത്തണില്‍ കൂടുതല്‍ അറിവ് നേടണമെന്നുണ്ട്. അതിനാല്‍ പൈത്തണിലെ കൂടുതല്‍ command ഉകളും അവയുടെ പ്രയോഗവും പഠിക്കണമെന്നുണ്ട്. എന്നെ സഹായിക്കണമെന്ന് അഭ്യര്‍ത്ഥിക്കുന്നു. ഞാന്‍ തന്നെ തയ്യാറാക്കിയ ഒരു ഗ്രാഫിക്സ് പ്രോഗ്രാം താഴെ നല്‍കുന്നു.മറ്റ് സുഹൃത്തുക്കള്‍ ഈ പ്രോഗ്രാം ചെയ്തുനോക്കുക.
#A figure with circles
for i in range(9):
Subscribe to: Post Comments (Atom)