Comodines Regex usando el módulo Re en Python

  2. HowTo
  3. How-To's de Python
  4. Comodines Regex usando el módulo Re en …
Jay Shaw 10 octubre 2023
Python Python Regex
  1. Use la función re.sub() para operaciones Regex usando comodines en Python
  2. Reemplazar coincidencias en expresiones regulares usando el módulo re.sub() en Python
  3. Comprender cómo usar comodines con el submódulo re.sub()
  4. Use dos o más comodines Regex juntos en Python
  5. Realice operaciones en cadenas usando el patrón Regex y la función re.sub() agregando un comodín en Python
  6. Conclusión
Comodines Regex usando el módulo Re en Python

Los comodines se utilizan en expresiones regulares como símbolo para representar o intercambiar uno o más caracteres. Estos se utilizan principalmente para simplificar los criterios de búsqueda.

Este artículo explica en detalle cómo usar re.sub() con un comodín en Python para hacer coincidir cadenas de caracteres con expresiones regulares.

Use la función re.sub() para operaciones Regex usando comodines en Python

El módulo re en Python se usa para operaciones en expresiones regulares (RegEx). Estas son cadenas únicas de caracteres que se utilizan para encontrar una cadena o un grupo de cadenas.

Comparar un texto con un patrón específico puede determinar si está presente o ausente.

También puede dividir un patrón en uno o más subpatrones. El soporte Regex está disponible en Python a través del módulo re.

Su objetivo principal es buscar una cadena dentro de una expresión regular.

Antes de que entendamos cómo usar re.sub() con un comodín en Python, aprendamos la implementación de la función re.sub() en sentencias de cadenas normales.

Reemplazar coincidencias en expresiones regulares usando el módulo re.sub() en Python

La función re.sub() reemplaza una o más coincidencias en el texto dado con una cadena.

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

Devuelve la cadena creada sustituyendo el reemplazo repl por las ocurrencias no superpuestas más a la izquierda del patrón en la cadena.

En ausencia de una coincidencia, la cadena se devuelve en su forma original. Si repl es una cadena, se procesa cualquier escape de barra invertida. El repl también puede ser una función.

Entendamos el ejemplo de código a continuación.

import re

rex = "[0-9]+"
string_reg = "ID - 54321, Pay - 586.32"
repl = "NN"

print("Original string")
print(string_reg)

result = re.sub(rex, repl, string_reg)

print("After replacement")
print(result)

Lo que hace el código:

  1. La primera línea de código importa el módulo re.
  2. El patrón a buscar se almacena dentro de la variable rex. El cuantificador - [0-9]+ implica un grupo de dígitos que van del 0 al 9 cuyos lugares decimales pueden extenderse a cualquier número de dígitos.
  3. La cadena sobre la que se implementará la suboperación se almacena dentro de la variable string_reg.
  4. La cadena para reemplazar el patrón se almacena dentro de la variable repl.
  5. La operación re.sub() busca el patrón rex dentro de la variable de cadena string_reg y lo reemplaza con repl. La cadena devuelta se almacena dentro de la variable resultado.
result = re.sub(rex, repl, string_reg)

Salida: Todos los dígitos numéricos se reemplazan con 'NN', mientras que todos los alfabéticos se dejan intactos.

Original string
ID - 54321, Pay - 586.32
After replacement
ID - NN, Pay - NN.NN

Comprender cómo usar comodines con el submódulo re.sub()

Este artículo se centra principalmente en cuatro tipos de comodines: . (Punto), *, ?, y +. Aprender lo que hace cada uno de ellos es importante para aprender a usar re.sub() con un comodín en Python.

  1. . (El Punto) - Usa re.sub con el . comodín en Python para coincidir con cualquier carácter excepto una nueva línea. El módulo re se importa en el programa a continuación, y tres instancias de cadena se almacenan dentro de una variable de cadena string_reg.

    Usar re.sub() con . comodín en Python, la variable string_reg se sobrescribe con el resultado devuelto por la función re.sub(). Como el punto coincide con un nuevo carácter, el programa busca el patrón anuncio y cualquier número de d que se repiten después de anuncio.

    En la salida, se puede ver que cada vez que el programa encuentra un patrón anuncio, lo reemplaza con ELIMINADO.

    import re

