Problemen met NaN-uitvoer in Python oplossen: fouten oplossen in op bestanden gebaseerde berekeningen

Afzonderlijke gemiddelden van positieve en negatieve getallen uit een bestand berekenen

Python-backend-script om bestandsgegevens te lezen, gemiddelden te berekenen en ontbrekende waarden robuust te verwerken.

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

Omgaan met verschillende gegevensformaten met modulaire en herbruikbare code

Python-backend-script met verbeterde modulaire structuur en foutafhandeling voor verschillende dataformaten.

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

Eenheidstesten voor een op bestanden gebaseerd gemiddeldeberekeningsprogramma

Python-eenheidstests voor het garanderen van een correcte gemiddelde berekening voor verschillende invoerscenario's.

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

Veelgestelde vragen over Python NaN en foutafhandeling

1. Wat doet float('NaN') doen in Python?
2. Met deze opdracht wordt een speciale floatwaarde gemaakt die wordt herkend als “NaN” (geen getal). Het is handig voor het afhandelen van gevallen waarin een berekening niet gedefinieerd is of wanneer u ontbrekende gegevens in uw programma moet markeren.
3. Hoe kan ik ervoor zorgen dat mijn uitvoer voldoet aan specifieke opmaakvereisten?
4. Met behulp van methoden als replace() Hiermee kunt u bepalen hoe uw uitvoer wordt weergegeven. Bijvoorbeeld, replace('nan', 'NaN') kan ervoor zorgen dat uw “NaN”-waarden in het juiste geval verschijnen, zoals vereist in bepaalde testsystemen.
5. Waarom is try...except belangrijk in bestandsgebaseerde programma's?
6. De try...except blok is cruciaal voor foutafhandeling in gevallen waarin regels ongeldige gegevens kunnen bevatten. Het voorkomt dat het programma crasht als een regel niet kan worden omgezet in een float, waardoor de code betrouwbaarder wordt.
7. Wat is een inline conditioneel, en waarom zou je het gebruiken?
8. Een inline voorwaardelijke like sum(numbers) / len(numbers) if numbers else float('NaN') Hiermee kunt u een bewerking alleen uitvoeren als aan bepaalde voorwaarden is voldaan, bijvoorbeeld als een lijst waarden bevat. Dit is ideaal om fouten zoals delen door nul te voorkomen.
9. Hoe werkt de with open(file_name, 'r') opdracht werken?
10. Met deze opdracht wordt een bestand in de leesmodus geopend en daarna automatisch gesloten. Het gebruik van “with” zorgt ervoor dat het bestand goed wordt gesloten, wat helpt bij het beheer van bronnen en voorkomt dat fouten ontstaan ​​door het per ongeluk open laten van bestanden.
11. Kan ik testen of een waarde “NaN” is in Python?
12. Ja, je kunt het gebruiken math.isnan() om te controleren of een waarde “NaN” is. Dit is met name handig als u “NaN”-waarden wilt opmaken of uitsluiten in berekeningen of uitvoer.
13. Waarom is opmaakconsistentie belangrijk bij automatische beoordeling?
14. Geautomatiseerde systemen vertrouwen op exacte opmaak, dus kleine verschillen (zoals “nan” in plaats van “NaN”) kunnen fouten veroorzaken. Gebruik consistente methoden zoals replace() voor opmaak voorkomt deze problemen.
15. Hoe vereenvoudigt het gebruik van lijsten het categoriseren van gegevens in Python?
16. Met lijsten kunt u gegevens in categorieën verdelen, zoals positieve en negatieve gegevens, waardoor het berekenen van afzonderlijke statistieken voor elke categorie eenvoudig wordt. Het toevoegen van waarden aan lijsten op basis van voorwaarden is efficiënt en houdt de code georganiseerd.
17. Wat zijn inline conditionals en wanneer moeten ze worden gebruikt?
18. Inline conditionals maken beknopte instructies van één regel mogelijk die alleen code uitvoeren als aan een voorwaarde wordt voldaan. U kunt bijvoorbeeld alleen een gemiddelde berekenen als er waarden in een lijst voorkomen, waardoor fouten worden voorkomen.
19. Hoe kan ik de afdrukuitvoer omleiden voor testen?
20. Door te gebruiken StringIO En sys.stdout omleiding, kunt u de uitvoer vastleggen in tests om te verifiëren dat deze overeenkomt met de verwachte resultaten. Dit is een gebruikelijke praktijk bij het testen van eenheden waarbij u de programma-uitvoer wilt valideren.
21. Wat is het doel van tearDown bij unittests?
22. In unittest kaders, tearDown() wordt gebruikt om op te ruimen na tests, zoals het verwijderen van tijdelijke bestanden. Dit zorgt ervoor dat elke test begint met een nieuwe omgeving, waardoor gegevensinterferentie tussen tests wordt voorkomen.

De oplossing afronden

Deze opdracht demonstreert het belang van het omgaan met speciale gevallen, zoals ontbrekende positieve of negatieve waarden, bij het berekenen van gemiddelden in Python. Door het gebruik van voorwaardelijke instructies en opmaakaanpassingen zorgt u ervoor dat “NaN” wordt geretourneerd wanneer dat nodig is, waardoor fouten uit lege gegevenslijsten worden voorkomen.

Python's tools zoals probeer...behalve En zweven('NaN') maken flexibel foutbeheer mogelijk, waardoor het gemakkelijker wordt om met onverwachte gegevens om te gaan. Dergelijke praktijken zijn van onschatbare waarde voor programmeurs die opdrachten, geautomatiseerde tests en elke situatie aanpakken die nauwkeurige uitvoerformattering vereist. 🚀