Flujos de texto y expresiones regulares

Introducción

Seguimos utilizando el mismo contenedor bda-m00-debian que creaste en la página 01, con sus herramientas y tu carpeta local bda-m00 compartida mediante un bind mount en /bda-m00. No tienes que crear otro contenedor. Los archivos que prepares aquí también aparecerán en esa carpeta del anfitrión.

Abre Docker y utiliza la terminal de tu equipo anfitrión para entrar:

• Si el contenedor está detenido, inícialo y conecta con su terminal:

  docker start -ai bda-m00-debian

• Si el contenedor ya está funcionando, abre una nueva sesión dentro de él:

  docker exec -it bda-m00-debian /bin/bash

Elige solo la opción que corresponda. Si ya tienes abierta una terminal dentro del contenedor, puedes seguir utilizándola sin ejecutar ninguna de las dos órdenes. Al entrar desde Docker trabajarás como root, igual que al comienzo de la página 01; no utilices para este bloque la sesión SSH de alumno-m00.

Una vez dentro de Debian, sitúate en el volumen:

cd /bda-m00
pwd

La salida debe ser /bda-m00. A partir de aquí, salvo indicación expresa, todos los comandos de esta página se ejecutan dentro del contenedor y desde ese espacio de trabajo.

Los procesos de datos se construyen conectando resultados: un comando obtiene o lee datos, otro los filtra y un tercero guarda o resume la salida. Este bloque ocupa dos sesiones: empieza por flujos y filtros, introduce regex y aplica después estas herramientas a campos, ordenación y transformación de texto. Ejecuta los ejemplos y ejercicios desde /bda-m00, el volumen preparado en la página 01. Reutilizaremos sus comandos de lectura; la preparación siguiente permite recuperar los archivos mínimos si no los conservas.

Objetivos

• Distinguir entrada estándar, salida normal y salida de errores.
• Usar redirecciones y tuberías sin perder información de diagnóstico.
• Construir flujos pequeños con cut, sort, uniq, tee y grep.
• Usar grep -E para validar formato, distinguiéndolo de una validación semántica.
• Extraer campos, ordenar valores y transformar texto sin sobrescribir el original.

Antes de comenzar: directorios y archivo de prueba

Trabaja dentro del contenedor Debian, con el volumen montado en /bda-m00. Esta página necesita inicialmente la siguiente estructura mínima:

/bda-m00/
├── data/
│   └── raw/
│       └── notas-prueba.txt
└── logs/

Puedes conservar todos los demás directorios y archivos de la página 01. El esquema no indica que debas borrarlos ni que logs tenga que estar vacío.

Si no has podido entrar en /bda-m00, revisa el montaje del apartado 1.2 de la página 01; no crees una carpeta del mismo nombre para sustituir un volumen ausente. Una vez dentro, prepara los directorios que falten:

mkdir -p data/raw logs
ls -ld data/raw logs

mkdir -p conserva los directorios si ya existen y crea los que faltan. El listado debe mostrar ambos como directorios.

Contenido de data/raw/notas-prueba.txt

El archivo que reutilizaremos para buscar texto debe contener estas tres líneas, con un salto de línea al terminar cada una:

notas-prueba.txt

Primera nota
Segunda nota
Tercera nota

Consulta el archivo antes de cambiar nada:

cat data/raw/notas-prueba.txt

Si no existe, cat informará de ello. Créalo con el editor ya utilizado en la página 01 y escribe las tres líneas anteriores:

nano data/raw/notas-prueba.txt

Guarda con Ctrl + O, confirma con Intro y sal con Ctrl + X. Si el archivo ya existe y contiene esas líneas, no necesitas editarlo. Si contiene otras notas que quieres conservar, haz antes una copia con otro nombre, por ejemplo:

cp -i data/raw/notas-prueba.txt data/raw/notas-prueba-respaldo.txt

-i pide confirmación si el respaldo ya existe: no lo sobrescribas sin comprobar su contenido. Después puedes preparar el archivo de pruebas con las tres líneas indicadas.

Comprueba el punto de partida:

