Limiter les flottants à deux décimales


1692

Je veux aêtre arrondi à 13,95 .

>>> a
13.949999999999999
>>> round(a, 2)
13.949999999999999

La roundfonction ne fonctionne pas comme je m'y attendais.



6
Hmm ... Essayez-vous de représenter la monnaie? Si c'est le cas, vous ne devriez pas utiliser de flotteurs pour des dollars. Vous pourriez probablement utiliser des flottants pour quelques centimes, ou quelle que soit la plus petite unité de monnaie commune que vous essayez de modéliser, mais la meilleure pratique consiste à utiliser une représentation décimale, comme l'a suggéré HUAGHAGUAH dans sa réponse.
SingleNegationElimination

63
Il est important de ne pas représenter la devise en float. Les flotteurs ne sont pas précis. Mais les montants d'un cent ou d'un cent sont des nombres entiers. Par conséquent, les entiers sont la bonne façon de représenter la monnaie.
Davoud Taghawi-Nejad

2
@ DavoudTaghawi-Nejad ou plus au point ... The Decimal Type
Basic

17
Je viens probablement trop tard ici, mais je voulais demander si les développeurs de Python ont résolu ce problème? Parce que quand je fais le tour (13.949999999999999, 2), j'obtiens simplement 13.95. Je l'ai essayé en Python 2.7.6, ainsi qu'en 3.4. Ça marche. Vous ne savez pas si 2.7 y était même en 2009. Peut-être que c'est une chose Python 2.5?
bad_keypoints

Réponses:


1690

Vous rencontrez l' ancien problème avec les nombres à virgule flottante que tous les nombres ne peuvent pas être représentés exactement. La ligne de commande vous montre simplement la forme flottante complète de la mémoire.

Avec une représentation en virgule flottante, votre version arrondie est le même nombre. Étant donné que les ordinateurs sont binaires, ils stockent des nombres à virgule flottante sous forme d'entier, puis le divisent par une puissance de deux, de sorte que 13,95 sera représenté de la même manière que 125650429603636838 / (2 ** 53).

Les nombres en double précision ont 53 bits (16 chiffres) de précision et les flottants réguliers ont 24 bits (8 chiffres) de précision. Le type à virgule flottante en Python utilise la double précision pour stocker les valeurs.

Par exemple,

>>> 125650429603636838/(2**53)
13.949999999999999

>>> 234042163/(2**24)
13.949999988079071

>>> a = 13.946
>>> print(a)
13.946
>>> print("%.2f" % a)
13.95
>>> round(a,2)
13.949999999999999
>>> print("%.2f" % round(a, 2))
13.95
>>> print("{:.2f}".format(a))
13.95
>>> print("{:.2f}".format(round(a, 2)))
13.95
>>> print("{:.15f}".format(round(a, 2)))
13.949999999999999

Si vous ne recherchez que deux décimales (pour afficher une valeur monétaire, par exemple), vous avez deux choix:

  1. Utilisez des entiers et stockez les valeurs en cents, pas en dollars, puis divisez par 100 pour convertir en dollars.
  2. Ou utilisez un nombre à virgule fixe comme décimal .

27
@Christian Il existe une différence fondamentale entre la valeur stockée et la façon dont vous affichez cette valeur. Le formatage de la sortie devrait vous permettre d'ajouter un remplissage au besoin, ainsi que l'ajout de séparateurs de virgules, etc.
Basic

22
vaut la peine de mentionner que "%.2f" % round(a,2)vous pouvez mettre non seulement dans printf, mais aussi dans des choses commestr()
andilabs

20
pourquoi est-ce que les gens assument toujours la monnaie lors de l'arrondi à virgule flottante? parfois, vous voulez simplement travailler avec moins de précision.
worc

9
@radtek: Vous devez comprendre que la valeur binaire (de type float) est juste l'approximation disponible la plus proche du nombre décimal (que vous connaissez en tant qu'être humain). Il n'existe aucune valeur binaire (représentable de manière finie) telle que 0,245. Elle n'existe tout simplement pas et mathématiquement ne peut pas exister. La valeur binaire qui est la plus proche de 0,245 est légèrement inférieure à 0,245, elle arrondit donc naturellement. De même, il n'existe pas de 0,225 en binaire, mais la valeur binaire qui est la plus proche de 0,225 est légèrement supérieure à 0,225, donc naturellement elle arrondit.
John Y

