Solução de problemas de saída NaN em Python: correção de erros em cálculos baseados em arquivo

Calculando médias separadas de números positivos e negativos de um arquivo

Script de back-end Python para ler dados de arquivos, calcular médias e lidar com valores ausentes de maneira robusta.

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

Lidando com diferentes formatos de dados com código modular e reutilizável

Script de back-end Python com estrutura modular aprimorada e tratamento de erros para vários formatos de dados.

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

Teste de unidade para programa de cálculo de média baseado em arquivo

Testes de unidade Python para garantir o cálculo médio correto para diferentes cenários de entrada.

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

Perguntas comuns sobre Python NaN e tratamento de erros

1. O que faz float('NaN') fazer em Python?
2. Este comando cria um valor flutuante especial reconhecido como “NaN” (não é um número). É útil para lidar com casos em que um cálculo é indefinido ou quando você precisa sinalizar dados ausentes em seu programa.
3. Como posso garantir que minha saída atenda aos requisitos de formatação específicos?
4. Usando métodos como replace() permite que você controle como sua saída aparece. Por exemplo, replace('nan', 'NaN') pode garantir que seus valores “NaN” apareçam no caso correto, conforme exigido em certos sistemas de teste.
5. Por que é try...except importante em programas baseados em arquivos?
6. O try...except O bloco é crucial para o tratamento de erros nos casos em que as linhas podem conter dados inválidos. Ele evita que o programa trave se uma linha não puder ser convertida em float, tornando o código mais confiável.
7. O que é uma condicional embutida e por que usá-la?
8. Uma condicional embutida como sum(numbers) / len(numbers) if numbers else float('NaN') permite que você execute uma operação somente quando determinadas condições forem atendidas, como quando uma lista possui valores. Isso é ideal para evitar erros como divisão por zero.
9. Como é que with open(file_name, 'r') comando funciona?
10. Este comando abre um arquivo no modo de leitura e o fecha automaticamente depois. Usar “com” garante que o arquivo feche corretamente, o que auxilia no gerenciamento de recursos e evita erros ao deixar arquivos abertos acidentalmente.
11. Posso testar se um valor é “NaN” em Python?
12. Sim, você pode usar math.isnan() para verificar se um valor é “NaN”. Isso é particularmente útil quando você deseja formatar ou excluir valores “NaN” em cálculos ou saídas.
13. Por que a consistência da formatação é importante na avaliação automatizada?
14. Os sistemas automatizados dependem de formatação exata, portanto, pequenas diferenças (como “nan” em vez de “NaN”) podem causar erros. Usando métodos consistentes como replace() para formatação evita esses problemas.
15. Como o uso de listas simplifica a categorização de dados em Python?
16. As listas permitem separar os dados em categorias como positivos e negativos, o que torna simples o cálculo de estatísticas separadas para cada categoria. Acrescentar valores a listas com base em condições é eficiente e mantém o código organizado.
17. O que são condicionais in-line e quando devem ser usadas?
18. Condicionais embutidos permitem instruções concisas de uma linha que executam código somente se uma condição for atendida. Por exemplo, calcular uma média apenas se existirem valores em uma lista, evitando erros.
19. Como posso redirecionar a saída de impressão para teste?
20. Usando StringIO e sys.stdout redirecionamento, você pode capturar a saída em testes para verificar se ela corresponde aos resultados esperados. Esta é uma prática comum em testes unitários onde você deseja validar a saída do programa.
21. Qual é o propósito tearDown em testes unitários?
22. Em unittest estruturas, tearDown() é usado para limpeza após testes, como remoção de arquivos temporários. Isso garante que cada teste comece com um ambiente novo, evitando interferência de dados entre os testes.

Resumindo a solução

Esta tarefa demonstra a importância de lidar com casos especiais, como valores positivos ou negativos ausentes, ao calcular médias em Python. Ao usar instruções condicionais e ajustes de formatação, você garante que “NaN” seja retornado quando necessário, evitando erros em listas de dados vazias.

Ferramentas do Python como tente... exceto e float('NaN') permitem o gerenciamento flexível de erros, facilitando o tratamento de dados inesperados. Essas práticas são inestimáveis ​​para programadores que lidam com tarefas, testes automatizados e qualquer situação que exija formatação precisa de saída. 🚀