Expresión regular en Python con ejemplos | Serie 1

Una expresión regular (RegEx) es una secuencia especial de caracteres que utiliza un patrón de búsqueda para encontrar una string o un conjunto de strings. Puede detectar la presencia o ausencia de un texto comparándolo con un patrón particular y también puede dividir un patrón en uno o más subpatrones. Python proporciona un módulo re que admite el uso de expresiones regulares en Python. Su función principal es ofrecer una búsqueda, donde toma una expresión regular y una string. Aquí, devuelve la primera coincidencia o ninguna.

Ejemplo:

import re
 
s = 'GeeksforGeeks: A computer science portal for geeks'
 
match = re.search(r'portal', s)
 
print('Start Index:', match.start())
print('End Index:', match.end())

Start Index: 34
End Index: 40

El código anterior proporciona el índice inicial y el índice final del portal de strings. 

Nota: Aquí el carácter r (r’portal’) significa raw, no regex. La string sin formato es ligeramente diferente de una string normal, no interpretará el carácter \ como un carácter de escape. Esto se debe a que el motor de expresiones regulares usa el carácter \ para su propio propósito de escape.

Antes de comenzar con el módulo de expresiones regulares de Python, veamos cómo escribir expresiones regulares usando metacaracteres o secuencias especiales. 

metacaracteres

Para comprender la analogía de RE, los metacaracteres son útiles, importantes y se utilizarán en las funciones del módulo re. A continuación se muestra la lista de metacaracteres.

Analicemos cada uno de estos metacaracteres en detalle. 

\ – Barra invertida

La barra invertida (\) asegura que el carácter no sea tratado de manera especial. Esto puede considerarse una forma de escapar de los metacaracteres. Por ejemplo, si desea buscar el punto (.) en la string, encontrará que el punto (.) se tratará como un carácter especial como uno de los metacaracteres (como se muestra en la tabla anterior). Entonces, para este caso, usaremos la barra invertida (\) justo antes del punto (.) para que pierda su especialidad. Vea el siguiente ejemplo para una mejor comprensión.

Ejemplo: 

import re
 
s = 'geeks.forgeeks'
 
# without using \
match = re.search(r'.', s)
print(match)
 
# using \
match = re.search(r'\.', s)
print(match)

<_sre.SRE_Match object; span=(0, 1), match='g'>
<_sre.SRE_Match object; span=(5, 6), match='.'>

[] – Corchetes

Los corchetes ([]) representan una clase de caracteres que consta de un conjunto de caracteres que deseamos hacer coincidir. Por ejemplo, la clase de carácter [abc] coincidirá con cualquier a, b o c. 

También podemos especificar un rango de caracteres usando – dentro de los corchetes. Por ejemplo, 

• [0, 3] es muestra como [0123]
• [ac] es lo mismo que [abc]

También podemos invertir la clase de carácter usando el símbolo de intercalación (^). Por ejemplo, 

• [^0-3] significa cualquier número excepto 0, 1, 2 o 3
• [^ac] significa cualquier carácter excepto a, b o c

^ – Intercalación

El símbolo de intercalación (^) coincide con el comienzo de la string, es decir, comprueba si la string comienza con los caracteres dados o no. Por ejemplo –  

• ^g verificará si la string comienza con g, como geeks, globe, girl, g, etc.
• ^ge verificará si la string comienza con ge, como geeks, geeksforgeeks, etc.

$– dólar

El símbolo de dólar ($) coincide con el final de la string, es decir, comprueba si la string termina con los caracteres dados o no. Por ejemplo – 

• s$buscará la string que termina con geeks, extremos, s, etc.
• ks$buscará la string que termina con ks, como geeks, geeksforgeeks, ks, etc.

. – Punto

El símbolo de punto (.) coincide con un solo carácter excepto el carácter de nueva línea (\n). Por ejemplo –  

• ab buscará la string que contiene cualquier carácter en el lugar del punto, como acb, acbd, abbb, etc.
• .. comprobará si la string contiene al menos 2 caracteres

| – O

El símbolo or funciona como el operador or, lo que significa que verifica si el patrón antes o después del símbolo or está presente en la string o no. Por ejemplo –  

• a|b coincidirá con cualquier string que contenga a o b, como acd, bcd, abcd, etc.

? – Signo de interrogación

El signo de interrogación (?) comprueba si la string antes del signo de interrogación en la expresión regular aparece al menos una vez o no aparece en absoluto. Por ejemplo –  

• ab?c coincidirá con la string ac, acb, dabc pero no coincidirá con abbc porque hay dos b. De manera similar, no coincidirá con abdc porque b no va seguido de c.

* – Estrella

El símbolo de estrella (*) coincide con cero o más apariciones de la expresión regular que precede al símbolo *. Por ejemplo –  

