Lesson 15_Pyton

താഴെ കൊടുത്തവ ഓരോന്നും gedit ലോ IDLE സോഫ്‌റ്റ്‌വെയറിലോ തയ്യാറാക്കി  save  ചെയ്‌ത ശേഷം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ. 

Program 1.

 

Program 2.

Program 3.




Program 4.

Program 5.

Program 6. 

 

Lesson 14_Python

 കാല്‍ക്കുലേറ്റര്‍ നിര്‍മ്മാണം Python / wxGlade ഉപയോഗിച്ച്

 

1.  Applications → Programming → wxGlade Add a Frame

2.  Add a GridSizer (കഴിഞ്ഞ അധ്യായത്തില്‍ വിശദീകരിച്ചിട്ടുണ്ട്.) 

3.  ആവശ്യമായ ടോക്‌സ്റ്റ് ബോക്‌സുകളും ബട്ടണുകളും ഉള്‍പ്പെടുത്തുക.

    ( ഒരു ടക്‌സ്‌റ്റ് ബോക്‌സും 18 ബട്ടണുകളുമാണ്  ഉള്‍പ്പെടുത്തിയിരിക്കുന്നത്.)

4.  ടെക്‌സ്റ്റ് ബോക്‌സ് സെലക്‌ട് ചെയ്‌ത് Properties ജാലകത്തിലെ Common ടാബിലെtext_ctrl_1 എന്നതിനു പകരം മറ്റൊരു പേര്  x  എന്നു നല്‍കാം. 

5.  ഓരോ ബട്ടണും സെലക്‌ട് ചെയ്ത് Properties ജാലകത്തിലെ Widget ടാബിലെ Button_1, Button_2,..... തുടങ്ങിയവയ്ക്കു പകരം 1,2,........Add(+),Sub(-),....മുതയായവ നല്കുക. തുടര്‍ന്ന് Events ടാബ് സെലക്‌ട് ചെയ്‌ത് Handler എന്ന ഭാഗത്ത് ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ പ്രവര്‍ത്തിക്കേണ്ട ഫങ്‌ഷന്റെ പേര് ചേര്‍ക്കണം.( click 1, click 2,.....,click9,click0,sum, minus, div.....എന്നിങ്ങനെയാണ് ഇവിടെ കൊടുത്തിരിക്കുന്നത്.)

6.  പൈത്തണ്‍ കോഡ് നിര്‍മ്മാണം :
wxGlade ജാലകത്തിലെ Applications ക്ലിക്കു ചെയ്യുക. അതിനു ശേഷം Properties ജാലകത്തില്‍ Language എന്നതില്‍ python സെലക്‌ട് ചെയ്‌ത് Output path ഓപ്‌ഷനു നേരെയുള്ള ബട്ടണില്‍ ക്ലിക്കു ചെയ‌ത് ആവശ്യമായ ഫോള്‍ഡര്‍ തെരഞ്ഞെടുത്ത് ഫയല്‍ നാമം നല്‍കി (calculator.py) Save വട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. .py എന്ന എക്‌സ്‌റ്റന്‍ഷന്‍ നിര്‍ബന്ധമായും നല്‍കണം. തുടര്‍ന്ന് Generate Code ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. Code generation completed successfully എന്ന ഒരു Information കാണാം. OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. .wxg എന്ന എക്‌സ്‌റ്റന്‍ഷനോടുകൂടി ഈ പ്രോജക്ട് സേവ് ചെയ്യാം. (File--> Save) സേവ് ചെയ്‌തിരിക്കുന്ന പൈത്തണ്‍ ഫയല്‍ (calculator.py) gedit text editor ല്‍ തുറന്ന് താഴെ കൊടുത്തിരിക്കുന്ന മാറ്റങ്ങള്‍ വരുത്തുക.

click 1 ഫങ്‌ഷന്റെ കോഡു വരുന്ന ഭാഗത്ത് print "Event handler `click1' not implemented!" എന്നതിനു പകരം 
 
v = '1'

t = self.x.GetValue()

t = t + v

self.x.SetValue(t)

എന്നാണ് gedit text editor ല്‍ മാറ്റേണ്ടത്. ഇതുപോലെ മറ്റ് ബട്ടണുകളുമായി ബന്ധപ്പെട്ട (Numbers) അനുബന്ധ ടെക്‌സ്റ്റുകളും മാറ്റേണ്ടതാണ്. (v = '1' എന്നതിനു പകരം v = '2' എന്ന മാറ്റം മാത്രം വരുത്തിയാല്‍ മതിയാകും click 2 ഫങ്‌ഷന്റെ കോഡു വരുന്നതില്‍). ഇവിടെ x എന്നത്  ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരാണ്. v,t എന്നിവയ്ക്കു പകരം ഏതു പേരും നല്കാം.(v = '1' എന്നതിനു പകരം v = '+' എന്ന മാറ്റം മാത്രം വരുത്തിയാല്‍ മതിയാകും sum ഫങ്‌ഷന്റെ കോഡു വരുന്നതില്‍)