12
@radtek: Vous avez littéralement demandé une explication. La solution la plus simple est en effet à utiliser Decimal, et c'était l'une des solutions présentées dans cette réponse. L'autre consistait à convertir vos quantités en nombres entiers et à utiliser l'arithmétique entière. Ces deux approches sont également apparues dans d'autres réponses et commentaires.
John Y

586

Il existe de nouvelles spécifications de format, String Mini-Language Specification :

Vous pouvez faire de même que:

"{:.2f}".format(13.949999999999999)

Remarque 1: ce qui précède renvoie une chaîne. Pour obtenir comme flotteur, enveloppez simplement avec float(...):

float("{:.2f}".format(13.949999999999999))

Remarque 2: l' emballage avec float()ne change rien:

>>> x = 13.949999999999999999
>>> x
13.95
>>> g = float("{:.2f}".format(x))
>>> g
13.95
>>> x == g
True
>>> h = round(x, 2)
>>> h
13.95
>>> x == h
True

17
pour ajouter des virgules, vous pouvez également '{0:,.2f}'.format(1333.949999999)imprimer '1,333.95'.
Stephen Blum

@ OnurYıldırım: oui, mais vous pouvez l'envelopper avec float(); float("{0:.2f}".format(13.9499999))
Jossef Harush

5
@JossefHarush vous pouvez l'envelopper avec float (), mais vous n'avez rien gagné. Maintenant, vous avez à nouveau un flotteur, avec la même imprécision. 13.9499999999999 et 13.95 sont le même flottant.
Ned Batchelder

4
@NedBatchelder: je suis d'accord qu'ils sont égaux, mais cela limite le flotteur à deux décimales :)
Jossef Harush

8
Soit dit en passant, depuis Python 3.6, nous pouvons utiliser des chaînes f:f"Result is {result:.2f}"
Andrey Semakin

289

La fonction intégrée round()fonctionne très bien en Python 2.7 ou version ultérieure.

Exemple:

>>> round(14.22222223, 2)
14.22

Consultez la documentation .


1
Dois-je donc comprendre qu'il s'agit d'un échec de Python 2.7? Pourquoi une fonction aussi fondamentale donnerait-elle des résultats différents de v 2.7 à v 3?
MikeM

mais round(2.16, 1)donnez 2.2pourquoi python offre juste un truncatefunc
jiamo

Par exemple, si vous essayez d'arrondir la valeur 2,675 à deux décimales, vous obtenez ce >>> round(2.675, 2) 2.67 docs.python.org/2/tutorial/floatingpoint.html
danger89

4
Depuis la page de documentation de Python 3:Note The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float.
Richard Dally

Notez que si vous essayez d'utiliser cette méthode pour imprimer un nombre tel que 1,00000, elle n'imprimera que 1,0, quel que soit le nombre de décimales que vous spécifiez.
Josh Correia

142

Je pense que l'approche la plus simple consiste à utiliser la format()fonction.

Par exemple:

a = 13.949999999999999
format(a, '.2f')

13.95

Cela produit un nombre flottant sous la forme d'une chaîne arrondie à deux décimales.


97

Utilisation

print"{:.2f}".format(a)

au lieu de

print"{0:.2f}".format(a)

Parce que ce dernier peut entraîner des erreurs de sortie lors de la tentative de sortie de plusieurs variables (voir les commentaires).


2
Ça n'a pas de sens. Les deux instructions données se comportent de manière identique sur Python 2.7, et seule la deuxième instruction est valide sur Python 2.6. (Aucune de ces instructions n'est valide en Python 3 ou Python <2.6.) La première forme n'a aucun avantage à part la brièveté.
Mark Dickinson

1
Je veux dire, imprimer "{0: .2f} {0: .2f}". Le format (a, b) entraînera une erreur de sortie - il affichera deux fois la valeur "a". Pendant l'impression "{:. 2f} {: .2f}". Le format (a, b) affichera les valeurs 'a' et 'b'.
Alexey Antonenko

2
Pour Python 3, il suffit d'ajouter des parenthèses print (...). Et en eux tout ce que j'ai écrit est vrai.
Alexey Antonenko

"Je veux dire, imprimer" {0: .2f} {0: .2f} ". Le format (a, b) entraînera une erreur de sortie". Ah. Eh bien, c'est une déclaration très différente! Vous devriez peut-être modifier votre réponse? (Qu'est-ce que «déclencher l'erreur» signifie dans la réponse actuelle, par exemple? Pouvez-vous donner un exemple d'un cas où la deuxième déclaration déclenche une exception mais pas la première?)
Mark Dickinson

