Comment arrondir un nombre aux chiffres significatifs en Python

Pour arrondir un nombre à un nombre choisi de chiffres significatifs, trouvez son ordre de grandeur décimal et passez le nombre de décimales correspondant à round(). Par exemple, 1 342 arrondi à un chiffre significatif devient 1 000. La fonction intégrée suffit pour une seule valeur ; utilisez une fonction auxiliaire pour les calculs répétés, le formatage lorsque le résultat doit rester du texte, Decimal lorsque les règles d’arrondi décimal comptent, ou NumPy pour les tableaux.

Arrondir aux chiffres significatifs avec round() de Python’s

round(number, ndigits) arrondit à un nombre de décimales. Pour les chiffres significatifs, calculez ndigits comme digits - 1 - floor(log10(abs(number))). Pour 1 342 et un chiffre significatif, cela donne 1 - 1 - 3, soit -3, donc Python arrondit au millier le plus proche.

Exécutez cet exemple :

print(round(1342, -3))

1000

Python utilise l’arrondi au pair (ties-to-even) pour les cas exactement à mi-chemin, de sorte que le dernier chiffre conservé est pair lorsque la valeur se trouve exactement à mi-chemin entre deux valeurs arrondies. C’est différent d’arrondir toujours un cas à mi-chemin en s’éloignant de zéro. Un ndigits négatif arrondit aux dizaines, centaines ou puissances de dix supérieures. round() renvoie un nombre ; il ne conserve pas les zéros finaux comme convention d’affichage. Pour les entrées en virgule flottante, l’approximation binaire stockée peut aussi affecter les cas décimaux apparemment à mi-chemin.

Arrondir aux chiffres significatifs avec une fonction auxiliaire math

Une fonction auxiliaire peut calculer le nombre de décimales à partir de l’ordre de grandeur en base 10. La version suivante accepte des nombres de chiffres entiers positifs et des valeurs numériques finies, et renvoie zéro inchangé. Elle lève ValueError pour un nombre de chiffres non pris en charge ou une entrée non finie, car log10() ne peut pas déterminer un ordre de grandeur décimal fini pour ces valeurs.

from math import floor, isfinite, log10


def round_significant(value, digits):
    if not isinstance(digits, int) or digits < 1:
        raise ValueError("digits must be a positive integer")
    if not isfinite(value):
        raise ValueError("value must be finite")
    if value == 0:
        return value
    places = digits - 1 - floor(log10(abs(value)))
    return round(value, places)


print(round_significant(1324, 2))

La formule fonctionne pour les valeurs finies positives et négatives car elle utilise abs(value) pour trouver l’ordre de grandeur, tandis que round() conserve le signe. Elle suit la règle d’arrondi au pair de Python. Utilisez math.isfinite() pour décider si une entrée est prise en charge avant de calculer le logarithme ; traitez NaN et les infinis séparément si votre application en a besoin.

Arrondir aux chiffres significatifs avec le formatage de chaînes

Le format %g utilise sa précision comme nombre de chiffres significatifs. Avec la précision p, il utilise la notation scientifique lorsque l’exposant décimal est inférieur à -4 ou supérieur ou égal à p ; sinon, il utilise la notation ordinaire. Pour la précision 3, 0.0001 et 999 utilisent la notation ordinaire, tandis que 0.00001 et 1000 utilisent la notation scientifique. Le formatage renvoie une chaîne, ce qui est utile lorsque l’objectif est la présentation. Conservez cette chaîne pour préserver sa représentation choisie ; convertissez-la avec float() uniquement lorsque des opérations numériques ultérieures sont nécessaires. La conversion en nombre supprime les détails d’affichage tels que les zéros finaux.

Par exemple, "%.3g" % 1324 formate la valeur avec trois chiffres significatifs. Le résultat est du texte, et le choix exact entre notation ordinaire et scientifique est fait par le formateur.

Arrondir aux chiffres significatifs avec sigfig

Le package tiers sigfig accepte le nombre de chiffres significatifs via son argument sigfigs. Installez le package dans votre environnement avant de l’utiliser. Par exemple, l’appel au package est sigfig.round(1324, sigfigs=2). C’est pratique lorsque le comportement et le formatage du package conviennent à votre application ; ce n’est pas nécessaire pour les approches intégrées ou auxiliaires ci-dessus.

Arrondir aux chiffres significatifs avec decimal.Decimal

Decimal prend en charge l’arithmétique décimale et un mode d’arrondi explicite. Construisez-le à partir d’une chaîne lorsque les chiffres décimaux de l’entrée comptent ; convertir un flottant existant ne peut pas récupérer les informations que le flottant n’a pas stockées. Cet exemple met à l’échelle un décimal fini non nul à la précision demandée et arrondit les cas à mi-chemin en s’éloignant de zéro avec ROUND_HALF_UP.

from decimal import Decimal, ROUND_HALF_UP


def round_decimal_significant(value, digits):
    if not isinstance(digits, int) or digits < 1:
        raise ValueError("digits must be a positive integer")
    number = Decimal(str(value))
    if not number.is_finite():
        raise ValueError("value must be finite")
    if number.is_zero():
        return number
    quantum = Decimal(1).scaleb(number.adjusted() - digits + 1)
    return number.quantize(quantum, rounding=ROUND_HALF_UP)


print(round_decimal_significant("1324", 2))

Le résultat reste un Decimal. ROUND_HALF_UP n’est qu’une politique ; choisissez un mode tel que ROUND_HALF_EVEN lorsqu’il correspond aux règles de votre application. L’arithmétique décimale peut toujours être limitée par la précision du contexte actif, elle ne promet donc pas une précision illimitée.

Arrondir des tableaux aux chiffres significatifs avec NumPy

NumPy est utile lorsque l’entrée est un tableau, mais numpy.around() accepte des décimales plutôt que des chiffres significatifs. Pour une valeur finie non nulle, calculez le nombre de décimales avec digits - 1 - floor(log10(abs(value))) et passez-le à numpy.around(). Pour un tableau, calculez les ordres de grandeur élément par élément et traitez les zéros et les valeurs non finies avant de prendre les logarithmes. NumPy est une dépendance supplémentaire ; cette approche suit le comportement d’arrondi en virgule flottante et ne conserve pas les zéros d’affichage.

L’exemple ci-dessous arrondit uniquement les éléments finis non nuls. Il laisse inchangés zéro, NaN, ainsi que l’infini positif ou négatif. La valeur renvoyée est un ndarray NumPy avec des éléments en virgule flottante. NumPy est une dépendance supplémentaire, installez-le donc avant d’exécuter cet exemple.

import numpy as np


values = np.array([1234.5, -1234.5, 0.0, np.nan, np.inf, -np.inf])
digits = 3
rounded = values.copy()
finite_nonzero = np.isfinite(values) & (values != 0)

for index in np.flatnonzero(finite_nonzero):
    places = digits - 1 - int(np.floor(np.log10(abs(values[index]))))
    rounded[index] = np.around(values[index], decimals=places)

print(rounded.tolist())

[1230.0, -1230.0, 0.0, nan, inf, -inf]