Depanarea ieșirii NaN în Python: Remedierea erorilor în calculele bazate pe fișiere

Calcularea mediilor separate ale numerelor pozitive și negative dintr-un fișier

Script backend Python pentru a citi datele fișierului, a calcula medii și a gestiona cu putere valorile lipsă.

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

Gestionarea diferitelor formate de date cu cod modular și reutilizabil

Script backend Python cu structură modulară îmbunătățită și gestionarea erorilor pentru diferite formate de date.

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

Testarea unitară pentru programul de calcul mediu bazat pe fișiere

Teste unitare Python pentru a asigura calculul mediu corect pentru diferite scenarii de intrare.

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

Întrebări frecvente despre Python NaN și gestionarea erorilor

1. Ce face float('NaN') faci in Python?
2. Această comandă creează o valoare flotantă specială recunoscută ca „NaN” (Nu este un număr). Este util pentru gestionarea cazurilor în care un calcul este nedefinit sau când trebuie să semnalați datele lipsă din program.
3. Cum mă pot asigura că rezultatul meu corespunde cerințelor specifice de formatare?
4. Folosind metode precum replace() vă permite să controlați modul în care apare rezultatul dvs. De exemplu, replace('nan', 'NaN') vă puteți asigura că valorile dvs. „NaN” apar în cazul corect, așa cum este necesar în anumite sisteme de testare.
5. De ce este try...except important în programele bazate pe fișiere?
6. The try...except blocul este crucial pentru tratarea erorilor în cazurile în care liniile pot conține date nevalide. Împiedică programul să se prăbușească dacă o linie nu poate fi convertită într-un float, făcând codul mai fiabil.
7. Ce este un condițional inline și de ce să-l folosești?
8. Un condițional inline like sum(numbers) / len(numbers) if numbers else float('NaN') vă permite să efectuați o operație numai atunci când sunt îndeplinite anumite condiții, cum ar fi atunci când o listă are valori. Acest lucru este ideal pentru a evita erori precum împărțirea la zero.
9. Cum face with open(file_name, 'r') munca de comanda?
10. Această comandă deschide un fișier în modul de citire și îl închide automat ulterior. Utilizarea „cu” asigură închiderea corectă a fișierului, ceea ce ajută la gestionarea resurselor și evită erorile de la lăsarea accidentală a fișierelor deschise.
11. Pot testa dacă o valoare este „NaN” în Python?
12. Da, poți folosi math.isnan() pentru a verifica dacă o valoare este „NaN”. Acest lucru este deosebit de util atunci când doriți să formatați sau să excludeți valorile „NaN” în calcule sau rezultate.
13. De ce este importantă consistența formatării în evaluarea automată?
14. Sistemele automate se bazează pe formatarea exactă, astfel încât diferențele minore (cum ar fi „nan” în loc de „NaN”) pot cauza erori. Folosind metode consistente precum replace() pentru formatare previne aceste probleme.
15. Cum simplifică utilizarea listelor clasificarea datelor în Python?
16. Listele vă permit să separați datele în categorii precum pozitive și negative, ceea ce face ca calcularea statisticilor separate pentru fiecare categorie să fie simplă. Adăugarea de valori la liste în funcție de condiții este eficientă și menține codul organizat.
17. Ce sunt condiționalele inline și când ar trebui folosite?
18. Condiționalele inline permit instrucțiuni concise de o linie care execută cod numai dacă o condiție este îndeplinită. De exemplu, calcularea unei medii numai dacă există valori într-o listă, prevenind erorile.
19. Cum pot redirecționa imprimarea pentru testare?
20. Prin utilizarea StringIO şi sys.stdout redirecționare, puteți captura rezultatul în teste pentru a verifica dacă se potrivește cu rezultatele așteptate. Aceasta este o practică comună în testarea unitară în care doriți să validați rezultatul programului.
21. Care este scopul tearDown la testele unitare?
22. În unittest cadre, tearDown() este folosit pentru a curăța după teste, cum ar fi eliminarea fișierelor temporare. Acest lucru asigură că fiecare test începe cu un mediu nou, prevenind interferența datelor între teste.

Încheierea soluției

Această sarcină demonstrează importanța gestionării cazurilor speciale, cum ar fi lipsa valorilor pozitive sau negative, atunci când se calculează mediile în Python. Folosind instrucțiuni condiționate și ajustări de format, vă asigurați că „NaN” este returnat atunci când este necesar, prevenind orice eroare din listele de date goale.

Instrumentele Python cum ar fi incearca...mai putin şi float('NaN') permite gestionarea flexibilă a erorilor, facilitând gestionarea datelor neașteptate. Astfel de practici sunt de neprețuit pentru programatori care abordează sarcini, teste automate și orice situație care necesită o formatare precisă a ieșirii. 🚀