string_reg = "a23kaddhh234 ... add2asdf675 ... xxxadd2axxx"

string_reg = re.sub(r"ad.", "REMOVED ", string_reg)
print(string_reg)

    Producción:

    a23kREMOVED hh234 ... REMOVED 2asdf675 ... xxxREMOVED 2axxx

  2. El asterisco (*): use re.sub() con este comodín en Python para dar al RE anterior tantas repeticiones como sea posible, haciendo coincidir 0 o más de esas repeticiones en el RE resultante.

    Por ejemplo, ad* coincide con las letras 'a', 'ad' o 'a' seguido de cualquier número de d.

    Se puede ver en el resultado aquí que cada instancia de 'a' y 'ad' se reemplaza con la palabra clave 'PATCH'.

    import re

string_reg = "a23kaddhh234 ... add2asdf675 ... xxxadd2axxx"

string_reg = re.sub(r"ad*", "PATCH", string_reg)
print(string_reg)

    Producción:

    PATCH23kPATCHhh234 ... PATCH2PATCHsdf675 ... xxxPATCH2PATCHxxx

  3. El +: use re.sub() con este comodín en Python para hacer coincidir 1 o más repeticiones del RE anterior en el nuevo RE. Ad+ no coincidirá con 'a'; en su lugar, coincide con 'a' seguido de cualquier número distinto de cero de d.

    La función busca el patrón 'ad....' donde '...' representa el número repetido del siguiente RE 'd' y lo reemplaza con 'POP'.

    import re

string_reg = "a23kaddhh234 ... add2asdf675 ... xxxadd2axxx"

string_reg = re.sub(r"ad+", "POP", string_reg)
print(string_reg)

    Producción:

    a23kPOPhh234 ... POP2asdf675 ... xxxPOP2axxx

  4. El ? - hace coincidir el siguiente RE con las 0 o 1 repeticiones del anterior RE. El patrón anuncio? coincide con 'a' o 'ad'.

    El programa encuentra las instancias de 'a' o 'ad' y las reemplaza con la expresión regular (REGEX) 'POP'.

    import re

string_reg = "a23kaddhh234 ... add2asdf675 ... xxxadd2axxx"

string_reg = re.sub(r"ad?", "POP", string_reg)
print(string_reg)

    Producción:

    POP23kPOPdhh234 ... POPd2POPsdf675 ... xxxPOPd2POPxxx

Use dos o más comodines Regex juntos en Python

A veces, usar re.sub() con un comodín en Python con un solo cuantificador no es suficiente para obtener el resultado deseado. La combinación de cuantificadores permite la posibilidad de pasar patrones más complejos al sistema.

Entendamos algunos de ellos.

  1. El *?, +?, ?? - En los ejemplos anteriores, hemos aprendido acerca de los cuantificadores ‘.’, ‘+’, ‘*’. Todos ellos son codiciosos, lo que implica que coinciden con la mayor cantidad de texto posible.

    Por ejemplo, si RE<.*> se compara con <a> b <c>, coincidirá con la cadena completa en lugar de solo con <a>, que a menudo no es el comportamiento deseado.

    El ? El cuantificador se agrega al final para resolver el problema. El cuantificador le indica que haga la coincidencia de una manera mínima o no codiciosa, lo que implica que se emparejan la menor cantidad de caracteres.

    Solo <a> coincidirá cuando se utilice el patrón RE<.*?>.

    import re

string_reg = "as56ad5 ... dhgasd55df ... xxxadd2axxx"

