函数是一种可以复用代码，把大型代码拆分成多段代码，实现功能分离，达到模块化的效果。
对于函数主要有两个操作：定义函数和调用函数
函数定义
使用关键字def ,函数名，圆括号，圆括号内可以有参数，最后再跟一个冒号:。函数的命名和变量的命名一样。
回顾下变量命名的规范：只能用字母或者下划线开头，名字中只能包含字母，数字和下划线。
定义一个函数可以这样子：
# def 函数名 (参数)：
# 执行语句
# return 返回值
# 定义一个不执行任何语句的函数(无参数，无返回值)
def main():
pass
# 定义一个无参数，有返回值的函数
def main1():
return True
# 定义一个有参数，有返回值的函数
def main2(name):
print("My name is %s" %name)
注意：
1.函数的返回值，如果没有用return指定返回值，默认是返回None 。None作为布尔值的时候和False一样，但是两者是有区别的。Python中不含任何值得空数据结构都等价于False，但不等于None，可以用is操作符判断: if xxx is None
函数调用
函数的调用很简单，只需要在函数名字后面加上(),就是调用函数了，当然有参数的要给予参数。比如上面定义了函数后，要调用，只需要这样：main() main1() main2("West")
注意只使用了函数名，不带()的不是调用，返回的是函数对象，函数也是对象的一种，函数名也可以当做变量一样赋值给另一个，比如：test = main test() 就等价于调用了函数main
函数参数
函数参数有几种类型：位置参数，关键字参数，默认参数，可变参数。
-
位置参数
传入的参数是按照位置顺序依次传递的。(坏处是需要记住每个位置的参数的意义，容易记混而出错)
# 定义一个函数sum，计算x和y的和 # x和y称为参数，具体的说是形参 def sum(x,y): return x+y # 调用的时候，依次传递参数给x和y sum(3,4) # 可以把返回值赋值给一个变量 data = sum(3,4) #依次把3复制给x，4复制给y print(data) #data = 7 -
关键字参数
关键字参数可以在调用的时候指定参数的名字，这样就避免了位置参数所带来的坏处了。
关键字参数也可以不按顺序的调用，也可以和位置参数混合调用，但是位置参数必须要在关键字参数的前面调用
# 定义函数 def sum(x,y): return x+y # 使用关键字参数调用函数 print(sum(x=2,y=4)) # 不按顺序的关键字参数调用 print(sum(y=3,x=2)) # 和位置参数混合使用 print(sum(1,y=7)) # 这种方式是不对的 # print(sum(x=1,7)) 位置参数在关键参数后面了。 -
默认参数
函数定义时候指定的默认参数，在调用时候，如果没有提供对应的参数，则用默认参数替代，否则就用提供的参数。
注意：默认参数必须在位置参数之后
# 定义函数 def sum(x=4,y=5): return x+y # def sum(x=4,y): 这种是不行的，默认参数必须在位置参数之后 # 试想下这种定义函数，调用时候 sum(3),那这个3是给默认参数呢，还是给位置参数的，分不清了。 # 两个参数都提供 print(sum()) #输出： 9 # 提供一个参数，默认是给第一个参数 print(sum(3)) #输出： 8 # 提供一个参数，在赋值时候指定 print(sum(y=2)) #输出： 6 # 提供两个参数 print(sum(2,3)) #输出： 5默认参数需要注意的一点是：默认参数的值在函数定义的时候就已经计算出来了，而不是函数运行时候生成，当参数值为可变的数据类型时候，很容易犯错（涉及到传值还是传引用的问题，下面会讲)，比如：
def main(a,b=[]): # b为空列表，列表为可变的数据类型
b.append(a)
print(b)
main(1) # 执行第一次，输出为：[1]
main(2) # 第二次执行，输出为：[1,2],而不是[2]
要想列表每次只输出一个，可以在函数定义的时候对b是否为None做个判断，如下：
def main(a,b=None):
if b is None:
b = []
b.append(a)
print(b)
最终输出为[1]和[2]
-
可变参数
可变参数的意思就是，提供给函数的参数是不确定的，可能是一个，也可以是多个，也可以没有参数，有两种可变参数，分别是args和*kwargs。
-
*args
会把传入的多的参数作为一个元组 （前面是星号，后面的变量名可以自定义）,收集的是位置参数。
# 比如计算 a²+b²+c²... def calc(*number): sum = 0 for i in number: sum = sum + i * i return sum # 调用方式 也可以不给参数，直接calc(),结果当然是0 print(calc()) # 元组(1,2,3,4)的形式 print(calc(1,2,3,4)) # 如果已经存在一个元组,可以这样传递参数 data = (1,2,3) print(calc(data[0],data[1],data[2])) #比较繁琐 # 可以直接这样，加个星号 print(calc(*data)) -
**kwargs
会把传入的多的参数作为一个字典 （前面两个是星号，后面的变量名可以自定义），收集的是关键字参数。
def people(name,age,**kwargs): print("name:",name) print("age:",age) print("other:",kwargs) # 可以传入0个或任意个参数，除了接受name和age参数外，还接受任意个参数kwargs(关键字参数) # 可以不传入关键字参数 people("ZZY",22) # 也可以传入关键字参数 people("zzy",22,city="ShenZhen") # 可以把dict作为参数传进去 kw = {'city':'shanghai','job':'Coder'} people("zzy",22,**kw)
-
函数参数传递
前面说到，在默认参数是可变数据类型时容易犯错，这里涉及到Python函数参数的传递问题，这里先给出结论：Python函数参数传递，既不是传值，也不是传引用。
首先要清楚知道的是，在python中，一切都是对象，python的变量是没有类型的，只有对象才有类型，变量是可以指向任何的对象的，可以指向列表，元组，函数，变量也可以看做是对象的一种引用(也可以看成是一个标签，贴在对象上)。
进一步理解：
# 变量a 相当于是给一个有三个元素的列表贴上标签a
a = [1,2,3]
print(type(a))
print(id(a))
# 把标签a贴到元组上
a = (4,5,6)
print(type(a))
print(id(a))
# 输出：
# <class 'list'>
# 140094689003912
# <class 'tuple'>
# 140094689336776
从上面的程序可以看出：变量a是没有类型的，它既可以执行列表，也可以指向元组。
再到函数的传参上，其实就是变量指向的对象的内存地址的传递（可以理解为传递的是对象） ，这里就牵扯到python中可变对象和不可变对象的概念了：
可变对象：字典，列表，集合...
不可变对象：整形，字符串，元组...
正是由于存在可变对象和不可变对象，python函数的参数传递看起来有时候是传值，有时候是传引用，可以这样子去理解(仅仅限于理解)
参数是可变对象的传递，类似于c/c++中的引用传递
参数是不可变对象的传递，类似于c/c++中的值传递
举例说明：
# 不可变对象
def show(data):
data = 10
print(data)
# 变量a，指向内存中保存5的内存地址
a = 5
show(a) # 输出10
print(a) # 输出5
'''
解释：
首先a = 5,相当于给内存中的5贴上一个标签a
然后调用show(a)，将data = a，等于给内存中的5再贴一个标签 data
接着执行data = 10,等于把5的标签data撕掉，贴到了10上面
所以这时候，a还是指向了5，而data已经指向了10，所以print(data) = 10,print(a) = 5,类似是传值。
'''
# 可变对象 还是这个列子
def add(data,b=[]):
b.append(data)
print(b)
add(1) # 输出 [1]
add(2) # 输出 [1,2]
'''
解释：
首先调用了add(1),默认参数为一个空列表b，第一次调用b.append(data)，因为列表是可变的，所以在列表内存中添加一个1，第二调用add(1),默认参数还是b，默认参数在函数定义的时候就生成，b指向的还是列表的内存地址，这时候的列表中已经有了一个元素1，再执行b.append(data)，就变成了[1,2]了。
'''
网上看到的个人觉得讲的比较好的，也参考学习过的博客：
内部函数
内部函数，我觉得也是嵌套函数，也就是在函数内部定义的函数。当一个函数内部需要多次执行比较复杂的任务的时候，内部函数作用还是很大的，可以避免代码的堆叠
def out(a,b):
def _in(c,d):
return c+d
return _in(a,b)
print(out(3,2)) # 输出 5
闭包
闭包其实就是一个内部函数，但是这个内部函数对外部作用域的变量进行了引用，并且外部函数的返回值为内部函数，那么这个内部函数就称为闭包。
比如：
def test(x):
def _in(y):
return x+y
return _in
a = test(2)
print(a(3)) # 输出 5
'''
外部函数为test，内部函数为_in，但是_in调用了外部函数的变量x，并且函数的返回值为_in函数
'''
注意点：
- 闭包只能引用外部函数的局部变量，不能修改。
更多的知识暂时没接触到，有接触了再更新这个笔记吧~~
匿名函数--lambda()函数
匿名函数是指一类不需要使用def去定义，只需要表达式的函数，能够替代一些小的函数。
lambda语法为：lambda [arg1,arg2...argn] : expression
比如print((lambda a,b:a+b)(3,4) 就是一个匿名函数，输出为7.其实就等同于以下代码：
def func(a,b):
return a+b
print(func(3,4))
通常，匿名函数都是用在，定义了匿名函数，作为参数传递给另一个函数，再调用。
一般来说，定义实际的函数会比匿名函数清晰的多，但是在一些场合需要定义很多的小函数的时候，要记住它们的名字有时有些繁琐，比如在图形界面中，回调函数就可以用匿名函数来定义了。
