浮動小数点数の誤差とは?0.1+0.2が0.3にならない理由と対処法
Python で「0.1 + 0.2」を計算すると、答えは 0.3 ではなく 0.30000000000000004 になります。JavaScript でも同じです。バグのように見えますが、これは小数を 2 進数で扱うコンピューターの仕組みから来る「浮動小数点数の誤差」で、ほとんどのプログラミング言語で起きます。
この記事では、誤差が生まれる理由を実際のビットを表示しながら説明し、仕事で困らないための対処法を紹介します。例は Python 3.12、Microsoft Edge 155(ヘッドレスモード)の JavaScript、PowerShell 5.1、Python に付属の SQLite 3.45 で実際に実行し、その結果を載せています。
この記事で分かること:
- 0.1 が 2 進数ではぴったり表せない理由と、IEEE 754 倍精度(64 ビット)の中身
- 誤差がたまる・大きな数に足すと消える・253 を超える整数がずれる、という 3 つの現れ方
- == で比べずに math.isclose や許容誤差で比べる方法
- お金の計算は Decimal か整数(円・セント)で持つ理由と、Decimal(“0.1”) と Decimal(0.1) の違い
- round() の偶数丸め、fractions、SQL の FLOAT と DECIMAL の違い
0.1 + 0.2 は 0.3 にならない
まずは実際に確かめてみましょう。Python で次のコードを実行すると、1 行目に「0.30000000000000004」、2 行目に「False」と表示されます。
print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
JavaScript も同じです。ブラウザの開発者ツールのコンソール(F12 キーで開く画面の「Console」)に次の式を入力すると「0.30000000000000004」と表示されます。0.1 + 0.2 === 0.3 は false です。
0.1 + 0.2
PowerShell 5.1 はもっと紛らわしく、次のコマンドを実行すると「0.3」と表示されます。ところが「0.1 + 0.2 -eq 0.3」は False です。表示のときに桁を短くしているだけで、中身は Python と同じ 0.30000000000000004 です((0.1 + 0.2).ToString(“R”) で確かめられます)。画面に 0.3 と出ても、中身が 0.3 とは限らないことを覚えておきましょう。
0.1 + 0.2
原因:0.1 は 2 進数で割り切れない
10 進数の 1/3 と同じことが起きている
10 進数で 1/3 を書こうとすると 0.3333… と 3 が永遠に続き、どこかで打ち切るしかありません。コンピューターは数を 2 進数(0 と 1)で持つため、同じことが 0.1 で起きます。小数を 2 進数に直すには「2 倍して、整数部分(0 か 1)を取り出す」をくり返します。
0.1 × 2 = 0.2 → 0
0.2 × 2 = 0.4 → 0
0.4 × 2 = 0.8 → 0
0.8 × 2 = 1.6 → 1(残りは 0.6)
0.6 × 2 = 1.2 → 1(残りは 0.2)
0.2 × 2 = 0.4 → 0 ← 2 行目と同じ。ここから先はくり返し
……
0.1(10 進数)= 0.000110011001100110011…(2 進数)
「0011」が永遠に続く循環小数になるので、どこかで打ち切って丸めるしかありません。Python の公式チュートリアル「浮動小数点演算、その問題と制限」でも、ほとんどの 10 進数の小数は 2 進数の小数でぴったり表せず、入力した値は近い値で近似されると説明されています。一方、0.5(2 進数で 0.1)・0.25(0.01)・0.75(0.11)のように、1/2 を何回か掛けた数の足し算で表せる小数は、ぴったり表せます。
実際に保存されている値を見る
Python の print(0.1) は「0.1」と表示しますが、これは「その値に戻せる一番短い表し方」で見せているだけです。小数点以下 20 桁まで表示するか、Decimal に変換すると、本当の値が見えます。
from decimal import Decimal
print(f"{0.1:.20f}")
print(Decimal(0.1))
実行結果は次のとおりです。0.1 は、実際には 0.1 より少しだけ大きい値として保存されています。
0.10000000000000000555
0.1000000000000000055511151231257827021181583404541015625
同じように調べると、0.2 も少し大きく、0.3 は 0.299999999999999988897… と少し小さく保存されています。0.1 と 0.2 の「少し大きい」が足し合わさった結果が、0.3 として保存されている値とずれるため、== で比べると False になるのです。
IEEE 754 倍精度(64 ビット)の仕組み
Python の float や JavaScript の Number は、IEEE 754 という規格の「倍精度(binary64、double)」という形式で、1 つの数を 64 ビットで持っています。64 ビットは次の 3 つに分かれています。
| 部分 | ビット数 | 役割 |
|---|---|---|
| 符号 | 1 | 0 ならプラス、1 ならマイナス |
| 指数 | 11 | 2 の何乗を掛けるか(実際の値に 1023 を足して保存) |
| 仮数 | 52 | 「1.xxxx」の小数点以下の部分(先頭の 1 は保存しないので、実質 53 ビットの精度) |
考え方は「1.2345 × 103」のような指数表記と同じで、それを 2 進数で行っています。値は「(-1)符号 × 1.仮数 × 2指数 – 1023」で求められます。
0.1 のビットを表示する
Python の struct モジュールを使うと、float を 8 バイト(64 ビット)のデータに変換して中身を見られます。”>d” は「ビッグエンディアン(上位のバイトから並べる)の倍精度」という指定です。
import struct
data = struct.pack(">d", 0.1)
print(data.hex())
bits = format(int.from_bytes(data, "big"), "064b")
print(bits[0], bits[1:12], bits[12:])
実行すると、16 進数と、符号・指数・仮数に分けた 2 進数が表示されます。
3fb999999999999a
0 01111111011 1001100110011001100110011001100110011001100110011010
- 符号は 0 なのでプラス
- 指数 01111111011 は 10 進数で 1019。1019 – 1023 = -4 なので「× 2-4」
- 仮数は「1001」のくり返しで、最後だけ「…1010」になっている。続きの「1001…」を切り捨てずに丸めて繰り上げた跡で、このせいで 0.1 より少しだけ大きくなる

