Código:

DIRECCIÓN ACADÉMICA CT-FO-02-05

Revisión: 1

Página:
INFORME TÉCNICO
1 de 26

TITULO
Lenguajes y Autómatas I
PROGRAMA EDUCATIVO.
NOMBRE.
P1 Actividad 1 FU2 Expresiones regulares

ELABORADO
Efrain Uc Salvador

FECHA DE ELABORACION: 14 DE mayo DE 2018

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
2 de 26

INDICE.

Contenido
I INTRODUCCION. ......................................................................................................................... 3
II JUSTIFICACIÓN ......................................................................................................................... 4
III METODOLOGIA Y DESARROLLO ....................................................................................... 5
IV OBTENCION DE RESULTADOS Y ANÁLISIS ESTADISTICOS. ................................... 23
V. RESULTADOS Y DISCUSION. ............................................................................................... 24
VI. REFERENCIAS ........................................................................................................................ 25
VII ANEXOS. .................................................................................................................................. 26
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
3 de 26

I INTRODUCCION.

En este trabajo de investigación se hablará sobre como distintos lenguajes de programación

en este caso como Java, C# y Python manejan las expresiones regulares, como las
implementan en distintas operaciones, así como las bibliotecas que utilizan para
implementarlas. Aunque de igual manera tenemos que saber o entender que son las
expresiones regulares ya que son un lenguaje para la descripción de lenguajes. Una
expresión regular define un lenguaje. Por ejemplo, la expresión regular /[a-z]+/ define el
lenguaje formado por las cadenas que consisten en repeticiones de una o más letras
minúsculas.
Las ER nos permiten filtrar textos para encontrar coincidencias, comprobar la validez de
fechas, documentos de identidad o contraseñas, se pueden utilizar para reemplazar texto
con unas características concretas por otro, y muchos más usos.
El problema es que no son intuitivas a primera vista, por lo que la solución a la que llegan
muchos programadores con experiencia que no quieren aprenderse la sintaxis a fondo es
tener un conjunto de soluciones que le han servido en el pasado y partir de alguna que se
parezca.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
4 de 26

II JUSTIFICACIÓN

Este trabajo se baso en investigar como diferentes tipos de lenguajes implementan las
expresiones regulares, las bibliotecas que usan para su implementación, así como las
diferentes operaciones que se pueden realizar con ellas, con el fin de entender mejor su
funcionalidad al momento de realizar algún programa donde vayamos a implementarlas.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
5 de 26

III METODOLOGIA Y DESARROLLO

Expresiones regulares en Java.

Las expresiones regulares son algo que se usa desde hace años en otros lenguajes de
programación como Perl, Sed o Awk. En la versión 1.4 del JDK de Sun se incluye el paquete
java.util.regex, que proporciona una serie de clases para poder hacer uso de la potencia de este
tipo de expresiones en Java. Antes de nada, necesitamos saber qué es una expresión regular y
para que nos puede servir:

Pues bien, una expresión regular es un patrón que describe a una cadena de caracteres. Todos
hemos utilizado alguna vez la expresión *.doc para buscar todos los documentos en algún lugar de
nuestro disco duro, pues bien, *.doc es un ejemplo de una expresión regular que representa a
todos los archivos con extensión doc, el asterisco significa cualquier secuencia de caracteres (vale,
los que ya conozcan esto dirán que no es correcto, y dirán bien, es más preciso hablar de *.doc
pero el ejemplo es muy gráfico).

Las expresiones regulares se rigen por una serie de normas y hay una construcción para cualquier
patrón de caracteres. Una expresión regular sólo puede contener (aparte de letras y números) los
siguientes caracteres:

< $, ^, ., *, +, ?, [, ], . >

Una expresión regular, nos servirá para buscar patrones en una cadena de texto, por ejemplo,
encontrar cuantas veces se repite una palabra en un texto, para comprobar que una cadena tiene
una determinada estructura, por ejemplo, que el nombre de archivo que nos proponen tiene una
determinada extensión, o comprobar que un email está bien escrito... Para cada uno de estos
casos existe una expresión regular que los representa:

 Por medio de la expresión regular "camión" podemos encontrar cuantas veces se repite
camión en un texto. Es la construcción más sencilla.
 Esta expresión "^www.*.es" comprueba que una cadena sea una dirección web que
comience por www y sea de un servidor español.
 Y esta, para ver la potencia de las expresiones regulares, comprueba la buena formación
