Python 函数看这一篇就够了（函数调试，函数参数类型，匿名函数，递归函数）

一.函数基本知识

定义一个函数

# def关键字 函数名（）：
# def f1():

函数调用 函数名（实参）

# def f(n):
#     total=0
#     for i in range(n):
#         i+=1
#     total+=i
# print(total)
# #调用函数
# f(10)

函数形参

定义函数时写在小括号里面的 a,b就是形参

#def f(a,b):

函数实参

调用函数时，写在小括号里面的 1,2 就是实参

def f(a,b):
    pass
f(1,2)

二.函数返回值

默认返回None，可以通过return返回
return可以有多个返回值，return后的代码不会执行,相当于break

三.函数调试

# def f(a,b):
# print(1)
# print(2)
# print(3)
# value=max(a,b)
# return value

# def f1(m,n):
# print("你好")
# print("hello")
# value1=max(m,n)
# print(value1)
# k=f(m,n)
# return k
# print(f1(10,20))

# 你好
# hello
# 20
# 1
# 2
# 3
# 20

四.函数变量作用域

# def f1(m):
# #函数内部定义的局部变量（m，i)，函数外部都不能使用
# i=10
# m=20
# print(i,m)
# f1(20)
# print(m, i)

# 函数内部可以获取函数外部的变量，在调用前写都是正确的
# a=10
# def f(a,b):
# print(a,b)
#
#
# print(a)
# f(10,20) #10 10,20


# 如果赋值
#a=10
#def f1():
# 第一种 认为a是外部变量可以获取
#print(a) #10

# 第二种 因为函数内部有a的赋值，所以此处认为a尚未定义就用
# print(a)
# a=20
# print("你好",a) #报错

#a不是修改外部变量 而是函数内有一个新的变量a为20，函数结束此变量消失
# a=20
# print(a) #20,10

#第三种 修改外部变量 使用关键字global声明使用的就是外部变量a
# global a
# a=20
# print(a) #20 20
# f1()
# print(a)

五.函数参数类型

位置参数

按照形参位置实参依次传入值

# def f(a,b,c):
# print(a,b,c)
# f(1,2,3)

 默认参数

形参在定义时可以默认有值，实参可以不给默认参数传值，但必须放在最后

# def f(a,b,c=4):
# print(a,b,c)
# f(1,2)

# 实参给默认参数传值时，用实参的值

# def f(a,b,c=4):
# print(a,b,c)
# f(1,2,3)

关键字参数

# 通过指令将实参赋予哪个形参
# 要求没有默认值的形参，必须赋值
# c就是关键字参数

# def f(a,b,c,d=4):
# print(a,b,c,d)
# f(1,2,c=4)

可变(元组)参数*args *args

必须放在其他形参之后，它会把实参剩下的值全收了，放在元组里

# def f(a,b,c,*args):
# print(a,b,c,args,type(args))
# f(1,2,3,4,4,6,7)

#默认参数和可变参数同时存在时，可以通过关键字指定默认参数的值

# def f1(a,*args,b=20):
# print(a,b,args,type(args))
# f1(10,20,1,1,2,3,b=200)
#10 200 (20, 1, 1, 2, 3) <class 'tuple'>

 可变（字典）参数

*args后面的值可以放在**kwargs里
# 通过关键字赋值,结果放在字典里
# c,d就是**kwargs

# def f1(a,b,*args,**kwargs):
# print(a,b,args,kwargs)
# f1(10,20,1,2,3,4,5,c=100,d=200)
#10 20 (1, 2, 3, 4, 5) {'c': 100, 'd': 200}

六.匿名函数

# lambda() 函数 只支持最简单，最近的函数写法
# lambda :
# 冒号左边是形参列表，右边是函数体
# 一般不能独立存在，需要作为实参赋予函数的形参
# f2 = lambda: print("你好")
# print(type(f2))
# f2()
#
# f3 = lambda: 100
# print(type(f3), f3())
#
# f4 = lambda x:x + 100
# print(type(f4), f4(200))

# f5 = lambda x, y: x + y
# print(type(f5), f5(200, 100))

# 将函数作为实参传入
# def f1(i,f):
# for i in range(i):
# f()
# f1(3,lambda:print("你好"))


#l=[{"name":"a","age":30},{"name":"b","age":10},{"name":"c","age":40}]
#print(max(l,key=lambda e:e["age"]))
# def f(e):
# return e["age"]
# print(max(l,key=f))

#排序
# l.sort(key=lambda e:e["age"])
# print(l)

# def f1(e):
# """
# 确定排序规则函数
# :param e: 待排序的元素
# :return: 排序的依据
# """
# return e["age"]
# l.sort(key=f1)
# print(l)

七.递归函数 (自己调用自己)

# 有深度限制，不是高性能，一般不用

'''
递归深度
import sys
sys.getrecursionlimit() 获取最大递归深度
sys.setrecursionlimit(200) 修改递归最大递归深度
'''

(1)递归求和

def f(n):
#递归出口
   if n==1:
      return 1
   else:
#自己调用自己
      return n +f(n-1)
print(f(10))

(2)递归求阶乘

#5！=5*4*3*2*1
# #import sys
# def f(n):
# #递归出口
# if n==1:
# return 1
# else:
# #调用
# return n*(f(n-1))
# #sys.setrecursionlimit(2000)
# print(f(5))

(3)#递归求斐波那契数列

#斐波那契数列
# def f(n):
# # if n==1 or n==2:
# # return 1
# if n==1:
# return 1
# elif n==2:
# return 1
# else:
# return f(n-1)+f(n-2)
# print(f(5))