Python Startup #2

by 07:15 0 comments
ပထမပိုင္းမွာတံုးကြ်န္ေတာ္ေျပာခဲ့တဲ့ Python Interpreter မွာ 0 နဲ ့စတာေတြ 010 ဆိုဘာလို ့8 လို ့တယ္ေပါ့။ ေရးလိုက္တာနဲ ့ျပန္ေဖာ္ျပတာကိုၾကည့္ျပီးသေဘာေပါက္ျပီးသားသူလဲသိမွာပါ။ Python Interpreter မွာက 0 နဲ ့စလိုက္ရင္ octal or base 8 အျဖစ္နဲ ့ interpreted လုပ္ပါတယ္။
ဒါဆိုအပိုင္း၂ေလးဆက္လိုက္ရေအာင္ဗ်ာ…

Lists & Tuples

Lists နဲ ့Tuples နဲ ့မွာအဓိကကြဲျပားတာကေတာ့ List က changes ရွိႏိုင္တယ္ဒါေပသိ Tuples ေတြကေတာ့ဒီလိုမပာုတ္ပါဘူး ေျပာရရင္ fix ျဖစ္တယ္ေပါ့။ ဒါကလဲလိုအပ္တဲ့ေနရာမွာသင့္ေတာ္တဲ့ေကာင္ကိုေရြးသံုးသြားႏိုင္တာေပါ့ေလ။
Lists ေတြကို variable အသစ္ထည့္ထည့္သြားတဲ့အေျခအေနမ်ိဳးေတြမွာအသံုးခ်ႏိုင္ျပီး Tuples ေတြကိုေတာ့ changes မျပဳလုပ္ႏိုင္ေအာင္ျပဳလုပ္ထားသင့္တဲ့ sequence ေတြမ်ိဳးမွာအသံုးခ်ပါတယ္။ သူ ့ေနရာနဲ ့သူအသံုးတည့္တာၾကီးပဲေပါ့။
Tuples အေၾကာင္းကိုေတာ့ေနာက္မွ Detailed သြားမယ္ဗ်ာ။ ပာုတ္ျပီဒါဆိုကြ်န္ေတာ္တို ့ Lists ဆိုတာကိုအေသးစိတ္ေလ့လာလိုက္ၾကရေအာင္ဗ်ာ။

2.0 Lists

2.1 Lists are actually a sequence.

String ကဲ့သုိ ့ပါပဲ List ဆိုတာကလဲတကယ္ေတာ့ Sequence of values ေတြျဖစ္ပါတယ္။ ေနာက္ List တစ္ခုမွာဆို data type ကၾကိဳက္တာရပါတယ္။ List တစ္ခုထဲမွာရွိတဲ့ values ေတြကို elements ဒါမွမပာုတ္ items လို ့ေခၚၾကပါတယ္။ List ေတြသည္ Square Bracket ဆိုတဲ့ [] ကိုအသံုးျပဳပါတယ္။ 
 >>> [1, 2, 3, 4, 5]  
 >>> [‘I’, ‘Love’, ‘MSF’]  
ပထမ List ကေတာ့ Integer 5 ခုပါ။ ဒုတိယေကာင္ကေတာ့ string 3 ခုပါ၀င္တဲ့ List တစ္ခုပါ။ ေျပာဖို ့တစ္ခုရွိတယ္ဗ် ဒီဥပမာေတြသာကြ်န္ေတာ္က same data type နဲ ့ေရးျပသြားတာေနာ္။ List မွာအေပၚကေျပာခဲ့သလိုပဲ any data types ပါ။ ေအာက္ပါဥပမာမွာ string, list, float နဲ ့တျခား List တစ္ခုပါထပ္ထည့္ျပပါမယ္။
 >>> [‘Hello’, 1, 1.5, [11, ‘World’]]  
