Python-Kind (ch 4.7)

Parameters အေၾကာင္းျပီးရင္ Argumentsအေၾကာင္းေျပာပါမယ္

Required arguments, Keyword arguments, Default arguments, Variable-length arguments ဆိုတဲ႔ function argumentsေတြထဲက default နဲ႔ keyword argumentsအေၾကာင္းကိုပဲ ေရးပါမယ္။

### Default argumentsဆိုတာဘာလဲ?

functionထဲမွာ default value(အလိုအေလ်ာက္ေရြးခ်ယ္မႈ) သတ္မွတ္ေပးထားတာပါ။အကယ္၍ valueမသတ္မွတ္္ခဲ႔ရင္ default valueကို သံုးေပးသြားမွာပါ။
```
>>>def printinfo( name, age = 35 ):
print("Name: ", name)
print ("Age: ", age )
return

>>>printinfo(name="John",age=27)
Name: John #result
Age: 27 #result

>>>printinfo(name="Miki)
Name: Miki #result
Age: 35 #result
```

*printinfo* ဆိုတဲ႔ functionမွာဆို ageကို default value 35 ထည့္ေပးထားမယ္။
nameနဲ႔ age argumentsေတကို valueထည့္ေပးလိုက္တဲ႔အခါ ageရဲ႕ default valueကိုမထုတ္ေပးတာေတြ႔ရမွာပါ။
nameတစ္ခုပဲ valueထည့္ေပးတဲ႔အခါ ageရဲ႕ default valueကို သံုးသြားပါတယ္။

### Keyword argumentsဆိုတာ ဘာလဲ?

Functionမွာ default value မသတ္မွတ္ေပးေတာ့ပဲ argumentsပဲ ေရးေပးထားမွာပါ။value ေပးတဲ႔အခါ ရွိတဲ႔ arguments အတိုင္းေပးရမွာပါ။ဥပမာ arguments ၂ခုရွိရင္ value ၂ခုလံုးပါမွ အလုပ္လုပ္ေပးမွာပါ။

```
>>>def printinfo( name, age ):
print("Name: ", name)
print ("Age ", age)
return
>>>printinfo( age=50, name="miki" )
Name:miki
Age:50

>>>printinfo(name="john")
Traceback (most recent call last):
File "", line 1,in
info(name="john")
TypeError:info() missing 1 required positional argument: 'age'
```

nameနဲ႔ age value ၂ခုစလံုးပါတဲ႔အခါ အလုပ္လုပ္ေပးျပီး
nameတခုပဲ ေရးေပးတဲ႔ခါ argument တခုလိုေသးတဲ႔အတြက္ အလုပ္မလုပ္ေပးတာကို ေတြ႕ရမွာပါ။

Arguments(*args) and Keyword arguments(**kwargs)

အဓိက နားလည္ရမွာက * (for tuple) နဲ႔ **(for dictionary)ပဲျဖစ္တယ္။
*args နဲ႔ **kwargs ေတြဟာ functionမွာသံုးတဲ႔ special syntax(spelling or grammar of programming language)ေတြျဖစ္ပါတယ္။*args ရဲ႕ေနာက္မွာ **kwargs ကိုသံုးမယ္။နာမည္အေနနဲ႔ args နဲ႔ kwargsမွမဟုတ္ပဲ ႀကိဳက္ရာသံုးခြင့္ရွိမယ္။ဥပမာ *args နဲ႔ **foo လို႔သံုးနိုင္မယ္။*args နဲ႔ **kwargsေတြဟာ ေနရာယူသက္သာလို႕ ပိုေကာင္းတယ္လို႔ဆိုနိုင္တယ္။

*args ကို non-keyword argumentလို႔ေျပာနိုင္တယ္။
Eg.fun(3,4)
fun("foo","bar")

*argsရဲ႕ အသံုးျပဳပံုကို exampleမွာ ရွင္းျပထားပါတယ္။
```
>>>def add(a, b,c):

print(a+b+c)


>>>print add(2,3,4)
9 #result
-----------------------

>>>def add(*args):

total = 0

for arg in args:

total+=arg
print total

>>>print add(2,3,4)
9 #result
```


**kwargs ဟာဆိုရင္ dictionaryလိုပဲ။Double asterisk(**) ေလးက အဓိကသေကၤတေလးပါ။keyနဲ႔ value တြဲဖို႕က အေရးပါပါတယ္။

Eg.fun(foo=3,bar=4)
```
>>>def capital_city(**kwargs):
result = []
for key, value in kwargs.items():

result.append("The capital city of{} is {} .format (key,value)

return result

>>>print capital_city(China = "Beijing",Cairo = "Egypt",Rome = "Italy"))
```
['The capital city of China is Beijing', 'The capital city of Cairo is Egypt','The capital city of Rome is Italy']