cat data/raw/notas-prueba.txt
wc -l data/raw/notas-prueba.txt

Debes ver las tres notas y un recuento de 3. Así, los ejemplos posteriores tendrán el mismo resultado aunque no conservaras los archivos del bloque anterior.

Archivos que prepararemos durante esta página

Archivo	Cuándo y cómo se prepara
data/raw/cotizaciones.csv	En el apartado 2, con su cabecera y una cotización, al aprender > y >>.
logs/copia-cotizaciones.log, logs/salida.log y logs/errores.log	En el apartado 2, mediante tee y las redirecciones. No necesitan crearse antes con touch.
data/raw/personas.csv	En el apartado 6, copiando en Nano el contenido que se proporciona allí.
data/raw/ejemplotexto.txt	En el apartado 9, copiando en Nano el texto de práctica.

No crees data/raw/no-existe.csv: lo utilizaremos deliberadamente como archivo inexistente para estudiar errores. Tampoco vacíes un CSV o un registro que ya contenga trabajo: antes de repetir ejemplos con >, conserva una copia con otro nombre, como acabamos de hacer con las notas.

1. Los tres flujos estándar

Por convención, los procesos reciben tres canales estándar: entrada (stdin), salida normal (stdout) y salida de errores (stderr). No todos leen datos de la entrada estándar ni producen texto en ambos canales de salida. Esta separación permite guardar resultados sin esconder problemas.

Prueba un resultado normal. echo escribe una línea de texto:

echo 'BTCUSDT'

Ahora fuerza un error controlado y observa que el mensaje no es un resultado de datos:

head data/raw/no-existe.csv

2. Redirigir con intención

Los operadores de redirección los interpreta la shell: no son opciones del comando. La barra vertical | conecta órdenes formando una tubería; en este apartado la usaremos para mostrar y guardar con tee, y en el siguiente construiremos tuberías paso a paso.

Sintaxis	Efecto
comando > archivo	Guarda stdout, sobrescribiendo el archivo.
comando >> archivo	Añade stdout al final.
comando < archivo	Toma stdin del archivo.
comando 2> errores.log	Guarda solo stderr.
comando > salida.log 2>&1	Guarda ambos flujos juntos.
`comando	tee archivo`

Esta es la primera vez que escribimos contenido en el CSV. Crea la cabecera con > y añade una fila con >>:

echo 'timestamp,symbol,price' > data/raw/cotizaciones.csv
echo '2026-10-02T10:00:00Z,BTCUSDT,65000.50' >> data/raw/cotizaciones.csv
cat data/raw/cotizaciones.csv
wc -l data/raw/cotizaciones.csv

La última orden debe devolver 2: una cabecera y un registro. Esta diferencia entre sobrescribir y añadir se utilizará para conservar los logs de ejecución.

También puedes proporcionar el archivo por la entrada estándar:

wc -l < data/raw/cotizaciones.csv

El resultado sigue siendo 2, pero no añade el nombre del archivo: wc recibe los datos por stdin, no como un argumento de archivo. < lee; > escribe. Ninguna lectura con < vacía el archivo.

La forma 2>&1 conecta la salida de errores con el destino que tenga la salida normal en ese momento. El orden importa: primero se establece el destino de stdout y después se conecta stderr. Para mostrar y guardar a la vez, tee copia lo que recibe hacia pantalla y hacia el archivo indicado; por defecto sobrescribe ese archivo.

cat data/raw/cotizaciones.csv | tee logs/copia-cotizaciones.log
cat logs/copia-cotizaciones.log

Ambas salidas deben mostrar las dos líneas del CSV. Aquí el CSV es un texto simple separado por comas, sin campos entrecomillados ni comas dentro de un campo; las herramientas de este bloque no son un analizador general de CSV.

Haz una prueba con un archivo inexistente:

head data/raw/no-existe.csv > logs/salida.log 2> logs/errores.log
cat logs/salida.log
cat logs/errores.log

salida.log estará vacío; errores.log explicará el fallo. No redirijas los errores a /dev/null sin comprenderlos: los registros de errores serán indispensables al programar tareas con cron.

3. Tuberías: un paso cada vez

Una tubería | conecta la salida normal de una orden con la entrada de la siguiente. Empieza con dos pasos:

echo 'BTCUSDT
ETHUSDT
BTCUSDT' | sort

La salida ordenada contiene dos apariciones de BTCUSDT. Añade uniq -c para contar:

echo 'BTCUSDT
ETHUSDT
BTCUSDT' | sort | uniq -c

      2 BTCUSDT
      1 ETHUSDT

Las comillas del ejemplo contienen tres líneas reales. sort ordena texto y uniq -c cuenta repeticiones consecutivas; por eso se ordena antes de contar. Aquí basta con esa operación básica: los campos de cut se explican en el apartado 6 y las opciones de ordenación en el 7. Al terminar ambos aplicaremos este recuento al CSV, sin adelantar órdenes todavía no estudiadas.

Una tubería normal transmite stdout, no stderr. Un error del primer comando no se convierte automáticamente en datos para el siguiente.

Consulta ahora el código de salida de una comprobación. test -s comprueba que un archivo existe y tiene contenido; $? contiene el código del último comando y debe consultarse inmediatamente:

test -s data/raw/cotizaciones.csv
echo "$?"

0 significa que el archivo existe y no está vacío. Prueba con una ruta inexistente y observa que el resultado deja de ser 0.

4. Filtrar texto con grep

grep muestra las líneas que contienen un patrón. Empieza por búsquedas sencillas de texto:

grep 'BTCUSDT' data/raw/cotizaciones.csv
grep -n 'BTCUSDT' data/raw/cotizaciones.csv
grep -v 'timestamp,symbol,price' data/raw/cotizaciones.csv

La primera salida contiene la fila de BTCUSDT; con -n, esa misma fila lleva el prefijo 2: en el CSV recién preparado. -v invierte la selección: el último comando omite de la salida la línea que contiene el texto de la cabecera. No modifica el archivo. En el apartado siguiente veremos cómo anclar un patrón al principio de línea.

Buscar sin distinguir mayúsculas de minúsculas

Recupera el archivo de tres notas que preparaste en la página 01. Contiene Primera nota, Segunda nota y Tercera nota:

grep -n 'NOTA' data/raw/notas-prueba.txt
grep -in 'NOTA' data/raw/notas-prueba.txt

La primera orden no muestra nada: por defecto, NOTA y nota son diferentes. -i ignora esa diferencia y puede combinarse con -n. La segunda debe mostrar:

1:Primera nota
2:Segunda nota
3:Tercera nota

Esta búsqueda sirve para localizar texto escrito de formas distintas. No la aplicaremos a la validación del símbolo del proyecto, donde exigir mayúsculas es una regla deliberada.

5. Expresiones regulares extendidas

Usaremos grep -E, que activa expresiones regulares extendidas. Los patrones básicos son:

Patrón	Significado
^BTCUSDT$	La línea completa es BTCUSDT.
[0-9]+	Uno o más dígitos.
[0-9]+([.][0-9]+)?	Entero o decimal simple.
^[A-Z0-9]+$	Solo mayúsculas y dígitos.
`BTCUSDT	ETHUSDT`

Los corchetes forman una clase de caracteres; [.] representa un punto literal. + exige una o más repeticiones, ? hace opcional el elemento anterior y los paréntesis agrupan. {3} exige tres repeticiones y {3,20} entre tres y veinte. ^ y $ fijan inicio y final de línea. No confundas estos patrones con el comodín de nombres *.txt usado por find.

Compara una búsqueda parcial con una validación completa:

echo 'precio-BTCUSDT-prueba' | grep -E 'BTCUSDT'
echo 'precio-BTCUSDT-prueba' | grep -E '^BTCUSDT$'

La primera orden muestra la línea; la segunda no, porque la línea completa no es exactamente el símbolo. Los anclajes ^ y $ evitan aceptar texto adicional.

grep devuelve 0 si selecciona líneas, 1 si no encuentra coincidencias y 2 si hay un error. Una entrada inválida sin coincidencias no es un fallo de la herramienta.

Un patrón de línea de cotización simplificada sería:

grep -E '^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z,[A-Z0-9]+,[0-9]+([.][0-9]+)?$' data/raw/cotizaciones.csv

Advertencia

Una regex valida la forma, no el significado. 2026-02-31 puede ajustarse al patrón AAAA-MM-DD, aunque no sea una fecha real. Los controles semánticos y de calidad se desarrollarán en M04.

6. Extraer campos: trabajar con un CSV sencillo

Hasta ahora hemos combinado órdenes sobre símbolos de cotización. Las mismas herramientas permiten explorar otros datos. Recuperaremos un ejemplo del curso anterior con personas ficticias, reducido a cinco campos para ver con claridad qué hace cada paso.

Desde /bda-m00, abre nano data/raw/personas.csv y escribe exactamente esta cabecera y estas cuatro filas:

personas.csv

Nombre,Edad,Profesion,Ciudad,Pais
Juan,30,Ingeniero,Madrid,España
Maria,25,Medica,Barcelona,España
Carlos,35,Abogado,Valencia,España
Ana,28,Profesora,Sevilla,España

Guarda y comprueba con cat y wc -l: deben aparecer cinco líneas contando la cabecera. Los nombres son ficticios; no uses información personal real para preparar el ejemplo.

cut selecciona campos de cada línea. -d indica el delimitador y -f el número de campo, empezando en 1:

cut -d ',' -f 1 data/raw/personas.csv
cut -d ',' -f 3 data/raw/personas.csv
cut -d ',' -f 1,4 data/raw/personas.csv

La primera orden muestra Nombre y los cuatro nombres; la segunda, Profesion y las profesiones; la tercera, nombre y ciudad separados por coma. Puedes seleccionar una lista (1,4) o un intervalo (2-4). cut conserva el orden de los campos del archivo: no lo uses para reordenar columnas.

Si quieres trabajar solo con datos, retira primero la cabecera mediante tail -n +2. Esta variante de tail significa «desde la línea 2», no «las dos últimas líneas»:

tail -n +2 data/raw/personas.csv | cut -d ',' -f 1
tail -n +2 data/raw/personas.csv | tail -n 2 | cut -d ',' -f 1,4

La primera salida debe contener Juan, Maria, Carlos y Ana. La segunda debe ser:

Carlos,Valencia
Ana,Sevilla

Lee la tubería de izquierda a derecha: quitar cabecera → seleccionar las dos últimas personas → extraer dos campos. Para localizar una fila por un dato y después mostrar un campo:

grep '^Maria,' data/raw/personas.csv | cut -d ',' -f 4

Debe mostrar Barcelona. El anclaje y la coma permiten buscar ese nombre en el primer campo, no una coincidencia en cualquier posición.

Advertencia

cut separa por caracteres, no interpreta todas las reglas de CSV. Este ejemplo no contiene comas ni saltos de línea dentro de campos entrecomillados. Un CSV con esos casos necesita un lector adecuado, no esta separación simple. Tampoco debemos obtener nombres de archivos procesando las columnas de ls -l: nombres con espacios y formatos variables rompen esa técnica.

7. Ordenar texto y números

sort ordena líneas completas. Sin opciones compara texto; -n compara valores numéricos y -r invierte el orden. Antes de usarlos con el CSV, compara sobre una entrada pequeña:

echo '2
10
1' | sort
echo '2
10
1' | sort -n
echo '2
10
1' | sort -nr

El orden textual esperado es 1, 10, 2; el numérico, 1, 2, 10; y el numérico descendente, 10, 2, 1. Aquí solo hay dígitos: la ordenación de letras y caracteres acentuados también depende de la configuración regional.

Para ordenar filas por una columna, -t fija el separador y -k la clave de ordenación. -k 2,2 indica que la clave empieza y termina en el segundo campo:

tail -n +2 data/raw/personas.csv | sort -t ',' -k 2,2n

La n asociada a la clave pide comparar la edad como número. Debes obtener las filas de Maria (25), Ana (28), Juan (30) y Carlos (35), conservando todos sus campos. Añade r a esa clave numérica para invertir su orden:

tail -n +2 data/raw/personas.csv | sort -t ',' -k 2,2nr

Los modificadores n y r se asocian aquí a la clave 2,2. No mezcles una clave con modificadores propios y opciones globales esperando que siempre se combinen: expresarlos en la misma clave deja clara la comparación.

No hemos ordenado la cabecera como si fuera una persona. Tampoco hemos cambiado personas.csv: sort muestra el resultado. Si lo necesitas como archivo, usa un destino diferente:

tail -n +2 data/raw/personas.csv | sort -t ',' -k 2,2n > logs/personas-por-edad.csv
wc -l logs/personas-por-edad.csv

El resultado tiene cuatro líneas y no incluye cabecera. Nunca redirijas la salida sobre el mismo archivo que estás leyendo: > lo vacía antes de que la orden lo procese.

sort -u elimina líneas duplicadas al ordenar. uniq, en cambio, reúne repeticiones consecutivas, como vimos al construir la tubería del apartado 3. No son dos órdenes intercambiables en cualquier posición de un flujo.

Ahora sí podemos aplicar aquel recuento al CSV de cotizaciones, con todas sus piezas ya estudiadas:

tail -n +2 data/raw/cotizaciones.csv | cut -d ',' -f 2 | sort | uniq -c

En el CSV inicial debe aparecer una cotización de BTCUSDT. La tubería quita la cabecera, extrae símbolos, los ordena y cuenta repeticiones. Si posteriormente has añadido registros, contrasta el recuento con el contenido real, no con el valor inicial.

8. Transformar caracteres con tr

tr recibe texto por la entrada estándar y escribe una transformación por la salida estándar. No se le pasa un nombre de archivo como argumento para que lo abra. Sus conjuntos describen caracteres, no palabras completas ni expresiones regulares.

echo 'terminal linux' | tr 'a-z' 'A-Z'
echo 'Nombre,Edad,Ciudad' | tr ',' ';'
echo 'La carpeta    contiene   notas' | tr -s ' '

Las salidas deben ser, respectivamente:

TERMINAL LINUX
Nombre;Edad;Ciudad
La carpeta contiene notas

En el primer ejemplo se usan letras ASCII sin acentos; no presupongas que ese rango convierte correctamente cualquier texto Unicode. El segundo sustituye cada coma por punto y coma. En el tercero, -s comprime repeticiones consecutivas del carácter espacio. Esto no es una limpieza general de CSV: cambiar separadores indiscriminadamente puede alterar campos que contengan esos caracteres.

-d elimina los caracteres indicados:

echo 'a1b2c3' | tr -d '0-9'

Debe mostrar abc. tr -d '\n' quitaría saltos de línea, uniendo registros; no lo aplicaremos a nuestros CSV porque destruiría la separación entre filas.

9. Sustituir texto con sed

Cuando necesitas cambiar una palabra o actuar sobre determinadas líneas, sed permite expresar una edición. La forma básica de sustitución es s/patron/reemplazo/: busca un patrón y sustituye su primera coincidencia en cada línea. El indicador final g pide sustituir todas las coincidencias de esa línea.

Prepara data/raw/ejemplotexto.txt con Nano, a partir del ejemplo del curso anterior:

ejemplotexto.txt

La camioneta es     vieja
La estUfa es nueva
La cesta es nueva
La camisa es vieja
La sudadera es nueva

No uses todavía -i: las órdenes siguientes mostrarán los cambios sin modificar el archivo:

sed 's/U/u/g' data/raw/ejemplotexto.txt
sed 's/nueva/vieja/g' data/raw/ejemplotexto.txt
sed '4s/vieja/nueva/g' data/raw/ejemplotexto.txt

La primera salida debe corregir estUfa a estufa. La segunda cambia nueva en las líneas 2, 3 y 5. La tercera cambia únicamente la cuarta línea a La camisa es nueva; 4 selecciona la línea donde se aplica la sustitución. Cada orden parte del original: las transformaciones mostradas no se acumulan entre ejecuciones.

