Skip to content

Revisión automática de la práctica 06-palindromo

Este es el resultado de una revisión automática de la prácica 06-palindromo, tal y como la hemos recogido de este repositorio de entrega. Por favor, ten en cuenta que al ser una revisión automática, realizada en parte con la ayuda de un asistente de inteligencia artificial generativa, puede incluir errores, y ser incorrecta. Pero leela con atención, porque creemos que puede tener información útil. Si tienes cualquier duda, o crees que la revisión es errónea, por favor, consulta con los profesores de la asignatura.

Comprobación de archivos con extension '.py'

  • Archivos Python excluidos de la búsqueda:
  • Archivos Python encontrados (excluyendo esos): palindromo.py

Correcto, se elige palindromo.py como entrega.

Comprobación con ficheros de solución

Los archivos son diferentes de los de la solución.

Prueba automática del programa

Pruebas realizadas por 06-palindromo/tests/test_palindromo.py:

OK

Pruebas realizadas por 06-palindromo/tests/test_program.py:

OK

Revisión automática de programa

Programa revisado:

import sys


def leer_argumentos() -> str:
    """Lee y valida los argumentos de la línea de comandos.

    :return: Texto a evaluar
    """
    # Comprobamos que se ha proporcionado exactamente un argumento
    if len(sys.argv) != 2:
        print("Error: Se espera exactamente un argumento")
        print("Uso: python palindromo.py \"texto a evaluar\"")
        sys.exit(1)
    return sys.argv[1]


def limpiar_texto(texto: str) -> str:
    """Limpia el texto dejando solo caracteres alfabéticos en minúsculas.

    :param texto: Texto a limpiar
    :return: Texto limpio
    """
    texto_limpio = ''
    for caracter in texto.lower():
        if 'a' <= caracter <= 'z':  # Verifica si es una letra minúscula
            texto_limpio += caracter
    return texto_limpio


def palindromo(texto: str) -> bool:
    """Determina si el texto es un palíndromo.

    :param texto: Cadena de caracteres a evaluar,
     en minúsculas y sin caracteres no alfabéticos
    :return: True si es palíndromo, False en caso contrario
    """
    # Casos base
    if len(texto) <= 1:
        return True

    # Comparamos primer y último carácter
    if texto[0] != texto[-1]:
        return False

    # Llamada recursiva con el texto reducido (sin el primer y último carácter)
    return palindromo(texto[1:-1])


def main():
    texto_original = leer_argumentos()
    texto_limpio = limpiar_texto(texto_original)

    if palindromo(texto_limpio):
        print("Es palíndromo")
    else:
        print("No es palíndromo")


if __name__ == "__main__":
    main()

Análisis

Cumple con el enunciado

El programa cumple con los requisitos principales del enunciado. La función palindromo es puramente recursiva (sin bucles), maneja correctamente el caso base para cadenas vacías o de longitud 1, y reduce el problema en cada llamada recursiva comparando el primer y último carácter. La limpieza del texto (convertir a minúsculas y eliminar no alfabéticos) se realiza antes de la recursión, como exige el enunciado. Los ejemplos proporcionados en el enunciado funcionarían correctamente:

  • "Anita lava la tina." → "anitalavalatina" (palíndromo).
  • "Hola" → "hola" (no palíndromo).
    Sin embargo, existe un problema crítico: la función limpiar_texto solo considera caracteres entre 'a' y 'z' (ASCII), ignorando letras específicas del español como ñ, á, é, etc. Por ejemplo, "año" se limpiaría como "ao", lo cual es incorrecto (debería mantener la ñ). Aunque los ejemplos del enunciado no incluyen estos casos, el enunciado menciona explícitamente "caracteres no alfabéticos", y en español las letras con diacríticos son alfabéticas.

Es fácil de leer y entender

El código es claro y accesible para principiantes. Las funciones tienen nombres descriptivos (leer_argumentos, limpiar_texto, palindromo), y los comentarios/docstrings explican su propósito. La lógica recursiva en palindromo es sencilla de seguir: compara extremos y reduce la cadena. El uso de texto[1:-1] para la llamada recursiva es intuitivo para quien conoce slicing. La estructura general (main + if __name__) sigue el esquema habitual enseñado.

Sigue buenas prácticas de programación

El programa separa responsabilidades en funciones bien definidas (entrada, limpieza, lógica recursiva), lo cual es una buena práctica. Los docstrings cumplen con la documentación mínima requerida. No obstante:

  • Falta validación de entrada robusta: Si el usuario introduce múltiples argumentos, el mensaje de error menciona python en lugar de python3 (como en el ejemplo del enunciado).
  • Limpieza inadecuada de texto: Como se señaló, el enfoque 'a' <= caracter <= 'z' es insuficiente para el español. Se debería usar str.isalpha() para identificar caracteres alfabéticos de forma universal.
  • No se manejan casos extremos no especificados: Por ejemplo, si la cadena limpia queda vacía tras eliminar no alfabéticos (ej: "123!@#"), el programa devuelve True (correcto por el enunciado), pero no hay comentarios que expliquen este comportamiento.

Recomendaciones de mejora

  1. Mejorar limpiar_texto: Reemplazar la comparación manual 'a' <= caracter <= 'z' por caracter.isalpha(). Esto garantizaría que letras como ñ, á, etc., se conserven. Ejemplo: 
    texto_limpio = ''.join(caracter for caracter in texto.lower() if caracter.isalpha())
  2. Ajustar el mensaje de error: En leer_argumentos, cambiar python por python3 en el mensaje de uso para coincidir con el ejemplo del enunciado.
  3. Agregar comentario en palindromo: Explicar explícitamente por qué cadenas vacías son palíndromos (ej: "Caso base: cadenas vacías o de 1 carácter son palíndromos por definición").
  4. Validar entrada limpia: Aunque el enunciado no lo exige, sería útil añadir un comentario en main que aclare que si texto_limpio queda vacío, se considera palíndromo (ej: # Cadenas sin caracteres alfabéticos (ej: "123") son palíndromos por definición).

Estos cambios mantendrían la simplicidad para principiantes, pero resolverían problemas reales de internacionalización y claridad.