PySide6.QtCore.QRegularExpression

class QRegularExpression

QRegularExpression 类提供了使用正则表达式进行模式匹配的功能。更多…

概要

方法

静态函数

注意

本文档可能包含从C++自动翻译到Python的代码片段。我们始终欢迎对代码片段翻译的贡献。如果您发现翻译问题，您也可以通过在我们的https:/bugreports.qt.io/projects/PYSIDE上创建工单来告知我们。

详细描述

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

正则表达式，或称为regexps，是处理字符串和文本的非常强大的工具。这在许多情况下都非常有用，例如，

验证

正则表达式可以测试子字符串是否满足某些条件，例如是否为整数或不包含空格。

搜索

正则表达式提供了比简单的子字符串匹配更强大的模式匹配功能，例如，匹配单词mail、letter或correspondence中的一个，但不匹配单词email、mailman、mailer、letterbox等。

搜索和替换

正则表达式可以用不同的子字符串替换所有出现的子字符串，例如，将所有出现的&替换为&，除非&后面已经跟着一个amp;。

字符串分割

可以使用正则表达式来识别字符串应该在何处分割，例如分割以制表符分隔的字符串。

本文档绝不是使用正则表达式进行模式匹配的完整参考，以下部分要求读者对类似Perl的正则表达式及其模式语法有一定的基本了解。

关于正则表达式的好参考资料包括：

介绍

QRegularExpression 实现了与Perl兼容的正则表达式。它完全支持Unicode。有关QRegularExpression支持的正则表达式语法的概述，请参阅前面提到的pcrepattern(3)手册页。正则表达式由两部分组成：一个模式字符串和一组改变模式字符串含义的模式选项。

你可以通过传递一个字符串给QRegularExpression构造函数来设置模式字符串：

re = QRegularExpression("a pattern")

这将模式字符串设置为a pattern。你也可以使用setPattern()函数在现有的QRegularExpression对象上设置模式：

re = QRegularExpression()
re.setPattern("another pattern")

请注意，由于C++字面字符串的规则，您必须在模式字符串中使用另一个反斜杠来转义所有反斜杠：

# matches two digits followed by a space and a word
re = QRegularExpression("\\d\\d \\w+")
# matches a backslash
re2 = QRegularExpression("\\\\")

或者，你可以使用原始字符串字面量，在这种情况下，你不需要在模式中转义反斜杠，R"(...)"之间的所有字符都被视为原始字符。正如你在以下示例中所看到的，这简化了模式的编写：

# matches two digits followed by a space and a word
re = QRegularExpression(R"(\d\d \w+)")

pattern() 函数返回当前为 QRegularExpression 对象设置的模式：

re = QRegularExpression("a third pattern")
pattern = re.pattern() # pattern == "a third pattern"

模式选项

模式字符串的含义可以通过设置一个或多个模式选项来修改。例如，可以通过设置CaseInsensitiveOption来使模式不区分大小写。

你可以通过将它们传递给QRegularExpression构造函数来设置选项，如下所示：

# matches "Qt rocks", but also "QT rocks", "QT ROCKS", "qT rOcKs", etc.
re = QRegularExpression("Qt rocks", QRegularExpression.CaseInsensitiveOption)

或者，您可以在现有的 QRegularExpressionObject 上使用 setPatternOptions() 函数：

re = QRegularExpression("^\\d+$")
re.setPatternOptions(QRegularExpression.MultilineOption)
# re matches any line in the subject string that contains only digits (but at least one)

可以通过使用patternOptions()函数来获取当前设置在QRegularExpression对象上的模式选项：

re = QRegularExpression("^two.words$", QRegularExpression.MultilineOption()
                                                           | QRegularExpression.DotMatchesEverythingOption)
QRegularExpression.PatternOptions options = re.patternOptions()
# options == QRegularExpression::MultilineOption | QRegularExpression::DotMatchesEverythingOption

