Solución de problemas de salida NaN en Python: corrección de errores en cálculos basados ​​en archivos

Calcular promedios separados de números positivos y negativos a partir de un archivo

Script de backend de Python para leer datos de archivos, calcular promedios y manejar valores faltantes de manera sólida.

def calculate_averages(file_name):
    """Calculate and print average of negative and positive numbers from a file.
    Args:
        file_name (str): Name of the file containing numbers, one per line.
    Returns:
        None (prints averages directly).
    """
    negatives = []
    positives = []
    # Read the file and categorize numbers
    with open(file_name, 'r') as file:
        for line in file:
            try:
                num = float(line.strip())
                if num < 0:
                    negatives.append(num)
                elif num > 0:
                    positives.append(num)
            except ValueError:
                # Ignore lines that aren't valid numbers
                continue
    # Calculate averages with NaN fallback
    neg_avg = sum(negatives) / len(negatives) if negatives else float('NaN')
    pos_avg = sum(positives) / len(positives) if positives else float('NaN')
    # Print averages to match Pearson's expected format
    print(f"{neg_avg:.1f}".replace('nan', 'NaN'))
    print(f"{pos_avg:.1f}".replace('nan', 'NaN'))

# Call the function with test file
calculate_averages('numbers.txt')

Manejo de diferentes formatos de datos con código modular y reutilizable

Script de backend de Python con estructura modular mejorada y manejo de errores para varios formatos de datos.

import math
def calculate_average(numbers):
    """Helper function to calculate average, returning NaN if list is empty."""
    return sum(numbers) / len(numbers) if numbers else float('NaN')

def parse_numbers(file_name):
    """Parse numbers from file, categorize them into positives and negatives."""
    negatives, positives = [], []
    with open(file_name, 'r') as file:
        for line in file:
            try:
                num = float(line.strip())
                if num < 0:
                    negatives.append(num)
                elif num > 0:
                    positives.append(num)
            except ValueError:
                continue
    return negatives, positives

def display_averages(neg_avg, pos_avg):
    """Prints averages in a specific format."""
    neg_output = str(neg_avg) if not math.isnan(neg_avg) else "NaN"
    pos_output = str(pos_avg) if not math.isnan(pos_avg) else "NaN"
    print(neg_output)
    print(pos_output)

# Main function to tie all parts together
def main(file_name):
    negatives, positives = parse_numbers(file_name)
    neg_avg = calculate_average(negatives)
    pos_avg = calculate_average(positives)
    display_averages(neg_avg, pos_avg)

# Execute main function with file input
main('numbers.txt')

Pruebas unitarias para el programa de cálculo promedio basado en archivos

Pruebas unitarias de Python para garantizar el cálculo promedio correcto para diferentes escenarios de entrada.

import unittest
from io import StringIO
import sys

class TestCalculateAverages(unittest.TestCase):
    def setUp(self):
        self.file_name = 'test_numbers.txt'

    def test_both_positives_and_negatives(self):
        with open(self.file_name, 'w') as f:
            f.write("-5\n-10\n15\n20\n")
        output = StringIO()
        sys.stdout = output
        main(self.file_name)
        sys.stdout = sys.__stdout__
        self.assertEqual(output.getvalue().strip(), "-7.5\n17.5")

    def test_no_negatives(self):
        with open(self.file_name, 'w') as f:
            f.write("10\n20\n30\n")
        output = StringIO()
        sys.stdout = output
        main(self.file_name)
        sys.stdout = sys.__stdout__
        self.assertEqual(output.getvalue().strip(), "NaN\n20.0")

    def test_no_positives(self):
        with open(self.file_name, 'w') as f:
            f.write("-10\n-20\n-30\n")
        output = StringIO()
        sys.stdout = output
        main(self.file_name)
        sys.stdout = sys.__stdout__
        self.assertEqual(output.getvalue().strip(), "-20.0\nNaN")

    def tearDown(self):
        import os
        os.remove(self.file_name)

