1. 案列,代码演示
def test():
print('拼搏到无能为力,坚持到感动自己')
f=test() # 变量可以指向函数,函数名也是一个变量,多以变量可以当做函数使用
f()
思考问题: test 增加功能,但是不能修改test 函数内部------> 装饰器
在代码运行期间,可以动态增加函数功能的方式,被称为装饰器[Decorator]
也就是说,在不修改员函数的基础上,给原函数增加功能
好处: 在团队开发中,如果两个或者两个以上的程序员会用到相同的功能,但是功能又有细微的差别,采用装饰器:相互不影响,代码简化
2.使用
简单装饰器 代码演示:
def test():
print('拼搏到无能为力,坚持到感动自己')
# a ,书写闭包
# B , 给外部函数设置参数,fun表示的是原函数
def outer (fun):
def inner():
# d , 给原函数增加功能
print('hello')
# c , 调用原函数
fun()
return innter
#e,使用闭包
f= outer(test) # f= inner
# 注意 增加的功能,可以写在原函数调用的前面或者后面
# 注意: outer 函数就被称为装饰器
练习 给下面的函数添加功能,打印九九乘法表
def show():
for i in range(10):
print(i)
def outer1(fun):
dfe innter1():
fun ()
for i in range(1,10):
for j in range(1,i+1):
prrint('%d*%d=%d'%(j,i,i*j),end=" ")
print("")
return inner1
f1 = outer1(show)
f1()
2.2 有参数的装饰器 代码演示
def getAge(age):
print(age)
getAge(10)
getage(-5)
print('**********')
# 需求: 在不修改原函数的基础上,进行数据的过滤,当用户输入age为负数时,则置为0
def wr apper(fun):
# 注意: 当前原含糊有参数,装饰器的作用是为了操作原函数中的参数,给inner 设置参数
def inner(num):
# 增加新功能;过滤负数
if num<0:
num = 0
# 调用原函数
fun(num) # age = num
return inner
f= wrapper (getAge)
f(10) # num= 10
f(-5)
2.3 系统的简写 代码演示:
# 简化 demo2 中的操作,@ 装饰器的名称 应用到原函数中
# 需求: 在不修改原函数的基础上,进行数据的过滤,当用户输入age为负数时,则置为0
def wrapper(fun):
# 注意: 当原函数有参数,装饰器的作用是为了操作原函数中的参数,给inner 设置参数
def innter(num):
# 增加新功能,过滤负数
if num< 0:
num= 0
# 调用原函数
fun(num) # age=num
return inner
# 将wrapper装饰器应用在getAge函数上,
@ wrapper
def getAge(age):
print(age)
getAge(10)
getAge(-5)
""'
@ wr apper
等价于
f= wrapper (getAge)
f(10) # num=10
# 注意:当前使用@ 的时候 ,在同一个文件中, 装饰器必须出现的原函数的前面
""'
2.4 不定长参数的装饰器 代码啊演示
# 应用场景 : 当同一个装饰器作用于不同函数的时候,这些函数的参数的个数不相同
def wrapper (fun):
dfe inner (*args):
print('hello')
fun(* args) # a= args[0] b=args[1]
return innter
@ wrapper
def fun1(a,b):
print (a+b)
@wrapper
dfe fun2(a,b,c,d):
print(a,b,c,d)
fun1(10,20) # args = (10,20)
fun2(1,2,3,4)
2,.5 多个装饰器作用于同一个函数 代码演示:
# 将多个装饰器应用到通哟个函数上
def wrapper1(fun):
def innter1():
print('1~~~~')
fun()
return innter1
def wrapper2(fun):
dfe inner2():
print('2~~~~")
return inner2
@ wr apper1
@ wr apper 2
def show():
print("hello'')
show()
"""
1~~~~
2~~~~
hello
"""
# 结论 多个函数装饰器作用于一个函数的时候,从第一个装饰器开始,,从上往下依次执行,但是,原函数只会被执行一次
二 函数 递归
概念
函数递归: 一个会调用自身函数[在一个函数的内部,自己调用自已]
递归调用
递归中包含了一种隐式循环,他会重复指定某段代码[函数体] , 但这种循环不需要条件控制
使用递归解决问题思路:
a. 找到一个连接条件[临界值]
b.找到相邻两次循环之间的关系
c. 一般情况下,会找到一个规律[公式]
2.使用 代码演示:
#案例一
"""
1 2 3 4 5 6 7 8 9 10 11.。。。
斐波那契数列：1,1,2,3,5,8,13,21,34,55,89.....
解决问题：报一个数，输出数列中对应的数
规律：
a.第一个位置和第二个位置上数是固定的，都是1
b.第n个位置上的数：第 n - 1 的数 + 第 n - 2 的数
r1 = func1(1) ------>1
r2 = func1(2) ------>1
r3 = fun1(3) ------>func1(1) + func1(2)----->1 + 1 = 2
r4 = fun1(4)------->fun1(3) + fun1(2) ----->func1(1) + func1(2) + fun1(2) ---->1 + 1 + 1 = 3
r5 = fun1(5) ----->fun1(4) + fun1(3) ----->fun1(3) + fun1(2) + func1(1) + func1(2)--->func1(1) + func1(2) ++ fun1(2) + func1(1) + func1(2)--->5
.....
rn = fun1(n) ----->fun1(n- 1) + fun1(n - 2)
"""
def func1(num):
#临界值
if num == 1 or num == 2:
return 1
else:
#print("~~~~",num)
result = func1(num- 1) + func1(num - 2) #result = func1(1) + func1(2) --->1 + 1 =2
return result
print(func1(10))
#练习;使用递归计算1~某个数之间的和
"""
add(1) = 1 :临界值
add(2) = add(1) + 2
add(3) = add(2) + 3 ---->add(1) + 2 + 3 = 1 + 2 + 3
add(4) = add(3) + 4---->add(2) + 3 + 4 ---->add(1) + 2 + 3 + 4---->1 + 2 + 3 + 4
....
add(n) = add(n - 1) + n
"""
def add(num):
"""
n = 1
sum = 0
while n <= 100:
sum += n
n += 1
return sum
sum1 = 0
for i in range(1,num + 1):
sum1 += i
return sum1
"""
#使用递归实现
if num == 1:
return 1
else:
return add(num - 1) + num
print(add(100))
# 注意: 以后在实际项目中尽量用递归,如果隐式循环的次数太多,会导致内存泄漏[栈溢出]
优点: 简化代码,逻辑清晰