equals ഫങ്‌ഷന്റെ കോഡു വരുന്ന ഭാഗത്ത് print "Event handler `equals' not implemented!" എന്നതിനു പകരം താഴെ കൊടുത്തിരിക്കുന്ന രീതിയില്‍ മാറ്റം വരുത്തുക.

clear ഫങ്‌ഷന്റെ കോഡു വരുന്ന ഭാഗത്ത് print "Event handler `clear' not implemented!" എന്നതിനു പകരം താഴെ കൊടുത്തിരിക്കുന്ന രീതിയിലും മാറ്റം വരുത്തുക.


ഫയല്‍ സേവ് ചെയ്‌തതിനുശേഷം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.

മറ്റൊരു വിധത്തില്‍

1. Applications → Programming → wxGlade
2. Add a Frame
3. Add a GridSizer (കഴിഞ്ഞ അധ്യായത്തില്‍ വിശദീകരിച്ചിട്ടുണ്ട്.)
4. ആവശ്യമായ ടോക്‌സ്റ്റ് ബോക്‌സുകളും ബട്ടണുകളും ഉള്‍പ്പെടുത്തുക.
5. ഓരോ ടെക്‌സ്റ്റ് ബോക്‌സും സെലക്‌ട് ചെയ്‌ത് Properties ജാലകത്തിലെ Common ടാബിലെ text_ctrl_1, text_ctrl_2,text_ctrl_3 ,text_ctrl_4 എന്നിവയ്ക്കു പകരം മറ്റു പേരുകള്‍ x,y,z,a വേണമെങ്കില്‍ നല്‍കാം.
6. ഓരോ ബട്ടണും സെലക്‌ട് ചെയ്ത് Properties ജാലകത്തിലെ Widget ടാബിലെ Button_1, Button_2,..... തുടങ്ങിയവയ്ക്കു പകരം 1,2,........+,-,/,....മുതയായവ നല്കുക. തുടര്‍ന്ന് Events ടാബ് സെലക്‌ട് ചെയ്‌ത് Handler എന്ന ഭാഗത്ത് ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ പ്രവര്‍ത്തിക്കേണ്ട ഫങ്‌ഷന്റെ പേര് ചേര്‍ക്കണം.( click 1, click 2,.....,click9,click0,sum, minus, div.....എന്നിങ്ങനെയാണ് ഇവിടെ കൊടുത്തിരിക്കുന്നത്.)
7. പൈത്തണ്‍ കോഡ് നിര്‍മ്മാണം :
   wxGlade ജാലകത്തിലെ Applications ക്ലിക്കു ചെയ്യുക. അതിനു ശേഷം Properties ജാലകത്തില്‍ Language എന്നതില്‍ python സെലക്‌ട് ചെയ്‌ത് Output path ഓപ്‌ഷനു നേരെയുള്ള ബട്ടണില്‍ ക്ലിക്കു ചെയ‌ത് ആവശ്യമായ ഫോള്‍ഡര്‍ തെരഞ്ഞെടുത്ത് ഫയല്‍ നാമം നല്‍കി (calculator.py) Save വട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. .py എന്ന എക്‌സ്‌റ്റന്‍ഷന്‍ നിര്‍ബന്ധമായും നല്‍കണം. തുടര്‍ന്ന് Generate Code ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. Code generation completed successfully എന്ന ഒരു Information കാണാം. OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. .wxg എന്ന എക്‌സ്‌റ്റന്‍ഷനോടുകൂടി ഈ പ്രോജക്ട് സേവ് ചെയ്യാം. (File--> Save)
   6. സേവ് ചെയ്‌തിരിക്കുന്ന പൈത്തണ്‍ ഫയല്‍ (calculator.py) gedit text editor ല്‍ തുറന്ന് താഴെ കൊടുത്തിരിക്കുന്ന മാറ്റങ്ങള്‍ വരുത്തുക. 
   click 1 ഫങ്‌ഷന്റെ കോ‍ഡു വരുന്ന ഭാഗത്ത് print "Event handler `click1' not implemented!" എന്നതിനു പകരം

v = '1'

t = self.x.GetValue()

t = t + v

self.x.SetValue(t)

എന്നാണ് gedit text editor ല്‍ മാറ്റേണ്ടത്. ഇതുപോലെ മറ്റ് ബട്ടണുകളിലെ (Numbers) അനുബന്ധ ടെക്‌സ്റ്റുകളും മാറ്റേണ്ടതാണ്. (v = '1' എന്നതിനു പകരം v = '2' എന്ന മാറ്റം മാത്രം വരുത്തിയാല്‍ മതിയാകും click 2 ഫങ്‌ഷന്റെ കോ‍ഡു വരുന്നതില്‍). ഇവിടെ x എന്നത് മൂന്നാമത്തെ ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരാണ്. v,t എന്നിവയ്ക്കു പകരം ഏതു പേരും നല്കാം.