• ab*c coincidirá con la string ac, abc, abbbc, dabc, etc. pero no coincidirá con abdc porque b no va seguida de c.

+ – Más

El símbolo más (+) coincide con una o más apariciones de la expresión regular que precede al símbolo +. Por ejemplo –  

• ab+c coincidirá con la string abc, abbc, dabc, pero no con ac, abdc porque no hay b en ac y b no va seguida de c en abdc.

{m, n} – Llaves

Las llaves coinciden con las repeticiones que preceden a la expresión regular de m a n, ambas inclusive. Por ejemplo –  

• a{2, 4} coincidirá con la string aaab, baaaac, gaad, pero no coincidirá con strings como abc, bc porque solo hay una a o ninguna a en ambos casos.

(<regex>) – Grupo

El símbolo de grupo se utiliza para agrupar subpatrones. Por ejemplo –  

• (a|b)cd coincidirá con strings como acd, abcd, gacd, etc.

Secuencias Especiales

Las secuencias especiales no coinciden con el carácter real en la string, sino que indican la ubicación específica en la string de búsqueda donde debe ocurrir la coincidencia. Facilita la escritura de patrones de uso común.  

Lista de secuencias especiales 

Módulo Regex en Python

Python tiene un módulo llamado re que se usa para expresiones regulares en Python. Podemos importar este módulo usando la declaración de importación .

Ejemplo: Importación del módulo re en Python 

import re

Veamos varias funciones proporcionadas por este módulo para trabajar con expresiones regulares en Python. 

re.findall()

Devuelve todas las coincidencias no superpuestas del patrón en la string, como una lista de strings. La string se escanea de izquierda a derecha y las coincidencias se devuelven en el orden encontrado.

Ejemplo: encontrar todas las ocurrencias de un patrón 

# A Python program to demonstrate working of
# findall()
import re
 
# A sample text string where regular expression
# is searched.
string = """Hello my Number is 123456789 and
            my friend's number is 987654321"""
 
# A sample regular expression to find digits.
regex = '\d+'
 
match = re.findall(regex, string)
print(match)
 
# This example is contributed by Ayush Saluja.

['123456789', '987654321']

re.compilar() 

Las expresiones regulares se compilan en objetos de patrón, que tienen métodos para varias operaciones, como buscar coincidencias de patrones o realizar sustituciones de strings. 

Ejemplo 1:

# Module Regular Expression is imported
# using __import__().
import re
 
# compile() creates regular expression
# character class [a-e],
# which is equivalent to [abcde].
# class [abcde] will match with string with
# 'a', 'b', 'c', 'd', 'e'.
p = re.compile('[a-e]')
 
# findall() searches for the Regular Expression
# and return a list upon finding
print(p.findall("Aye, said Mr. Gibenson Stark"))

Producción: 

['e', 'a', 'd', 'b', 'e', 'a']

Comprender la salida: 

• La primera aparición es ‘e’ en «Aye» y no ‘A’, ya que distingue entre mayúsculas y minúsculas.
• La siguiente aparición es ‘a’ en «dicho», luego ‘d’ en «dicho», seguida de ‘b’ y ‘e’ en «Gibenson», la última ‘a’ coincide con «Stark».
• La barra invertida del metacarácter ‘\’ tiene un papel muy importante ya que señala varias secuencias. Si la barra invertida se va a usar sin su significado especial como metacarácter, use ‘\\’

Ejemplo 2: Establecer clase [\s,.] coincidirá con cualquier carácter de espacio en blanco, ‘,’ o ‘.’ . 

import re
 
# \d is equivalent to [0-9].
p = re.compile('\d')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))
 
# \d+ will match a group on [0-9], group
# of one or greater size
p = re.compile('\d+')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))

Producción: 

['1', '1', '4', '1', '8', '8', '6']
['11', '4', '1886']

Ejemplo 3:

import re
 
# \w is equivalent to [a-zA-Z0-9_].
p = re.compile('\w')
print(p.findall("He said * in some_lang."))
 
# \w+ matches to group of alphanumeric character.
p = re.compile('\w+')
print(p.findall("I went to him at 11 A.M., he \
said *** in some_language."))
 
# \W matches to non alphanumeric characters.
p = re.compile('\W')
print(p.findall("he said *** in some_language."))

Producción: 

['H', 'e', 's', 'a', 'i', 'd', 'i', 'n', 's', 'o', 'm', 'e', '_', 'l', 'a', 'n', 'g']
['I', 'went', 'to', 'him', 'at', '11', 'A', 'M', 'he', 'said', 'in', 'some_language']
[' ', ' ', '*', '*', '*', ' ', ' ', '.']

Ejemplo 4:

import re
 
