Fehlerbehebung bei der NaN-Ausgabe in Python: Beheben von Fehlern in dateibasierten Berechnungen

Berechnen separater Durchschnittswerte positiver und negativer Zahlen aus einer Datei

Python-Backend-Skript zum Lesen von Dateidaten, Berechnen von Durchschnittswerten und zum robusten Umgang mit fehlenden Werten.

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

Umgang mit verschiedenen Datenformaten mit modularem und wiederverwendbarem Code

Python-Backend-Skript mit verbesserter modularer Struktur und Fehlerbehandlung für verschiedene Datenformate.

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

Unit-Tests für ein dateibasiertes Durchschnittsberechnungsprogramm

Python-Komponententests zur Sicherstellung einer korrekten Durchschnittsberechnung für verschiedene Eingabeszenarien.

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

Häufige Fragen zu Python NaN und Fehlerbehandlung

1. Was bedeutet float('NaN') in Python tun?
2. Dieser Befehl erstellt einen speziellen Float-Wert, der als „NaN“ (Not a Number) erkannt wird. Dies ist nützlich für die Behandlung von Fällen, in denen eine Berechnung nicht definiert ist oder wenn Sie fehlende Daten in Ihrem Programm kennzeichnen müssen.
3. Wie kann ich sicherstellen, dass meine Ausgabe bestimmten Formatierungsanforderungen entspricht?
4. Mit Methoden wie replace() Mit dieser Option können Sie steuern, wie Ihre Ausgabe angezeigt wird. Zum Beispiel, replace('nan', 'NaN') kann sicherstellen, dass Ihre „NaN“-Werte in der richtigen Schreibweise angezeigt werden, wie es in bestimmten Testsystemen erforderlich ist.
5. Warum ist try...except wichtig in dateibasierten Programmen?
6. Der try...except Der Block ist für die Fehlerbehandlung von entscheidender Bedeutung, wenn Zeilen möglicherweise ungültige Daten enthalten. Es verhindert, dass das Programm abstürzt, wenn eine Zeile nicht in eine Gleitkommazahl konvertiert werden kann, wodurch der Code zuverlässiger wird.
7. Was ist eine Inline-Bedingung und warum wird sie verwendet?
8. Ein Inline-bedingtes Like sum(numbers) / len(numbers) if numbers else float('NaN') ermöglicht es Ihnen, einen Vorgang nur dann auszuführen, wenn bestimmte Bedingungen erfüllt sind, beispielsweise wenn eine Liste Werte enthält. Dies ist ideal, um Fehler wie Division durch Null zu vermeiden.
9. Wie funktioniert die with open(file_name, 'r') Befehlsarbeit?
10. Dieser Befehl öffnet eine Datei im Lesemodus und schließt sie anschließend automatisch. Durch die Verwendung von „with“ wird sichergestellt, dass die Datei ordnungsgemäß geschlossen wird. Dies hilft bei der Ressourcenverwaltung und vermeidet Fehler, die dazu führen können, dass Dateien versehentlich geöffnet bleiben.
11. Kann ich testen, ob ein Wert in Python „NaN“ ist?
12. Ja, Sie können es verwenden math.isnan() um zu prüfen, ob ein Wert „NaN“ ist. Dies ist besonders hilfreich, wenn Sie „NaN“-Werte in Berechnungen oder Ausgaben formatieren oder ausschließen möchten.
13. Warum ist Formatkonsistenz bei der automatisierten Bewertung wichtig?
14. Automatisierte Systeme sind auf eine exakte Formatierung angewiesen, daher können geringfügige Unterschiede (wie „nan“ statt „NaN“) Fehler verursachen. Mit konsistenten Methoden wie replace() zur Formatierung verhindert diese Probleme.
15. Wie vereinfacht die Verwendung von Listen die Kategorisierung von Daten in Python?
16. Mithilfe von Listen können Sie Daten in Kategorien wie positive und negative Daten unterteilen, wodurch die Berechnung separater Statistiken für jede Kategorie einfacher wird. Das Anhängen von Werten an Listen basierend auf Bedingungen ist effizient und sorgt für die Organisation des Codes.
17. Was sind Inline-Bedingungen und wann sollten sie verwendet werden?
18. Inline-Bedingungen ermöglichen prägnante einzeilige Anweisungen, die Code nur dann ausführen, wenn eine Bedingung erfüllt ist. Berechnen Sie beispielsweise einen Durchschnitt nur dann, wenn Werte in einer Liste vorhanden sind, um Fehler zu vermeiden.
19. Wie kann ich die Druckausgabe zum Testen umleiten?
20. Durch die Verwendung StringIO Und sys.stdout Umleitung können Sie die Ausgabe in Tests erfassen, um zu überprüfen, ob sie den erwarteten Ergebnissen entspricht. Dies ist eine gängige Praxis bei Unit-Tests, bei denen Sie die Programmausgabe validieren möchten.
21. Was ist der Zweck von tearDown in Unit-Tests?
22. In unittest Rahmen, tearDown() wird zum Aufräumen nach Tests verwendet, z. B. zum Entfernen temporärer Dateien. Dadurch wird sichergestellt, dass jeder Test mit einer neuen Umgebung beginnt, wodurch Dateninterferenzen zwischen den Tests verhindert werden.

Zusammenfassung der Lösung

Diese Aufgabe zeigt, wie wichtig es ist, Sonderfälle wie das Fehlen positiver oder negativer Werte bei der Berechnung von Durchschnittswerten in Python zu behandeln. Durch die Verwendung von bedingten Anweisungen und Formatierungsanpassungen stellen Sie sicher, dass „NaN“ bei Bedarf zurückgegeben wird, und verhindern so Fehler durch leere Datenlisten.

Pythons Tools mögen Versuchen Sie es ... außer Und float('NaN') ermöglichen ein flexibles Fehlermanagement und erleichtern so den Umgang mit unerwarteten Daten. Solche Praktiken sind von unschätzbarem Wert für Programmierer, die Aufgaben, automatisierte Tests und alle Situationen bewältigen, die eine präzise Ausgabeformatierung erfordern. 🚀