plus ഫങ്‌ഷന്റെ കോ‍ഡു വരുന്ന ഭാഗത്ത് print "Event handler `plus' not implemented!" എന്നതിനു പകരം

c = float(self.x.GetValue())

self.z.SetValue(str(c))

self.y.SetValue('+')

self.x.SetValue('')

ഇവിടെ x എന്നത് മൂന്നാമത്തെ ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരും, y എന്നത് രണ്ടാമത്തെ ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരും, z എന്നത് ഒന്നാമത്തെ ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരുമാണ്. ഇതുപോലെ മറ്റ് ബട്ടണുകളിലെ (minus, multi, div) അനുബന്ധ ടെക്‌സ്റ്റുകളും മാറ്റേണ്ടതാണ്. മൂന്നാമത്തെ വരിയിലെ '+' എന്നതിനു പകരം ആവശ്യമായ മാറ്റങ്ങള്‍ മാത്രം വരുത്തിയാല്‍ മതി.

equals ഫങ്‌ഷന്റെ കോഡു വരുന്ന ഭാഗത്ത് print "Event handler `equals' not implemented!" എന്നതിനു പകരം

c = float(self.x.GetValue())

d = float(self.z.GetValue())

e = self.y.GetValue()

if(e == '+' ):

ans=c+d

elif(e == 'x' ):

ans=c*d

elif(e == '-' ):

ans=d-c

else:

ans=d/c

self.a.SetValue(str(ans))

എന്നാണ് gedit text editor ല്‍ മാറ്റേണ്ടത്. ഇവിടെ a എന്നത് നാലാമത്തെ ടോക്‌സ്റ്റ് ബോക്‌സിന്റെ പേരാണ്. c, d, e, ans തുടങ്ങിയവയ്ക്കു പകരം ഏതു പേരും നല്കാം.

clear ഫങ്‌ഷന്റെ കോഡു വരുന്ന ഭാഗത്ത് print "Event handler `clear' not implemented!" എന്നതിനു പകരം

self.x.SetValue(' ')

self.y.SetValue(' ')

self.z.SetValue(' ')

self.a.SetValue(' ')

എന്നാണ് gedit text editor ല്‍ മാറ്റേണ്ടത്. ഇത്രയും മാറ്റങ്ങള്‍ വരുത്തി ഫയല്‍ സേവ് ചെയ്‌തതിനുശേഷം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.
Click here

Code 

Lesson 13_Python

.

മുകളില്‍ കൊടുത്തിരിക്കുന്ന രീതിയിലുള്ള ഒരു ഫ്രെയിം wxGlade ഉപയോഗിച്ച് തയ്യാറാക്കി അതില്‍ ഒരു സര്‍ക്കാര്‍ ജീവനക്കാരന്റെ പേരും വയസ്സു നല്കുമ്പോള്‍ അദ്ദേഹം സര്‍വ്വീസില്‍ നിന്നും വിരിക്കുന്ന വര്‍ഷം കാണിക്കുന്നതിനുള്ള  ഒരു പ്രോഗ്രാം തയ്യാറാക്കുക.
Click here

Lesson 12_Python

wxGlade - Code Generator


വിഷ്വല്‍ പ്രോഗ്രാമുകള്‍ ഉപയോഗിക്കുമ്പോള്‍ പ്രോഗ്രാമിംഗ് എളുപ്പമാകുന്നു.  ഇത് കമ്പ്യൂട്ടര്‍ പ്രോഗ്രാമുകള്‍ തയ്യാറാക്കുന്നതിനുള്ള WYSIWIG ( What You See Is What You Get) മാതൃകകളാണ്.  സാധാരണ പ്രോഗ്രാമിംഗ് ഭാഷകളില്‍ ഒരു ചതുരം വരയ്ക്കുന്നതിന് ബന്ധപ്പെട്ട കോഡുകളടങ്ങിയ നിര്‍ദ്ദേശങ്ങള്‍ ടൈപ്പു ചെയ്യണം.  എന്നാല്‍ വിഷ്വല്‍ പ്രോഗ്രാമുകളില്‍ ഒരു ചതുരം വരയ്ക്കുന്നതിന് Open Office Writer ലേയും മറ്റും പോലെ ഡ്രാഗ് ആന്റ് ഡ്രോപ് മതിയാകും.  പ്രോഗ്രാമിംഗ് ഭാഷയുടെ കോഡുകളും പദവിന്യാസവും അറിയാതെ തന്നെ പ്രോഗ്രാമുകള്‍ തയ്യാറാക്കുന്നതിന് Code Generator സഹായിക്കുന്നു.  പൈത്തണ്‍, C++, Perl, XRC, Lisp എന്നീ പ്രോഗ്രാമിംഗ് ഭാഷകളില്‍ ഉപയോഗിക്കുന്ന ഒരു കോഡ് ജനറേറ്ററാണ്  wxGlade   .

