Rozwiązywanie problemów z wyjściem NaN w Pythonie: naprawianie błędów w obliczeniach opartych na plikach

Obliczanie oddzielnych średnich liczb dodatnich i ujemnych z pliku

Skrypt zaplecza Pythona do odczytywania danych z plików, obliczania średnich i niezawodnego obsługi brakujących wartości.

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

Obsługa różnych formatów danych za pomocą kodu modułowego i wielokrotnego użytku

Skrypt backendowy w języku Python z ulepszoną strukturą modułową i obsługą błędów dla różnych formatów danych.

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

Testowanie jednostkowe programu do obliczania średniej opartej na plikach

Testy jednostkowe Pythona zapewniające prawidłowe obliczenia średniej dla różnych scenariuszy wejściowych.

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

Często zadawane pytania dotyczące Pythona NaN i obsługi błędów

1. Co robi float('NaN') zrobić w Pythonie?
2. To polecenie tworzy specjalną wartość zmiennoprzecinkową rozpoznawaną jako „NaN” (nie liczba). Jest to przydatne do obsługi przypadków, gdy obliczenie jest niezdefiniowane lub gdy trzeba oznaczyć brakujące dane w programie.
3. Jak mogę się upewnić, że moje dane wyjściowe odpowiadają określonym wymaganiom formatowania?
4. Używanie metod takich jak replace() pozwala kontrolować sposób wyświetlania wyników. Na przykład, replace('nan', 'NaN') może zapewnić, że wartości „NaN” pojawią się we właściwych przypadkach, zgodnie z wymaganiami w niektórych systemach testowych.
5. Dlaczego try...except ważne w programach plikowych?
6. The try...except blok ma kluczowe znaczenie dla obsługi błędów w przypadkach, gdy linie mogą zawierać nieprawidłowe dane. Zapobiega awarii programu, jeśli linii nie można przekonwertować na liczbę zmiennoprzecinkową, dzięki czemu kod jest bardziej niezawodny.
7. Co to jest wbudowany warunek i dlaczego go używać?
8. Wbudowany warunek warunkowy sum(numbers) / len(numbers) if numbers else float('NaN') umożliwia wykonanie operacji tylko wtedy, gdy spełnione są określone warunki, na przykład gdy lista zawiera wartości. Jest to idealne rozwiązanie, aby uniknąć błędów, takich jak dzielenie przez zero.
9. Jak to jest with open(file_name, 'r') dowodzenie pracą?
10. To polecenie otwiera plik w trybie odczytu, a następnie automatycznie go zamyka. Użycie opcji „z” zapewnia prawidłowe zamknięcie pliku, co pomaga w zarządzaniu zasobami i pozwala uniknąć błędów wynikających z przypadkowego pozostawienia plików otwartych.
11. Czy mogę sprawdzić, czy wartość w Pythonie to „NaN”?
12. Tak, możesz skorzystać math.isnan() aby sprawdzić, czy wartość to „NaN”. Jest to szczególnie przydatne, gdy chcesz sformatować lub wykluczyć wartości „NaN” w obliczeniach lub wynikach.
13. Dlaczego spójność formatowania jest ważna w automatycznym ocenianiu?
14. Zautomatyzowane systemy opierają się na dokładnym formatowaniu, więc drobne różnice (np. „nan” zamiast „NaN”) mogą powodować błędy. Używanie spójnych metod, takich jak replace() do formatowania zapobiega tym problemom.
15. W jaki sposób używanie list upraszcza kategoryzację danych w Pythonie?
16. Listy umożliwiają podzielenie danych na kategorie, np. pozytywne i negatywne, co ułatwia obliczanie oddzielnych statystyk dla każdej kategorii. Dołączanie wartości do list na podstawie warunków jest wydajne i pozwala zachować porządek w kodzie.
17. Co to są wbudowane warunki warunkowe i kiedy należy je stosować?
18. Wbudowane warunki warunkowe pozwalają na zwięzłe, jednowierszowe instrukcje, które wykonują kod tylko wtedy, gdy spełniony jest warunek. Na przykład obliczenie średniej tylko wtedy, gdy wartości istnieją na liście, co pozwala uniknąć błędów.
19. Jak mogę przekierować wydruki do testów?
20. Używając StringIO I sys.stdout przekierowania, możesz przechwycić dane wyjściowe w testach, aby sprawdzić, czy odpowiadają one oczekiwanym wynikom. Jest to powszechna praktyka w testach jednostkowych, gdy chcesz sprawdzić wyniki programu.
21. Jaki jest cel tearDown w testach jednostkowych?
22. W unittest ramy, tearDown() służy do czyszczenia po testach, np. usuwania plików tymczasowych. Dzięki temu każdy test rozpoczyna się w nowym środowisku, co zapobiega zakłóceniom danych pomiędzy testami.

Podsumowanie rozwiązania

To zadanie pokazuje, jak ważne jest radzenie sobie ze specjalnymi przypadkami, takimi jak brakujące wartości dodatnie lub ujemne, podczas obliczania średnich w Pythonie. Używając instrukcji warunkowych i dostosowań formatowania, masz pewność, że w razie potrzeby zostanie zwrócona wartość „NaN”, co zapobiega błędom wynikającym z pustych list danych.

Narzędzia Pythona, takie jak spróbuj... z wyjątkiem I pływak('NaN') pozwalają na elastyczne zarządzanie błędami, ułatwiając obsługę nieoczekiwanych danych. Takie praktyki są nieocenione dla programistów zajmujących się zadaniami, testami automatycznymi i każdą sytuacją wymagającą precyzyjnego formatowania danych wyjściowych. 🚀