python函数调用的四种方式

第一种：参数按顺序从第一个参数往后排#标准调用

def normal_invoke(x, y):
    print("--normal_invoke:--" )
    print("x is %d" %x )
    print("y is %d" %y)
# 标准调用
normal_invoke(1, 2)

运行结果：

--normal_invoke:--
x is 1
y is 2

第二种：#关键字调用 

def keyword_invoke(x, y):
    print ("--keyword_invoke--:"  )
    print ("x is %d" % x  )
    print ("y is %d" % y )

#关键字调用
keyword_invoke(y=1, x=2)
注意：关键调用从哪开始的，从哪以后都必须使用关键字调用除了‘*’收集参数。不能写成这样的：keyword_invoke(y=1, 2)，这样就会报错。

运行结果：

--keyword_invoke--:
x is 2
y is 1

第三种：#非关键字可变长参数(tuple) def normal_tuple_invoke(x, y=2, *values):  

def normal_tuple_invoke(x, y=2, *values):
   print ("--normal_tuple_invoke--"  )
   print ("x is %d" % x)
   print ("y is %d" % y )
   for value in values:
      print("tuple's value has", value)

#非关键字可变长参数(tuple)
normal_tuple_invoke(1, 3, 'xyz', 123.4)

注意：收集参数  ‘*’当你参数不确定有多少是你可是使用它，他会把不确定的部分存在values元组中，当然这个元组名字要看‘*’后面跟的是啥了。

运行结果：

--normal_tuple_invoke--
x is 1
y is 3
tuple's value has xyz
tuple's value has 123.4

第四种：关键字可变长参数

def keyword_dict_invoke(x, y=2, **value_dict):
    print ("--keyword_dict_invoke--" )
    print ("x is %d" % x  )
    print ("y is %d" % y  )
    for key in value_dict:
        print ("key is ", key  )
        print ("value is ", value_dict[key] )

#关键字可变长参数(dict)
keyword_dict_invoke(y=1, x=2, arg2='def', arg1='put at the last')

运行结果：

--keyword_dict_invoke--
x is 2
y is 1
key is  arg2
value is  def
key is  arg1
value is  put at the last

第五中：还有一种是以整个函数为参数传回来，目前我知道是装饰器在使用

装饰器实际上就是为了给某程序增添功能，但该程序已经上线或已经被使用，那么就不能大批量的修改源代码，这样是不科学的也是不现实的，因为就产生了装饰器，使得其满足：

1. 不能修改被装饰的函数的源代码
2. 不能修改被装饰的函数的调用方式
3. 满足1、2的情况下给程序增添功能

那么根据需求，同时满足了这三点原则，这才是我们的目的。因为，下面我们从解决这三点原则入手来理解装饰器。

等等，我要在需求之前先说装饰器的原则组成：

< 函数+实参高阶函数+返回值高阶函数+嵌套函数+语法糖 = 装饰器 >

这个式子是贯穿装饰器的灵魂所在

def test():
    time.sleep(2)
    print("test is running!")

def deco(func):
    start = time.time()
    func() #2
    stop = time.time()
    print(stop-start)

deco(test) #1

运行结果：

test is running!
2.009514808654785