请参考PatternOption枚举文档以获取有关每个模式选项的更多信息。

匹配类型和匹配选项

match() 和 globalMatch() 函数的最后两个参数设置了匹配类型和匹配选项。匹配类型是 MatchType 枚举的一个值；通过使用 NormalMatch 匹配类型（默认值）来选择“传统”匹配算法。还可以启用正则表达式对主题字符串的部分匹配：有关更多详细信息，请参阅 partial matching 部分。

匹配选项是一组一个或多个MatchOption值。它们改变了正则表达式与主题字符串的特定匹配方式。请参阅MatchOption枚举文档以获取更多详细信息。

正常匹配

为了执行匹配，您可以简单地调用match()函数，并传递一个字符串进行匹配。我们将这个字符串称为主题字符串。match()函数的结果是一个QRegularExpressionMatch对象，可用于检查匹配结果。例如：

# match two digits followed by a space and a word
re = QRegularExpression("\\d\\d \\w+")
match = re.match("abc123 def")
hasMatch = match.hasMatch() # true

如果匹配成功，可以使用（隐式的）捕获组编号0来检索整个模式匹配的子字符串（另请参阅关于提取 捕获 子字符串的部分）：

re = QRegularExpression("\\d\\d \\w+")
match = re.match("abc123 def")
if match.hasMatch():
    matched = match.captured(0) # matched == "23 def"
    # ...

也可以通过将偏移量作为match()函数的参数传递，从主题字符串内的任意偏移量开始匹配。在以下示例中，"12 abc" 没有匹配，因为匹配是从偏移量1开始的：

re = QRegularExpression("\\d\\d \\w+")
match = re.match("12 abc 45 def", 1)
if match.hasMatch():
    matched = match.captured(0) # matched == "45 def"
    # ...

提取捕获的子字符串

QRegularExpressionMatch 对象还包含有关模式字符串中捕获组捕获的子字符串的信息。captured() 函数将返回由第 n 个捕获组捕获的字符串：

re = QRegularExpression("^(\\d\\d)/(\\d\\d)/(\\d\\d\\d\\d)$")
match = re.match("08/12/1985")
if match.hasMatch():
    day = match.captured(1) # day == "08"
    month = match.captured(2) # month == "12"
    year = match.captured(3) # year == "1985"
    # ...

模式中的捕获组从1开始编号，隐式捕获组0用于捕获与整个模式匹配的子字符串。

也可以通过使用capturedStart()和capturedEnd()函数来检索每个捕获子字符串的起始和结束偏移量（在主题字符串内部）：

re = QRegularExpression("abc(\\d+)def")
match = re.match("XYZabc123defXYZ")
if match.hasMatch():
    startOffset = match.capturedStart(1) # startOffset == 6
    endOffset = match.capturedEnd(1) # endOffset == 9
    # ...

所有这些函数都有一个重载，接受一个QString作为参数，以便提取命名的捕获子字符串。例如：

re = QRegularExpression("^(?\\d\\d\\d\\d)$")
match = re.match("08/12/1985")
if match.hasMatch():
    date = match.captured("date") # date == "08"
    month = match.captured("month") # month == "12"
    year = match.captured("year") # year == 1985

全局匹配

全局匹配 对于在目标字符串中查找给定正则表达式的所有出现非常有用。假设我们想从给定的字符串中提取所有单词，其中单词是匹配模式 \w+ 的子字符串。

globalMatch 返回一个 QRegularExpressionMatchIterator，这是一个类似Java的前向迭代器，可用于遍历结果。例如：

re = QRegularExpression("(\\w+)")
i = re.globalMatch("the quick fox")

由于它是一个类似Java的迭代器，QRegularExpressionMatchIterator将立即指向第一个结果之前。每个结果都作为一个QRegularExpressionMatch对象返回。hasNext()函数将返回true，如果至少还有一个结果，而next()将返回下一个结果并推进迭代器。继续前面的例子：