മുകളില്‍ കൊടുത്തിരിക്കുന്ന രീതിയിലുള്ള ഒരു ഫ്രെയിം wxGlade ഉപയോഗിച്ച് തയ്യാറാക്കി അതില്‍ രണ്ടു സംഖ്യകളുടെ തുകയും വ്യത്യാസവും കാണുന്നതിനുള്ള പ്രോഗ്രാം പൂര്‍ത്തിയാക്കുന്നതെങ്ങനെയെന്നു നോക്കാം.
 1.  Applications മെനുവിലെ Programming എന്ന സബ് മെനുവില്‍ നിന്നും wxGlade തൂറക്കുക.മൂന്നു ജാലകങ്ങള്‍ തുറന്നു വരും.
a. wxGlade പ്രധാന ജാലകം (മെനുകളും, ടൂള്‍ ബട്ടണുകള്‍ കാണാം)
b. wxGlade:Tree ജാലകം
c.  Properties ജാലകം.

2.  പ്രധാന ജാലകത്തിലെ Add a Frame (ആദ്യത്തെ ബട്ടണ്‍) ബട്ടണില്‍ ക്ലിക്കു ചെയ്താല്‍ ലഭിക്കുന്ന Select frame class ഡയലോഗ് ബോക്സില്‍ നിന്നും wxFrame ഓപ്‌ഷന്‍ സെലക്‌ട് ചെയ്‌ത് OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക.  പുതിയൊരു ഫ്രെയിം ലഭിക്കും(<design>ജാലകം).  wxGlade:Tree ജാലകത്തില്‍ വരുന്ന മാറ്റം ശ്രദ്ധിക്കുക. Properties ജാലകത്തിലെ widget ടാബ് സെലക്‌ട് ചെയ്‌ത്  Title ബോക്‌സില്‍ ആവശ്യമായ ടൈറ്റില്‍ നല്‌കുക. ഫ്രെയിമിന്റെ Title bar ല്‍ പുതിയ പേര് വന്നിട്ടുണ്ടാകും. ഫ്രെയിമിന്റെ (<design>ജാലകം)  size, background color, foreground color, font ഇവയില്‍ ആവശ്യമായ മാറ്റങ്ങള്‍ നല്‍കുന്നതിനുള്ള ഓപ്‌ഷനുകള്‍ Common ടാബില്‍ ലഭ്യമാണ്.


3.  പ്രധാന ജാലകത്തിലെ Add a GridSizer (അവസാനത്തെ ബട്ടണ്‍) ബട്ടണ്‍ സെലക്‌ട് ചെയ്‌തതിനുശേഷം പുതുതായി ലഭിച്ച ഫ്രെയമിന്റെ (<design>ജാലകം) ഉള്ളില്‍ ക്ലിക്കുചെയ്യുക. അപ്പോള്‍ തുറന്നു വരുന്ന Select sizer attributes ഡയലോഗ് ബോക്‌സില്‍ ആവശ്യമായ വിലകള്‍ (Rows, Columns,....)നല്‍കി OK ബട്ടണില്‍ ക്ലിക്കുചെയ്യുക.  അതോടെ ഫ്രെയിമില്‍ ആവശ്യമായ രീതിയില്‍ വരികളും നിരകളും വന്നിട്ടുണ്ടാകും.

 

4.  ഫ്രെയിമില്‍ അടുത്തതായി നമുക്ക് ലേബലുകളും ടെക്‌സ്‌റ്റ് ബോക്‌സുകളും ബട്ടണുകളും ഉള്‍പ്പെടുത്തണം.
a. ലേബല്‍ നിര്‍മ്മാണം :

പ്രധാന ജാലകത്തിലെ Add a Static Text ബട്ടണ്‍ സെലക്‌ട് ചെയ്‌ത്  <design>ജാലകത്തിന്റെ ആദ്യത്തെ കളത്തില്‍ ക്ലിക്കുചെയ്യുക.  <design>ജാലകത്തിലും  wxGlade:Tree ജാലകത്തിലും ലേബലിന്റെ പേര് തെളിഞ്ഞുവരും. 

Properties ജാലകത്തിലെ Widget ടാബ് സെലക്‌ട്  ചെയ്‌ത് Label 1 എന്നത് മാറ്റി പകരം ആവശ്യമായ ടെക്‌സ്‌റ്റുകള്‍ ചേര്‍ക്കാം (Number 1).

