（一）函数介绍

什么是函数

请看如下代码:

_/___.' >'"". ")
print (" | | : - \\.;\\ _ /;./ - : | | ")
print (" \ \ -. \\_ __\\ /__ _/ .- / / ")
print (" ======-.____-.___\_____/___.-____.-'====== ") print (" =---=' ")
print (" ")
print (" ............................................. ")
print (" 佛祖镇楼 BUG辟易 ")
print (" 佛曰: ")
print (" 写字楼里写字间，写字间里程序员； ")
print (" 程序人员写程序，又拿程序换酒钱。 ")
print (" 酒醒只在网上坐，酒醉还来网下眠； ")
print (" 酒醉酒醒日复日，网上网下年复年。 ")
print (" 但愿老死电脑间，不愿鞠躬老板前； ")
print (" 奔驰宝马贵者趣，公交自行程序员。 ")
print (" 别人笑我忒疯癫，我笑自己命太贱； ")
print (" 不见满街漂亮妹，哪个归得程序员？")
">

print ("                            _ooOoo_  ")
print ("                           o8888888o  ")
print ("                           88  .  88  ")
print ("                           (| -_- |)  ")
print ("                            O\\ = /O  ")
print ("                        ____/`---'\\____  ")
print ("                      .   ' \\| |// `.  ")
print ("                       / \\||| : |||// \\  ")
print ("                     / _||||| -:- |||||- \\  ")
print ("                       | | \\\\\\ - /// | |  ")
print ("                     | \\_| ''\\---/'' | |  ")
print ("                      \\ .-\\__ `-` ___/-. /  ")
print ("                   ___`. .' /--.--\\ `. . __  ")
print ("                ."" '< `.___\\_<|>_/___.' >'"".  ")
print ("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |  ")
print ("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /  ")
print ("         ======`-.____`-.___\\_____/___.-`____.-'======  ")
print ("                            `=---='  ")
print ("  ")
print ("         .............................................  ")
print ("                  佛祖镇楼                  BUG辟易  ")
print ("          佛曰:  ")
print ("                  写字楼里写字间，写字间里程序员；  ")
print ("                  程序人员写程序，又拿程序换酒钱。  ")
print ("                  酒醒只在网上坐，酒醉还来网下眠；  ")
print ("                  酒醉酒醒日复日，网上网下年复年。  ")
print ("                  但愿老死电脑间，不愿鞠躬老板前；  ")
print ("                  奔驰宝马贵者趣，公交自行程序员。  ")
print ("                  别人笑我忒疯癫，我笑自己命太贱；  ")
print ("                  不见满街漂亮妹，哪个归得程序员？")

运行后的现象:

想一想：
如果一个程序在不同的地方需要输出“佛祖镇楼”，程序应该怎样设计？

 if 条件1:
    输出‘佛祖镇楼’

...(省略)...

if 条件2:
    输出‘佛祖镇楼’

...(省略)...

如果需要输出多次，是否意味着要编写这块代码多次呢？

抽象
抽象是数学中非常常见的概念。举个例子：
计算数列的和，比如：1 + 2 + 3 + ... + 100，写起来十分不方便，于是数学家发明了求和符号∑，可以把 1 + 2 + 3 + ... + 100记作：
$\underset{n=1}{\overset{100}{\sum n}}$
这种抽象记法非常强大，因为我们看到 ∑ 就可以理解成求和，而不是还原成低级的加法运算。
而且，这种抽象记法是可扩展的，比如：
$\underset{n=1}{\overset{100}{\sum (n^2+1)}}$
还原成加法运算就变成了：
(1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1)
可见，借助抽象，我们才能不关心底层的具体计算过程，而直接在更高的层次上思考问题。
写计算机程序也是一样，函数就是最基本的一种代码抽象的方式。

小总结:

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

（二）函数定义和调用

（1）定义函数

定义函数的格式如下：

def 函数名():
    代码

demo:

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

（2）调用函数

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

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

注意：Python调用函数要放在定义函数后面，部分编程语言可放在前面

（3）练一练

要求：定义一个函数，能够输出自己的姓名和年龄，并且调用这个函数让它执行

• 使用def定义函数
• 编写完函数之后，通过 函数名() 进行调用

答案

（三）函数的文档说明

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

如果执行，以下代码

help(test)

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

Help on function test in module __main__:

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

（四）函数参数①

思考一个问题，如下：

现在需要定义一个函数，这个函数能够完成2个数的加法运算，并且把结果打印出来，该怎样设计？下面的代码可以吗？有什么缺陷吗？