de los correos electrónicos: "[^A-Za-z0-9.@_-~#]+".

Implementación.

El paquete java.util.regex está formado por dos clases, la clase Matcher y la clase Pattern y por
una excepción, PatternSyntaxException.

La clase Pattern (según la documentación del jdk1.4) es la representación compilada de una

expresión regular, o lo que es lo mismo, representa a la expresión regular, que en el paquete
java.util.regex necesita estar compilada. En castellano significa patrón.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
6 de 26

La clase Matcher es un tipo de objeto que se crea a partir de un patrón mediante la invocación del
método Pattern.matcher. Este objeto es el que nos permite realizar operaciones sobre la
secuencia de caracteres que queremos validar o la en la secuencia de caracteres en la que
queremos buscar. En castellano lo más parecido a esto es la palabra encajador.

Por lo tanto, tenemos patrones que deben ser compilados, a partir de estos creamos objetos
Matcher (encajadores) para poder realizar las operaciones sobre la cadena en cuestión.

Vamos con la clase Pattern, para crear un patrón necesitamos compilar una expresión regular,
esto lo conseguimos con el método compile:

Pattern patron = Pattern.compile("camion");

El método pattern devuelve la expresión regular que hemos compilado, el método matcher crea
un objeto Matcher a partir del patrón, el método split divide una cadena dada en partes que
cumplan el patrón compilado y por último el método matches compila una expresión regular y
comprueba una cadena de caracteres contra ella.

Ahora la clase Matcher. Esta clase se utiliza para comprobar cadenas contra el patrón indicado. Un
objeto Matcher se genera a partir de un objeto Pattern por medio del método matcher:

Pattern patron = Pattern.compile("camion");

Matcher encaja = patron.matcher();

