Python入門篇-遞歸函數Recursion

　　　　　　　　　　　　Python入門篇-遞歸函數（recursion）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑

版權聲明：原創作品，謝絕轉載！否則將追究法律責任。

 

 

 

一.遞歸概述

　　（1）函數直接或者間接調用自身就是遞歸；

　　（2）遞歸需要有邊界，遞歸前進段，遞歸返回段；

　　（3）遞歸一定要有邊界條件；

　　（4）當邊界條件不滿足的時候，遞歸前進；
　　
　　（5）當邊界條件滿足的時候，遞歸返回；

 

二.遞歸案例

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

import sys

print("默認的遞歸調用次數限制0是：{} 次".format(sys.getrecursionlimit()))

sys.setrecursionlimit(20000)    #我們修改默認的遞歸調用次數

print("當前遞歸調用次數限制是：{} 次".format(sys.getrecursionlimit()))
"""
遞歸要求：
    遞歸一定要有退出條件，遞歸調用一定要執行到這個退出條件。沒有退出條件的遞歸調用，就是無限調用。
    遞歸調用的深度不宜過深：
        Python對遞歸調用的深度做了限制，以保護解釋器
        超過遞歸深度限制，拋出："RecursionError： maxinum recursion depth exceeded" 即超過了最大遞歸深度
        sys.getrecursionlimit()
"""



"""
    斐波拉契數字推理公式：F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)
"""
def fib(n):
    return 1 if n < 2 else fib(n-1) + fib(n-2)

for i in range(20):
    print(fib(i), end=' ')


#以上代碼執行結果如下:
默認的遞歸調用次數限制0是：1000 次
當前遞歸調用次數限制是：20000 次
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

 

三.遞歸的性能

1>.使用for循環打印斐波拉契前35個數字

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


import datetime

start = datetime.datetime.now()

pre = 0

cur = 1 # No1

print(pre, cur, end=' ')

n = 35

for i in range(n-1):
    pre, cur = cur, pre + cur
    print(cur, end=' ')

delta = (datetime.datetime.now() - start).total_seconds()

print("\n遞歸調用打印斐波拉契錢35個數字的時間為：{}".format(delta))



#以上代碼直接結果如下:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 
遞歸調用打印斐波拉契錢35個數字的時間為：0.0

2>.使用遞歸方式打印斐波拉契前35個數字

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

import datetime

n = 35

start = datetime.datetime.now()

def fib(n):
    return 1 if n < 2 else fib(n-1) + fib(n-2)

for i in range(n):
    print(fib(i), end=' ')

delta = (datetime.datetime.now() -start).total_seconds()

print("\n遞歸調用打印斐波拉契錢35個數字的時間為：{}".format(delta))



#以上代碼直接結果如下:
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 
遞歸調用打印斐波拉契錢35個數字的時間為：5.93134

3>.遞歸優化方案 

　　循環稍微復雜一些，但是只要不是死循環，可以多次迭代直至算出結果

　　fib函數代碼極簡易懂，但是只能獲取到最外層的函數調用，內部遞歸都是中間結果。而且給定一個n都要進行2n次遞歸，深度月神，效率月底。為了獲取斐波那契數列需要外面在套一個n次的循環，效率就更低了。

　　遞歸還有深度限制，如果遞歸復雜，函數反復壓棧，棧內存很快就溢出了

　　思考：這個極簡的遞歸代碼能否提高性能呢？下面是優化后的代碼，效率有明顯的提示，代碼如下所示：

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


import datetime

start = datetime.datetime.now()

pre = 0

cur = 1 # No1

print(pre, cur, end=' ')

"""
    改進后的fib函數和循環的思想類似
    參數n是邊界條件，用n來計算
    上一次的結果直接作為參數的實參
    效率很高
    和循環比較，性能相近。所以並不是說遞歸一定效率低下。但是遞歸有深度限制。
"""
def fib(n, pre=0,cur=1): # recursion
    pre, cur = cur, pre + cur
    print(cur, end=' ')
    if n == 2:
        return
    fib(n-1, pre, cur)

fib(35)

delta = (datetime.datetime.now() -start).total_seconds()

print("\n遞歸調用打印斐波拉契錢35個數字的時間為：{}".format(delta))

#以上代碼直接結果如下:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465
遞歸調用打印斐波拉契錢35個數字的時間為：0.0

4>.間接遞歸

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


def foo():
    bar()

def bar():
    foo()


"""
        我們這里看起來只是調用foo函數，但是進入foo函數中的函數體中我們發現調用bar函數，進入bar函數中的函數體中我們發現它
    又再次調用foo函數。因此我們執行該代碼后會發現跑出來異常：“RecursionError: maximum recursion depth exceeded”.
        這就形成了間接遞歸，是通過別的函數調用了函數自身。但是，如果構成了循環遞歸調用是非常危險的，但是往往這種情況在代碼
    復雜的情況下，還是可能發生這種調用。要用代碼的規范來避免這種遞歸調用的發生。
"""
foo()      

