Python基础(四)

函数介绍

如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

函数定义和调用

定义函数

格式如下：

def 函数名():
代码

示例：

# 定义一个函数，能够完成打印信息的功能
def printInfo():
print '------------------------------------'
print ' 人生苦短，我用Python'
print '------------------------------------'

调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它。调用函数很简单，通过函数名()即可完成调用。

示例：

# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()

函数的文档说明

>>> def test(a,b):
... "用来完成对2个数求和"
... print("%d"%(a+b))
...
>>>
>>> test(11,22)
33

如果执行，以下代码：

>>> help(test)

能够看到test函数的相关说明:

Help on function test in module __main__:

test(a, b)
用来完成对2个数求和
(END)

函数参数

定义带有参数的函数

def add2num(a, b):
c = a+b
print c

调用带有参数的函数

def add2num(a, b):
c = a+b
print c

add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据

调用带有参数函数的运行过程：

调用函数

调用函数时参数的顺序：

>>> def test(a,b):
... print(a,b)
...
>>> test(1,2)
1 2
>>> test(b=1,a=2)
2 1
>>>
>>> test(b=1,2)
File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>>

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def printinfo( name, age = 35 ):
# 打印任何传入的字符串
print "Name: ", name
print "Age ", age

# 调用printinfo函数
printinfo(name="miki" )
printinfo( age=9,name="miki" )

以上实例输出结果：

Name: miki
Age 35
Name: miki
Age 9

注意：带有默认值的参数一定要位于参数列表的最后面。

>>> def printinfo(name, age=35, sex):
... print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
基本语法如下：

def functionname([formal_args,] *args, **kwargs):
"函数_文档字符串"
function_suite
return [expression]

加了星号（ * ）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

示例：

>>> def fun(a, b, *args, **kwargs):
... """可变参数演示示例"""
... print "a =", a
... print "b =", b
... print "args =", args
... print "kwargs: "
... for key, value in kwargs.items():
... print key, "=", value
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d) # 注意元组与字典的传参方式
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args = ((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:

引用传参

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。
示例：

>>> def selfAdd(a):
... """自增"""
... a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]

函数返回值

带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return。如下：

def add2num(a, b):
c = a+b
return c

函数返回多个值

本质其实是利用了元组。

>>> def divid(a, b):
... shang = a//b
... yushu = a%b
... return shang, yushu
...
>>> sh, yu = divid(5, 2)
>>> sh
5
>>> yu
1

四种函数的类型

函数根据有没有参数，有没有返回值，可以相互组合，一共有4种：

无参数，无返回值
无参数，又反悔
有参数，无返回值
有参数，有返回值

函数的嵌套调用

示例：

def testB():
print('---- testB start----')
print('这里是testB函数执行的代码...(省略)...')
print('---- testB end----')

def testA():

print('---- testA start----')

testB()

print('---- testA end----')

testA()

结果：

---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----

局部变量与全局变量

局部变量

在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，但是各个不会产生影响
局部变量是为了临时保存数据需要在函数中定义变量来进行存储

全局变量

在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的

递归函数

函数在内部调用自己本身。

递归

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

sum = lambda arg1, arg2: arg1 + arg2

#调用sum函数
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )