前面几章已经学习了 Python 内置的一些函数，如 `print()` `input()` `len()` `str()` 等。其实我们自己也可以编写属于自己的函数。函数其实是可重复使用的一系列代码的集合，或者说是可重复使用的代码块，显然函数也是一种流程控制结构。
*****
[TOC]
****
# 4.1 代数中的函数
代数中，一个函数如： `f(x) = x * 2`
这是一个非常简单的函数，用以求给定 x 的2倍。如：f(2) = 2 * 2 = 4，f(3) = 3 * 2 = 6。
# 4.2 Python中函数定义与使用
**定义** Python中函数使用关键字 `def` 来定义，语法如下：
```
def function_name(parameters):
''' docstring '''
statement(s)
```
中文解释：
```
def 函数名(参数们):
''' 文档字符串，描述函数是做什么的 '''
函数体（一行以上的代码）
```
函数名命名规则同变量名命名规则。
**使用定义好的函数——调用**
```
function_name(actual parameters)
```
实例：
```
# 斐波那契数列
def fib(n):
"""print a Fibbonacci series up to n."""
a, b = 0, 1
fibLst = []
while a < n:
## print(a, end=',')
fibLst.append(a)
a, b = b, a+b
return fibLst
print(fib(100))
```
```
# Out:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
```
该实例定义了 fib(n) 函数，n 称之为形式参数（形参）。 `print(fib(100))` 中 fib(100) 则是对已定义函数的调用，100 称之为实际参数（实参）。
# 4.3 函数的参数
*参考runobb.com*
**可更改(mutable)与不可更改(immutable)对象：**
在 Python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
* **不可变类型：**变量赋值**a=5**后再赋值**a=10**，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
* **可变类型：**变量赋值**la=[1,2,3,4]**后再赋值**la[2]=5**则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
Python 函数的参数传递：
* **不可变类型：**类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
* **可变类型：**类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
Python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
Python 传不可变对象实例：
```
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print(b)
# 结果是 2
```
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。
Python 传可变对象实例：
可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
```
# 可写函数说明
def changeme(mylist):
"'修改传入的列表"'
mylist.append([1,2,3,4])
print("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme(mylist)
print("函数外取值: ", mylist)
```
```
# Out:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
```
**调用函数时可使用的正式参数类型**（若定义时参数为空—即括号里为空，则调用时不需要传入参数）：
* 必需参数
* 关键字参数
* 默认参数
* 不定长参数
必需参数：
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。如下：
```
# 可写函数说明
def printme(str):
'''打印任何传入的字符串'''
print(str)
return
# 调用 printme 函数，不加参数会报错
printme()
```
```
# Out：
Traceback (most recent call last):
File "function-para.py", line 8, in <module>
printme()
TypeError: printme() missing 1 required positional argument: 'str'
```
关键字参数：
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
```
# 可写函数说明
def printme(str):
'''打印任何传入的字符串'''
print(str)
return
# 调用printme函数
printme(str = "随心而码") # 随心而码
```
以下实例中演示了函数参数的使用不需要使用指定顺序：
```python
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
```
```
# Out：
名字: runoob
年龄: 50
```
默认参数：
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
```
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )
```
```
# Out：
名字: runoob
年龄: 50
------------------------
名字: runoob
年龄: 35
```
不定长参数：
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
```
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
```
加了星号\*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
```
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
```
```
# Out:
70
(60, 50)
```
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
```
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
```
```
# Out:
10
输出:
70
60
50
```
还有一种就是参数带两个星号\*\*基本语法如下：
```
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
```
加了两个星号\*\*的参数会以字典的形式导入。
```
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
```
```
# Out:
1
{'a': 2, 'b': 3}
```
*****
# 4.4 函数与变量作用域
前面已经学习过了变量及其命名规则，现在学习变量作用域——变量的作用范围。只有在模块、函数、类中，我们讨论变量的作用域。
**全局变量与局部变量**
在 Python 中根据变量可供访问的作用范围，将变量分为全局变量（Global Variable）和局部变量（Local Variable）。
* 全局变量定义于模块、函数、类之外，自赋值定义开始，后续代码都可以访问该变量
* 局部变量只能在被定义的模块、函数或类内部被访问
```
j = 10 # Global Variable
def add(i):
i = i + j # i: Local Variable
return i
i = 16 # Global Variable,not the i inside the function
print('Global Variable:', j)
print('"i" inside the function:', add(5))
print('"i" outside the function,it\'s a new global variable:', i)
```
```
# Out：
Global Variable: 10
"i" inside the function: 15
"i" outside the function,it's a new global variable: 16
```
**global 关键字**
```
i = 1
def test():
i = i + 5
print(i)
test()
```
```
# Out：
Traceback (most recent call last):
File "func-variable-scope.py", line 18, in <module>
test()
File "func-variable-scope.py", line 15, in test
i = i + 5
UnboundLocalError: local variable 'i' referenced before assignment
```
添加 `global` 关键字后，内部作用域可修改外部作用域
```
i = 1
print('全局变量内存地址：',id(i))
def test():
global i
print('全局变量函数内赋值前内存地址：',id(i))
i = i + 5
print('全局变量函数内赋值后内存地址：',id(i))
print(i)
test()
print(i)
```
```
# Out：
全局变量内存地址： 140712509232160
全局变量函数内赋值前内存地址： 140712509232160
全局变量函数内赋值后内存地址： 140712509232320
6
6
```
显然（哈哈哈哈哈···），最初定义的全局变量内存地址不变。在函数内赋值后的 i 是一个新的全局变量。
**闭包（Closure）** 闭包是介于全局变量和局部变量之间的一种特殊变量。闭包变量定义在外部函数与内部嵌套函数之间。用法如下：
```
j = 5 # 全局变量 j
def sum0(): # 外部函数 sum0
k = 1 # 闭包变量 k
def sum1(): # 嵌套的内部函数 sum1
i = k + j # 局部变量 i
return i
return sum1()
s = sum0()
print(s) # 输出 6
```
**nonlocal 关键字**
如果要修改嵌套作用域（Closure作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：
```
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
```
```
# Out:
100
100
```
全局变量、闭包变量、局部变量的使用范围的关系如下：
全局变量 > 闭包变量 > 局部变量。
注意：在编程中尽量不要使用这些编程方法。
*****
# 4.5 匿名函数
Python 中使用 `lambda` 来创建匿名函数。所谓匿名函数，与 `def` 关键字定义的函数相比，没有函数名称。
* lambda 只是一个表达式，函数体比 def 简单很多。
* lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
* lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
* 虽然 lambda 函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
lambda 函数的语法只包含一个语句，如下：
```
lambda [arg1 [,arg2,.....argn]]:expression
```
示例：
```
>>> lambda x, y: x * y
<function <lambda> at 0x000002116691C1E0>
>>> func = lambda x, y: x * y
>>> func(2,2)
4
```
*****
# 4.6 递归函数
递归（Recursion Algorithm，递归算法）在计算机科学中是指一种通过重复将问题分解为同类子问题而解决问题的方法。
利用函数实现递归过程就是递归函数。递归函数通过自己调用自己来实现递归算法。
实例：求 1，2，3，4，···，n 加法和
```
# 一般求和函数
def add(num):
i = 1
add = 0
while i <= num:
add = add + i
i += 1
return add
print(add(50)) # 1275
# 递归求和函数
def recursion_add(num):
if num == 1:
return num
return recursion_add(num-1) + num
print(recursion_add(50)) # 1275
```
