函数参数之position argument || keyword argument||default value

        函数的定义大家都无比熟悉，不论何种语言，都有类似的定义，但是python语言还是有其独到之处，函数的定义本身来说，都差不多，
这里我么需要关注的是函数参数的类型，注意哦，这里的类型不是参数本身的数据类型，而是参数在调用时候具有的不同特性。

# about parameter : position & keyword parameter & default value
def greet(name,greeting='hello world'):
    print name,greeting
# call with keyword parameter
print 'call without keyword format'
greet('kin','welcome !')
greet('welcome !','kin')
# call with keyword parameter
print 'call with keyword format '
greet(name='kin',greeting='welcome !')
greet(greeting='welcome !',name='kin')
print 'about default parameter'
greet('kin')
greet('kin','welcome once again')

程序的输出：

call without keyword format
kin welcome !
welcome ! kin
call with keyword format
kin welcome !
kin welcome !
about default parameter
kin hello world
kin welcome once again

同一个函数，使用不用的调用方式，产生的程序输出不同，
注意这里，函数的定义没有变，改变的函数的调用方式，
一种是使用position argument ： 无需考虑变量名称，直接调用即可
一种是keyword argument :    在调用的时候，使用变量名来确定不同变量的调用顺序，（说道这里，说点题外话，在JCL中，也有类似的定义的先是position argument，后是keyword  argument，现在想来，语言都是想通的）
使用函数的默认值： 函数的默认值必须作为最后的参数来定义，当然了你可以覆盖掉该值
在着就是你需要注意的是，如果函数的参数个数是不确定情况下，函数时如何定义并调用的？在python中，它也是使用特殊的语法来实现的：
看看下面的代码：

def complexpara(x,y,z,name='a',*tuplep,**dicp):
    print x,y,z # position paramter
    print name
    print tuplep   # leftover   position  parater
    print dicp   #   leftover   keyword parameter
# call with complex  agurment
complexpara(1,2,3,'kin',4,5,6,add='shanghai',email='@gmail.com')
# let's think something about usage of * when call
tuplep=(1,3,5)
def  myadd(*element):
    print reduce(lambda x,y:x+y,element)
print 'sum result is ',myadd(*tuplep), # call with arguments unpacked from a tuple
tuplep=(1,3,5,7,9)
print 'sum result is ',myadd(*tuplep),  # call with arguments unpacked from a tuple


dicp={'name':'kin','age':'30'}
def parsedic(**dictp):
    print 'name is '+dictp['name']+'age is '+dictp['age']
def parsediccom(dictp):
    print 'name is '+dictp['name']+'age is '+dictp['age']

            parsedic(**dicp)            # call with arguments unpacked from a dict
            parsediccom(dicp)           # call with arguments unpacked from a dict 

程序的输出：

1 2 3
kin
(4, 5, 6)
{'add': 'shanghai', 'email': '@gmail.com'}
sum result is 9
None sum result is 25
None name is kinage is 30
name is kinage is 30

首先看第一个例子，这个函数的定义就是定义了一个复杂的参数定义，需要注意语法时：
*tuplep,**dicp
该变量一个是tuple,一个是dict,其目的实现变参（参数的个数不确定的情况）
一个是用来接收剩余的position argument ，一个是用来接收keyword argument
通过函数的调用，你就可以知道二者的作用个
第二个例子与第三个例子则是说明了如何定义，并调用类似的函数，
通过定义可变长度参数函数，myadd，你可以以任意个那数参数对其进行调用，
同样通过定义你也可以使用字典来进行定义，并调用，不过你也开一使用普通方式，进行调用，二者的功能是相同的，
但是语法的形式，以及函数的灵活性不同，相比较而言，使用了*，**的可读性要差点，但是程序的灵活性变强。

总体上来说，python的函数功能还是很强大，知道这些对你阅读，编写程序是很有帮助的
同时，还是提醒自己啊，再好的书，也不如官方文档啊，威武！
这里还涉及到了list,tuple,dict的upack，
tt=(5,6)
x,y=tt
ref:

A call calls a callable object (e.g., a function) with a possibly empty series of arguments
call ::= primary "(" [argument_list [","]
            | expression genexpr_for] ")"
argument_list ::= positional_arguments ["," keyword_arguments]
                     ["," "*" expression]
                     ["," "**" expression]
| keyword_arguments ["," "*" expression]
                    ["," "**" expression]
| "*" expression ["," "**" expression]
| "**" expression
positional_arguments ::= expression ("," expression)*
keyword_arguments ::= keyword_item ("," keyword_item)*
keyword_item ::= identifier "=" expression