Lists ေတြထဲမွာအေပၚကလိုေနာက္ထပ္ Lists တစ္ခုထပ္ထည့္လိုက္တာမ်ိဳးေတြကို nested လို ့ေခၚပါတယ္။ ေနာက္ ဘာမွမထည့္ထားတဲ့ [] ေတြလဲေရးရတာမ်ိဳးေတြရွိတတ္ပါတယ္။ ဘယ္လိုေျပာရမလဲဗ်ာ စာေသာက္ဆိုင္ကစားပြဲထိုးတစ္ေယာက္ကလာစားတဲ့သူမွာတဲ့ပာာကိုမွတ္ရတာကို program ေရးလိုက္ရင္ေပါ့။ အရင္ဆံုးဘာမွမေရးထားတဲ့စာရြက္အလြတ္တစ္ရြက္ (Program ထဲမွာေတာ့ေဘာပင္ေပါ့ထည့္မေရးရဘူးေပါ့ကြယ္ :P) အဲ့လိုစာရြက္အလြတ္ကို Empty List ဆိုတဲ့ [] ေပါ့။ ေနာက္ customer ကမွာလိုက္တာေတြကိုစာရြက္မွာေရးျပီးမွတ္သလိုပဲ ခုနက List ထဲကိုလဲထည့္မွတ္သြားတာေပါ့ Python အရေျပာရရင္ List ထဲကို append လုပ္တယ္ေပါ့။ ဒီလိုပါ။
 paper = [] # Creating Empty List  
 ask = raw_input(‘What would you like to order: ‘) # Asking for the input  
 paper.append(ask) # Adding User Value into Empty List  
 print paper # Print out the results from the list  
append() ဆိုတာကေတာ့ List ထဲကို Value ထည့္ခ်င္အသံုးျပဳတဲ့ function name ေလးတစ္ခုေပါ့။

 2.2 Lists are mutable

ပာုတ္ပါတယ္။ Lists ေတြက mutable ျဖစ္ပါတယ္။ Interpreter မွာေအာက္ကလို List ေလးတစ္ခုေရးလိုက္ျပီထားဗ်ာ။
 >>> foods = [‘salad’, ‘noodle’, ‘wine’]  
 >>> numbers = [1, 2, 3]  
ပထမ List ေလးကိုအရင္ေျပာမယ္။ အဲ့ဒီ foods ဆိုတဲ့ Lists ထဲကပာာေတြအကုန္မျပပဲတစ္ခုပဲျပခ်င္တယ္ဆိုဘယ္လိုေရးမလဲ? ကြ်န္ေတာ္ wine ဆိုတဲ့ေကာင္ကိုေခၚျပပါမယ္။
 >>> foods[2]  
 ‘wine’[/code]  
ဘာလဲပာ wine က 3th place မွာေလ…. တတိယေကာင္မပာုတ္ဘူးလားးးး ဒါေပသိ သတိထားရမွာက count ကို 1 ကေနမစပါဘူး 0 ကစပါတယ္။ ေအာက္ကပံုေလးကိုၾကည့္လိုက္ပါ။
ရွင္းတယ္မလား ဒါဆိုေနာက္တစ္ေကာင္ numbers = [1, 2, 3]. Lists ေတြက mutable ျဖစ္တယ္လို ့ေျပာခဲ့တယ္ေနာ္ ဒီငနဲၾကီးကေျပာတယ္ေနာ္၊ ဒါဆို 2 ဆိုတဲ့နံပတ္ကိုမၾကိဳက္ဘူးကြာ 11 ေျပာင္းမယ္…..။ ရပါတယ္ဗ်ာ ဒီလိုေလးေျပာင္းပါမယ္။ 
 >>> numbers[1] = 11  
 >>> print numbers  
 [1, 11, 3]  
ဘာမွေတာင္မွတ္စရာမလိုဘူးရယ္ ခုနကလိုတစ္ခုခ်င္းေခၚသလိုေခၚတာေလးေရး ေနာက္က equal sign နဲ ့ေျပာင္းမယ့္ value ေရးလိုက္ရံုေလးတင္…..


List ဆိုတာကို indices နဲ ့ elements ေတြလို ့မွတ္ထားလိုက္ရင္အဆင္ေျပပါတယ္။ အဲ့ဒီ indices နဲ ့ elements ေတြရဲ့ၾကားကဆက္စပ္မွဳကို mapping လို ့ေခၚပါတယ္။ element တစ္ခုစီကို index တစ္ခုစီနဲ ့ဆက္စပ္ေနပါတယ္။

List indices အလုပ္လုပ္ပံုကေတာ့
•     ဘယ္ interger expression ကို index အေနနဲ ့အသံုးခ်ႏိုင္ပါတယ္။
•     မရွိတဲ့ value တစ္ခုကိုေရးဖို ့ပဲျဖစ္ျဖစ္ ေဖာ္ျပဖို ့ပဲျဖစ္ျဖစ္ျပဳလုပ္လိုက္ပါက IndexError ေဖာ္ျပမွာျဖစ္ပါတယ္။
•     Index ေတြကို negative values (such as: -1, -2) ေတြနဲ ့ေဖာ္ျပရင္ နကို list values ေတြကို backward ျပန္ရည္တြက္ပါတယ္။ ဥပမာေပးရမယ္ဆို

 >>> print numbers[-1]  
 3  
