Python3 如何优雅地使用正则表达式
Python系列之正则表达式详解
Python系列之正则表达式详解Python 正则表达式模块 (re) 简介Python 的 re 模块（Regular Expression 正则表达式）提供各种正则表达式的匹配操作，和 Perl 脚本的正则表达式功能类似，使⽤这⼀内嵌于 Python 的语⾔⼯具，尽管不能满⾜所有复杂的匹配情况，但⾜够在绝⼤多数情况下能够有效地实现对复杂字符串的分析并提取出相关信息。
Python 会将正则表达式转化为字节码，利⽤ C 语⾔的匹配引擎进⾏深度优先的匹配。
表 1. 正则表达式元字符和语法符号说明实例.表⽰任意字符，如果说指定了 DOTALL 的标识，就表⽰包括新⾏在内的所有字符。
'abc' >>>'a.c' >>>结果为:'abc'^表⽰字符串开头。
'abc' >>>'^abc' >>>结果为:'abc'$表⽰字符串结尾。
'abc' >>>'abc$' >>>结果为:'abc'*, +, ?'*'表⽰匹配前⼀个字符重复 0 次到⽆限次，'+'表⽰匹配前⼀个字符重复 1次到⽆限次，'?'表⽰匹配前⼀个字符重复 0 次到1次'abcccd' >>>'abc*' >>>结果为:'abccc''abcccd' >>>'abc+' >>>结果为:'abccc''abcccd' >>>'abc?' >>>结果为:'abc'*?, +?, ??前⾯的*,+,?等都是贪婪匹配，也就是尽可能多匹配，后⾯加?号使其变成惰性匹配即⾮贪婪匹配'abc' >>>'abc*?' >>>结果为:'ab''abc' >>>'abc??' >>>结果为:'ab''abc' >>>'abc+?' >>>结果为:'abc'{m}匹配前⼀个字符 m 次'abcccd' >>>'abc{3}d' >>>结果为:'abcccd' {m,n}匹配前⼀个字符 m 到 n 次'abcccd' >>> 'abc{2,3}d' >>>结果为:'abcccd' {m,n}?匹配前⼀个字符 m 到 n 次，并且取尽可能少的情况'abccc' >>> 'abc{2,3}?' >>>结果为:'abcc'\对特殊字符进⾏转义，或者是指定特殊序列 'a.c' >>>'a\.c' >>> 结果为: 'a.c'[]表⽰⼀个字符集,所有特殊字符在其都失去特殊意义,只有： ^ - ] \ 含有特殊含义'abcd' >>>'a[bc]' >>>结果为:'ab'|或者，只匹配其中⼀个表达式，如果|没有被包括在()中，则它的范围是整个正则表达式'abcd' >>>'abc|acd' >>>结果为:'abc' ( … )被括起来的表达式作为⼀个分组. findall 在有组的情况下只显⽰组的内容 'a123d' >>>'a(123)d' >>>结果为:'123'(?#...)注释，忽略括号内的内容特殊构建不作为分组 'abc123' >>>'abc(?#fasd)123' >>>结果为:'abc123'(?= …)表达式’…’之前的字符串，特殊构建不作为分组在字符串’ pythonretest ’中 (?=test) 会匹配’pythonre ’(?!...)后⾯不跟表达式’…’的字符串，特殊构建不作为分组如果’ pythonre ’后⾯不是字符串’ test ’，那么(?!test) 会匹配’ pythonre ’(?<=… )跟在表达式’…’后⾯的字符串符合括号之后的正则表达式，特殊构建不作为分组正则表达式’ (?<=abc)def ’会在’ abcdef ’中匹配’def ’（?:）取消优先打印分组的内容'abc' >>>'(?:a)(b)' >>>结果为'[b]'?P<>指定Key'abc' >>>'(?P<n1>a)>>>结果为:groupdict{n1:a}表 2. 正则表达式特殊序列特殊表达式序列说明\A只在字符串开头进⾏匹配。
python正则表达式详解
python正则表达式详解python 正则表达式详解1. 正则表达式模式模式描述^匹配字符串的开头$匹配字符串的末尾。
.匹配任意字符，除了换⾏符，当re.DOTALL标记被指定时，则可以匹配包括换⾏符的任意字符。
[...]⽤来表⽰⼀组字符,单独列出：[amk] 匹配 'a'，'m'或'k'[^...]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*匹配0个或多个的表达式。
re+匹配1个或多个的表达式。
re?匹配0个或1个由前⾯的正则表达式定义的⽚段，⾮贪婪⽅式re{ n}匹配n个前⾯表达式。
例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
re{ n,}精确匹配n个前⾯表达式。
例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。
"o{1,}"等价于"o+"。
"o{0,}"则等价于"o*"。
re{ n,m}匹配 n 到 m 次由前⾯的正则表达式定义的⽚段，贪婪⽅式a| b匹配a或b(re)匹配括号内的表达式，也表⽰⼀个组(?imx)正则表达式包含三种可选标志：i, m, 或 x 。
只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。
只影响括号中的区域。
(?: re)类似 (...), 但是不表⽰⼀个组(?imx:re)在括号中使⽤i, m, 或 x 可选标志(?-imx:re)在括号中不使⽤i, m, 或 x 可选标志(?#...)注释.(?= re)前向肯定界定符。
如果所含正则表达式，以 ... 表⽰，在当前位置成功匹配时成功，否则失败。
python正则表达式或的用法
正则表达式是一种用来描述字符串匹配模式的语法，它可以用来检查一个字符串是否符合某种规则，或者从一个字符串中提取出符合条件的子串。
Python 中提供了 re 模块来支持正则表达式的使用。
re 模块中有一些常用的函数和方法，例如：•pile(pattern, flags=0)：根据给定的模式字符串和可选的标志参数，编译一个正则表达式对象，该对象可以用来进行匹配、搜索、替换等操作。
•re.match(pattern, string, flags=0)：尝试从字符串的起始位置匹配一个模式，如果成功，返回一个匹配对象，否则返回None。
匹配对象有一些方法和属性，例如group()返回匹配的字符串，span()返回匹配的位置等。
•re.search(pattern, string, flags=0)：扫描整个字符串并返回第一个成功的匹配对象，如果没有匹配，返回 None。
•re.findall(pattern, string, flags=0)：返回一个列表，包含字符串中所有匹配模式的子串。
•re.finditer(pattern, string, flags=0)：返回一个迭代器，每次迭代返回一个匹配对象。
•re.sub(pattern, repl, string, count=0, flags=0)：使用 repl 替换字符串中所有匹配模式的子串，返回替换后的字符串。
如果指定了 count 参数，只替换前 count 次匹配。
•re.split(pattern, string, maxsplit=0, flags=0)：根据模式分割字符串，返回一个列表。
如果指定了 maxsplit 参数，最多分割maxsplit 次。
re 模块中还有一些常量，用来表示一些匹配模式的标志，例如：•re.I或re.IGNORECASE：忽略大小写•re.S或re.DOTALL：使 . 匹配包括换行符在内的所有字符•re.M或re.MULTILINE：多行模式，影响 ^ 和 $ 的行为•re.X或re.VERBOSE：详细模式，允许在正则表达式中添加注释要使用正则表达式，首先要了解正则表达式的语法规则，例如：•. 匹配任意单个字符（除了换行符）•[ ] 匹配方括号中出现的任意字符•[^ ] 匹配方括号中未出现的任意字符•o匹配前一个字符出现零次或多次•o匹配前一个字符出现一次或多次•匹配前一个字符出现零次或一次•{m} 匹配前一个字符出现 m 次•{m,n} 匹配前一个字符出现 m 到 n 次•^ 匹配字符串开头或行开头（多行模式下）•$ 匹配字符串结尾或行结尾（多行模式下）•\b 匹配单词边界•\w 匹配字母、数字或下划线•\d 匹配数字•\s 匹配空白字符下面是一个使用正则表达式来验证邮箱地址是否合法的 Python 代码示例：import redef is_valid_email(email):# 定义邮箱地址的正则表达式pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$' # 使用 re.match 方法进行匹配match = re.match(pattern, email)# 如果匹配成功，返回 True；否则返回 Falsereturn bool(match)# 测试代码emails=['***************','***********','test@.com','abc@123'] for email in emails:print(email, is_valid_email(email))输出结果为：**********************************test@.com Falseabc@123 False。
python 匹配正则
python 匹配正则正则表达式是一种强大的文本匹配工具，Python中也提供了re 模块来支持正则表达式的使用。
本文将通过一些简单的例子来介绍Python中如何使用正则表达式进行匹配。
1.基础正则表达式正则表达式的基本语法如下：. 匹配任意单个字符d 匹配数字，相当于[0-9]w 匹配字母、数字、下划线，相当于[A-Za-z0-9_]s 匹配空格、制表符、换行符等空白字符[] 匹配括号中的任意一个字符| 匹配左右两边的任意一个表达式() 分组，可以用于后续的引用例如：import re# 匹配以a开头的字符串result = re.match('a', 'abc')print(result.group()) # a# 匹配数字result = re.match('d', '123')print(result.group()) # 1# 匹配字母、数字、下划线result = re.match('w', 'a_1')print(result.group()) # a# 匹配空白字符result = re.match('s', ' a')print(result.group()) # (一个空格)2.量词量词用于控制匹配的次数，常见的量词包括： * 匹配前面的字符0次或多次+ 匹配前面的字符1次或多次匹配前面的字符0次或1次{n} 匹配前面的字符恰好n次{n,} 匹配前面的字符至少n次{n,m} 匹配前面的字符至少n次，至多m次例如：import re# 匹配a出现0次或多次result = re.match('a*', 'aaabbb')print(result.group()) # aaa# 匹配a出现1次或多次result = re.match('a+', 'aaabbb')print(result.group()) # aaa# 匹配a出现0次或1次result = re.match('a?', 'aaabbb')print(result.group()) # a# 匹配a出现3次result = re.match('a{3}', 'aaabbb')print(result.group()) # aaa# 匹配a出现至少2次result = re.match('a{2,}', 'aaabbb')print(result.group()) # aaa# 匹配a出现至少1次，至多3次result = re.match('a{1,3}', 'aaabbb')print(result.group()) # aaa3.字符集字符集用于匹配一组字符中的任意一个，常见的字符集包括： [abc] 匹配a、b、c中的任意一个字符[a-z] 匹配a到z中的任意一个小写字母[A-Z] 匹配A到Z中的任意一个大写字母[0-9] 匹配0到9中的任意一个数字[^a] 匹配除了a以外的任意一个字符例如：import re# 匹配a、b、c中的任意一个字符result = re.match('[abc]', 'b')print(result.group()) # b# 匹配a到z中的任意一个小写字母result = re.match('[a-z]', 'c')print(result.group()) # c# 匹配A到Z中的任意一个大写字母result = re.match('[A-Z]', 'C')print(result.group()) # C# 匹配0到9中的任意一个数字result = re.match('[0-9]', '7')print(result.group()) # 7# 匹配除了a以外的任意一个字符result = re.match('[^a]', 'b')print(result.group()) # b4.特殊字符特殊字符用于匹配一些特殊的字符，常见的特殊字符包括：匹配转义字符，例如匹配点号.可以使用.^ 匹配字符串的开头$ 匹配字符串的结尾b 匹配单词边界B 匹配非单词边界例如：import re# 匹配转义字符，例如匹配点号可以使用.result = re.match('a.b', 'a.b')print(result.group()) # a.b# 匹配字符串的开头result = re.match('^abc', 'abcdef')print(result.group()) # abc# 匹配字符串的结尾result = re.match('abc$', 'defabc')print(result.group()) # abc# 匹配单词边界result = re.findall(r'btheb', 'the cat in the hat')print(result) # ['the', 'the']# 匹配非单词边界result = re.findall(r'BtheB', 'themethecatinthehat') print(result) # ['the', 'the']以上就是Python中使用正则表达式进行匹配的基础知识，希望对大家有所帮助。
python正则表达式详解
python正则表达式详解Python正则表达式详解正则表达式是一种强大的文本处理工具，它可以用来匹配、查找、替换文本中的特定模式。
在Python中，正则表达式是通过re模块来实现的。
本文将详细介绍Python中正则表达式的使用方法。
一、基本语法正则表达式是由一些特殊字符和普通字符组成的字符串。
其中，特殊字符用来表示一些特定的模式，普通字符则表示普通的文本。
下面是一些常用的正则表达式特殊字符：1. ^：匹配字符串的开头。
2. $：匹配字符串的结尾。
3. .：匹配任意一个字符。
4. *：匹配前面的字符出现0次或多次。
5. +：匹配前面的字符出现1次或多次。
6. ?：匹配前面的字符出现0次或1次。
7. []：匹配方括号中的任意一个字符。
8. [^]：匹配不在方括号中的任意一个字符。
9. ()：将括号中的内容作为一个整体进行匹配。
10. |：匹配左右两边任意一个表达式。
二、常用函数Python中re模块提供了一些常用的函数来操作正则表达式，下面是一些常用的函数：1. re.match(pattern, string, flags=0)：从字符串的开头开始匹配，如果匹配成功则返回一个匹配对象，否则返回None。
2. re.search(pattern, string, flags=0)：在字符串中查找第一个匹配成功的子串，如果匹配成功则返回一个匹配对象，否则返回None。
3. re.findall(pattern, string, flags=0)：在字符串中查找所有匹配成功的子串，返回一个列表。
4. re.sub(pattern, repl, string, count=0, flags=0)：将字符串中所有匹配成功的子串替换为repl，返回替换后的字符串。
三、实例演示下面是一些实例演示，展示了正则表达式的使用方法：1. 匹配邮箱地址import reemail='*************'pattern = r'\w+@\w+\.\w+' result = re.match(pattern, email) if result:print(result.group())else:print('匹配失败')2. 匹配手机号码import rephone='138****5678' pattern = r'^1[3-9]\d{9}$' result = re.match(pattern, phone) if result:print(result.group())else:print('匹配失败')3. 查找所有数字import retext = 'abc123def456ghi789' pattern = r'\d+'result = re.findall(pattern, text)print(result)4. 替换字符串中的空格import retext = 'hello world'pattern = r'\s+'result = re.sub(pattern, '-', text)print(result)四、总结本文介绍了Python中正则表达式的基本语法和常用函数，并通过实例演示展示了正则表达式的使用方法。
python3正则模块re的使用方法详解
python3正则模块re的使⽤⽅法详解⼀、正则1.正则表达式定义正则就是⽤⼀些具有特殊含义的符号组合到⼀起（称为正则表达式）来描述字符或者字符串的⽅法。
或者说：正则就是⽤来描述⼀类事物的规则。
（在Python中）它内嵌在Python中，并通过 re 模块实现。
正则表达式模式被编译成⼀系列的字节码，然后由⽤ C 编写的匹配引擎执⾏。
2.⽬的和特点给定⼀个正则表达式和另⼀个字符串，我们可以达到如下的⽬的：给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）：可以通过正则表达式，从字符串中获取我们想要的特定部分。
正则表达式的特点是：灵活性、逻辑性和功能性⾮常强；可以迅速地⽤极简单的⽅式达到字符串的复杂控制。
由于正则表达式主要应⽤对象是⽂本，因此它在各种⽂本编辑器场合都有应⽤，⼩到著名编辑器EditPlus，⼤到Microsoft Word、Visual Studio等⼤型编辑器，都可以使⽤正则表达式来处理⽂本内容。
3.常⽤的正则表达式4.贪婪模式与⾮贪婪模式正则表达式通常⽤于在⽂本中查找匹配的字符串。
Python⾥数量词默认是贪婪的（在少数语⾔⾥也可能是默认⾮贪婪），总是尝试匹配尽可能多的字符；⾮贪婪的则相反，总是尝试匹配尽可能少的字符。
例如：正则表达式"ab*“如果⽤于查找"abbbc”，将找到"abbb"。
⽽如果使⽤⾮贪婪的数量词"ab*?"，将找到"a"。
5.反斜杠与⼤多数编程语⾔相同，正则表达式⾥使⽤"“作为转义字符，这就可能造成反斜杠困扰。
假如你需要匹配⽂本中的字符”"，那么使⽤编程语⾔表⽰的正则表达式⾥将需要4个反斜杠"\\"：前两个和后两个分别⽤于在编程语⾔⾥转义成反斜杠，转换成两个反斜杠后再在正则表达式⾥转义成⼀个反斜杠。
Python⾥的原⽣字符串很好地解决了这个问题，这个例⼦中的正则表达式可以使⽤r"\“表⽰。
python正则或的用法
Python正则或的用法Python是一种功能强大的编程语言，其内置了正则表达式（regular expressions）模块，可以帮助我们在文本中查找、匹配和操作字符串。
其中一项常用的功能是使用正则表达式进行或操作。
本文将介绍如何在Python中使用正则表达式实现或操作。
正则表达式是一种强大的字符串匹配工具，它可以用于查找和操作符合特定模式的字符串。
在Python中，我们可以使用re模块来使用正则表达式。
要使用正则表达式进行或操作，我们需要使用竖杠（|）将多个模式进行分隔。
下面是一个简单的示例，演示如何在Python中使用正则表达式实现或操作：1导入re模块：import re2定义正则表达式模式：pattern = r"apple|banana|orange"在这个示例中，我们使用竖杠将三个水果名称分隔开来，表示我们要查找的字符串可以是"apple"、"banana"或"orange"中的任意一个。
3使用re模块的search函数进行匹配：match = re.search(pattern, text)在这个示例中，我们假设text是一个包含水果名称的字符串。
search函数用于在字符串中查找与模式匹配的内容。
4检查匹配结果：if match:print("Found a match: ", match.group())else:print("No match found.")如果匹配成功，我们可以通过match.group()方法获取匹配到的内容；否则，打印未找到匹配的提示信息。
通过以上步骤，我们可以使用正则表达式实现在文本中搜索多个模式的功能。
以上示例只是一个简单的演示，实际应用中的正则表达式可能会更复杂和具体。
值得注意的是，正则表达式是一种强大而灵活的工具，但也需要一定的学习和实践。
python3 解析数学表达式
python3 解析数学表达式
"Python3 解析数学表达式" 指的是使用 Python 3 语言来解析和计算数学表达式。
这通常涉及到使用特定的库或工具来解析字符串形式的数学表达式，并返回计算结果。
以下是一些与 Python 3 解析数学表达式相关的内容：
1.SymPy: SymPy 是一个 Python 库，用于进行符号数学的计算，包括解析
数学表达式。
2.eval() 函数: Python 的内置eval()函数可以用来解析并计算字符串形式的
数学表达式。
例如：result = eval("2 + 3 × 4")。
3.使用正则表达式: 通过正则表达式，可以解析简单的数学表达式，例如只包
含加减乘除的表达式。
4.解析复杂数学公式: 对于更复杂的数学公式，可能需要使用专门的解析器或
编译器来正确解析和计算。
总结："Python3 解析数学表达式" 是指使用 Python 3 来解析和计算字符串形式的数学表达式。
这通常涉及到使用特定的库或工具，如SymPy 或内置的eval()函数，来处理数学表达式的字符串形式，并返回计算结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
正则表达式（Regular expressions 也称为REs，或regexes 或regex patterns）本质上是一个微小的且高度专业化的编程语言。
它被嵌入到Python 中，并通过re 模块提供给程序猿使用。
使用正则表达式，你需要指定一些规则来描述那些你希望匹配的字符串集合。
这些字符串集合可能包含英语句子、e-mail 地址、TeX 命令，或任何你想要的东东。
正则表达式模式被编译成一系列的字节码，然后由一个C 语言写的匹配引擎所执行。
对于高级的使用，你可能需要更关注匹配引擎是如何执行给定的RE，并通过一定的方式来编写RE，以便产生一个可以运行得更快的字节码。
本文暂不讲解优化的细节，因为这需要你对匹配引擎的内部机制有一个很好的理解。
但本文的例子均是符合标准的正则表达式语法。
小甲鱼注释：Python 的正则表达式引擎是用C 语言写的，所以效率是极高的。
另，所谓的正则表达式，这里说的RE，就是上文我们提到的“一些规则”。
正则表达式语言相对较小，并且受到限制，所以不是所有可能的字符串处理任务都可以使用正则表达式来完成。
还有一些特殊的任务，可以使用正则表达式来完成，但是表达式会因此而变得非常复杂。
在这种情况下，你可能通过自己编写Python 代码来处理会更好些；尽管Python 代码比一个精巧的正则表达式执行起来会慢一些，但可能会更容易理解。
小甲鱼注释：这可能是大家常说的“丑话说在前”吧，大家别管他，正则表达式非常优秀，她可以处理你98.3% 的文本任务，一定要好好学哦~~~~~简单的模式我们将从最简单的正则表达式学习开始。
由于正则表达式常用于操作字符串的，因此我们从最常见的任务下手：字符匹配。
字符匹配大多数字母和字符会匹配它们自身。
举个例子，正则表达式 FishC 将完全匹配字符串 "FishC"。
（你可以启用不区分大小写模式，这将使得 FishC 可以匹配 "FISHC" 或 "fishc"，我们会在后边讨论这个话题。
）当然这个规则也有例外。
有少数特殊的字符我们称之为元字符（metacharacter），它们并不能匹配自身，它们定义了字符类、子组匹配和模式重复次数等。
本文用很大的篇幅专门讨论了各种元字符及其作用。
下边是元字符的完整列表（我们将在后边逐一讲解）：. ^ $ * + ? { } [ ] \ | ( )小甲鱼注释：如果没有这些元字符，正则表达式就变得跟字符串的find() 方法一样平庸了......我们先来看下方括号 [ ]，它们指定一个字符类用于存放你需要匹配的字符集合。
可以单独列出需要匹配的字符，也可以通过两个字符和一个横杆 - 指定匹配的范围。
例如 [abc] 会匹配字符 a，b 或 c；[a-c] 可以实现相同的功能。
后者使用范围来表示与前者相同的字符集合。
如果你想只匹配小写字母，你的RE 可以写成 [a-z]。
需要注意的一点是：元字符在方括号中不会触发“特殊功能”，在字符类中，它们只匹配自身。
例如 [akm$] 会匹配任何字符 'a'，'k'，'m' 或 '$'，'$' 是一个元字符，但在方括号中它不表示特殊含义，它只匹配 '$' 字符本身。
你还可以匹配方括号中未列出的所有其他字符。
做法是在类的开头添加一个脱字符号 ^ ，例如 [^5] 会匹配除了 '5' 之外的任何字符。
或许最重要的元字符当属反斜杠 \ 了。
跟Python 的字符串规则一样，如果在反斜杠后边紧跟着一个元字符，那么元字符的“特殊功能”也不会被触发。
例如你需要匹配符号 [ 或 \，你可以在它们前面加上一个反斜杠，以消除它们的特殊功能：\[，\\。
反斜杠后边跟一些字符还可以表示特殊的意义，例如表示十进制数字，表示所有的字母或者表示非空白的字符集合。
小甲鱼解释：反斜杠真牛逼，反斜杠后边跟元字符去除特殊功能，反斜杠后边跟普通字符实现特殊功能。
让我们来举个例子：\w 匹配任何字符。
如果正则表达式以字节的形式表示，这相当于字符类 [a-zA-Z0-9_]；如果正则表达式是一个字符串，\w 会匹配所有Unicode 数据库（unicodedata 模块提供）中标记为字母的字符。
你可以在编译正则表达式的时候，通过提供re.ASCII 表示进一步限制 \w 的定义。
小甲鱼解释：re.ASCII 标志使得\w 只能匹配ASCII 字符，不要忘了，Python3 是Unicode 的。
下边列举一些反斜杠加字符构成的特殊含义：特殊字符含义\d 匹配任何十进制数字；相当于类 [0-9]\D 与 \d 相反，匹配任何非十进制数字的字符；相当于类 [^0-9]\s 匹配任何空白字符（包含空格、换行符、制表符等）；相当于类 [ \t\n\r\f\v]\S 与 \s 相反，匹配任何非空白字符；相当于类 [^ \t\n\r\f\v]\w 匹配任何字符，见上方解释\W 于 \w 相反\b 匹配单词的开始或结束\B 与 \b 相反它们可以包含在一个字符类中，并且一样拥有特殊含义。
例如 [\s,.] 是一个字符类，它将匹配任何空白字符（/s 的特殊含义），',' 或 '.'。
最后我们要讲的一个元字符是 .，它匹配除了换行符以外的任何字符。
如果设置了re.DOTALL 标志，. 将匹配包括换行符在内的任何字符。
重复的事情使用正则表达式能够轻松的匹配不同的字符集合，但Python 字符串现有的方法却无法实现。
然而，如果你认为这是正则表达式的唯一优势，那你就too young too native 了。
正则表达式有另一个强大的功能，就是你可以指定RE 部分被重复的次数。
我们来看看 * 这个元字符，当然它不是匹配 '*' 字符本身（我们说过元字符都是有特殊能力的），它用于指定前一个字符匹配零次或者多次。
例如 ca*t 将匹配 ct（0 个字符a），cat（1 个字符a），caaat（3 个字符a），等等。
需要注意的是，由于受到C 语言的int 类型大小的内部限制，正则表达式引擎会限制字符'a' 的重复个数不超过20 亿个；不过，通常我们工作中也用不到那么大的数据。
正则表达式默认的重复规则是贪婪的，当你重复匹配一个RE 时，匹配引擎会尝试尽可能多的去匹配。
直到RE 不匹配或者到了结尾，匹配引擎就会回退一个字符，然后再继续尝试匹配。
我们通过例子一步步的给大家讲解什么叫“贪婪”：先考虑一下表达式 a[bcd]*b，首先需要匹配字符 'a'，然后是零个到多个 [bcd]，最后以 'b' 结尾。
那现在想象一下，这个RE 匹配字符串 abcbd 会怎样？步骤匹配说明1 a 匹配RE 的第一个字符 'a'2 abcbd 引擎在符合规则的情况下尽可能地匹配 [bcd]*，直到该字符串的结尾3 失败引擎尝试匹配RE 最后一个字符 'b'，但当前位置已经是字符串的结尾，所以失败告终4 abcb 回退，所以 [bcd]* 匹配少一个字符5 失败再一次尝试匹配RE 最后一个字符 'b'，但字符串最后一个字符是 'd'，所以失败告终6 abc 再次回退，所以 [bcd]* 这次只匹配 'bc'7 abcb 再一次尝试匹配字符 'b'，这一次字符串当前位置指向的字符正好是 'b'，匹配成功最终，RE 匹配的结果是 abcb。
小甲鱼解释：正则表达式默认的匹配规则是贪婪的，后边有教你如何使用非贪婪的方法匹配。
另一个实现重复的元字符是 +，用于指定前一个字符匹配一次或者多次。
要特别注意 * 和 + 的区别：* 匹配的是零次或者多次，所以被重复的内容可能压根儿不会出现；+ 至少需要出现一次。
例如 ca+t 会匹配 cat 和 caaat，但不会匹配 ct。
还有两个表示重复的元字符，其中一个是问号 ?，用于指定前一个字符匹配零次或者一次。
你可以这么想，它的作用就是把某种东西标志位可选的。
例如小?甲鱼可以匹配小甲鱼，也可以匹配甲鱼。
最灵活的应该是元字符 {m, n}（m 和n 都是十进制整数），上边讲到的几个元字符都可以使用它来表达，它的含义是前一个字符必须匹配m 次到n 次之间。
例如 a/{1, 3}b 会匹配 a/b，a//b 和 a///b。
但不会匹配 ab（没有斜杠）；也不会匹配a////b（斜杠超过三个）。
你可以省略m 或者n，这样的话，引擎会假定一个合理的值代替。
省略m，将被解释为下限0；省略n 则会被解释为无穷大（事实上是上边我们提到的20 亿）。
小甲鱼解释：如果是{, n} 相当于{0, n}；如果是{m, } 相当于{m, +无穷}；如果是{n}，则是重复前一个字符n 次。
聪明的鱼油应该已经发现了，其实 *、+ 和 ? 都可以使用 {m, n} 来代替。
{0,} 跟 * 是一样的；{1, } 跟 + 是一样的；{0, 1}跟 ? 是一样的。
不过还是鼓励大家记住并使用 *、+ 和 ?，因为这些字符更短并且更容易阅读。
小甲鱼解释：还有一个原因是匹配引擎对* + ? 做了优化，效率要更高些。