Trata una expresión regular generada por IA como un borrador, no como una regla terminada. Crea una pequeña tabla de pruebas sintéticas, compara las coincidencias esperadas con las reales, corrige el patrón y guarda un informe de revisión antes de usarlo con datos reales.
La traducción se ha realizado con IA. Comprueba el código, las unidades y los valores junto con el original. La revisión por hablantes nativos de cada idioma aún no se ha completado. English
Para quién esEsta guía es para personas que usan IA para redactar expresiones regulares y quieren una forma sencilla de comprobar el patrón con casos conocidos que deben coincidir y no coincidir.
Supongamos que un ID interno de trabajo debe tener el formato WK-YYYY-NNNN. El prefijo debe ser WK en mayúsculas, el año debe estar entre 2000 y 2099, los separadores deben ser guiones y la parte final debe contener exactamente cuatro dígitos ASCII.
Imagina que un asistente de IA propone el patrón WK-\d{4}-\d{4}. Parece razonable, pero solo exige cuatro dígitos para el año. No aplica el intervalo indicado de 2000-2099. El siguiente paso más seguro no es usarlo de inmediato, sino probarlo con ejemplos cuya respuesta ya conoces.
El siguiente conjunto de datos es sintético y se creó específicamente para este artículo. Guárdalo como regex_cases.csv. Contiene tres cadenas que deben coincidir y siete que no deben hacerlo.
case_id,value,should_match
C001,WK-2026-0001,yes
C002,WK-2000-0042,yes
C003,WK-2099-9999,yes
C004,WK-1999-0001,no
C005,wk-2026-0001,no
C006,WK-2026-001,no
C007,WK-2026-00001,no
C008,WK-2026_0001,no
C009," WK-2026-0001",no
C010,WK-20A6-0001,no
Los casos cubren los límites permitidos del año, un año fuera de rango, un prefijo en minúsculas, campos de secuencia demasiado cortos y demasiado largos, un separador incorrecto, espacio en blanco al inicio y un carácter no numérico en el año. Son suficientemente pequeños para clasificarlos manualmente antes de ejecutar cualquier expresión regular.
El patrón de IA WK-\d{4}-\d{4} debería aceptar C001, C002 y C003. Por razones estructurales debería rechazar C005 hasta C010. Sin embargo, también acepta C004 porque 1999 sigue estando formado por cuatro dígitos.
| Caso | Esperado | Patrón de IA | Resultado |
|---|---|---|---|
| C001 | MATCH | MATCH | PASS |
| C002 | MATCH | MATCH | PASS |
| C003 | MATCH | MATCH | PASS |
| C004 | NO MATCH | MATCH | FAIL |
| C005 | NO MATCH | NO MATCH | PASS |
| C006 | NO MATCH | NO MATCH | PASS |
| C007 | NO MATCH | NO MATCH | PASS |
| C008 | NO MATCH | NO MATCH | PASS |
| C009 | NO MATCH | NO MATCH | PASS |
| C010 | NO MATCH | NO MATCH | PASS |
El patrón revisado es WK-20[0-9]{2}-[0-9]{4}. El prefijo 20 restringe el año al intervalo de 2000 a 2099, y [0-9] hace explícito el conjunto de dígitos previsto. El script usa fullmatch, por lo que toda la cadena de entrada debe cumplir el patrón.
Guarda el siguiente script como ai_regex_check.py. Prueba tanto la propuesta de la IA como el patrón revisado, escribe cada caso en un informe CSV y se niega a reutilizar una carpeta de salida existente.
import csv
import re
from pathlib import Path
SOURCE = Path("regex_cases.csv")
OUTPUT_DIR = Path("outputs") / "regex_check_result"
REPORT = OUTPUT_DIR / "regex_check.csv"
AI_PATTERN = re.compile(r"WK-\d{4}-\d{4}")
REVISED_PATTERN = re.compile(r"WK-20[0-9]{2}-[0-9]{4}")
def parse_expected(value: str) -> bool:
normalized = value.strip().lower()
if normalized == "yes":
return True
if normalized == "no":
return False
raise ValueError(f"Expected yes or no, got: {value!r}")
def label(value: bool) -> str:
return "MATCH" if value else "NO MATCH"
def main() -> None:
if not SOURCE.is_file():
raise FileNotFoundError(f"Source CSV not found: {SOURCE}")
if OUTPUT_DIR.exists():
raise FileExistsError(f"Output folder already exists: {OUTPUT_DIR}")
results = []
ai_failures = 0
revised_failures = 0
with SOURCE.open("r", encoding="utf-8-sig", newline="") as stream:
reader = csv.DictReader(stream)
required = {"case_id", "value", "should_match"}
if reader.fieldnames is None or not required.issubset(reader.fieldnames):
raise ValueError("CSV is missing a required column.")
for row_number, row in enumerate(reader, start=2):
expected = parse_expected(row["should_match"])
text = row["value"]
ai_actual = AI_PATTERN.fullmatch(text) is not None
revised_actual = REVISED_PATTERN.fullmatch(text) is not None
ai_pass = ai_actual == expected
revised_pass = revised_actual == expected
if not ai_pass:
ai_failures += 1
if not revised_pass:
revised_failures += 1
results.append({
"case_id": row["case_id"],
"value": text,
"expected": label(expected),
"ai_actual": label(ai_actual),
"ai_test": "PASS" if ai_pass else "FAIL",
"revised_actual": label(revised_actual),
"revised_test": "PASS" if revised_pass else "FAIL",
})
OUTPUT_DIR.parent.mkdir(parents=True, exist_ok=True)
OUTPUT_DIR.mkdir()
fields = [
"case_id", "value", "expected", "ai_actual", "ai_test",
"revised_actual", "revised_test"
]
with REPORT.open("x", encoding="utf-8", newline="") as stream:
writer = csv.DictWriter(stream, fieldnames=fields)
writer.writeheader()
writer.writerows(results)
print(f"Cases: {len(results)}.")
print(f"AI pattern failures: {ai_failures}.")
print(f"Revised pattern failures: {revised_failures}.")
print(f"Report: {REPORT.as_posix()}")
if revised_failures:
raise RuntimeError("Revised pattern still fails one or more tests.")
if __name__ == "__main__":
main()
python ai_regex_check.pyHay 10 casos de prueba. El patrón de IA debe fallar exactamente en un caso, C004. El patrón revisado debe superar los 10 casos.
| Medida | Valor esperado |
|---|---|
| Casos | 10 |
| Fallos del patrón de IA | 1 |
| Fallos del patrón revisado | 0 |
| Caso de fallo de IA | C004 |
| Casos aprobados por el patrón revisado | 10 |
La salida de consola esperada se obtuvo manualmente a partir de la tabla de pruebas y del script. No es un registro capturado de una ejecución.
Cases: 10.
AI pattern failures: 1.
Revised pattern failures: 0.
Report: outputs/regex_check_result/regex_check.csv| Error | Por qué importa |
|---|---|
| Probar solo cadenas que deben coincidir | Una expresión regular demasiado permisiva puede parecer correcta hasta que se prueba un caso negativo. |
| Usar un patrón de IA sin volver a formular el requisito | El patrón puede resolver un problema ligeramente distinto del que querías resolver. |
| Comprobar solo un ejemplo normal | Los errores de límite, longitud, mayúsculas y minúsculas y separadores quedan sin probar. |
| Usar search en vez de fullmatch para una regla de campo completo | Puede encontrarse una subcadena aparentemente válida dentro de un valor que en conjunto es inválido. |
| Cambiar las respuestas esperadas después de ver la salida de la expresión regular | La prueba deja de ser una especificación independiente del comportamiento requerido. |
Superar estas 10 pruebas solo demuestra que el patrón revisado se comporta correctamente para estos 10 ejemplos sintéticos. No demuestra matemáticamente que todos los posibles valores de entrada se gestionen correctamente. Añade casos cuando aparezca un nuevo límite o modo de fallo.
Una expresión regular también valida la sintaxis, no la realidad del negocio. WK-2026-1234 puede coincidir perfectamente aunque ese ID no exista en tu base de datos. La existencia, la unicidad, la autorización y las relaciones con otros campos requieren comprobaciones separadas.
Este pequeño ejemplo no evalúa el rendimiento con entradas muy largas o diseñadas de forma adversarial. Los patrones más complejos generados por IA deben revisarse tanto por su corrección como por su comportamiento en tiempo de ejecución antes de usarlos en servicios que procesan texto no confiable.
2026-09-20 · ejemplo revisado manualmente · objetivo: Python 3.12 · biblioteca estándar: csv, pathlib, re · sin ejecución
Las explicaciones y los ejemplos son de elaboración propia. Puedes consultar los comportamientos y conceptos relacionados en las siguientes fuentes oficiales.