浮動小数点数を小数点以下2桁に制限する

13.95aに四捨五入したい。

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

round機能は、私が期待されるように動作しません。

あなたはに実行されている古い問題ではない、すべての数字が正確に表現することができます浮動小数点数を持ちます。コマンドラインは、メモリから完全な浮動小数点形式を表示しているだけです。

浮動小数点表現では、丸められたバージョンは同じ数です。コンピュータはバイナリなので、浮動小数点数を整数として格納し、2の累乗で除算するので、13.95は125650429603636838 /（2 ** 53）と同様の方法で表されます。

倍精度の数値の精度は53ビット（16桁）で、通常の浮動小数点の精度は24ビット（8桁）です。Pythonの浮動小数点型は、倍精度を使用して値を格納します。

例えば、

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

小数点以下2桁のみの場合（たとえば、通貨の値を表示する場合）は、より適切な選択肢がいくつかあります。

1. 整数を使用し、値をドルではなくセントで格納し、100で除算してドルに変換します。
2. または、decimalのような固定小数点数を使用します。

新しいフォーマット仕様、String Format Specification Mini-Languageがあります。

以下と同じことができます：

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

注1：上記は文字列を返します。フロートとして取得するには、単に次のようにラップしfloat(...)ます。

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

注2：でラップしfloat()ても何も変わりません。

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

ビルトインround()はPython 2.7以降で問題なく動作します。

例：

>>> round(14.22222223, 2)
14.22

ドキュメントを確認してください。

format()関数を使うのが一番簡単だと思います。

例えば：

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

13.95

これにより、浮動小数点数が小数点以下2桁に丸められたストリングとして生成されます。

使用する

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

の代わりに

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

後者の場合、複数の変数を出力しようとすると、出力エラーが発生する可能性があるためです（コメントを参照）。

ほとんどの数値は、浮動小数点数で正確に表すことができません。それがあなたの数式またはアルゴリズムが必要とするものであるので、あなたが数を丸めたいならば、あなたは丸めを使いたいでしょう。表示を特定の精度に制限したいだけの場合は、丸めを使用せず、その文字列としてフォーマットするだけです。（別の丸め方法で表示したい場合で、トン数がある場合は、2つの方法を組み合わせる必要があります。）

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

そして最後に、おそらく最も重要なことですが、正確な数学が必要な場合は、浮動小数点数はまったく必要ありません。通常の例では、お金を扱い、「セント」を整数として格納します。

以下のコードを試してください：

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

TLDR;）

入力/出力の丸め問題は、Python 2.7.0および3.1で完全に解決されました。

正しく丸められた数値は、可逆的に前後に変換できます。
str -> float() -> repr() -> float() ...またはDecimal -> float -> str -> Decimal
、Decimal型はストレージに必要なくなりました。

（当然のことながら、累積された最後のビットエラーを排除するために、丸められた数値の加算または減算の結果を丸めることが必要になる場合があります。明示的な10進数演算は引き続き便利ですが、文字列への変換str()（つまり、有効な12桁に丸める） ）通常、極端な精度や極端な数の連続する算術演算が必要ない場合は十分です。）

無限テスト：

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+ :-)

ドキュメンテーション

4番目の段落のリリースノート「Python 2.7-その他の言語の変更」を参照してください。

ほとんどのプラットフォームで、浮動小数点数と文字列間の変換が正しく丸められるようになりました。これらの変換はさまざまな場所で行われます。浮動小数点数および複素数のstr（）。floatおよびcomplexコンストラクタ。数値フォーマット; marshal、pickleおよびjsonモジュールを使用して、浮動小数点数と複素数をシリアル化および逆シリアル化します。Pythonコードでの浮動小数点数および虚数リテラルの解析。10進数から浮動小数点への変換。

これに関連して、浮動小数点数x のrepr（）は、正しい丸めの下でxに丸められることが保証されている最短の10進数文字列に基づいて結果を返すようになりました（丸め半から丸めモード）。以前は、xを17桁の10進数に丸めることに基づいて文字列を提供していました。

関連する問題

