NaN-väljundi tõrkeotsing Pythonis: vigade parandamine failipõhistes arvutustes

Positiivsete ja negatiivsete arvude eraldi keskmiste arvutamine failist

Pythoni taustaskript failiandmete lugemiseks, keskmiste arvutamiseks ja puuduvate väärtuste tõhusaks käsitlemiseks.

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

Erinevate andmevormingute käsitlemine modulaarse ja korduvkasutatava koodiga

Pythoni taustaskript, millel on täiustatud modulaarne struktuur ja erinevate andmevormingute vigade käsitlemine.

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

Failipõhise keskmise arvutamise programmi ühikutestimine

Pythoni ühikutestid, mis tagavad õige keskmise arvutamise erinevate sisendstsenaariumide jaoks.

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

Levinud küsimused Python NaN-i ja tõrkekäsitluse kohta

1. Mis teeb float('NaN') teha Pythonis?
2. See käsk loob spetsiaalse ujuva väärtuse, mida tuntakse kui "NaN" (mitte arv). See on kasulik juhtudel, kui arvutus on määratlemata või kui peate oma programmis puuduvad andmed märgistama.
3. Kuidas tagada, et mu väljund vastaks konkreetsetele vormingunõuetele?
4. Kasutades selliseid meetodeid nagu replace() võimaldab teil kontrollida, kuidas teie väljund kuvatakse. Näiteks replace('nan', 'NaN') võib tagada, et teie "NaN" väärtused kuvatakse õiges kirjas, nagu teatud testimissüsteemides nõutakse.
5. Miks on try...except failipõhistes programmides oluline?
6. The try...except plokk on vigade käsitlemisel ülioluline juhtudel, kui read võivad sisaldada kehtetuid andmeid. See takistab programmi kokkujooksmist, kui joont ei saa ujukiks teisendada, muutes koodi usaldusväärsemaks.
7. Mis on tekstisisene tingimus ja miks seda kasutada?
8. Tekstisisene tingimuslik nagu sum(numbers) / len(numbers) if numbers else float('NaN') võimaldab toimingu sooritada ainult siis, kui teatud tingimused on täidetud, näiteks kui loendil on väärtused. See on ideaalne selliste vigade vältimiseks nagu nulliga jagamine.
9. Kuidas toimib with open(file_name, 'r') käsutöö?
10. See käsk avab faili lugemisrežiimis ja sulgeb selle hiljem automaatselt. Kasutades "koos" tagab faili õige sulgemise, mis aitab ressursse hallata ja väldib failide kogemata avatuks jätmisel tekkivaid vigu.
11. Kas ma saan Pythonis testida, kas väärtus on "NaN"?
12. Jah, võite kasutada math.isnan() et kontrollida, kas väärtus on "NaN". See on eriti kasulik, kui soovite arvutustes või väljundis "NaN" väärtusi vormindada või välistada.
13. Miks on vormingu järjepidevus automaatse hindamise puhul oluline?
14. Automatiseeritud süsteemid tuginevad täpsele vormingule, nii et väikesed erinevused (nt "nan" "NaN" asemel) võivad põhjustada vigu. Kasutades järjepidevaid meetodeid nagu replace() Vormindamisel väldib neid probleeme.
15. Kuidas loendite kasutamine Pythonis andmete kategoriseerimist lihtsustab?
16. Loendid võimaldavad teil jagada andmed kategooriatesse, nagu positiivsed ja negatiivsed, mis muudab iga kategooria jaoks eraldi statistika arvutamise lihtsaks. Tingimustel põhinevate loendite väärtuste lisamine on tõhus ja hoiab koodi korrastatuna.
17. Mis on tekstisisesed tingimussõnad ja millal tuleks neid kasutada?
18. Tekstisisesed tingimustingimused võimaldavad lühikesi üherealisi avaldusi, mis käivitavad koodi ainult tingimuse täitmisel. Näiteks keskmise arvutamine ainult siis, kui loendis on väärtused, vältides vigu.
19. Kuidas saan prindiväljundit testimiseks ümber suunata?
20. Kasutades StringIO ja sys.stdout ümbersuunamist, saate testides väljundi jäädvustada, et kontrollida, kas see vastab oodatud tulemustele. See on levinud tava ühikutestimisel, mille puhul soovite programmi väljundit valideerida.
21. Mis on eesmärk tearDown ühikutestides?
22. sisse unittest raamistikud, tearDown() kasutatakse pärast teste puhastamiseks, näiteks ajutiste failide eemaldamiseks. See tagab, et iga test algab värske keskkonnaga, vältides andmehäireid testide vahel.

Lahenduse kokkupakkimine

See ülesanne näitab, kui oluline on Pythonis keskmiste arvutamisel käsitleda erijuhtumeid, nagu puuduvad positiivsed või negatiivsed väärtused. Kasutades tingimuslauseid ja vormingu korrigeerimisi, tagate, et "NaN" tagastatakse vajadusel, vältides tühjadest andmeloenditest tulenevaid vigu.

Pythoni tööriistad nagu proovi... välja arvatud ja float ('NaN') võimaldavad paindlikku veahaldust, muutes ootamatute andmete käsitlemise lihtsamaks. Sellised tavad on hindamatu väärtusega programmeerijatele, kes tegelevad ülesannetega, automatiseeritud testidega ja mis tahes olukorraga, mis nõuab täpset väljundi vormindamist. 🚀