下载文档原格式
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 正则表达式详解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 中提供了 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中也提供了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中，正则表达式是通过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的使⽤⽅法详解⼀、正则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是一种功能强大的编程语言，其内置了正则表达式（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 解析数学表达式" 指的是使用 Python 3 语言来解析和计算数学表达式。
这通常涉及到使用特定的库或工具来解析字符串形式的数学表达式，并返回计算结果。
以下是一些与 Python 3 解析数学表达式相关的内容：
1.SymPy: SymPy 是一个 Python 库，用于进行符号数学的计算，包括解析
数学表达式。
2.eval() 函数: Python 的内置eval()函数可以用来解析并计算字符串形式的
数学表达式。
例如：result = eval("2 + 3 × 4")。
3.使用正则表达式: 通过正则表达式，可以解析简单的数学表达式，例如只包
含加减乘除的表达式。
4.解析复杂数学公式: 对于更复杂的数学公式，可能需要使用专门的解析器或
编译器来正确解析和计算。
总结："Python3 解析数学表达式" 是指使用 Python 3 来解析和计算字符串形式的数学表达式。
这通常涉及到使用特定的库或工具，如SymPy 或内置的eval()函数，来处理数学表达式的字符串形式，并返回计算结果。
在Python 中，正则表达式的`match` 方法用于检查字符串的开头是否匹配给定的正则表达式。
这个方法返回一个匹配对象（Match Object）或者在不匹配时返回`None`。
以下是`match` 方法的基本用法：```pythonimport re# 定义正则表达式pattern = pile(r'正则表达式')# 在字符串中查找匹配match_object = pattern.match('要匹配的字符串')# 判断是否匹配成功if match_object:# 匹配成功matched_text = match_object.group() # 获取匹配的文本print(f'匹配成功: {matched_text}')else:# 匹配失败print('匹配失败')```注意：1. `pile` 方法用于将正则表达式字符串编译成正则表达式对象，提高匹配效率。
你也可以直接使用`re.match(r'正则表达式', '要匹配的字符串')`，但使用`compile` 更为高效，尤其在需要多次使用同一正则表达式时。
2. `match` 方法只匹配字符串的开头。
如果你希望匹配整个字符串，请使用`search` 方法。
3. 如果匹配成功，`match_object.group()` 方法返回匹配的文本。
以下是一个简单的示例：```pythonimport re# 匹配以字母开头，后跟数字的字符串pattern = pile(r'[a-zA-Z]\d+')# 测试字符串test_string = 'A123'# 使用match 进行匹配match_object = pattern.match(test_string)if match_object:matched_text = match_object.group()print(f'匹配成功: {matched_text}')else:print('匹配失败')```这个示例中的正则表达式`[a-zA-Z]\d+` 匹配以字母开头，后跟至少一个数字的字符串。
Python是一种功能强大的编程语言，它提供了丰富的库和工具，以便开发者能够轻松地处理各种任务。
正则表达式是Python中的一个重要工具，它能够帮助开发者进行字符串匹配和替换操作。
在使用正则表达式时，掌握如何匹配结尾的字符串是非常重要的。
本文将介绍Python正则表达式中匹配结尾的方法，内容包括如下几个部分：一、Python正则表达式简介二、Python正则表达式匹配结尾的方法三、示例演示四、总结一、Python正则表达式简介正则表达式是一种强大的字符串匹配工具，它使用特定的符号和语法规则来描述字符串的模式。
Python中的re模块提供了对正则表达式的支持，开发者可以借助re模块对字符串进行匹配、替换和提取等操作。
二、Python正则表达式匹配结尾的方法在Python中，要匹配结尾的字符串，可以使用'$'符号。
'$'符号用来表示字符串的结束位置，在正则表达式中使用它可以精确匹配结尾的字符串。
示例如下：import repattern = r'ing$'text = "I am running"result = re.search(pattern, text)if result:print("匹配成功")else:print("匹配失败")在上面的示例中，使用了正则表达式'ing$'来匹配以'ing'结尾的字符串，结果会返回匹配成功。
三、示例演示接下来，我们通过一个实际的示例来演示如何在Python中使用正则表达式匹配结尾的字符串。
示例代码如下：import repattern = r'ing$'text = "I am running"result = re.search(pattern, text)if result:print("匹配成功")else:print("匹配失败")通过运行上述代码，我们可以得到匹配结果。
Python正则表达式使⽤经典实例下⾯列出Python正则表达式的⼏种匹配⽤法，具体内容如下所⽰：1.测试正则表达式是否匹配字符串的全部或部分regex=ur"" #正则表达式if re.search(regex, subject):do_something()else:do_anotherthing()2.测试正则表达式是否匹配整个字符串regex=ur"\Z" #正则表达式末尾以\Z结束if re.match(regex, subject): do_something()else: do_anotherthing()3.创建⼀个匹配对象，然后通过该对象获得匹配细节(Create an object with details about how the regex matches (part of) a string)regex=ur"" #正则表达式match = re.search(regex, subject)if match: # match start: match.start() # match end (exclusive): atch.end() # matched text: match.group() do_something()else: do_anotherthing()4.获取正则表达式所匹配的⼦串(Get the part of a string matched by the regex)regex=ur"" #正则表达式match = re.search(regex, subject)if match: result = match.group()else: result = ""5. 获取捕获组所匹配的⼦串(Get the part of a string matched by a capturing group)regex=ur"" #正则表达式match = re.search(regex, subject)if match: result = match.group(1)else: result = ""6. 获取有名组所匹配的⼦串(Get the part of a string matched by a named group)regex=ur"" #正则表达式match = re.search(regex, subject)if match:result = match.group"groupname")else:result = ""7. 将字符串中所有匹配的⼦串放⼊数组中(Get an array of all regex matches in a string)result = re.findall(regex, subject)8.遍历所有匹配的⼦串(Iterate over all matches in a string)for match in re.finditer(r"<(.*?)\s*.*?/\1>", subject) # match start: match.start() # match end (exclusive): atch.end() # matched text: match.group()9.通过正则表达式字符串创建⼀个正则表达式对象(Create an object to use the same regex for many operations)reobj = pile(regex)10.⽤法１的正则表达式对象版本（use regex object for if/else branch whether (part of) a string can be matched）reobj = pile(regex)if reobj.search(subject): do_something()else: do_anotherthing()11.⽤法２的正则表达式对象版本（use regex object for if/else branch whether a string can be matched entirely）reobj = pile(r"\Z") ＃正则表达式末尾以\Z 结束if reobj.match(subject): do_something()else: do_anotherthing()12.创建⼀个正则表达式对象，然后通过该对象获得匹配细节（Create an object with details about how the regex object matches (part of) a string）reobj = pile(regex)match = reobj.search(subject)if match: # match start: match.start() # match end (exclusive): atch.end() # matched text: match.group() do_something()else: do_anotherthing()13.⽤正则表达式对象获取匹配⼦串（Use regex object to get the part of a string matched by the regex）reobj = pile(regex)match = reobj.search(subject)if match: result = match.group()else: result = ""14.⽤正则表达式对象获取捕获组所匹配的⼦串（Use regex object to get the part of a string matched by a capturing group）reobj = pile(regex)match = reobj.search(subject)if match: result = match.group(1)else: result = ""15.⽤正则表达式对象获取有名组所匹配的⼦串（Use regex object to get the part of a string matched by a named group）reobj = pile(regex)match = reobj.search(subject)if match: result = match.group("groupname")else: result = ""16.⽤正则表达式对象获取所有匹配⼦串并放⼊数组（Use regex object to get an array of all regex matches in a string）reobj = pile(regex)result = reobj.findall(subject)17.通过正则表达式对象遍历所有匹配⼦串（Use regex object to iterate over all matches in a string）reobj = pile(regex)for match in reobj.finditer(subject): # match start: match.start() # match end (exclusive): match.end() # matched text: match.group()字符串替换1.替换所有匹配的⼦串#⽤newstring替换subject中所有与正则表达式regex匹配的⼦串result = re.sub(regex, newstring, subject)2.替换所有匹配的⼦串（使⽤正则表达式对象）reobj = pile(regex)result = reobj.sub(newstring, subject)字符串拆分1.字符串拆分result = re.split(regex, subject)2.字符串拆分（使⽤正则表⽰式对象）reobj = pile(regex)result = reobj.split(subject)。
python 中正则表达式的用途正则表达式在Python中的用途1. 引言正则表达式是一种用于描述、匹配和处理字符串的强大工具。
在Python中，内置了re模块，提供了对正则表达式的支持。
正则表达式可以帮助我们在文本中查找、替换、提取特定的模式，从而实现对字符串的灵活处理。
本文将介绍正则表达式在Python中的用途。
2. 文本匹配正则表达式最常用的功能之一是对文本进行匹配。
通过定义特定的模式，我们可以轻松地查找到符合条件的字符串。
比如，我们可以使用正则表达式来匹配邮箱地址、电话号码等特定格式的字符串。
3. 字符串替换正则表达式还可以用来进行字符串的替换。
通过定义匹配模式和替换的规则，我们可以对文本中的指定字符串进行替换。
例如，我们可以将一段文本中的所有数字替换为"#"，或者将所有的URL替换为特定的字符串。
4. 字符串分割正则表达式可以用来分割字符串。
通过指定分割模式，我们可以将一个长字符串按照特定的规则进行拆分，得到一个字符串列表。
这在处理日志文件、CSV文件等文本数据时非常有用。
5. 提取关键信息正则表达式还可以帮助我们从字符串中提取出关键信息。
通过定义匹配模式，我们可以轻松地从文本中提取出日期、时间、IP地址等特定的信息。
这对于数据清洗、数据提取等工作非常有帮助。
6. 校验数据格式正则表达式可以用来校验数据的格式是否符合要求。
通过定义匹配模式，我们可以检查一个字符串是否满足特定的格式要求。
例如，我们可以使用正则表达式来校验一个字符串是否为合法的身份证号码、手机号码等。
7. 数据清洗在数据处理过程中，常常会遇到一些无用的字符、空白行等需要清洗的情况。
正则表达式提供了强大的工具来进行数据清洗。
通过定义匹配模式，我们可以轻松地将无用的字符、空白行等清除掉，从而得到干净的数据。
8. 数据提取正则表达式还可以用于数据提取。
通过定义匹配模式，我们可以从一段文本中提取出符合条件的数据。
python中正则表达式的使⽤详解从学习Python⾄今，发现很多时候是将Python作为⼀种⼯具。
特别在⽂本处理⽅⾯，使⽤起来更是游刃有余。
说到⽂本处理，那么正则表达式必然是⼀个绝好的⼯具，它能将⼀些繁杂的字符搜索或者替换以⾮常简洁的⽅式完成。
我们在处理⽂本的时候,或是查询抓取,或是替换.⼀.查找如果你想⾃⼰实现这样的功能模块,输⼊某⼀个ip地址,得到这个ip地址所在地区的详细信息.但是⼈家没有提供api供外部调⽤,但是我们可以通过代码模拟查询然后对结果进⾏抓取.通过查看这个相应页⾯的源码,我们可以发现,结果是放在三个<li></li>中的复制代码代码如下:<table width="80%" border="0" align="center" cellpadding="0" cellspacing="0"><tr><td align="center"><h3> IP查询(搜索IP地址的地理位置)</h3></td></tr><tr><td align="center"><h1>您查询的IP:121.0.29.231</h1></td></tr><tr><td align="center"><ul class="ul1"><li>本站主数据：浙江省杭州市阿⾥巴巴</li><li>参考数据⼀：浙江省杭州市阿⾥巴巴</li><li>参考数据⼆：浙江省杭州市阿⾥巴巴</li></ul></td></tr><tr><td align="center">如果您发现查询结果不详细或不正确，请使⽤<a href="ip_add.asp?ip=121.0.29.231"><fontcolor="#006600"><b>IP数据库⾃助添加</b></font></a>功能进⾏修正<br/><br/><iframe src="/jss/bd_460x60.htm" frameborder="no" width="460" height="60" border="0" marginwidth="0" marginheight="0" scrolling="no"></iframe><br/><br/></td></tr><form method="get" action="ips8.asp" name="ipform" onsubmit="return checkIP();"><tr><td align="center">IP地址或者域名：<input type="text" name="ip" size="16"> <input type="submit" value="查询"><input type="hidden" name="action" value="2"></td></tr><br><br></form></table>如果你了解正则表达式你可能会写出正则表达式复制代码代码如下:(?<=<li>).*?(?=</li>)这⾥使⽤了前瞻：lookahead 后顾: lookbehind,这样的好处就是匹配的结果中就不会包含html的li标签了.如果你对⾃⼰写的正则表达式不是很⾃信的话,可以在⼀些在线或者本地的正则测试⼯具进⾏⼀些测试,以确保正确.接下来的⼯作就是如果⽤Python实现这样的功能,⾸先我们得将正则表达式表⽰出来:复制代码代码如下:r"(?<=<li>).*?(?=</li>)"Python中字符串前⾯加上前导r这个字符,代表这个字符串是R aw String(原始字符串),也就是说Python字符串本⾝不会对字符串中的字符进⾏转义.这是因为正则表达式也有转义字符之说,如果双重转义的话,易读性很差.这样的串在Python中我们把它叫做"regular expression pattern"如果我们对pattern进⾏编译的话复制代码代码如下:prog = pile(r"(?<=<li>).*?(?=</li>)")我们便可以得到⼀个正则表达式对象regular expression object,通过这个对象我们可以进⾏相关操作.⽐如复制代码代码如下:result=prog.match(string)##这个等同于result=re.match(r"(?<=<li>).*?(?=</li>)",string)##但是如果这个正则需要在程序匹配多次,那么通过正则表达式对象的⽅式效率会更⾼接下来就是查找了,假设我们的html结果已经以html的格式存放在text中,那么通过复制代码代码如下:result_list = re.findall(r"(?<=<li>).*?(?=</li>)",text)便可以取得所需的结果列表.⼆.替换使⽤正则表达式进⾏替换⾮常的灵活.⽐如之前我在阅读Trac这个系统中wiki模块的源代码的时候,就发现其wiki语法的实现就是通过正则替换进⾏的.在使⽤替换的时候会涉及到正则表达式中的Group分组的概念.假设wiki语法中使⽤!表⽰转义字符即感叹号后⾯的功能性字符会原样输出,粗体的语法为写道'''这⾥显⽰为粗体'''那么有正则表达式为复制代码代码如下:r"(?P<bold>!?''')"这⾥的?P<bold>是Python正则语法中的⼀部分,表⽰其后的group的名字为"bold"下⾯是替换时的情景,其中sub函数的第⼀个参数是pattern,第⼆个参数可以是字符串也可以是函数,如果是字符串的话,那么就是将⽬标匹配的结果替换成指定的结果,⽽如果是函数,那么函数会接受⼀个match object的参数,并返回替换后的字符串,第三个参数便是源字符串.复制代码代码如下:result = re.sub(r"(?P<bold>!?''')", replace, line)每当匹配到⼀个三单引号,replace函数便运⾏⼀次,可能这时候需要⼀个全局变量记录当前的三单引号是开还是闭,以便添加相应的标记.在实际的trac wiki的实现的时候,便是这样通过⼀些标记变量,来记录某些语法标记的开闭,以决定replace函数的运⾏结果.--------------------⽰例⼀. 判断字符串是否是全部⼩写代码复制代码代码如下:# -*- coding: cp936 -*-import res1 = 'adkkdk's2 = 'abc123efg'an = re.search('^[a-z]+$', s1)if an:print 's1:', an.group(), '全为⼩写'else:print s1, "不全是⼩写！"an = re.match('[a-z]+$', s2)if an:print 's2:', an.group(), '全为⼩写'else:print s2, "不全是⼩写！"结果究其因1. 正则表达式不是python的⼀部分，利⽤时需要引⽤re模块2. 匹配的形式为： re.search(正则表达式，带匹配字串)或re.match(正则表达式，带匹配字串)。
正则表达式优化手段正则表达式是一种强大的文本处理工具，但在处理复杂或大数据量时，性能可能会受到影响。
为了提高正则表达式的效率和性能，以下是一些优化手段：1. **减少重复匹配**：在正则表达式中，尽量减少不必要的重复匹配。
例如，使用`\d+`而不是`\d`，这样可以减少每次匹配的字符数。
2. **使用固定字符串**：在正则表达式中，尽量避免使用可变字符串，如`.*`。
这样的表达式会在整个目标字符串中反复匹配，导致效率低下。
3. **使用预编译**：在Python等语言中，可以使用`pile()`函数预编译正则表达式。
预编译后的正则表达式在匹配时速度更快。
4. **优化贪婪模式**：默认情况下，正则表达式的匹配是贪婪的，会尽可能多地匹配字符。
在某些情况下，可以使用非贪婪模式（在量词后面加上`?`）来提高效率。
5. **避免使用回溯**：在复杂正则表达式中，回溯可能导致性能下降。
尽量避免使用可以导致回溯的表达式模式，如`(a+)*b`。
6. **减少使用元字符**：元字符可以增加表达式的功能，但也会增加匹配的时间。
在可能的情况下，尽量减少元字符的使用。
7. **考虑字符集的顺序**：在定义字符集时，将最可能出现的情况放在前面，这样可以减少匹配的时间。
8. **优化全局匹配**：当使用`re.findall()`或`re.finditer()`时，全局匹配会尝试在整个字符串中查找所有匹配项。
如果不需要全局匹配，可以使用其他方法代替。
9. **调整匹配优先级**：使用括号可以将匹配的优先级提高，从而减少不必要的匹配。
10. **使用正则表达式的内置函数**：正则表达式库通常提供了一些内置函数，如`re.split()`、`re.sub()`等，这些函数在某些情况下比使用正则表达式更高效。
11. **理解引擎工作原理**：不同的正则表达式引擎（如Python的`re`模块和Perl的`Regexp::Common`模块）有不同的工作原理和优化方式。
python正则根据开头和结尾字符串获取中间字符串的方法Python正则表达式：根据开头和结尾字符串获取中间字符串的方法在Python中，正则表达式是处理文本操作非常关键的工具。
通过正则表达式，我们可以方便地匹配和提取字符串中的特定部分，从而实现数据处理的目的。
其中，要根据开头和结尾字符串获取中间的字符串，可以使用正则表达式中的“lookbehind”和“lookahead”语法。
以下是具体的实现方法：1. 根据开头和结尾字符串生成正则表达式模式我们可以使用正则表达式模式来匹配开头和结尾字符串，并同时保留中间的部分。
例如，在文本中查找以“Hello”为开头、以“World”为结尾的字符串，可以使用如下正则表达式模式：```pythonpattern = r'(?<=Hello).*?(?=World)'```这个正则表达式模式中，使用了“lookbehind”语法“(?<=Hello)”，表示匹配以“Hello”为开头的文本。
同时，也使用了“lookahead”语法“(?=World)”，表示匹配以“World”为结尾的文本。
最后，使用“.*?”匹配开头和结尾之间的任意文本，保留中间部分。
2. 使用正则表达式模式匹配字符串在生成正则表达式模式之后，我们可以使用Python中的re模块来进行字符串匹配操作。
例如，在文本“Hello, World!”中查找以“Hello”为开头、以“World”为结尾的字符串，代码如下：```pythonimport retext = 'Hello, World!'pattern = r'(?<=Hello).*?(?=World)'match = re.search(pattern, text)if match:result = match.group(0)print(result)```在以上代码中，使用了re模块中的search()函数进行正则表达式匹配。
Python3 正则表达式特殊符号及用法（详细列表）正则表达式的强大之处在于特殊符号的应用，特殊符号定义了字符集合、子组匹配、模式重复次数。
正是这些特殊符号使得一个正则表达式可以匹配字符串集合而不只是一个字符串。
注1：为了便于理解，难点的地方均用斜体举了栗子。
注2：如果你对正则表达式一头雾水或者看不懂下边这个列表，那么小甲鱼极力推荐你先学习这个：Python3 如何优雅地使用正则表达式字符含义表示匹配除了换行符外的任何字符.注：通过设置re.DOTALL 标志可以使 . 匹配任何字符（包含换行符）| A | B，表示匹配正则表达式A 或者B1. （脱字符）匹配输入字符串的开始位置^2. 如果设置了re.MULTILINE 标志，^ 也匹配换行符之后的位置1. 匹配输入字符串的结束位置$2. 如果设置了re.MULTILINE 标志，$ 也匹配换行符之前的位置1. 将一个普通字符变成特殊字符，例如 \d 表示匹配所有十进制数字\2. 解除元字符的特殊功能，例如 \. 表示匹配点号本身3. 引用序号对应的子组所匹配的字符串4. 详见下方列举[...] 字符类，匹配所包含的任意一个字符注1：连字符 - 如果出现在字符串中间表示字符范围描述；如果如果出现仅作为普通字符注2：特殊字符仅有反斜线 \ 保持特殊含义，用于转义字符。
其它特殊字+、? 等均作为普通字符匹配注3：脱字符 ^ 如果出现在首位则表示匹配不包含其中的任意字符；如果在字符串中间就仅作为普通字符匹配{M,N} M 和N 均为非负整数，其中M <= N，表示前边的RE 匹配M ~ N 注1：{M,} 表示至少匹配M 次注2：{,N} 等价于{0,N}注3：{N} 表示需要匹配N 次* 匹配前面的子表达式零次或多次，等价于{0,} + 匹配前面的子表达式一次或多次，等价于{1,} ? 匹配前面的子表达式零次或一次，等价于{0,1}*?, +?, ?? 默认情况下 *、+ 和 ? 的匹配模式是贪婪模式（即会尽可能多地匹配符合符串）；*?、+? 和?? 表示启用对应的非贪婪模式。
python 正则表达式模糊匹配和精确匹配-回复Python正则表达式是一种强大的工具，用于文本匹配和处理。
在正则表达式中，我们常常需要进行模糊匹配和精确匹配。
本文将详细介绍这两种匹配方法，并给出一些具体的应用示例。
一、模糊匹配模糊匹配是指在匹配搜索时，允许一定程度的误差。
这在处理大量数据和不完整的数据时非常有用。
在正则表达式中，模糊匹配常常使用特殊字符来实现。
下面是几个常用的模糊匹配字符：1. "."：匹配任意字符，除了换行符。
例如，正则表达式"ca.e"可以匹配"case"、"cake"和"cave"等单词。
2. "*"：匹配前一个字符的零个或多个实例。
例如，正则表达式"ca*t"可以匹配"ct"、"cat"、"caat"、"caaat"等单词。
3. "+"：匹配前一个字符的一个或多个实例。
例如，正则表达式"ca+t"可以匹配"cat"、"caat"、"caaat"等单词，但不能匹配"ct"。
4. "?"：匹配前一个字符的零个或一个实例。
例如，正则表达式"ca?t"可以匹配"ct"、"cat"等单词，但不能匹配"caat"。
5. "{m,n}"：匹配前一个字符的m到n个实例。
例如，正则表达式"ca{1,3}t"可以匹配"cat"、"caat"、"caaat"等单词，但不能匹配"ct"和"caa"。
正则表达式（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}跟 ? 是一样的。
不过还是鼓励大家记住并使用 *、+ 和 ?，因为这些字符更短并且更容易阅读。
小甲鱼解释：还有一个原因是匹配引擎对* + ? 做了优化，效率要更高些。