words = QStringList()
while i.hasNext():
    match = i.next()
    word = match.captured(1)
    words << word

# words contains "the", "quick", "fox"

你也可以使用 peekNext() 来获取下一个结果而不推进迭代器。

也可以简单地在基于范围的for循环中使用globalMatch的结果，例如像这样：

# using a raw string literal, R"(raw_characters)", to be able to use "\w"
# without having to escape the backslash as "\\w"
re = QRegularExpression(R"(\w+)")
subject = QString("the quick fox")
for match in re.globalMatch(subject):
    # ...

可以向globalMatch()函数传递一个起始偏移量和一个或多个匹配选项，就像使用match()进行正常匹配一样。

部分匹配

当到达主题字符串的末尾时，会获得部分匹配，但需要更多字符才能成功完成匹配。请注意，部分匹配通常比正常匹配效率低得多，因为无法使用匹配算法的许多优化。

部分匹配必须通过在调用match或globalMatch时指定匹配类型为PartialPreferCompleteMatch或PartialPreferFirstMatch来明确请求。如果找到部分匹配，则在match()返回的QRegularExpressionMatch对象上调用hasMatch()函数将返回false，但hasPartialMatch()将返回true。

当找到部分匹配时，不会返回捕获的子字符串，并且对应于整个匹配的（隐式）捕获组0捕获主题字符串的部分匹配子字符串。

请注意，请求部分匹配仍然可能导致完全匹配，如果找到的话；在这种情况下，hasMatch() 将返回 true 而 hasPartialMatch() 将返回 false。一个 QRegularExpressionMatch 永远不会同时报告部分匹配和完全匹配。

部分匹配主要在两种场景下非常有用：实时验证用户输入和增量/多段匹配。

验证用户输入

假设我们希望用户以特定格式输入日期，例如“MMM dd, yyyy”。我们可以使用如下模式检查输入的有效性：

^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d\d?, \d\d\d\d$

（此模式不会捕获无效的日期，但为了示例的目的，我们保留它）。

我们希望在用户输入时使用这个正则表达式验证输入，以便我们可以在输入提交后立即报告错误（例如，用户输入了错误的键）。为了做到这一点，我们必须区分三种情况：

  • 输入不可能匹配正则表达式；

  • 输入内容与正则表达式匹配；

  • 当前输入与正则表达式不匹配，但如果添加更多字符，它将匹配。

请注意，这三种情况正好代表了QValidator的可能状态（参见QValidator::State枚举）。

特别是在最后一种情况下，我们希望正则表达式引擎报告一个部分匹配：我们成功地将模式与目标字符串匹配，但由于遇到目标字符串的结尾，匹配无法继续。然而，请注意，匹配算法应继续并尝试所有可能性，如果找到完整的（非部分）匹配，则应报告此匹配，并将输入字符串视为完全有效。

此行为由PartialPreferCompleteMatch匹配类型实现。例如：

pattern = QString("^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d\\d?, \\d\\d\\d\\d$")
re = QRegularExpression(pattern)
input = QString("Jan 21,")
match = re.match(input, 0, QRegularExpression.PartialPreferCompleteMatch)
hasMatch = match.hasMatch() # false
hasPartialMatch = match.hasPartialMatch() # true

如果对主题字符串匹配相同的正则表达式导致完全匹配，则按常规报告：

input = QString("Dec 8, 1985")
match = re.match(input, 0, QRegularExpression.PartialPreferCompleteMatch)
hasMatch = match.hasMatch() # true
hasPartialMatch = match.hasPartialMatch() # false

另一个具有不同模式的示例，展示了优先选择完全匹配而非部分匹配的行为：

re = QRegularExpression("abc\\w+X|def")
match = re.match("abcdef", 0, QRegularExpression.PartialPreferCompleteMatch)
hasMatch = match.hasMatch() # true
hasPartialMatch = match.hasPartialMatch() # false
captured = match.captured(0) # captured == "def"

