这个程序是如何工作的？

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 个或多个字符。最后一个 if 语句说：如果 pattern 的形式是 '*' + p，那么 return True 如果：

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

Answer 2

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

Above statement means when character of pattern variable at 0 index is '*' than condition is true and after that it run below conditional statement

return samePattern(main[1:],pattern) 或 samePattern(main,pattern[1:])

This statement call "samePattern" function in recursively and pass parameters as(value of main variable starting from index of 1 to n-1 characters, pattern variable)

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 的文本和模式，直到模式到达通配符并且它们不再是同一个字符。

Section 2. 触发并仅沿一个字符移动文本并重试。

第 3 部分命中，该模式是一个没有其他任何内容的“*”，并且 returns 正确。

第 2 节返回真值，Python 的短路评估不会测试 or 的另一侧，因为它不需要，并且整个事情崩溃到 True 成功匹配。

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

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

现在的文字和模式是sting and *ing，和第三种情况一样-前面的通配符。

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

部分 2. 触发，因为模式以 * 开头。（它跳过第 3 节。因为它不是只有一颗星）。第 2 部分移动一个文本字符并使用相同的模式重试。

同样的情况反复发生，直到第 4 节触发并且文本已运行结束。现在这个 returns False.

现在第一个False从or测试的左边部分回来了，右边部分是第一次尝试。这会将模式移过通配符，*ing 变为 ing.

但我们仍在递归的深处，在文本的 last 字符处 - g and ing，第 1 节中的 returns False。

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

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

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

这又回到了一个级别，并且尝试了该级别的 or 测试的另一侧。 ing and ing。第 3 节和 main==pattern.

为真

这个 returns 是的，or returns 是的，整个事情在一堆真相中崩溃了。

所有部分一起工作，但粗略地说，第 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:])

这个程序是如何工作的？

How does this program work?

python

recursion

logic

wildcard