Directorio de artículos
En el desarrollo de rastreadores, es necesario extraer información útil de un texto grande, que
正则表达式es uno de los métodos de extracción de información.
1. Conceptos básicos de expresiones regulares
Una expresión regular ( Regular Expression) es una cadena que puede representar una información regular. Python viene con un módulo de expresión regular re, a través del cual puede buscar, extraer y reemplazar una información regular. En el desarrollo de programas, las expresiones regulares se pueden usar para hacer que un programa de computadora encuentre lo que necesita de un texto grande.
Existen los siguientes pasos para usar expresiones regulares:
(1) 寻找规律
(2) 使用正则符号表示规律
(3)提取信息
2. Símbolos básicos de las expresiones regulares
2.1 Número de punto“.”
un punto puedeSustituya cualquier carácter excepto una nueva línea, incluidos, entre otros, letras y números en inglés, caracteres chinos, signos de puntuación en inglés y signos de puntuación en chino.
2.2 Asteriscos“*”
un asterisco puedeRepresenta una subexpresión (carácter ordinario, otro o varios símbolos de expresión regular) que la precede de 0 a infinitas veces。
2.3 Signo de interrogación“?”
un signo de interrogación puedeIndica la subexpresión que le precede 0 o 1 veces. Tenga en cuenta que el signo de interrogación aquí es un signo de interrogación en inglés.
2.4 Barra invertida“\”
Las barras invertidas no se pueden usar solas en expresiones regulares, ni siquiera en Python como un todo. barra invertida requeridaPara usarse junto con otros caracteres para convertir símbolos especiales en símbolos ordinarios y símbolos ordinarios en símbolos especiales：
2.5 numeros“\d”
dentro de la expresión regularUse "\d" para representar un solo dígito. ¿Por qué usar la letra d? Porque d es la primera letra de "digital" en inglés. Debe enfatizarse que aunque "\d" se compone de barras invertidas y la letra d, "\d" debe considerarse como un símbolo de expresión regular completo.
2.6 Paréntesis“()”
los paréntesis puedenExtraiga el contenido entre paréntesis。
3. Usar expresiones regulares en Python
Python ya viene con un módulo de expresiones regulares muy potente. Usando este módulo, es muy conveniente extraer información regular de un texto grande a través de expresiones regulares. El módulo de expresiones regulares de Python se llama "re", que es un acrónimo de "regularexpression". En Python, primero debe importar este módulo antes de usarlo. La declaración importada es:
import re # pycharm 如果报错 Alt+Enter 自动导入即可
Vamos a presentar las API de uso común:
3.1 encontrar todo
El módulo de expresiones regulares de Python contiene un método findall que permiteDevuelve todas las cadenas que cumplen los requisitos como una lista。
def findall(pattern, string, flags=0):
"""Return a list of all non-overlapping matches in the string.
If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group.
Empty matches are included in the result."""
return _compile(pattern, flags).findall(string)
patternRepresenta una expresión regular, stringrepresenta la cadena original y flagsrepresenta algunas marcas de funciones especiales.
findallEl resultado es una lista que contiene todos los resultados coincidentes. Si no se encuentra ninguna coincidencia, se devuelve una lista vacía:
content = '我的电脑密码是：123456，我的手机密码是：888888，我的家门密码是：000000，勿忘！'
pwd_list = re.findall('是：(.*?)，', content)
machine_list = re.findall('我的(.*?)密码是：', content)
name_list = re.findall('名字是(.*?),', content)
print('所有密码为：{}'.format(pwd_list))
print('所属为：{}'.format(machine_list))
print('用户姓名为：{}'.format(name_list))
Es obvio que no hay ningún resultado coincidente en la Lista vacía. Aquí hay otro cambio: al hacer coincidir las contraseñas, habrá una menos como se muestra a la izquierda. La razón radica en la coincidencia. Mis reglas de coincidencia son: '是：(.*?)，', la parte de la contraseña del medio del texto que cumple estrictamente con este formato se puede extraer, y el foco está en este último ，.，勿忘！ Para extraer:
cuando necesite extraer algún contenido, use paréntesis para encerrar el contenido, para no obtener información irrelevante. Si 包含多个 “(.*?)”, como se muestra en la figura a continuación, 返回的仍然是一个列表，但是列表里面的元素变为了元组el primer elemento de la tupla es el número de cuenta y el segundo elemento es la contraseña:
Hay un flagsparámetro en el prototipo de función. Este parámetro se puede omitir; cuando no se omite, tiene algunas funciones auxiliares, como 忽略大小写, 忽略换行符etc. Aquí hay un ejemplo de ignorar líneas nuevas:
Parámetros comunes:
re.I
IGNORECASE
忽略字母大小写
re.L
LOCALE
影响 “w, “W, “b, 和 “B，这取决于当前的本地化设置。
re.M
MULTILINE
使用本标志后，‘^’和‘$’匹配行首和行尾时，会增加换行符之前和之后的位置。
re.S
DOTALL
使 “.” 特殊字符完全匹配任何字符，包括换行；没有这个标志， “.” 匹配除了换行符外的任何字符。
re.X
VERBOSE
当该标志被指定时，在 RE 字符串中的空白符被忽略，除非该空白符在字符类中或在反斜杠之后。
它也可以允许你将注释写入 RE，这些注释会被引擎忽略；
注释用 “#”号 来标识，不过该符号不能在字符串或反斜杠之后。
Referencia: Parámetro de indicadores de expresión regular de Python
3.2 búsqueda
search()El uso es el mismo que findall()el uso de , perosearch() solo devolverá la primera cadena que cumpla con los requisitos. Una vez que encuentra algo que se ajusta a sus requisitos, deja de buscar. Es especialmente útil para encontrar solo los primeros datos del texto súper grande, lo que puede mejorar en gran medida la eficiencia de ejecución del programa.
def search(pattern, string, flags=0):
"""Scan through string looking for a match to the pattern, returning
a Match object, or None if no match was found."""
return _compile(pattern, flags).search(string)
Para el resultado, si la coincidencia es exitosa, es 1. 正则表达式的对象Para obtener el resultado coincidente, debe usar .group()este método para obtener el valor interno; si no hay datos coincidentes, es None:
Solo cuando .group()el parámetro dentro es 1, se imprimirá el resultado entre paréntesis en la expresión regular.
.group()Los parametrosEl número máximo de paréntesis en la expresión regular no puede exceder. Un parámetro de 1 significa leer el contenido del primer paréntesis, un parámetro de 2 significa leer el contenido del segundo paréntesis, y así sucesivamente:
3.3 Diferencia entre ".*" y ".*?"
En el desarrollo de rastreadores, .*?estos 3 símbolos se usan principalmente juntos.
- Un punto significa cualquier carácter que no sea de nueva línea y un asterisco significa que coincide con el carácter anterior cero o cualquier número de veces. Entonces.
“.*”表示匹配一串任意长度的字符串任意次_ - En este momento, se deben agregar otros símbolos antes y después de ".*" para limitar el rango; de lo contrario, el resultado será la cadena completa original.
- Si
“.*”agrega un signo de interrogación al final, se convierte en“.*?”, ¿qué tipo de resultado se puede obtener? El signo de interrogación significa coincidir con el símbolo que lo precede 0 o 1 veces. Entonces.“.*?” 的意思就是匹配一个能满足要求的最短字符串_
El “(.*)”resultado es una lista con un solo elemento, que es una cadena muy larga.
El resultado de usar “(.*?)”esto es una lista de 3 elementos, cada uno de los cuales corresponde directamente a cada contraseña en el texto original.
Resumir:
- ①
“.*”：贪婪模式，获取最长的满足条件的字符串。 - ②
“.*?”：非贪婪模式，获取最短的能满足条件的字符串。
4. Habilidades de extracción de expresiones regulares
4.1 No es necesario usar compilar
def findall(pattern, string, flags=0):
"""Return a list of all non-overlapping matches in the string.
If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group.
Empty matches are included in the result."""
return _compile(pattern, flags).findall(string)
def compile(pattern, flags=0):
"Compile a regular expression pattern, returning a Pattern object."
return _compile(pattern, flags)
Cuando se usa re.compile(), el método se llama dentro del programa _compile(), cuando se usa re.finall(), el método se llama automáticamente primero dentro del módulo _compile()y luego se llama al método findall(). re.findall()Viene con su propia re.compile()función, por lo que no hay necesidad de usarlo re.compile().
4.2 Coger primero lo grande y luego lo pequeño
Algunos contenidos no válidos y contenidos válidos pueden tener las mismas reglas. En este caso es fácil mezclar contenido válido e inválido, como en el siguiente texto:
有效用户:
姓名: 张三
姓名: 李四
姓名: 王五
无效用户:
姓名: 不知名的小虾米
姓名: 隐身的张大侠
Los nombres de usuarios válidos y usuarios no válidos están precedidos por "nombre: ". Si se usan “姓名: (.*?)\n”para hacer coincidir, la información válida y la información no válida se mezclarán, lo que dificultará la distinción:
Para resolver este problema, debe usar la técnica de atrapar lo grande y luego lo pequeño. Primero haga coincidir el usuario efectivo como un todo y luego haga coincidir el nombre del usuario efectivo:
4.3 Dentro y fuera de paréntesis
En el ejemplo anterior, 括号y “.*?”se usan juntos, por lo que algunos lectores pueden pensar que solo puede haber estos tres tipos de caracteres entre paréntesis, y ningún otro carácter ordinario. Pero, de hecho, también puede haber otros caracteres entre paréntesis, y el efecto en el resultado de la coincidencia es el siguiente:
De hecho, no es difícil de entender, solo recuerda: " 按照匹配规则查找，括号内的被提取"!