在这种情况下，子模式 abc\\w+X 部分匹配了目标字符串；然而，子模式 def 完全匹配了目标字符串，因此报告了一个完全匹配。

如果在匹配时找到多个部分匹配（但没有完全匹配），那么QRegularExpressionMatch对象将报告找到的第一个匹配。例如：

re = QRegularExpression("abc\\w+X|defY")
match = re.match("abcdef", 0, QRegularExpression.PartialPreferCompleteMatch)
hasMatch = match.hasMatch() # false
hasPartialMatch = match.hasPartialMatch() # true
captured = match.captured(0) # captured == "abcdef"

增量/多段匹配

增量匹配是部分匹配的另一个用例。假设我们想在一个大文本中找到正则表达式的出现（即匹配正则表达式的子字符串）。为了做到这一点，我们希望将大文本分成较小的块“喂”给正则表达式引擎。显而易见的问题是，如果匹配正则表达式的子字符串跨越两个或更多块，会发生什么。

在这种情况下，正则表达式引擎应该报告一个部分匹配，这样我们就可以再次匹配添加新数据，并（最终）获得一个完整的匹配。这意味着正则表达式引擎可能会假设在主题字符串的末尾之后还有其他字符。这并不是字面意义上的——引擎永远不会尝试访问主题中最后一个字符之后的任何字符。

QRegularExpression 在使用 PartialPreferFirstMatch 匹配类型时实现了这种行为。这种匹配类型一旦找到部分匹配就会报告，并且不会尝试其他匹配选项（即使它们可能导致完全匹配）。例如：

re = QRegularExpression("abc|ab")
match = re.match("ab", 0, QRegularExpression.PartialPreferFirstMatch)
hasMatch = match.hasMatch() # false
hasPartialMatch = match.hasPartialMatch() # true

这是因为在匹配交替运算符的第一个分支时，找到了部分匹配，因此匹配停止，而没有尝试第二个分支。另一个例子：

re = QRegularExpression("abc(def)?")
match = re.match("abc", 0, QRegularExpression.PartialPreferFirstMatch)
hasMatch = match.hasMatch() # false
hasPartialMatch = match.hasPartialMatch() # true

这展示了量词可能看起来违反直觉的行为：由于?是贪婪的，引擎首先尝试在匹配"abc"后继续匹配；但随后匹配到达了目标字符串的末尾，因此报告了部分匹配。在以下示例中，这种情况更加令人惊讶：

re = QRegularExpression("(abc)*")
match = re.match("abc", 0, QRegularExpression.PartialPreferFirstMatch)
hasMatch = match.hasMatch() # false
hasPartialMatch = match.hasPartialMatch() # true

如果我们记住引擎期望主题字符串只是我们正在寻找匹配的整个文本的一个子字符串（也就是说，正如我们之前所说，引擎假设主题字符串的末尾还有其他字符），就很容易理解这种行为。

由于*量词是贪婪的，报告一个完整的匹配可能是一个错误，因为在当前主题"abc"之后可能还有其他"abc"的出现。例如，完整的文本可能是“abcabcX”，因此报告的正确匹配（在完整文本中）应该是"abcabc"；通过仅匹配开头的"abc"，我们反而得到了一个部分匹配。

错误处理

由于模式字符串中的语法错误，QRegularExpression 对象可能无效。如果正则表达式有效，isValid() 函数将返回 true，否则返回 false：

invalidRe = QRegularExpression("(unmatched|parenthesis")
isValid = invalidRe.isValid() # false

您可以通过调用errorString()函数获取有关特定错误的更多信息；此外，patternErrorOffset()函数将返回模式字符串内的偏移量

invalidRe = QRegularExpression("(unmatched|parenthesis")
if not invalidRe.isValid():
    errorString = invalidRe.errorString() # errorString == "missing )"
    errorOffset = invalidRe.patternErrorOffset() # errorOffset == 22
    # ...