Layout ടാബ് സെലക്‌ട്  ചെയ്‌ത്  ടെക്‌സ്‌റ്റിന്റെ allignment കൃത്യമാക്കാം.  ഇതേ രീതിയില്‍ <design>ജാലകത്തിലെ രണ്ടാമത്തെ Row യിലെ ആദ്യത്തെ കളത്തിലും (Number 2), മൂന്നാമത്തെ Row യിലെ ആദ്യത്തെ കളത്തിലും (Answer)  ആവശ്യമായ ടെക്‌സ്‌റ്റുകള്‍ ചേര്‍ക്കാം.
b. ടെക്‌സ്‌റ്റ് ബോക്‌സ് ഉള്‍പ്പെടുത്തല്‍ 
പ്രധാന ജാലകത്തിലെ Add a TextCtrl ബട്ടണ്‍  സെലക്‌ട് ചെയ്‌ത്  <design>ജാലകത്തിന്റെ രണ്ടാമത്തെ Column - ത്തിലെ ആദ്യത്തെ കളത്തില്‍ ക്ലിക്കു ചെയ്താല്‍ ടെക്‌സ്‌റ്റു ബോക്‌സ് ലഭ്യമാകും.  Properties ജാലകത്തിലെ Layout ടാബ് സെലക്‌ട്  ചെയ്‌ത്  ടെക്‌സ്‌റ്റ്  ബോക്‌സിന്റെ  allignment കൃത്യമാക്കാം. കൂടാതെ Common  ടാബ് സെലക്‌ട്  ചെയ്‌ത് Name ബോക്‌സിലെ text_ctrl_1 എന്നതിനു പകരം മറ്റൊരു പേര് (x) വേണമെങ്കില്‍ നല്‍കാം. ഇതുപോലെ രണ്ടാമത്തെ Column - ത്തിലെ രണ്ടാമത്തെ കളത്തിലും ടെക്‌സ്‌റ്റു ബോക്‌സ് ലഭ്യമാക്കാം. ഇവിടെയും Common  ടാബ് സെലക്‌ട്  ചെയ്‌ത് Name ബോക്‌സിലെ text_ctrl_2 എന്നതിനു പകരം മറ്റൊരു പേര് (y) വേണമെങ്കില്‍ നല്‍കാം.
 c.ബട്ടണുകള്‍ ചേര്‍ക്കല്‍
 പ്രധാന ജാലകത്തിലെ Add a Button ടൂള്‍ സെലക‌്ട് ചെയ്‌ത്  ആദ്യത്തെ Row യിലെ അവസാനത്തെ കളത്തില്‍ ക്ലിക്കുചെയ്യുമ്പോള്‍ അവിടെ ഒരു ബട്ടണ്‍ പ്രത്യക്ഷമാകും  Properties ജാലകത്തിലെ Widget ടാബ് സെലക്‌ട്  ചെയ്‌ത്  Button_ 1 എന്നത് മാറ്റി പകരം ആവശ്യമായ ടെക്‌സ്‌റ്റുകള്‍ ചേര്‍ക്കാം (Add  or +).  അതിനു ശേഷം  Properties ജാലകത്തിലെ Events  ടാബ് സെലക്‌ട്  ചെയ്‌ത്  Handler എന്ന ഭാഗത്ത് ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ പ്രവര്‍ത്തിക്കേണ്ട ഫങ്‌ഷന്റെ പേര്  (sum) ചേര്‍ക്കണം. ഇതുപോലെ തൊട്ടുതാഴെയുള്ള കളത്തിലും ഒരു ബട്ടണ്‍ഉള്‍പ്പെടുത്തുക (subtract 0r -).  Properties ജാലകത്തിലെ Events  ടാബ് സെലക്‌ട്  ചെയ്‌ത്  Handler എന്ന ഭാഗത്ത് ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുമ്പോള്‍ പ്രവര്‍ത്തിക്കേണ്ട ഫങ്‌ഷന്റെ പേര്  (diff) ചേര്‍ക്കണം.
ഉത്തരം പ്രത്യക്ഷപ്പെടേണ്ട കളത്തില്‍ മറ്റൊരു ബട്ടണ്‍ ഉള്‍പ്പെടുത്തുക.   Properties ജാലകത്തിലെ Widget ടാബ് സെലക്‌ട്  ചെയ്‌ത്  Button_ 3 എന്നത് ഒഴിവാക്കണം.  കൂടാതെ Common  ടാബ് സെലക്‌ട്  ചെയ്‌ത് Name ബോക്‌സിലെ text_ctrl_1 എന്നതിനു പകരം മറ്റൊരു പേര് (z) വേണമെങ്കില്‍ നല്‍കാം. ഇതോടെ ഫ്രെയിം നിര്‍മ്മാണം പൂര്‍ത്തിയായി.  <design>ജാലകത്തില്‍ Right Click ചെയ്യുമ്പോള്‍ ലഭിക്കുന്ന drop down  ലിസ്‌റ്റില്‍ നിന്നും  Preview ക്ലിക്കു ചെയ്‌താല്‍ ഫ്രെയിം കാണാം.

