Lesson 1: Introduction
പേഴ്സണല്‍ കമ്പ്യൂട്ടറുകള്‍ 1979-80 കാലഘട്ടത്തില്‍ പ്രചാരത്തില്‍
വന്നപ്പോള്‍ വിദ്യാര്‍ത്ഥികളില്‍ ഭൂരിഭാഗം പേരേയും പ്രോഗ്രാമിംഗ്
പഠിപ്പിക്കുവാന്‍ രക്ഷിതാക്കളും അധ്യാപകരും എല്ലാം തന്നെ അത്യുത്സാഹം
കാണിച്ചിരുന്നു. അങ്ങനെ ആ കാലഘട്ടത്തിന്‍ത്തന്നെ ധാരാളം കമ്പ്യൂട്ടര്‍
സ്ഥാപനങ്ങള്‍ നിലവില്‍ വരികയും ലക്ഷക്കണക്കിന് കുട്ടികള്‍ കമ്പ്യൂട്ടര്‍
പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാനതത്വങ്ങള്‍ (eg: BASIC, LOGO) പഠിക്കാന്‍
തുടങ്ങി. എന്നാല്‍ ഇവരില്‍ വിരലിലെണ്ണാവുന്ന കുറച്ചുപേര്‍ മാത്രമേ ഈ
മേഖലയില്‍ ശോഭിച്ചുള്ളൂ. പ്രോഗ്രാമിംഗ് പഠപ്പിക്കാന്‍ വേണ്ടി നിലവില്‍
വന്ന സ്ഥാപനങ്ങളില്‍ ഭൂരിഭാഗവും കമ്പ്യൂട്ടര്‍ പഠനത്തിന്റെ മറ്റ്
മേഖലകളിലേക്ക് മാറുകയും ചെയ്തു. എന്താണ് ഇങ്ങനെ സംഭവിക്കാനുണ്ടായ കാരണം
....? ഇവ മനസ്സിലാക്കാന്‍ വളരെ പ്രയാസമായിരുന്നു എന്നതു മാത്രമല്ല,
കുട്ടികളുടെ താത്പര്യങ്ങള്‍ക്കും അനുഭവങ്ങള്‍ക്കും അനുസരിച്ചുള്ള
പ്രവര്‍ത്തനങ്ങളായിരുന്നില്ല അവര്‍ക്ക് നല്കിയിരുന്നത് എന്നതായിരുന്നു
ഒരു പ്രധാന കാരണം.
Capturing student interest in computer programming at the start of their programming courses is essential for the success of becoming a great Programmer.
കമ്പ്യൂട്ടര്‍ പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള പൈത്തണ്‍ ഭാഷ (Python) പഠിക്കുന്നതിനുമുമ്പായി നമുക്ക് അമേരിക്കയിലുള്ള MIT (Massachusetts Institute of Technology) യിലെ Lifelong Kindergarten Research Group വികസിപ്പിച്ചെടുത്ത Scratch (സ്ക്രാച്ച്) സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ചുകൊണ്ട് ചില രസകരമായ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്യാം.
Scratch is developed to teach programming concepts to students as their first exposure to computer programming.
Animation, Games, Interactive Stories തുടങ്ങിയവ തയ്യാറാക്കാന്‍ സഹായിക്കുന്ന ലളിതമായ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് Scratch. ഇതൊരു വിഷ്വല്‍ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാന ധാരണകള്‍ ലഭിക്കാന്‍ ഇതിലെ പ്രവര്‍ത്തനങ്ങള്‍ വളരെയധികം സഹായിക്കുന്നു.
Capturing student interest in computer programming at the start of their programming courses is essential for the success of becoming a great Programmer.
കമ്പ്യൂട്ടര്‍ പ്രോഗ്രാമുകള്‍ എഴുതാനുള്ള പൈത്തണ്‍ ഭാഷ (Python) പഠിക്കുന്നതിനുമുമ്പായി നമുക്ക് അമേരിക്കയിലുള്ള MIT (Massachusetts Institute of Technology) യിലെ Lifelong Kindergarten Research Group വികസിപ്പിച്ചെടുത്ത Scratch (സ്ക്രാച്ച്) സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ചുകൊണ്ട് ചില രസകരമായ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്യാം.
Scratch is developed to teach programming concepts to students as their first exposure to computer programming.
Animation, Games, Interactive Stories തുടങ്ങിയവ തയ്യാറാക്കാന്‍ സഹായിക്കുന്ന ലളിതമായ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് Scratch. ഇതൊരു വിഷ്വല്‍ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാന ധാരണകള്‍ ലഭിക്കാന്‍ ഇതിലെ പ്രവര്‍ത്തനങ്ങള്‍ വളരെയധികം സഹായിക്കുന്നു.
Posted on 13th March 2012 by Suresh Babu P P
Lesson 2: Scratch
IT@School കസ്റ്റമൈസ് ചെയ്ത ഏറ്റവും പുതിയ
Ubuntu 10.04 വേര്‍ഷനാണ് ഉപയോഗിക്കുന്നതെങ്കില്‍ Scratch സോഫ്റ്റ് വെയര്‍
അതില്‍ ലഭ്യമാണ്. ഇല്ലെങ്കില്‍ മാത്രം താഴെ കൊടുത്തിരിക്കുന്ന
പാക്കേജ് ഡൗണ്‍ലോഡ് ചെയ്ത് ഇന്‍സ്റ്റാള്‍ ചെയ്യുക.
Package
Applications --> Programming --> Scratch എന്ന ക്രമത്തില്‍ ഇതു പ്രവര്‍ത്തിപ്പിക്കാം. തുറന്നുവരുന്ന ജാലകം ശ്രദ്ധിക്കൂ.
ഈ ജാലകത്തിലെ പ്രധാനപ്പെട്ട മൂന്നു ഭാഗങ്ങളാണ്
1. Block Palette (Button Screen)
2. Script Editor (Code Screen)
3. Stage
Sprites (ചിത്രത്തില്‍ കാണുന്ന പൂച്ചക്കുട്ടി) എന്നറിയപ്പെടുന്ന ഒബ്‌ജക്‌ടുകള്‍ കൊണ്ടാണ് സ്ക്രാച്ച് പ്രോജക്ടുകള് നിര്‍മ്മിച്ചിരിക്കുന്നത്. Sprite നെ നമുക്ക് ഏതു തരത്തിലുള്ള ഒബ്‌ജക്‌ടുകള്‍ ആക്കി മാറ്റാനും സാധിക്കും(eg: Animals, Birds, Butterfly, People, Train etc). എങ്ങനെ വ്യത്യസ്ത തരത്തിലുള്ള ഒബ്‌ജക്‌ടുകളെ സ്റ്റേജിലേക്ക് കൊണ്ടുവരാം എന്നു നോക്കാം. Script Editor ജാലകത്തിലെ Costumes ടാബില്‍ ഒന്നു ക്ലിക്കുചെയ്തുനോക്കൂ.
ഇപ്പോള്‍ വന്നിരിക്കുന്ന Costume 1 ലും Costume 2 ലും മാറി മാറി ക്ലിക്കു ചെയ്യുമ്പോള്‍ Stage ല്‍ വരുന്ന മാറ്റം നിരീക്ഷിക്കുക.
Script Editor ജാലകത്തിലെ Costumes എന്നതിലെ Import ബട്ടണില്‍ ക്ലിക്കുചെയ്താല്‍ ലഭിക്കുന്ന ജാലകത്തില്‍ നിന്നും ലഭ്യമായ / ആവശ്യമായ ഒബ്‌ജക്‌ടുകള്‍ സെലക്ട് ചെയ്ത് OK ക്ലിക്കുചെയ്യുക. ഇപ്പോള്‍ Costumes ജാലകത്തിലും Stage ലും വന്നിരിക്കുന്ന മാറ്റങ്ങള്‍ നിരീക്ഷിക്കുക.
സ്വന്തമായി വരച്ചെടുക്കുന്ന ഒരു ഒബ്‌ജക്‌ട് ആണ് വേണ്ടതെങ്കില്‍ Costumes ജാലകത്തിലെ Paint ടാബില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Paint Editor ജാലകത്തില്‍ ലഭ്യമായ ടൂളുകളുപയോഗിച്ച് ചിത്രങ്ങള്‍ വരച്ച് ഉള്‍പ്പെടുത്താം. നമ്മള്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന ഒബ്‌ജക്‌ടുകളെ (sprites) delete ചെയ്യാനും, edit ചെയ്യാനുമെല്ലാമുള്ള സൗകര്യങ്ങള്‍ ഇവിടെ ലഭ്യമാണ്.
ഒന്നില്‍ക്കൂടുതല്‍ ഒബ്‌ജക്‌ടുകളെ സ്റ്റേജിലേക്ക് കൊണ്ടുവരാം എന്നു നോക്കാം . Stage(വെളുത്ത പ്രതലം) നു തൊട്ടുതാഴെയുള്ള New Sprite എന്നതിന്റെ വലതു വശത്തുള്ള 3 നക്ഷത്രാടയാളങ്ങളി ല്‍- Choose new sprite from file, Get surprise sprite- ഇവയില്‍ ഏതെങ്കിലും ഒന്ന് സെലക്ട് ചെയ്ത് അതിലുള്ള ഫോള്‍ഡറില്‍ നിന്നും നമുക്കാവശ്യമുള്ള ഒബ്‌ജക്‌ട് തെരഞ്ഞെടുക്കാം. സ്വന്തമായി വരച്ചെടുക്കുന്ന ഒരു ഒബ്‌ജക്‌ട് ആണ് വേണ്ടതെങ്കില്‍ Paint new sprite എന്നതില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Paint Editor എന്ന ചെറിയ ജാലകത്തില്‍ ലഭ്യമായ ടൂളുകളുപയോഗിച്ച് ചിത്രങ്ങള്‍ വരച്ച് ഉള്‍പ്പെടുത്താം.
Stage (വെളുത്ത പ്രതലം) ന് ഒരു background നല്കണമെങ്കിലോ ? Stage ജാലകത്തിന്റെ ഏറ്റവും താഴെയായി stage എന്ന പേരോടുകൂടിയ ഒരു വെളുത്ത ചതുരം കാണാം. അതില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ Script Editor ജാലകത്തില്‍ Backgrounds എന്ന പുതിയൊരു ടാബ് പ്രത്യക്ഷപ്പെടും. Backgrounds ടാബില്‍ ക്ലക്കുചെയ്തതിനുശേഷം നേരത്തെ ഒബ്‌ജക്‌ടുകളെ ഉള്‍പ്പെടുത്തിയ അതേ രീതിയില്‍ പുതിയ Background ഉം ഉള്‍പ്പെടുത്താം.
നമ്മള്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന ഒബ്‌ജക്‌ടുകള്‍ക്കു ശബ്ദം നല്‍കാനുള്ള സംവിധനം Sounds ടാബിലൂടെ ലഭ്യമാക്കാം. Scratch എന്ന സോഫ്റ്റ്‌വെയറില്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന / നമ്മള്‍ ഉല്‍പ്പെടുത്തിയ ഒബ്‌ജക്‌ടുകള്‍ (sprite) എല്ലാം തന്നെ നമ്മുടെ നിര്‍ദ്ദേശത്തി നനുസരിച്ച് മാത്രം പ്രവര്‍ത്തിക്കുന്നവയാണ്. ഇതിനുവേണ്ട നിര്‍ദ്ദേശങ്ങളെല്ലാം തന്നെ Scratch ജാലകത്തിലെ ഒന്നാമത്തെ ഭാഗമായ Block Palette (Button Screen) ല്‍ ലഭ്യമാണ്.
എട്ട് കാറ്റഗറികളിലായാണ് സ്ക്രാച്ച് ബ്ലോക്കുക്ലള്‍ ക്രമീകരിച്ചിരിക്കുന്നത്.
(Motion, Looks, Sound, Pen, control, Sensing, Operators, Variables) ഓരോ ബ്ലോക്കിലും ലഭ്യമായ നിര്‍ദ്ദേശങ്ങല്‍ നിരീക്ഷിക്കുക.
Block Palette ല്‍ Motion ബ്ലോക്ക് സെലക്ട് ചെയ്തത് ചലിപ്പിക്കാനുള്ള നിര്‍ദ്ദേശം (move 10 steps) Script Editor ജാലകത്തിലേക്ക് വലിച്ചിട്ടതിനുശേഷം അതില്‍ ക്ലിക്കു ചെയ്യുക. അപ്പോള്‍ Stage ല്‍ വന്ന മാറ്റം നിരീക്ഷികികു. (drag blocks from the Blocks Palette to the Scripts Area. and click on it.)
ചില ബ്ലോക്കുകളുടെ ഉള്ളില്‍ എഡിറ്റ് ചെയ്യാവുന്ന Text Field കളും കാണാം. ബ്ലോക്കുകളുടെ ഉള്ളില്‍ കാണുന്ന വെളുത്ത പ്രതലത്തില്‍ ക്ലിക്കു ചെയ്ത് വിലകളില്‍ മാറ്റം വരുത്താം.
മറ്റു ചില ബ്ലോക്കുകളില്‍ pull down menu കള്‍ കാണാം. ഇതിന്റെ വലതു വശത്തുള്ള ആരോയില്‍ ക്ലിക്കു ചെയ്താല്‍ മറ്റു മെനുകള്‍ കാണാം.
ഓരോ ബ്ലോക്കും ചെയ്യുന്ന പ്രവര്‍ത്തികള്‍ എന്താണെന്നറിയാന്‍ - Right click on block → Select help from the pop up menu.
Activity 1.
Package
Applications --> Programming --> Scratch എന്ന ക്രമത്തില്‍ ഇതു പ്രവര്‍ത്തിപ്പിക്കാം. തുറന്നുവരുന്ന ജാലകം ശ്രദ്ധിക്കൂ.
ഈ ജാലകത്തിലെ പ്രധാനപ്പെട്ട മൂന്നു ഭാഗങ്ങളാണ്
1. Block Palette (Button Screen)
2. Script Editor (Code Screen)
3. Stage
Sprites (ചിത്രത്തില്‍ കാണുന്ന പൂച്ചക്കുട്ടി) എന്നറിയപ്പെടുന്ന ഒബ്‌ജക്‌ടുകള്‍ കൊണ്ടാണ് സ്ക്രാച്ച് പ്രോജക്ടുകള് നിര്‍മ്മിച്ചിരിക്കുന്നത്. Sprite നെ നമുക്ക് ഏതു തരത്തിലുള്ള ഒബ്‌ജക്‌ടുകള്‍ ആക്കി മാറ്റാനും സാധിക്കും(eg: Animals, Birds, Butterfly, People, Train etc). എങ്ങനെ വ്യത്യസ്ത തരത്തിലുള്ള ഒബ്‌ജക്‌ടുകളെ സ്റ്റേജിലേക്ക് കൊണ്ടുവരാം എന്നു നോക്കാം. Script Editor ജാലകത്തിലെ Costumes ടാബില്‍ ഒന്നു ക്ലിക്കുചെയ്തുനോക്കൂ.
ഇപ്പോള്‍ വന്നിരിക്കുന്ന Costume 1 ലും Costume 2 ലും മാറി മാറി ക്ലിക്കു ചെയ്യുമ്പോള്‍ Stage ല്‍ വരുന്ന മാറ്റം നിരീക്ഷിക്കുക.
Script Editor ജാലകത്തിലെ Costumes എന്നതിലെ Import ബട്ടണില്‍ ക്ലിക്കുചെയ്താല്‍ ലഭിക്കുന്ന ജാലകത്തില്‍ നിന്നും ലഭ്യമായ / ആവശ്യമായ ഒബ്‌ജക്‌ടുകള്‍ സെലക്ട് ചെയ്ത് OK ക്ലിക്കുചെയ്യുക. ഇപ്പോള്‍ Costumes ജാലകത്തിലും Stage ലും വന്നിരിക്കുന്ന മാറ്റങ്ങള്‍ നിരീക്ഷിക്കുക.
സ്വന്തമായി വരച്ചെടുക്കുന്ന ഒരു ഒബ്‌ജക്‌ട് ആണ് വേണ്ടതെങ്കില്‍ Costumes ജാലകത്തിലെ Paint ടാബില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Paint Editor ജാലകത്തില്‍ ലഭ്യമായ ടൂളുകളുപയോഗിച്ച് ചിത്രങ്ങള്‍ വരച്ച് ഉള്‍പ്പെടുത്താം. നമ്മള്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന ഒബ്‌ജക്‌ടുകളെ (sprites) delete ചെയ്യാനും, edit ചെയ്യാനുമെല്ലാമുള്ള സൗകര്യങ്ങള്‍ ഇവിടെ ലഭ്യമാണ്.
ഒന്നില്‍ക്കൂടുതല്‍ ഒബ്‌ജക്‌ടുകളെ സ്റ്റേജിലേക്ക് കൊണ്ടുവരാം എന്നു നോക്കാം . Stage(വെളുത്ത പ്രതലം) നു തൊട്ടുതാഴെയുള്ള New Sprite എന്നതിന്റെ വലതു വശത്തുള്ള 3 നക്ഷത്രാടയാളങ്ങളി ല്‍- Choose new sprite from file, Get surprise sprite- ഇവയില്‍ ഏതെങ്കിലും ഒന്ന് സെലക്ട് ചെയ്ത് അതിലുള്ള ഫോള്‍ഡറില്‍ നിന്നും നമുക്കാവശ്യമുള്ള ഒബ്‌ജക്‌ട് തെരഞ്ഞെടുക്കാം. സ്വന്തമായി വരച്ചെടുക്കുന്ന ഒരു ഒബ്‌ജക്‌ട് ആണ് വേണ്ടതെങ്കില്‍ Paint new sprite എന്നതില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Paint Editor എന്ന ചെറിയ ജാലകത്തില്‍ ലഭ്യമായ ടൂളുകളുപയോഗിച്ച് ചിത്രങ്ങള്‍ വരച്ച് ഉള്‍പ്പെടുത്താം.
Stage (വെളുത്ത പ്രതലം) ന് ഒരു background നല്കണമെങ്കിലോ ? Stage ജാലകത്തിന്റെ ഏറ്റവും താഴെയായി stage എന്ന പേരോടുകൂടിയ ഒരു വെളുത്ത ചതുരം കാണാം. അതില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ Script Editor ജാലകത്തില്‍ Backgrounds എന്ന പുതിയൊരു ടാബ് പ്രത്യക്ഷപ്പെടും. Backgrounds ടാബില്‍ ക്ലക്കുചെയ്തതിനുശേഷം നേരത്തെ ഒബ്‌ജക്‌ടുകളെ ഉള്‍പ്പെടുത്തിയ അതേ രീതിയില്‍ പുതിയ Background ഉം ഉള്‍പ്പെടുത്താം.
നമ്മള്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന ഒബ്‌ജക്‌ടുകള്‍ക്കു ശബ്ദം നല്‍കാനുള്ള സംവിധനം Sounds ടാബിലൂടെ ലഭ്യമാക്കാം. Scratch എന്ന സോഫ്റ്റ്‌വെയറില്‍ ഉള്‍പ്പെടുത്തിയിരിക്കുന്ന / നമ്മള്‍ ഉല്‍പ്പെടുത്തിയ ഒബ്‌ജക്‌ടുകള്‍ (sprite) എല്ലാം തന്നെ നമ്മുടെ നിര്‍ദ്ദേശത്തി നനുസരിച്ച് മാത്രം പ്രവര്‍ത്തിക്കുന്നവയാണ്. ഇതിനുവേണ്ട നിര്‍ദ്ദേശങ്ങളെല്ലാം തന്നെ Scratch ജാലകത്തിലെ ഒന്നാമത്തെ ഭാഗമായ Block Palette (Button Screen) ല്‍ ലഭ്യമാണ്.
എട്ട് കാറ്റഗറികളിലായാണ് സ്ക്രാച്ച് ബ്ലോക്കുക്ലള്‍ ക്രമീകരിച്ചിരിക്കുന്നത്.
(Motion, Looks, Sound, Pen, control, Sensing, Operators, Variables) ഓരോ ബ്ലോക്കിലും ലഭ്യമായ നിര്‍ദ്ദേശങ്ങല്‍ നിരീക്ഷിക്കുക.
Block Palette ല്‍ Motion ബ്ലോക്ക് സെലക്ട് ചെയ്തത് ചലിപ്പിക്കാനുള്ള നിര്‍ദ്ദേശം (move 10 steps) Script Editor ജാലകത്തിലേക്ക് വലിച്ചിട്ടതിനുശേഷം അതില്‍ ക്ലിക്കു ചെയ്യുക. അപ്പോള്‍ Stage ല്‍ വന്ന മാറ്റം നിരീക്ഷികികു. (drag blocks from the Blocks Palette to the Scripts Area. and click on it.)
ചില ബ്ലോക്കുകളുടെ ഉള്ളില്‍ എഡിറ്റ് ചെയ്യാവുന്ന Text Field കളും കാണാം. ബ്ലോക്കുകളുടെ ഉള്ളില്‍ കാണുന്ന വെളുത്ത പ്രതലത്തില്‍ ക്ലിക്കു ചെയ്ത് വിലകളില്‍ മാറ്റം വരുത്താം.
മറ്റു ചില ബ്ലോക്കുകളില്‍ pull down menu കള്‍ കാണാം. ഇതിന്റെ വലതു വശത്തുള്ള ആരോയില്‍ ക്ലിക്കു ചെയ്താല്‍ മറ്റു മെനുകള്‍ കാണാം.
ഓരോ ബ്ലോക്കും ചെയ്യുന്ന പ്രവര്‍ത്തികള്‍ എന്താണെന്നറിയാന്‍ - Right click on block → Select help from the pop up menu.
Activity 1.
Step1. Scratch സോഫ്റ്റ്‌വോയര്‍
തുറന്ന് Block Palette ലെ
Motion ബ്ലോക്ക്
സെലക്ട് ചെയ്ത് move
10 steps ബ്ലോക്കിനെ
Script Editor ജാലകത്തിലേക്ക്
വലിച്ചിടുക.
Step 2. Block Palette
ലെ Sound
ബ്ലോക്ക് സെലക്ട്
ചെയ്ത് play sound എന്ന
ഒന്നാമത്തെ നിര്‍ദ്ദേശത്തെ
Script Editor ജാലകത്തിലേക്ക്
വലിച്ചിട്ട് (drag and drop)
ചലിപ്പിക്കാനുള്ള
നിര്‍ദ്ദേശത്തോട് ചേര്‍ത്തുവയ്ക്കുക.
പതാകയുടെ ചിത്രം കാണുന്ന(when
clicked) ബ്ലോക്കില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ Stage ല്‍ വരുന്ന മാറ്റം നിരീക്ഷിക്കുക.
Step 3. Block Palette
ലെ Control
ബ്ലോക്ക് സെലക്ട്
ചെയ്ത് ഒരു പ്രവര്‍ത്തനം
ആവര്‍ത്തിക്കാനുള്ള നിര്‍ദ്ദേശവും
(repeat), ഒരു
പതാകയുടെ ചിത്രം കാണുന്ന(when
clicked) ബ്ലോക്കും
Script Editor ജാലകത്തിലേക്ക്
വലിച്ചിട്ട് , താഴെ
ചിത്രത്തില്‍ കാണുന്നതു പോലെ
ചേര്‍ത്തുവയ്ക്കുക.
Stage ന്റെ
മുകളിലായി start green flag
scripts, stop everything എന്നീ
പേരുകളില്‍ രണ്ട് ബട്ടണുകള്‍
കാണാം. ഇവയില്‍
ക്ലിക്കുചെയ്യ് ഇവയുടെ ഉപയോഗം
മനസ്സിലാക്കുക. ഇതിന്റെ
മുകളിലായി ഇടതുവശത്ത് Tool
box (Duplicate, Delete, Grow sprite, Shrink sprite) ഉം
വലതു വശത്തായി Switch to
small stage, Switch to full stage, Switch to presentation mode എന്നീ
ബട്ടണുകളും കാണാ.
ഇതില്‍ Switch
to presentation mode എന്ന
ബട്ടണില്‍ ക്ലിക്കുചെയ്തതിനുശേഷം
start green flag scripts എന്ന
ബട്ടണ്‍ ( Enter കീ)
പ്രസ്സു ചെയ്തു
നോക്കൂ. ..... Presentation Mode ല്‍
നിന്നും Project Mode ലേക്ക്
വരാന്‍ ഇടതു വശത്തുള്ള Exit
presentation ബട്ടണ്‍
(Esc കീ)
പ്രസ്സുചെയ്താല്‍
മതി.
നമ്മള്‍
തയ്യാറാക്കിയ ഈ ചെറിയ പ്രോജക്ട്
സേവ് ചെയ്യാന്‍ --
File → Save എന്ന
ക്രമത്തില്‍ ക്ലിക്കുചെയ്ത്
File Name, സേവ്
ചെയ്യേണ്ട ഫോള്‍ഡര്‍ എന്നിവ
നല്കി O K ബട്ടണില്‍
ക്ലിക്കു ചെയ്യുക.
നമ്മള്‍ തയ്യാറാക്കുന്ന പ്രോജക്ടുകള് Scratch ന്റെ web site ലേക്ക് അപ്‌ലോഡ് ചെയ്യാന്‍ ഉദ്ദേശിക്കുന്നുണ്ടെങ്കില്‍ File മെനുവിന്റെ ഇടതു വശത്തു കാണുന്ന Share this project എന്ന ഐക്കണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Upload to Scratch Server ഡയലോഗ് ബോക്‌സില്‍ ആവശ്യമായ വിവരങ്ങള്‍ നല്കി OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്താല്‍ മിതി. (After creating an account)
നമ്മള്‍ തയ്യാറാക്കുന്ന പ്രോജക്ടുകള് Scratch ന്റെ web site ലേക്ക് അപ്‌ലോഡ് ചെയ്യാന്‍ ഉദ്ദേശിക്കുന്നുണ്ടെങ്കില്‍ File മെനുവിന്റെ ഇടതു വശത്തു കാണുന്ന Share this project എന്ന ഐക്കണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന Upload to Scratch Server ഡയലോഗ് ബോക്‌സില്‍ ആവശ്യമായ വിവരങ്ങള്‍ നല്കി OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്താല്‍ മിതി. (After creating an account)
Scratch
സോഫ്റ്റ്‌വോയറിനെക്കുറിച്ച്
കൂടുതല്‍ അറിയാന്‍ → സ്ക്രാച്ച്
ജാലകത്തിലെ Help → Help
page → Getting Started, Help Screens, Reference Guide എന്നിവ
മതിയാകും.........
Scratch പ്രോജക്ടിലുള്ള
വ്യത്യസ്ത ബ്ലോക്കുകള്‍
(നിര്‍ദ്ദേശങ്ങള്‍)
ഉപയോഗിച്ചുകൊണ്ട്
വളരെയധികം പ്രവര്‍ത്തനങ്ങള്‍
ചെയ്യാനുള്ള അവസരം
വിദ്യാര്‍ത്ഥികള്‍ക്കു
ലഭിക്കുന്നതിലൂടെ യഥാര്‍ത്ഥ
പ്രോഗ്രാമിംഗ് ഭാഷ പഠിക്കാനുള്ള
താത്പര്യം ജനിക്കും..................
Posted on 13th March 2012 by Suresh Babu P P
Lesson 3: Python
Python പ്രോഗ്രാം പഠനത്തിനാവശ്യമായ സോഫ്റ്റ്‌വെയര്‍ പാക്കേജുക ളെല്ലാം (Text Editor, IDLE,wxGlade...) IT@School കസ്റ്റമൈസ് ചെയ്ത ഏറ്റവും പുതിയ Ubuntu 10.04 വേര്‍ഷനില്‍ ലഭ്യമാണ്.
പൈത്തണ്‍ ഒരു ഇന്‍റര്‍പ്രട്ടഡ് പ്രോഗ്രാമിംഗ് ഭാഷയാണ്,അതുകൊണ്ട് ഒന്നുകില്‍ പൈത്തണ്‍ ഇന്‍റര്‍പ്രട്ടറിലേക്ക് നേരിട്ടോ അല്ലെങ്കില്‍ ഒരു ഫയലിലേക്കോ പ്രോഗ്രാം എഴുതി റണ്‍ ചെയ്യിക്കാവുന്നതാണ്.
ആദ്യം നമുക്ക് ഇന്‍റര്‍പ്രട്ടര്‍ ഉപയോഗിക്കുന്നതെങ്ങനെയെന്നു നോക്കാം,കമാന്റ് പ്രോംപ്ററില്‍ ( ടെര്‍മിനല്‍ ) python എന്നു ടൈപ്പ് ചെയ്താലാണ് ഇന്‍റര്‍പ്രട്ടര്‍ പ്രവര്‍ത്തിച്ചു തുടങ്ങുക.
Application --> Accessories --> Terminal എന്ന ക്രമത്തില്‍ ടെര്‍മിനല്‍ ജാലകം തുറക്കുക.
അടുത്തതായി നമുക്ക് ഇതേ പ്രഗ്രാം ഒരു ഫയലില്‍ തയ്യാറാക്കി നോക്കാം.
തയ്യാറാക്കുന്ന പൈത്തണ്‍ പ്രോഗ്രാമുകളെല്ലാം സൂക്ഷിച്ചു വെയ്ക്കാനായി ആദ്യമായി ഒരു ഫോള്‍ഡര്‍ (eg: Name of the folder : programs) നിര്‍മ്മിക്കാം.
Text Editor (Applications --> Accessories --> Text editor (gedit) ) തുറന്ന് വളരെ ലളിതമായ ഒരു പ്രോഗ്രാം എഴുതാം.
eg : print "Hello, World"
തുടര്‍ന്ന് മുമ്പ് തയ്യാറാക്കയ ഫോള്‍ഡറില്‍ (programs) .py ന്ന എക്സ്‌റ്റന്‍ഷനോടെ ( eg: hello.py) സേവ് ചെയ്യുക.
സേവ് ചെയ്ത ഫയല്‍ തുറന്നു കഴിഞ്ഞാല്‍ താഴെ കാണുന്ന പ്രകാരം ആയിരിക്കും.
അപ്പോള്‍ നാം തയ്യാറാക്കി സേവ് ചെയ്തിരിക്കുന്ന പൈത്തണ്‍ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നതു കാണാം.
ഈ പ്രോഗ്രാമിലെ print എന്നുള്ളത് പ്രോഗ്രാമിന്റെ output (പുറത്തുകാണേണ്ട പ്രവര്‍ത്തനഫലം) കാണിക്കുവാന്‍ ഉപയോഗിക്കുന്ന ഒരു പൈത്തണ്‍ കീ വേര്‍ഡ് ആണ്.
അക്ഷരങ്ങളും അക്കങ്ങളും ഉള്‍പ്പടെ എഴുതാനുപയോഗിക്കുന്ന എല്ലാ ചിഹ്നങ്ങളെയും (സ്പേസും മറ്റുമടക്കം) character എന്നാണ് പറയുക. ഉദ്ധരണചിഹ്നങ്ങള്‍ക്കിടയിലായി character-കള്‍ എഴുതുന്നതിന് string എന്നു പറയുന്നു. ഉദാഹരണത്തിന്, നമ്മുടെ പ്രോഗ്രാമില്‍ക്കണ്ട "Hello, World!" ഒരു string ആണ്.
പൈത്തണില്‍ സ്പേസിനു (space) വളരെയധികം പ്രാധാന്യമുണ്ട്. ഒരു വരിയുടെ ആദ്യമുളള സ്പേസിനെ Indentation എന്നു വിളിക്കുന്നു.തെററായ ശൈലിയില്‍ Indentation നല്കിയാല്‍ പൈത്തണ്‍ (error) സന്ദേശം കാണിക്കും.താഴെക്കൊടുത്തിരിക്കുന്ന ഉദാഹരണം കാണുക.
കീ വേര്‍ഡുകളും ഐഡന്‍റിഫയറുകളും
നാം എഴുതുന്ന പൈത്തണ്‍ പ്രോഗ്രാം സോഴ്സ് കോഡിനെ ഐഡന്‍റിഫയറുകളായി
(names അഥവാ നാമങ്ങള്‍)വിഭജിക്കാം.
താഴെകൊടിത്തിരിക്കുന്ന ഐഡന്‍റിഫയറുകളെ റിസര്‍വ്ഡ് വാക്കുകളായോ കീ വേര്‍ഡുകളായോ പൈത്തണ്‍ കണക്കാക്കുന്നു. ഈ കീ വേര്‍ഡുകളെ ഐഡന്‍റിഫയറായോ വേരിയബിളിന്റെ പേരായോ ഉപയോഗിക്കാന്‍ പാടില്ല.അവ താഴെ കൊടുത്തിരിക്കുന്നതുപോലെ തന്നെ ഉപയോഗിക്കേണ്ടതാണ്:
and del from not while
as elif global or with
assert else if pass yield
break except import print
class exec in raise
continue finally is return
def for lambda try
പൈത്തണില്‍ ഒരു വേരിയബിള്‍ പ്രസ്താവിക്കാന്‍ പേരും അതിന്റെ മൂല്യവും നല്‍കുകയാണ് വേണ്ടത്
പൈത്തണ്‍ പ്രോഗാമില്‍ നമ്മള്‍ എഴുതുന്ന വരികള്‍ ഭൂരിഭാഗവും
എക്സ്‌പ്രഷനുകളായിരിക്കും. എക്സ്‌പ്രഷനുകള്‍ ഓപ്പറേറററുകളും ഓപ്പറാന്റുകളും
കൊണ്ട് തയ്യാറാക്കിയതാണ്. ഒരു എക്സ്പ്രഷന് ഇതുപോലെയാണ് 2 + 3 .ഗണിതശാസ്ത്രപരമായതോ യുക്തിപരമായതോ ആയ എന്തെങ്കിലും പ്രവൃത്തി ചെയ്യുവാന്‍ പൈത്തണ്‍ ഇന്‍ര്‍ പ്രട്ടറിനോട് പറയുന്ന ചിഹ്നങ്ങളെ ഓപ്പറേററര്‍ എന്നു വിളിക്കുന്നു.
പൈത്തണില്‍ ഗണിതക്രിയകള്‍ ചെയ്യുമ്പോള്‍ ഉപയോഗിക്കുന്ന ചിഹ്നങ്ങള്‍
തുക +
വ്യത്യാസം -
ഗുണനം *
ഹരണം /
ഘാതം (കൃതി) **
ശിഷ്ടം %
താഴെ
കൊടുത്തിരിക്കുന്ന ഓരോന്നും
പൈത്തണ്‍ പ്രോഗ്രാമില്‍
ചെയ്തു നോക്കൂ.
print 7+4
print 7-4
print 7*4
print 7/4
print 7.0/4
print 7**4
print 7.0**4
print 7%4
print “7+4=”, 7+4
print “7*4=”, 7*4
Python language supports following type of operators.
- Arithmetic Operators
- Comparision Operators
- Logical (or Relational) Operators
- Assignment Operators
- Conditional (or ternary) Operators
റിലേഷണല്‍ ഓപ്പറേററര്‍
| ഓപ്പറേററര്‍ | അര്‍ത്ഥം | |||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| < | നേക്കാള്‍ മൂല്യം കുറവാണ് | |||||||||||||||||||||||||||||||||||||
| <= | നേക്കാള്‍ മൂല്യം കുറവോ തുല്യമോ ആണ് | |||||||||||||||||||||||||||||||||||||
| > | നേക്കാള്‍ മൂല്യം കൂടുതലാണ് | |||||||||||||||||||||||||||||||||||||
| >= | നേക്കാള്‍ മൂല്യം കൂടുതലോ തുല്യമോ ആണ് | |||||||||||||||||||||||||||||||||||||
| == | നോട് തുല്യമാണ് | |||||||||||||||||||||||||||||||||||||
| != | നോട് തുല്യമല്ല |
ലോജിക്കല്‍ ഓപ്പറേറററുകള്‍
ലോജിക്കല്‍ AND,OR ഓപ്പറേഷനുകള്‍ ചെയ്യുവാന്‍ പൈത്തണില്‍ and , or എന്നീ കീവേഡുകള്‍ ഉപയോഗിക്കുന്നു.
x and y എന്ന ലോജിക്കല്‍ ഓപ്പറേഷന്‍ x തെററാണെങ്കില്‍ False എന്ന് ഫലം നല്കുന്നു,അല്ലെങ്കില്‍ y വിലയിരുത്തി ഫലം നല്‍ കുന്നു. x സാധുവാണെങ്കില്‍ True എന്ന് ഫലം നല്കുന്നു.
എക്സ്‌പ്രഷനുകള്‍
സാധാരണയായി എക്സ്‌പ്രഷനുകള്‍ എഴുതുമ്പോള്‍ ഓരോ ഓപ്പറേറ്ററിനു ശേഷവും ഒരു
സ്പേസ് ഇടുന്നത് എക്സ്പ്രഷന് കൃത്യമായി മനസിലാക്കുവാന്‍
സഹായക്കുന്നു.
For more details Click here
on 13th March 2012 by Suresh Babu P P
Lesson 4: Python
ഒരു
പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തിന്റെ
ഭാഗമായി മൂല്യങ്ങള്‍ (വിലകള്‍)
ഉപയോഗി ക്കേണ്ടതായി
വരും.
ഇവയില്‍
ചിലതിനെ നമുക്ക് പേരിട്ട്
വിളിക്കേണ്ടതായ ആവശ്യമുണ്ടാകും.
ഇങ്ങനെ
മൂല്യങ്ങളെ
പേരിട്ടു വിളിക്കാനുള്ള
ഉപാധിയാണ് ചരങ്ങള്‍ (Variables).
ലളിതമായിപ്പറഞ്ഞാല്‍
മൂല്യങ്ങളെ (values)
സൂക്ഷിച്ചു വെക്കാനുള്ള
പേരെഴുതിയ പെട്ടികളാണ്
ചരങ്ങള്‍.
A variable is something with a value that may
change. In simplest terms, a variable is just a box that you can put
stuff in.
പൈത്തണ്‍
ഭാഷയിലെ key
words ( eg: print, and, or, with, if, return, for, in, else,
…....................) ഒഴികെ
ഏതു പേരും ചരങ്ങള്‍ക്കിടാമെങ്കിലും
ചരത്തിനെ എന്തു സൂചിപ്പിക്കാനാണോ
പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്നത്,
ആ
അര്‍ത്ഥം വരുന്ന പേരുകള്‍
കൊടുക്കന്താണ് നല്ലത്.
Program 1 :
ഉപയോക്താവിനോട് പേര് ചോദിക്കുകയും (Hello, What is your name ?), പേര് കിട്ടിക്കഴിഞ്ഞാല്‍ ആ പേരുവച്ച് ഹായ് പറയുകയും കൂടാതെ താങ്കളുടെ വയസ്സെത്ര ? (Hai, name, Please tell me your age in years ) എന്ന ചോദ്യം ചോദിക്കുകയും അതിനുള്ള മറുപടി കിട്ടിക്കഴിയുമ്പേള്‍ വീണ്ടും മറുടിയായി പേരിന്റെ കൂടെ , താങ്കള്‍ക്ക് ഇനി സര്‍വ്വീസില്‍ നിന്നും വിരമിക്കാന്‍ ഇത്ര വര്‍ഷം കൂടിയേയുള്ളൂ ( name, you have only …...years to retire. Goodbye! ) എന്ന ഒരു Output ലഭിക്കുന്ന പ്രോഗ്രാം തയ്യാറാക്കി നോക്കാം.
Text Editor തുറന്ന് താഴെ കൊടുത്ത ക്രമത്തില്‍ ടൈപ്പു ചെയ്യുക.
name = raw_input("Hello, What is your name ?")
print "Hai ", name, "Please tell me your age in years"
years = input("How many years ?")
Retirement =55 - years
print name, "you have only ", Retirement, " years to retire. Goodbye!"
ഇത്രയും
ടൈപ്പ് ചെയ്തതിനുശേഷം
ret_year.py എന്ന
പേരില്‍ ഡസ്ക്ടോപ്പിലെ
programs എന്ന
ഫോള്‍ഡറില്‍ സേവ് ചെയ്യുക.
സേവ് ചെയ്തു
കഴിഞ്ഞാല്‍ പൈത്തണ്‍ പ്രോഗ്രാമിലെ
ചില വാക്കുകളുടെ നിറം മാറുന്നതായി
കാണാം.
ഈ
പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുവാന്‍
- Desktop ലുള്ള
programs എന്ന
ഫോള്‍ഡറില്‍ Right
Click ചെയ്യുമ്പോള്‍
വരുന്ന drop down മെനുവില്‍
നിന്നും Open in Terminal
സെലക്ട്
ചെയ്യുക. അപ്പോള്‍
തുറന്നുവരുന്ന ജാലകത്തില്‍
$ ചിഹ്നത്തിനുശേഷം
python ret_year.py ( python സ്പേസ്
ഫയലിന്റെ എക്സ്റ്റന്‍ഷനോടുകൂടിയ
പേര്) ടൈപ്പ്
ചെയ്ത് Enter കീ
പ്രസ്സ് ചെയ്യുക.
അപ്പോള്‍ നാം
തയ്യാറാക്കി സേവ് ചെയ്തിരിക്കുന്ന
പൈത്തണ്‍ പ്രോഗ്രാം
പ്രവര്‍ത്തിക്കുന്നതു കാണാം.Program 2:
ഒരു
ചതുരത്തിന്റെ പരപ്പളവ്
കണ്ടെത്തുന്നതിനുള്ള പ്രാഗ്രാം
നീളം
= l
വീതി
= b
പരപ്പളവ്
= നീളം*വീതി
=l*b
പൈത്തണ്‍
പ്രോഗ്രാമിലാക്കാന്‍,
Text Editor തുറന്ന്
താഴെ കൊടുത്ത ക്രമത്തില്‍
ടൈപ്പു ചെയ്യുക.
b=input(" Enter Breadth ?")
a=l*b
print a
സേവ് ചെയ്തതിനുശേഷം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
Posted on 13th March 2012 by Suresh Babu P P
Lesson 5
Python Shell
Terminal (Applications →
Accessories → Terminal ) തൂറന്ന്
python എന്ന
കമാന്റ് കൊടുക്കുക.
>>> എന്ന
ഒരു പ്രോംപ്റ്റ് (കമാന്റുകള്‍
കൊടുക്കാനുള്ള സൂചകം)
തുറന്നുവരുന്നതു
കാണാം. ഇതാണ്
പൈത്തണ്‍ ഷെല്‍.
ഷെല്ലിലെഴുതിയ ഒരു പ്രോഗ്രാമും സ്ഥായിയല്ല . എഡിറ്ററിലേക്ക് copy – paste ചെയ്ത് സൂക്ഷിക്കാം.
പൈത്തണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കാനുള്ള രണ്ടു വഴികളാണ് Text Editor / Terminal ഉപയോഗിക്കുന്ന രീതിയും, ഷെല്‍ ഉപയോഗിക്കുന്ന രീതിയും. ഇവ രണ്ടും ചേര്‍ന്ന പ്രോഗ്രാം എഴുതാനും പ്രവര്‍ത്തിപ്പിച്ചുനോക്കാനും വളരെ എളുപ്പമുള്ള ഒരു സോഫ്റ്റ‌വെയറാണ് IDLE ( Integrated Development Environment)
IDLE തുറക്കാന്‍ - Applications -> Programming -> IDLE(using python)
IDLE തുറക്കുമ്പോള്‍ ആദ്യം കാണുക ഒരു പൈത്തണ്‍ ഷെല്‍ ആണ്. കൂടാതെ ഒരു പൈത്തണ്‍ എഡിറ്ററും ഇതിലുണ്ട്. നാം നേരത്തെ തയ്യാറാക്കിയ ഒരു പ്രോഗ്രാം (rety.py) ഇതിലൊന്നു തുറന്നു നോക്കാം.
Applications -> Programming -> IDLE(using python)
File → Open
rety.py എന്ന ഫയല്‍ സൂക്ഷിച്ചുവച്ച programs എന്ന ഫോള്‍ഡറില്‍ ഫയല്‍ സെലക്ട് ചെയ്ത് open ബട്ടണില്‍ ക്ലിക്കുചെയ്യുക. ഈ ഫയല്‍ ഒരു എഡിറ്ററില്‍ തുറന്നുവരുന്നതു കാണാം. ഈ മറ്റ് എഡിറ്ററുകളില്‍ കാണുന്ന സൗകര്യങ്ങള്‍ കൂടാതെ പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിക്കാന്‍ സഹായ കരമായ മറ്റ് ധാരാളം സൗകര്യങ്ങള്‍ ഇവിടെയുണ്ട്.
ഇതില്‍
ഏറ്റവും പ്രധാനപ്പെട്ട ഒന്നാണ്
ടെര്‍മിനല്‍ ഉപയോഗിക്കാതെ,
എഡിറ്ററിനുള്ളില്‍
നിന്നുകൊണ്ടുതന്നെ പ്രോഗ്രാം
പ്രവര്‍ത്തിപ്പിച്ചു നോക്കാനുള്ള
സൗകര്യം. ഇതിനായി
പ്രോഗ്രാം തുറന്നുവെച്ച
എഡിറ്ററിലെ Run → Run Module (F5) എന്ന
ക്രമത്തില്‍ ക്ലിക്കുചെയ്യുക.
അപ്പോള്‍ പ്രോഗ്രാമിന്റെ
Output ആദ്യം തുറന്നുവന്ന
ഷെല്ലില്‍ വരുന്നതു കാണാം.
1.ഒരു
വസ്തുവിന്റെ വേഗത
കണ്ടുപിടിക്കുന്നതിനുള്ള
പ്രോഗ്രാം നമുക്ക് IDLE
ഉപയോഗിച്ചു
ചെയ്തു നോക്കാം.
വേഗത
= ദൂരം
/ സമയം
s= d/t
Applications →
Programming → IDLE എന്ന
ക്രമത്തില്‍ IDLE
സോഫ്റ്റ‌വെയര്‍
തുറക്കുക
File → New Window പന്ന
ക്രമത്തില്‍ പുതിയൊരു ഫയല്‍
(Editor)തുറക്കുക.
ഈ
എഡിറ്ററില്‍ താഴെ കൊടുത്തിരിക്കുന്ന
രൂപത്തില്‍ ടൈപ്പുചെയ്യുക.
t = input( “Time taken” )
s = d / t
print s
2. ഒരു വിദ്യാര്‍ത്ഥിക്ക് വിവിധ വിഷയങ്ങളില്‍ ലഭിച്ച മാര്‍ക്കുകളുടെ തുകയും ശരാശരിയും കാണുന്നതിനുള്ള പ്രോഗ്രാം IDLE സോഫ്റ്റ്‌വെയറില്‍ ചെയ്തുനോക്കൂ.
n=raw_input("Enter Your Name : ")
p=input("Mark in Physics :")
c=input("Mark in Chemistry :")
b=input("Mark in biology :")
m=input("Mark in Maths :")
t=p+c+b+m
a=t/4.0
print "Total Mark of ",n,"=",t
print "Average=",a
Posted on 14th March 2012 by Suresh Babu P P
Lesson 6
പൈത്തണ്‍
ഭാഷ ഉപയോഗിച്ച് അരിത് മെറ്റിക്
ക്രിയകള്‍ ചെയ്യുന്നതിനുള്ള
ചില പ്രവര്‍ത്തനങ്ങളാണ് നാം
ഇതുവരെ ചെയ്തത്. എന്നാല്‍
താരതമ്യം ചെയ്യല്‍, തിരയല്‍
തുടങ്ങിയ ലോജിക്കല്‍ ക്രിയകള്‍
ചെയ്യുന്നതിനും നമുക്ക്
പൈത്തണ്‍ ഭാഷ ഉപയോഗപ്പെടുത്താം.
if ... else നിത്യ ജീവിത്തില്‍ നമുക്ക് പലതരത്തിലുളള തീരുമാനങ്ങള്‍ കൈകൊള്ളേണ്ടതായി വരാറുണ്ട് . അതുപോലെ കമ്പ്യൂട്ടര്‍ പ്രോഗ്രാം എഴുതുമ്പോഴും നമുക്ക് ഇത്തരത്തിലുള്ള ചില തീരുമാനങ്ങള്‍ കൈകൊള്ളേണ്ടതായി വരും. അതിനായി നമുക്ക് if-else പ്രസ്താവന ഉപയോഗിക്കാവുന്നതാണ്, ഇവ ഉപയോഗിച്ച് നമുക്ക് പ്രോഗ്രാമിന്റെ ഗതി നിയന്ത്രിക്കുവാന്‍ സാധിക്കും.
ഒരു വ്യവസ്ഥ (condition) ശരിയാണോ എന്ന് പരിശോധിച്ച്, ശരിയാണെങ്കില്‍ ഒരു കൂട്ടം കാര്യങ്ങളും, തെറ്റാണെങ്കില്‍ മറ്റൊരുകൂട്ടം കാര്യങ്ങളും ചെയ്യാന്‍ പൈത്തണില്‍ (മറ്റു പ്രോഗ്രാമിംഗ് ഭാഷകളിലും) ഉപയോഗിക്കുന്ന ഒരുപാധിയാണ്
if
... else എന്ന പ്രയോഗം.
if സ്റ്റേറ്റ്‌മെന്റ്
ഉപയോഗിക്കുമ്പോള്‍ ശ്രദ്ധിക്കേണ്ട
കാര്യങ്ങള്‍
if, else എന്നീ
നിര്‍ദ്ദേശങ്ങള്‍ ടൈപ്പുചെയ്യേണ്ടത്
ഒരേ നിരയിലായി രിക്കണം.
മറ്റു സ്റ്റേറ്റുമെന്റുകള്‍
if, else എന്നിവ
ടൈപ്പുചെയ്ത നിരയില്‍ ആകരുത്.
എന്നാല്‍ if, else
എന്നിവ ഒഴികെയുള്ളവ
സ്റ്റേറ്റുമെന്റുകള്‍ എല്ലാം
ഒരേ നിരയിലായിരിക്കണം.
if, else എന്നിവയോടൊപ്പം
ഒരു കോളന്‍ (:) ഇടണം.
ഉദാ :
ഒരു കുട്ടിക്ക്
ശാസ്ത്ര പരീക്ഷിയില്‍ ലഭിച്ച
മാര്‍ക്ക് ഇന്‍പുട്ടായി
സ്വീകരിക്കുന്നതിനും മാര്‍ക്ക്
39 ല്‍ കൂടുതല്‍
ആണെങ്കില്‍ Passed എന്നും
, 39 ല്‍ കുറവാണെങ്കില്‍
Failed എന്നും പ്രിന്റ്
ചെയ്യുന്നതിനുള്ള പൈത്തണ്‍
പ്രോഗ്രാം.
m=input(“Enter
Mark : ”)
if
m>39:
print
“Passed”
else:
print “Failed”
ഉദാ
2: ഒരു
സംഖ്യ ഒറ്റസംഖ്യയോ ഇരട്ടസംഖ്യയോ
എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു
പ്രോഗ്രാം
n
= input("Please input an integer:
")if (n
% 2) == 0
: print
n, " is an even number"else : print
n, " is an odd number"
ഉദാ
3: ഒരു
സംഖ്യ ന്യൂനസംഖ്യയാണോ,
അധിസംഖ്യയാണോ, പൂജ്യമാണോ
എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു
പ്രോഗ്രാം.
n
= input("Please input a number: ")if n
< 0 : print
n, " is a negative number"else : if
n == 0 : print
n, " is zero" else
: print
n, " is a positive number"Posted on 15th March 2012 by Suresh Babu P P
Lesson 7
Turtle Graphics
അരിത്തമെറ്റിക് ഓപ്പറേഷനുകളും ലോജിക്കല്‍ ഓപ്പറേഷനുകളും കൈകാര്യം ചെയ്യുന്നതുപോലെ ഗ്രാഫിക് നിര്‍ദ്ദേശങ്ങള്‍ക്കനുസരിച്ച് കമ്പ്യൂട്ടറിനെ പ്രവര്‍ത്തി പ്പിക്കാനും പൈത്തണ്‍ ഭാഷ ഉപയോഗിക്കാം. ടര്‍ട്ടില്‍ (Turtle) എന്ന അനുബന്ധ സോഫ്റ്റ്‌വെയറിന്റെ സഹായത്തോടെ യാണ് ഇത് സാധ്യമാകുന്നത്. IT@School Ububtu വേര്‍ഷുകളല്‍ ടര്‍ട്ടില്‍ പ്രത്യേകം ഇന്‍സ്റ്റാള്‍ ചെയ്യേണ്ടതില്ല.
ഒരു ആരോ മാര്‍ക്ക് (Turtle) ചലിക്കുന്നതിനനുസരിച്ച് വിവിധ രൂപങ്ങള്‍ ഉണ്ടാകുന്ന തരത്തിലാണ് Turtle ഗ്രാഫിക്സ് പ്രവര്‍ത്തിക്കുന്നത്. പ്രോഗ്രാമിന്റെ തുടക്കത്തില്‍ from turtle import* എന്ന ചേര്‍ത്താല്‍ Turtle നിര്‍ദ്ദേശങ്ങള്‍ പൈത്തണില്‍ പ്രവര്‍ത്തിക്കും.
Applications → Programming → IDLE(using python) എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ തുറന്നുവരുന്ന python shell ജാലകത്തില്‍ from turtle import*എന്ന് ടൈപ്പുചെയ്തതിനുശേഷം രണ്ടാമത്തെ വരിയില്‍ forward(50) എന്ന് ടൈപ്പുചെയ്ത് Enter key പ്രസ്സുചെയ്തു നോക്കൂ. അടുത്ത വരിയില്‍ circle(50) എന്ന് ടൈപ്പുചെയ്ത് Enter key പ്രസ്സ് ചെയ്യുക. അടുത്ത വരിയില്‍ dot(20,”blue”) എന്നും ടൈപ്പുചെയ്ത് Enter key പ്രസ്സ് ചെയ്യുക. മാറ്റങ്ങള്‍ നിരീക്ഷിക്കുക.
ഇതേ പ്രവര്‍ത്തനം Applications → Programming → IDLE(using python) എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്ത് File → New Window എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ തുറന്നുവരുന്ന എഡിറ്ററില്‍ ടൈപ്പുചെയ്ത് .pyഎന്ന എക്സ്റ്റന്‍ഷനോടുകൂടി സേവ് ചെയ്തതിനുശേഷം ഈ പ്രോഗ്രാം Run ചെയ്തു നോക്കൂ.
വരയും വൃത്തവും ബിന്ദുവും വരയ്ക്കുന്നതുപോലെ ബഹുഭുജങ്ങളും പൈത്തണ്‍ ഭാഷ (Turtle) ഉപയോഗിച്ച് നിര്‍മ്മിക്കാം.
ഒരു സമഭുജത്രികോണം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം താഴെ കൊടുക്കുന്നു.
from turtle import*
pencolor("blue")
pensize(5)
rt(120)
fd(100)
rt(120)
fd(100)
rt(120)
fd(100)
പ്രോഗ്രാം ടൈപ്പുചെയ്തു പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയതിനുശേഷം ഓരോ നിര്‍ദ്ദേശം എന്തിനുള്ളതാണെന്ന് മനസ്സിലാക്കാം.
ഒരു സമചതുരം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കുക.
ഒരു സമപഞ്ചഭുജം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം രണ്ടു രീതികളില്‍ എഴുതിയിരിക്കുന്നത് നിരീക്ഷിക്കുക.
രീതി 1:
from turtle import*
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72) രീതി 2:
from turtle import*
for i in range(5):
fd(50)
rt(72)
ര ണ്ടാമത്ത രീതിയില്‍ വളരെ കുറച്ചു നിര്‍ദ്ദേശങ്ങള്‍ മാത്രം ഉപയോഗിച്ച് എളുപ്പത്തില്‍ ഏതു സമബഹുഭുജവും നിര്‍മ്മിക്കാം.
ഒരു കൂട്ടം വിലകള്‍ ഒരു ചരത്തില്‍ ഉള്‍പ്പെടുത്തുന്നതിന് പൈത്തണ്‍ ഭാഷയിലുപയോഗിക്കുന്ന നിര്‍ദ്ദേശമാണ് range എന്നത്.
പ്ര ോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തിയിട്ടുള്ള ഏതെങ്കിലും നിര്‍ദ്ദേശങ്ങള്‍ ആവര്‍ത്തിച്ച് പ്രവര്‍ത്തിക്കണമെങ്കില്‍ അവ വീണ്ടും വീണ്ടും ടൈപ്പു ചെയ്യേണ്ടതില്ല. അവ for എന്ന നിര്‍ദ്ദേശത്തോടൊപ്പം നല്കിയാല്‍ മതി.
അരിത്തമെറ്റിക് ഓപ്പറേഷനുകളും ലോജിക്കല്‍ ഓപ്പറേഷനുകളും കൈകാര്യം ചെയ്യുന്നതുപോലെ ഗ്രാഫിക് നിര്‍ദ്ദേശങ്ങള്‍ക്കനുസരിച്ച് കമ്പ്യൂട്ടറിനെ പ്രവര്‍ത്തി പ്പിക്കാനും പൈത്തണ്‍ ഭാഷ ഉപയോഗിക്കാം. ടര്‍ട്ടില്‍ (Turtle) എന്ന അനുബന്ധ സോഫ്റ്റ്‌വെയറിന്റെ സഹായത്തോടെ യാണ് ഇത് സാധ്യമാകുന്നത്. IT@School Ububtu വേര്‍ഷുകളല്‍ ടര്‍ട്ടില്‍ പ്രത്യേകം ഇന്‍സ്റ്റാള്‍ ചെയ്യേണ്ടതില്ല.
ഒരു ആരോ മാര്‍ക്ക് (Turtle) ചലിക്കുന്നതിനനുസരിച്ച് വിവിധ രൂപങ്ങള്‍ ഉണ്ടാകുന്ന തരത്തിലാണ് Turtle ഗ്രാഫിക്സ് പ്രവര്‍ത്തിക്കുന്നത്. പ്രോഗ്രാമിന്റെ തുടക്കത്തില്‍ from turtle import* എന്ന ചേര്‍ത്താല്‍ Turtle നിര്‍ദ്ദേശങ്ങള്‍ പൈത്തണില്‍ പ്രവര്‍ത്തിക്കും.
Applications → Programming → IDLE(using python) എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ തുറന്നുവരുന്ന python shell ജാലകത്തില്‍ from turtle import*എന്ന് ടൈപ്പുചെയ്തതിനുശേഷം രണ്ടാമത്തെ വരിയില്‍ forward(50) എന്ന് ടൈപ്പുചെയ്ത് Enter key പ്രസ്സുചെയ്തു നോക്കൂ. അടുത്ത വരിയില്‍ circle(50) എന്ന് ടൈപ്പുചെയ്ത് Enter key പ്രസ്സ് ചെയ്യുക. അടുത്ത വരിയില്‍ dot(20,”blue”) എന്നും ടൈപ്പുചെയ്ത് Enter key പ്രസ്സ് ചെയ്യുക. മാറ്റങ്ങള്‍ നിരീക്ഷിക്കുക.
ഇതേ പ്രവര്‍ത്തനം Applications → Programming → IDLE(using python) എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്ത് File → New Window എന്ന ക്രമത്തില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ തുറന്നുവരുന്ന എഡിറ്ററില്‍ ടൈപ്പുചെയ്ത് .pyഎന്ന എക്സ്റ്റന്‍ഷനോടുകൂടി സേവ് ചെയ്തതിനുശേഷം ഈ പ്രോഗ്രാം Run ചെയ്തു നോക്കൂ.
വരയും വൃത്തവും ബിന്ദുവും വരയ്ക്കുന്നതുപോലെ ബഹുഭുജങ്ങളും പൈത്തണ്‍ ഭാഷ (Turtle) ഉപയോഗിച്ച് നിര്‍മ്മിക്കാം.
ഒരു സമഭുജത്രികോണം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം താഴെ കൊടുക്കുന്നു.
from turtle import*
pencolor("blue")
pensize(5)
rt(120)
fd(100)
rt(120)
fd(100)
rt(120)
fd(100)
പ്രോഗ്രാം ടൈപ്പുചെയ്തു പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയതിനുശേഷം ഓരോ നിര്‍ദ്ദേശം എന്തിനുള്ളതാണെന്ന് മനസ്സിലാക്കാം.
ഒരു സമചതുരം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കുക.
ഒരു സമപഞ്ചഭുജം നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം രണ്ടു രീതികളില്‍ എഴുതിയിരിക്കുന്നത് നിരീക്ഷിക്കുക.
രീതി 1:
from turtle import*
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72)
fd(50)
rt(72) രീതി 2:
from turtle import*
for i in range(5):
fd(50)
rt(72)
ര ണ്ടാമത്ത രീതിയില്‍ വളരെ കുറച്ചു നിര്‍ദ്ദേശങ്ങള്‍ മാത്രം ഉപയോഗിച്ച് എളുപ്പത്തില്‍ ഏതു സമബഹുഭുജവും നിര്‍മ്മിക്കാം.
ഒരു കൂട്ടം വിലകള്‍ ഒരു ചരത്തില്‍ ഉള്‍പ്പെടുത്തുന്നതിന് പൈത്തണ്‍ ഭാഷയിലുപയോഗിക്കുന്ന നിര്‍ദ്ദേശമാണ് range എന്നത്.
പ്ര ോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തിയിട്ടുള്ള ഏതെങ്കിലും നിര്‍ദ്ദേശങ്ങള്‍ ആവര്‍ത്തിച്ച് പ്രവര്‍ത്തിക്കണമെങ്കില്‍ അവ വീണ്ടും വീണ്ടും ടൈപ്പു ചെയ്യേണ്ടതില്ല. അവ for എന്ന നിര്‍ദ്ദേശത്തോടൊപ്പം നല്കിയാല്‍ മതി.
Posted on 16th March 2012 by Suresh Babu P P
Lesson 8
Turtle Graphics (cont...)
ഒരു
കൂട്ടം വിലകള്‍ ഒരു ചരത്തില്‍
ഉള്‍പ്പെടുത്തുന്നതിന്
പൈത്തണ്‍ ഭാഷയിലുപയോഗിക്കുന്ന
നിര്‍ദ്ദേശമാണ് range
എന്നത്. പൈത്തണില്‍
സംഖ്യകളുടെ സമാന്തരശ്രേണികള്‍
(arithmetic
progressions) നിര്‍മ്മിക്കാനുള്ള
ഒരു മാര്‍ഗ്ഗം കൂടിയാണ് range()IDLE
തുറന്ന്
താഴെക്കാണുന്ന പ്രോഗ്രാം
പരീക്ഷിച്ചുനോക്കുക range(10) range(1,11) range(1,2,11) 
range(10) എന്ന
പ്രോഗ്രാം ശകലം IDLE
സോഫ്റ്റ്‌വെയറില്‍
പ്രവര്‍ത്തിക്കുമ്പോള്‍,
നമുക്ക്, പൂജ്യം
മുതല്‍ സൂചിപ്പിച്ച സംഖ്യയ്ക്ക്
തൊട്ടുമുമ്പുവരെയുള്ള
പൂര്‍ണ്ണസംഖ്യകളുടെ ഒരു
ശ്രേണി [,
] എന്നീ
ചതുര ബ്രായ്ക്കറ്റുകള്ക്കുള്ളിലായി
ലഭിക്കുന്നു.
ഇങ്ങനെ
ചതുര ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളില്‍
അര്‍ധവിരാമം (കോമ
:
, ) ഉപയോഗിച്ച്
വേര്‍തിരിച്ച് മൂല്യങ്ങള്‍
എഴുതുന്നതിന് ലിസ്റ്റ് (
list) എന്നാണ്
പൈത്തണില്‍ പറയുക.
a=range(10) എന്ന
നിര്‍ദ്ദേശം നല്കിയാല്‍
0,1,2,3,4,5,6,7,8,9 എന്നീ
സംഖ്യകള്‍ a എന്ന
ചരത്തില്‍ ശേഖരിക്കപ്പെടും.
ഇതിനു പകരമായി
a=range(0,10) എന്ന്
നല്കിയാലും മതി.
a=range(1,10,2) എന്ന
നിര്‍ദ്ദേശം നല്കിയാല്‍ 10
നു താഴെയുള്ള ഒറ്റ
സംഖ്യകള്‍ (1,3,5,7,9) a എന്ന
ചരത്തില്‍ ശേഖരിക്കപ്പെടും.
പൈത്തണ്‍
ഗ്രാഫിക് നിര്‍ദ്ദേശങ്ങള്‍
from turtle import* – ടര്‍ട്ടില്‍
ഗ്രാഫിക്സ് കമ്പ്യൂട്ടറില്‍
പ്രവര്‍ത്തനക്ഷമമാക്കുന്നതിന്
പ്രോഗ്രാമിന്റെ തുടക്കത്തില്‍
നല്കണം.
forward( ) – ടര്‍ട്ടില്‍
വലതുവശത്തേക്ക് ചലിപ്പിക്കുന്നതിന്
right( ) – ടര്‍ട്ടിലിന്റെ
ദിശ നിശ്ചിത ഡിഗ്രി വലത്തോട്ടു
തിരിയാന്‍
left( ) – ടര്‍ട്ടിലിന്റെ
ദിശ നിശ്ചിത ഡിഗ്രി ഇടത്തോട്ടു
തിരിയാന്‍
showturtle( ) – ടര്‍ട്ടില്‍
പ്രത്യക്ഷപ്പെടാന്‍
hideturtle( ) – ടര്‍ട്ടില്‍
അപ്രത്യക്ഷമാകാന്‍
circle( ) – ടര്‍ട്ടില്‍
വൃത്താകൃതിയില്‍ ചലിപ്പിക്കുന്നതിന്
dot( ) – ഒരു
ബിന്ദു രേഖപ്പെടുത്തുന്നതിന്
penup( ) – വരകള്‍
തെളിയാതെ ടര്‍ട്ടില്‍
ചലിപ്പിക്കുന്നതിന്
pendown( ) – ടര്‍ട്ടില്‍
ചലിപ്പിക്കുന്നതിന് അനുസരിച്ച്
വര തെളിയാന്‍
pencolor() – രൂപങ്ങളുടെ
നിറം നിര്‍ണ്ണയിക്കാന്‍
pensize() – വരകളുടെ
വീതി നിര്‍ണ്ണയിക്കാന്‍
write() – ഗ്രാഫിക്
സ്ക്രീനില്‍ ഒരു സംഖ്യ പ്രന്റ്
ചെയ്യാന്‍
time.sleep() – രണ്ടു
നിര്‍ദ്ദേശങ്ങള്‍ക്കിടയില്‍
ഒരു നിശ്ചിത സമയം pause ചെയ്യുവാന്‍
import time – സമയവുമായി
ബന്ധപ്പെട്ട നിര്‍ദ്ദേശങ്ങള്‍
പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്താന്‍
പ്രോഗ്രാമിന്റെ തുടക്കത്തില്‍
നല്കണം.
clear() – ഗ്രാഫിക്
സ്ക്രീനിലെ വരകളും എഴുത്തുകളും
പൂര്‍ണ്ണമായും ഇല്ലാതാക്കാന്‍
ഉദാ 1:
ഉദാ 1:
60 സെക്കന്റ് മുതല്‍ ഒരു സെക്കന്റ് വരെ
കാണിക്കുന്ന കൗണ്ട് ഡൗണ്‍ ക്ലോക്ക് നിര്‍മ്മിക്കാനുള്ള പ്രോഗ്രാം താഴെ
കൊടുത്ത രീതിയില്‍ IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് തയ്യാറാക്കി നോക്കൂ.
from turtle import*
import time
hideturtle()
for s in range (60,0,-1):
write(s)
time.sleep(1)
clear()
ഉദാ 2:
ഒരു ജ്യാമിതീയ പാറ്റേണ്‍ നിര്‍മ്മിക്കാനുള്ള പ്രോഗ്രാം താഴെ കൊടുത്ത രീതിയില്‍ IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് തയ്യാറാക്കി നോക്കൂ.
from turtle import*
pencolor("blue")
pensize(4)
for i in range(8):
rt(45)
circle(50)
ഉദാ 3:
from turtle import*
import time
hideturtle()
for s in range (60,0,-1):
write(s)
time.sleep(1)
clear()
ഉദാ 2:
ഒരു ജ്യാമിതീയ പാറ്റേണ്‍ നിര്‍മ്മിക്കാനുള്ള പ്രോഗ്രാം താഴെ കൊടുത്ത രീതിയില്‍ IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് തയ്യാറാക്കി നോക്കൂ.
from turtle import*
pencolor("blue")
pensize(4)
for i in range(8):
rt(45)
circle(50)
ഉദാ 3:
ഏതു
സംഖ്യയുടേയും ഗുണനപ്പട്ടിക
കാണാനുള്ള ഒരു പ്രോഗ്രാം.
കമ്പ്യൂട്ടര്‍
ഒരു സംഖ്യ ഇന്‍പുട്ടായി
സ്വീകരിക്കുകയും തുടര്‍ന്ന്
ആ ഗുണനപ്പട്ടിക പ്രിന്റ്
ചെയ്യുകയും ചെയ്യുന്നു.
n=input("Enter a Number : ")
for i in range(1,11):
print i,"x",n,"=",i*n
for i in range(1,11):
print i,"x",n,"=",i*n
(ഈ പ്രോഗ്രാമില്‍ ഗ്രാഫിക് നിര്‍ദ്ദേശങ്ങളില്ലാത്തതിനാല്‍ ഉത്തരം Python Shell ജാലകത്തിലാണ് ദൃശ്യമാകുക.)
Posted on 1st April 2012 by Suresh Babu P P
Lesson 9
പ്രോഗ്രാമില്‍
ഉള്‍പ്പെടുത്തിയിട്ടുള്ള
ഏതെങ്കിലും നിര്‍ദ്ദേശങ്ങള്‍
ആവര്‍ത്തിച്ച് പ്രവര്‍ത്തിക്കണമെങ്കില്‍
അവ വീണ്ടും വീണ്ടും ടൈപ്പു
ചെയ്യേണ്ടതില്ലെന്നും പകരം
for
എന്ന
നിര്‍ദ്ദേശത്തോടൊപ്പം
നല്കിയാല്‍ മതിയെന്നും നാം
മനസ്സിലാക്കിയിട്ടുണ്ട്.
അതായത്
for
എന്നത്
ഒരു ആവര്‍ത്തന നിര്‍ദ്ദേശമാണ്
(Loop
statement). പൈത്തണ്‍
ഉള്‍പ്പടെയുള്ള കമ്പ്യൂട്ടര്‍
ഭാഷകളില്‍ for
നിര്‍ദ്ദേശത്തെപ്പോലെതന്നെ
while
നിര്‍ദ്ദേശവും
ഉപയോഗി ക്കാറുണ്ട്.
ഒരു
വ്യവസ്ഥ ശരിയാകുന്നതുവരെ
കുറേ കാര്യങ്ങള്‍ ആവര്‍ത്തിച്ച്
ചെയ്യാന്‍ പൈത്തണിലും മറ്റ്
മിക്ക കംപ്യൂട്ടര്‍ ഭാഷകളിലുമുള്ള
ഉപാധിയാണ് while.
ഒരേ
പ്രോഗ്രാം for,
while എന്നിവ
ഉപയോഗിച്ച് നിര്‍മ്മിച്ചിരിക്കുന്നത്
താഴെ കൊടുക്കുന്നു.
from turtle import*
clear()
pencolor("red")
for i in range(6):
rt(60)
circle(100)
clear()
pencolor("red")
for i in range(6):
rt(60)
circle(100)
from turtle import*
clear()
pencolor("red")
i=0
while(i<6 br="br"> rt(60)
circle(100)
i=i+1
IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് രണ്ട് പ്രേഗ്രാമുകളും തയ്യാറാക്കി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.
ഉദാ : നൂറിനു താഴെയുള്ള ഒറ്റ സംഖ്യകള്‍ പ്രിന്റ് ചെയ്യുന്നതിനുള്ള ഒരു പ്രോഗ്രാം for ഉപയോഗിച്ചും while ഉപയോഗിച്ചും തയ്യാറാക്കിയത് ശ്രദ്ധിക്കുക.
for i in range (1,100,2):
print i
i=1
while (i<100 br="br"> print i
i=i+2
clear()
pencolor("red")
i=0
while(i<6 br="br"> rt(60)
circle(100)
i=i+1
IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് രണ്ട് പ്രേഗ്രാമുകളും തയ്യാറാക്കി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.
ഉദാ : നൂറിനു താഴെയുള്ള ഒറ്റ സംഖ്യകള്‍ പ്രിന്റ് ചെയ്യുന്നതിനുള്ള ഒരു പ്രോഗ്രാം for ഉപയോഗിച്ചും while ഉപയോഗിച്ചും തയ്യാറാക്കിയത് ശ്രദ്ധിക്കുക.
for i in range (1,100,2):
print i
i=1
while (i<100 br="br"> print i
i=i+2
for നിര്‍ദ്ദേശത്തില്‍
ആവര്‍ത്തനചരത്തിന്റെ (iterating
variable) തുടക്ക
വിലയും (initial
value) വര്‍ദ്ധനവും
(increment) പരിധിയും
(exit condition).
എന്നാല്‍ while
നിര്‍ദ്ദേശത്തില്‍
പരിധി (exit
condition) മാത്രമേ
നിര്‍ദ്ദേശത്തില്‍
ഉള്‍പ്പെടുന്നുള്ളൂ.
for നിര്‍ദ്ദേശത്തില്‍
range ഫങ്ഷന്
ഉള്‍പ്പെട്ടിരിക്കും.
എന്നാല്‍ while
നിര്‍ദ്ദേശത്തോടൊപ്പം
range ഫങ്ഷന്
ചേര്‍ക്കേണ്ടതില്ല.
ആവര്‍ത്തന
ചരത്തിന്റെ തുടക്കവില while
നിര്‍ദ്ദേശത്തിനു
മുമ്പാണ് നല്കേണ്ടത്.
ആവര്‍ത്തന
ചരത്തിന്റെ വര്‍ധനവ് /
കുറവ് while
നിര്‍ദ്ദേശത്തിനകത്തെ
ഒരു നിര്‍ദ്ദേശമായാണ്
നല്കേണ്ടത്.
അല്ലെങ്കില്‍
while നിര്‍ദ്ദേശം
നില്‍ക്കാതെ പ്രവര്‍ത്തിച്ചു കൊണ്ടിരിക്കും.
from turtle import*
clear()
pencolor("red")
for
നിര്‍ദ്ദേശത്തിനകത്ത്
വീണ്ടും for
നിര്‍ദ്ദേശം
ഉള്‍പ്പെടുത്തുന്ന താഴെ
കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം
ശ്രദ്ധിക്കുക.
clear()
pencolor("red")
for i in range(6):
rt(60)
for j in range(30,71,10):
circle(j)
Posted on 4th April 2012 by Suresh Babu P P
Lesson 10
ഫങ്ഷനുകള്‍
ഒരു പ്രോഗ്രാമില്‍ ഒരേ കോഡുതന്നെ വീണ്ടും വീണ്ടും ഉപയോഗിക്കേണ്ടതായി വരാം. നമുക്ക് വീണ്ടും വീണ്ടും ഉപയോഗിക്കേണ്ട കാര്യങ്ങള്‍ ഒരു ഫങ്ഷനായി എഴുതുകയും അതിനെ ആവശ്യമുളള സ്ഥലത്തേക്ക് വിളിക്കുകയും ചെയ്യാം. ഫങ്ഷനുകള്‍
എന്നാല്‍ സബ് പ്രോഗ്രാമുകളാണ്. സ്വതന്ത്രമായി നില്‍ക്കുന്ന ഇത്തരം സബ്
പ്രോഗ്രാമുകളെ ആവശ്യമുള്ള സന്ദര്‍ഭങ്ങളില്‍ മറ്റു പ്രോഗ്കാമുകള്‍ക്ക്
പ്രയോജനപ്പെടുത്തുകയും ചെയ്യാം.
കാല്‍ക്ക്
സോഫ്റ്റ്‌വെയറില്‍ നാം
ഉപയോഗിക്കുന്ന sum, average, count
തുടങ്ങിയ ഫങ്ഷനുകള്‍
പോലെ ഗണിതക്രിയകള്‍
എളുപ്പമാക്കുന്നതും വീണ്ടും
വീണ്ടും ഉപയോഗിക്കാന്‍
കഴീയുന്നതുമായ ഫങ്ഷനുകള്‍
പൈത്തണ്‍ ഭാഷയിലും നിര്‍മ്മിക്കാന്‍
കഴിയും.
ഒരു ഫങ്ഷന് നിര്‍വചിക്കുവാന്‍ നമ്മള്‍ def എന്ന കീവേഡാണുപയോഗിക്കുന്നത്.
രണ്ടു
സംഖ്യകളുടെ തുക കാണുന്നതിനുള്ള
പൈത്തണ്‍ ഫങ്ഷന് താഴെ
നല്കുന്നു.
def sum(a,b):
c=a+b
return c
ഇതില്‍
def sum(a,b): എന്നത്
രണ്ട് ചരങ്ങളുടെ വിലകള്‍
സ്വീകരിക്കാന്‍ കഴിയുന്ന
sum എന്ന പേരിലുള്ള
ഫങ്ഷന് നിര്‍മ്മിക്കുന്നതിനുള്ള
നിര്‍ദ്ദേശം നല്കുന്നതിനുപയോഗിക്കുന്നു.
c=a+b എന്നത്
ഫങ്ഷനിലേക്ക് ലഭ്യമാകുന്ന
രണ്ട് വിലകള്‍ തമ്മില്‍ കൂട്ടി
c എന്ന ചരത്തില്‍
ശേഖരിക്കുന്നതിന് സഹായിക്കുന്നു.
return c എന്നത്
ഫങ്ഷന് ഉപയോഗപ്പെടുത്തുന്ന
പ്രോഗ്രാമിന് രണ്ടു സംഖ്യകളുടെ
തുക തിരികെ നല്കുന്നതിന്
സഹായിക്കുന്നു.
ഫങ്ഷനുകള്‍
തയ്യാറാക്കുമ്പോള്‍ ശ്രദ്ധിക്കേണ്ട
കാര്യങ്ങള്‍ :
ഫങ്ഷന്
നിര്‍മ്മിക്കുന്നതിന് def
നിര്‍ദ്ദേശം നല്കണം.
ഫങ്ഷന്
ഇഷ്ടമുള്ള പേര് നല്കാം.
(മുകളിലെ ഉദാഹരണത്തില്‍
sum എന്നാണ്
നല്കിയിരിക്കുന്നത്)
ഫങ്ഷനിലേക്ക്
നല്കുന്ന വിലകളെ സൂചിപ്പിക്കുന്ന
ചരങ്ങള്‍ ഫങ്ഷന്റെ പേരിനു
ശേഷം ബ്രാക്കറ്റിലാണ്
നല്കേണ്ടത്.
ഫങ്ഷന്
പ്രവര്‍ത്തിക്കുമ്പോള്‍ഉണ്ടാകുന്ന
ഉത്തരം തിരികെ പ്രധാന പ്രോഗ്രാമിനു
ലഭിക്കണമെങ്കില്‍ return
നിര്‍ദേശമാണ്
ഉപയോഗിക്കേണ്ടത്.
മുകളില്‍ നല്കിയ തുക കാണാനുള്ള ഫങ്ഷന് ടൈപ്പ് ചെയ്ത് function.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ (pythonsb) സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത്
(add.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ (pythonsb) സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
import function
x=input("Enter first number:")
y=input("Enter second number:")
print "sum =",function.sum(x,y)
ഉദാ: സംഖ്യകളുടെ ഗുണനഫലം (പട്ടിക) കാണുന്നതിനുളുള്ള പൈത്തണ്‍ പ്രോഗ്രാം
x=input("Enter first number:")
y=input("Enter second number:")
print "sum =",functions.sum(x,y)
print "difference =",functions.diff(x,y)
print "Product =",functions.prod(x,y)
print "Quotient =",functions.quot(x,y)
print "Remainder =",functions.rem(x,y)
ഒരു ഫയലില്‍ ഒന്നില്‍ക്കൂടുതല്‍ ഫങ്ഷനുകള്‍ ഉള്‍പ്പെടുത്താവുന്നതാണ്. വ്യത്യസ്ത ഫങ്ഷനുകളും ക്ലാസ്സുകളുമെല്ലാം ചേര്‍ന്ന ഫയലുകളാണ് മൊഡ്യൂളുകള്‍ എന്നറിയപ്പെടുന്നത്. പൈത്തണ്‍ ഭാഷയോടൊപ്പം തന്നെ ഇത്തരം ധാരാളം മൊഡ്യൂളുകള്‍ ലഭ്യമാണ്. ഇവ import എന്ന നിര്‍ദ്ദേശത്തിന്റെ സഹായത്തോടെ നമ്മുടെ പ്രോഗ്രാമിലും ഉള്‍പ്പെടുത്താം. (eg: import time, from turtle import* ....) ഒരു മൊഡ്യൂള്‍ നമ്മുടെ പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തുമ്പോള്‍ ആ മൊഡ്യൂളിലുള്ള എല്ലാ ഫങ്ഷനുകളും നമ്മുടെ പ്രോഗ്രാമിലും ലഭ്യമാകും.
മുകളില്‍ നല്കിയ തുക കാണാനുള്ള ഫങ്ഷന് ടൈപ്പ് ചെയ്ത് function.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ (pythonsb) സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത്
(add.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ (pythonsb) സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
import function
x=input("Enter first number:")
y=input("Enter second number:")
print "sum =",function.sum(x,y)
ഉദാ: സംഖ്യകളുടെ ഗുണനഫലം (പട്ടിക) കാണുന്നതിനുളുള്ള പൈത്തണ്‍ പ്രോഗ്രാം
def prod(a,b):
c=a*b
return c
മുകളില്‍ നല്കിയ ഗുണനഫലം കാണാനുള്ള ഫങ്ഷന് ടൈപ്പ് ചെയ്ത് myfunction.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത് (mt.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
import myfunction
n=input("Enter a Number:")
for i in range(1,11):
print i,"x",n,"=",myfunction.prod(i,n)
ഉദാ: തുക, വ്യത്യാസം, ഗുണനഫലം, ഹരണഫലം, ശിഷ്ടം തുടങ്ങിയവ കാണാന്‍ സഹായിക്കുന്ന ഫങ്ഷനുകള്‍ അടങ്ങിയ പ്രോഗ്രാം.
def sum(a,b):
return (a+b)
def diff(a,b):
return (a-b)
def prod(a,b):
return (a*b)
def quot(a,b):
return (a/b)
def rem(a,b):
return (a%b)
മുകളില്‍ നല്കിയ ഫങ്ഷനുകള്‍ ടൈപ്പ് ചെയ്ത് functions.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത് (cal.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
import functionsമുകളില്‍ നല്കിയ ഗുണനഫലം കാണാനുള്ള ഫങ്ഷന് ടൈപ്പ് ചെയ്ത് myfunction.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത് (mt.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
import myfunction
n=input("Enter a Number:")
for i in range(1,11):
print i,"x",n,"=",myfunction.prod(i,n)
ഉദാ: തുക, വ്യത്യാസം, ഗുണനഫലം, ഹരണഫലം, ശിഷ്ടം തുടങ്ങിയവ കാണാന്‍ സഹായിക്കുന്ന ഫങ്ഷനുകള്‍ അടങ്ങിയ പ്രോഗ്രാം.
def sum(a,b):
return (a+b)
def diff(a,b):
return (a-b)
def prod(a,b):
return (a*b)
def quot(a,b):
return (a/b)
def rem(a,b):
return (a%b)
മുകളില്‍ നല്കിയ ഫങ്ഷനുകള്‍ ടൈപ്പ് ചെയ്ത് functions.py എന്ന പേരില്‍ സ്വന്തം ഫോള്‍ഡറില്‍ സേവ് ചെയ്യുക. അതിനു ശേഷം താഴെ നല്കിയിരിക്കിന്ന പ്രോഗ്രാം ടൈപ്പ് ചെയ്ത് (cal.py എന്ന പേരില്‍) മുന്‍പ് തയ്യാറാക്കിയ അതേ ഫോള്‍ഡറില്‍ സേവ് ചെയ്തതിനുശേഷം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.
x=input("Enter first number:")
y=input("Enter second number:")
print "sum =",functions.sum(x,y)
print "difference =",functions.diff(x,y)
print "Product =",functions.prod(x,y)
print "Quotient =",functions.quot(x,y)
print "Remainder =",functions.rem(x,y)
ഒരു ഫയലില്‍ ഒന്നില്‍ക്കൂടുതല്‍ ഫങ്ഷനുകള്‍ ഉള്‍പ്പെടുത്താവുന്നതാണ്. വ്യത്യസ്ത ഫങ്ഷനുകളും ക്ലാസ്സുകളുമെല്ലാം ചേര്‍ന്ന ഫയലുകളാണ് മൊഡ്യൂളുകള്‍ എന്നറിയപ്പെടുന്നത്. പൈത്തണ്‍ ഭാഷയോടൊപ്പം തന്നെ ഇത്തരം ധാരാളം മൊഡ്യൂളുകള്‍ ലഭ്യമാണ്. ഇവ import എന്ന നിര്‍ദ്ദേശത്തിന്റെ സഹായത്തോടെ നമ്മുടെ പ്രോഗ്രാമിലും ഉള്‍പ്പെടുത്താം. (eg: import time, from turtle import* ....) ഒരു മൊഡ്യൂള്‍ നമ്മുടെ പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തുമ്പോള്‍ ആ മൊഡ്യൂളിലുള്ള എല്ലാ ഫങ്ഷനുകളും നമ്മുടെ പ്രോഗ്രാമിലും ലഭ്യമാകും.
Posted on 6th April 2012 by Suresh Babu P P