如果尝试使用无效的QRegularExpression进行匹配，则返回的QRegularExpressionMatch对象也将是无效的（即其isValid()函数将返回false）。同样适用于尝试全局匹配。

不支持的Perl兼容正则表达式功能

QRegularExpression 不支持Perl兼容正则表达式中所有可用的功能。最显著的一点是不支持捕获组的重复名称，使用它们可能会导致未定义的行为。

这可能会在未来的Qt版本中发生变化。

调试使用QRegularExpression的代码

QRegularExpression 内部使用即时编译器（JIT）来优化匹配算法的执行。JIT 大量使用自修改代码，这可能导致调试工具如 Valgrind 崩溃。如果你想调试使用 QRegularExpression 的程序（例如，Valgrind 的 --smc-check 命令行选项），你必须启用所有自修改代码的检查。启用这些检查的缺点是程序运行速度会显著变慢。

为了避免这种情况，如果您在调试模式下编译Qt，JIT默认是禁用的。可以通过将QT_ENABLE_REGEXP_JIT环境变量分别设置为非零或零值来覆盖默认设置并启用或禁用JIT的使用（无论是在调试模式还是发布模式下）。

class PatternOption

(继承自 enum.Flag) PatternOption 枚举定义了模式字符串应如何解释的修饰符，从而决定了模式如何与目标字符串匹配。

常量

描述

QRegularExpression.NoPatternOption

未设置任何模式选项。

QRegularExpression.CaseInsensitiveOption

模式应以不区分大小写的方式匹配目标字符串。此选项对应于Perl正则表达式中的/i修饰符。

QRegularExpression.DotMatchesEverythingOption

模式字符串中的点元字符（.）被允许匹配目标字符串中的任何字符，包括换行符（通常，点不匹配换行符）。此选项对应于Perl正则表达式中的/s修饰符。

QRegularExpression.MultilineOption

模式字符串中的插入符号（^）和美元符号（$）元字符分别允许在目标字符串中的任何换行符之后和之前匹配，以及在目标字符串的最开始和最末尾匹配。此选项对应于Perl正则表达式中的/m修饰符。

QRegularExpression.ExtendedPatternSyntaxOption

模式字符串中未转义且不在字符类中的任何空白字符将被忽略。此外，字符类外未转义的井号（#）会导致其后的所有字符，直到第一个换行符（包括换行符），都被忽略。这可以用于提高模式字符串的可读性，并在正则表达式中添加注释；如果模式字符串是从文件加载的或由用户编写的，这将特别有用，因为在C++代码中，始终可以使用字符串字面量的规则将注释放在模式字符串之外。此选项对应于Perl正则表达式中的/x修饰符。

QRegularExpression.InvertedGreedinessOption

量词的贪婪性被反转：*, +, ?, {m,n}, 等变为懒惰的，而它们的懒惰版本（*?, +?, ??, {m,n}?, 等）变为贪婪的。在Perl正则表达式中没有与此选项等效的选项。

QRegularExpression.DontCaptureOption

未命名的捕获组不捕获子字符串；命名的捕获组仍然按预期工作，以及对应于整个匹配的隐式捕获组编号0。在Perl正则表达式中没有与此选项等效的选项。

QRegularExpression.UseUnicodePropertiesOption

\w、\d等字符类的含义，以及它们的对应项（\W、\D等）的含义，从仅匹配ASCII字符更改为匹配具有相应Unicode属性的任何字符。例如，\d更改为匹配具有Unicode Nd（十进制数字）属性的任何字符；\w更改为匹配具有Unicode L（字母）或N（数字）属性的任何字符，加上下划线，等等。此选项对应于Perl正则表达式中的/u修饰符。
class MatchType

MatchType 枚举定义了应该对主题字符串尝试的匹配类型。

常量

描述

QRegularExpression.NormalMatch

