正则表达式转义字符(正则表达式元字符)
本篇文章给大家谈谈正则表达式转义字符，以及正则表达式元字符对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。
在正则表达式中\\.和.有什么区别
一、作为Java的转义字符
1.在Java中，反斜杠（\）是一个特殊的字符，被称为转义字符，它的作用是用来转义后面一个字符。转义后的字符通常用于表示一个不可见的字符或具有特殊含义的字符，例如换行（\n）、回车符(\r)、制表符(\t)。
2.在Java中以下字符都有特殊意义，无法直接表示
单引号：char c='a';表示字符类型的数据时需要使用单引号将字符左右括起来。所以要表示字符'则需要使用\'
双引号：String str="abc";表示字符串类型的数据时需要使用双引号将字符串左右括起来。要表示字符串"则需要\"
反斜杠：String regex="你好\n\t阿";在Java代码中\表示转义字符，所以如果要表示字面意思的\，则需要使用\\
所以用反斜杠加上本身字符来进行表示。
二、在正则表达式中
2.1Java中正则表达式的\
\表示将下一字符标记为特殊字符。如\d表示数字字符匹配，等效于 [0-9]。\w表示匹配任何字类字符（字母数字下划线），注意包括下划线。与"[A-Za-z0-9_]"等效。
在其他语言中，\\表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。
在 Java中，\\表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
在 Java中，\\表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
在 Java中，\\表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
\\中的第一个\表示java的转义字符\由编译器解析，第二个\是正则表达式\由正则表达式引擎解析。
所以，在其他的语言中（如Perl），一个反斜杠\就足以具有转义的作用，而在 Java中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java的正则表达式中，两个\\代表其他语言中的一个\，这也就是为什么表示一位数字的正则表达式是\\d，而表示一个普通的反斜杠是\\\\。
所以Java正则表达式中匹配一个普通的反斜杠是\\\\。
所以如果在[]内表示一个]，要写两个\，即[\\]]。
例如，我要在前面不是0-9，也不是） ]}三个反括号的后面位置中，匹配-的后面是数字或者正括号( [{的-前面的位置，须写成:
(?<![0-9)}\\]])(?=-[0-9({\\[])。
若在该位置加0,可写成String s= str.replaceAll("(?<![0-9)}\\]])(?=-[0-9({\\[])","0");
2.2说明：
字符说明
^匹配输入字符串开始的位置。如果设置了 RegExp对象的 Multiline属性，^还会与"\n"或"\r"之后的位置匹配。
$匹配输入字符串结尾的位置。如果设置了 RegExp对象的 Multiline属性，$还会与"\n"或"\r"之前的位置匹配。
*零次或多次匹配前面的字符或子表达式。例如，zo*匹配"z"和"zoo"。*等效于{0,}。
+一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+等效于{1,}。
?零次或一次匹配前面的字符或子表达式。例如，"do(es)?“匹配"do"或"does"中的"do”。?等效于{0,1}。
{n} n是非负整数。正好匹配 n次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,} n是非负整数。至少匹配 n次。例如，"o{2,}“不匹配"Bob"中的"o”，而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。"o{0,}“等效于"o*”。
{n,m} m和 n是非负整数，其中 n<= m。匹配至少 n次，至多 m次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。‘o{0,1}’等效于‘o?’。注意：您不能将空格插入逗号和数字之间。
x y
[xyz]字符集。匹配包含的任一字符。例如，"[abc]“匹配"plain"中的"a”。
[ ^xyz]反向字符集。匹配未包含的任何字符。例如，"[^abc]“匹配"plain"中"p”，“l”，“i”，“n”。
[a-z]字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
\d数字字符匹配。等效于 [0-9]。
\D非数字字符匹配。等效于 [ ^0-9]。
\w匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\W与任何非单词字符匹配。与"[ ^A-Za-z0-9_]"等效。
2.3Java正则表达式的使用方法
使用正则表达式需要引入 java.util.regex包，我们就从这里入手讲解：
java.util.regex
java.util.regex包主要包括以下三个类：
Pattern类：
pattern对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个 Pattern对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数。
Matcher类：
Matcher对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用 Pattern对象的 matcher方法来获得一个 Matcher对象。
matches方法
PatternSyntaxException：
PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误
Python正则表达式中特殊字符的转义:以|为例
在Python正则表达式中，特殊字符|需通过反斜杠转义为|以匹配其字面量，否则会被解释为逻辑“或”操作符，导致意外匹配结果。
1.|的默认行为与问题逻辑“或”操作符：在正则表达式中，|默认表示匹配左侧或右侧的子模式。例如，apple|banana会匹配"apple"或"banana"。当模式仅为|时，它会被解释为匹配空字符串或空字符串，即任何字符串的任意位置（包括空字符串本身）。
示例代码：import rere.search('|','e')#匹配成功，因为空字符串存在于任何位置
2.匹配字面量|的转义方法使用反斜杠转义：若需匹配|本身而非逻辑“或”，需在|前添加反斜杠，即|。示例修正代码：import pandas as pdimport numpy as npimport redf_test= pd.DataFrame(np.array([['a|b','b','c|r'], ['e','f','g']]), columns=['First','Second','Third'])print("原始DataFrame:")print(df_test)print("使用转义后的'|'进行搜索的输出:")for elem in df_test.get('First'): x= bool(re.search(r'|', elem))#正确转义 if x: print(elem)
输出结果：原始DataFrame: First Second Third0 a|b b c|r1 e f g使用转义后的'|'进行搜索的输出:a|b
关键点：使用原始字符串r'|'避免Python字符串转义冲突（如|需双重转义）。
转义后仅匹配包含字面量|的字符串（如'a|b'），排除'e'等无关结果。
3.其他常见需转义的特殊字符正则表达式中以下元字符需转义以匹配字面值：
.→.（匹配任意字符，除换行符）^→ ^（匹配字符串开头）$→$（匹配字符串结尾）*→*（匹配前一个字符零次或多次）+→+（匹配前一个字符一次或多次）?→?（匹配前一个字符零次或一次）{}→{}（指定匹配次数）[]→ []（字符集）()→()（分组）→（转义字符本身）4.实用技巧与注意事项原始字符串（Raw Strings）：建议使用r'pattern'形式编写正则表达式，避免Python字符串转义规则干扰。例如：
pattern= r'|'#正确#非原始字符串需双重转义：pattern='|'#可读性差动态正则表达式的安全转义：若模式包含用户输入或不确定内容，使用re.escape()自动转义所有特殊字符：
import reuser_input="file.txt|backup"escaped_input= re.escape(user_input)#输出:'file.txt|backup'5.总结核心原则：匹配元字符字面值时，必须用转义（如|）。代码健壮性：结合原始字符串和re.escape()，可避免转义冲突并防御恶意输入。应用场景：精确匹配包含特殊字符的文本（如日志分析、数据清洗），确保模式匹配的准确性。掌握这些方法后，可高效处理正则表达式中的特殊字符，避免常见陷阱。
求一去乱码、汉字的正则表达式
\p{ASCII}
正则表达式的构造摘要
构造匹配
字符
x字符 x
\\反斜线字符
\0n带有八进制值 0的字符 n(0<= n<= 7)
\0nn带有八进制值 0的字符 nn(0<= n<= 7)
\0mnn带有八进制值 0的字符 mnn（0<= m<= 3、0<= n<= 7）
\xhh带有十六进制值 0x的字符 hh
\uhhhh带有十六进制值 0x的字符 hhhh
\t制表符('\u0009')
\n新行（换行）符('\u000A')
\r回车符('\u000D')
\f换页符('\u000C')
\a报警(bell)符('\u0007')
\e转义符('\u001B')
\cx对应于 x的控制符
字符类
[abc] a、b或 c（简单类）
[^abc]任何字符，除了 a、b或 c（否定）
[a-zA-Z] a到 z或 A到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a到 d或 m到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e或 f（交集）
[a-z&&[^bc]] a到 z，除了 b和 c：[ad-z]（减去）
[a-z&&[^m-p]] a到 z，而非 m到 p：[a-lq-z]（减去）
预定义字符类
.任何字符（与行结束符可能匹配也可能不匹配）
\d数字：[0-9]
\D非数字： [^0-9]
\s空白字符：[\t\n\x0B\f\r]
\S非空白字符：[^\s]
\w单词字符：[a-zA-Z_0-9]
\W非单词字符：[^\w]
POSIX字符类（仅 US-ASCII）
\p{Lower}小写字母字符：[a-z]
\p{Upper}大写字母字符：[A-Z]
\p{ASCII}所有 ASCII：[\x00-\x7F]
\p{Alpha}字母字符：[\p{Lower}\p{Upper}]
\p{Digit}十进制数字：[0-9]
\p{Alnum}字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}可见字符：[\p{Alnum}\p{Punct}]
\p{Print}可打印字符：[\p{Graph}\x20]
\p{Blank}空格或制表符：[\t]
\p{Cntrl}控制字符：[\x00-\x1F\x7F]
\p{XDigit}十六进制数字：[0-9a-fA-F]
\p{Space}空白字符：[\t\n\x0B\f\r]
java.lang.Character类（简单的 java字符类型）
\p{javaLowerCase}等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}等效于 java.lang.Character.isMirrored()
Unicode块和类别的类
\p{InGreek} Greek块（简单块）中的字符
\p{Lu}大写字母（简单类别）
\p{Sc}货币符号
\P{InGreek}所有字符，Greek块中的除外（否定）
[\p{L}&&[^\p{Lu}]]所有字母，大写字母除外（减去）
边界匹配器
^行的开头
$行的结尾
\b单词边界
\B非单词边界
\A输入的开头
\G上一个匹配的结尾
\Z输入的结尾，仅用于最后的结束符（如果有的话）
\z输入的结尾
Greedy数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n次
X{n,} X，至少 n次
X{n,m} X，至少 n次，但是不超过 m次
Reluctant数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n次
X{n,}? X，至少 n次
X{n,m}? X，至少 n次，但是不超过 m次
Possessive数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n次
X{n,}+ X，至少 n次
X{n,m}+ X，至少 n次，但是不超过 m次
Logical运算符
XY X后跟 Y
X|Y X或 Y
(X) X，作为捕获组
Back引用
\n任何匹配的 nth捕获组
引用
\ Nothing，但是引用以下字符
\Q Nothing，但是引用所有字符，直到\E
\E Nothing，但是结束从\Q开始的引用
特殊构造（非捕获）
(?:X) X，作为非捕获组
(?idmsux-idmsux) Nothing，但是将匹配标志由 on转为 off
(?idmsux-idmsux:X) X，作为带有给定标志 on- off的非捕获组
(?=X) X，通过零宽度的正 lookahead
(?!X) X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组
--------------------------------------------------------------------------------
反斜线、转义和引用
反斜线字符('\')用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式\\与单个反斜线匹配，而\{与左括号匹配。
在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。
根据 Java Language Specification的要求，Java源代码的字符串中的反斜线被解释为 Unicode转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java字节码编译器解释。例如，当解释为正则表达式时，字符串字面值"\b"与单个退格字符匹配，而"\\b"与单词边界匹配。字符串字面值"\(hello\)"是非法的，将导致编译时错误；要与字符串(hello)匹配，必须使用字符串字面值"\\(hello\\)"。
字符类
字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符(&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。
字符类运算符的优先级如下所示，按从最高到最低的顺序排列：
1字面值转义\x
2分组 [...]
3范围 a-z
4并集 [a-e][i-u]
5交集 [a-z&&[aeiou]]
注意，元字符的不同集合实际上位于字符类的内部，而非字符类的外部。例如，正则表达式.在字符类内部就失去了其特殊意义，而表达式-变成了形成元字符的范围。
行结束符
行结束符是一个或两个字符的序列，标记输入字符序列的行结尾。以下代码被识别为行结束符：
新行（换行）符('\n')、
后面紧跟新行符的回车符("\r\n")、
单独的回车符('\r')、
下一行字符('\u0085')、
行分隔符('\u2028')或
段落分隔符('\u2029)。
如果激活 UNIX_LINES模式，则新行符是惟一识别的行结束符。
如果未指定 DOTALL标志，则正则表达式.可以与任何字符（行结束符除外）匹配。
默认情况下，正则表达式 ^和$忽略行结束符，仅分别与整个输入序列的开头和结尾匹配。如果激活 MULTILINE模式，则 ^在输入的开头和行结束符之后（输入的结尾）才发生匹配。处于 MULTILINE模式中时，$仅在行结束符之前或输入序列的结尾处匹配。
组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C)))中，存在四个这样的组：
1((A)(B(C)))
2\A
3(B(C))
4(C)
组零始终代表整个表达式。
之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back引用在表达式中使用，也可以在匹配操作完成后从匹配器检索。
与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串"aba"与表达式(a(b)?)+相匹配，会将第二组设置为"b"。在每个匹配的开头，所有捕获的输入都会被丢弃。
以(?)开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。
关于正则表达式转义字符到此分享完毕，希望能帮助到您。