5>.遞歸總結

    （1）遞歸是一種很自然的表達，符合邏輯思維
    （2）遞歸相對運行效率低，每一次調用函數都要開辟棧幀
    （3）遞歸有深度限制，如果遞歸層次太深，函數反復壓棧，棧內存很快就溢出了
    （4）如果有限次數的遞歸，可以使用遞歸調用，或者使用循環代替，循環代碼稍微復雜一些，但是只要不是死循環，可以多次迭代直至算出結果
    （5）絕大多數遞歸，都可以使用循環實現
    （6）即使遞歸代碼很簡潔，但是能不用則不用遞歸

 

 

四.遞歸練習

1>.求N的階乘

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


def fac(n):
    if n == 1:
        return 1
    return n * fac(n-1)

N = 5

print("{} 的階乘為：{}".format(N,fac(N)))



#以上代碼執行結果如下:
5 的階乘為：120

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


def fac(n,p = 1):
    if n == 1:
        return p
    p *= n
    # print(p)
    return fac(n - 1,p)

N = 5

print("{} 的階乘為：{}".format(N,fac(N)))



#以上代碼執行結果如下:
5 的階乘為：120

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


def fac(n,p = None):
   if p is None:
       p = [1]
   if n == 1:
       return p[0]

   p[0] *= n
   return fac(n - 1,p)

N = 5

print("{} 的階乘為：{}".format(N,fac(N)))



#以上代碼執行結果如下:
5 的階乘為：120

2>.將一個數逆序放入列表中，例如：1234=>【4,3,2,1】

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

data = str(1234)

def revert(x):
    if x == -1:
        return ""
    return data[x] + revert(x -1)

print(revert(len(data) - 1))



#以上代碼執行結果如下:
4321

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]



def revert(n,list_1 = None):
    if list_1 is None:
        list_1 = []
    x,y = divmod(n,10)
    list_1.append(y)

    if x == 0:
        return list_1
    return revert(x,list_1)

print(revert(12345))



#以上代碼執行結果如下:
[5, 4, 3, 2, 1]

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

num = 1234

def revert(num,target=[]):
    if num:
        target.append(num[len(num) - 1])    #等效於target.append(num[-1:])
        revert(num[:len(num) - 1])
    return target

print(revert(str(num)))



#以上代碼執行結果如下:
['4', '3', '2', '1']

3>.解決猴子吃桃問題

    猴子第一天摘下若干個桃子，當即吃了一半，還不過癮，又吃了一個。第二天早上有將剩下的桃子吃掉一半，又多吃了一個。以后每天早上都吃了前一天剩下的一半零一個。到第十天早上想吃時，只剩下一個桃子了。求第一天共摘了多少個桃子。

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

def peach(days = 10):
    if days == 1:
        return 1
    return (peach(days - 1) + 1) * 2

print(peach())



#以上代碼執行結果如下:
1534

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]

def peach(days = 1):
    if days == 10:
        return 1
    return (peach(days + 1) + 1) * 2

print("第一天共摘了{}個桃子".format(peach()))



#以上代碼執行結果如下:
第一天共摘了1534個桃子

4>.把字典扁平化

源字典 =  {'a':{'b':1,'c':2}, 'd':{'e':3,'f':{'g':4}}}

目標字典 = {'a.c':2,'d.e':3,'d.f.g':4,'a.b':1}

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

target = {}


def flatmap(src,prefix=''):
    for k,v in src.items():
        if isinstance(v,(list,tuple,set,dict)):
            flatmap(v,prefix=prefix + k + '.')      #遞歸調用
        else:
            target[prefix + k] = v

flatmap(source)

print(target)



#以上代碼輸出結果如下：
{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}


def flatmap(src,dest=None,prefix=''):
    if dest == None:
        dest = {}
    for k,v in src.items():
        if isinstance(v,(list,tuple,set,dict)):
            flatmap(v,dest,prefix=prefix + k + '.')      #遞歸調用
        else:
            dest[prefix + k] = v

    return dest

target = flatmap(source)

print(target)



#以上代碼輸出結果如下：
{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}


def flatmap(src,dest=None,prefix=''):
    def _flatmap(src,dest=None,prefix=''):
        for k,v in src.items():
            key = prefix + k
            if isinstance(v,(list,tuple,set,dict)):
                _flatmap(v,dest,key + ".")              #遞歸調用
            else:
                dest[key] = v
    dest = {}
    _flatmap(src,dest)
    return dest

target = flatmap(source)

print(target)



#以上代碼輸出結果如下：
{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

5>.求2個字符串的最長公共子串

#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:[e-mail]


def findit(str1,str2):
    count = 0
    length = len(str1)

    for sublen in range(length,0,-1):
        for start in range(0,length - sublen +1):
            substr = str1[start:start + sublen]
            count += 1
            if str2.find(substr) > -1:
                print("count={},substrlen={}0".format(count,sublen))
                return substr

s1 = "abcdefg"
s2 = "defabcdoabcdeftw"
s3 = "1234a"

print(findit(s1,s2))
print(findit(s1,s3))



#以上代碼輸出結果如下:
count=2,substrlen=60
abcdef
count=22,substrlen=10
a