我希望能够匹配带转义引号的字符串字面量。 例如，我想搜索"this is a 'test with escaped\' values' ok"并正确识别反斜杠作为转义字符。我尝试了以下解决方案：
import re
regexc = re.compile(r"\'(.*?)(?<!\\)\'")
match = regexc.search(r""" Example: 'Foo \' Bar' End. """)
print match.groups()
# I want ("Foo \' Bar") to be printed above
\”本身无法被转义。我不知道该怎么做。我想要像下面这样的解决方案，但是负回顾断言需要固定长度：# ...
re.compile(r"\'(.*?)(?<!\\(\\\\)*)\'")
# ...
'[^'\\]*(?:\\.[^'\\]*)*'"首先注意，MizardX的答案是100%准确的。我想补充一些关于效率的额外建议。其次，我想指出这个问题早就被解决和优化了-参见：精通正则表达式（第3版），（它详细介绍了这个特定问题-强烈推荐）。
首先让我们看一下子表达式，以匹配可能包含转义单引号的单引号字符串。如果你要允许转义单引号，最好也允许转义转义（这就是Douglas Leeder的答案所做的）。但只要你在做它，它同样容易允许转义任何其他字符。有了这些要求。MizardX是唯一一个得到正确表达式的人。这里有两种格式，长格式和短格式（我已经获得了这个自由，用大量的描述性注释写成了VERBOSE模式-对于非平凡的正则表达式，你应该总是这样做）：
# MizardX's correct regex to match single quoted string:
re_sq_short = r"'((?:\\.|[^\\'])*)'"
re_sq_long = r"""
' # Literal opening quote
( # Capture group $1: Contents.
(?: # Group for contents alternatives
\\. # Either escaped anything
| [^\\'] # or one non-quote, non-escape.
)* # Zero or more contents alternatives.
) # End $1: Contents.
'
"""
这个代码可以正确匹配以下所有字符串测试用例：
text01 = r"out1 'escaped-escape: \\ ' out2"
test02 = r"out1 'escaped-quote: \' ' out2"
test03 = r"out1 'escaped-anything: \X ' out2"
test04 = r"out1 'two escaped escapes: \\\\ ' out2"
test05 = r"out1 'escaped-quote at end: \'' out2"
test06 = r"out1 'escaped-escape at end: \\' out2"
好的，现在让我们开始改进这个内容。首先，备选项的顺序很重要，应该始终将最可能的备选项放在第一位。在这种情况下，非转义字符比转义字符更有可能出现，因此反转顺序将稍微提高正则表达式的效率，如下所示：
# Better regex to match single quoted string:
re_sq_short = r"'((?:[^\\']|\\.)*)'"
re_sq_long = r"""
' # Literal opening quote
( # $1: Contents.
(?: # Group for contents alternatives
[^\\'] # Either a non-quote, non-escape,
| \\. # or an escaped anything.
)* # Zero or more contents alternatives.
) # End $1: Contents.
'
"""
这样已经好了一些，但是可以通过应用Jeffrey Friedl的"unrolling-the-loop"效率技术（来自MRE3）进一步改进（显著）。上面的正则表达式不是最优的，因为它必须费力地将星号量词应用于两个替代项的非捕获组，每个替代项一次只消耗一个或两个字符。这种交替可以完全消除，方法是认识到类似的模式一遍又一遍地重复出现，并且可以构造等效的表达式来完成相同的事情而不需要交替。以下是一个优化后的表达式，用于匹配单引号字符串并将其内容捕获到组$1中：
# Better regex to match single quoted string:
re_sq_short = r"'([^'\\]*(?:\\.[^'\\]*)*)'"
re_sq_long = r"""
' # Literal opening quote
( # $1: Contents.
[^'\\]* # {normal*} Zero or more non-', non-escapes.
(?: # Group for {(special normal*)*} construct.
\\. # {special} Escaped anything.
[^'\\]* # More {normal*}.
)* # Finish up {(special normal*)*} construct.
) # End $1: Contents.
'
"""
'This is an example string which contains one \'internally quoted\' string.' r"""
AUTHOR SINGLE-QUOTE REGEX STEPS TO: MATCH NON-MATCH
Evan Fosmark '(.*?)(?<!\\)' 374 376
Douglas Leeder '(([^\\']|\\'|\\\\)*)' 154 444
cletus/PEZ '((?:\\'|[^'])*)(?<!\\)' 223 527
MizardX '((?:\\.|[^\\'])*)' 221 369
MizardX(improved) '((?:[^\\']|\\.)*)' 153 369
Jeffrey Friedl '([^\\']*(?:\\.[^\\']*)*)' 13 19
"""
(?<!\\)(?:\\\\)*表达式来实现。以下是一些测试字符串，用于练习各种解决方案：text01 = r"out1 'escaped-escape: \\ ' out2"
test02 = r"out1 'escaped-quote: \' ' out2"
test03 = r"out1 'escaped-anything: \X ' out2"
test04 = r"out1 'two escaped escapes: \\\\ ' out2"
test05 = r"out1 'escaped-quote at end: \'' out2"
test06 = r"out1 'escaped-escape at end: \\' out2"
test07 = r"out1 'str1' out2 'str2' out2"
test08 = r"out1 \' 'str1' out2 'str2' out2"
test09 = r"out1 \\\' 'str1' out2 'str2' out2"
test10 = r"out1 \\ 'str1' out2 'str2' out2"
test11 = r"out1 \\\\ 'str1' out2 'str2' out2"
test12 = r"out1 \\'str1' out2 'str2' out2"
test13 = r"out1 \\\\'str1' out2 'str2' out2"
test14 = r"out1 'str1''str2''str3' out2"
给定这个测试数据，让我们看看各种解决方案的表现（'p'表示通过，'XX'表示失败）：
r"""
AUTHOR/REGEX 01 02 03 04 05 06 07 08 09 10 11 12 13 14
Douglas Leeder p p XX p p p p p p p p XX XX XX
r"(?:^|[^\\])'(([^\\']|\\'|\\\\)*)'"
cletus/PEZ p p p p p XX p p p p p XX XX XX
r"(?<!\\)'((?:\\'|[^'])*)(?<!\\)'"
MizardX p p p p p p p p p p p p p p
r"(?<!\\)(?:\\\\)*'((?:\\.|[^\\'])*)'"
ridgerunner p p p p p p p p p p p p p p
r"(?<!\\)(?:\\\\)*'([^'\\]*(?:\\.[^'\\]*)*)'"
"""
import re
data_list = [
r"out1 'escaped-escape: \\ ' out2",
r"out1 'escaped-quote: \' ' out2",
r"out1 'escaped-anything: \X ' out2",
r"out1 'two escaped escapes: \\\\ ' out2",
r"out1 'escaped-quote at end: \'' out2",
r"out1 'escaped-escape at end: \\' out2",
r"out1 'str1' out2 'str2' out2",
r"out1 \' 'str1' out2 'str2' out2",
r"out1 \\\' 'str1' out2 'str2' out2",
r"out1 \\ 'str1' out2 'str2' out2",
r"out1 \\\\ 'str1' out2 'str2' out2",
r"out1 \\'str1' out2 'str2' out2",
r"out1 \\\\'str1' out2 'str2' out2",
r"out1 'str1''str2''str3' out2",
]
regex = re.compile(
r"""(?<!\\)(?:\\\\)*'([^'\\]*(?:\\.[^'\\]*)*)'""",
re.DOTALL)
data_cnt = 0
for data in data_list:
data_cnt += 1
print ("\nData string %d" % (data_cnt))
m_cnt = 0
for match in regex.finditer(data):
m_cnt += 1
if (match.group(1)):
print(" quoted sub-string%3d = \"%s\"" %
(m_cnt, match.group(1)))
p.s. 感谢 MizardX 提供非常酷的 (?<!\\)(?:\\\\)* 表达式。每天都能学到新东西！
import re
regexc = re.compile(r"(?:^|[^\\])'(([^\\']|\\'|\\\\)*)'")
def check(test, base, target):
match = regexc.search(base)
assert match is not None, test+": regex didn't match for "+base
assert match.group(1) == target, test+": "+target+" not found in "+base
print "test %s passed"%test
check("Empty","''","")
check("single escape1", r""" Example: 'Foo \' Bar' End. """,r"Foo \' Bar")
check("single escape2", r"""'\''""",r"\'")
check("double escape",r""" Example2: 'Foo \\' End. """,r"Foo \\")
check("First quote escaped",r"not matched\''a'","a")
check("First quote escaped beginning",r"\''a'","a")
r"(?:^|[^\\])'(([^\\']|\\'|\\\\)*)'"仅向前匹配我们想要的字符串内容：
编辑：
在前面添加额外的正则表达式以检查第一个引号是否被转义。
(?:^|[^\\])'(([^\\']|\\'|\\\\)*)')不能匹配"test 'test \x3F test' test"和"test \\'test' test"。(包含引号和反斜杠以外转义字符的字符串，以及以转义反斜杠开头的字符串)(?<!\\)'((?:\\'|[^'])*)(?<!\\)')不能匹配"test 'test\\' test"。(以转义反斜杠结尾的字符串)(?<!\\)(?:\\\\)*'((?:\\.|[^\\'])*)'
对于单引号或双引号的字符串，您可以使用以下方法：
(?<!\\)(?:\\\\)*("|')((?:\\.|(?!\1)[^\\])*)\1
使用Python进行测试运行：
Doublas Leeder´s test cases:
"''" matched successfully: ""
" Example: 'Foo \' Bar' End. " matched successfully: "Foo \' Bar"
"'\''" matched successfully: "\'"
" Example2: 'Foo \\' End. " matched successfully: "Foo \\"
"not matched\''a'" matched successfully: "a"
"\''a'" matched successfully: "a"
cletus´ test cases:
"'testing 123'" matched successfully: "testing 123"
"'testing 123\\'" matched successfully: "testing 123\\"
"'testing 123" didn´t match, as exected.
"blah 'testing 123" didn´t match, as exected.
"blah 'testing 123'" matched successfully: "testing 123"
"blah 'testing 123' foo" matched successfully: "testing 123"
"this 'is a \' test'" matched successfully: "is a \' test"
"another \' test 'testing \' 123' \' blah" matched successfully: "testing \' 123"
MizardX´s test cases:
"test 'test \x3F test' test" matched successfully: "test \x3F test"
"test \\'test' test" matched successfully: "test"
"test 'test\\' test" matched successfully: "test\\"
(?<!\\)(?:\\\\)*表达式做得很好！ - ridgerunner如果我理解你的意思（我不确定），你想在字符串中查找引用的字符串，忽略转义的引号。是这样吗？如果是的话，请尝试以下方法：
/(?<!\\)'((?:\\'|[^'])*)(?<!\\)'/
基本上：
好的，我已在Java中进行了测试（抱歉这是我的强项而非Python，但原理相同）：
private final static String TESTS[] = {
"'testing 123'",
"'testing 123\\'",
"'testing 123",
"blah 'testing 123",
"blah 'testing 123'",
"blah 'testing 123' foo",
"this 'is a \\' test'",
"another \\' test 'testing \\' 123' \\' blah"
};
public static void main(String args[]) {
Pattern p = Pattern.compile("(?<!\\\\)'((?:\\\\'|[^'])*)(?<!\\\\)'");
for (String test : TESTS) {
Matcher m = p.matcher(test);
if (m.find()) {
System.out.printf("%s => %s%n", test, m.group(1));
} else {
System.out.printf("%s doesn't match%n", test);
}
}
}
结果：
'testing 123' => testing 123
'testing 123\' doesn't match
'testing 123 doesn't match
blah 'testing 123 doesn't match
blah 'testing 123' => testing 123
blah 'testing 123' foo => testing 123
this 'is a \' test' => is a \' test
another \' test 'testing \' 123' \' blah => testing \' 123
看起来是正确的。
使用 Python 的 re.findall() 函数和 cletus 的表达式:
re.findall(r"(?<!\\)'((?:\\'|[^'])*)(?<!\\)'", s)
在字符串中查找多个匹配项的测试：
>>> re.findall(r"(?<!\\)'((?:\\'|[^'])*)(?<!\\)'",
r"\''foo bar gazonk' foo 'bar' gazonk 'foo \'bar\' gazonk' 'gazonk bar foo\'")
['foo bar gazonk', 'bar', "foo \\'bar\\' gazonk"]
>>>
使用Cletus的TESTS字符串数组：
["%s => %s" % (s, re.findall(r"(?<!\\)'((?:\\'|[^'])*)(?<!\\)'", s)) for s in TESTS]
非常好用。（你可以自己试试，也可以相信我的话。）
>>> print re.findall(r"('([^'\\]|\\'|\\\\)*')",r""" Example: 'Foo \' Bar' End. """)[0][0]
'Foo \' Bar'