函数
函数是由函数名、参数和函数体组成，格式如下
def 函数名 （形式参数）：
函数体
return 返回值
def是系统关键字，之后的文章会系统讲一下，这里只要知道这个是用来定义函数的
例如，我们定义一个求两个数的和的函数：
def add(a,b):
c=a+b
return c
#这里的 def 和 return 是绿色的，
也就是系统关键字#这里函数名是add（英语是求和的意思）
#然后有两个形式参数，a和b
#函数体部分执行的是 c = a +b#最后函数返回的是 c 的值#这就完成了一个求和函数的定义
函数的调用
函数的调用很简单，我们只要根据函数的定义形式
将实际计算时的参数值传进去就行（也可能没有参数）
函数调用格式：
函数名（实际参数）
add(1,2)
3
add(3,4)
#这里的 add（3,4） 就是函数调用
#实际参数分别是 3 和 4
#当函数调用发生时，才开始执行函数的内容
#即给 a 赋值为 3 ， b 赋值为 4 #然后计算出 c = 7
#最后返回 c 的值 7 7
函数调用 写的参数是实际参数（‘实际’体现在参数是实际执行函数使用的）
函数定义 写的参数是形式参数（‘形式’体现在他只是个格式和形式，真正函数执行时候还是先看实际参数）
参数的传递
函数调用时候，是将实际参数传递给形式参数
函数参数的传递方法有很多
1.参数按照位置顺序传递
刚才的add函数就是这种，按顺序，3传递给a，4传递给b2.参数按赋值传递
def mino(a,b):
c=a-b
return c
mino(3,4)
#位置传递
-1
mino(b=3,a=4)
#参数赋值传递
1
2.参数按照默认值传递
有时候，可以在函数定义里给函数形参设定一个默认值, 当函数实参没有传递值进来，就使用默认值
def mino2(a,b=3):
c=a-b
return c
mino2(5,1)
4
mino2(5)
2
这里在定义函数时候，给形参 b 设置了默认值 3
然后调用函数时候，只传递了一个参数值 5
则python默认将 4 传递给 a，因为在定义时候给 b 设定了默认值 3
当然，当传入的参数是两个时候，则覆盖掉默认值，即不使用定义时候的默认参数值
3 （难点）元组类型的变长度参数传递
我们写个打印输出的函数
def dayin(a,b):
print(a,b)
dayin("1",2)
1 2
如果我们要打印三个数怎么办？
def dayin(a,b,c):
print(a,b,c)
dayin(12,3,4)
12 3 4
如果我们要打印1000个数呢???
我们可以定义一个变长参数，即这个参数代表的数字可长可短我们可以在
参数前面加一个星号 * ，表示这个参数是可变长参数
当其他参数赋值完毕时候，剩下的参数依次赋值给这个可变长参数
def dayin(a,*b):
print(a,b)
dayin(2,3,4)
2 (3, 4)
但是，注意到没有，这里的 b 是元组 （3,4）
所以你执意要打印出，可以提前修改函数的打印功能
def dayin(a,*b):
print(a,end=" ")
for i in b:
print(i,end=" ")
dayin(2,3,4)
2 3 4
dayin(1,2,3,4,5,6,78,8)
1 2 3 4 5 6 78 8
4.（难点）字典类型的变长度参数传递 ##一个*号 代表元组，两个**号代表字典
我们可以在参数前面加两个星号 ** ，表示这个参数是可变长参数
但是形式是 实参名=字典值的方式传递
def dayin2(a,*b,**c):
print(a,b,c)
dayin2("q","w",r=3)
q ('w',) {'r': 3}
注意到，字典类型变长参数传递一定是赋值形式传递进去的
当然，元组和字典形式变长参数也可能用不到，例如：
dayin2(1)1
() {}
这样，打印出的就是空元祖和空字典啦~
如果你执意要实现那种打印形式，我们就改一下函数：
def dayin2(a,*b,**c):
print(a,end=" ")
for i in b:
print(i,end=" ")
for i in c:
print(i ,end=" ")
dayin2("q","w",r=3)
q w r
def dayin2(a,*b,**c):
print(a,end=" ")
for i in b:
print(i,end=" ")
for i in c:
print(c[i] ,end=" ")
dayin2("q","w",r=3)
q w 3
dayin2(1,2,r=3)
1 2 3
继续完善
def dayin2(a,*b,**c):
print(a,end=" ")
if len(b)!=0:
for i in b:
print(i,end=" ")
if len(c)!=0:
for i in c:
print(c[i] ,end=" ")
dayin2(1,2,r=3)
1 2 3
dayin2(1,2,4,5,r=3,www="df")
1 2 4 5 3 df
注意，可变参数的位置一般写在最后，不能乱了顺序，否则会报错！！！dayin2(1,2,4,www="df",5,r=3)
File "", line 1 dayin2(1,2,4,www="df",5,r=3) ^SyntaxError: positional argument follows keyword argument
无返回值的函数
上面所有的函数都是有返回值的函数，如果没有返回值会怎样呢？
这个可以有！
def add():
a=1 b=2
print(a+b)
add()3
函数中变量的作用域
变量的作用域就是在程序中能对这个变量操作的区域范围
有点像初高中学的函数的定义域
Python允许同名变量的出现
让我们看个例子：
a=0
def dayin_out():
a=1
print(a)
def dayin_inner():
a=2
print(a)
dayin_out() ##只是调用了外层函数，并没有调用内层的dayin_inner函数
1
dayin_inner() ##说明不可以直接调用内层函数，必须要先调用外层函数，接着才能调用内层函数---------------------------------------------------------------------------
NameError Traceback (most recent call last) in ()----> 1 dayin_inner() ##说明不可以直接调用内层数，
#必须要先调用外层函数，接着才能调用内层函数
NameError: name 'dayin_inner' is not defined
a=0
def dayin_out():
a=1
print(a)
def dayin_inner():
a=2
print('inner=% d'% a)
###### print函数体实际上还是针对的外层的dayin_out函数，内层并没有调用dayin_out()
1
inner= 1
a=0
def dayin_out():
a=1
print(a)
def dayin_inner():
a=2
print('inner=% d'% a)
dayin_inner() #######这一行代码的意思就是激活内层函数
dayin_out()
1
inner= 2
这里有三个a，第一个a是在函数外面，我们称之为全局变量（即它的作用域是全局的）
当然，与之相对的，第二个和第三个a就成为局部变量
而且这个dayin_inner( ) 函数是被嵌套在 dayin_outer( ) 中的
值为 1 的 a 的作用范围是dayin_outer( )外层函数中
值为 2 的 a 的作用范围是dayin_outer( )内层函数中
当我们要使用变量时候，实行的是最近的区域搜索赋值
a=0
def dayin_out():
a=1
print(a)
def dayin_inner():
a=2
print('inner=% d'% a)
dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
0
dayin_out()
1
inner= 2
我们修改一下程序：
a=0
def dayin_out():
#a=1
print(a)
def dayin_inner():
a=2
print('inner=% d'% a)
dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()
0
inner= 2
当我们把 a = 1 注释掉
则外层函数打印 a 的时候，取的全局变量
因为内层函数的作用域只在内层函数中，不能延伸到外层函数
我们再改一下程序：
a=0
def dayin_out():
a=1
print(a)
def dayin_inner():
# a=2
print('inner=% d'% a)
dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()
0
1
inner= 1
把内层函数里的 a 注释掉
则内层函数使用的 a 是外层函数定义的 a
因为，外层函数距离内层函数比全局变量距离内层函数更近
如果外层函数没有定义 a ，则会去取全局变量
a=0
def dayin_out():
#a=1
print(a)
def dayin_inner():
# a=2
print('inner=% d'% a)
dayin_inner()
#######这一行代码的意思就是激活内层函数
print(a)
dayin_out()
0
0
inner= 0
注意：不要将变量的作用域和变量重复赋值覆盖搞混
我们看个例子：
a=0
a=5
def dayin_out():
a=1
print(a)
def dayin_inner():
a=2
print('inner=% d'% a)
dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()
5
1
inner= 2
注意这里全局变量只有一个 a
他的值是 5，因为 0 被覆盖了
匿名函数
匿名函数，匿名指的是我们不知道这个函数的名字
当我们使用时候，用lambda来声明匿名函数
这种匿名函数是没有名字的，是临时使用的格式：
函数对象名 = lambda 形式参数：表达式我们演示一下看看：
def add(a,b):
c=a+b
return c
add(1,3)
4
func=lambda x,y:x+y
func(1,2)
3
func(2,3)
5
这里用匿名函数代替了add（）函数的功能
x，y是形式参数
x+y是函数体内容
匿名函数也可以有条件分支语句：
返回x和y中较大值
find_max=lambda x,y:x if x>y else y
find_max(3,4)
4
小建议：当函数较为复杂时，不建议匿名函数，不太好写而且结构难理解
函数的递归
递归指的是一种直接或者间接调用自身的算法
它的本质是将问题分解为同类型的子问题
def shulie(n):
if n==1:
return 1
else:
return 2*shulie(n-1)
shulie(1)
1
shulie(2)
2
shulie(8)
128
有个经典的Fibonacci数列问题
这个数列具有这样的特点：前两项均为1，从第三项起，每一项都是其前两项的和
即F0=F1=1，当n＞1时，Fn+2=Fn+1+Fn。
可以写成下面的函数
def Fn(n):
if n==0:
return 0
elif n==1:
return 1
else:
return Fn(n-1) + Fn(n-2)
Fn(40)
102334155
Fn(10)
Fn(50)
12586269025