နွစ္ခုလံုးကိုတြဲသံုးလို႕လည္းရပါေသးတယ္။
```
>>>def Func(*args,**kwargs):

for arg in args:

print arg

for item in kwargs.items():

print item

>>>print Func(1,x=7,u=8)


1

('x', 7)

('u', 8)
```
resultမွာ keyနဲ႔မေဖာ္ျပခဲ႔တဲ႔ 1 ကို *args အျဖစ္ထုတ္ျပတာျပီး keyထားခဲ႔တဲ႔ x နဲ႔ uကို **kwargsအျဖစ္ထုတ္ျပသြားတာပါ။

### Arbitrary Arguments Lists

Arbitrary argumentsေတြက default tuple(sequence) ပံုစံလိုပါပဲ။ *argsလိုပါပဲ။
```
>>>def greet(*names):
for name in names:
print("Hello",name)

>>>greet("Monica","Luke","Steve","John")

Hello Monica
Hello Luke
Hello Steve
Hello John
```

### Unpacking Arguments Lists

Unpack လုပ္ဖို႕ *(for tuple)သံုးနိုင္တယ္။

Eg.
```
>>>def fun(a,b,c):
print(a,b,c)

>>>my_list(1,2,3)
>>>fun(my_list)
TypeError: fun() takes exactly 3 arguments(1 given)
```

unpackမလုပ္ထားေသးလို႔ errorျပေနပါတယ္။
unpack လုပ္ဖို႔ * ကိုသံုးၾကည့္မယ္။

```
>>>def fun(a,b,c):
print(a,b,c)

>>>my_list(1,2,3)
>>>fun(*my_list)
(1,2,3)
```

### Lambda Expression ဆိုတာ ဘာလဲ?

Lambdaဆိုတာ function or operatorတစ္ခုပါ။
Create လုပ္ရမယ္ တစ္ႀကိမ္သာသံုးမယ့္ functionေတအတြက္ အသံုးျပဳပါတယ္။

lambda arguments:expression

အေျခခံ syntaxေရးပံုပါ။
lambdaမွာ arguments အေရအတြက္ လိုသေလာက္သံုးနိုက္ေပမယ့္ expressionကေတာ့ တစ္ခုတည္းျဖစ္ရမွာပါ။

```
>>> def add(x, y):
return x + y

>>>add(2,3)
5
```

add functionတစ္ခု x နဲ႔ yက argumentsေတျဖစ္ျပီး sumကို returnျပန္ထားတဲ႔ ရိုးရိုးfunctionပါ။
Lambda functionကို သံုးၾကည့္ပါမယ္။

```
>>>add = lambda x, y : x + y
>>>print add(2, 3)
5
```
x,yက argumentsျဖစ္ျပီး x+y က expressionပါ။
returnျပန္ဖို႕မလိုေတာ့ပဲ lambda functionနဲ႔ပဲ အလုပ္လုပ္ပါတယ္။

### Documentation Stringsဆိုတာ ဘာလဲ?

Docstringလို႔ အတိုသတ္မွတ္ၾကပါတယ္။String တစ္ခုျဖစ္ျပီး """ """ ထဲမွာေရးပါတယ္။Functionရဲ႕ summary lineအျဖစ္ေရးပါတယ္။Function, classေတြရဲ႕ ပထမဆံုးေဖာ္ျပခ်က္မွာ ေရးပါတယ္။

Eg.
```
>>>def fun():
"""Hello World"""

Functionမွာတဲ႔ docstringကို ထုတ္ျပမယ္ဆို __doc__ နဲ႔ထုတ္ျပရပါမယ္။
Eg.

>>>print(fun.__doc__)
Hello World
```

Docstringကို single lineသာမဟုတ္ပဲ multi lineေရးလို႕ရပါတယ္။ပထမstringေနာက္က blank lineေရးပါတယ္။ျပီးမွ အျခားေဖာ္ျပခ်က္ေတြေရးပါတယ္။

Eg.
```
>>>def complex(real=0.0, imag=0.0): """Form a complex number.

Keyword arguments:
real -- the real part
imag -- the imaginary part
"""

if imag == 0.0 and real == 0.0: return complex_zero
```

### Function Annotationဆိုတာ ဘာလဲ?

Functionမွာပါတဲ႔ argumentsေတြကို class ခြဲျပတာပါ။Parameter နဲ႔ valueေတ returnျပန္ဖို႕အတြက္သံုးပါတယ္။
```
>>>def foobar(a: expression, b: expression
```
Annotation syntaxပံုစံပါ။

Eg.
```
>>>def p(fname:str,lname:str):
print(p.__annotations__)
return fname+' '+lname

>>>p('John','Legend')
{'fname':, 'lname':}
'John Legend'
```
p.__annotations__သံုးလိုက္တဲ႔အတြက္ p functionရဲ႕ argumentsျဖစ္တဲ႔ fnameနဲ႔ lnameကို classခြဲျပသြားတာပါ။string ေတြထည့္ခဲ႔တာျဖစ္တဲ႔အတြက္ လို႔ေဖာ္ျပသြားတာပါ။

Thank You ⭐⭐⭐
Sign In or Register to comment.