Dépannage de la sortie NaN en Python : correction des erreurs dans les calculs basés sur des fichiers

Calcul de moyennes distinctes de nombres positifs et négatifs à partir d'un fichier

Script backend Python pour lire les données des fichiers, calculer les moyennes et gérer les valeurs manquantes de manière robuste.

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

Gestion de différents formats de données avec du code modulaire et réutilisable

Script backend Python avec structure modulaire améliorée et gestion des erreurs pour différents formats de données.

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

Tests unitaires pour le programme de calcul de moyenne basé sur des fichiers

Tests unitaires Python pour garantir un calcul moyen correct pour différents scénarios d'entrée.

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

Questions courantes sur Python NaN et la gestion des erreurs

1. Qu'est-ce que float('NaN') faire en Python ?
2. Cette commande crée une valeur flottante spéciale reconnue comme « NaN » (Not a Number). C'est utile pour gérer les cas où un calcul n'est pas défini ou lorsque vous devez signaler les données manquantes dans votre programme.
3. Comment puis-je m'assurer que ma sortie correspond à des exigences de formatage spécifiques ?
4. En utilisant des méthodes comme replace() vous permet de contrôler la façon dont votre sortie apparaît. Par exemple, replace('nan', 'NaN') peut garantir que vos valeurs « NaN » apparaissent dans la casse correcte, comme l'exigent certains systèmes de test.
5. Pourquoi try...except important dans les programmes basés sur des fichiers ?
6. Le try...except Le bloc est crucial pour la gestion des erreurs dans les cas où les lignes peuvent contenir des données non valides. Cela empêche le programme de planter si une ligne ne peut pas être convertie en float, ce qui rend le code plus fiable.
7. Qu'est-ce qu'un conditionnel en ligne et pourquoi l'utiliser ?
8. Un conditionnel en ligne comme sum(numbers) / len(numbers) if numbers else float('NaN') vous permet d'effectuer une opération uniquement lorsque certaines conditions sont remplies, par exemple lorsqu'une liste contient des valeurs. C’est idéal pour éviter des erreurs comme la division par zéro.
9. Comment le with open(file_name, 'r') travail de commandement ?
10. Cette commande ouvre un fichier en mode lecture et le ferme automatiquement par la suite. L'utilisation de « with » garantit que le fichier se ferme correctement, ce qui facilite la gestion des ressources et évite les erreurs liées à la sortie accidentelle de fichiers ouverts.
11. Puis-je tester si une valeur est « NaN » en Python ?
12. Oui, vous pouvez utiliser math.isnan() pour vérifier si une valeur est « NaN ». Ceci est particulièrement utile lorsque vous souhaitez formater ou exclure les valeurs « NaN » dans les calculs ou la sortie.
13. Pourquoi la cohérence du formatage est-elle importante dans la notation automatisée ?
14. Les systèmes automatisés reposent sur un formatage exact, donc des différences mineures (comme « nan » au lieu de « NaN ») peuvent provoquer des erreurs. Utiliser des méthodes cohérentes comme replace() pour le formatage évite ces problèmes.
15. Comment l'utilisation de listes simplifie-t-elle la catégorisation des données en Python ?
16. Les listes vous permettent de séparer les données en catégories telles que les positives et les négatives, ce qui facilite le calcul de statistiques distinctes pour chaque catégorie. L'ajout de valeurs aux listes en fonction de conditions est efficace et maintient le code organisé.
17. Que sont les conditions en ligne et quand doivent-elles être utilisées ?
18. Les conditions en ligne permettent des instructions concises sur une seule ligne qui exécutent du code uniquement si une condition est remplie. Par exemple, calculer une moyenne uniquement si des valeurs existent dans une liste, évitant ainsi les erreurs.
19. Comment puis-je rediriger la sortie d’impression pour les tester ?
20. En utilisant StringIO et sys.stdout redirection, vous pouvez capturer le résultat dans les tests pour vérifier qu'il correspond aux résultats attendus. Il s'agit d'une pratique courante dans les tests unitaires où vous souhaitez valider la sortie du programme.
21. Quel est le but de tearDown dans les tests unitaires ?
22. Dans unittest des cadres, tearDown() est utilisé pour nettoyer après les tests, comme supprimer des fichiers temporaires. Cela garantit que chaque test démarre avec un nouvel environnement, évitant ainsi les interférences de données entre les tests.

Conclusion de la solution

Cette mission démontre l'importance de gérer les cas particuliers, comme les valeurs positives ou négatives manquantes, lors du calcul des moyennes en Python. En utilisant des instructions conditionnelles et des ajustements de formatage, vous garantissez que « NaN » est renvoyé en cas de besoin, évitant ainsi toute erreur provenant de listes de données vides.

Les outils de Python comme essaie...sauf et flotteur('NaN') permettent une gestion flexible des erreurs, facilitant ainsi la gestion des données inattendues. De telles pratiques sont inestimables pour les programmeurs chargés de tâches, de tests automatisés et de toute situation nécessitant un formatage de sortie précis. 🚀