in ဆိုတဲ့ keyword ကိုအသံုးခ်ျပီး lists ထဲမွာ element ရွိမရွိဆိုတာကို True or False  နဲ ့ေဖာ္ျပခိုင္းႏိုင္ပါတယ္။ ခုနက foods ဆိုတဲ့ list နဲ ့ေဖာ္ျပပါမယ္။
 >>> foods = [‘salad’, ‘noodle’, ‘wine’]  
 >>> ‘wine’ in foods  
 True  
 >>> ‘cocktail’ in foods  
 False  

2.3 Traversing a list

List တစ္ခုထဲက elements ေတြကို pass over လုပ္ျပီးေဖာ္ျပသြားတာေျပာရရင္ traversing လုပ္တဲ့အခါက်ရင္အသင့္ေတာ္ဆံုးက for ကိုအသံုးျပဳျပီး looping လုပ္သြားတာပါ။ 
 >>> for things in foods:  
 …  print things  

တစ္ခုေျပာမယ္ေနာ္ print ဆိုတဲ့အေၾကာင္းေရးတဲ့အခါမွာ white space အေနနဲ ့tab ခုန္လို ့ရေပမဲ့မခုန္ပါနဲ ့။ space-bar ကိုပဲ ၄ခ်က္ပုတ္ျပီးအသံုးျပဳေပးပါ။ ဒါေလးကိုလဲမွတ္ထားပါ… ဘာ Script ပဲေရးေရးအဲ့လိုအသံုးျပဳတဲ့အက်င့္ေလးလုပ္ေပးပါ။ www.python.org မွာသြားဖတ္လို ့ရပါတယ္။ Rule ေလးတစ္ခုပါပဲ ဒါပာာလဲ။

ဒါဆို Lists အေၾကာင္းပဲျပန္ဆက္မယ္ဗ်ာ…. အခုလို functions ေလးကေတာ့ တျခားမပာုတ္ပါဘူး foods ဆိုတဲ့ထဲက elements ေတြကိုတစ္ခုခ်င္းေဖာ္ျပေပးသြားတာပါ။ ေနာက္ဥပမာထဲမွာ things လို ့သံုးေပမယ့္ညီကိုေတြၾကိဳက္တာေရးလို ့ရပါတယ္။ တစ္ခုပါပဲေအာက္မွျပန္ေခၚတာနဲ ့ေတာ့တူပေစေပါ့။
ဒါဆိုေနာက္ေကာင္ေလးကိုထပ္ေျပာမယ္။ အေပၚမွာ numbers = [1,2,3] လို ့ေရးထားခဲ့ေသးတယ္ေနာ္။ ပာုတ္ျပီ အထဲက numbers ေတြအကုန္လံုးကို ၂နဲ ့ေျမာက္မယ္ဆိုရင္ေကာာာာာ….. ကိုယ့္ဘာသာကို calculator နဲ တြက္ျပီးတစ္ခုခ်င္း numbers[index] = calculated number ဒါမ်ိဳးေတာ့ရတာေပါ့ေလ။ ဒါေပသိဒီလိုၾကီးလုပ္တာက အခုေတာ့ဘာမွမျဖစ္ေပမယ့္ တကယ္တန္းကိုယ္ကေရးေတာ့မယ္ဆိုအဲ့လိုၾကီးလုပ္ျပီးအခ်ိန္ကုန္ခံမလို ့လား…. ဒီေတာ့ေနာက္ဥပမာေလးတစ္ခုေရးမယ္ဗ်ာ။

 for i in range(len(numbers)):  
   numbers[i] *= 2  
ဒါဆိုမူလရွိတဲ့ numbers ထဲက elements ေတြျဖစ္တဲ့ 1, 2, 3 ကဆိုရင္ ၂နဲ ့ေျမာက္လိုက္တဲ့ 2, 4, 6 ျဖစ္သြားမွာပါ။ ဘယ္လိုျဖစ္သြားလဲဆိုတာကိုရွင္းပါမယ္။ ပထမဆံုးရွင္းခ်င္တာက numbers[i] *= 2 ပါ။
ဒါကကြ်န္ေတာ္အတိုေခါက္ေရးလိုက္တာပါ။ numbers[i] *= 2 ဆိုတာက numbers[i] = numbers[i] * 2 နဲ ့တူတူပါပဲ။ ေရးရတာတိုသြားတယ္ေပါ့ဗ်ာ။ အခုလိုအရွည္ကိုဖတ္လိုက္ရင္ေတာ့သေဘာေပါက္ျပီထင္ပါတယ္။ ဒါဆိုေနာက္တစ္ခု for ဆိုတဲ့စာေၾကာင္းက len() ဆုိတဲ့ေကာင္… သူအလုပ္လုပ္တာကေတာ့ဘာမွမပာုတ္ပါဘူး parenthesis ထဲက value ရဲ့အရွည္ကိုတြက္ခ်က္ပါတယ္။ ဒါကိုေျပာတာပါ။

 >>> len(‘MSF’)  
 3  