# '*' replaces the no. of occurrence
# of a character.
p = re.compile('ab*')
print(p.findall("ababbaabbb"))

Producción: 

['ab', 'abb', 'a', 'abbb']

Comprender la salida: 

• Nuestro RE es ab*, el cual ‘a’ acompañado de cualquier no. de ‘b’s, a partir de 0.
• La salida ‘ab’ es válida debido a que la única ‘a’ está acompañada de la única ‘b’.
• La salida ‘abb’ es válida debido a que solo ‘a’ está acompañada de 2 ‘b’.
• La salida ‘a’ es válida debido a que solo ‘a’ está acompañada de 0 ‘b’.
• La salida ‘abbb’ es válida debido a que solo ‘a’ está acompañada de 3 ‘b’.

re.dividir() 

Divida la string por las ocurrencias de un carácter o un patrón, al encontrar ese patrón, los caracteres restantes de la string se devuelven como parte de la lista resultante. 

Sintaxis: 

re.split(pattern, string, maxsplit=0, flags=0)

El primer parámetro, el patrón denota la expresión regular, la string es la string dada en la que se buscará el patrón y en la que se produce la división, maxsplit si no se proporciona se considera cero ‘0’, y si se proporciona cualquier valor distinto de cero, entonces a lo sumo que se produzcan muchas divisiones. Si maxsplit = 1, entonces la string se dividirá una sola vez, lo que dará como resultado una lista de longitud 2. Las banderas son muy útiles y pueden ayudar a acortar el código, no son parámetros necesarios, por ejemplo: banderas = re.IGNORECASE, en esta división , se ignorarán las mayúsculas y minúsculas, es decir, las minúsculas o las mayúsculas.

Ejemplo 1:

from re import split
 
# '\W+' denotes Non-Alphanumeric Characters
# or group of characters Upon finding ','
# or whitespace ' ', the split(), splits the
# string from that point
print(split('\W+', 'Words, words , Words'))
print(split('\W+', "Word's words Words"))
 
# Here ':', ' ' ,',' are not AlphaNumeric thus,
# the point where splitting occurs
print(split('\W+', 'On 12th Jan 2016, at 11:02 AM'))
 
# '\d+' denotes Numeric Characters or group of
# characters Splitting occurs at '12', '2016',
# '11', '02' only
print(split('\d+', 'On 12th Jan 2016, at 11:02 AM'))

Producción: 

['Words', 'words', 'Words']
['Word', 's', 'words', 'Words']
['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']
['On ', 'th Jan ', ', at ', ':', ' AM']

Ejemplo 2:

import re
 
# Splitting will occurs only once, at
# '12', returned list will have length 2
print(re.split('\d+', 'On 12th Jan 2016, at 11:02 AM', 1))
 
# 'Boy' and 'boy' will be treated same when
# flags = re.IGNORECASE
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here', flags=re.IGNORECASE))
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here'))

Producción: 

['On ', 'th Jan 2016, at 11:02 AM']
['', 'y, ', 'oy oh ', 'oy, ', 'om', ' h', 'r', '']
['A', 'y, Boy oh ', 'oy, ', 'om', ' h', 'r', '']

re.sub() 

El ‘sub’ en la función significa SubString, se busca un cierto patrón de expresión regular en la string dada (tercer parámetro), y al encontrar el patrón de substring se reemplaza por repl (segundo parámetro), el conteo verifica y mantiene el número de veces esto ocurre. 

Sintaxis:

 re.sub(pattern, repl, string, count=0, flags=0)

Ejemplo 1:

import re
 
# Regular Expression pattern 'ub' matches the
# string at "Subject" and "Uber". As the CASE
# has been ignored, using Flag, 'ub' should
# match twice with the string Upon matching,
# 'ub' is replaced by '~*' in "Subject", and
# in "Uber", 'Ub' is replaced.
print(re.sub('ub', '~*', 'Subject has Uber booked already',
             flags=re.IGNORECASE))
 
# Consider the Case Sensitivity, 'Ub' in
# "Uber", will not be replaced.
print(re.sub('ub', '~*', 'Subject has Uber booked already'))
 
# As count has been given value 1, the maximum
# times replacement occurs is 1
print(re.sub('ub', '~*', 'Subject has Uber booked already',
             count=1, flags=re.IGNORECASE))
 
# 'r' before the pattern denotes RE, \s is for
# start and end of a String.
print(re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam',
             flags=re.IGNORECASE))

Producción 

S~*ject has ~*er booked already
S~*ject has Uber booked already
S~*ject has Uber booked already
Baked Beans & Spam

re.subn() 

subn() es similar a sub() en todos los sentidos, excepto en su forma de proporcionar resultados. Devuelve una tupla con un recuento del total de reemplazo y la nueva string en lugar de solo la string. 

