Feilsøking av NaN-utdata i Python: Retting av feil i filbaserte beregninger

Beregning av separate gjennomsnitt av positive og negative tall fra en fil

Python backend-skript for å lese fildata, beregne gjennomsnitt og håndtere manglende verdier 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åndtere forskjellige dataformater med modulær og gjenbrukbar kode

Python backend-skript med forbedret modulær struktur og feilhåndtering for ulike 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')

Enhetstesting for filbasert gjennomsnittsberegningsprogram

Python-enhetstester for å sikre korrekt gjennomsnittsberegning for ulike 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()

Vanlige spørsmål om Python NaN og feilhåndtering

1. Hva gjør float('NaN') gjøre i Python?
2. Denne kommandoen oppretter en spesiell flyteverdi som gjenkjennes som "NaN" (ikke et tall). Det er nyttig for å håndtere tilfeller der en beregning er udefinert eller når du trenger å flagge manglende data i programmet.
3. Hvordan kan jeg sikre at utdataene mine samsvarer med spesifikke formateringskrav?
4. Ved å bruke metoder som replace() lar deg kontrollere hvordan utdataene dine vises. For eksempel replace('nan', 'NaN') kan sikre at "NaN"-verdiene vises i riktig tilfelle, som kreves i visse testsystemer.
5. Hvorfor er det try...except viktig i filbaserte programmer?
6. De try...except blokkering er avgjørende for feilhåndtering i tilfeller der linjer kan inneholde ugyldige data. Det forhindrer programmet fra å krasje hvis en linje ikke kan konverteres til en flyter, noe som gjør koden mer pålitelig.
7. Hva er en innebygd betinget, og hvorfor bruke den?
8. En innebygd betinget like sum(numbers) / len(numbers) if numbers else float('NaN') lar deg utføre en operasjon bare når visse betingelser er oppfylt, for eksempel når en liste har verdier. Dette er ideelt for å unngå feil som divisjon med null.
9. Hvordan fungerer with open(file_name, 'r') kommandoarbeid?
10. Denne kommandoen åpner en fil i lesemodus og lukker den automatisk etterpå. Bruk av "med" sikrer at filen lukkes ordentlig, noe som hjelper til med ressursadministrasjon og unngår feil ved å la filer være åpne ved et uhell.
11. Kan jeg teste om en verdi er "NaN" i Python?
12. Ja, du kan bruke math.isnan() for å sjekke om en verdi er "NaN." Dette er spesielt nyttig når du vil formatere eller ekskludere "NaN"-verdier i beregninger eller utdata.
13. Hvorfor er konsistens i formateringen viktig i automatisert gradering?
14. Automatiserte systemer er avhengige av nøyaktig formatering, så mindre forskjeller (som "nan" i stedet for "NaN") kan forårsake feil. Ved å bruke konsistente metoder som replace() for formatering forhindrer disse problemene.
15. Hvordan forenkler bruk av lister kategorisering av data i Python?
16. Lister lar deg dele data inn i kategorier som positive og negative, noe som gjør det enkelt å beregne separat statistikk for hver kategori. Å legge til verdier til lister basert på forhold er effektivt og holder koden organisert.
17. Hva er innebygde betingelser, og når bør de brukes?
18. Innebygde betingelser tillater konsise én-linje-setninger som kjører kode bare hvis en betingelse er oppfylt. For eksempel beregner et gjennomsnitt bare hvis det finnes verdier i en liste, og forhindrer feil.
19. Hvordan kan jeg omdirigere utskrifter for testing?
20. Ved å bruke StringIO og sys.stdout omdirigering, kan du fange opp utdata i tester for å bekrefte at det samsvarer med forventede resultater. Dette er en vanlig praksis i enhetstesting der du ønsker å validere programutdata.
21. Hva er hensikten med tearDown i enhetstester?
22. I unittest rammer, tearDown() brukes til å rydde opp etter tester, som å fjerne midlertidige filer. Dette sikrer at hver test starter med et nytt miljø, og forhindrer datainterferens mellom testene.

Avslutter løsningen

Denne oppgaven demonstrerer viktigheten av å håndtere spesielle tilfeller, som manglende positive eller negative verdier, når man beregner gjennomsnitt i Python. Ved å bruke betingede setninger og formateringsjusteringer, sikrer du at "NaN" returneres når det er nødvendig, og forhindrer eventuelle feil fra tomme datalister.

Pythons verktøy som prøv...bortsett fra og float('NaN') tillate fleksibel feilhåndtering, noe som gjør det enklere å håndtere uventede data. Slik praksis er uvurderlig for programmerere som takler oppdrag, automatiserte tester og enhver situasjon som krever presis utdataformatering. 🚀