Question

我遇到了这个代码，它将*通配符与字符串相匹配。 *可以视为0或更多字符。

def samePattern(main,pattern):
    if pattern=="*" or main==pattern:
        return True
    if main=="":
        return False
    if main[0:1]==pattern[0:1]:
        return samePattern(main[1:],pattern[1:])

    if pattern[0:1]=="*":
        return samePattern(main[1:],pattern) or samePattern(main,pattern[1:])

    return False

虽然我认为我理解了基本情况，但我不了解该行

if pattern[0:1]=="*":
        return samePattern(main[1:],pattern) or samePattern(main,pattern[1:])

正在运作。

有人可以解释它是如何工作的吗？

Answer 1

如果模式[0：1] ==“*”：

上述语句表示0索引处的模式变量的字符为'*'时，条件为true，之后在条件语句下运行

返回samePattern（main [1：]，pattern）或samePattern（main，pattern [1：]）

此语句以递归方式调用“samePattern”函数并将参数传递为（主索引的值从索引1开始到n-1个字符，模式变量）

Answer 2

'*'匹配0个或更多字符。最后一个if语句说：如果pattern的格式为'*' + p，则返回True，如果是：

main的第一个字符匹配模式后的所有内容（因此'*'头部的pattern可能会匹配main头部的更多字符，或者
p，pattern的尾部与main匹配（我们已完成'*'）

Answer 3

重要的一点是通配符的位置：

test*
te*ing
*ing

在第一种情况下，最后使用通配符testing and test*：

def samePattern(main,pattern):
    if pattern=="*" or main==pattern:                  #  3.
        return True                                    
    if main=="":                                       #  4.
        return False                                   
   if main[0:1]==pattern[0:1]:                         #  1.
       return samePattern(main[1:],pattern[1:])        #

    if pattern[0:1]=="*":
        return samePattern(main[1:],pattern) or samePattern(main,pattern[1:])
                            ^                       ^
                            | # 2.                  | # 5.

    return False

第1部分：test遍历文本和模式，直到模式到达通配符并且它们不再是相同的字符。

第2节触发，并仅沿一个字符移动文本并再次尝试。

第3节命中，模式是单一的＆＃39; *＆＃39;没有别的，它返回True。

第2节带有True值，Python的短路评估不会测试or的另一面，因为它并不需要，并且整个事情坍塌到True成功的比赛。

第二种情况，中间的通配符以相同的方式开始。 testing and te*ing：

第1节。遍历文本和模式，直到模式到达通配符。

现在文本和模式是sting and *ing，这与第三种情况相同 - 前面的通配符。

第三种情况，前面是通配符，例如testing and *ing：

第2节触发因为模式以*开头。（它跳过了第3部分，因为它不是仅一颗星）。第2节移动一个文本字符并以相同的模式再次尝试。

同样的情况一再发生，直到第4节触发并且文本已用完。现在返回False。

现在，第一个False从or测试的左侧部分返回，右侧部分首次尝试。这会使模式移过通配符，*ing变为ing。

但我们仍然在递归中，在文本的 last 字符 - g and ing，它从第1节返回False。

此深度的or测试的两侧返回False，因此整条线都可以。

这回到了一个级别，并尝试了该级别or测试的另一面。 ng and ing。第1节中的错误。

此深度的or测试的两侧返回False，因此整条线都可以。

这回到了一个级别，并尝试了该级别or测试的另一面。 ing and ing。从第3节和main==pattern开始为真。

这返回True，or返回True，整个事物在一堆真理中崩溃。

所有部分协同工作，但粗略地说第1节将文本与文本匹配，第2节和第3节匹配结束通配符，第4节和第5节匹配起始通配符，它们重叠，负责处理通配符 - 在 - 中间。

添加一些printf debugging帮我看看发生了什么：

第一

def samePattern(main,pattern):
    print "main", main, "pattern", pattern

[..]

然后

    if pattern[0:1]=="*":
        x = samePattern(main[1:],pattern)
        print "x", x
        return x or samePattern(main,pattern[1:])

这个程序如何运作？

3 个答案: