regular_expression note

regular_expression

search and replace
:%s/Hola/Adíos
Search and replace ALL
:%s/Hola/Adiós/g

Replace lineNumber for the number of line.
:%s/lineNumber/\=line('.')/g

Search lineNumber and replace to index var.
:let index=0 | g/lineNumber/s//\=index./ |let index=index+1



patron: coincide con cualquier cadena que comience con patron.
patron$: coincide con cualquier cadena que termine con patron.
patron$: coincide con la cadena exacta patron.

[abc]: coincide con a, b, o c
[387ab]: coincide con 3, 8, a o b
niñ[oa]s: coincide con niños o niñas.
Para evitar errores, en caso de que queramos crear una clase de caracteres que contenga un corchete, debemos escribir una barra \ delante, para que el motor de expresiones regulares lo considere un caracter normal: la clase [ab\[] coincide cona, b y [.

[a-c]: equivale a [abc]
[0-9]: equivale a [0123456789]
[a-d5-8]: equivale a [abcd5678]



Si queremos, por ejemplo, crear una clase que coincida con los caracteres a, 4 y -, debemos escribirla así:

[a4-]
[-a4]
[a\-4]


[^abc]: coincide con cualquier caracter distinto a a, b y c



\d (POSIX [[:digit:]]): equivale a [0-9]
\s (POSIX [[:space:]]): caracteres de espacio en blanco (espacio, tabulador, nueva línea, etc)
\w (POSIX [[:word:]]): letras minúsculas, mayúsculas, números y guión bajo (_)


"." : coincide con cualquier caracter.



?: coincide con cero o una ocurrencia del patrón. Dicho de otra forma, hace que el patrón sea opcional
+: coincide con una o más ocurrencias del patrón
*: coincide con cero o más ocurrencias del patrón.
{x}: coincide con exactamente x ocurrencias del patrón
{x, y}: coincide con al menos x y no más de y ocurrencias. Si se omite x, el mínimo es cero, y si se omite y, no hay máximo. Esto permite especificar a los otros como casos particulares: ? es {0,1}, + es {1,} y * es {,} o {0,}.




.* : cualquier cadena, de cualquier largo (incluyendo una cadena vacía)
[a-z]{3,6}: entre 3 y 6 letras minúsculas
\d{4,}: al menos 4 dígitos
.*hola!?: una cadena cualquiera, seguida de hola, y terminando (o no) con un !



?: Además de servir como cuantificador, puede modificar el comportamiento de otro. De forma predeterminada, un cuantificador coincide con la mayor cadena posible. Cuando se le coloca un ?, se indica que se debe coincidir con la menor cadena posible. Esto es: dada la cadena bbbbb, b+ coincide con la cadena entera, mientras que b+? coincide solamente con b. Es decir, la menor cadena que cumple el patrón.
(): agrupan patrones. Sirven para que aquel pedazo de la cadena que coincida con el patrón sea capturado; o para delimitar el alcance de un cuantificador. Ejemplo: ab+ coincide con ab, abb, abbbbb, …, mientras que (ab)+ coincide con ab, abab, abab…
| : permite definir opciones para el patrón: perro|gato coincide con perro y con gato.




import os
patron = re.compile('a[3-5]+') # coincide con una letra, seguida de al menos 1 dígito entre 3 y 5


>>> cadena = 'a44453'
>>> patron.match(cadena)
<_sre.SRE_Match object at 0x02303BF0>
>>> patron.search(cadena)
<_sre.SRE_Match object at 0x02303C28>
>>> cadena = 'ba3455' # la coincidencia no está al principio!
>>> patron.search(cadena)
<_sre.SRE_Match object at 0x02303BF0>
>>> print patron.match(cadena)
None



Digitamos lo siguiente para remplazar de manera global (en todo el texto) la hilera hilera1 por hilera2:
%s/hilera1/hilera2/g



Si quisieramos reemplazar confirmando cada reemplazo usamos:
%s/hilera1/hilera2/cg





s substitución
d borrado
i\, a\, añade antes/después de la línea afectada
c\ reemplaza la línea afectada
Algunas ociones:

-e comando: añade comando
-i edita el fichero in-place
-n suprime la salida
Algunos flags:

g: aplica los cambios globalmente (por defecto, sólo se cambia la primera aparición en cada línea)
p imprime las líneas afectadas, incluso con la opción -n.
NUMERO: reemplaza la aparición número NUMERO
w fichero: escribe las líneas con sustituciones al fichero indicado
Ejemplo: cambia, en el fichero amigos, todas las apariciones de pepe y paco por Pepe y Paco, respectivamente:

$ sed -e 's/pepe/Pepe/g' -e 's/paco/Paco/g' amigos (también sed 's/pepe/Pepe/g ; s/paco/Paco/g' amigos)
Ejemplo: cambia pepe por Pepe, pero sólo en las líneas que tengan Potamo

$ sed '/Potamo/s/pepe/Pepe/g' amigos
Ejemplo: muestra sólo las lineas que contengan jaime

$ sed -n '/jaime/p' amigos
Ejemplo: borra las lineas que contengan jaime

$ sed '/jaime/d' amigos
Ejemplo: cambia las lineas que contengan jaime por otra cosa

$ sed '/jaime/c\BORRADO' amigos
Ejemplo: inserta una línea, con la palabra 'APARICION', antes de las líneas que contengan jaime

$ sed '/jaime/i\APARICION' amigos
Ejemplo: reemplaza, en cada línea de fichero, la quinta ocurrencia de stop por STOP

$ sed 's/stop/STOP/5' fichero
Ejemplo: igual que antes pero guarda cada línea reemplazada en el fichero f2

$ sed 's/stop/STOP/5w f2' fichero

Indicación de líneas:

podemos especificar las líneas del fichero en las que queremos que se realicen las operaciones:
sed '3s/stop/STOP/g' (reemplaza sólo en la línea 3) 
sed '3,10s/stop/STOP/g' (reemplaza de la línea 3 a la 10) 
sed '3,$s/stop/STOP/g' (reemplaza de la línea 3 al final) 
sed '!3s/stop/STOP/g' (reemplaza en todas las líneas menos la 3)

Operador &:

se sustituye por el patrón reconocido 
Ejemplo: reemplaza stop por <stop>

$ sed '3s/stop/<&>/g' fichero

Comandos desde fichero:

la opción -f permite leer comandos de sed agrupados en un fichero 
Ejemplo: reemplazo desde la línea 1 hasta una línea que comience por END (o el final, si no hay ninguna)

$ cat file.sed 
1,/^END/{ 
    s/[Ll]inux/GNU\/Linux/g 
    s/samba/Samba/g 
} 
$ sed -f file.sed fichero







ER de un sólo carácter

ER	concuerda con
.	cualquier carácter
[ ]	cualquiera de los caracteres entre corchetes, p.e. [abc] concuerda con a, b o c; [a-z] concuerda con cualquier letra minúscula
[^ ]	cualquier carácter que no esté entre corchetes
^	principio de línea
$	final de línea
*	0 o más ocurrencias de la expresión regular anterior
\( \)	permite agrupar ER
\	escapa un metacarácter
Dentro de [ ] los metacaracteres pierden su significado especial: p.e. [a.]c concuerda con ac y .c
Para incluir un carácter ] en una lista colocarlo al principio; para incluir un ^ en cualquier lugar menos al principio; para incluir un - al final: p.e. [a^]c concuerda con ac y ^c

Ejemplos:

ER	concuerda con
a..c	cadena que empiece por a, seguida por dos caracteres y c: a00c, xaxxcxx, aacc,...
0[abc]0	cadenas que tengan un 0 seguido de un carácter a, b, o c y seguido de otro 0: 0a0, 00ab0b0, bc0c0,...
0[^abc]0	cadenas que tengan un 0 seguido de un carácter distinto a a, b, o c y seguido de otro 0
0[a-z]0	cadenas que tengan un 0 seguido de una letra minúscula, y 0
^abc	líneas que empiecen por abc
abc$	líneas que terminen por abc
ab*c	cadenas que empiecen por a, que continúen con 0 o más b, y una c: abc, ac, abbc, aaccab,...pero no cba o aaab
b[cq]*e	cadenas que empiecen por b, que continúen con 0 o más c o q, y una e: be, bcce, bccqqee o bqqqce
.*	cualquier cadena
abc.*	cualquier cadena que empiece por abc
0\(abc\)*0	cadenas que tengan un 0 seguido de 0 o más ocurrencias de abc, y seguido de otro 0: 0abc0, 00, 0abcabc0,..., pero no 0ac0 o 0cba0
^#.*\.$	línea que empiece por # y termine por . (notar que el segundo . está escapado por la \; la ER .* implica 0 o más caracteres cualquiera)

Repetición

Podemos repetir una regexp usando \{ \}
Constructor	Propósito
\{n\}	concuerda con exactamente n ocurrencias de la RE previa
\{n,\}	concuerda con al menos n ocurrencias de la RE previa
\{n, m\}	concuerda con entre n y m ocurrencias de la RE previa
Ejemplos:

a\{5\}: 5 ocurrencias del carácter a 
.\{5,\}: al menos 5 ocurrencias de cualquier carácter

Expresiones regulares extendidas

Los sistemas UNIX actuales admiten extensiones a las expresiones regulares básicas:
debemos usar egrep, grep -E, sed -r
ER	concuerda con
+	una o más ocurrencias de la RE anterior
?	cero o una ocurrencia de la RE anterior
Además, \( \) y \{ \} se reemplazan por ( ) y { }

Ejemplos:
ab+c concuerda con abc, abbc, pero no con ac
ab?c concuerda con ac, abc, pero no con abbc
Para usar los caracteres (, ), { o } escaparlos con \

Alternancia

El carácter | permite alternar entre 2 o más RE
(a|b)c concuerda con ac o bc

Etiquetado

Las RE que se ponen entre ( ) quedan etiquetadas, y podemos hacer referencia a esos elementos mediante \n, con n el número de la etiqueta
Ejemplos:
(.)oo\1 concuerda con moom, noon, pero no con moon
(.)oo\1-(.)aa\1\2 concuerda con moom-paamp

Otros caracteres

Además de los ya vistos, pueden usarse otros metacaracteres:
ER	concuerda con
\n, \r, \t	LF, CR y tab (no siempre funcionan)
[:space:]	caracteres en blanco ([ \t\n\r\f\v])
[:blank:]	espacio y tabulado
[:alnum:] o \w	caracteres alfánuméricos (letras y números)
[:digit:]	dígitos
[:alpha:]	alfabéticos
[:upper:]	mayúsculas
[:lower:]	minúsculas
[:xdigit:]	dígitos hexadecimales
[:punct:]	signos de puntuación
[:cntrl:]	caracteres de control
[:graph:]	caracteres imprimibles (sin espacio)
[:print:]	caracteres imprimibles (con espacio)
\<, \>	inicio/fin de palabra
\b	posición entre palabras
\B	posición en medio de una palabra
[[:upper:]]bc concuerda con Abc, pero no abc
\babc\b concuerda con ab abc df, pero no con abcdef
\Babc\B concuerda con ababcdf, pero no con ab abc df

Más ejemplos

\w+@\w+\.\w+((\.\w+)*)? concuerda con direcciones de e-mail
(0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[012])-(19|20)[0-9]{2} concuerda con fechas en el formato dd-mm-yyyy (años entre el 1900 y 2099)
[-+]?([0-9]*\.)?[0-9]+([eE][-+]?[0-9]+)? concuerda con números en punto flotante (con o sin exponente)
Ejemplos de uso con sed:

$ echo "abc1234def" | sed -r "s/[0-9]+/NUMERO/" 
abcNUMEROdef 
$ echo "abc1234def" | sed -r 's/[0-9]+/<&>/' 
abc<1234>def 
# En el siguiente ejemplo, notar que las ER intentan siempre reconocer la secuencia más larga posible 
$ echo "000x111x222x333" | sed 's/x.*x/<&>/' 
000<x111x222x>333 
# Eliminar blancos a principio y al final de línea y sustituir más de un blanco seguido por uno solo 
$ sed -r "s/^_+// ; s/_+$// ; s/__+/_/g" fich 
# Pon los 4 primeros caracteres de cada línea al final de la misma 
$ sed -r 's/^(.{4,4})(.*)/\2\1/' fich 
# Cambia de minúsculas a mayúsculas la primera letra de cada palabra 
$ sed -r 's/\<./\u&/g' 
# Convierte DOS newlines (CR/LF) a formato Unix (LF) 
$ sed 's/^M$//'4 
# también funcionaría 
$ sed 's/\r//'


## Ejemplos
patatas x X
leche   x Y
huevos  x XXX
Son las XX y he comprado X huevos y solamente Y cartones de leche

#Remplaza las X por 12
%s/X\{1,}/12/g
#Remplaza las Y por 6
%s/Y\{1,}/6/g