တစ္ခုပဲ သူက space ေနရာကိုလဲ 1 ယူပါတယ္။
 >>> len(‘I Love MSF’)  
 10  
8 မပာုတ္ပါဘူး string ၾကားထဲမွာ space ၂ေနရာပါတယ္ အဲ့ဒီ၂ခုကိုလဲထည့္တြက္ပါတယ္။ ေနာက္ lists ေတြထည့္ရင္မွတ္ဖို ့က
 >>> len(numbers)  
 3  
ပာုတ္ပါတယ္။ 3 လို ့ပဲျပမွာပါ။ numbers ထဲက element တစ္ခုကိုမွ 1 ယူတာပါ။ elements က ၃ ခုရွိတဲ့အတြက္ ၃ ယူလိုက္တာပါ။
ေနာက္တစ္ခုေျပာခ်င္တာက range()။ ဒီ function ကေတာ့ arithmetic ျဖစ္တဲ့ list တစ္ခုျပဳလုပ္ပါတယ္။ အေပၚကလိုပဲ for loop ပတ္တဲ့မ်ိဳးေတြမွာသံုးၾကတာမ်ားပါတယ္။ range(start,stop[,step]) ဒီလိုေလးပါ။ အထဲက argument က integer ျဖစ္ရပါမယ္။ Interpreter မွာဒီလိုေလးရိုက္ၾကည့္ပါ။
 >>> range(2)  
 [0, 1]  
0 ကစမယ္ေပါ့။ အေပၚမွာျပခဲ့တဲ့ထဲက step ကို omit လုပ္မယ္။ ေျပာရရင္ခ်န္ခဲ့လို ့ရပါတယ္။ သူက optional argument ပါပဲ။ အကယ္လို ့ခ်န္ခဲ့လိုက္မယ္အေပၚကလို range(2) ဆိုရင္ step ကုိ 1 နဲ ့သြားမွာပါ။ ေနာက္ start ကိုခ်န္ခဲ့ရင္ 0 ကေနစတြက္မွာျဖစ္ပါတယ္။ stop ကေတာ့ပါရမွာေပါ့ေလ။ ဘာ arguments မွမပါရင္ Error တက္မွာပါ။
 >>> range(1,13,2)  
 [1, 3, 5, 7, 9, 11]  
သေဘာေပါက္မယ္ထင္ပါတယ္။ ေနာက္ start က stop ထက္ၾကီးေနျပီး step က positive နဲ ့ဆို empty list ျပန္မွာပါ။
 >>> range(0, -10, 2)  
 []  
ေနာက္ step က negative ဆို reverse သြားမွာပါ။
 >>> range(0, -10, 2)  
 [0, -2, -4, -6, -8]  
အကယ္လို ့step ကို 0 ေပးလိုက္ရင္ ValueError တက္မွာျဖစ္ပါတယ္။ range() function ကေတာ့ဒါပါပဲ။ ဒါဆိုလိုရင္းကိုဆက္မယ္ဗ်ာ။

 2.4 List operations

Strings ေတြလိုပါပဲ + က List မွာလဲ concatenate ျပဳလုပ္ပါတယ္။
 >>> a = [1, 2, 3]  
 >>> b = [4, 5, 6]  
 >>> c = a + b  
 >>> print c  
 [1, 2, 3, 4, 5, 6]  
ေနာက္ Strings ေတြလိုပါပဲ * က repeat လုပ္တာပါပဲ။
 >>> [1] * 3  
 [1, 1, 1]  
 >>> [1, 2, 3] * 2  
 [1, 2, 3, 1, 2, 3]  

2.5 Slicing the List

 >>> a = [1, 2, 3, 4, 5, 6]  
 >>> a[1:3]  
 [2, 3]  