5.  പൈത്തണ്‍ കോഡ് നിര്‍മ്മാണം :
<design>ജാലകത്തിലെ ക്രമീകരണത്തിനു സമാനമായ പൈത്തണ്‍ കോഡ് നിര്‍മ്മിക്കണം.  wxGlade ജാലകത്തിലെ Applications ക്ലിക്കു ചെയ്യുക.  അതിനു ശേഷം Properties ജാലകത്തില്‍ Language എന്നതില്‍ python സെലക്‌ട് ചെയ്‌ത്  Output path ഓപ്‌ഷനു നേരെയുള്ള ബട്ടണില്‍ ക്ലിക്കു ചെയ‌ത് ആവശ്യമായ ഫോള്‍ഡര്‍ തെരഞ്ഞെടുത്ത്  ഫയല്‍ നാമം നല്‍കി (calc.py)  Save വട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. .py എന്ന എക്‌സ്‌റ്റന്‍ഷന്‍ നിര്‍ബന്ധമായും നല്‍കണം. തുടര്‍ന്ന് Generate Code ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക. Code generation completed successfully എന്ന ഒരു Information കാണാം. OK ബട്ടണില്‍ ക്ലിക്കു ചെയ്യുക.  .wxg എന്ന എക്‌സ്‌റ്റന്‍ഷനോടുകൂടി ഈ പ്രോജക്ട് സേവ് ചെയ്യാം. (File--> Save)
6.  സേവ് ചെയ്‌തിരിക്കുന്ന പൈത്തണ്‍ ഫയല്‍  (calc.py) gedit text editor ല്‍ തുറക്കുക.

sum ഫങ്ഷന്റെ കോഡ് വരുന്ന ഭാഗത്തും diff  ഫങ്ഷന്റെ കോഡ് വരുന്ന ഭാഗത്തും താഴെ കൊടുത്ത രീതിയല്‍ മാറ്റങ്ങള്‍ വരുത്തി സേവ് ചെയ്‌തതിനു ശേഷം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.

print "Event handler `Sum' not implemented!"  
എന്നതിനു പകരം  
c=int(self.x.Value)+int(self.y.Value)
self.z.SetLabel(str(c))
എന്നും
print "Event handler `diff' not implemented!"
എന്നതിനു പകരം  
c=int(self.x.Value)-int(self.y.Value)
self.z.SetLabel(str(c))
എന്നുമാണ്  gedit text editor ല്‍ മാറ്റേണ്ടത്.


Click here

Lesson 11_Python

സ്‌ട്രിങ്ങുകള്‍

പ്രോഗ്രാമിംഗ് ഭാഷകളിലുപയോഗിക്കുന്ന ചരങ്ങള്‍ക്ക് (variables) സംഖ്യകളേയും അക്ഷരങ്ങളേയും ശേഖരിക്കാനും കൈകാര്യം ചെയ്യാനും സാധിക്കും.
a=5           -->  a എന്ന ചരത്തില്‍ 5 എന്ന സംഖ്യ ശേഖരിക്കുന്നതിന്
a="5"        --> a   എന്ന ചരത്തില്‍ 5 എന്ന സംഖ്യ അകഷരമായി ശേഖരിക്കുന്നതിന്.
a="x"        -->  a എന്ന ചരത്തില്‍ x എന്ന അക്ഷരം ശേഖരിക്കുന്നതിന്.
a="hello"  -->  a എന്ന ചരത്തില്‍ hello എന്ന വാക്ക് ശേഖരിക്കുന്നതിന്.


അക്ഷര രൂപത്തിലുള്ള ഡാറ്റയാണ്  സ്‌ട്രിങ്ങുകള്‍.  ഉദ്ദരണിയില്‍ (" ") നല്‍കുന്ന സംഖ്യകളും സ്‌ട്രിങ്ങുകളാണ്.  സ്‌ട്രിങ്ങില്‍ ഒന്നോ അതില്‍ക്കൂടുതലോ അക്ഷരങ്ങളുണ്ടാകാം.  സ്‌ട്രിങ്ങിലെ ഓരോ അക്ഷരത്തേയും നമുക്ക് പ്രത്യേകം ലഭ്യമാക്കാം.


