九、函数
- 1. 函数定义
- 2. 函数参数
-
- 3. 匿名函数
- 4. 递归函数
- 5. 函数返回值及函数的参数传递
1. 函数定义
# 函数定义：实现某功能代码封装，较少冗余的代码块
2. 函数参数
2.1 形式参数
2.1.1 定义
# 函数定义时的函数参数名称称为形式参数
2.1.2 分类
# 必选参数
def info(name, age, sex): # name,age,sex为必选参数
# 默认参数
# 默认参数可以传递也可以不传递参数
# 规则：default argument follows non-default argument
def info(name, age, sex='male') # sex为默认参数，male为默认参数值;name,age为必选参数
# 可变长度位置参数
# *args
def myargs(*num): # *将输入的参数打包：1，2，3->打包为元组(1,2,3)
print(*num)
print(type(num), num) # 输出num类型和num
myargs() # ()
print("n")
myargs(1) # 1 (1,)
print("n")
myargs(1, 2) # 1 2 (1, 2)
# 可变长度关键字参数
# **kwargs
def myargs(**num): # **将输入的参数打包成字典：a=1,b=2->{a:1,b:2}
print(num,type(num)) # 输出num及num类型
myargs(a=1, b=2) # {'a': 1, 'b': 2}
myargs(c=2, d=5, g=7) # {'c': 2, 'd': 5, 'g': 7}
2.2 实际参数
2.2.1 定义
函数调用时的提供的实际值称为实际参数
2.2.2 分类
# 位置参数
# 规则：info(sex='m', "sc", age=19)# 位置参数要位于关键字参数前面
# keyword argument follows positional argument
info('mghaolian', 18, 'men') # 'mghaolian', 18, 'men'为位置参数
# 关键字参数
info("sc", sex='m', age=19) # "sc"为位置参数, sex='m', age=19关键字参数
# 可变长度位置参数
def calculate_function(*args):
# sum1 = 0
# for i in args:
# sum1 += i
return sum(args) # 6
print(calculate_function(1,2,3))
# 可变长度关键字参数
def calculate_function(**myargs):
# sum1 = 0
# for i in myargs.values():
# sum1 += i
return sum(myargs.values())
print(calculate_function(a=1,b=2,c=3,d=9)) # 15
总结：无论形参还是实参，带等号的参数定义和传递都放在后面
3. 匿名函数
3.1 定义
# 不需要创建函数名，只能有一个函数，不用return
# 返回值就是该表达式结果
# lambda arg1,arg2:表达式
add = lambda x, y: x+y # 定义lambda函数，x y为参数，x+y为表达式，也是函数返回结果
print(add(2,3)) # 5
3.2 适用场景
# 匿名函数使用，当需要使用一个函数实现单一功能时，使用匿名函数简化代码，使代码简介优雅
lst = [1, 2, 3, 4, 5] # 定义列表
# map(function，iterable)
print(list(map(lambda x: x * x, lst))) # 使用map函数映射，并将map对象转化为列表输出，实现计算数字的乘方
def fun1(x): # 定义函数实现计算数字的平方
return x*x
print(list(map(fun1, lst)))
lst = [23.345,56.35456666,43.99998,43.345]
print(list(map(lambda x: round(x,2),lst))) # 利用lambda和map函数实现保留小数点后两位数
print(list(map(lambda x: '{:.2f}%'.format(x*100), lst))) #利用lambda和字符串的格式化实现百分数的转化并保留小数点后两位数
4. 递归函数
4.1 定义
# 函数Func(Type a,……)直接或间接调用函数本身，则该函数称为递归函数
4.2 实例
# 计算n!
def f(a):
if a == 1:
return 1 # 寻找递归函数的出口
return a*f(a-1)
print(f(4))
# 用递归实现斐波拉契数列 1,1,2,3,5,8,13
# 规律：f(n) = f(n-1) + f(n-2)
k = {1: 1, 2: 1}
def recursion(n):
if n in k:
return k[n] # 寻找递归函数的出口
else:
r = recursion(n - 1) + recursion(n - 2)
k[n] = r
return r
recursion(7)
print(list(map(lambda x: x, k.values())))
# 走楼梯问题 每次走楼梯都可以选择走一个台阶或者两个台阶
# n阶楼梯，一共几种走法
# n=1,1;
# n=2,2;
# n=3,3;
# n=4,5;
# n=10,几种走法？
def f(n):
if n==1: # 寻找递归函数的出口
return 1
elif n==2:
return 2 # 寻找递归函数的出口
else:
return f(n-1)+f(n-2)
print(f(10))
# 有一对雌雄兔子，每两个月就繁殖雌雄兔一对，问n月后有多少对兔子？
# 1，2--》1对
# 3，4--》2对
# 5，6--》4对
def f(n):
if n <= 2:
return 1 # 寻找递归函数的出口
return f(n-2)*2
print(f(19))
5. 函数返回值及函数的参数传递
5.1 return 关键字
# return标志语句块的结束，后面的代码不可以执行
# 定义函数，包含两个必选参数x y
def fun1(x, y):
print("return ......")
if x > y:
print("return x......")
return x # return返回结构该语句块结束
print("xxxx") # 位于return语句后面无法执行
print("return y......")
return y # return返回结构该语句块结束
print("return end......") # 位于return语句后面无法执行
# result = fun1(10,8)
# print(result)
i,j = fun1(100,8)
print(i,j)
print(fun1(100,8)) # return返回元组
5.2 参数传递
# 从动态类型的参数传递看，参数传递实际传递的是引用
# 不可变数据类型
def func1():
global x # 在声明全局之前不能使用，否则视为局部变量与全局变量声明矛盾
print(x, id(x)) # 1 2072128940336
x = 100
print(x, id(x)) # 100 2072129131984
x = 1
func1()
print(x, id(x)) # 100 2072129131984
def func1(x):
print(x, id(x)) # 1 2228869294384
x = 100
print(x, id(x)) # 100 2228869486032
x = 1
func1(x)
print(x, id(x)) # 1 2228869294384
# 可变数据类型的传递
# 在局部和全局都可以修改其值
# 参数定义时，尽量避免定义为可变数据类型 def f(a=[])
# 创建a只在函数定义时创建，再调用函数时只执行函数体里面的内容
def f(x):
x[0] = 100
print(x)
a = [1,2,3]
f(a) # [100, 2, 3]
print(a) # [100, 2, 3]
def f(a=[]):
a.append(1)
print(a)
f()
f()
f()
# 结果：
# [1]
# [1, 1]
# [1, 1, 1]