Una vez que tenemos el objeto creado, podemos realizar tres tipos de operaciones sobre una
cadena de caracteres. Una es a través del método matches que intenta encajar toda la secuencia
en el patrón (para el patrón "camión" la cadena "camión" encajaría, la cadena "mi camión es
verde" no encajaría). Otra es a través del método lookingAt, intenta encajar el patrón en la cadena
(para el patrón "camión" tanto la cadena "camión" como la cadena "mi camión es verde"
encajaría). Otra es la proporcionada por el método find que va buscando subcadenas dentro de la
cadena de caracteres que cumplan el patrón compilado (una vez encontrada una ocurrencia, se
puede inspeccionar por medio de los métodos start que marca el primer carácter de la ocurrencia
en la secuencia y el método end que marca el ultimo carácter de la ocurrencia). Todos estos
métodos devuelven un booleano que indica si la operación ha tenido éxito.

Todo lo anterior está orientado a la búsqueda de patrones en cadenas de caracteres, pero puede
que queramos llegar más allá, que lo que queramos sea reemplazar una cadena de caracteres que
se corresponda con un patrón por otra cadena. Por ejemplo, un método que consigue esto es
replaceAll que reemplaza toda ocurrencia del patrón en la cadena por la cadena que se le
suministra.

Ejemplos.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
7 de 26

El siguiente es un ejemplo del uso del método replaceAll sobre una cadena. El ejemplo sustituye
todas las apariciones que concuerden con el patron "a*b" por la cadena "-".

// se importa el paquete java.util.regex

import java.util.regex.*;

public class EjemploReplaceAll{

public static void main(String args[]){

// compilamos el patron

Pattern patron = Pattern.compile("a*b");

// creamos el Matcher a partir del patron, la cadena como parametro

Matcher encaja = patron.matcher("aabmanoloaabmanoloabmanolob");

// invocamos el metodo replaceAll

String resultado = encaja.replaceAll("-");

System.out.println(resultado);

El siguiente ejemplo trata de validar una cadena que supuestamente contiene un email, lo hace
con cuatro comprobaciones, con un patrón cada una, la primera que no contenga como primer
caracter una @ o un punto, la segunda que no comience por www., que contenga una y solo una
@ y la cuarta que no contenga caracteres ilegales:

import java.util.regex.*;

public class ValidacionEmail {

public static void main(String[] args) throws Exception {

String input = "www.?regular.com";

// comprueba que no empieze por punto o @

Pattern p = Pattern.compile("^.|^@");

Matcher m = p.matcher(input);

if (m.find())
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
8 de 26

System.err.println("Las direcciones email no empiezan por punto o @");

// comprueba que no empieze por www.

p = Pattern.compile("^www.");

m = p.matcher(input);

if (m.find())

System.out.println("Los emails no empiezan por www");

// comprueba que contenga @

p = Pattern.compile("@");

m = p.matcher(input);

if (!m.find())

System.out.println("La cadena no tiene arroba");

// comprueba que no contenga caracteres prohibidos

p = Pattern.compile("[^A-Za-z0-9.@_-~#]+");

m = p.matcher(input);

StringBuffer sb = new StringBuffer();

boolean resultado = m.find();

boolean caracteresIlegales = false;

while(resultado) {

caracteresIlegales = true;

m.appendReplacement(sb, "");

resultado = m.find();

// Añade el ultimo segmento de la entrada a la cadena

m.appendTail(sb);

input = sb.toString();
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
9 de 26

if (caracteresIlegales) {

System.out.println("La cadena contiene caracteres ilegales");

Expresiones Regulares en C#.

Las expresiones regulares son la buena manera de validar campos del texto tales como nombres,
las direcciones, los números de teléfono, y otra información del usuario. Usted puede utilizarlas
para obligar la entrada, aplicar reglas del formato, y mucho más. Hay varios métodos de cómo
validar información. Este documento es una breve introducción a la clase de
System.Text.RegularExpressions.Regex y demuestra cómo usted puede utilizar expresiones
regulares.

Clase Regex

La clase Regex representa una expresión regular de sólo lectura. Contiene también métodos
estáticos que permiten utilizar otras clases de expresiones regulares sin crear explícitamente
instancias de objetos de las otras clases.

En el siguiente ejemplo de código se utiliza el método Regex.IsMatch para comprobar si una

cadena tiene el formato de correo electrónico válido. El método IsValidEmail devuelve el valor true
si la cadena contiene una dirección de correo electrónico válida; en caso contrario, devuelve false
y no realiza más acciones. Puede utilizar IsValidEmail para filtrar las direcciones de correo
electrónico que contienen caracteres no válidos antes de que la aplicación almacene las
direcciones en una base de datos o las muestre en una página ASP.NET.

¿Qué es regex?

Con regex podemos describir nuestros "patrones" de texto. Una vez que hayamos descrito el
patrón correctamente, podemos utilizarlo para hacer búsquedas, reemplazos, extracción y
modificación de texto. Regex, lo podemos encontrar en el siguiente namespace:

using System.Text.RegularExpressions;

Como ya hemos hablado antes, su función es crear algún patrón. Entonces vamos a crear el
objecto Regex con un patrón que busque un texto de a-z con 10 de longitud, por ejemplo:

Regex obj = new Regex("[a-z]{10}");

Finalmente, para poder buscar con el siguiente patrón, lo haríamos con IsMatch:
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
10 de 26

MessageBox.Show(obj.IsMatch("geeky theory").ToString());

IsMatch nos devuelve un true/false dependiendo del patrón que tenemos y si ha podido
encontrarlo o no en el texto Ahora vamos a explicar los 5 comandos de regex más importantes:

· [] dentro irá el patrón que debe cumplir el texto. Es decir, los caracteres que deben de
coincidir.
· {} especifica el número de caracteres.
· () para agrupar.
· ^ marca el empezar del patrón. Por ejemplo, con el patrón ^xyz, "xyz123" saldría true,
mientras que "123xyz" no encaja con el patrón diseñado
· $ marca el final del patrón. Por ejemplo, con el patrón 123$, "xyz123" saldría true,
mientras que "123xyz" no encaja con el patrón diseñado

El anterior ejemplo cuando creábamos el objecto regex, su expresión también lo podemos

expresarlo de la siguiente forma:

^[a-z]{10}$

Funcionamiento de las expresiones regulares.

El eje del procesamiento de texto mediante expresiones regulares es el motor de expresiones

regulares, que viene representado por el objeto System.Text.RegularExpressions.Regex en .NET.
Como mínimo, el procesamiento de texto mediante expresiones regulares necesita que el motor
de expresiones regulares disponga de los dos elementos de información siguientes:

 El patrón de expresión regular que se debe identificar en el texto.

 En .NET, los patrones de expresiones regulares se definen mediante una sintaxis o un
lenguaje especial, que es compatible con las expresiones regulares de Perl 5 y agrega
algunas características adicionales, como búsquedas de coincidencias de derecha a
izquierda.
 El texto que se debe analizar para el patrón de expresión regular.

Los métodos de la clase Regex permiten realizar las operaciones siguientes:

 Determinar si el patrón de expresión regular se produce en el texto de entrada llamando

al método Regex.IsMatch.
 Recuperar una o todas las apariciones del texto que coincide con el patrón de expresión
regular llamando al método Regex.Match o Regex.Matches. El primer método devuelve un
objeto System.Text.RegularExpressions.Match que proporciona información sobre el texto
coincidente. El segundo método devuelve un objeto MatchCollection que contiene un
objeto System.Text.RegularExpressions.Match por cada coincidencia encontrada en el
texto analizado.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
11 de 26

 Reemplazar el texto que coincide con el patrón de expresión regular llamando al método
Regex.Replace.

Ejemplos de expresiones regulares.

La clase String incluye varios métodos de búsqueda y reemplazo de cadenas que puede usar
cuando desee buscar cadenas literales en una cadena mayor. Las expresiones regulares son muy
útiles cuando se desea buscar una de varias subcadenas en una cadena mayor o cuando se desea
identificar patrones en una cadena, como se muestra en los ejemplos siguientes.

· Ejemplo 1: reemplazar subcadenas

Suponga que una lista de distribución de correo contiene nombres que a veces incluyen un
tratamiento (Sr., Sra. o Srta.) junto con un nombre y un apellido. Si no desea incluir los
tratamientos al generar las etiquetas de los sobres a partir de la lista, puede usar una expresión
regular para quitarlos, como se muestra en el ejemplo siguiente.

using System;

using System.Text.RegularExpressions;

public class Example

public static void Main()

string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";

string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels",

"Abraham Adams", "Ms. Nicole Norris" };

foreach (string name in names)

Console.WriteLine(Regex.Replace(name, pattern, String.Empty));

// The example displays the following output:

// Henry Hunt

// Sara Samuels
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
12 de 26

// Abraham Adams

// Nicole Norris

El patrón de expresión regular (Mr\.? |Mrs\.? |Miss |Ms\.? ) busca coincidencias con cualquier
aparición de "Mr", "Mr.", "Mrs", "Mrs.", "Miss", "Ms" o "Ms.". La llamada al método
Regex.Replace reemplaza la cadena coincidente con String.Empty; es decir, la quita de la cadena
original.

· Ejemplo 2: identificar palabras duplicadas

Duplicar palabras accidentalmente es un error frecuente que cometen los escritores. Se puede
usar una expresión regular para identificar palabras duplicadas, como se muestra en el ejemplo
siguiente.

using System;

using System.Text.RegularExpressions;

public class Class1

public static void Main()

string pattern = @"\b(\w+?)\s\1\b";

string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";

foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))

Console.WriteLine("{0} (duplicates '{1}') at position {2}",

match.Value, match.Groups[1].Value, match.Index);

// The example displays the following output:

// This this (duplicates 'This') at position 0

// a a (duplicates 'a') at position 66

El patrón de expresión regular \b(\w+?)\s\1\b se puede interpretar de la manera siguiente:

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
13 de 26

· \b Empieza en un límite de palabras.

· (\w+?) Coincide con uno o más caracteres de palabra, pero con el menor número de
caracteres posible. Juntos, forman un grupo al que se puede hacer referencia como \1.
· \s Coincide con un carácter de espacio en blanco.
· \1 Coincide con la subcadena que es igual al grupo denominado \1.
· \b Coincide con un límite de palabras.

Se llama al método Regex.Matches con las opciones de expresiones regulares establecidas en

RegexOptions.IgnoreCase. Por tanto, la operación de coincidencia no distingue mayúsculas de
minúsculas y el ejemplo identifica la subcadena "Esto esto" como una duplicación.

Observe que la cadena de entrada incluye la subcadena -“this? This"-. Sin embargo, debido al
signo de puntuación intermedio, no se identifica como una duplicación.

Expresiones Regulares en Python.

Cuando manejamos texto en Python, una de las operaciones más comunes es la búsqueda de una
subcadena; ya sea para obtener su posición en el texto o simplemente para comprobar si está
presente. Si la cadena que buscamos es fija, los métodos como find(), index() o similares nos
ayudarán. Pero si buscamos una subcadena con cierta forma, este proceso se vuelve más
complejo.

Al buscar direcciones de correo electrónico, números de teléfono, validar campos de entrada, o

una letra mayúscula seguida de dos minúsculas y de 5 dígitos entre 1 y 3; es necesario recurrir a
las Expresiones Regulares, también conocidas como Patrones.

Patrones

Las expresiones regulares son un potente lenguaje de descripción de texto. Y no existe un lenguaje
moderno que no permita usarlas. Las reglas con las que se forman son bastante simples. Pero
aprender a combinarlas correctamente requiere de práctica. Utilizándolas podemos buscar una
subcadena al principio o al final del texto. Incluso si queremos que se repita cierta cantidad de
veces, si queremos que algo NO aparezca, o si debe aparecer una subcadena entre varias
posibilidades. Permite, además, capturar aquellos trozos del texto que coincidan con la expresión
para guardarlos en una variable o reemplazarlos por una cadena predeterminada; o incluso una
cadena formada por los mismos trozos capturados.

Implementación.

Para utilizar expresiones regulares en Python es necesario importar el paquete re, que es
encargado de gestionar todo el tema de las expresiones regulares. Lo siguiente es, declarar la
expresión regular. Python nos ofrece 2 formas distintas de hacerlo:
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
14 de 26

Declarar expresion regular en Python

import re

# 1º forma

regex = r'(bar|ar|mar)co'

# 2º forma

regex = re.compile(r'(bar|ar|mar)co')

La 1º forma es más eficaz y ocupa menos espacio en memoria, porque solo es una simple cadena
con el prefijo r, pero cada vez que se utiliza, esta crea las estructuras internas necesarias para su
ejecución y una vez finalizada su tarea, destruye esas mismas estructuras. La 2º forma en cambio
crea las estructuras desde el principio y no las destruyes hasta que la propia variable que contiene
la expresión regular es destruida. Ocupa más espacio en memoria y necesita del paquete re de
Python. ¿Cuál elegir? Pues depende del uso. Si solo vas utilizar una o 2 veces la misma expresión
regular, la 1º forma es la mejor, porque ocupa menos espacio en memoria. Si la expresión regular
se va a utilizar de manera repetida y en múltiples sitios. La 2º forma es la mejor, porque crea las
estructuras al principio y no las borra cuando se utiliza la expresión regular.

Símbolos especiales usados:

El punto “.”: indica cualquier caracter excepto el salto de línea (\n).

>>> re.search('h..a', 'hola')

<_sre.SRE_Match object; span=(0, 4), match='hola'>

>>> re.search('h..a', 'h34a')

<_sre.SRE_Match object; span=(0, 4), match='h34a'>

El asterisco “*”: indica la aparición del caracter anterior cero o más veces.

>>> re.search('a*', 'a')

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

>>> re.search('a*', '')

<_sre.SRE_Match object; span=(0, 0), match=''>

El signo de interrogación “?”: indica que el caracter anterior es opcional.

>>> re.search('sep?tiembre', 'setiembre')

<_sre.SRE_Match object; span=(0, 9), match='setiembre'>

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
15 de 26

El signo de suma “+”: indica la aparición de un caracter una o más veces. En ese caso “a+” es lo
mismo que “aa*”

>>> re.search('a+', '')

>>> re.search('a+', 'a')

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

>>> re.search('a+', 'aaaaaa')

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

Las llaves “{}”: indican las repeticiones del caracter anterior. “{3}” indica ‘rrr’ y “t{3,}” indica tres o
más repeticiones de la letra “t”.

>>> re.search('a{3}', 'aaa')

<_sre.SRE_Match object; span=(0, 3), match='aaa'>

El acento circunflejo “^”: indica el comienzo de una cadena.

>>> re.search('^hello', 'hello world')

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

>>> re.search('^hello', 'hey, hello world')

>>>

El signo de dólar “$”: indica el fin de una cadena o antes del último salto de línea.

>>> re.search('world$', 'hello world')

<_sre.SRE_Match object; span=(6, 11), match='world'>

>>> re.search('world$', 'hello world there')

>>>

Los corchetes “[]”: agrupan caracteres o rangos de caracteres.

>>> re.search('[0-9]{4}', 'hello world 2017')

<_sre.SRE_Match object; span=(12, 16), match='2017'>

Los paréntesis “()”: sirven para agrupar expresiones y capturan los índices inicial y final del texto
coincidente.

>>> resultado = re.search('([a-z]+) ([0-9]{4})', 'world 2017')

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
16 de 26

>>> resultado.group()

'world 2017'

>>> resultado.group(1)

'world'

>>> resultado.group(2)

'2017'

>>> resultado.groups()

('world', '2017')

Algunas funciones de este módulo son: compile, match, search, findall, split, sub, finditer.

FLAGS: los “modos” modifican el comportamiento de la búsqueda. Se pueden combinar usando el

operador bit a bit OR, es decir, la barra vertical:

re.search('\d+', '2017', re.I | re.A)

re.IGNORECASE (re.I) permite la no distinción entre mayúsculas y minúsculas.

re.LOCALE (re.L) permite que algunos caracteres especiales tengan en cuenta el idioma que se usa
en el computador local. Debido a que ahora se usa Unicode por defecto se recomienda usar este
flag sólo con patrones de bytes.

re.MULTILINE (re.M) permite que “^” busque el comienzo de cada linea (no solo el comienzo del
texto) y que “$” busque el final de cada linea (no solo el final del texto).

re.DOTALL (re.S) hace que “.” busque cualquier caracter incluyendo una nueva linea (es decir
cuando aparece el salto de línea ‘\n’).

>>> texto = "hola mundo\nhello world"

>>> re.search('.+', texto)

<_sre.SRE_Match object; span=(0, 10), match='hola mundo'>

>>> re.search('.+', texto, re.DOTALL)

<_sre.SRE_Match object; span=(0, 22), match='hola mundo\nhello world'>

re.ASCII (re.A) Permite que \w, \W, \b, \B, \d, \D, \s y \S busquen coincidencias ASCII en vez de
Unicode. Sólo es permitido para patrones Unicode e ignorado para bytes.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
17 de 26

re.VERBOSE (re.X) se utiliza para poder dividir una expresión regular compleja en pequeños
fragmentos que pueden tener comentarios para una mejor comprensión. Si no se desea compilar
pero sí usar modificadores, se puede usar el símbolo (?_) junto con uno o varios modificadores,
por ejemplo, (?i), (?m), (?iL).

COMPILE: Prepara el patrón de caracteres que se va a buscar. La sintaxis de compile es:

>>> re.compile(pattern, flags=0)

“pattern” es el patrón de caracteres que se va a buscar. A parte de la opción de usar

modificadores “compile” ofrece una ligera mayor velocidad de búsqueda de los caracteres
correspondientes. Un ejemplo de uso de compile:

>>> pattern = re.compile('python', re.I)

>>> pattern.findall('la programación PyThOn')

['PyThOn']

Aqui con el modo re.I se ignoran las mayúsculas y minúsculas lo que se puede lograr también sin
compilar usando (?i):

>>> re.findall('(?i)python','la programacion PyThOn')

['PyThOn']

De otra forma no hay correspondencia:

>>> re.findall('python','la programacion Python')

[]

MATCH: La función match determina si hay una coincidencia únicamente al comienzo del texto
procesado:

>>> patron = "Python"

>>> texto1 = "Monty Python"

>>> texto2 = "Python interpreter"

>>> match1 = re.match(patron, texto1)

>>> type(match1) # no hay coincidencia

<type 'NoneType'>

>>> print match1

None
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
18 de 26

# python 3 muestra la coincidencia y los índices inicial y final

>>> match2 = re.match(patron, texto2)

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

match2.group() # hay una coincidencia

'Python'

Incluso si se usa el modificador MULTILINE solamente hay búsqueda al comienzo del texto.

>>> texto3 = "Monty \n Python"

>>> match3 = re.match(patron, texto3, re.M)# no hay coincidencia

SEARCH: Busca la primera aparición del patrón de búsqueda en la cadena de texto. Search
devuelve un objeto match o None si no hay coincidencia.

>>> match = re.search('django', 'plataforma django, django reinhardt')

>>> match

<_sre.SRE_Match object; span=(11, 17), match='django'>

FINDALL: Encuentra todas las coincidencias en forma de lista:

>>> re.findall('\d+', '23 de junio, 14 de mayo')

['23', '14']

FINDITER: Devuelve un iterador de objetos match. El resultado es igual a findall pero generando
los elementos de la lista uno por uno.

>>> iter_string = re.finditer('\d+', '23 de junio, 14 de mayo')

>>> iter_string

<callable-iterator object at 0x02ACE610>

# Usamos la funcón nativa next() para obtener el siguiente valor del iterador

>>> next(iter_string)

<_sre.SRE_Match object; span=(0, 2), match='23'>

>>> next(iter_string)

<_sre.SRE_Match object; span=(13, 15), match='14'>

SUB: Sustituye el patrón por La sintaxis de sub es:

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
19 de 26

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

>>> re.sub('string', 'cadena', 'remplaza la string de caracteres')

'remplaza la cadena de caracteres'

COUNT: indica las veces que se debe sustituir el patrón de caracteres, por defecto se remplazan
todas las apariciones del texto.

>>> re.sub('string', 'cadena', 'remplaza la string de caracteres string', count=1)

'remplaza la cadena de caracteres string'

SUBN: hace lo mismo, pero devuelve una tupla con el número de remplazos.

>>> re.subn('string', 'cadena', 'remplaza la string de caracteres string')

('remplaza la cadena de caracteres cadena', 2)

SPLIT: Separa la cadena de texto en donde aparece el patrón.

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

>>> re.split('web','Django es un framework web de codigo abierto escrito en Python')

['Django es un framework ', ' de codigo abierto escrito en Python']

Ejemplos.

1.- comprobar si cadena coincide con expresión regular

import re

regex_format1 = re.compile(r'ab+c')

regex_format2 = r'ab+c'

text1 = 'abc'

if regex.search(text1):

print('La cadena está dentro del conjunto de la expresión regular')

else:

print('La cadena no está dentro del conjunto de la expresión regular')

# output La cadena está dentro del conjunto de la expresión regular.

text2 = 'test'

if re.search(regex_format2, text2):
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
20 de 26

print('La cadena está dentro del conjunto de la expresión regular')

else:

print('La cadena no está dentro del conjunto de la expresión regular')

# output La cadena no está dentro del conjunto de la expresión regular.

La función search() comprueba si una parte de un texto está dentro del conjunto de la expresión
regular. Si es así devuelve un objeto llamado Match Object. Sino coincide devuelve None.

Match Object es un objeto que contiene información útil sobre el resultado de la expresión regular
sobre una cadena.

Match Object

import re

regex = re.compile(r'[a-z]+')

text = '0122 test, test1'

mo = regex.search(text)

# group(0) devuelve la parte de la cadena que coincide con la expresión regular.

print(mo.group(0)) # output: test

2.- sustituir los espacios en blanco por -

import re

# Expresión regular que busca todos los caracteres espacios.

regex = re.compile(r'\s+')

text = " test1 test2 test3\ntest4 \ntest5 "

#Reemplazar todo los espacios por el caracter -.

result = regex.sub('-', text)

# output: -test1-test2-test3-test4-test5-

La expresión regular busca todos los caracteres considerados espacios en blanco y los reemplaza
por el caracter -. Bastante sencillo si dominas las expresiones regulares. Pero la gracia de sustituir
con expresiones regulares, es que puedes utilizar una función para procesar el texto seleccionado
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
21 de 26

por la expresión y devolver una salida de texto; aquí es donde se vuelven útiles las expresiones
regulares.

3.- usar funciones para reemplazar texto

import re

all_numbers = ['cero', 'uno', 'dos', 'tres', 'cuatro, 'cinco', 'seis', 'siete', 'ocho', 'nueve']

def replace_func(mo):

"""

Función que procesará las coincidencias de la cadena y la expresión regular.

Devuelve los números escritos con letras. Además, si el número es par las letras
estarán en mayúsculas.

:param mo: es un Match Object con la información de la subcadena que coincide con la
expresión regular.

"""

number = int(mo.group(0))

if number % 2 == 0:

# es par. Devolvemos el número en letras mayúsculas.

return all_numbers[number].upper()

# no es par. Devolvemos el número en letras.

return all_numbers[number]

regex = re.compile(r'[0-9]')

text = 'test 1 6 3 8 0'

# Añadimo el nombre de la función.

result = regex.sub(replace_func, text)

 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
22 de 26

print(result)

# output test uno SEIS tres OCHO CERO

En el ejemplo usamos la función replace_func para que procese las coincidencias del texto y la
expresión regular. La función recibe un objeto del tipo Match Object con información de la
subcadena que va a ser reemplazada, así como los grupos que forman parte de la expresión
regular.

El ejemplo quizás no sea práctico, pero nos da idea del pequeño potencial que tiene las
expresiones regulares en Python. Podemos reemplazar por unas u otras cadenas en función de lo
que extraigamos de la expresión regular. También podremos guardar los resultados de las
expresiones regulares en variables externas para poder utilizarlas posteriormente. Así por ejemplo
podemos capturar las etiquetas html de un código. O guardar el dominio de direcciones e-mails.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
23 de 26

IV OBTENCION DE RESULTADOS Y ANÁLISIS ESTADISTICOS.

En la programación se da muchas veces el caso de buscar una cadena de texto en otra. Por
ejemplo, podemos buscar el texto “rata” en la cadena “errata”. “rata” se denomina el
“patrón de búsqueda” (search pattern en inglés) o “subcadena” y “errata” el destino. (Para
el destino hay más variedad de nombres.)
Si el patrón de búsqueda se encuentra dentro del texto a rastrear, es decir, si hay un match
en inglés, entonces una función de búsqueda típicamente devuelve el índice de la primera
ocurrencia de la subcadena.
Las funciones de búsqueda sin expresiones regulares existen también sin distinguir entre
mayúsculas y minúsculas y comenzando la búsqueda desde el final.
Estas funciones son fáciles de entender, pero no ofrecen mucha flexibilidad. Por ejemplo,
¿qué hago para buscar la palabra “rata” y no simplemente la secuencia de cadena r-a-t-a
dentro de cualquier palabra? Quiero una función que encuentre “rata” en “El gato caza la
rata” pero no en “errata”. Podría apañarme buscando algo como espacio más “rata” más
otro espacio, pero esto no funcionará si rata es la última o primera palabra. Es decir, lo que
necesito es una función que encuentre mi patrón de búsqueda sólo cuando es una palabra
entera y no parte de una palabra.
Pues, esta funcionalidad se obtiene con las expresiones regulares: una búsqueda con
alternativas y cadenas variables en longitud y contenido.
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
24 de 26

V. RESULTADOS Y DISCUSION.

Después de revisar todo lo investigado sobre el manejo de expresiones regulares y como lo

implementan diferentes lenguajes de programación como son Java, C# y Python podemos
decir que su utilidad más obvia es la de describir un conjunto de cadenas para una
determinada función, resultando de utilidad en editores de texto y otras aplicaciones
informáticas para buscar y manipular textos.
Numerosos editores de texto y otras herramientas utilizan expresiones regulares para buscar
y reemplazar patrones en un texto. Por ejemplo, las herramientas proporcionadas por las
distribuciones de Unix (incluyendo el editor sed y el filtro grep) popularizaron el concepto
de expresión regular entre usuarios no programadores, aunque ya era familiar entre los
programadores.
Inicialmente, este reconocimiento de cadenas se programaba para cada aplicación sin
mecanismo alguno inherente al lenguaje de programación, pero, con el tiempo, se ha ido
incorporado el uso de expresiones regulares para facilitar programar la detección de ciertas
cadenas.
En el área de la programación las expresiones regulares son un método por medio del cual
se pueden realizar búsquedas dentro de cadenas de caracteres. Sin importar la amplitud de
la búsqueda requerida de un patrón definido de caracteres, las expresiones regulares
proporcionan una solución práctica al problema. Adicionalmente, un uso derivado de la
búsqueda de patrones es la validación de un formato específico en una cadena de caracteres
dada, como por ejemplo fechas o identificadores.
Para poder utilizar las expresiones regulares al programar es necesario tener acceso a un
motor de búsqueda con la capacidad de utilizarlas
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
25 de 26

VI. REFERENCIAS
 S.L. Programación en Castellano
Expresiones Regulares en Java
Programación en Castellano.
URL: https://programacion.net/articulo/expresiones_regulares_en_java_127
 Ejemplos Java
Ejemplos de Expresiones Regulares en Java
Puntocomnoesunlenguaje.blogspot.mx
URL: http://puntocomnoesunlenguaje.blogspot.mx/2013/07/ejemplos-expresiones-
regulares-java-split.html
 Introducción a expresiones regulares
Msdn.microsoft.com
URL: https://msdn.microsoft.com/es-es/library/bb932288.aspx
 Expresiones Regulares en Python
Piensapython.com
URL: https://piensapython.com/python/2016/06/27/expresiones-regulares-python/
 Expresiones regulares en Python
Búho programador
URL: http://buhoprogramador.com/entrada/10/expresiones-regulares-en-python
 Código:
DIRECCIÓN ACADÉMICA CT-FO-02-05
Revisión: 1

Página:
INFORME TÉCNICO
26 de 26

VII ANEXOS.

Información adicional utilizada en el documento