Memecahkan Masalah Output NaN dengan Python: Memperbaiki Kesalahan dalam Perhitungan Berbasis File

Menghitung Rata-Rata Terpisah Angka Positif dan Negatif dari File

Skrip backend Python untuk membaca data file, menghitung rata-rata, dan menangani nilai yang hilang dengan kuat.

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

Menangani Berbagai Format Data dengan Kode Modular dan Dapat Digunakan Kembali

Skrip backend Python dengan struktur modular yang ditingkatkan dan penanganan kesalahan untuk berbagai 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')

Pengujian Unit untuk Program Perhitungan Rata-Rata Berbasis File

Pengujian unit Python untuk memastikan penghitungan rata-rata yang benar untuk skenario masukan yang berbeda.

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

Pertanyaan Umum Tentang Python NaN dan Penanganan Kesalahan

1. Apa artinya? float('NaN') lakukan dengan Python?
2. Perintah ini menciptakan nilai float khusus yang dikenali sebagai “NaN” (Bukan Angka). Ini berguna untuk menangani kasus di mana perhitungan tidak ditentukan atau ketika Anda perlu menandai data yang hilang dalam program Anda.
3. Bagaimana cara memastikan keluaran saya sesuai dengan persyaratan pemformatan tertentu?
4. Menggunakan metode seperti replace() memungkinkan Anda mengontrol tampilan output Anda. Misalnya, replace('nan', 'NaN') dapat memastikan nilai “NaN” Anda muncul dalam huruf yang benar, seperti yang disyaratkan dalam sistem pengujian tertentu.
5. Mengapa demikian try...except penting dalam program berbasis file?
6. Itu try...except blok sangat penting untuk penanganan kesalahan jika baris mungkin berisi data yang tidak valid. Ini mencegah program mogok jika suatu baris tidak dapat diubah menjadi float, sehingga membuat kode lebih dapat diandalkan.
7. Apa yang dimaksud dengan kondisi inline, dan mengapa menggunakannya?
8. Suka bersyarat sebaris sum(numbers) / len(numbers) if numbers else float('NaN') memungkinkan Anda melakukan operasi hanya ketika kondisi tertentu terpenuhi, seperti ketika daftar memiliki nilai. Ini ideal untuk menghindari kesalahan seperti pembagian dengan nol.
9. Bagaimana caranya with open(file_name, 'r') perintah bekerja?
10. Perintah ini membuka file dalam mode baca dan menutupnya secara otomatis setelahnya. Menggunakan "dengan" memastikan file ditutup dengan benar, yang membantu dalam pengelolaan sumber daya dan menghindari kesalahan karena membiarkan file terbuka secara tidak sengaja.
11. Bisakah saya menguji apakah suatu nilai adalah “NaN” dengan Python?
12. Ya, Anda bisa menggunakannya math.isnan() untuk memeriksa apakah suatu nilai adalah “NaN.” Ini sangat membantu ketika Anda ingin memformat atau mengecualikan nilai “NaN” dalam penghitungan atau keluaran.
13. Mengapa konsistensi pemformatan penting dalam penilaian otomatis?
14. Sistem otomatis mengandalkan pemformatan yang tepat, sehingga perbedaan kecil (seperti “nan” dan bukan “NaN”) dapat menyebabkan kesalahan. Menggunakan metode yang konsisten seperti replace() untuk pemformatan mencegah masalah ini.
15. Bagaimana cara menggunakan daftar menyederhanakan kategorisasi data dengan Python?
16. Daftar memungkinkan Anda memisahkan data ke dalam kategori seperti positif dan negatif, sehingga penghitungan statistik terpisah untuk setiap kategori menjadi mudah. Menambahkan nilai ke daftar berdasarkan kondisi adalah hal yang efisien dan menjaga kode tetap teratur.
17. Apa itu kondisional inline, dan kapan sebaiknya digunakan?
18. Persyaratan inline memungkinkan pernyataan satu baris ringkas yang mengeksekusi kode hanya jika suatu kondisi terpenuhi. Misalnya, menghitung rata-rata hanya jika ada nilai dalam daftar, sehingga mencegah kesalahan.
19. Bagaimana cara mengarahkan keluaran cetak untuk pengujian?
20. Dengan menggunakan StringIO Dan sys.stdout pengalihan, Anda dapat mengambil keluaran dalam pengujian untuk memverifikasi bahwa keluaran tersebut sesuai dengan hasil yang diharapkan. Ini adalah praktik umum dalam pengujian unit di mana Anda ingin memvalidasi keluaran program.
21. Apa tujuannya tearDown dalam tes unit?
22. Di dalam unittest kerangka kerja, tearDown() digunakan untuk membersihkan setelah pengujian, seperti menghapus file sementara. Hal ini memastikan setiap pengujian dimulai dengan lingkungan baru, mencegah gangguan data di antara pengujian.

Menyelesaikan Solusinya

Tugas ini menunjukkan pentingnya menangani kasus-kasus khusus, seperti kehilangan nilai positif atau negatif, saat menghitung rata-rata dengan Python. Dengan menggunakan pernyataan kondisional dan penyesuaian format, Anda memastikan bahwa “NaN” dikembalikan saat diperlukan, mencegah kesalahan apa pun dari daftar data kosong.

Alat Python seperti coba...kecuali Dan mengapung('NaN') memungkinkan manajemen kesalahan yang fleksibel, sehingga lebih mudah menangani data yang tidak terduga. Praktik seperti itu sangat berharga bagi pemrogram yang menangani tugas, pengujian otomatis, dan situasi apa pun yang memerlukan pemformatan keluaran yang tepat. 🚀