这里先解释一下几个概念
- 位置参数:按位置设置的参数,隐式用元组保存对应形参.平时我们用的大多数是按位置传参.比如有函数def func(a,b,c),调用func(1,2,3).即a=1,b=2,c=3
- 关键字参数:可以通过关键字设置参数,不用关心参数位置,隐式用字典保存形参.比如有函数def func(a,b,c),调用func(b=1,c=2,a=3),即a=3,b=1,c=2

普通格式

代码如下:

def func(opt_args):
    ...
    return value

带收集位置参数的函数

格式如下

代码如下:

def func(*params):
    ...
    return value

用法

使用函数时,不用限制传参的个数,*params会自动收集传入的参数作为一个元组.

实例

代码如下:

def  func(*params):
    print params

a = [1,2,3,4]
b = 'hello'
c = 3
func(a, b, c)

输出

代码如下:

([1, 2, 3, 4], ‘hello', 3)

带收集关键字参数的函数

格式如下

代码如下:

def func(**params):
    ...
    return value

用法
按关键字传参时,**params会自动收集传入的参数作为一个字典.

实例

代码如下:

def  func(**params):
    print params
func(a=1, b=2, c=3)

输出

代码如下:

{‘a': 1, ‘c': 3, ‘b': 2}

函数特殊用法

默认参数

格式

代码如下:

def func(a = 1, b = 2)

等号(=)号是默认值,调用函数时可以不用传参给默认参数.

实例

代码如下:

def  func(a = 1, b = 2):
    print a, b 
func(a=3)

输出

代码如下:

3 2

函数可以返回多个值

格式

代码如下:

return a, b, c

实例

代码如下:

def  func(a = 1, b = 2):
    return a, b

print func(a=3)

输出

代码如下:

(3, 2)

内嵌函数和闭包

格式

代码如下:

def foo()    #外部函数
    def bar()    #内嵌函数
        ....
    ....

如果内嵌函数引用了外部函数的变量(包括外部函数参数),这个引用的变量称为自由变量, 那么称这个内嵌函数是闭包.再来看看专业的解释:闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。

实例

代码如下:

def foo(a, b):
    x = 4
    def bar():
        return x * a + b;
    return bar

f1= foo(1, 2)
f2= foo(2, 3)

print f1(), f2()

输出

代码如下:

6 11

传递函数

Python一切皆对象，函数这一语法结构也是一个对象, 可以将函数名作为参数传递

格式

代码如下:

def bar(*param1, **param2):
    ....

def foo(bar, *param1, **param2):
    bar(*param1, **param2)

实例

代码如下:

def bar(*param1, **param2):
    print param1
    print param2

def foo(bar, *param1, **param2):
    bar(*param1, **param2)

foo(bar,  1, 2, 3,  a = 111, b = 222, c = 333)

输出

代码如下:

(1, 2, 3)
{‘a': 111, ‘c': 333, ‘b': 222}

匿名函数与lambda

lambda语法可以创建一个匿名的函数,主要作用是简化书写,是一种语法糖.

- 格式

代码如下:

lambda [arg1[, arg2, … argN]] : expression

实例

代码如下:

def foo(x, y):
    return x + y
print  "call foo function, result is: ", foo(3, 4)

bar = lambda x = 2, y = 3 : x + y
print  "call lambda fucntion, result is:", bar(3,4)

输出

代码如下:

call foo function, result is: 7
call lambda fucntion, result is: 7

标准调用

关键字调用

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

关键字可变长参数(dict)

python函数调用的四种方式 --基础重点

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

# -*- coding: UTF-8 -*-  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):  

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

第四种：#关键字可变长参数(dict) 

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') 

注意：**value_dict 传回来的参数以字典：key-value的形式存放，单招顺序首先传回来的是：key，其次是：value。

运行结果：

--keyword_dict_invoke--  x is 2  y is 1  key is  arg1  
value is  put at the last  
key is  arg2  
value is  def  
  Process finished with exit code 0

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

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

1. 不能修改被装饰的函数的源代码

2. 不能修改被装饰的函数的调用方式

3. 满足1、2的情况下给程序增添功能

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

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

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

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

improt timedef 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

我们来看一下这段代码，在#1处，我们把test当作实参传递给形参func，即func=test。注意，这里传递的是地址，也就是此时func也指向了之前test所定义的那个函数体，可以说在deco()内部，func就是test。在#2处，把函数名后面加上括号，就是对函数的调用（执行它）。因此，这段代码运行结果是：

test is running! 
the run time is 3.0009405612945557

Python 中函数的应用非常广泛，前面章节中我们已经接触过多个函数，比如 input() 、print()、range()、len() 函数等等，这些都是 Python 的内置函数，可以直接使用。

除了可以直接使用的内置函数外，Python 还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

举个例子，前面学习了 len() 函数，通过它我们可以直接获得一个字符串的长度。我们不妨设想一下，如果没有 len() 函数，要想获取一个字符串的长度，该如何实现呢？请看下面的代码：

n=0for c in "http://c.biancheng.net/python/":n = n + 1print(n)

程序执行结果为：

30

要知道，获取一个字符串长度是常用的功能，一个程序中就可能用到很多次，如果每次都写这样一段重复的代码，不但费时费力、容易出错，而且交给别人时也很麻烦。

所以 Python 提供了一个功能，即允许我们将常用的代码以固定的格式封装（包装）成一个独立的模块，只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数（Function）。

比如，在程序中定义了一段代码，这段代码用于实现一个特定的功能。问题来了，如果下次需要实现同样的功能，难道要把前面定义的代码复制一次？如果这样做实在太傻了，这意味着每次当程序需要实现该功能时，都要将前面定义的代码复制一次。正确的做法是，将实现特定功能的代码定义成一个函数，每次当程序需要实现该功能时，只要执行（调用）该函数即可。

其实，函数的本质就是一段有特定功能、可以重复使用的代码，这段代码已经被提前编写好了，并且为其起一个“好听”的名字。在后续编写程序过程中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码。

下面演示了如何将我们自己实现的 len() 函数封装成一个函数：

#自定义 len() 函数def my_len(str):length = 0for c in str:length = length + 1return length#调用自定义的 my_len() 函数length = my_len("http://c.biancheng.net/python/")print(length)#再次调用 my_len() 函数length = my_len("http://c.biancheng.net/shell/")print(length)

程序执行结果为：

30
29

如果读者接触过其他编程语言中的函数，以上对于函数的描述，肯定不会陌生。但需要注意的一点是，和其他编程语言中函数相同的是，Python 函数支持接收多个（ ≥0 ）参数，不同之处在于，Python 函数还支持返回多个（ ≥0 ）值。

比如，上面程序中，我们自己封装的 my_len(str) 函数，在定义此函数时，我们为其设置了 1 个 str 参数，同时该函数经过内部处理，会返回给我们 1 个 length 值。

通过分析 my_len() 函数这个实例不难看出，函数的使用大致分为 2 步，分别是定义函数和调用函数。接下来一一为读者进行详细的讲解。

Python函数的定义

定义函数，也就是创建一个函数，可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现，具体的语法格式如下：

def 函数名(参数列表):
    //实现特定功能的多行代码
    [return [返回值]]

其中，用 [] 括起来的为可选择部分，即可以使用，也可以省略。

此格式中，各部分参数的含义如下：

• 函数名：其实就是一个符合 Python 语法的标识符，但不建议读者使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能（如上面的 my_len，即表示我们自定义的 len() 函数）。

• 形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。

• [return [返回值] ]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。

注意，在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。另外，如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。

例如，下面定义了 2 个函数：

#定义个空函数，没有实际意义def pass_dis():pass#定义一个比较字符串大小的函数def str_max(str1,str2):str = str1 if str1 > str2 else str2return str

虽然 Python 语言允许定义个空函数，但空函数本身并没有实际意义。

另外值得一提的是，函数中的 return 语句可以直接返回一个表达式的值，例如修改上面的 str_max() 函数：

def str_max(str1,str2):return str1 if str1 > str2 else str2

该函数的功能，和上面的 str_max() 函数是完全一样的，只是省略了创建 str 变量，因此函数代码更加简洁。

Python函数的调用

调用函数也就是执行函数。如果把创建的函数理解为一个具有某种用途的工具，那么调用函数就相当于使用该工具。

函数调用的基本语法格式如下所示：

[返回值] = 函数名([形参值])

其中，函数名即指的是要调用的函数的名称；形参值指的是当初创建函数时要求传入的各个形参的值。如果该函数有返回值，我们可以通过一个变量来接收该值，当然也可以不接受。

需要注意的是，创建函数有多少个形参，那么调用时就需要传入多少个值，且顺序必须和创建函数时一致。即便该函数没有参数，函数名后的小括号也不能省略。

例如，我们可以调用上面创建的 pass_dis() 和 str_max() 函数：

pass_dis()strmax = str_max("http://c.biancheng.net/python","http://c.biancheng.net/shell");print(strmax)

首先，对于调用空函数来说，由于函数本身并不包含任何有价值的执行代码，也没有返回值，应该调用空函数不会有任何效果。

其次，对于上面程序中调用 str_max() 函数，由于当初定义该函数为其设置了 2 个参数，因此这里在调用该参数，就必须传入 2 个参数。同时，由于该函数内部还使用了 return 语句，因此我们可以使用 strmax 变量来接收该函数的返回值。

因此，程序执行结果为：

http://c.biancheng.net/shell

为函数提供说明文档

前面章节讲过，通过调用 Python 的 help() 内置函数或者 __doc__ 属性，我们可以查看某个函数的使用说明文档。事实上，无论是 Python 提供给我们的函数，还是自定义的函数，其说明文档都需要设计该函数的程序员自己编写。

其实，函数的说明文档，本质就是一段字符串，只不过作为说明文档，字符串的放置位置是有讲究的，函数的说明文档通常位于函数内部、所有代码的最前面。

以上面程序中的 str_max() 函数为例，下面演示了如何为其设置说明文档：

#定义一个比较字符串大小的函数def str_max(str1,str2):    '''    比较 2 个字符串的大小    '''str = str1 if str1 > str2 else str2return strhelp(str_max)#print(str_max.__doc__)

程序执行结果为：

Help on function str_max in module __main__:

str_max(str1, str2)
    比较 2 个字符串的大小

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。一般有普通格式、带收集位置参数的函数、带收集关键字参数的函数几种格式。