ഉദാ:
a="hello"  --‍‍> a എന്ന ചരത്തില്‍ hello എന്ന സ്‌ട്രിങ്ങ് ശേഖരിക്കുന്നതിന്.
print a      -->  a എന്ന ചരത്തില്‍ ശേഖരിച്ച hello എന്ന സ്‌ട്രിങ്ങ് പ്രിന്റ് ചെയ്യുന്നതിന്.
print a[0]  --> a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ ആദ്യത്തെ അക്ഷരം പ്രിന്റ് ചെയ്യുന്നതിന്.
print a[1]  --> a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ രണ്ടാമത്തെ അക്ഷരം പ്രിന്റ് ചെയ്യുന്നതിന്.
print a[2]  --> a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ മൂന്നാമത്തെ അക്ഷരം പ്രിന്റ് ചെയ്യുന്നതിന്.
.............
.............
print a[:2]  -->  a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ ആദ്യത്തെ രണ്ട് അക്ഷരങ്ങള്‍ പ്രിന്റ് ചെയ്യുന്നതിന്.
print a[:3]  -->  a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ ആദ്യത്തെ മൂന്ന് അക്ഷരങ്ങള്‍ പ്രിന്റ് ചെയ്യുന്നതിന്.
...............
...............
 print a[2:]  -->  a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ ആദ്യത്തെ രണ്ട്  അക്ഷരങ്ങള്‍ ഒഴികെയുള്ളവ  പ്രിന്റ് ചെയ്യുന്നതിന്.
print a[3:]  -->  a യില്‍ ശേഖരിച്ച സ്‌ട്രിങ്ങിലെ ആദ്യത്തെ മൂന്ന്  അക്ഷരങ്ങള്‍ ഒഴികെയുള്ളവ  പ്രിന്റ് ചെയ്യുന്നതിന്.
................
................
print a.upper() --> a യിലെ  സ്‌ട്രിങ്ങിനെ Capital Letter ലേയ്ക്ക് മാറ്റുന്നതിന്.
print a.lower()  --> a യിലെ  സ്‌ട്രിങ്ങിനെ Small Letter ലേയ്ക്ക് മാറ്റുന്നതിന്.


a എന്ന ചരത്തില്‍ n അക്ഷരങ്ങള്‍ ഉണ്ടെങ്കില്‍ a[0] ആദ്യത്തെ അക്ഷരത്തേയും a[n-1] അവസാനത്തെ അക്ഷരത്തേയും സൂചിപ്പിക്കുന്നു.


പൈത്തണില്‍ + ചിഹ്നം രണ്ടു സംഖ്യകളെ കൂട്ടുന്നതിനു മാത്രമല്ല രണ്ട് സ്‌ട്രിങ്ങുകള്‍ കൂട്ടിച്ചേര്‍ക്കുന്നതിനും ഉപയോഗിക്കുന്നു.

Len

In Python , len() is used to denote the length of a string.

Example 1.
>>> s="suresh"
>>> len(s)
6

Example 2.>>> m=['maths','physics','chemistry']
>>> len(m)
3

Example 3. സ്‌ട്രിങ്ങ് പിരമിഡ് നിര്‍മ്മിക്കുന്നതിനുള്ള പ്രോഗ്രാം.

s=raw_input("Enter Your N ame")
n=len(s)
for i in range(n+1):
    print s[:i]

 

 

Lesson 10_Python

 ഫങ്ഷനുകള്‍ 

ഒരു പ്രോഗ്രാമില്‍ ഒരേ കോഡുതന്നെ വീണ്ടും വീണ്ടും ഉപയോഗിക്കേണ്ടതായി വരാം.  നമുക്ക് വീണ്ടും വീണ്ടും ഉപയോഗിക്കേണ്ട കാര്യങ്ങള്‍ ഒരു ഫങ്ഷനായി എഴുതുകയും അതിനെ ആവശ്യമുളള സ്ഥലത്തേക്ക് വിളിക്കുകയും ചെയ്യാം. ഫങ്ഷനുകള്‍ എന്നാല്‍ സബ് പ്രോഗ്രാമുകളാണ്. സ്വതന്ത്രമായി നില്‍ക്കുന്ന ഇത്തരം സബ് പ്രോഗ്രാമുകളെ ആവശ്യമുള്ള സന്ദര്‍ഭങ്ങളില്‍ മറ്റു പ്രോഗ്കാമുകള്‍ക്ക് പ്രയോജനപ്പെടുത്തുകയും ചെയ്യാം. 

കാല്‍ക്ക് സോഫ്റ്റ്‌വെയറില്‍ നാം ഉപയോഗിക്കുന്ന 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)


ഉദാ: സംഖ്യകളുടെ ഗുണനഫലം (പട്ടിക) കാണുന്നതിനുളുള്ള പൈത്തണ്‍ പ്രോഗ്രാം

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
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* ....) ഒരു മൊഡ്യൂള്‍ നമ്മുടെ പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തുമ്പോള്‍ ആ മൊഡ്യൂളിലുള്ള  എല്ലാ ഫങ്ഷനുകളും നമ്മുടെ പ്രോഗ്രാമിലും ലഭ്യമാകും.