3
Vous seriez après l'impression ("{0: .2f} {1: .2f}". Format (a, b)) si vous avez deux variables
Hovo

95

La plupart des nombres ne peuvent pas être représentés exactement dans des flottants. Si vous voulez arrondir le nombre parce que c'est ce que votre formule mathématique ou votre algorithme requiert, vous devez utiliser arrondir. Si vous souhaitez simplement restreindre l'affichage à une certaine précision, n'utilisez même pas round et formatez-le simplement comme cette chaîne. (Si vous souhaitez l'afficher avec une autre méthode d'arrondi et qu'il y en a des tonnes, vous devez mélanger les deux approches.)

>>> "%.2f" % 3.14159
'3.14'
>>> "%.2f" % 13.9499999
'13.95'

Et enfin, mais peut-être le plus important, si vous voulez des mathématiques exactes, vous ne voulez pas du tout de flottants. L'exemple habituel consiste à gérer l'argent et à stocker les «cents» sous forme d'entier.


68

Essayez le code ci-dessous:

>>> a = 0.99334
>>> a = int((a * 100) + 0.5) / 100.0 # Adding 0.5 rounds it up
>>> print a
0.99

Mais attention, la valeur de a reste un flotteur imprécis. Jetez un œil ici - repl.it/LJs (Cliquez sur "Exécuter la session" en haut de la section de droite).
lifebalance

3
Si vous optez pour cette approche, vous devez ajouter un 0,5 pour une représentation plus précise. int (a * 100 + 0,5) / 100,0; L'utilisation de math.ceil est une autre option.
arhuaco

3
@ShashankSawant: Eh bien, d'une part, la réponse telle qu'elle est présentée ne s'arrondit pas, elle tronque. La suggestion d'ajouter la moitié à la fin sera arrondie, mais il n'y a aucun avantage à le faire en utilisant simplement la roundfonction en premier lieu. D'autre part, comme cette solution utilise toujours la virgule flottante, le problème d'origine de l'OP demeure, même pour la version "corrigée" de cette "solution".
John Y

3
-1, c'est juste une réimplémentation inutile de la roundfonction (qui a été utilisée dans la question).
interjay

4
@interjay qui est nécessaire si le round()ne fonctionne pas comme l'OP mentionné.
Pithikos

57

TLDR;)

Le problème d'arrondi des entrées / sorties a été définitivement résolu par Python 2.7.0 et 3.1 .

Un nombre correctement arrondi peut être converti de façon réversible d'avant en arrière:
str -> float() -> repr() -> float() ...ou Decimal -> float -> str -> Decimal
Un type décimal n'est plus nécessaire pour le stockage.


