本文为廖雪峰Python教程的学习笔记
具体内容，可参考如下链接：
http://www.liaoxuefeng.com/
一、函数定义
函数是逻辑结构化和过程化的一种编程。过程：就是没有返回值的函数
函数是可以实现一些特定功能的小方法或是小程序。
在Python中有很多内建函数，当然随着学习的深入，你也可以学会创建对自己有用的函数。简单的理解下函数的概念，就是你编写了一些语句，为了方便使用这些语句，把这些语句组合在一起，给它起一个名字。使用的时候只要调用这个名字，就可以实现语句组的功能了。
在没用过函数之前，我们要计算一个数的幂时会用到**，方法是这样的：
>>>2**3 #此处为python 函数返回值 8
现在知道了函数，就可以用内建函数pow来计算乘方了：
>>>pow(2,3) #8
1）python内建函数，如何调用函数
python系统中自带的一些函数就叫做内建函数，Python内置的函数可以通过官方文档查看。也可以通过help()查看帮助信息。比如：dir()、type()等等，不需要我们自己编写。还有一种是第三方函数，就是其它程序员编好的一些函数，共享给大家使用。前面说的这两种函数都是拿来就可以直接使用的。最后就是我们自己编些的方便自己工作学习用的函数，就叫做自定义函数了。
函数调用的方法虽然没讲解，但以前面的案例中已经使用过了。pow()就是一个内建函数，系统自带的。只要正确使用函数名，并添写好参数就可以使用了。
2）定义函数function的方法
语句定义函数，在缩进块中编写函数体，返回值用return语句返回，如果没有return语句，返回值为None，等价于return 。
根据需要，return语句也可以返回多个值组成的tuple，可以不写(),多个值之间用’,’隔开，调用函数时可以用多个变量接受返回值,多个变量按位置赋值。
定义函数需要用到def语句，具体的定义函数语法格式如图所示：
def 函数名（参数）：
代码块
3）函数名的命名规则
（1）函数名必须以下划线或者字母开头，可以包含任意字母、数字或者下划线的组合。不能使用任何的标点符号。
(2) 函数名是区分大小写的
（3）函数名不能使保留字（关键字）
定义函数需要注意的几个事项：
1）def开头，代表定义函数
2）def和函数名中间要敲定一个空格
3）之后是函数名，这个名字用户自己起的，方便自己使用就好
4）函数名后跟圆括号()，代表定义的是函数，里边可以加参数
5）圆括号()后一定要加冒号：这个很重要，不要忘记
6）代码块部分，是由语句组成，要有缩进
7）函数要有返回值return
下面写个完整个的函数范例给大家参考：
def welcome(name):
print("welcome %s" % name)
welcome("rxz")
结果：welcome rxz有返回值的函数:
#自定义取绝对值函数
def my_abs(x):
#isinstance()检查参数类型
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x将my_abs()保存在function.py文件中，在该目录下启动Python解释器，导入my_abs()函数，就可以调用函数
>>> from function import my_abs
>>> print(my_abs(-1))
1
>>> print(my_abs(1))
1pass语句可以用做占位符，表示什么都不做，可用来定义一个空函数。在没想好具体语句的时候，可以用pass语句使代码先运行起来。
#定义空函数
def nop():
pass
#放在if语句中
if a > b:
pass二、函数参数
1、形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
2、实参可以是常量，变量，表达式，函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确认的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。
def calc(x,y): #------------>形参
res = x**y
return res
c = calc (a,b) #-------->实参
print(c)
3、默认参数
将变化小的参数作为默认参数，如果没有传入或改变默认参数的值，则使用默认参数。如果不需要改变默认参数，不用传入默认参数；需要改变默认参数时，传入默认参数即可。
必选参数在前，默认参数在后。有多个默认参数时，调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。表示该参数用传进去的值，其他默认参数继续使用默认值。
例如，学生注册信息，设置年龄和城市为默认参数
def student(name, gender, age = 29, city = 'suzhou'):
print('name = ', name, '\tgender = ', gender, '\tage = ', age, '\tcity = ', city)
student('alex', 'M')
student('Lily', 'F', 6, 'Tianjin')
student('rose', 'F', 8)
student('Jack', 'M', city = 'Xi\'an')
#分别用四种方式调用enroll函数后，输出结果如下所示
name = alex gender = M age = 29 city = suzhou
name = Lily gender = F age = 6 city = Tianjin
name = rose gender = F age = 8 city = suzhou
name = Jack gender = M age = 29 city = Xi'an默认参数必须指向不变对象。因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
def add_end(L = []):
L.append('end')
return L
#正常调用
print(add_end([1, 2, 3]))
print(add_end(['a', 'b', 'c']))
#使用默认参数调用
print(add_end())
print(add_end())
#函数add_end()在正常调用时，输出结果为：
[1, 2, 3, 'end']
['a', 'b', 'c', 'end']
#调用默认参数时，结果为：
['end']
['end', 'end']
Python函数在定义时，默认参数的值已经被计算出来。因为列表为可变对象，L指向可变对象，每次调用函数时，如果改变了L的内容，下次调用时，默认参数的内容就变了，不是函数定义时的列表了。函数add_end()可做如下修改,用不可变对象None实现：
def add_end(L = None):
if L is None:
L = []
L.append('end')
return L
#使用默认参数调用
print(add_end())
print(add_end())
#再使用默认参数调用时，结果为：
['end']
['end']4、可变参数
传入的参数个数可变，可以为0到任意个。
在参数前加*实现可变参数。
可变参数在函数调用时自动组装为一个tuple。
在列表和元组前加*，可以将列表或元组中的元素变为可变参数传入函数。
def add_sum(*nums):
sum = 0
for num in nums:
sum += num
return sum
print(add_sum(1, 2, 3))
L = [1, 2, 3, 4]
print(add_sum(*L))
T = (1, 2)
print(add_sum(*T))
#运行结果为：
6
10
35、关键字参数
将任意个含参数名的参数组装为一个dict。
在参数前加**实现关键字参数。
在dict前加**，可以将dict作为为关键字参数传入函数。传入的为dict的拷贝，在函数中的修改不会影响函数外的dict。
例如，函数person()包含必选关键字name和age，还包含关键字参数kw
def person(name, age, city = 'Beijing', country = 'china', **kw):
print('name: ', name, '\tage: ', age, '\tcity: ', city, '\tcountry: ', country, '\tother: ', kw)
#dict
other = {'gender': 'F', 'height': 168}
person('Tom', 18)
person('Lily', 20, city = 'Tianjin', gender = 'F', hobby = 'read')
person('Tim', 15, gender = 'M', city = 'Beijing')
#将dict作为关键字参数传入
person('Ann', 16, **other)运行结果如下：
name: Tom age: 18 city: Beijing country: china other: {}
name: Lily age: 20 city: Tianjin country: china other: {'gender': 'F', 'hobby': 'read'}
name: Tim age: 15 city: Beijing country: china other: {'gender': 'M'}
name: Ann age: 16 city: Beijing country: china other: {'gender': 'F', 6、命名关键字参数
关键字参数可以传入任意多个名字，对名字没有限制。
如果要限制关键字参数的名字，需要在参数列表中使用*，*之后的关键字为命名关键字，只接受这些参数作为关键字名字。
如果已经有可变参数，不需要特殊分隔符*
def person(name, age, *, city, country):
print('name: ', name, '\tage: ', age, '\tcity: ', city, '\tcountry: ', country)
#如果已经有可变参数，不需要特殊分隔符*
def person1(name, age, *args, city, country):
print('name: ', name, '\tage: ', age, '\tcity: ', city, '\tcountry: ', country)调用函数时，必须传入参数名，位置可以颠倒。
person('Tom', 18, city = 'Tianjin',country = 'china')
person('Tom', 18, country = 'china', city = 'Tianjin')
person1('Tom', 18, city = 'Tianjin',country = 'china')
person1('Tom', 18, country = 'china', city = 'Tianjin')该函数只接受两个位置参数，如果调用时不用函数名(person(‘Tom’, 18, ‘Tianjin’, ‘china’)), Python解释器认为传入了四个位置参数，会报错。
如果命名关键字参数有缺省值，调用时可以不传入该参数。
7、组合参数
不同类型的函数可以组合使用，参数定义的顺序必须为：必选参数，默认参数，可变参数，命名关键字参数和关键字参数。
def func1(a, b, c = 0, *d, e, **kw):
print(a, '\t', b, '\t', c, '\t', d, '\t', e, '\t', kw)
def func2(a, b, c = 0, *, d, e, **kw):
print(a, '\t', b, '\t', c, '\t', d, '\t', e, '\t', kw)
def func3(a, b, c):
print(a, '\t', b, '\t', c)
t = (3, 4, 5, 6, 7, 8, 9)
l = [3, 4, 5, 6, 7, 8, 9]
t1 = (4, 5, 6)
dic = {'name': 'Z', 'gender': 'M'}
print('func1')
func1(1, 2, e = 4, d = 3)
func1(1, 2, d = 3, e = 4)
func1(1, 2, d = 3, e = 4, name = 'L', gender = 'F')
func1(*t, e = 10)
func1(*l, e = 10)
func1(*t, e = 11, **dic)
func1(*l, e = 11, **dic)
print('func2')
func2(1, 2, d = 3, e = 4)
func2(1, 2, d = 3, e = 4, name = 'L', gender = 'F')
func2(*t1, d = 20, e = 20)
func2(*t1, d = 21, e = 21, **dic)
func3(*t1)输出为：
func1
1 2 0 () 4 {'d': 3}
1 2 0 () 4 {'d': 3}
1 2 0 () 4 {'name': 'L', 'gender': 'F', 'd': 3}
3 4 5 (6, 7, 8, 9) 10 {}
3 4 5 (6, 7, 8, 9) 10 {}
3 4 5 (6, 7, 8, 9) 11 {'name': 'Z', 'gender': 'M'}
3 4 5 (6, 7, 8, 9) 11 {'name': 'Z', 'gender': 'M'}
func2
1 2 0 3 4 {}
1 2 0 3 4 {'name': 'L', 'gender': 'F'}
4 5 6 20 20 {}
4 5 6 21 21 {'name': 'Z', 'gender': 'M'}
4 5 6func1中，
d为可变参数，可以为空，d=3被认为是关键字参数；
e为命名关键字参数，调用时必须使用名字调用；
用*t, *l, *dic调用时，*t, *l的前三个元素作为必选参数a, b, 默认参数c,后面的部分作为命名关键字e = 10，剩下的部分作为可变参数构成tuple d = (6, 7, 8, 9), **dic作为关键字参数。
func2中，
d, e均为命名关键字，必须使用名字调用。
因为不包含可变参数，如果要使用tuple, list调用，tuple和list的长度必须不超过固定参数加默认参数的长度，所以只能使用t1进行调用。
8、位置参数和关键字
标注调用“实参与形参位置一一对应；关键字调用：位置无须固定；
def func1(a, b, c):
print(a)
print(b)
print(c)
#位置参数：实参与形参位置一一对应，缺一不行，多一个也不行
func1(1, 2, 3)
#关键字参数，无须固定位置，缺一不行，多一个也不行
function（b=1,a=2,c=3）注意：位置参数必须在关键参数左边
使用函数的好处：
1）代码重用
2）保持一致性，易维护
3）可扩展性
三、函数的返回值
要想获取函数的执行结果，就可以用return语句把结果返回
注意：
1）函数在执行过程中只要遇到return语句，就会停止执行并且返回结果，也可以理解return语句的出现就代表函数的结束
2）如果未在函数中指定return，那么这个函数的返回结果就是None
3)return多个对象，解释器会把这么多的对象组装成一个元组 ，元组在作为一个整体输出
def add(a,b):
res = a+b
return res
result = add(8,9)
print("result = %s"% result)四、作用域
4.1、作用域介绍
Python中的作用域分4种情况
1）L：local，局部作用域，即函数中定义的变量
2）E：enclosing,嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但是不是全局的
3）G：global，全局变量，就是模块级别定义的变量
4）B：built-in，系统固定模块里面的变量，比如：int，bytearray等，搜索变量的优先级顺序依次是：
作用域局部 > 外出作用域 > 当前模块中的全局变量 > python内置作用域
也就是：LEGB
x = int(2.9) #int built_in
g_count = 0 # gloab
def outer():
a =10 # enclosing
def inner():
i_count = 2 # local
print(i_count)
#print(i_count) # 找不到
inner()
print(a)
outer()4.3、变量修改
一个不再局部作用域的变量默认是只读，如果试图为其绑定一个新的值，Python认为是在当前的局部作用域里创建一个新的变量，也就是说在当前局部作用域中，如果直接使用外部作用域的变量，那么这个变量是只读的，不能修改的
g_count = 10 # gloab
def outer():
#print(g_count)
g_count = 100
print(g_count )
outer()
def outer1():
glocal g_count
g_count = 100
print(g_count )
outer()4.3小结
1）变量查找顺序：LEGB，作用域局部 > 外出作用域 > 当前模块中的全局变量 > python内置作用域
2）只有模块，类，及函数才能引入新的作用域
3） 对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量
4）内部作用域要修改外部作用域变量的值时，全局变量要是用global关键字，嵌套作用域变量要使用nonlocal关键字，
nonloal是python3新增的关键字，有了这个关键字，就能完美的实现闭包了。