Para cambiar solo la primera coincidencia o todas, compara:

echo 'nueva nueva' | sed 's/nueva/vieja/'
echo 'nueva nueva' | sed 's/nueva/vieja/g'

Debes obtener vieja nueva y vieja vieja. Las comillas simples protegen la expresión para que llegue a sed sin interpretaciones de la shell.

-E activa expresiones regulares extendidas, como las estudiadas con grep -E. Para comprimir grupos de espacios:

sed -E 's/ +/ /g' data/raw/ejemplotexto.txt

La primera línea debe mostrar un único espacio entre es y vieja. Aquí + es un patrón que pide uno o más espacios; sustituimos cada grupo por un espacio. tr -s ' ' permite resolver esta transformación concreta de forma más simple; sed permite además seleccionar líneas y sustituir palabras.

La orden d elimina de la salida las líneas seleccionadas. Por ejemplo, el patrón ^$ selecciona una línea vacía:

echo 'Primera

Tercera' | sed '/^$/d'

Debe mostrar solo Primera y Tercera. Una línea que contiene espacios no es una línea vacía para ese patrón.

Para encadenar cambios, usa varias expresiones con -e, que se aplican por orden en una misma ejecución:

sed -e 's/U/u/g' -e 's/nueva/vieja/g' data/raw/ejemplotexto.txt > logs/texto-transformado.txt
cat logs/texto-transformado.txt
cat data/raw/ejemplotexto.txt

El primer archivo contiene las dos transformaciones; el original debe conservar estUfa y las apariciones de nueva. Esto permite contrastar el antes y el después antes de aceptar una edición.

La opción -i modifica el archivo en su lugar. Si necesitas practicarla, hazlo sobre una copia y pide además una copia de seguridad:

cp data/raw/ejemplotexto.txt logs/texto-editable.txt
sed -i.bak 's/U/u/g' logs/texto-editable.txt
ls -l logs/texto-editable.txt logs/texto-editable.txt.bak
cat logs/texto-editable.txt
cat logs/texto-editable.txt.bak

En GNU sed de Debian, -i.bak conserva la versión anterior con el sufijo .bak. El editable debe contener estufa; la copia de seguridad, estUfa. No confundas una salida correcta por pantalla con una modificación del archivo: depende de si has utilizado -i o una redirección.

10. Practicar regex sin mezclar motores

Los apuntes anteriores combinaban sintaxis de varios motores. En M00 trabajaremos con expresiones regulares extendidas (ERE): grep -E, sed -E y el operador Bash =~. No copies una expresión de Python o de un probador configurado como PCRE esperando que todas sus funciones existan aquí. En particular, \d, grupos (?:...), búsquedas anticipadas y cuantificadores «lazy» no forman parte de nuestra sintaxis ERE.

Literales, clases y repeticiones

El punto sin protección representa un carácter; [.] o \. representan el punto literal. Compara:

echo '3x14' | grep -E '^3.14$'
echo '3x14' | grep -E '^3[.]14$'
echo '3.14' | grep -E '^3[.]14$'

La primera y la tercera seleccionan la línea; la segunda no. El patrón de la primera acepta un carácter cualquiera entre 3 y 14, no exige un separador decimal.

Una clase negada comienza por ^ dentro de los corchetes: [^0-9] selecciona un carácter que no sea dígito. Fuera de los corchetes, ^ sigue significando inicio de línea. Las clases POSIX permiten expresar categorías: [[:digit:]] son dígitos y [[:space:]] espacios en blanco; sus detalles pueden depender de la configuración regional.

Repetición ERE	Ejemplo	Líneas completas admitidas
*: cero o más	^ab*c$	ac, abc, abbc
+: una o más	^ab+c$	abc, abbc, no ac
?: cero o una	^ab?c$	ac, abc, no abbc
{n}: exactamente n	^[0-9]{3}$	Tres dígitos
{n,}: al menos n	^[0-9]{3,}$	Tres o más dígitos
{n,m}: entre n y m	^[0-9]{2,4}$	Dos, tres o cuatro dígitos