string_reg = re.sub(r"ad*?", "SUGAR", string_reg)
print(string_reg)

    Salida: El anuncio*? el cuantificador busca instancias de sólo 'a'.

    SUGARs56SUGARd5 ... dhgSUGARsd55df ... xxxSUGARdd2SUGARxxx

    Para ad+?: Busca la instancia de sólo 'ad'.

    as56SUGAR5 ... dhgasd55df ... xxxSUGARd2axxx

    Para ad??: También busca instancias de solo 'a'.

    SUGARs56SUGARd5 ... dhgSUGARsd55df ... xxxSUGARdd2SUGARxxx

  2. Los *+, ++, ?+ (también conocidos como cuantificadores posesivos) - Similares a los cuantificadores '*', '+' y '?', aquellos con la coincidencia '+' con la mayor frecuencia posible.

    Cuando la expresión posterior no coincide, no permiten retroceder como lo hacen los cuantificadores codiciosos. Este tipo de cuantificador se conoce como cuantificador posesivo.

    Por ejemplo, a*a coincidirá con "aaaa" ya que a* coincide con las cuatro a, pero cuando se encuentra la última "a", la expresión retrocede y a* solo coincide tres a en total con la "a" final coincidiendo con la cuarta "a".

    Pero cuando la expresión a*+a se usa para hacer coincidir "aaaa", a*+ coincidirá con las cuatro "a", pero no se puede retroceder y no coincidirá con el final a*+ ya que no puede encontrar más caracteres que coincidan.

    Los equivalentes de x*+, x++ y x?+ son (?>x*), (?>x+) y (?>x?) respectivamente. Veamos el programa para entender mejor el concepto.

    import regex

string_reg = "as56ad5 ... dhgasd55df ... xxxadd2axxx"

string_reg = regex.sub(r"ad*+", "SUGAR", string_reg)
print(string_reg)

    Nota: El módulo re no admite cuantificadores posesivos. Utilice el módulo regex() en su lugar.

    Salida: Encuentra la instancia de a o 'adddd....'.

    SUGARs56SUGAR5 ... dhgSUGARsd55df ... xxxSUGAR2SUGARxxx

    Para ad++: encuentra una instancia de 'ad' o 'adddd....'.

    as56SUGAR5 ... dhgasd55df ... xxxSUGAR2axxx

    Para ad+?: Se comporta igual que ad++.

    as56SUGAR5 ... dhgasd55df ... xxxSUGARd2axxx

Realice operaciones en cadenas usando el patrón Regex y la función re.sub() agregando un comodín en Python

Hemos aprendido a usar el re.sub() con un comodín en Python. Ahora usaremos los conceptos juntos para buscar un patrón de cadena en un Regex y reemplazaremos la palabra completa en lugar de solo el patrón de cadena.

El enunciado del problema nos presenta una cadena y un patrón. El patrón debe buscarse dentro de la cadena dada.

Una vez encontrada, la función re.sub() reemplazará la palabra completa.

Ejemplo: reemplazar la palabra completa cuando el patrón se encuentra al principio

  1. Importar el módulo re.

  2. Cree una variable string_reg y almacene cualquier valor de cadena. Aquí, se almacena una cadena compuesta, lo que significa que la función re.sub() implementará su efecto en los cuatro grupos dentro de la cadena.

    string_reg = """\
    23khadddddh234 > REMOVED23khh234
    add2asdf675 > REMOVED2asdf675"""

  3. La función necesita encontrar un patrón dentro de la cadena, que reemplaza la cadena completa cuando se encuentra. El patrón a encontrar es 'sumar', por lo que se utiliza una combinación de cuantificadores para lograr el resultado deseado.

    La combinación debe ser de una manera que coincida con 'ad', 'add' o 'addddd'. Sin embargo, ni add23khh234 ni add2asdf675 deberían coincidir.

    La mejor manera de hacerlo es usar add.+?.

    string_reg = re.sub(r"add.+? ", "REMOVED ", string_reg)

Código:

import re

string_reg = """\
... 23khadddddh234 > REMOVED23khh234
... add2asdf675 > REMOVED2asdf675"""

string_reg = re.sub(r"add.+? ", "REMOVED ", string_reg)
print(string_reg)

Salida: El programa busca 'ad...', y cuando lo encuentra, lo reemplaza con repl 'REMOVED'. Si el 'anuncio...' aparece al principio, reemplaza la palabra completa.

... 23khREMOVED > REMOVED23khh234
... REMOVED > REMOVED2asdf675

Conclusión

Se presenta una vívida descripción de cómo usar re.sub() con un comodín en Python. La primera sección del artículo se centra en el uso de la función de Python re.sub con REGEX simple.

Luego se explica en detalle el concepto de usar comodines con re.sub().

Después de leer el artículo, el lector puede usar fácilmente re.sub() con un comodín en Python y crear programas que busquen patrones de cadenas en REGEX.

Artículo relacionado - Python Regex