Expresión regular de Python

En este tema, aprenderemos expresiones regulares de Python.

Definición: Las expresiones regulares, a veces llamadas re o regex o regexp, son secuencias de caracteres para coincidir con patrones en texto/cadena. Python tiene un módulo re construido para realizar esto.

Los usos comunes de una expresión regular son:

1. Buscar una cadena (buscar y buscar)
2. Encuentra todas las cadenas coincidentes (findall)
3. Split String en subcadena (dividido)
4. Reemplazar parte de una cadena (sub)

Una expresión regular es una combinación de alfabetos, metacharacteres. Entonces, los siguientes metacharacteres están disponibles.

• \ Esto se usa para dejar/ignorar el significado especial del carácter
• [] Esto indica una clase de caracteres EX: [A-Z], [A-ZA-Z0-9]
• ^ Esto coincide con el comienzo del texto
• $ Esto coincide con el final del texto
• . Esto coincide con cualquier personaje excepto Newline
• ? Coincidir con cero o uno.
• | Medios o (coincidir con cualquiera de los personajes separados por él.
• * Cualquier número de ocurrencias (incluidos 0 ocurrencias)
• + Uno o más ocurrencias
• Indican varias ocurrencias de una RE anterior para que coincida.
• () Encerrar un grupo de regexp

Si usamos invernada de inalcavil '\', indica varias secuencias. Quiero usar barra inalcadora sin su significado especial, use '\\'.

• \ d coincide con cualquier dígito decimal, esto es lo mismo que la clase de set [0-9]
• \ D coincide con cualquier personaje no dígito
• \ s coincide con cualquier personaje de espacio blanco.
• \ S coincide con cualquier personaje que no sea blanco
• \ W coincide con cualquier carácter alfanumérico; Esto es lo mismo que una clase [A-ZA-Z0-9_].
• \ W coincide con cualquier carácter no alfanumérico.

El siguiente método disponible en el módulo RE:

riñonalmi.buscar() :

Este método devuelve la parte coincidente de la cadena y se detiene después del primer partido. Por lo tanto, esto se puede usar para probar una expresión en lugar de extraer datos.

Sintaxis: re.búsqueda (patrón, cadena)
Valor de retorno:
Ninguno : el patrón no coincide
Cadena : patrón coincidente

Ex: En este ejemplo buscará el mes y la fecha

importar
regexp = r "([a-lza-z]+) (\ d+)"
Match = Re.Buscar (Regexp, "El cumpleaños de mi hijo es el 20 de julio")
Si el partido != Ninguno:
imprimir ("coincidir con índice %s, %s" %(coincidencia.inicio (), coincidir.end ()))#Esto proporciona un índice de cadena coincidente
Imprimir ("Match completo: % S" % (Match.grupo (0)))
Imprimir ("Mes: % S" % (coincidencia.grupo 1)))
Imprimir ("Día: % S" % (Partido.Grupo 2)))
demás:
imprimir ("El patrón regex dado no coincide")

re.fósforo() :

Este método busca y devuelve la primera coincidencia. Esto verifica el partido solo al comienzo de la cadena.

Sintaxis: re.Match (patrón, cadena)
Valor de retorno:
Ninguno: el patrón no coincide
Cadena: patrón coincidente

Ej: este ejemplo para mostrar el comienzo de la cadena coincidente

importar
regexp = r "([a-lza-z]+) (\ d+)"
Match = Re.Match (regexp, "20 de julio")
Si coincide == ninguno:
Imprimir ("No es una fecha válida")
demás:
Imprimir ("Cadena dada: % s" % (coincidencia.grupo()))
Imprimir ("Mes: % S" % (coincidencia.grupo 1)))
Imprimir ("Día: % S" % (Partido.Grupo 2)))

Ej: para mostrar el patrón no coincidente al principio

importar
Match = Re.Match (regexp, "Mi hijo de mi hijo es el 20 de julio")
Si coincide == ninguno:
Imprimir ("No es una fecha válida")
demás:
Imprimir ("Cadena dada: % s" % (coincidencia.grupo()))
Imprimir ("Mes: % S" % (coincidencia.grupo 1)))
Imprimir ("Día: % S" % (Partido.Grupo 2)))

re.encuentra todos() :

Este método devuelve todas las coincidencias de patrón en una cadena. La cadena se busca de principio a fin, y las coincidencias se devuelven en el orden encontrado.

Sintaxis : re.findall (patrón, cadena)
Valor de retorno
String vacía ([)]: el patrón no coincide
Lista de cadena: patrón coincidente

Ej: expresión regular para encontrar dígitos

importar
String = "" "Bangalore Pincode es 560066 y
Gulbarga Pincode es 585101 "" "
regexp = '\ d+'
Match = Re.findall (regexp, string)
imprimir (coincidir)

Ej: Encuentra el número de móvil (número exacto de 10 dígitos) del texto dado

importar
String = "" "Número de oficina de Bangalore 1234567891,
Mi número es 8884278690, contacto de emergencia 3456789123
Número no válido 898883456 "" "
regexp = '\ d 10'#Esta expresión regular para que coincida con un número exacto de 10 dígitos
Match = Re.findall (regexp, string)
imprimir (coincidir)