(Naturellement, il peut être nécessaire d'arrondir un résultat d'addition ou de soustraction de nombres arrondis pour éliminer les erreurs accumulées du dernier bit. Une arithmétique décimale explicite peut être toujours pratique, mais une conversion en chaîne par str()(c'est-à-dire en arrondissant à 12 chiffres valides) ) est généralement assez bonne si aucune précision extrême ou aucun nombre extrême d'opérations arithmétiques successives n'est requis.)

Test infini :

import random
from decimal import Decimal
for x in iter(random.random, None):           # Verify FOREVER that rounding is fixed :-)
    assert float(repr(x)) == x                # Reversible repr() conversion.
    assert float(Decimal(repr(x))) == x
    assert len(repr(round(x, 10))) <= 12      # Smart decimal places in repr() after round.
    if x >= 0.1:                              # Implicit rounding to 12 significant digits
        assert str(x) == repr(round(x, 12))   # by str() is good enough for small errors.
        y = 1000 * x                             # Decimal type is excessive for shopping
        assert str(y) == repr(round(y, 12 - 3))  # in a supermaket with Python 2.7+ :-)

Documentation

Voir les notes de publication Python 2.7 - Autres changements de langue, le quatrième paragraphe:

Les conversions entre les nombres à virgule flottante et les chaînes sont désormais correctement arrondies sur la plupart des plates-formes. Ces conversions se produisent à de nombreux endroits différents: str () sur les flottants et les nombres complexes; le flotteur et les constructeurs complexes; formatage numérique; sérialisation et des flotteurs de-sérialisation et de nombres complexes en utilisant les marshal, pickleet les jsonmodules; analyse des flottants et des littéraux imaginaires en code Python; et conversion décimale-à-flottante.

En relation avec cela, la repr () d'un nombre à virgule flottante x retourne désormais un résultat basé sur la chaîne décimale la plus courte qui est garantie d'arrondir à x sous un arrondi correct (avec le mode d'arrondi demi-rond à pair). Auparavant, il donnait une chaîne basée sur l'arrondi de x à 17 chiffres décimaux.

La question connexe


Plus d'informations: Le formatage d' floatavant Python 2.7 était similaire à l'actuel numpy.float64. Les deux types utilisent la même double précision IEEE 754 64 bits avec une mantisse 52 bits. Une grande différence est qu'il est formaté de manière à ce que chaque chiffre soit important; la séquence est sans lacunes et la conversion est réversible. Simplement: si vous avez peut-être un numéro numpy.float64, convertissez-le en float normal afin d'être formaté pour les humains, pas pour les processeurs numériques, sinon rien de plus n'est nécessaire avec Python 2.7+.np.float64.__repr__ est fréquemment formaté avec un nombre décimal excessif afin qu'aucun bit ne puisse être perdu, mais aucun numéro IEEE 754 valide n'existe entre 13,94999999999999999 et 13,950000000000001. Le résultat n'est pas agréable et la conversion repr(float(number_as_string))n'est pas réversible avec numpy. D'autre part:float.__repr__


Pourquoi avoir voté La question portait sur Python float(double précision) et normal round, pas sur numpy.double et sa conversion en chaîne. L'arrondi Python simple ne peut vraiment pas être mieux fait que dans Python 2.7. La plupart des réponses ont été écrites avant la 2.7, mais elles sont obsolètes, même si elles étaient très bonnes à l'origine. C'est la raison de ma réponse.
hynekcer

53 bits lorsque vous incluez le "bit caché", ce qui est implicitement 1, sauf lors d'un "dépassement progressif".
Rick James

Ce n'est pas la faute du rond, c'est la faute d'affichage.
Rick James

Oui, c'est bien connu. Je manque cependant un contexte si vous vous opposez à quelque chose dans Python 2.7 Release notes ou dans mon texte ou à rien du tout. Le but de cette question est plus compliqué qu'il n'était nécessaire. Il convient d'ajouter que la conversion de chaîne en flottant a également été corrigée dans Python 2.7 en raison d'un bogue d'arrondi sur certaines puces Intel 32 bits et que "la fonction round () est désormais correctement arrondie". ( Notes de version - 3.1 fonctionnalités rétroportées à 2.7 ). Pouvez-vous être d'accord?
hynekcer

1
Oops, qui était a*bcontre b*a. Merci pour les liens - Nostalgie.
Rick James

52

Avec Python <3 (par exemple 2.6 ou 2.7), il y a deux façons de le faire.

# Option one 
older_method_string = "%.9f" % numvar

# Option two (note ':' before the '.9f')
newer_method_string = "{:.9f}".format(numvar)

Mais notez que pour les versions Python supérieures à 3 (par exemple 3.2 ou 3.3), l'option deux est préférée .

Pour plus d'informations sur l'option deux, je suggère ce lien sur le formatage des chaînes de la documentation Python .

Et pour plus d'informations sur la première option, ce lien suffira et contient des informations sur les différents drapeaux .

Référence: convertir un nombre à virgule flottante avec une certaine précision, puis copier dans une chaîne


Comment représentez-vous un entier? Si j'utilise le format "{i3}". (Numvar) j'obtiens une erreur.
skytux

C'est ce que je veux dire: si numvar=12.456, alors "{:.2f}".format(numvar)cède 12.46mais "{:2i}".format(numvar)donne une erreur et je m'attends 12.
skytux

50

Vous pouvez modifier le format de sortie:

>>> a = 13.95
>>> a
13.949999999999999
>>> print "%.2f" % a
13.95

47

Personne ici ne semble l'avoir encore mentionné, alors permettez-moi de donner un exemple au format f-string / template-string de Python 3.6, qui je pense est magnifiquement soigné:

>>> f'{a:.2f}'

Cela fonctionne bien avec des exemples plus longs aussi, avec des opérateurs et sans besoin de parens:

>>> print(f'Completed in {time.time() - start:.2f}s')

39

Vous pouvez utiliser l' opérateur de format pour arrondir la valeur jusqu'à 2 décimales en python:

print(format(14.4499923, '.2f')) // output is 14.45

4
Cela renvoie la chaîne
Jemshit Iskenderov

29

En Python 2.7:

a = 13.949999999999999
output = float("%0.2f"%a)
print output

1
Cela n'aide pas du tout. outputa exactement la même valeur que a, donc vous pourriez aussi bien avoir écrit print aau lieu de print outputdans la dernière ligne.
Mark Dickinson

@MarkDickinson Pourriez-vous s'il vous plaît réessayer. Parce qu'il fonctionne comme prévu dans mon compilateur.
Shashank Singh

1
Vous manquez mon point. Oui, votre code s'imprime 13.95. Mais il en va de même print apour cette valeur particulière de aPython 2.7, il n'est donc pas vraiment clair quel était le point de l'étape de formatage.
Mark Dickinson

@MarkDickinson J'ai édité le code. Je suis d'accord que «imprimer un» imprime la même valeur que «imprimer la sortie». Mais si vous comparez "a == output", le résultat sera "False" car l'étape de formatage arrondit la valeur flottante "a" à deux décimales.
Shashank Singh

1
Avez-vous réellement essayé a == outputle code que vous montrez? Cela Trueme donne et je soupçonne que ça le fait aussi pour vous.
Mark Dickinson

22

Le didacticiel Python comporte une annexe intitulée Arithmétique à virgule flottante: problèmes et limites . Lis le. Il explique ce qui se passe et pourquoi Python fait de son mieux. Il a même un exemple qui correspond au vôtre. Permettez-moi de citer un peu:

>>> 0.1
0.10000000000000001

vous pourriez être tenté d'utiliser la round() fonction pour la couper en un seul chiffre que vous attendez. Mais cela ne fait aucune différence:

>>> round(0.1, 1)
0.10000000000000001

Le problème est que la valeur binaire à virgule flottante stockée pour “0.1” était déjà la meilleure approximation binaire possible 1/10, donc essayer de l'arrondir à nouveau ne peut pas l'améliorer: elle était déjà aussi bonne que possible.

Une autre conséquence est que puisque 0.1 n'est pas exactement 1/10, la somme de dix valeurs de 0.1peut ne pas donner exactement 1.0non plus:

>>> sum = 0.0
>>> for i in range(10):
...     sum += 0.1
...
>>> sum
0.99999999999999989

Une alternative et une solution à vos problèmes serait d'utiliser le decimalmodule.


18

Comme l'a souligné @Matt, Python 3.6 fournit des chaînes f , et ils peuvent également utiliser des paramètres imbriqués :

value = 2.34558
precision = 2
width = 4

print(f'result: {value:{width}.{precision}f}')

qui affichera result: 2.35



11

Utilisez une combinaison d'objet Decimal et de méthode round ().

Python 3.7.3
>>> from decimal import Decimal
>>> d1 = Decimal (13.949999999999999) # define a Decimal
>>> d1 
Decimal('13.949999999999999289457264239899814128875732421875')
>>> d2 = round(d1, 2) # round to 2 decimals
>>> d2
Decimal('13.95')

7

Pour fixer la virgule flottante dans les langages de type dynamique tels que Python et JavaScript, j'utilise cette technique

# For example:
a = 70000
b = 0.14
c = a * b

print c # Prints 980.0000000002
# Try to fix
c = int(c * 10000)/100000
print c # Prints 980

Vous pouvez également utiliser Decimal comme suit:

from decimal import *
getcontext().prec = 6
Decimal(1) / Decimal(7)
# Results in 6 precision -> Decimal('0.142857')

getcontext().prec = 28
Decimal(1) / Decimal(7)
# Results in 28 precision -> Decimal('0.1428571428571428571428571429')

1
getcontext().prec = 6fonctionne pour la portée de la fonction ou pour tous les endroits?
Julio Marins

1
Les contextes sont des environnements pour les opérations arithmétiques. Ils régissent la précision, définissent les règles d'arrondi, déterminent quels signaux sont traités comme des exceptions et limitent la plage des exposants. Chaque thread a son propre contexte actuel @JulioMarins
Siamand

7
from decimal import Decimal


def round_float(v, ndigits=2, rt_str=False):
    d = Decimal(v)
    v_str = ("{0:.%sf}" % ndigits).format(round(d, ndigits))
    if rt_str:
        return v_str
    return Decimal(v_str)

Résultats:

Python 3.6.1 (default, Dec 11 2018, 17:41:10)
>>> round_float(3.1415926)
Decimal('3.14')
>>> round_float(3.1445926)
Decimal('3.14')
>>> round_float(3.1455926)
Decimal('3.15')
>>> round_float(3.1455926, rt_str=True)
'3.15'
>>> str(round_float(3.1455926))
'3.15'

6
orig_float = 232569 / 16000.0

14.5355625

short_float = float("{:.2f}".format(orig_float)) 

14,54


5

Qu'en est-il d'une fonction lambda comme celle-ci:

arred = lambda x,n : x*(10**n)//1/(10**n)

De cette façon, vous pouvez simplement faire:

arred(3.141591657,2)

et obtenir

3.14

4

C'est simple comme 1,2,3:

  1. utiliser décimal module pour une arithmétique décimale décimale à virgule flottante correctement arrondie:

    d = décimal (10000000.0000009)

pour arrondir:

   d.quantize(Decimal('0.01'))

sera résultats avec Decimal('10000000.00')

  1. faire au-dessus de SEC:
    def round_decimal(number, exponent='0.01'):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(exponent))

OU

    def round_decimal(number, decimal_places=2):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(10) ** -decimal_places)
  1. voter pour cette réponse :)

