返回值

返回多个结果

元组可以包含锁哥数据，因此可以使用元组让函数一次返回多个值。如果函数返回的类型是元组，小括号可以省略。即: 推荐使用 return a,b 替换 return (a,b)

In [1]: def  test():
   ...:     a = 1
   ...:     b = 2
   ...:     return a,b
   ...:

In [2]: a_out, b_out = test()

In [5]: a_out
Out[5]: 1

In [6]: b_out
Out[6]: 2

In [7]: result = test()

In [8]: type(result)
Out[8]: tuple

交换两个数字 a, b

解法 1：使用临时变量

In [14]: c = a

In [15]: a = b

In [16]: b = c

解法二：不适用临时变量

In [18]: a = a + b

In [19]: b = a - b

In [20]: a = a - b

解法三：Python 专有 --推荐

1 2	# a, b = (b, a) 等号右边是一个元组，只是把小括号省略了。 a, b = b, a

函数参数

无论传递的参数是标示可变对象，还是不可变对象，只要针对在函数内部使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用。因为赋值就直接改变了变量与对象的绑定。

+=

对一般对象而言， += 就是 xx = xx + varible , 而列表变量使用 += , 即: num_list += 1 ，不会做相加再赋值的操作，本质上是在调用列表的 extend 方法，因此，它没有像 num_list = num_list + [4,5] 赋值操作这样，修改变量与对象的绑定，所以，实际上它操作的是外部传进的参数绑定的对象(即: 可以对传进的外部列表对象进行修改)。

In [30]: num_list = [1,2,3]
In [31]: def test(num_list):
    ...:     num_list += [4,5]

In [32]: test(num_list)

In [33]: num_list
Out[33]: [1, 2, 3, 4, 5]
# 可以看到，使用 += 通过 extend 实际上操作的是和外部绑定的同一个列表对象

In [34]: num_list = [1,2,3]

In [35]: def test(num_list):
    ...:     num_list = num_list + [4,5]

In [36]: test(num_list)

In [37]: num_list
Out[37]: [1, 2, 3]
# 可以看到，使用 = 赋值，重新将 num_list 变量绑定到了一个新的列表(num_list + [4,5]) 上，对外部变量的绑定对象没有影响。

缺省参数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
例如：对列表排序的方法： list.sort() 有一个 reverse 参数默认为 false，升序排序。

指定函数的缺省参数

在参数后使用赋值语句，可以指定参数的缺省值

提示

1. 缺省参数，需要使用最常见的值作为默认值！
2. 如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！

缺省参数的注意事项

缺省参数的定义位置
- 必须保证带有默认值的缺省参数在参数列表末尾
- 所以，以下定义是错误的！
def print_info(name, gender=True, title):
调用带有多个缺省参数的函数

在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！

多值参数(可变参数)

定义支持多值参数的函数

有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数
python 中有两种多值参数：

参数名前增加一个 * 可以接收元组参数名前增加两个 * 可以接收字典
一般在给多值参数命名时，习惯使用以下两个名字
- *args --存放元组参数，前面有一个 *
- **kwargs --存放字典参数，前面有两个 *
args 是 arguments 的缩写，有变量的含义
kw 是 keyword 的缩写， kwargs 可以记忆键值对参数

提示：多值参数的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，有利于我们能够读懂大牛的代码

代码示例:

In [39]: def demo(num, *nums, **person):
    ...:     print(num)
    ...:     print(nums)
    ...:     print(person)
    ...:

In [40]: demo(1)
1
()
{}

In [41]: demo(1,2,3,4,5)
1
(2, 3, 4, 5)
{}
In [42]: demo(1,2,3,4,name="小明", age=14)
1
(2, 3, 4)
{'name': '小明', 'age': 14}

案例: 计算任意多个数字的和

需求:

定义一个函数 sum_numbers , 可以接收的任意多个整数
功能要求: 将传递的所有数字累加，并且返回累加结果。

如果不使用可变参数，即: 使用元组达到传递多值的效果，代码如下:

def sum_numbers(args):
    num = 0
    print(args)

    # 循环遍历
    for n in args:
        num += n

    return num

result = sum_numbers((1,2,3,4))# 这里要多写括号，使其成为元组。

print(result)

如果使用可变参数，代码如下:

def sum_numbers(*args):
    num = 0
    print(args)

    # 循环遍历
    for n in args:
        num += n
    return num

result = sum_numbers(1,2,3,4)

print(result)

这样，传参的时候就方便简洁多了。

传参中的拆包

在调用带有多值参数的函数时，如果希望：
- 将一个元组变量，直接传递给 args
- 将一个字典变量，直接传递给 kwdrgs
就可以使用拆包，简化参数的传递，拆包的方式是：
- 在元组变量前，增加一个 *
- 在字典变量前，增加两个 *
在格式化输出的时候，也可以直接拆包比如：print("%d %d" % hero_rect.size) 直接将含有两个 number 的元组进行拆包输出。

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

#需要将一个元组变量/字典变量传递给函数对应的参数

gl_nums = (1,2,3)
gl_dict = {"name":"xiaoming", "age":18}

# 会把 gl_nums 和 gl_dict 作为元祖传递给 args
# demo(gl_nums, gl_dict)
# OUTPUT:
# ((1, 2, 3), {'name': 'xiaoming', 'age': 18})
# {}

demo(*gl_nums, **gl_dict)

输出:

(1, 2, 3)

{'name': 'xiaoming', 'age': 18}

递归

Be aware that recursion really isn’t a strong Python feature due tothe inherent recursion limit

特点：

一个函数内部调用自己
- 一个函数内部可以调用其他函数，当然，在函数内部也可以调用自己

代码特点：

函数内部代码是相同的，只是针对参数不同，处理结果不同
当参数满足一个条件时，函数不再执行
- 这个非常重要，通常被称为递归的出口，否则会出现死循环
编写递归程序时，关键两点:
1. 递归出口，递归截止条件
2. 递推表达式

提示：递归是一个编程技巧，在处理不确定的循环条件时，格外有用，例如: 遍历整个文件目录结构

Python function