进行正常匹配。

QRegularExpression.PartialPreferCompleteMatch

模式字符串与主题字符串进行部分匹配。如果找到部分匹配，则记录下来，并像往常一样尝试其他匹配选项。如果随后找到完全匹配，则优先选择完全匹配；在这种情况下，只报告完全匹配。如果没有找到完全匹配（只有部分匹配），则报告部分匹配。

QRegularExpression.PartialPreferFirstMatch

模式字符串与目标字符串进行部分匹配。如果找到部分匹配，则匹配停止并报告部分匹配。在这种情况下，不会尝试其他匹配选项（可能导致完全匹配）。此外，此匹配类型假设目标字符串只是较大文本的子字符串，并且（在此文本中）目标字符串的末尾之后还有其他字符。这可能会导致令人惊讶的结果；有关更多详细信息，请参阅部分 匹配部分中的讨论。

QRegularExpression.NoMatch

未进行匹配。此值作为匹配类型由默认构造的QRegularExpressionMatch或QRegularExpressionMatchIterator返回。使用此匹配类型对用户来说并不十分有用，因为从未发生匹配。此枚举值在Qt 5.1中引入。
class MatchOption

常量

描述

QRegularExpression.NoMatchOption

(继承自 enum.Flag) 未设置匹配选项。

QRegularExpression.AnchoredMatchOption

请改用AnchorAtOffsetMatchOption。

QRegularExpression.AnchorAtOffsetMatchOption

匹配必须精确地从传递给match()的偏移量开始才能成功，即使模式字符串不包含任何在该点锚定匹配的元字符。请注意，传递此选项不会将匹配的结束锚定到主题的末尾；如果你想完全锚定一个正则表达式，请使用anchoredPattern()。此枚举值在Qt 6.0中引入。

QRegularExpression.DontCheckSubjectStringMatchOption

在尝试匹配之前，不会检查主题字符串的UTF-16有效性。请谨慎使用此选项，因为尝试匹配无效字符串可能会导致程序崩溃和/或构成安全问题。此枚举值已在Qt 5.4中引入。
class WildcardConversionOption

(继承自 enum.Flag) WildcardConversionOption 枚举定义了将通配符 glob 模式转换为正则表达式模式的方式的修饰符。

常量

描述

QRegularExpression.DefaultWildcardConversion

未设置任何转换选项。

QRegularExpression.UnanchoredWildcardConversion

转换将不会锚定模式。这允许对通配符表达式进行部分字符串匹配。

QRegularExpression.NonPathWildcardConversion

转换将不会将模式解释为文件路径通配符。

另请参阅

wildcardToRegularExpression

__init__()

构造一个QRegularExpression对象，该对象具有空模式且没有模式选项。

__init__(re)
Parameters:

re – QRegularExpression

构造一个QRegularExpression对象作为re的副本。

另请参阅

operator=()

__init__(pattern[, options=QRegularExpression.PatternOption.NoPatternOption])
Parameters:

使用给定的pattern作为模式和options作为模式选项构造一个QRegularExpression对象。

static anchoredPattern(expression)
Parameters:

expression – 字符串

Return type:

字符串

返回在\A和\z锚点之间包裹的expression，用于精确匹配。

static anchoredPattern(expression)
Parameters:

expression – 字符串

Return type:

字符串

这是一个重载函数。

captureCount()
Return type:

整数

返回模式字符串中的捕获组数量，如果正则表达式无效则返回-1。

注意

隐式捕获组0 不包含在返回的数字中。

另请参阅

isValid()

errorString()
Return type:

字符串

返回检查正则表达式有效性时发现的错误的文本描述，如果未发现错误则返回“无错误”。

static escape(str)
Parameters:

str – 字符串

Return type:

字符串

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

转义str中的所有字符，使它们在用作正则表达式模式字符串时不再具有任何特殊含义，并返回转义后的字符串。例如：

