python编程基础之二十八

装饰器：说白了就是闭包，但是内部函数调用外部变量调用的是函数，

好处：就是在不用修改原函数代码的前提下给函数增加新的功能

装饰器有两种写法

第一种：

 1 #被修饰的函数
 2 def say_hello(name):
 3     print(‘我就是人见人爱，花见花开的%s‘%name)
 4
 5 # 参数是被修饰函数
 6 def wrapper(func):     #1.定义装饰器
 7     def inner(name):   #2.定义闭包 在闭包中增加功能
 8         print(‘-‘ * 50)
 9         func(name)     #3.调用原函数实现原来的功能
10         print(‘*‘ * 50)
11     return inner       #4.返回增强功能的函数
12
13 say_hello = wrapper(say_hello) #5.获取增强功能的函数
14 say_hello(‘张三‘)         #6. 调用增强函数，实现功能

第二种：

 1 def wrapper(func):
 2   def inner(age1):
 3       #增加的功能
 4       if age1 < 0:
 5           age1 = 0
 6       #调用原函数
 7       func(age1)
 8   return inner
 9
10 @wrapper     #相当于 getAge = wrapper(getage)
11 def getAge(age):
12     print(age)
13 getAge(18)  #调用增强的函数

直接在被修饰的函数定义前加@修饰器函数名

多个修饰器函数修饰同一个函数

记得修饰顺序按照远近顺序就行，近的先修饰

 1 def wrapper1(func):
 2       print("wrapper1~~~~外部函数")
 3       def inner(a,b):
 4           print(‘wrapper1-----内部函数‘)
 5           func(a,b)
 6       return inner
 7
 8     def wrapper2(func):
 9          print("wrapper2~~~~外部函数")
10         def inner(a, b):
11             print("wrapper2~~~~内部函数")
12             func(a, b)
13         return inner
14
15     @wrapper1
16     @wrapper2
17     def text(num1,num2):
18         print(num1 + num2)
19
20     text(10,20)

递归：一个函数直接或间接调用自己，递归分为正向递归，逆向递归两个过程

一个递归一定包含两个部分：递归结束条件，递归调用自己

1 def  recurve(*args,**kw):
2       if 递归终止条件:   #递归终止条件必须在递归调用前
3           # to do
4        else:
5           #to do
6           recurve(参数)
7           #to do

原文地址：https://www.cnblogs.com/higer666/p/9451298.html