NaN išvesties „Python“ trikčių šalinimas: failų skaičiavimų klaidų taisymas

Atskirų teigiamų ir neigiamų skaičių vidurkių apskaičiavimas iš failo

Python backend scenarijus, skirtas nuskaityti failo duomenis, apskaičiuoti vidurkius ir patikimai tvarkyti trūkstamas reikšmes.

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

Įvairių duomenų formatų tvarkymas naudojant modulinį ir daugkartinį kodą

Python backend scenarijus su patobulinta moduline struktūra ir klaidų tvarkymu įvairiems duomenų formatams.

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

Failų vidurkio skaičiavimo programos vienetų testavimas

Python vienetų testai, siekiant užtikrinti teisingą skirtingų įvesties scenarijų vidurkio skaičiavimą.

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

Dažni klausimai apie Python NaN ir klaidų tvarkymą

1. Ką daro float('NaN') daryti Python?
2. Ši komanda sukuria specialią slankiąją reikšmę, atpažįstamą kaip „NaN“ (ne skaičius). Tai naudinga sprendžiant atvejus, kai skaičiavimas neapibrėžtas arba kai reikia pažymėti trūkstamus duomenis programoje.
3. Kaip galiu užtikrinti, kad mano išvestis atitiktų konkrečius formatavimo reikalavimus?
4. Naudojant tokius metodus kaip replace() leidžia valdyti, kaip atrodo jūsų produkcija. Pavyzdžiui, replace('nan', 'NaN') gali užtikrinti, kad jūsų „NaN“ reikšmės būtų rodomos tinkama raide, kaip reikalaujama tam tikrose testavimo sistemose.
5. Kodėl yra try...except svarbu failais pagrįstose programose?
6. The try...except blokas yra labai svarbus sprendžiant klaidas tais atvejais, kai eilutėse gali būti neteisingų duomenų. Tai apsaugo programą nuo strigimo, jei eilutės negalima paversti plūduriuojančia, todėl kodas tampa patikimesnis.
7. Kas yra eilutinė sąlyga ir kodėl ją naudoti?
8. Eilutinis sąlyginis kaip sum(numbers) / len(numbers) if numbers else float('NaN') leidžia atlikti operaciją tik tada, kai įvykdomos tam tikros sąlygos, pvz., kai sąraše yra reikšmių. Tai idealiai tinka norint išvengti klaidų, tokių kaip padalijimas iš nulio.
9. Kaip veikia with open(file_name, 'r') komandinis darbas?
10. Ši komanda atidaro failą skaitymo režimu ir automatiškai uždaro jį vėliau. Naudojant „su“, failas tinkamai uždaromas, o tai padeda valdyti išteklius ir išvengti klaidų, kai failai netyčia paliekami atidaryti.
11. Ar galiu patikrinti, ar „Python“ reikšmė yra „NaN“?
12. Taip, galite naudoti math.isnan() norėdami patikrinti, ar reikšmė yra „NaN“. Tai ypač naudinga, kai norite formatuoti arba neįtraukti „NaN“ reikšmių skaičiavimuose ar išvestyje.
13. Kodėl automatizuotam vertinimui svarbus formatavimo nuoseklumas?
14. Automatizuotos sistemos priklauso nuo tikslaus formatavimo, todėl nedideli skirtumai (pvz., „nan“ vietoj „NaN“) gali sukelti klaidų. Naudojant nuoseklius metodus, pvz replace() Formatavimas apsaugo nuo šių problemų.
15. Kaip naudojant sąrašus supaprastinamas duomenų skirstymas į kategorijas Python?
16. Sąrašai leidžia suskirstyti duomenis į kategorijas, pvz., teigiamus ir neigiamus, todėl atskirą statistiką kiekvienai kategorijai apskaičiuoti paprasta. Vertybių pridėjimas prie sąrašų pagal sąlygas yra efektyvus ir išlaikomas tvarkingas kodas.
17. Kas yra įterptosios sąlygos ir kada jos turėtų būti naudojamos?
18. Įterptosios sąlygos leidžia pateikti glaustus vienos eilutės teiginius, kurie vykdo kodą tik tada, kai įvykdoma sąlyga. Pavyzdžiui, apskaičiuojant vidurkį tik tada, kai sąraše yra reikšmės, taip išvengiant klaidų.
19. Kaip galiu nukreipti spausdinimo išvestį testavimui?
20. Naudojant StringIO ir sys.stdout peradresavimą, galite užfiksuoti išvestį atliekant bandymus, kad patikrintumėte, ar ji atitinka laukiamus rezultatus. Tai įprasta vienetų testavimo praktika, kai norite patvirtinti programos išvestį.
21. Koks tikslas tearDown vienetiniuose testuose?
22. Į unittest karkasai, tearDown() naudojamas išvalyti po bandymų, pvz., pašalinti laikinuosius failus. Taip užtikrinama, kad kiekvienas bandymas prasidėtų naujoje aplinkoje, išvengiant duomenų trukdžių tarp bandymų.

Sprendimo užbaigimas

Ši užduotis parodo, kaip svarbu tvarkyti specialius atvejus, pvz., trūkstamų teigiamų ar neigiamų verčių, skaičiuojant vidurkius „Python“. Naudodami sąlyginius sakinius ir formatavimo koregavimus užtikrinate, kad prireikus būtų grąžinamas „NaN“, išvengiant klaidų iš tuščių duomenų sąrašų.

Python įrankiai kaip pabandyk... nebent ir float („NaN“) leidžia lanksčiai valdyti klaidas, todėl lengviau tvarkyti netikėtus duomenis. Tokia praktika yra neįkainojama programuotojams, sprendžiantiems užduotis, automatizuotus testus ir bet kokias situacijas, kurioms reikalingas tikslus išvesties formatavimas. 🚀