一、函数的定义 函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需要调用函数名即可

特性： 减少重复代码 使程序变得可扩展 使程序变得易维护 二、函数的参数 2.1、形参和实参数 形参，调用时才会存在的值 实惨，实际存在的值 def calculate(x,y): #形参，调用时才会存在的值

res=(x*y)

return  res  #返回值，返回res的值

n=calculate(5,3) #实惨，实际存在的值

print(n) #打印 1. 2. 3. 4. 5. 6. 7. 8. 9. 2.2、默认参数 定义：当不输入参数值会有一个默认的值，默认参数要放到最后

def stu_register(names,age,course,country='CN'): # 这里country='CN'就是默认参数

print("学员信息表".center(50,'%'))

print("姓名：",names)

print("年龄：",age)

print("国家：",country)

print("课程：",course)

stu_register("王二","22","linux") 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 2.3、 关键参数 定义： 正常情况下，给函数传参数要安装顺序，不想按顺序可以用关键参数，只需要指定参数名即可，（指定了参数名的就叫关键参数），但是要求是关键参数必须放在位置参数（以位置顺序确定对应的参数）之后

def stu_register(names,age,course,country='CN'):

print("学员信息表".center(50,'%'))

print("姓名：",names)

print("年龄：",age)

print("国家：",country)

print("课程：",course)

stu_register("王二",age="22",course="linux") # 这里age="22",course="linux"就是关键参数 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 2.4、非固定参数 定义： 如你的函数在传入参数时不确定需要传入多少个参数，就可以使用非固定参数

通过元组形式传递

def sed_alert(*args):

for u in args:

    print('发送报警给',u)

sed_alert('老刘','老王','老李') #同时把'老刘','老王','老李传递给args

通过列表形式传递

def sed_alert(*args):

for u in args:

    print('发送报警给',u)

sed_alert(['老刘','老王','老李']) # 通过列表进行传递，列表前面要加一个

字典形式（通过k,value的方式传递）

def stu_register(args):

print("发送报警给：" ,args)

def stu_register(args):

print("发送报警给：" ,args)

d = {'zhangsan':22,'lisi':23}

stu_register(*d) #变量前面要加两个 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 三、函数的返回值 作用：

返回函数执行结果，如果没有设置，默认返回None 终止函数运行，函数遇到return终止函数 def stu_register(**args):

print("发送报警给：" ,args)

return 1

status=stu_register(names='zhangsan',age="22")

print(status) #返回函数返回值 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 四、变量的作用域 全局变量和局部变量

在函数中定义的变量叫局部变量，在程序中一开始定义的变量叫全局变量 全局变量作用域整个程序，局部变量作用域是定义该变量的函数 当全局变量与局部变量同名是，在定义局部变量的函数内，局部变量起作用，其他地方全局变量起作用 同级的局部变量不能互相调用 想要函数里边的变量设置成全局变量，可用global进行设置 globvar = 0

def set_globvar_to_one():

global globvar    # 使用 global 声明全局变量

globvar = 1

def print_globvar():

globvar = 2

print(globvar)     # 没有使用 global

set_globvar_to_one()

print (globvar) # 输出 1

print_globvar() # 输出 1，函数内的 globvar 已经是全局变量 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 五、特殊函数 5.1、嵌套函数 定义： 嵌套函数顾名思义就是在函数里边再嵌套一层函数

def fun1():

print('第一层函数')

def fun2():

    print('第二层函数')

fun2()

fun1() 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 提示 在嵌套函数里边调用变量是从里往外依次调用，意思就是如果需要调用的变量在当前层没有就会去外层去调用，依次内推

匿名函数 基于Lambda定义的函数格式为：​​lambda 参数:函数体​​

参数，支持任意参数。 python lambda x: 函数体 lambda x1,x2: 函数体 lambda *args, **kwargs: 函数体

函数体，只能支持单行的代码。 python def xxx(x): return x + 100 lambda x: x + 100

返回值，默认将函数体单行代码执行的结果返回给函数的执行。 python func = lambda x: x + 100 v1 = func(10) print(v1) # 110

def func(a1,a2):

return a1 + a2 + 100

foo = lambda a1,a2: a1 + a2 + 100 1. 2. 3. 4. 5. 6. 7. 匿名函数适用于简单的业务处理，可以快速并简单的创建函数。

与三元运算结合

def calc(x,y):

if x

5.3、高阶函数 定义：变量可以指向函数，函数的参数可以接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称之为高阶函数 只需要满足一下任意一个条件，即是高阶函数

接收一个或多个函数作为输入 return返回另一个函数 python def get_abs(n): return int(str(n).strip("-")) #将负数改成正数 def add(x,y,f): return f(x) + f(y) print(add(-5,-10,get_abs)) # 调用get_abs函数，将get_abs传递给变量f

5.4、递归函数 定义:一个函数可以调用其他函数，如果一个函数调用自己本身，这个函数就称为递归函数

在默认情况下Python最多能递归1000次，（这样设计师是为了防止被内存被撑死）可以通过sys.setrecursionlimit(1500)进行修改 递归实现过程是先一层一层的进，然后在一层一层的出来 必须有一个明确的条件结束，要不然就是一个死循环了 每次进入更深层次，问题规模都应该有所减少 递归执行效率不高，递归层次过多会导致站溢出

计算4的阶乘 4x3x2x1

def calc(n):

if n==1:

    return 1

return n* calc(n-1)

print(calc(4))

打印数字从1-100

def fun(n):

if n==101:

    return 1

print(n)

fun(n+1)

fun(1) 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 5.5、闭包现象 定义:内层函数调用外层函数的变量，并且内存函数被返回到外边去了

def outer():

name = "老王，你最牛"

def inner():

    print("inner",name)

return inner #返回inner的内存地址

func= outer() #相当于把inner赋值给func

func() #相当于执行了inner 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域