PS: critique des autres: le formatage n'est pas arrondi.


2

Pour arrondir un nombre à une résolution, la meilleure façon est la suivante, qui peut fonctionner avec n'importe quelle résolution (0,01 pour deux décimales ou même d'autres étapes):

>>> import numpy as np
>>> value = 13.949999999999999
>>> resolution = 0.01
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
13.95

>>> resolution = 0.5
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
14.0

ne fonctionne pas pour moi sur python 3.4.3 et numpy 1.9.1? >>> import numpy as np >>> res = 0.01 >>> value = 0.184 >>> np.round (value / res) * res 0.1799999999999999999
szeitlin

1
Recherche de documentation Je vois que le problème vient de l' numpy.roundexactitude / précision. Il faut donc le définir comme entier avant multiplication avec résolution. J'ai mis à jour le code. Merci pour ça!
iblasi

Le seul nécessaire est de convertir le numpy.float64résultat de np.round en floatou simplement d'utiliser round(value, 2). Aucun numéro IEEE 754 valide n'existe entre le 13.94999999999999999 (= 1395 / 100.) et le 3.950000000000001 (= 1395 * .01). Pourquoi pensez-vous que votre méthode est la meilleure? La valeur d'origine 13.949999999999999289 (= valeur = round (valeur, 2)) est encore plus exacte que votre 13.950000000000001717 (imprimée par np.float96). Plus d'informations également pour numpy sont maintenant ajoutées à ma réponse que vous avez probablement downvoted par erreur. Il ne s'agissait pas de numpy à l'origine.
hynekcer

