装饰器&递归

装饰器

1.开放封闭原则

​ 在源码不改变的状况下,增长一些额外的功能

对扩展是开放的,对修改是封闭的

1.1 开放原则:增长额外新功能

1.2 封闭原则:不要改变源码

2 装饰器

知足开放封闭原则,在不改变原函数代码及调用方式的前提下,增长新功能

# 基本装饰器
def wrapper(func):  # 1
    def inner(*args):  # 这里的* 是聚合  ## 5
        ret = func(*args)  # 这里的* 是打散  ## 6
        return ret   # 7
    return inner
@wrapper    # 2  func1 = wrapper(func1)  因此运行到这一步 wrapper函数执行
def func1(*args):  # 3
    ...      # 6
func1()   #  4

语法糖的做用

# 标准版的装饰器

@a
def b():
    pass

# 语法糖的那行  就等价于   b = a(b)  把那一行换成这一行 是同样的 因此这是执行操做,和下面调用不要紧

## 带参数的装饰器

@c(1)
def b():
    pass

## 这个有两行操做  a = c(1)    b = a(b)

带参数装饰器

## 当装饰器装饰两个以上验证方式又不相同的函数时,就用到了带参数的装饰器
def outer(choose):  
    def wrapper(func):
        def inner(*args,**kwargs):
            if choose =='func1':
                print ('func1的判断条件')
                ret = func()
                return ret
            if choose=='func2':
                print ('func2的判断条件')
                ret = func()
                return ret
        return inner
    return wrapper
@outer('func1')   ## 这里的 outer('func1') 先执行  返回 wrapper 函数,因此就只比标准函数多一步操做
def func1():
    print('我是被装饰的函数1')
@outer('func2')    
def func2():
    
    print ('我是被装饰的函数2')
## 固然这样写很蠢;若是有操做的话能够直接对choose这个变量操做,不须要判断,由于相应的choose是不同的

两个装饰器装饰一个函数

def wrapper1(func):    
    print(0)
    def inner1():
        print(111)
        func()
        print(222)
    return inner1



def wrapper2(func):
    print(9)
    def inner2():
        print(333)
        func()
        print(444)
    return inner2
@wrapper1
@wrapper2
def func0():
    print('********')
    
## 结果 
9
0
111
333
********
444
222
## 这个语法糖 等价于 func0  = wrapper1(wrapper2(func0))

递归

递归毫不是简单的本身调用本身,他是一种化繁为简的思想,请宏观的看问题,细节交给计算机

递归要知足两点要求

​ 1 递归条件:能够经过不断调用自身,缩小待解决问题的范围

​ 2 基线条件:出口,当不知足递归条件时

# 阶乘问题
def jc(n):
    if n==1:
        return 1
    else:
        return n*jc(n-1)

## 斐波那契数列 第n项的值
def fbnq(n):
    if n==1:
        return 1
    if n<=0:
        return 0
    return fbnq(n-1)+fbnq(n-2)