def add2num():
    a = 11
    b = 22
    c = a+b
    print(c)

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是 函数的参数

(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)练一练

要求：定义一个函数，完成前2个数完成加法运算，然后对第3个数，进行减法；然后调用这个函数

• 使用def定义函数，要注意有3个参数
• 调用的时候，这个函数定义时有几个参数，那么就需要传递几个参数

答案：

def superman(a,b,c):
    d = c - (a + b)
    print(d)

superman(247,369,9527)

(4)调用函数时参数的顺序

", line 1
SyntaxError: positional argument follows keyword argument

">

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

(5)小总结

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”。
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”。

（五）函数返回值①

（1）“返回值”介绍

现实生活中的场景:

我给儿子10块钱，让他给我买包烟。这个例子中，10块钱是我给儿子的，就相当于调用函数时传递到参数，让儿子买烟这个事情最终的目标是，让他把烟给你带回来然后给你对么，此时烟就是返回值。

开发中的场景：

定义了一个函数，完成了获取室内温度，想一想是不是应该把这个结果给调用者，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整。

综上所述：

• 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果。

（2）带有返回值的函数

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

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

或者

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

（3）保存函数的返回值

在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存。
保存函数的返回值示例如下:

#定义函数
def add2num(a, b):
    return a+b

#调用函数，顺便保存函数的返回值
result = add2num(100,98)

#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

（六）4种函数的类型

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

• 无参数，无返回值
• 无参数，有返回值
• 有参数，无返回值
• 有参数，有返回值

（1）无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数。

def printMenu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

结果:

无参数，有返回值的函数

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数。

 # 获取温度
def getTemperature():
#这里是获取温度的一些处理过程
#为了简单起见，先模拟返回一个数据
    return 24

temperature = getTemperature()
print('当前的温度为:%d'%temperature)

（2）有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数。

（3）有参数，有返回值的函数

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数。

# 计算1~num的累积和
def calculateNum(num):
    result = 0
    i = 1
    while i<=num:
        result = result + i
        i+=1
    return result

result = calculateNum(100)
print('1~100的累积和为:%d'%result)

（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----

小总结：

• 一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
  
• 如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

（八）局部变量

（1）什么是局部变量

如下图所示:

（2）小总结

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

（九）全局变量

（1）什么是全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
demo如下:

定义全局变量

a = 100

def test1():
    print(a)

def test2():
    print(a)

# 调用函数
test1()
test2()

运行结果:

100
100

（2）全局变量和局部变量名字相同问题

看如下代码:

（3）修改全局变量

既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢？
代码如下:

（4）总结1:

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

（5）可变类型的全局变量

>>> 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]

（6）总结2：

• 在函数中不使用 global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
• 对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用 global时无法修改全局变量。
• 对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用 global时也可修改全局变量。

（十）函数返回值②

在python中我们可不可以返回多个值？

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

本质是利用了元组

(十一)函数参数②

（1）缺省参数

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

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

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

以上实例输出结果：

Name: 9527
Age 35
Name: 9527
Age 9

注意：带有默认值的参数一定要位于参数列表的最后面（可设置多个带默认值的参数）。

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

（2）不定长参数

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

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:
>>>
>>>

(3)引用传参

• 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
• Python有没有类似C语言中的指针传参呢？

>>> 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]

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

想一想为什么

>>> def selfAdd(a):
...     """自增"""
...     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]      # 想一想为什么没有变呢？

(十二)引用

在python中，值是靠引用来传递来的。
我们可以用 id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了
13033792
>>> id(b)   # b的id值依旧
13033816

>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a与b始终指向同一个地址
139935018544808
>>> b
[1, 2, 3]

可变类型与不可变类型
可变类型，值可以改变：

• 列表 list
• 字典 dict

不可变类型，值不可以改变：

• 数值类型 int, long, bool, float
• 字符串 str
• 元组 tuple

（十三）递归函数

（1）什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

（2）递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
解决办法1:

看阶乘的规律

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

解决办法2:

原理

解决办法3：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试 fact(1000)：

>>> fact(1000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in fact
  ...
  File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的 fact(n)函数由于 return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和 num * product在函数调用前就会被计算，不影响函数调用。
fact(5)对应的 fact_iter(5, 1)的调用如下：

===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的 fact(n)函数改成尾递归方式，也会导致栈溢出。

（3）小结

• 使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。
• 针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。
• Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

（十四）匿名函数

用 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需要一个表达式

应用场合

函数作为参数传递函数作为参数传递
①自己定义函数

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

②作为内置函数的参数

想一想，下面的数据如何指定按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'}]