16 進数の 3FB999999999999A と 2 進数の対応は、「基数変換ツール」の 16 進数の欄に貼り付けると確かめられます(先頭の 0 は表示されないので 62 桁になります)。16 進数 1 桁が 2 進数 4 桁に対応する仕組みは「2進数・16進数の基本」で解説しています。
float.hex() で最後の 1 ビットの違いを見る
float.hex() を使うと、保存されている値を「1.仮数(16 進数)p 指数(2 の何乗か)」の形で表示できます。0.1 + 0.2 と 0.3 を並べてみましょう。
for x in [0.1, 0.2, 0.3, 0.1 + 0.2]:
print(x, x.hex())
0.1 0x1.999999999999ap-4
0.2 0x1.999999999999ap-3
0.3 0x1.3333333333333p-2
0.30000000000000004 0x1.3333333333334p-2
0.3 と 0.1 + 0.2 は、仮数の最後の 1 桁(3 と 4)だけが違います。2 進数でいえば最後の 1 ビットの差で、10 進数に直すと約 5.55 × 10-17 のずれです。倍精度の精度はおよそ 10 進数 15〜17 桁なので、16〜17 桁目に誤差が顔を出します。

誤差の現れ方:よくある 3 つのパターン
足し続けると誤差がたまる
1 回 1 回の誤差は小さくても、計算をくり返すとたまっていきます。0.1 を 10 回足してみます。
import math
total = 0.0
for _ in range(10):
total += 0.1
print(total, total == 1.0)
print(sum([0.1] * 10), math.fsum([0.1] * 10))
1 行目は「0.9999999999999999 False」、2 行目は「1.0 1.0」です。+= で 1 つずつ足すと誤差がたまりますが、Python 3.12 の sum() は精度の高い足し方に変わったため 1.0 になります(公式ドキュメントの sum() に「Changed in version 3.12」として書かれています)。Python 3.11 の公式チュートリアルでは sum([0.1] * 10) == 1.0 が False になる例が載っており、バージョンによって結果が変わるので、正確に足したいときは math.fsum() を使うのが確実です。
大きな数に小さな数を足すと消える
仮数は 53 ビットしかないため、桁の大きく違う数を足すと、小さい方が仮数に入りきらずに消えます。
print(1e16 + 1)
print(1e16 + 1 - 1e16)
print(1e16 - 1e16 + 1)
結果は「1e+16」「0.0」「1.0」です。1e16(1 京)に 1 を足しても 1e16 のままなので、そこから 1e16 を引くと 0.0 になります。数学では同じ式なのに、計算の順番で答えが変わるのが浮動小数点数の特徴です。(0.1 + 0.2) + 0.3 が 0.6000000000000001、0.1 + (0.2 + 0.3) が 0.6 になるのも同じ理由です。
253 を超える整数は正確に表せない
小数だけでなく、大きな整数も誤差の対象です。仮数が 53 ビットなので、253(9007199254740992)を超えると、すべての整数を表せなくなります。
print(2 ** 53 + 1)
print(float(2 ** 53 + 1))
Python の int は桁数に上限がないので 1 行目は「9007199254740993」ですが、float にすると「9007199254740992.0」と 1 つずれます。JavaScript の Number はすべて倍精度なので、この問題が整数でも起きます。コンソールで Number.MAX_SAFE_INTEGER を表示すると「9007199254740991」(253 – 1)で、これが安全に扱える最大の整数です。次の式は、数学的には間違いなのに true になります。
Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2
実務では、API が返す JSON の大きな ID でよく問題になります。JSON.parse(‘{“id”: 9007199254740993}’).id は 9007199254740992 になり、別の ID を指してしまいます。大きな ID は文字列で受け渡しし、計算が必要なら BigInt(2n ** 53n + 1n のように n を付ける)を使います。
対処法 1:== ではなく許容誤差で比べる
計算結果の float を == で比べるのは避けます。Python では、公式チュートリアルでも紹介されている math.isclose() を使うと「ほぼ等しいか」を判定できます。
import math
print(math.isclose(0.1 + 0.2, 0.3))
print(math.isclose(0.1 + 0.2 - 0.3, 0.0))
print(math.isclose(0.1 + 0.2 - 0.3, 0.0, abs_tol=1e-9))
結果は「True」「False」「True」です。math.isclose() は標準では相対誤差(値の大きさに対する割合、rel_tol=1e-09)で比べます。そのため、0 との比較では割合が計算できず False になります。0 に近い値と比べるときは、abs_tol(絶対誤差、差がいくつ以内なら等しいとするか)も指定しましょう。
JavaScript には isclose がないので、自分で差を比べます。Number.EPSILON(2.220446049250313e-16)は「1 と、その次に大きい倍精度の数との差」で、Math.abs(0.1 + 0.2 – 0.3) < Number.EPSILON は true になります。ただし、これは 1 前後の値でしか通用しません。1000.1 + 1000.2 と 2000.3 の差は約 2.27e-13 で、EPSILON より大きいので false になります。値の大きさに合わせて許容誤差を決めるか、桁数の決まっている計算なら次に紹介する整数化を使いましょう。
対処法 2:お金は Decimal か整数で持つ
金額のように 1 円・1 セントのずれも許されない値は、float で持たないのが原則です。方法は 2 つあります。
Decimal を使う(文字列から作る)
Python の decimal モジュールは、10 進数のまま計算します。公式ドキュメントでも、会計のように厳密な等しさが求められる用途に向いていると説明されています。注意点は、必ず文字列から作ることです。
from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))
print(Decimal(0.1) + Decimal(0.2))
0.3
True
0.3000000000000000166533453694
Decimal(0.1) は、先に float の 0.1 ができてしまい、その誤差を含んだ値をそのまま正確に Decimal にします。これでは意味がありません。Decimal(“0.1”) のように文字列で渡せば、書いたとおりの 0.1 になります。なお、Decimal と float はそのまま足せず、Decimal(“0.1”) + 0.2 は TypeError になります(うっかり混ぜるのを防いでくれます)。
整数(円・セント)で持つ
もう 1 つの方法は、いちばん小さい単位の整数で持つことです。1.15 ドルなら 115 セント、という具合です。整数の計算には誤差がないので、言語やデータベースを問わず使えます。逆に、float の金額を後から整数に直すと失敗することがあります。
print(1.15 * 100)
print(int(1.15 * 100))
print(round(1.15 * 100))
結果は「114.99999999999999」「114」「115」です。int() は小数点以下を切り捨てるので、1.15 ドルが 114 セントになってしまいます。外から受け取った金額は、文字列のまま Decimal(“1.15”) にしてから 100 倍する(結果は 115.00)か、float にした時点で round() してから整数にしましょう。消費税のように端数が出る計算は、「どの時点で、切り捨て・切り上げ・四捨五入のどれをするか」を仕様として決め、Decimal の quantize(次の章)で明示的に丸めます。
丸めの注意点:round() は「偶数丸め」
Python の round() は四捨五入ではありません。ちょうど半分のときは偶数の側に丸めます(偶数丸め、銀行丸めとも呼ばれます)。
print(round(0.5), round(1.5), round(2.5), round(3.5))
結果は「0 2 2 4」です。さらに、round(2.675, 2) が 2.68 ではなく 2.67 になるのは、偶数丸めではなく float の誤差のせいです(2.675 が実際には 2.67499999… として保存されているため。f 文字列の :.2f でも同じことが起きる点は「Pythonのf文字列(f-string)の使い方」で紹介しています)。公式ドキュメントの round() の説明にも、この例が「バグではない」と書かれています。
10 進数のとおりに四捨五入したいときは、文字列から作った Decimal の quantize() に ROUND_HALF_UP を指定します。
from decimal import Decimal, ROUND_HALF_UP
print(Decimal("2.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP))
print(Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
print(Decimal(2.675).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
結果は「3」「2.68」「2.67」です。3 行目のように float から作ると、ROUND_HALF_UP を指定しても 2.67 になります。quantize() の引数 Decimal(“0.01”) は「小数点以下 2 桁にそろえる」という意味です。rounding を省略すると、Decimal の標準設定である ROUND_HALF_EVEN(偶数丸め)が使われます。切り捨てなら ROUND_DOWN、切り上げなら ROUND_UP を指定します。
言語によって丸め方が違う点にも注意が必要です。JavaScript の Math.round(2.5) は 3 ですが、Math.round(-2.5) は -2 です(ちょうど半分のときは大きい方へ丸める)。(2.675).toFixed(2) は Python と同じく “2.67” になります。
分数のまま計算する:fractions
1/3 のように、10 進数でも割り切れない数を正確に扱いたいときは、Python の fractions モジュールが使えます。分子と分母を整数で持つので、誤差が出ません。
from fractions import Fraction
a = Fraction(1, 10) + Fraction(2, 10)
print(a, a == Fraction(3, 10))
print(Fraction(1, 3) + Fraction(1, 6))
print(Fraction(0.1))
3/10 True
1/2
3602879701896397/36028797018963968
3 行目は、float の 0.1 が実際には「3602879701896397 ÷ 255」という分数であることを示しています。Decimal と同じく、float から作ると誤差ごと取り込むので、Fraction(“0.1”) や Fraction(1, 10) のように作りましょう。比の計算や確率の計算などには便利ですが、計算するほど分母が大きくなり遅くなるので、大量のデータには向きません。
SQL の FLOAT と DECIMAL
データベースにも、浮動小数点数の型(FLOAT・REAL・DOUBLE PRECISION など)と、10 進数で正確に持つ型(DECIMAL・NUMERIC)があります。公式ドキュメントでは、次のように説明されています。
| データベース | FLOAT・DOUBLE など | DECIMAL・NUMERIC |
|---|---|---|
| MySQL 8.4 | 近似値(approximate)。比較を正確な値として扱うと問題になることがある | 正確な値を保存。お金のように正確さが大事なときに使う |
| PostgreSQL | real・double precision は不正確(inexact)。等しいかの比較は期待どおりにならないことがある | numeric は金額など正確さが必要な値におすすめ。ただし整数型や浮動小数点型より計算がとても遅い |
| SQLite | REAL は 8 バイトの IEEE 浮動小数点数 | DECIMAL(10,2) と書いても NUMERIC という扱いになり、0.1 のような値は REAL(浮動小数点数)で保存される |
SQLite の動きを Python で確かめてみます。REAL・DECIMAL(10,2)・INTEGER の 3 つの列を作り、同じ値を入れて合計します。
import sqlite3
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t (f REAL, d DECIMAL(10,2), yen INTEGER)")
con.execute("INSERT INTO t VALUES (0.1, 0.1, 10), (0.2, 0.2, 20)")
print(con.execute("SELECT sum(f), sum(d), sum(yen) FROM t").fetchone())
print(con.execute("SELECT typeof(d) FROM t").fetchone())
(0.30000000000000004, 0.30000000000000004, 30)
('real',)
SQLite では DECIMAL 列でも誤差が出ました。SQLite で金額を扱うなら、円やセントの INTEGER で持つのが安全です。MySQL や PostgreSQL では DECIMAL・NUMERIC を使えば正確に計算できます(この 2 つは手元で実行していないため、上の表は公式ドキュメントの説明に基づいています)。PostgreSQL の公式ドキュメントには、numeric はちょうど半分を 0 から遠い方へ丸め、double precision は(多くの環境で)偶数の方へ丸める、と型によって round() の結果が変わることも書かれています。データの登録・更新の書き方は「SQLのINSERT・UPDATE・DELETEとトランザクション入門」で解説しています。
よくある間違い・落とし穴
ループの終了条件に float の == を使う
「while x != 1.0: x += 0.1」は、x がちょうど 1.0 にならないため止まらず、無限ループになります(試すときは回数の上限を付けてください)。< を使っても、回数がずれることがあります。
x = 0.0
count = 0
while x < 1.0:
x += 0.1
count += 1
print(count, x)
結果は「11 1.0999999999999999」で、10 回のつもりが 11 回回っています。10 回目の x が 0.9999999999999999 で、まだ 1.0 より小さいからです。回数が決まっているなら for i in range(10) のように整数で数え、値は i * 0.1 や i / 10 で計算しましょう。
表示を丸めただけで、中身も直ったと思う
f”{0.1 + 0.2:.2f}” は「0.30」と表示されますが、変数の中身は 0.30000000000000004 のままです。PowerShell が「0.3」と表示するのも同じです。表示の丸めは見た目だけなので、比較や次の計算には影響しません。
Decimal(0.1) や Fraction(0.1) と書く
float を渡すと、誤差ごと正確に取り込まれます。Decimal も Fraction も、小数は文字列で渡すのが基本です。すでに float になっている値を変換するしかない場合は、Decimal(str(x)) とすると、表示どおりの「0.1」になります。
int() で切り捨てて 1 ずれる
int(1.15 * 100) が 114 になるように、float の計算結果は「ほんの少し小さい」ことがあり、int() で切り捨てると 1 ずれます。0.29 * 100 も 28.999999999999996 で、int() すると 28 です。整数に直すときは round() を使うか、最初から Decimal・整数で計算します。
よくある質問
言語やパソコンの不具合ではないのですか?
不具合ではありません。Python・JavaScript・Java・C など多くの言語が同じ IEEE 754 倍精度を使っているので、同じ値になります。Python の公式チュートリアルにも、2000 年ごろ以降のほとんどのマシンが IEEE 754 を使い、Python の float はほぼすべての環境で倍精度に対応すると書かれています。
float はいつも使ってはいけないのですか?
そんなことはありません。測定値・座標・割合・統計など、もともと誤差を含む値や、多少の誤差が問題にならない計算には float が向いています。Decimal や Fraction より計算もずっと速いです。気をつけるのは「== で比べるとき」「お金のように 1 単位のずれも許されないとき」「大きな整数を扱うとき」の 3 つです。
単精度(float32)だとどうなりますか?
32 ビットの単精度は仮数が 23 ビットしかないため、誤差がもっと大きくなります。Python で struct.unpack(“<f”, struct.pack(“<f”, 0.1))[0] と単精度を経由させると、0.10000000149011612 になり、8 桁目で早くもずれます。C の float や、データベースの単精度の型(PostgreSQL の real など)を使うときは、精度が 6〜7 桁程度しかないことを意識しましょう。
まとめ
0.1 は 2 進数で割り切れないため、64 ビットの倍精度では近い値に丸めて保存され、0.1 + 0.2 が 0.30000000000000004 になります。float は == で比べず math.isclose や許容誤差で比べる、お金は文字列から作った Decimal か整数で持つ、四捨五入は Decimal の quantize で明示する、の 3 つを押さえておけば、ほとんどの場面で困りません。
関連する記事・ツール
- 基数変換ツール(2 進数・8 進数・10 進数・16 進数の相互変換、2 の補数対応)
- 2進数・16進数の基本|0xFF・カラーコード・IPアドレスなど仕事で出会う場面を解説
- ビット演算の基本と実用例|AND・OR・XOR・シフトとフラグ・マスクの使い方
- Pythonのf文字列(f-string)の使い方|書式指定・桁区切り・ゼロ埋めを実例で解説
- SQLのINSERT・UPDATE・DELETEとトランザクション入門|実行結果で解説
- Pythonのテスト入門|unittestとpytestの書き方・実行方法を実例で比較
- PythonのDecimalでお金を正確に計算する方法|quantize・丸め・prec