En primer lugar, la expresión regular
Las expresiones regulares (expresiones regulares) (expresiones regulares) operador (RE), para simplificar la expresión de un conjunto de expresiones de caracteres y caracteres compuesta.
de serie de módulos expresión general
la expresión concisa expresión de un conjunto de cadenas
Para la expresión sarta de herramientas "simple" y el pensamiento "características"
El análisis de las características de un hogar de una cuerda
Las expresiones regulares se utilizan comúnmente en el procesamiento de textos
características de expresión de tipo de texto (virus, intrusión, etc.)
Mientras tanto buscar o reemplazar un conjunto de cadenas
Todo o parte de la cadena coincidente
Utilizar expresiones regulares
Compilar: responda a las características de la sintaxis de las expresiones regulares expresión regular para convertir una cadena
operadores de expresiones regulares comunes
| operadores | explicación | Ejemplos |
| . | Representa cualquier carácter individual (excepto una línea nueva de forma predeterminada) | |
| [] | Personajes, un solo carácter se da en el rango de | [Abc] representa a, B, C, [AZ] representa una a un solo carácter, z |
| [^] | No caracteres, se le da un carácter único a la zona negativa | [^ Abc] representa un no una o b, o el único carácter c, |
| * | carácter anterior 0 veces o un número ilimitado de extensiones | abc * representa AB, ABC, ABCC, ABCCC etc. |
| + | Anterior personaje una vez o expansión ilimitada | abc + representa ABC, ABCC, ABCCC etc. |
| ? | carácter anterior 0 o 1 extensión de tiempo | abc * representa ab, abc |
| | | Cualquier expresión de una | abc | representa DEF ABC, DEF |
| {metro} | Antes extendemos un carácter m veces | ab {2} c representa abbc |
| {Minnesota} | Un frente carácter extensión m a n veces (incluyendo n) | representa ab {1,2} c abc, abbc |
| ^ | Coincide con el comienzo de la cadena de | ABC y en el principio de una cadena |
| PS | Final de la cadena | ABC y al final de una cadena |
| () | marcado de paquetes, uso interno operador | | (ABC) representa abc, (abc | def) representa ABC, DEF |
| \re | Número, es equivalente a [0-9] | |
| \ w | carácter de palabra, lo que equivale a [A-Za-z0-9_] |
Ejemplo de sintaxis
| Las expresiones regulares | Correspondiente cadena de caracteres |
| P (Y | YT | YTH | YTHO) N? | 'PN', 'PYN', 'PYTN', 'PYTHN', 'Python' |
| PYTHON + | 'PYTHON', 'PYTHONN', 'PYTHONNN' ...... |
| PITÓN | 'PYTON', 'Phyton' |
| PY [^ TH]? EN | 'Pyon', 'PYaON', 'PYbON', 'Pycon' ...... |
| PY {3} es una | ' PN', 'PYN', 'la solicitud', 'PYYYN' |
Ejemplos clásicos
| Las expresiones regulares | significado |
| ^ [A-Za-z] + $ | Una cadena de letras 26 |
| ^ [A-Za-Z0-9] + $ | Una serie de 26 letras y dígitos |
| ^ - \ d + $ | cadena de número entero |
| ^ [1-9] * [0-9] * $ | string entero positivo |
| [1-9] \ d {5} | código postal interior chino, 6 |
| [\ U4e00- \ u9fa5] | Coincidencia de caracteres chinos |
| \ D {3} - \ d {8} | \ d {4} - \ d {7} | número de teléfono interno 3 -8 o 4 - 7 |
Dos, Re biblioteca
biblioteca Re es una biblioteca estándar de Python, que se utiliza principalmente para la coincidencia de cadenas, llame al método "import re"
1, el tipo de expresión regular
Re biblioteca utilizando cadena de texto (cadena de tipo nativo) la expresión de expresiones regulares, representado como r'text', cadena de texto es una cadena que no contiene fuga
El r '[1-9] \ d { 5}', r '\ d {3} - \ d {8} | \ d {4} - \ d {7}'
tipo de cadena es más complicado, que necesita para escapar de algunos símbolos especiales
El '[1-9] 5 \\ {D}', '\\ {D} 3 - 8 \\ {D} |.... 4} {D \\ - \\ {D} 7'
2, la función principal de la Re función de biblioteca
| función | explicación |
| investigación() | Buscar una cadena coincidente desde una primera posición con una expresión regular, vuelve coinciden con objeto |
| revancha() | La expresión regular desde la posición de inicio de una cadena de caracteres, devoluciones coinciden con objeto |
| re.findall () | La cadena de búsqueda, devolver un tipo de lista puede coincidir con subseries de todos |
| re.split () | La cadena se divide de acuerdo con un resultado regular de la expresión coincidente, devuelve una lista de Tipo |
| re.finditer () | 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象 |
| re.sub() | 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串 |
（1）re.search()函数
re.search(pattern,string,flags = 0)
在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
flags:正则表达式使用时的控制标记
1 import re 2 match = re.search(r'[1-9]\d{5}','BIT 100081') 3 if match: 4 print(match.group(0)) 5 100081
| 常用标记 | 说明 |
| re.I re.IGNORECASE | 忽略正则表达式的大小写，[A-Z]能够匹配小写字符 |
| re.M re.MULTILINE | 正则表达式中^操作符能够将给定字符串的每行当做匹配开始 |
| re.S re.DOTALL | 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符 |
（2）re.match()函数
re.match(pattern,string,flags = 0)
从一个字符串的开始位置起匹配正则表达式，返回match对象
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
flags:正则表达式使用时的控制标记
1 import re 2 match = re.match(r'[1-9]\d{5}','BIT 100081') 3 if match: 4 print(match.group(0)) 5 6 match.group(0) 7 Traceback (most recent call last): 8 File "<input>", line 1, in <module> 9 AttributeError: 'NoneType' object has no attribute 'group'
由以上代码可看出，匹配不出以'BIT'开头的字符串，调用match.group(0)返回为空
1 import re 2 match = re.match(r'[1-9]\d{5}','100081 BIT') 3 if match: 4 print(match.group(0)) 5 100081
（3）re.findall()函数
re.findall(pattern,string,flags = 0)
搜索字符串，以列表类型返回全部能匹配的子串
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
flags:正则表达式使用时的控制标记
1 import re 2 ls = re.findall(r'[1-9]\d{5}','BIT100081 TSU100084') 3 ls 4 ['100081', '100084']
（4）re.split()函数
re.split(pattern,string,maxsplit = 0,flags = 0)
将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
maxsplit:最大分割数，剩余部分作为最后一个元素输出
flags:正则表达式使用时的控制标记
1 import re 2 re.split(r'[1-9]\d{5}','BIT100081 TSU100084') 3 ['BIT', ' TSU', ''] #将匹配的字符串去掉，剩余分割部分放入一个列表 4 re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit = 1) 5 ['BIT', ' TSU100084'] #将匹配的第一个字符串去掉，剩余分割部分放入一个列表（匹配的第一个字符串后的所有部分作为一个整体）
（5）re.finditer()函数
re.finditer(pattern,string,flags = 0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
flags:正则表达式使用时的控制标记
1 import re 2 for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSU100084'): 3 if m: 4 print(m.group(0)) 5 100081 6 100084
（6）re.sup()函数
re.sup(pattern,repl,string,count = 0,flags = 0)
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
pattern:正则表达式的字符串或原生字符串表示
repl:替换匹配字符串的字符串
string:待匹配字符串
count:匹配的最大替换次数
flags:正则表达式使用时的控制标记
1 import re 2 re.sub(r'[1-9]\d{5}','zipcode','BIT100081 TSU100084') 3 'BITzipcode TSUzipcode'
3、Re库的用法
（1）函数式用法：一次性操作
1 rst = re.search(r’[1-9]\d{5}’,’BIT 100081’)
（2）面向对象用法：编译后的多次操作
1 pat = re.compile(r’[1-9]\d{5}’) 2 rst = pat.search(‘BIT 100081’)
（3）re.compile()函数
regex = re.compile(pattern,flags = 0)
将正则表达式的字符串形式编译成正则表达式对象
pattern:正则表达式的字符串或原生字符串表示
flags:正则表达式使用时的控制标记
经过re.compile()方法后,regex被编译为正则表达式对象，可以使用对象方法，即regex.search()、regex.match()、regex.findall()、regex.split()、regex.finditer()、regex.sub()
1 import re 2 regex = re.compile(r'[1-9]\d{5}') 3 regex.search('100081') 4 <re.Match object; span=(0, 6), match='100081'> 5 regex.search('100081').group(0) 6 '100081'
4、Match对象
（1）Match的属性
| 属性 | 说明 |
| .string | 待匹配的文本 |
| .re | 匹配时使用的pattern对象（正则表达式） |
| .pos | 正则表达式搜索文本的开始位置 |
| .endpos | 正则表达式搜索文本的结束位置 |
1 import re 2 m = re.search(r'[1-9]\d{5}','BIT100081 TSU100084') 3 m.string #待匹配的字符串 4 'BIT100081 TSU100084' 5 m.re #匹配时使用的正则表达式 6 re.compile('[1-9]\\d{5}') 7 m.pos #正则表达式搜索文本的开始位置 8 0 9 m.endpos #正则表达式搜索文本的结束位置 10 19
（2）Match的方法
| 方法 | 说明 |
| .group(0) | 获得匹配后的字符串 |
| .start() | 匹配字符串在原始字符串的开始位置 |
| .end() | 匹配字符串在原始字符串的结束位置 |
| .span() | 返回(.start(),.end()) |
1 import re 2 m = re.search(r'[1-9]\d{5}','BIT100081 TSU100084') 3 m.group(0) #获得匹配后的字符串 4 '100081' #返回第一次匹配的结果 5 m.start() #匹配字符串在原始字符串的开始位置 6 3 7 m.end() #匹配字符串在原始字符串的结束位置 8 9 9 m.span() #返回(.start(),.end()) 10 (3, 9)
5、贪婪匹配和最小匹配
（1）贪婪匹配
贪婪匹配即匹配最长的子串，Re库默认采用贪婪匹配
1 import re 2 match = re.search(r'PY.*N','PYANBNCNDN') 3 match.group(0) 4 'PYANBNCNDN'
（2）最小匹配
最小匹配即匹配最短的子串
| 操作符 | 说明 |
| *? | 前一个字符0次或无限次扩展，最小匹配 |
| +? | 前一个字符1次或无限次扩展，最小匹配 |
| ?? | 前一个字符0次或1次扩展，最小匹配 |
| {m,n}? | 扩展前一个字符m至n次（含n），最小匹配 |
1 import re 2 match = re.search(r'PY.*?N','PYANBNCNDN') #最小匹配 3 match.group(0) 4 'PYAN'
资料来源：北京理工大学，嵩天，MOOC