Menyelesaikan masalah Output NaN dalam Python: Membetulkan Ralat dalam Pengiraan Berasaskan Fail

Mengira Purata Berasingan Nombor Positif dan Negatif daripada Fail

Skrip belakang Python untuk membaca data fail, mengira purata dan mengendalikan nilai yang hilang dengan mantap.

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

Mengendalikan Format Data Berbeza dengan Kod Modular dan Boleh Digunakan Semula

Skrip belakang Python dengan struktur modular yang lebih baik dan pengendalian ralat untuk pelbagai format data.

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

Ujian Unit untuk Program Pengiraan Purata Berasaskan Fail

Ujian unit Python untuk memastikan pengiraan purata yang betul untuk senario input yang berbeza.

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

Soalan Lazim Mengenai Python NaN dan Pengendalian Ralat

1. Apa yang boleh float('NaN') lakukan dalam Python?
2. Perintah ini mencipta nilai apungan khas yang dikenali sebagai "NaN" (Bukan Nombor). Ia berguna untuk mengendalikan kes di mana pengiraan tidak ditentukan atau apabila anda perlu membenderakan data yang hilang dalam program anda.
3. Bagaimanakah saya boleh memastikan output saya sepadan dengan keperluan pemformatan tertentu?
4. Menggunakan kaedah seperti replace() membolehkan anda mengawal cara keluaran anda muncul. Sebagai contoh, replace('nan', 'NaN') boleh memastikan nilai "NaN" anda muncul dalam kes yang betul, seperti yang diperlukan dalam sistem ujian tertentu.
5. kenapa try...except penting dalam program berasaskan fail?
6. The try...except blok adalah penting untuk pengendalian ralat dalam kes di mana baris mungkin mengandungi data tidak sah. Ia menghalang program daripada ranap jika garisan tidak boleh ditukar kepada apungan, menjadikan kod lebih dipercayai.
7. Apakah syarat sebaris, dan mengapa menggunakannya?
8. Suka bersyarat sebaris sum(numbers) / len(numbers) if numbers else float('NaN') membenarkan anda melakukan operasi hanya apabila syarat tertentu dipenuhi, seperti apabila senarai mempunyai nilai. Ini sesuai untuk mengelakkan ralat seperti pembahagian dengan sifar.
9. Bagaimana caranya with open(file_name, 'r') kerja arahan?
10. Perintah ini membuka fail dalam mod baca dan menutupnya secara automatik selepas itu. Menggunakan "dengan" memastikan fail ditutup dengan betul, yang membantu dalam pengurusan sumber dan mengelakkan ralat daripada membiarkan fail terbuka secara tidak sengaja.
11. Bolehkah saya menguji jika nilai adalah "NaN" dalam Python?
12. Ya, anda boleh gunakan math.isnan() untuk menyemak sama ada nilai ialah "NaN." Ini amat membantu apabila anda ingin memformat atau mengecualikan nilai "NaN" dalam pengiraan atau output.
13. Mengapakah ketekalan pemformatan penting dalam penggredan automatik?
14. Sistem automatik bergantung pada pemformatan yang tepat, jadi perbezaan kecil (seperti "nan" dan bukannya "NaN") boleh menyebabkan ralat. Menggunakan kaedah yang konsisten seperti replace() untuk pemformatan menghalang isu ini.
15. Bagaimanakah menggunakan senarai memudahkan pengkategorian data dalam Python?
16. Senarai membolehkan anda memisahkan data ke dalam kategori seperti positif dan negatif, yang menjadikan pengiraan statistik berasingan untuk setiap kategori menjadi mudah. Menambah nilai pada senarai berdasarkan syarat adalah cekap dan memastikan kod itu teratur.
17. Apakah syarat sebaris, dan bilakah ia harus digunakan?
18. Syarat sebaris membenarkan pernyataan satu baris ringkas yang melaksanakan kod hanya jika syarat dipenuhi. Contohnya, mengira purata hanya jika nilai wujud dalam senarai, mengelakkan ralat.
19. Bagaimanakah saya boleh mengubah hala output cetakan untuk ujian?
20. Dengan menggunakan StringIO dan sys.stdout pengalihan semula, anda boleh menangkap output dalam ujian untuk mengesahkan bahawa ia sepadan dengan hasil yang dijangkakan. Ini adalah amalan biasa dalam ujian unit di mana anda ingin mengesahkan output program.
21. Apakah tujuan tearDown dalam ujian unit?
22. Dalam unittest rangka kerja, tearDown() digunakan untuk membersihkan selepas ujian, seperti mengalih keluar fail sementara. Ini memastikan setiap ujian bermula dengan persekitaran yang segar, menghalang gangguan data antara ujian.

Menggulung Penyelesaian

Tugasan ini menunjukkan kepentingan mengendalikan kes khas, seperti kehilangan nilai positif atau negatif, semasa mengira purata dalam Python. Dengan menggunakan pernyataan bersyarat dan pelarasan pemformatan, anda memastikan bahawa "NaN" dikembalikan apabila diperlukan, menghalang sebarang ralat daripada senarai data kosong.

Alat Python seperti cuba...kecuali dan terapung('NaN') membenarkan pengurusan ralat yang fleksibel, menjadikannya lebih mudah untuk mengendalikan data yang tidak dijangka. Amalan sedemikian amat berharga untuk pengaturcara yang menangani tugasan, ujian automatik, dan sebarang situasi yang memerlukan pemformatan output yang tepat. 🚀