အကယ္လို ့ List ရဲ့ First argument ကေနစမယ္ဆို 0 ကေနေပါ့ေလ။ ဒါေပသိ အဲ့လို First argument ကေနစမယ္ဆို Slicing ရဲ့ : ေရွ ့က number ကို omit လုပ္ခဲ့လို ့ရပါတယ္။ ေနာက္ဆံုးထိဆို : ေနာက္ကေကာင္ကိုခ်န္ခဲ့လိုက္ပါ။
 >>> a[:5] # is equal to a[0:5]  
 [1, 2, 3, 4, 5]  
 >>> a[2:] # is equal to a[2:6]  
 [3, 4, 5, 6]  
အကယ္လို ့List တစ္ခုလံုးကိုေဖာ္ျပမယ္ဆို : ေရွ ့ေကာေနာက္ေကာကိုခ်န္လိုက္လို ့ရပါတယ္။
 a[:]  
 [1, 2, 3, 4, 5, 6]  
ေနအံုးဘာလို ့အဲ့လို၂ခုလံုးခ်န္တာကိုသံုးမွာလဲေပါ့။ ဒီတိုင္းေခၚလဲအကုန္ျပတာပဲကို? ဒီလိုရွိတယ္ဗ် List ေတြက mutable ျဖစ္တယ္လို ့ကြ်န္ေတာ္အေပၚမွာေျပာခဲ့သလိုပဲ operations လုပ္ေဆာင္တဲ့အခါက မူလ List ကိုမလုပ္ေစပဲ အဲ့ List ကိုကူးျပီးလုပ္ၾကပါတယ္။ ဒီေတာ့ ခုနက [:] ကိုအသံုးျပဳပါတယ္။ ဒီလိုပါ။
>>> b = a[:]
ဒီမွာထပ္ေျပာစရာရွိသြားပါျပီ။ b = a ဆိုေကာမရဘူးလားဆို print ထုတ္ရင္တာတူတူထြက္တာပါ b = a နဲ ့b = a[:] ကမတူပါဘူး။
ဘယ္လိုမတူလဲေျပာျပမယ္။
b = a ဆိုတာက b ဆိုတဲ့ေကာင္ကို a ရဲ့ List ကိုလွမ္းေထာက္ခိုင္းလိုက္တာပါ ဒီေတာ့ List အသစ္မလုပ္ေတာ့ပဲ a ရဲ့ List ကိုပဲ b ေကာ a ေကာအတူတူသံုးၾကပါတယ္။ ဒါဆို a ကေန List ကို edit လုပ္လိုက္ရင္ b လဲလိုက္ေျပာင္းသြားပါတယ္။
 >>> a = [1, 2, 3, 4, 5, 6]  
 >>> b = a  
 >>> print a  
 [1, 2, 3, 4, 5, 6]  
 >>> print b  
 [1, 2, 3, 4, 5, 6]  
 >>> a[0:4] = [11, 22, 33, 44]  
 >>> print a  
 [11, 22, 33, 44, 5, 6]  
 >>> print b  
 [11, 22, 33, 44, 5, 6]  
မရွင္းေသးဘူးဆိုေအာက္ကပံုကိုၾကည့္လိုက္ပါ။

b = a[:] ကက်ေတာ့ a ရဲ့ List ၾကီးကို Copy ျပီးအသစ္ထပ္လိုက္လုပ္ပါတယ္။ ျပီးမွ b နဲ ့ေပးညီလိုက္တယ္။ ဒီေတာ့ a ကို edit ရင္ b မွာသက္ေရာက္မွဳမရွိသလို b ကို edit လဲ a ကိုသက္ေရာက္မွာမပာုတ္ပါဘူး။
 >>> a = [1, 2, 3, 4, 5, 6]  
 >>> b = a[:]  
 >>> a[0:4] = [11, 22, 33, 44]  
 >>> print a  
 [11, 22, 33, 44, 5, 6]  
 >>> print b  
 [1, 2, 3, 4, 5, 6]  
သေဘာေပါက္မယ္ထင္ပါတယ္။ ေအာက္က figure ကိုၾကည့္လိုက္ရင္ပိုသေဘာေပါက္မွာပါ။

ေနာက္ slicing ကို arguments အမ်ားၾကီးကိုခ်ိန္းတာမွာသံုးပါတယ္။ အေပၚမွာေတာင္ပါျပီးသြားပါျပီ။
 >>> a = [1, 2, 3, 4, 5, 6]  
 >>> a[0:4] = [11, 22, 33, 44]  
 >>> print a  
 [11, 22 ,33 ,44, 5 ,6]  
To be continue

PyLab (c) 2016

Pylab

Developer

Keep calm and love Python

0 comments:

Post a Comment