3-python 函数篇

1. 函数组成元素介绍 ：

1.1 语句块关键字 : def ：

def test():    print "hello world";

1.2 返回值 return 介绍 ：

def test():    print "hello world";    return 10;

函数带有return 语句的时候， 程序运行到 return 则结束，并且将指定的值返回给调用者。

如果函数中没有 return, 或者类似 return ; 的语句的时候， 函数返回 Node.

函数可以返回多个值 :

def test():    return 5, 23;

这样可以返回多个值，但本质上是一个元组。

1.3 函数 参数 介绍 ：

函数一般可以传参进去， 定义时候直接在函数名后面的括号中定义 形参 即可。

def test(name,arg):    print "hello : " + name + "!";    return arg;

调用时候可以直接使用如 : a=test("test",123); 的形式调用。

2. 特殊形式的函数参数 ：

2.1 指定形参的方式调用：

函数中可以指定形参来调用函数， 这样可以不用按照函数定义形参的顺序来传值。

def test(name,arg):    print "hello : " + str(name) + "!";    return arg;a=test(arg="test",name=123);print a;

2.2 默认参数 ：

定义函数参数的时候可以使用默认值，如果函数参数使用了默认值， 则当不传参给它的时候， 参数将赋值一个指定默认值。

def test(name,arg=0):    print "hello : " + str(name) + "!";    return arg;a=test(name="test");print a;

当出现多个参数的时候， 默认参数定义必须从右向左。

2.3 可变参数：

• 元组形式的可变参数：

def test(*val):    print len(val);    for i in range(0,len(val)):        print val[i]test(1,2,3,4,5);

如上所示的使用 * + 参数名 ,可以接受多个不确定长度的参数，最终结果会将传递的值通过元组的形式存放到 val 中去。

以上的赋值相当于 : val=(1,2,3,4,5);

• 字典形式的可变参数：

def test(**val):        print val;        for key in list(val.keys()):            print key + " : " + str(val[key]);test(name="saligia",value=13, boolean=True, null=None);

如上所示的使用 ** + 参数名 ,可以接受多个不确定长度的参数，最终结果会将传递的值通过字典的形式存放到 val 中去。

以上的赋值相当于 : {'boolean': True, 'null': None, 'name': 'saligia', 'value': 13}

• 元组反转 :

元组反转实在传递函数参数的时候，可以将元组拆分成多个值来传递给参数：

def test(name,value):    print "name : " + name ;    print "value : " + value;args=("name","value");test(*args);

如上这样使用 *args 传递参数时候就相当于 test("name","value") 。

• 字典反转 :

def test(name,value):    print "name : " + name ;    print "value : " + value;args={'name':'saligia','value':'13'};test(**args);

3. main 函数 ：

python 代码的执行不依赖于 main（） 函数, python 代码从没有缩进的代码开始执行。

为了区分主执行文件还是被调用的文件，Python引入了一个变量 __name__ , 当文件是被调用时, __name__ 的值为模块名，当文件被执行时，__name__ 为__main__.

这个特性，为测试驱动开发提供了极好的支持，我们可以在每个模块中写上测试代码，这些测试代码仅当模块被Python直接执行时才会运行，代码和测试完美的结合在一起。

def fibo(num):    val=[0,1];    for i in range(0,num):        if i >= len(val) :            val.append(val[i-1] + val[i-2]);    return val;if __name__ == "__main__" :  print fibo(10);

4. 高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数 – 回调。

def add(x,y):    return x+y;def call(a,b,fun):    return fun(a,b);if __name__ == '__main__':  func=add  print call(15,20,func);

4.1 map/reduce 函数

4.1.1 map 函数

map 函数是对列表中的每一个值都调用指定的 func , 结果构成一个新的集合。

def filt(arg):    if arg > 5:        return 1;    else :        return 0;if __name__ == '__main__':  arr=range(10);  print map(filt, arr);#  [0, 0, 0, 0, 0, 0, 1, 1, 1, 1]

4.1.2 reduce 函数

reduce 是归并函数， 定义函数接受两个参数，返回一个值，通过这种迭代最终将一个 Iterator 编程一个值：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

实例 :

def filt(x,y):    if y > 5:        return x+y;    else :        return x+0;if __name__ == '__main__':  arr=range(10);  print reduce(filt, arr);

4.2 filter

filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

def func(x):    return x>5;if __name__ == '__main__':  arr=range(10);  print filter(func, arr);   ## [6, 7, 8, 9]

4.3 sorted 排序函数 ：

sorted 用来给列表排序 ：

arr=[10,13,1,5,3,0];print sorted(arr);

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序,key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

def lower(args):   return str(args).lower();if __name__ == '__main__':  arr=["Hello","abc",12,4,5,"Rst","year","Hear","zookeeper"];  print sorted(arr, key=lower);## [12, 4, 5, 'abc', 'Hear', 'Hello', 'Rst', 'year', 'zookeeper']

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True

def lower(args):   return str(args).lower();if __name__ == '__main__':  arr=["Hello","abc",12,4,5,"Rst","year","Hear","zookeeper"];  print sorted(arr, key=lower, reverse=True);

4.4 返回函数 ：

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def get_add(*args):    def func():        val = 0;        for num in args :            val = val + int(num);        return val ;    return func;if __name__ == '__main__':    f=get_add(1,2,3,4,5,5);    print f();

闭包调用问题 :

案例 :

def count():    fs = []    for i in range(1, 4):        def f():             return i*i        fs.append(f)    return fsf1,f2,f3 = count()print f1()     # 9print f2()     # 9print f3()     # 9

函数的调用发生在执行时， 所以当 return fs 的时候 i 等于 3 ， i 为全局变量， 所以调用 f() 返回 9。

解决办法是将全局变量编程函数内部的局部变量。

def count():    fs = []    for i in range(1, 4):        def f(num):            def g():                return num*num            return g;        fs.append(f(i))    return fsf1,f2,f3 = count()print f1()       # 1print f2()       # 4print f3()       # 9

4.5 匿名函数 ：

lambda 关键字表示匿名函数：

lambda x : x*x;

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

func=lambda x : x*x;print func(10)

匿名函数也可以作为返回值:

def build(x, y):    return lambda: x * x + y * y