ratiger
0%

递归函数的Debug技巧

发表于 更新于
在递归函数内部配合缩进，打印关键值，可以更直观地观察递归函数的执行情况。而利用Python装饰器，可无需修改调试函数实现，达到同样的效果。

在递归函数内部配合缩进，打印关键值，可以更直观地观察递归函数的执行情况。

参考：labuladong - 分享一个小技巧，提高刷题幸福感

Python装饰器方案

利用Python装饰器，可无需修改调试函数实现，达到同样的效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def debugHelper(func): # 装饰器
    cnt = 0
    indent = '│ ' # 根据自己的喜好来选择缩进方式
    def wrapper(*args, **kwargs):
        nonlocal cnt
        # 按照自己的需求来打印 begin
        print(indent*cnt,end="")
        print(args[0]) 
        # 按照自己的需求来打印 end
        cnt += 1
        res = func(*args, **kwargs) # 被修饰函数
        cnt -= 1
        # 按照自己的需求来打印 begin
        print(indent*cnt,end="")
        print(args[0],':',res) 
        # 按照自己的需求来打印 end
        return res 
    return wrapper

使用示例 1

斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@debugHelper
def fib(n) -> int:
    if n == 0 or n == 1:
        return n
    return fib(n-1)+fib(n-2)

res = fib(4)
print(res)

# 输出
# (4,)
# │ (3,)
# │ │ (2,)
# │ │ │ (1,)
# │ │ │ (1,) : 1
# │ │ │ (0,)
# │ │ │ (0,) : 0
# │ │ (2,) : 1
# │ │ (1,)
# │ │ (1,) : 1
# │ (3,) : 2
# │ (2,)
# │ │ (1,)
# │ │ (1,) : 1
# │ │ (0,)
# │ │ (0,) : 0
# │ (2,) : 1
# (4,) : 3

使用示例 2

LeetCode第10题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
def isMatch(s: str, p: str) -> bool:
    # .*表示任意字符串都可以匹配了
    def optimizePattern(p):
        j = 0
        while j < len(p)-1:
            if p[j+1] == '*':
                if j+3 <= len(p)-1 and p[j:j+2] == p[j+2:j+4]:
                    p = p[:j+2] + p[j+4:]
                    continue
                j += 1 # 配合下一句，实现 j+=2
            j += 1
        return p

    @debugHelper
    def dp(s,p):
        n,m = len(s), len(p)
        if m == 0:
            return n == 0
        if n == 0:
            if m == 1 or p[1] != '*':
                return False
            return dp(s,p[2:])
        if m == 1 or p[1] !='*':
            if s[0] == p[0] or p[0] == '.':
                return dp(s[1:],p[1:])
            return False
        # .* 或者 any char with *
        if p[0] == '.' or s[0] == p[0]:
            return dp(s,p[2:]) or dp(s[1:],p) # 匹配或者不匹配
        else:
            return dp(s,p[2:]) # 不相同，只能不匹配了

    p = optimizePattern(p)
    return dp(s,p)

s = "aab"
p = 'c*a*b'
res = isMatch(s,p)
print(res)

# 输出
# ('aab', 'c*a*b')
# │ ('aab', 'a*b')
# │ │ ('aab', 'b')
# │ │ ('aab', 'b') : False
# │ │ ('ab', 'a*b')
# │ │ │ ('ab', 'b')
# │ │ │ ('ab', 'b') : False
# │ │ │ ('b', 'a*b')
# │ │ │ │ ('b', 'b')
# │ │ │ │ │ ('', '')
# │ │ │ │ │ ('', '') : True
# │ │ │ │ ('b', 'b') : True
# │ │ │ ('b', 'a*b') : True
# │ │ ('ab', 'a*b') : True
# │ ('aab', 'a*b') : True
# ('aab', 'c*a*b') : True
# True