Felsökning av NaN-utgång i Python: åtgärda fel i filbaserade beräkningar

Beräkna separata medelvärden av positiva och negativa tal från en fil

Python backend-skript för att läsa fildata, beräkna medelvärden och hantera saknade värden 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')

Hantera olika dataformat med modulär och återanvändbar kod

Python backend-skript med förbättrad modulstruktur och felhantering för olika dataformat.

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

Enhetstestning för filbaserat medelberäkningsprogram

Python-enhetstester för att säkerställa korrekt medelberäkning för olika ingångsscenarier.

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

Vanliga frågor om Python NaN och felhantering

1. Vad gör float('NaN') göra i Python?
2. Detta kommando skapar ett speciellt flytvärde som känns igen som "NaN" (inte ett tal). Det är användbart för att hantera fall där en beräkning är odefinierad eller när du behöver flagga saknad data i ditt program.
3. Hur kan jag säkerställa att min utdata matchar specifika formateringskrav?
4. Att använda metoder som replace() låter dig styra hur din utdata visas. Till exempel, replace('nan', 'NaN') kan säkerställa att dina "NaN"-värden visas i rätt fall, vilket krävs i vissa testsystem.
5. Varför är det try...except viktigt i filbaserade program?
6. De try...except blocket är avgörande för felhantering i de fall rader kan innehålla ogiltiga data. Det förhindrar att programmet kraschar om en rad inte kan konverteras till en float, vilket gör koden mer tillförlitlig.
7. Vad är en inline villkorlig, och varför använda den?
8. En inline villkorad like sum(numbers) / len(numbers) if numbers else float('NaN') låter dig utföra en operation endast när vissa villkor är uppfyllda, till exempel när en lista har värden. Detta är idealiskt för att undvika fel som division med noll.
9. Hur fungerar with open(file_name, 'r') kommandoarbete?
10. Detta kommando öppnar en fil i läsläge och stänger den automatiskt efteråt. Att använda "med" säkerställer att filen stängs ordentligt, vilket hjälper till med resurshantering och undviker fel från att oavsiktligt lämna filer öppna.
11. Kan jag testa om ett värde är "NaN" i Python?
12. Ja, du kan använda math.isnan() för att kontrollera om ett värde är "NaN." Detta är särskilt användbart när du vill formatera eller utesluta "NaN"-värden i beräkningar eller utdata.
13. Varför är formateringskonsistens viktigt vid automatiserad betygsättning?
14. Automatiserade system förlitar sig på exakt formatering, så mindre skillnader (som "nan" istället för "NaN") kan orsaka fel. Att använda konsekventa metoder som replace() för formatering förhindrar dessa problem.
15. Hur förenklar det att använda listor att kategorisera data i Python?
16. Listor låter dig dela upp data i kategorier som positiva och negativa, vilket gör det enkelt att beräkna separat statistik för varje kategori. Att lägga till värden till listor baserat på villkor är effektivt och håller koden organiserad.
17. Vad är inline-villkor och när ska de användas?
18. Inline-villkor tillåter kortfattade enradssatser som exekverar kod endast om ett villkor är uppfyllt. Till exempel beräkna ett medelvärde endast om värden finns i en lista, vilket förhindrar fel.
19. Hur kan jag omdirigera utskrifter för testning?
20. Genom att använda StringIO och sys.stdout omdirigering kan du fånga utdata i tester för att verifiera att det matchar förväntade resultat. Detta är en vanlig praxis vid enhetstestning där du vill validera programutdata.
21. Vad är syftet med tearDown i enhetstester?
22. I unittest ramar, tearDown() används för att rensa upp efter tester, som att ta bort temporära filer. Detta säkerställer att varje test börjar med en ny miljö, vilket förhindrar datainterferens mellan testerna.

Avsluta lösningen

Den här uppgiften visar vikten av att hantera speciella fall, som saknade positiva eller negativa värden, vid beräkning av medelvärden i Python. Genom att använda villkorssatser och formateringsjusteringar säkerställer du att "NaN" returneras när det behövs, vilket förhindrar eventuella fel från tomma datalistor.

Pythons verktyg som försök...förutom och float('NaN') möjliggör flexibel felhantering, vilket gör det lättare att hantera oväntade data. Sådana metoder är ovärderliga för programmerare som tar sig an uppdrag, automatiserade tester och alla situationer som kräver exakt utdataformatering. 🚀