一、函数定义和调用及文档说明
1.定义函数
定义函数的格式如下：
def 函数名():
代码demo:
# 定义一个函数，能够完成打印信息的功能
def printInfo():
'''
我要说句话
:return:
'''
print (------------------------------------)
print ( 人生苦短，我用Python )
print (------------------------------------)
2.调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用
# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()
3.函数的文档说明
如果执行，以下代码
help(printInfo)能够看到test函数的相关说明
Help on function test in module __main__:
printInfo()
我要说句话
:return:
二、函数参数
1. 定义带有参数的函数
def add2num(a, b):
c = a+b
print c
2. 调用带有参数的函数
以调用上面的add2num(a, b)函数为例:
def add2num(a, b):
c = a+b
print (c)
add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据
3.调用函数时参数的顺序
>>> 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
4.形参与实参
定义时小括号中的参数，用来接收参数用的，称为 “形参”；调用时小括号中的参数，用来传递给函数用的，称为 “实参”。
5. 缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的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
6.不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
基本语法如下：
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:
>>>
>>>
7. 引用传参（难点）
Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。
三、函数返回值
1.带有返回值的函数
想要在函数中把结果返回给调用者，需要在函数中使用return
#如下示例:
def add2num(a, b):
c = a+b
return c
#或者
def add2num(a, b):
return a+b
2.保存函数的返回值
保存函数的返回值示例如下:
#定义函数
def add2num(a, b):
return a+b
#调用函数，顺便保存函数的返回值
result = add2num(100,98)
#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print result
'''
结果:
198
'''
3.返回多个值
其本质是利用了元组。
>>> def divid(a, b):
... shang = a//b
... yushu = a%b
... return shang, yushu
...
>>> sh, yu = divid(5, 2)
>>> sh
5
>>> yu
14.四种函数的类型
函数根据有没有参数，有没有返回值，可以相互组合，一共有4种：无参数，无返回值；无参数，有返回值；有参数，无返回值；有参数，有返回值。
四、函数的嵌套调用
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用函数嵌套调用。
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置。
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----
'''
五、函数的局部与全局变量
1.局部变量
局部变量就是在函数内部定义的变量。不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响。局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用。
2.全局变量
(1)什么是全局变量
demo:
# 定义全局变量
a = 100
def test1():
print(a)
def test2():
print(a+1)
# 调用函数
test1()
test2()在函数外边定义的变量叫做全局变量。全局变量能够在所有的函数中进行访问。
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错。
如果全局变量的名字和局部变量的名字相同，那么在局部变量的使用域中使用的是局部变量的值，所谓强龙不压地头蛇。
3.可变类型的全局变量
>>> a = 1
>>> def f():
... a += 1
... print a
...
>>> f()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in f
UnboundLocalError: local variable 'a' referenced before assignment
>>>
>>>
>>> li = [1,]
>>> def f2():
... li.append(1)
... print li
...
>>> f2()
[1, 1]
>>> li
[1, 1]在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量；对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。
六、递归函数
1.什么是递归函数
通过前面的学习知道一个函数可以调用其他函数。如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
2.递归函数的作用
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
#递归函数,n须为整数
def xxx(n):
if n == 1:
return 1
result = n * xxx(n-1)
return result
a = xxx(3)
print(a) #输出6
七、匿名函数
1.何为匿名函数
用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 )
'''
以上实例输出结果：
Value of total : 30
Value of total : 40
'''Lambda函数能接收任何数量的参数但只能返回一个表达式的值。匿名函数不能直接调用print，因为lambda需要一个表达式。
2.应用场合
(1)函数作为参数传递
#自己定义函数
>>> def fun(a, b, opt):
... print "a =", a
... print "b =", b
... print "result =", opt(a, b)
...
>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3(2)作为内置函数的参数
(3)想一想，下面的数据如何指定按age或name排序？
stus = [
{"name":"zhangsan", "age":18},
{"name":"lisi", "age":19},
{"name":"wangwu", "age":17}
]
#按name排序：
>>> stus.sort(key = lambda x:x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]
#按age排序：
>>> stus.sort(key = lambda x:x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]
八、函数应用：打印图形和数学计算
1.打印图形
写一个函数打印一条横线，打印自定义行数的横线
# 打印一条横线
def printOneLine():
print("-"*30)
# 打印多条横线
def printNumLine(num):
i=0
# 因为printOneLine函数已经完成了打印横线的功能，
# 只需要多次调用此函数即可
while i<num:
printOneLine()
i+=1
printNumLine(3)
2.数学计算
写一个函数求三个数的和，写一个函数求三个数的平均值
# 求3个数的和
def sum3Number(a,b,c):
return a+b+c # return 的后面可以是数值，也可是一个表达式
# 完成对3个数求平均值
def average3Number(a,b,c):
# 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
# 即把接收到的3个数，当做实参传递即可
sumResult = sum3Number(a,b,c)
aveResult = sumResult/3.0
return aveResult
# 调用函数，完成对3个数求平均值
result = average3Number(11,2,55)
print("average is %d"%result)