La repetición afecta al elemento anterior; para repetir una secuencia se agrupa con paréntesis. Por ejemplo, ^(ab)+$ admite ab y abab. Para elegir entre líneas completas utiliza ^(OK|ERROR)$: los anclajes delimitan el grupo entero, no una alternativa aislada.

Seleccionar líneas frente a extraer coincidencias

grep muestra normalmente la línea completa. La opción -o muestra solo cada coincidencia no vacía:

echo 'Contacto: @ana y @pedro_2' | grep -oE '@[A-Za-z0-9_]+'

Debes obtener dos líneas: @ana y @pedro_2. Es una extracción didáctica de menciones, no una comprobación de cuentas reales. Las comillas simples evitan que la shell interprete caracteres del patrón antes de entregarlo a grep.

Ejercicios regex recuperados

ID	Actividad
RX-1	Diseña un patrón ERE para el formato simplificado «ocho dígitos y una letra mayúscula». Prueba 12345678A, 1234567A, 12345678a y 12345678AA. Explica por qué reconocer el formato no calcula la letra de un DNI.
RX-2	Extrae las menciones de Aviso para @ana, @pedro_2 y @equipo, mostrando solo las coincidencias.
RX-3	Compara patrones que admitan cero, una y varias letras b entre a y c; prueba ac, abc y abbc, anotando selección o rechazo.
RX-4	Escribe un patrón para admitir únicamente OK o ERROR. Prueba también OK extra, texto ERROR y la cadena vacía.

Documenta patrón, entradas, salidas y código. Usa solo datos ficticios; no pruebes tarjetas, contraseñas o identificadores personales reales. La validación semántica no se añade por hacer una regex más larga.

Ejercicios de refuerzo

1. Crea logs/prueba.log, añade dos líneas sin sobrescribir las anteriores y comprueba el número de líneas.
2. Guarda en logs/simbolos.log el recuento de símbolos del CSV, sin perder su salida por pantalla.
3. A partir de data/raw/cotizaciones.csv, muestra los símbolos ordenados alfabéticamente sin incluir la cabecera ni modificar el archivo.
4. Filtra una lista que contenga BTCUSDT, btc/usdt, ETHUSDT y SOL-USDT, conservando solo símbolos válidos.
5. Ejecuta un comando que falle sobre un archivo inexistente y guarda únicamente su error en logs/error-prueba.log.
6. Muestra las notas de data/raw/notas-prueba.txt sustituyendo cada espacio por un guion, sin modificar el archivo. Comprueba que el original conserva los espacios.
7. Sobre una copia de data/raw/ejemplotexto.txt dentro de logs, corrige estUfa mediante edición en sitio y conserva una copia de seguridad. Compara el texto editado, el respaldo y el original.
8. Guarda en logs/personas-mayor-a-menor.csv las personas ordenadas por edad de mayor a menor, sin cabecera y conservando todas sus columnas. Comprueba el orden y el número de filas.
9. Muestra las líneas del CSV que contienen BTCUSDT, identificando su posición dentro del archivo.
10. Diseña una expresión regular extendida que acepte solo una línea formada por tres letras mayúsculas seguidas de tres dígitos. Prueba una entrada válida y otra inválida.

Práctica guiada

Crea un fichero data/raw/registros.csv con la cabecera timestamp,symbol,price y cinco registros del formato estudiado: tres válidos y dos inválidos (uno con símbolo en minúsculas y otro con precio no numérico). Escribe un flujo que omita la cabecera y separe los registros válidos y los inválidos en archivos distintos dentro de logs/. Comprueba que tienen tres y dos líneas respectivamente; explica qué parte del patrón valida cada campo. No modifiques cotizaciones.csv en esta práctica.

Relación con resultados de aprendizaje y criterios de evaluación

RA / CE	Evidencia
RA0.a)	Tuberías, redirecciones, campos, ordenación, transformaciones y regex ejecutados; resultados, archivos originales y errores comprobados.