Resolució de problemes de sortida de NaN a Python: correcció d'errors en càlculs basats en fitxers

Càlcul de mitjanes separades de nombres positius i negatius d'un fitxer

Script de fons de Python per llegir dades de fitxers, calcular mitjanes i gestionar els valors que falten de manera robusta.

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')

Maneig de diferents formats de dades amb codi modular i reutilitzable

Script de fons de Python amb estructura modular millorada i gestió d'errors per a diversos formats de dades.

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')

Proves unitàries per al programa de càlcul mitjà basat en fitxers

Proves d'unitat de Python per garantir un càlcul mitjà correcte per a diferents escenaris d'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()

Preguntes habituals sobre Python NaN i la gestió d'errors

1. Què fa float('NaN') fer en Python?
2. Aquesta ordre crea un valor flotant especial reconegut com a "NaN" (no un nombre). És útil per gestionar els casos en què un càlcul no està definit o quan necessiteu marcar les dades que falten al vostre programa.
3. Com puc assegurar-me que la meva sortida coincideix amb els requisits de format específics?
4. Utilitzant mètodes com replace() us permet controlar com apareix la vostra sortida. Per exemple, replace('nan', 'NaN') pot assegurar-se que els seus valors "NaN" apareixen en el cas correcte, tal com es requereix en determinats sistemes de prova.
5. Per què és try...except important en programes basats en fitxers?
6. El try...except El bloc és crucial per a la gestió d'errors en els casos en què les línies poden contenir dades no vàlides. Evita que el programa es bloquegi si una línia no es pot convertir en flotant, fent que el codi sigui més fiable.
7. Què és un condicional en línia i per què utilitzar-lo?
8. Un condicional en línia com sum(numbers) / len(numbers) if numbers else float('NaN') permet realitzar una operació només quan es compleixen determinades condicions, com ara quan una llista té valors. Això és ideal per evitar errors com la divisió per zero.
9. Com funciona el with open(file_name, 'r') treball de comandament?
10. Aquesta ordre obre un fitxer en mode de lectura i després el tanca automàticament. L'ús de "amb" garanteix que el fitxer es tanqui correctament, cosa que ajuda a la gestió dels recursos i evita errors de deixar els fitxers oberts accidentalment.
11. Puc provar si un valor és "NaN" a Python?
12. Sí, pots utilitzar math.isnan() per comprovar si un valor és "NaN". Això és especialment útil quan voleu formatar o excloure els valors "NaN" als càlculs o a la sortida.
13. Per què és important la coherència del format en la qualificació automatitzada?
14. Els sistemes automatitzats es basen en un format exacte, de manera que les diferències menors (com "nan" en lloc de "NaN") poden provocar errors. Utilitzant mètodes coherents com replace() perquè el format prevé aquests problemes.
15. Com l'ús de llistes simplifica la categorització de dades a Python?
16. Les llistes us permeten separar les dades en categories com ara positives i negatives, cosa que fa que el càlcul d'estadístiques separades per a cada categoria sigui senzill. Afegir valors a llistes basats en condicions és eficient i manté el codi organitzat.
17. Què són els condicionals en línia i quan s'han d'utilitzar?
18. Els condicionals en línia permeten declaracions concises d'una línia que executen codi només si es compleix una condició. Per exemple, calcular una mitjana només si hi ha valors en una llista, evitant errors.
19. Com puc redirigir la sortida d'impressió per a la prova?
20. Mitjançant l'ús StringIO i sys.stdout redirecció, podeu capturar la sortida a les proves per verificar que coincideix amb els resultats esperats. Aquesta és una pràctica habitual en les proves d'unitat on voleu validar la sortida del programa.
21. Quin és el propòsit tearDown en proves unitàries?
22. En unittest marcs, tearDown() s'utilitza per netejar després de les proves, com ara eliminar fitxers temporals. Això garanteix que cada prova comenci amb un entorn nou, evitant la interferència de dades entre proves.

Tancant la solució

Aquesta tasca demostra la importància de gestionar casos especials, com ara la falta de valors positius o negatius, a l'hora de calcular mitjanes en Python. Mitjançant declaracions condicionals i ajustos de format, us assegureu que es retorna "NaN" quan calgui, evitant qualsevol error de les llistes de dades buides.

Eines de Python com prova... excepte i float('NaN') permet una gestió flexible d'errors, facilitant la gestió de dades inesperades. Aquestes pràctiques són molt valuoses per als programadors que aborden tasques, proves automatitzades i qualsevol situació que requereixi un format de sortida precís. 🚀