escaped = QRegularExpression.escape("a(x) = f(x) + g(x)")
# escaped == "a\\(x\\)\\ \\=\\ f\\(x\\)\\ \\+\\ g\\(x\\)"

这对于从任意字符串构建模式非常方便：

pattern = "(" + QRegularExpression.escape(name) +
                  "|" + QRegularExpression.escape(nickname) + ")"
re = QRegularExpression(pattern)

注意

此函数实现了Perl的quotemeta算法，并使用反斜杠转义str中的所有字符，除了[A-Z]、[a-z]和[0-9]范围内的字符以及下划线(_)字符。与Perl的唯一区别是，str中的字面NUL使用序列"\\0"（反斜杠+'0'）进行转义，而不是"\\\0"（反斜杠+NUL）。

static escape(str)
Parameters:

str – 字符串

Return type:

字符串

这是一个重载函数。

static fromWildcard(pattern[, cs=Qt.CaseInsensitive[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion]])
Parameters:
Return type:

QRegularExpression

返回一个与全局模式 pattern 对应的正则表达式。如果 cs 是 CaseSensitive，则正则表达式将区分大小写，并根据 options 进行转换。

等同于

auto reOptions = cs == Qt::CaseSensitive ? QRegularExpression::NoPatternOption :
                                           QRegularExpression::CaseInsensitiveOption;
