Notas de estudio de Python, registros especiales, compartir con ustedes, espero que sea de ayuda para todos.
Expresión regular
Las cadenas son la estructura de datos involucrada con más frecuencia en la programación, y la necesidad de manipularlas está casi en todas partes. Por ejemplo, para determinar si una cadena de caracteres es una dirección de correo electrónico legal, aunque es posible extraer mediante programación la subcadena antes y después de @, y luego determinar si es una palabra y un nombre de dominio, esto no solo es problemático, sino también difícil de reutilizar el código.
Las expresiones regulares son un arma poderosa para combinar cadenas. Su idea de diseño es utilizar un lenguaje descriptivo para definir una regla para una cadena. Cualquier cadena que cumpla con la regla se considera "coincidente". De lo contrario, la cadena es ilegal.
Entonces, la forma en que juzgamos si una cadena es un correo electrónico válido es:
-
Cree una expresión regular que coincida con el correo electrónico;
-
Utilice la expresión regular para que coincida con la entrada del usuario para determinar si es legal.
Debido a que las expresiones regulares también están representadas por cadenas, primero debemos entender cómo usar caracteres para describir caracteres.
En la expresión regular, si el carácter se da directamente, es una coincidencia exacta. Utilice \ d para hacer coincidir un número y \ w para hacer coincidir una letra o un número, así:
- '00 \ d 'puede coincidir con' 007 ', pero no con' 00A ';
- '\ d \ d \ d' puede coincidir con '010';
- '\ w \ w \ d' puede coincidir con'py3 ';
. Puede coincidir con cualquier carácter, por lo que:
- 'py.' puede coincidir con 'pyc', 'pyo', 'py!' y así sucesivamente.
Para hacer coincidir caracteres de longitud variable, en la expresión regular, use * para representar cualquier número de caracteres (incluido 0), use + para representar al menos un carácter, use? Para representar 0 o 1 carácter, y use {n} para representar n caracteres, use {n, m} para representar nm caracteres:
veamos un ejemplo complejo: \ d {3} \ s + \ d {3,8}.
Leámoslo de izquierda a derecha:
- \ d {3} significa coincidir con 3 números, como '010';
- \ s puede coincidir con un espacio (también incluye caracteres de espacio en blanco como Tab), por lo que \ s + significa que hay al menos un espacio, por ejemplo, coincide con '', '', etc .;
- \ d {3,8} significa 3-8 números, como '1234567'.
En conjunto, las expresiones regulares anteriores pueden hacer coincidir números de teléfono con códigos de área separados por cualquier número de espacios.
¿Qué sucede si desea hacer coincidir un número como '010-12345'? Dado que'- 'es un carácter especial, en las expresiones regulares, es necesario usar' 'para escapar, por lo que el regular anterior es \ d {3} - \ d {3,8}.
Sin embargo, todavía no puede coincidir con '010-12345' debido a los espacios. Por tanto, necesitamos métodos de emparejamiento más complicados.
Avanzado
Para una coincidencia más precisa, puede utilizar [] para indicar el rango, por ejemplo:
- [0-9a-zA-Z_] puede coincidir con un número, letra o guión bajo;
- [0-9a-zA-Z _] + puede coincidir con una cadena que consta de al menos un número, letra o subrayado, como 'a100', '0_Z', 'Py3000', etc .;
- [a-zA-Z _] [0-9a-zA-Z _] * puede coincidir comenzando con una letra o guión bajo, seguido de cualquier cadena que consista en un número, letra o guión bajo, que es una variable legal de Python;
- [a-zA-Z _] [0-9a-zA-Z _] {0, 19} limita más precisamente la longitud de la variable a 1-20 caracteres (1 carácter en el frente + hasta 19 caracteres en la parte posterior).
A | B puede coincidir con A o B, por lo que (P | p) ython puede coincidir con 'Python' o 'python'.
Indica el comienzo de la línea, \ d indica que debe comenzar con un número.
Error de análisis de KaTeX: Secuencia de control no definida: \ d en la posición 8: indica el final de la línea, \ ̲d̲ indica que debe terminar con un número.
Es posible que haya notado que py también puede coincidir con 'python', pero agregar ^ py $ se convierte en una coincidencia de línea completa, que solo puede coincidir con'py '.
re módulo
Con el conocimiento de preparación, podemos usar expresiones regulares en Python. Python proporciona el módulo re, que contiene todas las funciones de expresión regular. Dado que las cadenas de Python también se escapan con \, preste especial atención a:
s = 'ABC\\-001' # Python的字符串
# 对应的正则表达式字符串变成：
# 'ABC\-001'
Por lo tanto, recomendamos encarecidamente usar el prefijo r de Python, para que no tenga que preocuparse por escapar:
s = r'ABC\-001' # Python的字符串
# 对应的正则表达式字符串不变：
# 'ABC\-001'
Primero observe cómo determinar si la expresión regular coincide:
import re
re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
re.match(r'^\d{3}\-\d{3,8}$', '010 12345')
El método match () juzga si hay una coincidencia. Si la coincidencia es exitosa, devuelve un objeto Match, de lo contrario, devuelve None. El método de juicio común es:
test = '用户输入的字符串'
if re.match(r'正则表达式', test):
print('ok')
else:
print('failed')
Cuerda partida
Dividir una cadena con expresiones regulares es más flexible que usar caracteres fijos. Consulta el código de división normal:
'a b c'.split(' ')
['a', 'b', '', '', 'c']
Bueno, los espacios continuos no se pueden reconocer, intente usar expresiones regulares:
re.split(r'\s+', 'a b c')
['a', 'b', 'c']
No importa cuántos espacios, se puede dividir normalmente. Únete, prueba:
re.split(r'[\s\,]+', 'a,b, c d')
['a', 'b', 'c', 'd']
Únete de nuevo; prueba:
re.split(r'[\s\,\;]+', 'a,b;; c d')
['a', 'b', 'c', 'd']
Si el usuario ingresa un conjunto de etiquetas, recuerde usar expresiones regulares para convertir la entrada irregular en la matriz correcta la próxima vez.
Agrupamiento
Además de simplemente juzgar si coincide, las expresiones regulares también tienen la poderosa función de extraer subcadenas. Utilice () para indicar el grupo que se extraerá. tal como:
^ (\ d {3}) - (\ d {3,8}) $ define dos grupos respectivamente, que pueden extraer directamente el código de área y el número local de la cadena coincidente:
import re
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
print m
print m.group(0)
print m.group(1)
print m.group(2)
resultado de la operación:
<_sre.SRE_Match object at 0x100249360>
010-12345
010
12345
Process finished with exit code 0
Si un grupo está definido en la expresión regular, la subcadena se puede extraer usando el método group () en el objeto Match.
Tenga en cuenta que el grupo (0) es siempre la cadena original, el grupo (1), el grupo (2) ... representan las subcadenas 1, 2, ....
La extracción de subcadenas es muy útil. Veamos un ejemplo más brutal:
t = '19:05:30'
m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
print m.groups()
resultado de la operación:
('19', '05', '30')
Process finished with exit code 0
Esta expresión regular puede identificar directamente la hora legal. Sin embargo, en algunos casos, las expresiones regulares no se pueden utilizar para completar la verificación, como identificar la fecha:
'^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'
En cuanto a fechas ilegales como '2-30' y '4-31', todavía no está reconocido por las reglas regulares, o es muy difícil escribirlas, en este momento el programa necesita cooperar con el reconocimiento.
Partido codicioso
Finalmente, es importante señalar que la coincidencia regular es una coincidencia codiciosa de forma predeterminada, es decir, la coincidencia de tantos caracteres como sea posible. Un ejemplo es el siguiente, haciendo coincidir el 0 después del número:
print re.match(r'^(\d+)(0*)$', '102300').groups()
resultado de la operación:
('102300', '')
Process finished with exit code 0
Dado que \ d + adopta la coincidencia codiciosa, coincide directamente con todos los siguientes 0. Como resultado, 0 * solo puede coincidir con la cadena vacía.
Debe hacer que \ d + use una coincidencia no codiciosa (es decir, que coincida lo menos posible) para que coincida con los siguientes 0, y agregar un?
print re.match(r'^(\d+?)(0*)$', '102300').groups()
resultado de la operación:
('1023', '00')
Process finished with exit code 0
Compilar
Cuando usamos expresiones regulares en Python, el módulo re hará dos cosas dentro:
- Compile la expresión regular, si la cadena de la expresión regular en sí es ilegal, se informará de un error;
- Utilice la expresión regular compilada para que coincida con la cadena.
Si una expresión regular se va a reutilizar miles de veces, por razones de eficiencia, podemos precompilar la expresión regular. Cuando se reutiliza, no es necesario compilar este paso y hacer coincidir directamente:
import re
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
print re_telephone.match('010-12345').groups()
print re_telephone.match('010-8086').groups()
resultado de la operación:
('010', '12345')
('010', '8086')
Process finished with exit code 0
Después de la compilación, se genera un objeto de expresión regular, dado que el objeto en sí contiene expresiones regulares, no es necesario dar una cadena regular al llamar al método correspondiente.
Bienvenido a prestar atención a la cuenta pública "Desarrollo web" , puede recibir la demostración de prueba de Python y los recursos de aprendizaje, todos aprenden Python juntos y recopilan los métodos del mundo, que es conveniente para usted y para mí desarrollar .
Espero poder ayudarlo. Si tiene alguna pregunta, puede unirse al grupo de intercambio técnico de QQ: 668562416
Si hay algo incorrecto o insuficiente, también espero que los lectores puedan brindar más comentarios o sugerencias.
Si necesita reimprimir, por favor contáctame. Puedes reimprimir con autorización, gracias
Bienvenido a prestar atención a la cuenta pública "Desarrollo web"