ਪਾਈਥਨ ਵਿੱਚ NaN ਆਉਟਪੁੱਟ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨਾ: ਫਾਈਲ-ਆਧਾਰਿਤ ਗਣਨਾਵਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ

ਇੱਕ ਫਾਈਲ ਤੋਂ ਸਕਾਰਾਤਮਕ ਅਤੇ ਨਕਾਰਾਤਮਕ ਸੰਖਿਆਵਾਂ ਦੀ ਵੱਖਰੀ ਔਸਤ ਦੀ ਗਣਨਾ ਕਰਨਾ

ਪਾਈਥਨ ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ ਫਾਈਲ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨ, ਔਸਤਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਅਤੇ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਮਜ਼ਬੂਤੀ ਨਾਲ ਸੰਭਾਲਣ ਲਈ।

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

ਮਾਡਯੂਲਰ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਕੋਡ ਨਾਲ ਵੱਖ-ਵੱਖ ਡਾਟਾ ਫਾਰਮੈਟਾਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਪਾਇਥਨ ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ ਸੁਧਾਰੀ ਮਾਡਯੂਲਰ ਬਣਤਰ ਅਤੇ ਵੱਖ-ਵੱਖ ਡੇਟਾ ਫਾਰਮੈਟਾਂ ਲਈ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਦੇ ਨਾਲ।

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

ਫਾਈਲ-ਆਧਾਰਿਤ ਔਸਤ ਗਣਨਾ ਪ੍ਰੋਗਰਾਮ ਲਈ ਯੂਨਿਟ ਟੈਸਟਿੰਗ

ਵੱਖ-ਵੱਖ ਇਨਪੁਟ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਸਹੀ ਔਸਤ ਗਣਨਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਪਾਈਥਨ ਯੂਨਿਟ ਟੈਸਟ।

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