@hynekcer Je ne pense pas que ma réponse soit la meilleure. Je voulais juste ajouter un exemple de flottement limite à n décimales mais le plus proche d'une résolution définie. J'ai vérifié, comme vous l'avez dit, qu'au lieu de intvous, vous pouvez également utiliser l' floatexemple @szeitlin. Merci pour votre commentaire supplémentaire. (Désolé mais je ne vous ai pas downvote)
iblasi

Ajouter une toute nouvelle dépendance pour le traitement numérique (pandas) est la "meilleure façon"?
Hejazzman

1

lambda x, n: int (x * 10 n + .5) / 10 n travaille pour moi depuis de nombreuses années dans de nombreuses langues.


-13

La méthode que j'utilise est celle du découpage de chaîne. C'est relativement rapide et simple.

Tout d'abord, convertissez le flotteur en chaîne, puis choisissez la longueur que vous souhaitez qu'il soit.

float = str(float)[:5]

Dans la seule ligne ci-dessus, nous avons converti la valeur en chaîne, puis conservé la chaîne uniquement dans ses quatre premiers chiffres ou caractères (inclus).

J'espère que cela pourra aider!


2
Veuillez ne pas publier de réponses identiques à plusieurs questions.
vaultah

18
WOW ... tdh ... Veuillez ne jamais créer de logiciel de comptabilité ... Que se passe-t-il si le nombre est 113,94 ?? cela se traduirait par 113,9 ... laissant 0,04 manquant .... De plus, cela a déjà des réponses d'il y a plus de 5 ans ....
Angry 84
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.