裝飾器&遞歸

裝飾器

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)