ਪਾਈਥਨ NaN ਅਤੇ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. ਕੀ ਕਰਦਾ ਹੈ float('NaN') ਪਾਈਥਨ ਵਿੱਚ ਕਰੋ?
2. ਇਹ ਕਮਾਂਡ "NaN" (ਨੰਬਰ ਨਹੀਂ) ਵਜੋਂ ਮਾਨਤਾ ਪ੍ਰਾਪਤ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਫਲੋਟ ਮੁੱਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਇੱਕ ਗਣਨਾ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ ਜਾਂ ਜਦੋਂ ਤੁਹਾਨੂੰ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਗੁੰਮ ਹੋਏ ਡੇਟਾ ਨੂੰ ਫਲੈਗ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
3. ਮੈਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾ ਸਕਦਾ ਹਾਂ ਕਿ ਮੇਰਾ ਆਉਟਪੁੱਟ ਖਾਸ ਫਾਰਮੈਟਿੰਗ ਲੋੜਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ?
4. ਵਰਗੇ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ replace() ਤੁਹਾਨੂੰ ਇਹ ਨਿਯੰਤਰਣ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਡਾ ਆਉਟਪੁੱਟ ਕਿਵੇਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ, replace('nan', 'NaN') ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ "NaN" ਮੁੱਲ ਸਹੀ ਕੇਸ ਵਿੱਚ ਦਿਖਾਈ ਦੇਣ, ਜਿਵੇਂ ਕਿ ਕੁਝ ਟੈਸਟਿੰਗ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੈ।
5. ਕਿਉਂ ਹੈ try...except ਫਾਈਲ-ਅਧਾਰਿਤ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ?
6. ਦ try...except ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਗਲਤੀ ਸੰਭਾਲਣ ਲਈ ਬਲਾਕ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜਿੱਥੇ ਲਾਈਨਾਂ ਵਿੱਚ ਅਵੈਧ ਡੇਟਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਰੈਸ਼ ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਲਾਈਨ ਨੂੰ ਫਲੋਟ ਵਿੱਚ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ, ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਬਣਾਉਂਦਾ ਹੈ।
7. ਇੱਕ ਇਨਲਾਈਨ ਕੰਡੀਸ਼ਨਲ ਕੀ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਕਿਉਂ ਵਰਤਣਾ ਹੈ?
8. ਇੱਕ ਇਨਲਾਈਨ ਸ਼ਰਤੀਆ ਵਰਗਾ sum(numbers) / len(numbers) if numbers else float('NaN') ਤੁਹਾਨੂੰ ਕੁਝ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਹੋਣ 'ਤੇ ਹੀ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਸੂਚੀ ਵਿੱਚ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਇਹ ਜ਼ੀਰੋ ਦੁਆਰਾ ਵੰਡ ਵਰਗੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਆਦਰਸ਼ ਹੈ।
9. ਕਿਵੇਂ ਕਰਦਾ ਹੈ with open(file_name, 'r') ਹੁਕਮ ਦਾ ਕੰਮ?
10. ਇਹ ਕਮਾਂਡ ਇੱਕ ਫਾਈਲ ਨੂੰ ਰੀਡ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬਾਅਦ ਵਿੱਚ ਆਪਣੇ ਆਪ ਬੰਦ ਕਰ ਦਿੰਦੀ ਹੈ। "ਨਾਲ" ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਫਾਈਲ ਸਹੀ ਢੰਗ ਨਾਲ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ, ਜੋ ਸਰੋਤ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਅਤੇ ਗਲਤੀ ਨਾਲ ਫਾਈਲਾਂ ਨੂੰ ਖੋਲ੍ਹਣ ਤੋਂ ਬਚਾਉਂਦੀ ਹੈ।
11. ਕੀ ਮੈਂ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹਾਂ ਕਿ ਕੀ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਮੁੱਲ "NaN" ਹੈ?
12. ਹਾਂ, ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ math.isnan() ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਕੀ ਕੋਈ ਮੁੱਲ "NaN" ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਗਣਨਾਵਾਂ ਜਾਂ ਆਉਟਪੁੱਟ ਵਿੱਚ "NaN" ਮੁੱਲਾਂ ਨੂੰ ਫਾਰਮੈਟ ਜਾਂ ਬਾਹਰ ਕੱਢਣਾ ਚਾਹੁੰਦੇ ਹੋ।
13. ਸਵੈਚਲਿਤ ਗਰੇਡਿੰਗ ਵਿੱਚ ਫਾਰਮੈਟਿੰਗ ਇਕਸਾਰਤਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ?
14. ਸਵੈਚਲਿਤ ਸਿਸਟਮ ਸਹੀ ਫਾਰਮੈਟਿੰਗ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ, ਇਸਲਈ ਮਾਮੂਲੀ ਅੰਤਰ (ਜਿਵੇਂ ਕਿ "NaN" ਦੀ ਬਜਾਏ "nan") ਗਲਤੀਆਂ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ। ਇਕਸਾਰ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਿਵੇਂ ਕਿ replace() ਫਾਰਮੈਟਿੰਗ ਲਈ ਇਹਨਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।
15. ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਡੇਟਾ ਨੂੰ ਸ਼੍ਰੇਣੀਬੱਧ ਕਰਨਾ ਕਿਵੇਂ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ?
16. ਸੂਚੀਆਂ ਤੁਹਾਨੂੰ ਸਕਾਰਾਤਮਕ ਅਤੇ ਨਕਾਰਾਤਮਕ ਵਰਗੀਆਂ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਵੱਖ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ, ਜੋ ਹਰੇਕ ਸ਼੍ਰੇਣੀ ਲਈ ਵੱਖਰੇ ਅੰਕੜਿਆਂ ਦੀ ਗਣਨਾ ਨੂੰ ਸਿੱਧਾ ਬਣਾਉਂਦਾ ਹੈ। ਸ਼ਰਤਾਂ ਦੇ ਅਧਾਰ ਤੇ ਸੂਚੀਆਂ ਵਿੱਚ ਮੁੱਲ ਜੋੜਨਾ ਕੁਸ਼ਲ ਹੈ ਅਤੇ ਕੋਡ ਨੂੰ ਵਿਵਸਥਿਤ ਰੱਖਦਾ ਹੈ।
17. ਇਨਲਾਈਨ ਕੰਡੀਸ਼ਨਲ ਕੀ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਦੋਂ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ?
18. ਇਨਲਾਈਨ ਕੰਡੀਸ਼ਨਲ ਸੰਖੇਪ ਇੱਕ-ਲਾਈਨ ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ ਜੋ ਕੋਡ ਨੂੰ ਸਿਰਫ਼ ਤਾਂ ਹੀ ਲਾਗੂ ਕਰਦੇ ਹਨ ਜੇਕਰ ਕੋਈ ਸ਼ਰਤ ਪੂਰੀ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਔਸਤ ਦੀ ਗਣਨਾ ਕਰਨਾ ਤਾਂ ਹੀ ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਮੁੱਲ ਮੌਜੂਦ ਹਨ, ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਦੇ ਹੋਏ।
19. ਮੈਂ ਟੈਸਟਿੰਗ ਲਈ ਪ੍ਰਿੰਟ ਆਉਟਪੁੱਟ ਨੂੰ ਕਿਵੇਂ ਰੀਡਾਇਰੈਕਟ ਕਰ ਸਕਦਾ ਹਾਂ?
20. ਵਰਤ ਕੇ StringIO ਅਤੇ sys.stdout ਰੀਡਾਇਰੈਕਸ਼ਨ, ਤੁਸੀਂ ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਟੈਸਟਾਂ ਵਿੱਚ ਆਉਟਪੁੱਟ ਕੈਪਚਰ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਉਮੀਦ ਕੀਤੇ ਨਤੀਜਿਆਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇਹ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਵਿੱਚ ਇੱਕ ਆਮ ਅਭਿਆਸ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।
21. ਦਾ ਮਕਸਦ ਕੀ ਹੈ tearDown ਯੂਨਿਟ ਟੈਸਟਾਂ ਵਿੱਚ?
22. ਵਿੱਚ unittest ਫਰੇਮਵਰਕ, tearDown() ਟੈਸਟਾਂ ਤੋਂ ਬਾਅਦ ਸਾਫ਼ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਸਥਾਈ ਫਾਈਲਾਂ ਨੂੰ ਹਟਾਉਣਾ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਟੈਸਟ ਨਵੇਂ ਵਾਤਾਵਰਨ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਟੈਸਟਾਂ ਦੇ ਵਿਚਕਾਰ ਡੇਟਾ ਦਖਲ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਹੱਲ ਨੂੰ ਸਮੇਟਣਾ