# Run the tests
unittest.main()

Preguntas comunes sobre Python NaN y el manejo de errores

1. ¿Qué hace? float('NaN') hacer en Python?
2. Este comando crea un valor flotante especial reconocido como "NaN" (no es un número). Es útil para manejar casos en los que un cálculo no está definido o cuando necesita marcar datos faltantes en su programa.
3. ¿Cómo puedo asegurarme de que mi salida coincida con los requisitos de formato específicos?
4. Usando métodos como replace() le permite controlar cómo aparece su salida. Por ejemplo, replace('nan', 'NaN') puede garantizar que sus valores "NaN" aparezcan en el caso correcto, como se requiere en ciertos sistemas de prueba.
5. ¿Por qué es try...except ¿Importante en programas basados ​​en archivos?
6. El try...except El bloque es crucial para el manejo de errores en los casos en que las líneas pueden contener datos no válidos. Evita que el programa falle si una línea no se puede convertir en flotante, lo que hace que el código sea más confiable.
7. ¿Qué es un condicional en línea y por qué usarlo?
8. Un condicional en línea como sum(numbers) / len(numbers) if numbers else float('NaN') le permite realizar una operación solo cuando se cumplen ciertas condiciones, como cuando una lista tiene valores. Esto es ideal para evitar errores como la división por cero.
9. ¿Cómo funciona el with open(file_name, 'r') trabajo de comando?
10. Este comando abre un archivo en modo lectura y luego lo cierra automáticamente. El uso de "con" garantiza que el archivo se cierre correctamente, lo que ayuda en la gestión de recursos y evita errores al dejar archivos abiertos accidentalmente.
11. ¿Puedo probar si un valor es "NaN" en Python?
12. Sí, puedes usar math.isnan() para comprobar si un valor es "NaN". Esto es particularmente útil cuando desea formatear o excluir valores "NaN" en cálculos o resultados.
13. ¿Por qué es importante la coherencia del formato en la calificación automática?
14. Los sistemas automatizados dependen de un formato exacto, por lo que diferencias menores (como "nan" en lugar de "NaN") pueden provocar errores. Usando métodos consistentes como replace() para formatear previene estos problemas.
15. ¿Cómo simplifica el uso de listas la categorización de datos en Python?
16. Las listas le permiten separar datos en categorías como positivos y negativos, lo que facilita el cálculo de estadísticas separadas para cada categoría. Agregar valores a listas según condiciones es eficiente y mantiene el código organizado.
17. ¿Qué son los condicionales en línea y cuándo deberían usarse?
18. Los condicionales en línea permiten declaraciones concisas de una línea que ejecutan código solo si se cumple una condición. Por ejemplo, calcular un promedio solo si existen valores en una lista, evitando errores.
19. ¿Cómo puedo redirigir la salida de impresión para realizar pruebas?
20. Al usar StringIO y sys.stdout redirección, puede capturar el resultado en pruebas para verificar que coincida con los resultados esperados. Esta es una práctica común en las pruebas unitarias donde desea validar el resultado del programa.
21. ¿Cuál es el propósito de tearDown en pruebas unitarias?
22. En unittest marcos, tearDown() se utiliza para limpiar después de las pruebas, como eliminar archivos temporales. Esto garantiza que cada prueba comience con un entorno nuevo, evitando la interferencia de datos entre pruebas.

Resumiendo la solución

Esta tarea demuestra la importancia de manejar casos especiales, como valores positivos o negativos faltantes, al calcular promedios en Python. Al utilizar declaraciones condicionales y ajustes de formato, se asegura de que se devuelva "NaN" cuando sea necesario, evitando errores de listas de datos vacías.

Las herramientas de Python como intentar... excepto y flotador('NaN') permiten una gestión de errores flexible, lo que facilita el manejo de datos inesperados. Estas prácticas son invaluables para los programadores que abordan tareas, pruebas automatizadas y cualquier situación que requiera un formato de salida preciso. 🚀