Python 隐式或未定义的匹配对象

通过使用Python的

re

模块，我学到的是，在使用

re

函数时，总是创建一个

match

对象

有人能解释一下这段代码的工作原理吗？我过不去

import re

text = "1 < than 2 > 0 & not 'NULL'"

html_escapes = {'&': '&amp;',
                '<': '&lt;',
                '>': '&gt;',
                '"': '&quot;',
                '\'': '&apos;'}


def multiwordreplace(txt, worddict):
    rc = re.compile('|'.join(map(re.escape, worddict)))
    def translate(match):
        return worddict[match.group(0)]
    return rc.sub(translate, txt)

print multiwordreplace(text, html_escapes)

重新导入
text=“1<2>0&不为空”
html_转义={'&'：'&；'，
'': '',
'"': '"',
“\”：“&apos；”
def multiwordreplace（txt，worddict）：
rc=re.compile（'|'.join（map（re.escape，worddict）））
def翻译（匹配）：
return worddict[match.group（0）]
返回rc.sub（翻译，txt）
打印多字替换（文本、html_转义）

这个

匹配的
对象来自哪里

x = re.compile(a)
x.sub(b, c)

相当于

re.sub(a, b, c)

i、 e.编译的正则表达式
a
是
模式
，
b
是替换的
repl
，
c
是
字符串

在这种情况下，
repl
是一个函数，
translate
。发件人：

如果repl是一个函数，则会为模式的每个非重叠出现调用它。函数接受单个匹配对象参数，并返回替换字符串

match
参数由
re.sub
为
string
中的每个匹配项提供，函数从
worddict
返回适当的替换项，以替换为
txt

你也可以这样写：

return rc.sub(lambda match: worddict[match.group(0)], txt)

相当于

re.sub(a, b, c)

i、 e.编译的正则表达式
a
是
模式
，
b
是替换的
repl
，
c
是
字符串

在这种情况下，
repl
是一个函数，
translate
。发件人：

如果repl是一个函数，则会为模式的每个非重叠出现调用它。函数接受单个匹配对象参数，并返回替换字符串

match
参数由
re.sub
为
string
中的每个匹配项提供，函数从
worddict
返回适当的替换项，以替换为
txt

你也可以这样写：

return rc.sub(lambda match: worddict[match.group(0)], txt)

相当于

re.sub(a, b, c)

i、 e.编译的正则表达式
a
是
模式
，
b
是替换的
repl
，
c
是
字符串

在这种情况下，
repl
是一个函数，
translate
。发件人：

如果repl是一个函数，则会为模式的每个非重叠出现调用它。函数接受单个匹配对象参数，并返回替换字符串

match
参数由
re.sub
为
string
中的每个匹配项提供，函数从
worddict
返回适当的替换项，以替换为
txt

你也可以这样写：

return rc.sub(lambda match: worddict[match.group(0)], txt)

相当于

re.sub(a, b, c)

i、 e.编译的正则表达式
a
是
模式
，
b
是替换的
repl
，
c
是
字符串

在这种情况下，
repl
是一个函数，
translate
。发件人：

如果repl是一个函数，则会为模式的每个非重叠出现调用它。函数接受单个匹配对象参数，并返回替换字符串

match
参数由
re.sub
为
string
中的每个匹配项提供，函数从
worddict
返回适当的替换项，以替换为
txt

你也可以这样写：

return rc.sub(lambda match: worddict[match.group(0)], txt)

我假设您指的是
匹配
的位置：

def translate(match):
    return worddict[match.group(0)]

起源于。Python支持函数式编程的概念，其中可以将函数作为参数传递

如果您这样调用
re.sub
作为：

rc.sub(translate, txt)

translate
是一个函数。而
rc.sub
所做的就是寻找匹配项每次匹配，都会使用生成的参数调用函数。结果是该函数的替换

另一个例子是
map
函数：

def map(f, lst):
    result = []
    for x in lst:
        result.append(f(x))
    return result

因此，使用函数
f
调用
map
。然后在
lst
上迭代，对于每个元素
x
，使用
x
调用
f
。结果将附加到列表中

因此，您不必传递带有参数的
translate
来获取值，您可以传递函数，以便另一个函数可以使用几个（不同）值调用该函数。
我假设您的意思是
匹配的位置
：

def translate(match):
    return worddict[match.group(0)]

起源于。Python支持函数式编程的概念，其中可以将函数作为参数传递

如果您这样调用
re.sub
作为：

rc.sub(translate, txt)

translate
是一个函数。而
rc.sub
所做的就是寻找匹配项每次匹配，都会使用生成的参数调用函数。结果是该函数的替换

另一个例子是
map
函数：

def map(f, lst):
    result = []
    for x in lst:
        result.append(f(x))
    return result

因此，使用函数
f
调用
map
。然后在
lst
上迭代，对于每个元素
x
，使用
x
调用
f
。结果将附加到列表中

因此，您不必传递带有参数的
translate
来获取值，您可以传递函数，以便另一个函数可以使用几个（不同）值调用该函数。
我假设您的意思是
匹配的位置
：

def translate(match):
    return worddict[match.group(0)]

起源于。Python支持函数式编程的概念，其中可以将函数作为参数传递

如果您这样调用
re.sub
作为：

rc.sub(translate, txt)

翻译