函数
函数
函数这个章节内容比较多，对于新手也有一定难度。建议多看几遍，多练习代码。
一、Python 自定义函数的基本步骤 #
1、什么是函数
函数，从学习 Python 之初就开始接触了。不过大多使用的是 Python 的内置函数。比如基本每个章节都会出现的 print() 函数。而现在主要学习的是自定义函数。
那么为什么需要函数呢？
函数就是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。函数其实就是把代码抽象出来的代码段。
那为什么要抽象出来呢？方便使用，方便重复使用。
函数的本质就是把一些数据传递给函数，让他内部处理后，返回所需要的结果。
举个例子，每次用到的 print 函数，都知道这个函数的作用是把数据输出到控制台。所以 print('两点水') 就是把 两点水 这个数据喂给 print 函数，然后直接将结果打印到控制台上。
2、如何自定义函数
要了解如何定义函数，需要先了解函数的组成部分。
def 函数名(参数1，参数2....参数n):
函数体
return 语句
这就是 Python 函数的组成部分。
所以自定义函数，基本有以下规则步骤：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
- 函数的第一行语句可以选择性地使用文档字符串（用于存放函数说明）
- 函数内容以冒号起始，并且缩进
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
语法示例：
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
实例：
- def 定义一个函数，给定一个函数名 sum
- 声明两个参数 num1 和 num2
- 函数的第一行语句进行函数说明：两数之和
- 最终 return 语句结束函数，并返回两数之和
def sum(num1,num2):
"两数之和"
return num1+num2
# 调用函数
print(sum(5,6))
输出结果：
11
二、函数返回值
通过上面的学习，可以知道通过 return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。
具体示例：
# -*- coding: UTF-8 -*-
def sum(num1,num2):
# 两数之和
if not (isinstance (num1,(int ,float)) and isinstance (num2,(int ,float))):
raise TypeError('参数类型错误')
return num1+num2
print(sum(1,2))
返回结果：
3
这个示例还通过内置函数 isinstance() 进行数据类型检查，检查调用函数时参数是否是整型和浮点型。如果参数类型不对，会报错，提示"参数类型错误"。
当然，函数也可以返回多个值，具体实例如下：
# -*- coding: UTF-8 -*-
def division ( num1, num2 ):
# 求商与余数
a = num1 % num2
b = (num1-a) / num2
return b , a
num1 , num2 = division(9,4)
tuple1 = division(9,4)
print (num1,num2)
print (tuple1)
输出的值：
2.0 1
(2.0, 1)
认真观察就可以发现，尽管从第一个输出值来看，返回了多个值，实际上是先创建了一个元组然后返回的。
回忆一下，元组是可以直接用逗号来创建的，观察例子中的 ruturn ，可以发现实际上我们使用的是逗号来生成一个元组。
Python 语言中的函数返回值可以是多个，而其他语言往往不支持，这是 Python 相比其他语言的简便和灵活之处。
Python 一次接受多个返回值的数据类型就是元组。
如果不记得元组的相关知识，建议立即动手写几个例子回忆一下，比如如何获取元组的第一个元素。
三、函数的参数
1、函数的参数类型
设置与传递参数是函数的重点，而 Python 的函数对参数的支持非常灵活。主要的参数类型有：默认参数、关键字参数（位置参数）、不定长参数。下面将逐一了解这几种参数。
2、默认参数
有时候，自定义的函数中如果调用的时候没有设置参数，需要给个默认值，这时候就需要用到默认值参数了。默认参数，只要在构造函数参数时，给参数赋值即可。
例如：
# -*- coding: UTF-8 -*-
def print_user_info( name , age , sex = '男' ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex))
return;
# 调用 print_user_info 函数
print_user_info( '两点水' , 18 , '女')
print_user_info( '三点水' , 25 )
输出结果：
昵称：两点水 年龄：18 性别：女
昵称：三点水 年龄：25 性别：男
从输出结果可以看到，当你设置了默认参数的时候，在调用函数的时候，不传该参数，就会使用默认值。
但是这里需要注意的一点是：只有在形参表末尾的那些参数可以有默认参数值，也就是说你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=1) 是有效的，但是 def func(a=1, b) 是 无效 的。
默认参数就这样结束了吗？还没有，细想一下，如果参数中是一个可修改的容器比如一个 list（列表）或者 dict（字典），那么使用什么来作为默认值呢？
可以使用 None 作为默认值。就像下面这个例子一样：
# 如果 b 是一个 list ，可以使用 None 作为默认值
def print_info( a , b = None ):
if b is None :
b=[]
return;
认真看下例子，会不会有这样的疑问：在参数中直接 b=[] 不就行了吗？也就是写成下面这个样子：
def print_info( a , b = [] ):
return;
对不对呢？运行一下也没发现错误啊，可以这样写吗？
这里需要特别注意的一点：默认参数的值应为不可变的对象，比如 None、True、False、数字或字符串。如果像上面的那样操作，当默认值在其他地方被修改后将会遇到各种麻烦。这些修改会影响到下次调用这个函数时的默认值。
示例如下：
# -*- coding: UTF-8 -*-
def print_info( a , b = [] ):
print(b)
return b ;
result = print_info(1)
result.append('error')
print_info(2)
输出的结果：
[]
['error']
认真观察，你会发现第二次输出的值根本不是你想要的，因此切忌不能这样操作。
还有一点，有时候就是不想要默认值，只想判断默认参数有没有值传递进来，那该怎么办？可以这样做：
_no_value =object()
def print_info( a , b = _no_value ):
if b is _no_value :
print('b 没有赋值')
return;
这里的 object 是 Python 中所有类的基类。可以创建 object 类的实例，但这些实例没什么实际用处，因为它并没有任何有用的方法，也没有任何实例数据（因为它没有任何的实例字典，甚至都不能设置任何属性值）。唯一能做的就是测试同一性，也正好利用这个特性来判断是否有值输入。
3、关键字参数（位置参数）
一般情况下，给函数传参需要按顺序来，如果不对应顺序，就会传错值。不过在 Python 中，可以通过参数名来给函数传递参数，而不用关心参数列表定义时的顺序，这被称之为关键字参数。
使用关键参数有两个优势：
- 由于不必担心参数的顺序，使用函数变得更加简单。
- 假设其他参数都有默认值，可以只给想要的那些参数赋值。
具体看例子：
# -*- coding: UTF-8 -*-
def print_user_info( name , age , sex = '男' ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex))
return;
# 调用 print_user_info 函数
print_user_info( name = '两点水' ,age = 18 , sex = '女')
print_user_info( name = '两点水' ,sex = '女', age = 18 )
输出的值：
昵称：两点水 年龄：18 性别：女
昵称：两点水 年龄：18 性别：女
4、不定长参数
有时候设计函数时，无法确定传入的参数个数，那么可以使用不定长参数。
Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 *。
如果在函数调用时没有指定参数，它就是一个空元组。也可以不向函数传递未命名的变量。
例如：
# -*- coding: UTF-8 -*-
def print_user_info( name , age , sex = '男' , * hobby):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex) ,end = ' ' )
print('爱好：{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( '两点水' ,18 , '女', '打篮球','打羽毛球','跑步')
输出的结果：
昵称：两点水 年龄：18 性别：女 爱好：('打篮球', '打羽毛球', '跑步')
通过输出的结果可以知道，*hobby 是可变参数，且 hobby 其实就是一个 tuple（元组）。
可变长参数也支持关键字参数（位置参数），没有被定义的关键参数会被放到一个字典里。这种方式即在参数前边加 **，更改上面的示例如下：
# -*- coding: UTF-8 -*-
def print_user_info( name , age , sex = '男' , ** hobby ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex) ,end = ' ' )
print('爱好：{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( name = '两点水' , age = 18 , sex = '女', hobby = ('打篮球','打羽毛球','跑步'))
输出的结果：
昵称：两点水 年龄：18 性别：女 爱好：{'hobby': ('打篮球', '打羽毛球', '跑步')}
通过对比上面的例子和这个例子，可以知道，*hobby 是可变参数，且 hobby 其实就是一个 tuple（元组），**hobby 是关键字参数，且 hobby 就是一个 dict（字典）。
5、只接受关键字参数
关键字参数使用起来简单，不容易出错。那么有些时候希望某些参数强制使用关键字参数传递，该怎么办呢？
将强制关键字参数放到某个 * 参数或者单个 * 后面就能达到这种效果，比如：
# -*- coding: UTF-8 -*-
def print_user_info( name , *, age , sex = '男' ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex))
return;
# 调用 print_user_info 函数
print_user_info( name = '两点水' ,age = 18 , sex = '女' )
# 这种写法会报错，因为 age ，sex 这两个参数强制使用关键字参数
#print_user_info( '两点水' , 18 , '女' )
print_user_info('两点水',age='22',sex='男')
通过例子可以看到，如果 age、sex 不使用关键字参数是会报错的。
很多情况下，使用强制关键字参数会比使用位置参数表意更加清晰，程序也更加具有可读性。使用强制关键字参数也会比使用 **kw 参数更好，且强制关键字参数在一些更高级场合同样也很有用。
四、函数传值问题
先看一个例子：
# -*- coding: UTF-8 -*-
def chagne_number( b ):
b = 1000
b = 1
chagne_number(b)
print( b )
最后输出的结果为 1。先看看运行的结果，想一下为什么打印的结果是 1，而不是 1000？
其实问题归结为：为什么通过函数 chagne_number 没有更改到 b 的值？
这个问题很多编程语言都会讲到，原理解释也是差不多的。这里主要是函数参数的传递中，传递的是类型对象，之前也介绍了 Python 中基本的数据类型等。而这些类型对象可以分为可更改类型和不可更改的类型。
在 Python 中，字符串、整型、浮点型、tuple 是不可更改的对象，而 list、dict 等是可以更改的对象。
例如：
不可更改的类型：变量赋值 a = 1，其实就是生成一个整型对象 1，然后变量 a 指向 1，当 a = 1000 就是再生成一个整型对象 1000，然后改变 a 的指向，不再指向整型对象 1，而是指向 1000，最后 1 会被丢弃。
可更改的类型：变量赋值 a = [1,2,3,4,5,6]，就是生成一个对象 list，list 里面有 6 个元素，而变量 a 指向 list，a[2] = 5 则是将 list a 的第三个元素值更改，这里跟上面是不同的，并不是将 a 重新指向，而是直接修改 list 中的元素值。
这也将影响到函数中参数的传递了：
不可更改的类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。比如在 fun(a) 内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可更改的类型：类似 C++ 的引用传递，如列表、字典。如 fun(a)，则是将 a 真正传过去，修改后 fun 外部的 a 也会受影响。
因此，在一开始的例子中，b = 1，创建了一个整型对象 1，变量 b 指向了这个对象，然后通过函数 chagne_number 时，按传值的方式复制了变量 b，传递的只是 b 的值，并没有影响到 b 的本身。具体可以看下修改后的实例，通过打印的结果更好地理解。
# -*- coding: UTF-8 -*-
def chagne_number( b ):
print('函数中一开始 b 的值：{}' .format( b ) )
b = 1000
print('函数中 b 赋值后的值：{}' .format( b ) )
b = 1
chagne_number( b )
print( '最后输出 b 的值：{}' .format( b ) )
打印的结果：
函数中一开始 b 的值：1
函数中 b 赋值后的值：1000
最后输出 b 的值：1
当然，如果参数中的是可更改的类型，那么调用了这个函数后，原来的值也会被更改。具体实例如下：
# -*- coding: UTF-8 -*-
def chagne_list( b ):
print('函数中一开始 b 的值：{}' .format( b ) )
b.append(1000)
print('函数中 b 赋值后的值：{}' .format( b ) )
b = [1,2,3,4,5]
chagne_list( b )
print( '最后输出 b 的值：{}' .format( b ) )
输出的结果：
函数中一开始 b 的值：[1, 2, 3, 4, 5]
函数中 b 赋值后的值：[1, 2, 3, 4, 5, 1000]
最后输出 b 的值：[1, 2, 3, 4, 5, 1000]
五、匿名函数
有没有想过定义一个很短的回调函数，但又不想用 def 的形式去写一个那么长的函数？答案是有的。Python 使用 lambda 来创建匿名函数，也就是不再使用 def 语句这样标准的形式定义一个函数。
匿名函数主要有以下特点：
- lambda 只是一个表达式，函数体比 def 简单很多。
- lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
基本语法
lambda [arg1 [,arg2,.....argn]]:expression
示例：
# -*- coding: UTF-8 -*-
sum = lambda num1 , num2 : num1 + num2;
print( sum( 1 , 2 ) )
输出的结果：
3
注意：尽管 lambda 表达式允许你定义简单函数，但是它的使用是有限制的。 你只能指定单个表达式，它的值就是最后的返回值。也就是说不能包含其他的语言特性了， 包括多个语句、条件表达式、迭代以及异常处理等等。
匿名函数中，有一个特别需要注意的问题，比如把上面的例子改一下：
# -*- coding: UTF-8 -*-
num2 = 100
sum1 = lambda num1 : num1 + num2 ;
num2 = 10000
sum2 = lambda num1 : num1 + num2 ;
print( sum1( 1 ) )
print( sum2( 1 ) )
会认为输出什么呢？第一个输出是 101，第二个是 10001？结果不是的，输出的结果是这样：
10001
10001
这主要在于 lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不同的。所以建议遇到这种情况还是使用第一种解法。