詳細：float Python 2.7以前のフォーマットは、現在のに似ていましたnumpy.float64。どちらのタイプも、52ビットの仮数で同じ64ビットのIEEE 754倍精度を使用します。大きな違いは、np.float64.__repr__ビットが失われないように過度の10進数で頻繁にフォーマットされることですが、13.949999999999999と13.950000000000001の間には有効なIEEE 754番号が存在しません。結果は良くなく、変換repr(float(number_as_string))はnumpyで元に戻すことはできません。一方：float.__repr__すべての桁が重要になるようにフォーマットされます。シーケンスにはギャップがなく、変換は可逆的です。単に：numpy.float64の数値がある場合は、数値プロセッサではなく人間用にフォーマットするために通常の浮動小数点数に変換します。それ以外の場合は、Python 2.7以降では何も必要ありません。

Python <3（例：2.6または2.7）では、2つの方法があります。

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

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

ただし、Pythonのバージョンが3を超える場合（3.2または3.3など）、オプション2が推奨されます。

オプション2の詳細については、Pythonドキュメントの文字列フォーマットに関するこのリンクをお勧めします。

オプション1の詳細については、このリンクで十分であり、さまざまなフラグに関する情報があります。

リファレンス：浮動小数点数を特定の精度に変換してから文字列にコピーする

出力形式を変更できます。

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

ここではまだ誰も言及していないようですので、Python 3.6のf-string / template-string形式の例を挙げましょう。

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

演算子を使用し、括弧を必要としない、より長い例でもうまく機能します。

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

pythonでは、フォーマット演算子を使用して、小数点以下2桁まで値を丸めることができます。

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

Python 2.7の場合：

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

Pythonチュートリアルには、「浮動小数点演算：問題と制限」という付録があります。それを読んで。何が起こっているのか、なぜPythonが最善を尽くしているのかを説明しています。あなたに合った例さえあります。少し引用させてください：

>>> 0.1
0.10000000000000001

このround() 関数を使用して、期待する1桁に戻すように誘惑されるかもしれません。しかし、それでも違いはありません。

>>> round(0.1, 1)
0.10000000000000001

問題は、に格納された2進浮動小数点値“0.1” がすでにへの可能な最高の2進近似であったため1/10、再度丸めることはそれを改善することはできません。

もう1つの結果は、0.1 が正確1/10ではないため、の10個の値を合計しても正確に0.1は得られない場合があること 1.0です。

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

問題の1つの代替策と解決策は、decimalモジュールを使用することです。

@Mattが指摘したように、Python 3.6はf-stringsを提供し、ネストされたパラメーターを使用することもできます。

value = 2.34558
precision = 2
width = 4

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

表示されます result: 2.35

それはあなたがそれをするように言ったとおり正確にやっていて、正しく働いています。浮動小数点の混乱の詳細を読んで、代わりに10進オブジェクトを試してください。

Decimalオブジェクトと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')

PythonやJavaScriptなどの型動的言語の浮動小数点を修正するために、この手法を使用します

# 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

Decimalを次のように使用することもできます。

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

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)

結果：

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'

orig_float = 232569 / 16000.0

14.5355625

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

14.54

このようなラムダ関数についてはどうですか？

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

この方法であなたはただ行うことができます：

arred(3.141591657,2)

そして得る

3.14

これは、1,2,3のように単純です。

1. 10進モジュールを使用して、正しく丸められた10進浮動小数点演算を高速化します。

   d = 10進数（10000000.0000009）

丸めを達成するには：

   d.quantize(Decimal('0.01'))

結果は Decimal('10000000.00')

2. 上記のDRYを作る：

    def round_decimal(number, exponent='0.01'):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(exponent))

または

    def round_decimal(number, decimal_places=2):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(10) ** -decimal_places)

3. この回答を賛成してください:)

PS：他の人の批評：フォーマットは丸めではありません。

数値を分解能に丸めるには、次の方法が最適です。これは、任意の分解能で機能します（小数点以下2桁に対して0.01、またはその他のステップ）。

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

ラムダx、n：int（x * 10 n + .5）/ 10 nは、長年、多くの言語で機能してきました。

私が使用する方法は、文字列スライスの方法です。比較的速くて簡単です。

まず、フロートを文字列に変換し、希望の長さを選択します。

float = str(float)[:5]

上記の1行では、値を文字列に変換し、文字列を最初の4桁または文字（両端を含む）のみに保持しました。

お役に立てば幸いです。