Fejlfinding af NaN-output i Python: Ret fejl i filbaserede beregninger

Beregning af separate gennemsnit af positive og negative tal fra en fil

Python backend-script til at læse fildata, beregne gennemsnit og håndtere manglende værdier robust.

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

Håndtering af forskellige dataformater med modulær og genanvendelig kode

Python backend script med forbedret modulær struktur og fejlhåndtering til forskellige dataformater.

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

Enhedstest for filbaseret gennemsnitsberegningsprogram

Python-enhedstest for at sikre korrekt gennemsnitsberegning for forskellige inputscenarier.

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

Almindelige spørgsmål om Python NaN og fejlhåndtering

1. Hvad gør float('NaN') gøre i Python?
2. Denne kommando opretter en speciel flydende værdi, der genkendes som "NaN" (ikke et tal). Det er nyttigt til at håndtere sager, hvor en beregning er udefineret, eller når du skal markere manglende data i dit program.
3. Hvordan kan jeg sikre, at mit output matcher specifikke formateringskrav?
4. Ved at bruge metoder som replace() giver dig mulighed for at kontrollere, hvordan dit output vises. f.eks. replace('nan', 'NaN') kan sikre, at dine "NaN"-værdier vises i det rigtige tilfælde, som det kræves i visse testsystemer.
5. Hvorfor er try...except vigtigt i filbaserede programmer?
6. De try...except blok er afgørende for fejlhåndtering i tilfælde, hvor linjer kan indeholde ugyldige data. Det forhindrer programmet i at gå ned, hvis en linje ikke kan konverteres til en float, hvilket gør koden mere pålidelig.
7. Hvad er en inline betinget, og hvorfor bruge det?
8. En inline betinget lignende sum(numbers) / len(numbers) if numbers else float('NaN') giver dig mulighed for kun at udføre en handling, når visse betingelser er opfyldt, såsom når en liste har værdier. Dette er ideelt til at undgå fejl som division med nul.
9. Hvordan virker with open(file_name, 'r') kommando arbejde?
10. Denne kommando åbner en fil i læsetilstand og lukker den automatisk bagefter. Brug af "med" sikrer, at filen lukker korrekt, hvilket hjælper med ressourcestyring og undgår fejl, der ved et uheld efterlader filer åbne.
11. Kan jeg teste, om en værdi er "NaN" i Python?
12. Ja, du kan bruge math.isnan() for at kontrollere, om en værdi er "NaN." Dette er især nyttigt, når du vil formatere eller udelukke "NaN"-værdier i beregninger eller output.
13. Hvorfor er formateringskonsistens vigtig i automatiseret karaktergivning?
14. Automatiserede systemer er afhængige af nøjagtig formatering, så mindre forskelle (som "nan" i stedet for "NaN") kan forårsage fejl. Brug konsekvente metoder som f.eks replace() til formatering forhindrer disse problemer.
15. Hvordan forenkler brugen af ​​lister kategorisering af data i Python?
16. Lister giver dig mulighed for at adskille data i kategorier som positive og negative, hvilket gør det nemt at beregne separate statistikker for hver kategori. Tilføjelse af værdier til lister baseret på forhold er effektivt og holder koden organiseret.
17. Hvad er inline conditionals, og hvornår skal de bruges?
18. Inline-betingelser giver mulighed for kortfattede sætninger på én linje, der kun udfører kode, hvis en betingelse er opfyldt. For eksempel beregner man kun et gennemsnit, hvis der findes værdier på en liste, hvilket forhindrer fejl.
19. Hvordan kan jeg omdirigere printoutput til test?
20. Ved at bruge StringIO og sys.stdout omdirigering, kan du fange output i test for at verificere, at det matcher de forventede resultater. Dette er en almindelig praksis i enhedstest, hvor du ønsker at validere programoutput.
21. Hvad er formålet med tearDown i enhedstest?
22. I unittest rammer, tearDown() bruges til at rydde op efter test, f.eks. fjernelse af midlertidige filer. Dette sikrer, at hver test starter med et nyt miljø, hvilket forhindrer datainterferens mellem testene.

Afslutning af løsningen

Denne opgave demonstrerer vigtigheden af ​​at håndtere specielle tilfælde, som manglende positive eller negative værdier, når man beregner gennemsnit i Python. Ved at bruge betingede sætninger og formateringsjusteringer sikrer du, at "NaN" returneres, når det er nødvendigt, hvilket forhindrer fejl fra tomme datalister.

Pythons værktøjer som prøv... undtagen og float('NaN') giver mulighed for fleksibel fejlhåndtering, hvilket gør det nemmere at håndtere uventede data. Sådan praksis er uvurderlig for programmører, der tackler opgaver, automatiserede tests og enhver situation, der kræver præcis outputformatering. 🚀