class QRegularExpression#

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

概述#

方法#

静态函数#

注意事项

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

详细描述#

警告

本节包含自动从C++转换为Python的片段，可能包含错误。

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

验证

正则表达式可以测试子字符串是否符合某些标准，例如是否为整数或不包含空白字符。

搜索

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

搜索和替换

正则表达式可以将所有子字符串的发生替换为另一个不同的子字符串，例如将所有发生的 & 替换为 &，除非 & 已被一个 amp; 所跟随。

字符串分割

正则表达式可以用来识别字符串应分隔的位置，例如分割制表符分隔的字符串。

本文档绝不是关于使用正则表达式进行模式匹配的完整参考，以下内容需要读者具备一定的Perl-like正则表达式及其模式语法的基础知识。

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

介绍#

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)

或者，您可以使用现有的 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 来检索整个模式匹配的子字符串（也请参阅有关 extract capturing substrings 的部分）

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

将模式字符串部分地匹配主题字符串。如果找到部分匹配，则停止匹配并报告部分匹配。在这种情况下，不尝试其他匹配替代方案（可能导致完整匹配）。此外，此匹配类型假定主题字符串是更大文本的子串，在该文本中，主题字符串之后还有其他字符。这可能导致意外的结果；有关更多信息，请参阅“partial matching”部分。

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

转换不会将模式解释为文件路径glob。

另请参阅

wildcardToRegularExpression

__init__(re)#
参数：

re – QRegularExpression

构造一个QRegularExpression对象，它是对re的复制。

另请参阅

operator=()

__init__(pattern[, options=QRegularExpression.PatternOption.NoPatternOption])
参数：

使用给定的 pattern 作为匹配模式以及将 options 作为模式选项来构造一个 QRegularExpression 对象。

__init__()

构建一个具有空模式和没有模式选项的 QRegularExpression 对象。

静态anchoredPattern(expression)#
参数：

expression – 字符串

返回类型：

字符串

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

静态anchoredPattern(expression)
参数：

expression – 字符串

返回类型：

字符串

这是一个重载函数。

captureCount()#
返回类型：

整数

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

注意事项

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

另请参阅

isValid()

errorString()#
返回类型：

字符串

返回在检查正则表达式有效性时找到的错误文本描述，如果没有找到错误则返回“无错误”。

静态escape(str)#
参数：

str – 字符串

返回类型：

字符串

警告

本节包含自动从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)
参数：

str – 字符串

返回类型：

字符串

这是一个重载函数。

static fromWildcard(pattern[, cs=Qt.CaseInsensitive[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion]])#
参数：
返回类型：

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]]])#
参数：
返回类型：

QRegularExpressionMatchIterator

这是一个重载函数。

请使用globalMatchView()代替。

globalMatch(subject[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
参数：
返回类型：

QRegularExpressionMatchIterator

尝试在给定的 subject 字符串中对正则表达式进行全局匹配，从主体内部的位置 offset 开始，使用 matchType 类型的匹配，并尊重给定的 matchOptions。

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

另请参阅

QRegularExpressionMatchIterator global matching

globalMatchView(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])#
参数：
返回类型：

QRegularExpressionMatchIterator

这是一个重载函数。

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

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

注意事项

被 subjectView 引用的数据必须保持有效，直到有 QRegularExpressionMatchIterator 或 QRegularExpressionMatch 对象使用它。

另请参阅

QRegularExpressionMatchIterator global matching

isValid()#
返回类型：

bool

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

match(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])#
参数：
返回类型：

QRegularExpressionMatch

这是一个重载函数。

建议使用 matchView()。

match(subject[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])
参数：
返回类型：

QRegularExpressionMatch

尝试将正则表达式与给定的 subject 字符串匹配，从主题中的位置 offset 开始，使用类型为 matchType 的匹配，并尊重给出的 matchOptions。

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

另请参阅

QRegularExpressionMatch normal matching

matchView(subjectView[, offset=0[, matchType=QRegularExpression.MatchType.NormalMatch[, matchOptions=QRegularExpression.MatchOption.NoMatchOption]]])#
参数：
返回类型：

QRegularExpressionMatch

这是一个重载函数。

尝试将正则表达式与给定的 subjectView 字符串文件匹配，从主题中的位置 offset 开始，使用类型为 matchType 的匹配，并尊重给出的 matchOptions。

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

注意事项

subjectView 所引用的数据必须保持有效，直到有 QRegularExpressionMatch 对象使用它。

另请参阅

QRegularExpressionMatch normal matching

namedCaptureGroups()#
返回类型：

字符串列表

警告

本节包含自动从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__(re)#
参数：

re – QRegularExpression

返回类型：

bool

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

另请参阅

operator==()

__eq__(re)#
参数：

re – QRegularExpression

返回类型：

bool

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

另请参阅

operator!=()

optimize()#

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

另请参阅

isValid() 调试使用 QRegularExpression 的代码

pattern()#
返回类型：

字符串

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

patternErrorOffset()#
返回类型：

整数

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

patternOptions()#
返回类型：

组合 PatternOption

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

setPattern(pattern)#
参数：

pattern – str

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

setPatternOptions(options)#
参数：

options – 由 PatternOption 组成的组合

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

swap(other)#
参数：

other – QRegularExpression

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

静态wildcardToRegularExpression(str[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion])#
参数：
返回类型：

字符串

警告

本节包含自动从C++转换为Python的片段，可能包含错误。

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

存在两种转换方式，一种针对文件路径通配符，另一种则较为通用。

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

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

更通用的全局匹配转换可以通过在转换选项中传递NonPathWildcardConversion来实现。

此实现密切遵循全局匹配模式通配符的定义。

c

任何字符表示自己，除了下面提到的一些。因此 c 匹配字符 c。

?

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

*

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

[abc]

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

[a-c]

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

[!abc]

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

[!a-c]

匹配括号内指定的范围之外的字符。这与完整正则表达式中的 [^a-c] 相同。

注意事项

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

关于实现的更多信息可以在以下链接中找到

默认情况下，返回的正则表达式是完全锚定的。换句话说，不需要再次调用anchoredPattern()。要获取非锚定的正则表达式，请将 UnanchoredWildcardConversion 放入转换选项中。

另请参阅

escape()

static wildcardToRegularExpression(str[, options=QRegularExpression.WildcardConversionOption.DefaultWildcardConversion])
参数：
返回类型：

字符串

这是一个重载函数。