re.compilar():

Las expresiones regulares se compilan en objetos de patrón y se pueden usar en métodos. Ejemplo de búsqueda de coincidencias de patrones, sustituciones de cadenas.

Ex:

importar
e = Re.compilar ('[a-e]')
Impresión (E.findall ("Nací a los 11 años.METRO. el 20 de julio de 1989 "))
e = Re.compilar ('\ d') # \ d es equivalente a [0-9].
Impresión (E.findall ("Nací a los 11 años.METRO. el 20 de julio de 1989 "))
P = Re.compilar ('\ d+')#grupo de uno o más dígitos
Imprimir (P.findall ("Nací a los 11 años.METRO. el 20 de julio de 1989 "))

re.dividir():

Cadena dividida basada en ocurrencias de un patrón. Si se encuentra el patrón, los caracteres restantes de la cadena se devuelven como parte de la lista resultante. Podemos especificar la división máxima para una cadena dada.

Sintaxis - re.división (patrón, cadena, maxsplit = 0)
Valores de retorno:
Lista vacía ([]): el patrón no coincide
Lista de cadena: patrón coincidente

Ex:

importar
# '\ W+' coincide con personajes no alfanuméricos o grupo de personajes
# dividido al encontrar ',' o espacios en blanco "
Imprimir (RE.Split ('\ w+', 'bueno, mejor, mejor'))
Imprimir (RE.Split ('\ w+', "Libros de libros de libros"))
# Aquí ':', ", ',' no son alfanuméricos donde ocurre la división
Imprimir (RE.Split ('\ w+', 'nacido el 20 de julio de 1989, a las 11:00 a.m.'))
# '\ d+' denota caracteres numéricos o grupo de caracteres
# La división ocurre en '20', '1989', '11', '00'
Imprimir (RE.Split ('\ d+', 'nacido el 20 de julio de 1989, a las 11:00 a.m.'))
# División máxima especificada como 1
Imprimir (RE.Split ('\ d+', 'nacido el 20 de julio de 1989, a las 11:00
Am ', maxsplit = 1))

re.sub():

Aquí el significado 'sub' es una subcadena. En esta función, la expresión regular dada (parámetro de patrón) coincide en la cadena dada (parámetro de cadena); Si se encuentra la subcadena, se reemplaza por un parámetro REPL.
Aquí en el recuento, especifique el número de veces que se reemplaza el Regex.
Aquí podemos especificar la bandera regex (Ej: RE. IGNORAR CASO)

Sintaxis:- re.sub (patrón, repl, string, count = 0, flags = 0)
Valor de retorno:
Devuelve una nueva cadena después de reemplazar un patrón más
Devuelve la misma cadena

Ex:

importar
# Ej: Patrón 'llly' coincide con la cadena en "con éxito" y "vellosa"
Imprimir (RE.Sub ('Lly', '#$', 'Cita de médico reservado con éxito en Delly'))
# Ej: Case Hasbeen ignorado, usando la bandera, 'lly' coincidirá dos veces con la cadena
# Después de coincidir, 'Lly' se reemplaza por '~*' en "con éxito" y "Delly".
Imprimir (RE.sub ('lly', '#$', 'cita de médico reservada con éxito en Delly', flags = re.IGNORAR CASO))
# Ej: CASE SENSTIVIVIDAD, 'LLY' no será replicado.
Imprimir (RE.Sub ('Lly', '#$', 'Cita de médico reservado con éxito en Delly'))
# EX: AS Count = 1, el reemplazo de tiempos máximos se produce es 1
Imprimir (RE.sub ('lly', '#$', 'cita de médico reservada con éxito en Delly', count = 1, flags = re.IGNORAR CASO))

re.Subn ():

funcionalidad subn () igual que sub () en todas las formas; La única diferencia es proporcionar salida. Devuelve una tupla que contiene un recuento de un total de reemplazo y la nueva cadena.
Sintaxis:- re.Subn (Patrón, Repl, String, Count = 0, Flags = 0)

Ex:

importar
Imprimir (RE.Subn ('Lly', '#$', 'Cita de médico reservado con éxito en Delly'))
t = re.Subn ('Lly', '#$', 'Cita de médico reservado con éxito en Delly', Flags = re.IGNORAR CASO)
Imprimir (t)
Imprimir (Len (T))
# Esto dará la misma salida que Sub ()
Imprimir (T [0])

re.escapar() :

Esto devuelve la cadena con la barra insegura '\' antes de cada carácter no alfanumérico. Esto es útil si queremos que coincidan con una cadena literal arbitraria que puede tener metacharacteres de expresión regulares.
Sintaxis:- re.Escape (cadena)
Ex:

importar
# El caso debajo tiene solo ", no es alfanumérico
Imprimir (RE.Escape ("Cita médica reservada con éxito a la 1 p.m."))
# El caso debajo tiene, ", Caret '^', '-', '[]', '\' no son alfanuméricos
Imprimir (RE.Escape ("preguntó qué es esto [0-9], dije \ t ^clase numérica"))

Conclusión:

El artículo cubrió las cosas necesarias para comprender la expresión regular en cualquier aplicación. Hemos aprendido varios métodos y meta caracteres presentes en Python Regexp utilizando ejemplos.