return QRegularExpression(wildcardToRegularExpression(str, options), reOptions);
globalMatch(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatchIterator

注意

此函数已弃用。

这是一个重载函数。

请使用 globalMatchView() 代替。

globalMatch(subject[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatchIterator

尝试从主题字符串中的offset位置开始，使用matchType类型的匹配，并遵守给定的matchOptions，对正则表达式进行全局匹配。

返回的QRegularExpressionMatchIterator位于第一个匹配结果之前（如果有的话）。

另请参阅

QRegularExpressionMatchIterator 全局 匹配

globalMatchView(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatchIterator

这是一个重载函数。

尝试从主题中的位置 offset 开始，使用类型为 matchType 的匹配，并遵守给定的 matchOptions，对给定的 subjectView 字符串视图进行正则表达式的全局匹配。

返回的QRegularExpressionMatchIterator位于第一个匹配结果之前（如果有的话）。

注意

只要存在使用它的QRegularExpressionMatchIterator或QRegularExpressionMatch对象，subjectView所引用的数据就必须保持有效。

另请参阅

QRegularExpressionMatchIterator 全局 匹配

isValid()
Return type:

布尔

如果正则表达式是有效的正则表达式（即它不包含语法错误等），则返回true，否则返回false。使用errorString()获取错误的文本描述。

match(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatch

注意

此函数已弃用。

这是一个重载函数。

请使用matchView()代替。

match(subject[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatch

尝试将正则表达式与给定的subject字符串进行匹配，从subject内部的offset位置开始，使用matchType类型的匹配，并遵循给定的matchOptions。

返回的 QRegularExpressionMatch 对象包含匹配的结果。

另请参阅

QRegularExpressionMatch 正常 匹配

matchView(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
Parameters:
Return type:

QRegularExpressionMatch

这是一个重载函数。

尝试将正则表达式与给定的subjectView字符串视图进行匹配，从主题内的offset位置开始，使用matchType类型的匹配，并遵守给定的matchOptions。

返回的 QRegularExpressionMatch 对象包含匹配的结果。

注意

只要存在使用它的QRegularExpressionMatch对象，subjectView所引用的数据就必须保持有效。

另请参阅

QRegularExpressionMatch 正常 匹配

namedCaptureGroups()
Return type:

字符串列表

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回一个包含模式字符串中命名捕获组名称的列表，列表长度为captureCount() + 1。列表按顺序排列，使得列表中位置i的元素是第i个捕获组的名称，如果该捕获组有名称，否则为空字符串。

例如，给定正则表达式

(?<day>\d\d)-(?<month>\d\d)-(?<year>\d\d\d\d) (\w+) (?<name>\w+)

namedCaptureGroups() 将返回以下列表：

("", "day", "month", "year", "", "name")

这对应于捕获组#0（对应于整个匹配）没有名称，捕获组#1名称为“day”，捕获组#2名称为“month”等事实。

如果正则表达式无效，则返回一个空列表。

另请参阅

isValid() captured() isEmpty()

__ne__(rhs)
Parameters:

rhs – QRegularExpression

Return type:

布尔

如果 lhs 正则表达式与 rhs 不同，则返回 true，否则返回 false。

另请参阅

operator==()

__eq__(rhs)
Parameters:

rhs – QRegularExpression

Return type:

布尔

如果 lhs 正则表达式等于 rhs，则返回 true，否则返回 false。如果两个 QRegularExpression 对象具有相同的模式字符串和相同的模式选项，则它们是相等的。

另请参阅

operator!=()

optimize()

立即编译模式，包括JIT编译（如果启用了JIT）以进行优化。

另请参阅

isValid() 调试 使用 QRegularExpression 的代码

pattern()
Return type:

字符串

返回正则表达式的模式字符串。

patternErrorOffset()
Return type:

整数

返回在检查正则表达式的有效性时，在模式字符串中发现错误的偏移量。如果没有发现错误，则返回-1。

patternOptions()
Return type:

PatternOption的组合

返回正则表达式的模式选项。

setPattern(pattern)
Parameters:

pattern – str

将正则表达式的模式字符串设置为pattern。模式选项保持不变。

setPatternOptions(options)
Parameters:

options – PatternOption 的组合

将给定的options设置为正则表达式的模式选项。模式字符串保持不变。

swap(other)
Parameters:

其他 – QRegularExpression

将正则表达式 other 与此正则表达式交换。此操作非常快速且永远不会失败。

static wildcardToRegularExpression(str[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion])
Parameters:
Return type:

字符串

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回给定全局模式pattern的正则表达式表示。

有两种可能的转换，一种是针对文件路径通配的，另一种是更通用的。

默认情况下，转换针对文件路径的通配符匹配，这意味着路径分隔符会得到特殊处理。这意味着它不仅仅是从“*”到“.*”等的基本转换。

wildcard = QRegularExpression.wildcardToRegularExpression("*.jpeg")
# Will match files with names like:
#    foo.jpeg
#    f_o_o.jpeg
#    föö.jpeg

通过传递NonPathWildcardConversion在转换options中，可以使用更通用的通配符转换。

此实现严格遵循通配符在glob模式中的定义：

c

任何字符都代表其本身，除了下面提到的那些。因此，c 匹配字符 c。

?

匹配除路径分隔符之外的任何单个字符（如果已选择文件路径通配符）。它与完整正则表达式中的b{.}相同。

*

匹配零个或多个任意字符，除了路径分隔符（如果已选择文件路径通配符）。它与完整正则表达式中的.*相同。

[abc]

匹配括号中给出的一个字符。

[a-c]

匹配括号内给定范围中的一个字符。

[!abc]

匹配一个不在括号内给出的字符。这与完整正则表达式中的[^abc]相同。

[!a-c]

匹配一个不在括号内给定范围内的字符。它与完整正则表达式中的[^a-c]相同。

注意

由于历史原因，反斜杠（\）字符在此上下文中不是转义字符。为了匹配其中一个特殊字符，请将其放在方括号中（例如，[?]）。

有关实现的更多信息可以在以下位置找到：

默认情况下，返回的正则表达式是完全锚定的。换句话说，不需要再次在结果上调用anchoredPattern()。要获取未锚定的正则表达式，请在转换options中传递UnanchoredWildcardConversion。

另请参阅

escape()

static wildcardToRegularExpression(str[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion])
Parameters:
Return type:

字符串

这是一个重载函数。