Risoluzione dei problemi dell'output NaN in Python: correzione degli errori nei calcoli basati su file

Calcolo delle medie separate dei numeri positivi e negativi da un file

Script backend Python per leggere i dati dei file, calcolare le medie e gestire i valori mancanti in modo affidabile.

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

Gestione di diversi formati di dati con codice modulare e riutilizzabile

Script backend Python con struttura modulare migliorata e gestione degli errori per vari formati di dati.

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

Test unitari per il programma di calcolo della media basato su file

Unit test Python per garantire il corretto calcolo della media per diversi scenari di input.

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

Domande comuni su Python NaN e sulla gestione degli errori

1. Cosa fa float('NaN') fare in Python?
2. Questo comando crea un valore float speciale riconosciuto come "NaN" (Not a Number). È utile per gestire i casi in cui un calcolo non è definito o quando è necessario contrassegnare i dati mancanti nel programma.
3. Come posso garantire che il mio output soddisfi requisiti di formattazione specifici?
4. Utilizzando metodi come replace() ti consente di controllare come appare il tuo output. Per esempio, replace('nan', 'NaN') può garantire che i valori "NaN" vengano visualizzati nel caso corretto, come richiesto in alcuni sistemi di test.
5. Perché è try...except importante nei programmi basati su file?
6. IL try...except block è fondamentale per la gestione degli errori nei casi in cui le righe possono contenere dati non validi. Impedisce al programma di bloccarsi se una riga non può essere convertita in float, rendendo il codice più affidabile.
7. Cos'è un condizionale in linea e perché usarlo?
8. Un condizionale in linea come sum(numbers) / len(numbers) if numbers else float('NaN') consente di eseguire un'operazione solo quando vengono soddisfatte determinate condizioni, ad esempio quando un elenco contiene valori. Questo è l'ideale per evitare errori come la divisione per zero.
9. Come funziona il with open(file_name, 'r') lavoro di comando?
10. Questo comando apre un file in modalità lettura e successivamente lo chiude automaticamente. L'uso di "con" garantisce che il file si chiuda correttamente, il che aiuta nella gestione delle risorse ed evita errori derivanti dal lasciare accidentalmente i file aperti.
11. Posso verificare se un valore è "NaN" in Python?
12. Sì, puoi usare math.isnan() per verificare se un valore è "NaN". Ciò è particolarmente utile quando si desidera formattare o escludere valori "NaN" nei calcoli o nell'output.
13. Perché la coerenza della formattazione è importante nella valutazione automatizzata?
14. I sistemi automatizzati si basano su una formattazione esatta, quindi piccole differenze (come "nan" invece di "NaN") possono causare errori. Utilizzando metodi coerenti come replace() per la formattazione previene questi problemi.
15. In che modo l'uso degli elenchi semplifica la categorizzazione dei dati in Python?
16. Gli elenchi ti consentono di separare i dati in categorie come positivi e negativi, il che rende semplice il calcolo di statistiche separate per ciascuna categoria. L'aggiunta di valori agli elenchi in base alle condizioni è efficiente e mantiene il codice organizzato.
17. Cosa sono i condizionali in linea e quando dovrebbero essere utilizzati?
18. I condizionali in linea consentono istruzioni concise di una riga che eseguono il codice solo se una condizione è soddisfatta. Ad esempio, calcolando una media solo se esistono valori in un elenco, evitando errori.
19. Come posso reindirizzare l'output di stampa per il test?
20. Utilizzando StringIO E sys.stdout reindirizzamento, è possibile acquisire l'output nei test per verificare che corrisponda ai risultati previsti. Questa è una pratica comune negli unit test in cui si desidera convalidare l'output del programma.
21. Qual è lo scopo di tearDown nei test unitari?
22. In unittest quadri, tearDown() viene utilizzato per ripulire dopo i test, come rimuovere i file temporanei. Ciò garantisce che ogni test inizi con un nuovo ambiente, prevenendo l'interferenza dei dati tra i test.

Conclusione della soluzione

Questo compito dimostra l'importanza di gestire casi speciali, come valori positivi o negativi mancanti, quando si calcolano le medie in Python. Utilizzando istruzioni condizionali e modifiche alla formattazione, ti assicuri che "NaN" venga restituito quando necessario, evitando eventuali errori derivanti da elenchi di dati vuoti.

Gli strumenti di Python come provare...tranne E float('NaN') consentire una gestione flessibile degli errori, semplificando la gestione dei dati imprevisti. Tali pratiche hanno un valore inestimabile per i programmatori che devono affrontare compiti, test automatizzati e qualsiasi situazione che richieda una formattazione precisa dell'output. 🚀