A NaN kimenet hibaelhárítása a Pythonban: A fájlalapú számítások hibáinak javítása

Pozitív és negatív számok külön átlagának kiszámítása egy fájlból

Python háttérszkript a fájladatok olvasásához, az átlagok kiszámításához és a hiányzó értékek megbízható kezeléséhez.

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

Különböző adatformátumok kezelése moduláris és újrafelhasználható kóddal

Python háttérszkript továbbfejlesztett moduláris felépítéssel és hibakezeléssel különféle adatformátumokhoz.

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

Egységteszt a fájl alapú átlagszámítási programhoz

Python egységtesztek a helyes átlagszámítás biztosítására különböző beviteli forgatókönyvekhez.

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

Gyakori kérdések a Python NaN-ről és a hibakezelésről

1. Mit tesz float('NaN') Pythonban csinálni?
2. Ez a parancs egy speciális lebegő értéket hoz létre, amelyet „NaN” (nem szám) néven ismer fel. Hasznos olyan esetek kezelésére, amikor a számítás nem definiált, vagy amikor meg kell jelölnie a hiányzó adatokat a programban.
3. Hogyan biztosíthatom, hogy a kimenet megfeleljen az adott formázási követelményeknek?
4. Olyan módszerek használatával, mint pl replace() lehetővé teszi a kimenet megjelenésének szabályozását. Például, replace('nan', 'NaN') biztosíthatja, hogy a „NaN” értékei a megfelelő kis- és nagybetűben jelenjenek meg, ahogy azt bizonyos tesztelési rendszerek megkövetelik.
5. Miért van try...except fontos a fájl alapú programokban?
6. A try...except blokk kulcsfontosságú a hibakezeléshez olyan esetekben, amikor a sorok érvénytelen adatokat tartalmazhatnak. Megakadályozza a program összeomlását, ha egy vonal nem konvertálható lebegővé, így a kód megbízhatóbb.
7. Mi az a soron belüli feltétel, és miért kell használni?
8. Egy soron belüli feltételes like sum(numbers) / len(numbers) if numbers else float('NaN') lehetővé teszi, hogy csak bizonyos feltételek teljesülése esetén hajtson végre műveletet, például ha egy listának vannak értékei. Ez ideális az olyan hibák elkerülésére, mint a nullával való osztás.
9. Hogyan működik a with open(file_name, 'r') parancsi munka?
10. Ez a parancs olvasási módban nyit meg egy fájlt, majd automatikusan bezárja. A „with” használata biztosítja a fájl megfelelő bezárását, ami segít az erőforrás-kezelésben, és elkerüli a véletlenül nyitva hagyott fájlok miatti hibákat.
11. Meg tudom tesztelni, hogy egy érték „NaN”-e a Pythonban?
12. Igen, használhatod math.isnan() annak ellenőrzésére, hogy egy érték „NaN”-e. Ez különösen akkor hasznos, ha „NaN” értékeket szeretne formázni vagy kizárni a számításokból vagy a kimenetből.
13. Miért fontos a formázási konzisztencia az automatizált osztályozásban?
14. Az automatizált rendszerek pontos formázásra támaszkodnak, így a kisebb eltérések (például a „nan” a „NaN” helyett) hibákat okozhatnak. Következetes módszerek használatával, mint pl replace() A formázás megakadályozza ezeket a problémákat.
15. Hogyan egyszerűsíti le a listák használata az adatok kategorizálását a Pythonban?
16. A listák lehetővé teszik az adatok kategóriákba, például pozitív és negatív kategóriákba történő szétválasztását, ami egyszerűvé teszi az egyes kategóriákra vonatkozó külön statisztikák kiszámítását. Az értékek feltételek alapján történő hozzáfűzése a listákhoz hatékony és rendszerezetten tartja a kódot.
17. Mik azok a soron belüli feltételrendszerek, és mikor kell őket használni?
18. A soron belüli feltételes feltételek tömör egysoros utasításokat tesznek lehetővé, amelyek csak akkor hajtanak végre kódot, ha egy feltétel teljesül. Például az átlag kiszámítása csak akkor, ha értékek szerepelnek a listában, megelőzve a hibákat.
19. Hogyan irányíthatom át a nyomtatási kimenetet tesztelésre?
20. Használatával StringIO és sys.stdout átirányítást, akkor tesztek során rögzítheti a kimenetet, hogy ellenőrizze, megfelel-e a várt eredményeknek. Ez egy bevett gyakorlat az egységteszteknél, ahol ellenőrizni kívánja a program kimenetét.
21. Mi a célja tearDown egységtesztekben?
22. In unittest keretek, tearDown() tesztek utáni tisztításra szolgál, például ideiglenes fájlok eltávolítására. Ez biztosítja, hogy minden teszt friss környezetben induljon, megelőzve a tesztek közötti adatinterferenciát.

A megoldás lezárása

Ez a feladat bemutatja a különleges esetek, például a hiányzó pozitív vagy negatív értékek kezelésének fontosságát az átlagok Pythonban történő kiszámításakor. Feltételes utasítások és formázási korrekciók használatával gondoskodik arról, hogy szükség esetén „NaN” kerüljön visszaadásra, megelőzve az üres adatlistákból származó hibákat.

A Python eszközei, mint pl próbáld meg... kivéve és float ('NaN') rugalmas hibakezelést tesz lehetővé, megkönnyítve a váratlan adatok kezelését. Az ilyen gyakorlatok felbecsülhetetlen értékűek a programozók számára, akik feladatokkal, automatizált tesztekkel és minden olyan helyzettel foglalkoznak, amelyek precíz kimeneti formázást igényelnek. 🚀