Sintaxis:

 re.subn(pattern, repl, string, count=0, flags=0)

Ejemplo:

import re
 
print(re.subn('ub', '~*', 'Subject has Uber booked already'))
 
t = re.subn('ub', '~*', 'Subject has Uber booked already',
            flags=re.IGNORECASE)
print(t)
print(len(t))
 
# This will give same output as sub() would have
print(t[0])

Producción 

('S~*ject has Uber booked already', 1)
('S~*ject has ~*er booked already', 2)
Length of Tuple is:  2
S~*ject has ~*er booked already

re.escape()

Devuelve una string con todos los caracteres no alfanuméricos con barra invertida, esto es útil si desea hacer coincidir una string literal arbitraria que puede tener metacaracteres de expresión regular.

Sintaxis:

re.escape(string)

Ejemplo:

import re
 
# escape() returns a string with BackSlash '\',
# before every Non-Alphanumeric Character
# In 1st case only ' ', is not alphanumeric
# In 2nd case, ' ', caret '^', '-', '[]', '\'
# are not alphanumeric
print(re.escape("This is Awesome even 1 AM"))
print(re.escape("I Asked what is this [a-9], he said \t ^WoW"))

This\ is\ Awesome\ even\ 1\ AM
I\ Asked\ what\ is\ this\ \[a\-9\]\,\ he\ said\ \    \ \^WoW

investigar()

Este método devuelve Ninguno (si el patrón no coincide) o un re.MatchObject contiene información sobre la parte coincidente de la string. Este método se detiene después de la primera coincidencia, por lo que es más adecuado para probar una expresión regular que para extraer datos.

Ejemplo: Búsqueda de una ocurrencia del patrón

# A Python program to demonstrate working of re.match().
import re
 
# Lets use a regular expression to match a date string
# in the form of Month name followed by day number
regex = r"([a-zA-Z]+) (\d+)"
 
match = re.search(regex, "I was born on June 24")
 
if match != None:
 
    # We reach here when the expression "([a-zA-Z]+) (\d+)"
    # matches the date string.
 
    # This will print [14, 21), since it matches at index 14
    # and ends at 21.
    print ("Match at index %s, %s" % (match.start(), match.end()))
 
    # We us group() method to get all the matches and
    # captured groups. The groups contain the matched values.
    # In particular:
    # match.group(0) always returns the fully matched string
    # match.group(1) match.group(2), ... return the capture
    # groups in order from left to right in the input string
    # match.group() is equivalent to match.group(0)
 
    # So this will print "June 24"
    print ("Full match: %s" % (match.group(0)))
 
    # So this will print "June"
    print ("Month: %s" % (match.group(1)))
 
    # So this will print "24"
    print ("Day: %s" % (match.group(2)))
 
else:
    print ("The regex pattern does not match.")

Match at index 14, 21
Full match: June 24
Month: June
Day: 24

Igualar objeto

Un objeto Match contiene toda la información sobre la búsqueda y el resultado y, si no se encuentra ninguna coincidencia, se devolverá None. Veamos algunos de los métodos y atributos de uso común del objeto de coincidencia.

Obtener la string y la expresión regular

El atributo match.re devuelve la expresión regular pasada y el atributo match.string devuelve la string pasada.

Ejemplo: obtener la string y la expresión regular del objeto coincidente

import re
 
s = "Welcome to GeeksForGeeks"
 
# here x is the match object
res = re.search(r"\bG", s)
 
print(res.re)
print(res.string)

re.compile('\\bG')
Welcome to GeeksForGeeks

Obtener el índice del objeto coincidente

• El método start() devuelve el índice inicial de la substring coincidente
• El método end() devuelve el índice final de la substring coincidente
• El método span() devuelve una tupla que contiene el índice inicial y final de la substring coincidente

Ejemplo: obtener el índice del objeto coincidente 

import re
 
s = "Welcome to GeeksForGeeks"
 
# here x is the match object
res = re.search(r"\bGee", s)
 
print(res.start())
print(res.end())
print(res.span())

11
14
(11, 14)

Obtener substring coincidente

El método group() devuelve la parte de la string para la que coinciden los patrones. Vea el siguiente ejemplo para una mejor comprensión.

Ejemplo: obtener una substring coincidente 

import re
 
s = "Welcome to GeeksForGeeks"
 
# here x is the match object
res = re.search(r"\D{2} t", s)
 
print(res.group())

me t

En el ejemplo anterior, nuestro patrón especifica la string que contiene al menos 2 caracteres seguidos de un espacio, y ese espacio va seguido de una t. 

Artículo relacionado: 
https://www.geeksforgeeks.org/regular-expressions-python-set-1-search-match-find/

Referencia: 
https://docs.python.org/2/library/re.html

Este artículo es una contribución de Piyush Doorwar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.