Lesson 9_Python

പ്രോഗ്രാമില്‍ ഉള്‍പ്പെടുത്തിയിട്ടുള്ള ഏതെങ്കിലും നിര്‍ദ്ദേശങ്ങള്‍ ആവര്‍ത്തിച്ച് പ്രവര്‍ത്തിക്കണമെങ്കില്‍ അവ വീണ്ടും വീണ്ടും ടൈപ്പു ചെയ്യേണ്ടതില്ലെന്നും പകരം for എന്ന നിര്‍ദ്ദേശത്തോടൊപ്പം നല്കിയാല്‍ മതിയെന്നും നാം മനസ്സിലാക്കിയിട്ടുണ്ട്. അതായത് for എന്നത് ഒരു ആവര്‍ത്തന നിര്‍ദ്ദേശമാണ് (Loop statement). പൈത്തണ്‍ ഉള്‍പ്പടെയുള്ള കമ്പ്യൂട്ടര്‍ ഭാഷകളില്‍ for നിര്‍ദ്ദേശത്തെപ്പോലെതന്നെ while നിര്‍ദ്ദേശവും ഉപയോഗി ക്കാറുണ്ട്. 

ഒരു വ്യവസ്ഥ ശരിയാകുന്നതുവരെ കുറേ കാര്യങ്ങള്‍ ആവര്‍ത്തിച്ച് ചെയ്യാന്‍ പൈത്തണിലും മറ്റ് മിക്ക കംപ്യൂട്ടര്‍ ഭാഷകളിലുമുള്ള ഉപാധിയാണ്  while.

ഒരേ പ്രോഗ്രാം for, while എന്നിവ ഉപയോഗിച്ച് നിര്‍മ്മിച്ചിരിക്കുന്നത് താഴെ കൊടുക്കുന്നു. 

from turtle import*
clear()
pencolor("red")
for i in range(6):
    rt(60)
    circle(100)
 

from turtle import*
clear()
pencolor("red")
i=0
while(i<6):
    rt(60)
    circle(100)
    i=i+1 
IDLE സോഫ്റ്റ്‌വെയര്‍ ഉപയോഗിച്ച് രണ്ട് പ്രേഗ്രാമുകളും തയ്യാറാക്കി പ്രവര്‍ത്തിപ്പിച്ചു നോക്കൂ.    
ഉദാ :  നൂറിനു താഴെയുള്ള ഒറ്റ സംഖ്യകള്‍ പ്രിന്റ് ചെയ്യുന്നതിനുള്ള ഒരു പ്രോഗ്രാം for  ഉപയോഗിച്ചും while  ഉപയോഗിച്ചും തയ്യാറാക്കിയത് ശ്രദ്ധിക്കുക.

for i in range(1,100,2):
    print i


i=1 
while(i<100):
    print i
    i=i+2

for നിര്‍ദ്ദേശത്തില്‍ ആവര്‍ത്തനചരത്തിന്റെ (iterating variable) തുടക്ക വിലയും (initial value) വര്‍ദ്ധനവും (increment) പരിധിയും (exit condition). എന്നാല്‍ while നിര്‍ദ്ദേശത്തില്‍ പരിധി (exit condition) മാത്രമേ നിര്‍ദ്ദേശത്തില്‍ ഉള്‍പ്പെടുന്നുള്ളൂ.

for നിര്‍ദ്ദേശത്തില്‍ range ഫങ്ഷന്‍ ഉള്‍പ്പെട്ടിരിക്കും. എന്നാല്‍ while നിര്‍ദ്ദേശത്തോടൊപ്പം range ഫങ്ഷന്‍ ചേര്‍ക്കേണ്ടതില്ല. 

ആവര്‍ത്തന ചരത്തിന്റെ തുടക്കവില while നിര്‍ദ്ദേശത്തിനു മുമ്പാണ് നല്കേണ്ടത്. 

ആവര്‍ത്തന ചരത്തിന്റെ വര്‍ധനവ് / കുറവ് while നിര്‍ദ്ദേശത്തിനകത്തെ ഒരു നിര്‍ദ്ദേശമായാണ് നല്കേണ്ടത്. അല്ലെങ്കില്‍ while നിര്‍ദ്ദേശം നില്‍ക്കാതെ പ്രവര്‍ത്തിച്ചു കൊണ്ടിരിക്കും. 

for നിര്‍ദ്ദേശത്തിനകത്ത് വീണ്ടും for നിര്‍ദ്ദേശം ഉള്‍പ്പെടുത്തുന്ന താഴെ കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം ശ്രദ്ധിക്കുക.

from turtle import*
clear()
pencolor("red")

for i in range(6):

      rt(60)

      for j in range(30,71,10):

           circle(j)