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 fs

f1,f2,f3 = count()

print f1()     # 9
print f2()     # 9
print 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 fs

f1,f2,f3 = count()

print f1()       # 1
print f2()       # 4
print 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