ਇਹ ਅਸਾਈਨਮੈਂਟ ਵਿਸ਼ੇਸ਼ ਕੇਸਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਮਹੱਤਤਾ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਪਾਈਥਨ ਵਿੱਚ ਔਸਤਾਂ ਦੀ ਗਣਨਾ ਕਰਦੇ ਸਮੇਂ, ਸਕਾਰਾਤਮਕ ਜਾਂ ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਦਾ ਗੁੰਮ ਹੋਣਾ। ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟਾਂ ਅਤੇ ਫਾਰਮੈਟਿੰਗ ਐਡਜਸਟਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋ ਕਿ "NaN" ਨੂੰ ਲੋੜ ਪੈਣ 'ਤੇ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਖਾਲੀ ਡਾਟਾ ਸੂਚੀਆਂ ਤੋਂ ਕਿਸੇ ਵੀ ਤਰੁੱਟੀ ਨੂੰ ਰੋਕਦੇ ਹੋਏ।

ਪਾਇਥਨ ਦੇ ਟੂਲ ਜਿਵੇਂ ਕੋਸ਼ਿਸ਼ ਕਰੋ...ਸਿਵਾਏ ਅਤੇ ਫਲੋਟ ('NaN') ਲਚਕਦਾਰ ਤਰੁੱਟੀ ਪ੍ਰਬੰਧਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਅਚਾਨਕ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲਣਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਅਜਿਹੇ ਅਭਿਆਸ ਪ੍ਰੋਗਰਾਮਰਾਂ ਲਈ ਅਸਾਈਨਮੈਂਟਾਂ, ਆਟੋਮੇਟਿਡ ਟੈਸਟਾਂ, ਅਤੇ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਨੂੰ ਸਹੀ ਆਉਟਪੁੱਟ ਫਾਰਮੈਟਿੰਗ ਦੀ ਜ਼ਰੂਰਤ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਅਨਮੋਲ ਹਨ। 🚀