Pythonで小数点以下を切り捨てたい！初心者向けに解説 – 正確な計算のための徹底ガイド
Pythonプログラミングを始めたばかりの皆さん、こんにちは！プログラミング学習は楽しい一方で、時には「あれ？思った通りの計算結果にならないぞ？」と首をかしげることもありますよね。特に数値計算においては、小数点以下の扱いで戸惑うことが多いかもしれません。
例えば、割り算の結果や、何らかの計算で得られた浮動小数点数から、小数点以下の部分を取り除いて整数だけを使いたい、という場面は頻繁に登場します。この記事は、そんな「小数点以下を切り捨てたい！」というあなたの疑問に、Pythonの基本的な機能から応用的な方法まで、分かりやすく、そして徹底的に解説するものです。
この記事を最後まで読めば、Pythonで小数点以下を切り捨てる様々な方法を理解し、あなたの目的に最適な方法を選べるようになります。さあ、一緒にPythonでの数値計算マスターへの第一歩を踏み出しましょう！
1. はじめに：なぜ小数点以下を切り捨てる必要があるのか？
日常生活やプログラミングの世界では、小数点以下を切り捨てたい状況が数多く存在します。いくつか例を見てみましょう。
- 商品の個数や人数: 買い物をしたとき、商品の個数は必ず整数ですよね。「リンゴを2.5個ください」とは言いません。ある合計金額から購入できる個数を計算する場合、割り算の結果に小数点以下が出たとしても、商品の個数は整数にしなければなりません。例えば、1個150円の商品を500円分買えるだけ買う場合、500 ÷ 150 ≒ 3.33… となりますが、買えるのは3個です。この0.33…の部分は切り捨てられます。
- 消費税の計算: 商品価格に税率をかけた結果、小数点以下の金額が出ることがあります。多くの場合は小数点以下を切り捨てたり、四捨五入したりして、最終的な金額を求めます。切り捨てがルールとして定められている場合もあります。
- プログラミングでのインデックスや個数: リストや配列の要素数を数えたり、ループ処理の回数を決めたりする場合、多くは整数が必要です。計算結果が浮動小数点数になった場合でも、それを整数のインデックスや回数に変換する必要があります。
- ページの表示件数: Webサイトで検索結果を表示する際に、「1ページに10件表示」という設定があるとします。全件数が123件の場合、必要なページ数は 123 ÷ 10 = 12.3 となりますが、ページ数は13ページ必要です（最後のページは3件だけですが、1ページとして数えます）。これは小数点以下を「切り上げ」る例ですが、反対に「123件を10件ずつに分けるとき、完全に表示できるページは何ページか？」と考える場合は、123 ÷ 10 の結果から小数点以下を「切り捨て」て12ページ、となります。
- 時間の計算: 例えば、合計秒数を分や時間に変換する場合、小数点以下を切り捨てて「何分ぴったり」や「何時間ぴったり」という値を得たいことがあります。
このように、小数点以下を無視して整数部分だけが必要になる場面は非常に多いのです。
Pythonでは、数値を扱う際に主に「整数 (int)」と「浮動小数点数 (float)」という型を使います。
- 整数 (int): -2, -1, 0, 1, 2, … のように、小数点以下の部分を持たない数値です。
- 浮動小数点数 (float): 3.14, -0.5, 2.0 のように、小数点以下の部分を持つ可能性のある数値です。コンピュータ内部では特定の形式（IEEE 754など）で表現されます。
Pythonでは、割り算（/ 演算子）の結果は基本的に浮動小数点数になります。また、計算の過程で浮動小数点数が生じることもあります。これらの浮動小数点数から小数点以下を取り除き、整数として扱いたい場合に、「切り捨て」の操作が必要になります。
ただし、「切り捨て」という言葉は、文脈によっていくつかの意味で使われることがあります。
- 小数点以下を単純に取り除く（ゼロ方向への丸め）: 例えば、3.7 を切り捨てて 3、-3.7 を切り捨てて -3 のように、常に絶対値が小さくなるように整数にすること。Pythonの
int()関数やmath.trunc()関数がこれに該当します。 - 常に小さい方の整数にする（負の無限大方向への丸め、床関数）: 例えば、3.7 を切り捨てて 3、-3.7 を切り捨てて -4 のように、常に数直線上を左に進んだ最も近い整数にすること。Pythonの
math.floor()関数や整数除算演算子//がこれに該当します。
このように、正の数と負の数で「切り捨て」の意味合いが変わってくることに注意が必要です。この記事では、これらの違いを明確にしながら、Pythonでの具体的な方法を解説していきます。
2. Pythonの数値型と「切り捨て」の基本
Pythonは、数値計算に関して非常に強力で使いやすい言語です。しかし、浮動小数点数を扱う際には、知っておくべきことがあります。それは、「浮動小数点数の精度問題」です。
ほとんどのプログラミング言語で使われている浮動小数点数の形式（IEEE 754）では、一部の小数を正確に表現することができません。例えば、0.1 という数値は、コンピュータの内部では2進数で表現されますが、2進数では 0.1 を正確に表現できず、わずかに誤差が生じます。これは、1/3 を10進数で 0.333… と無限小数でしか表現できないのと似ています。
この誤差は非常に小さいものですが、計算を繰り返したり、特定の値を比較したりする際に、予期しない結果を引き起こすことがあります。例えば：
“`python
print(0.1 + 0.2)
実行結果: 0.30000000000000004
print(0.1 + 0.2 == 0.3)
実行結果: False
“`
見ての通り、0.1 + 0.2 の計算結果は厳密には 0.3 ではなく、わずかな誤差を含んでいます。この誤差は、切り捨て操作にも影響を与える可能性があります。例えば、3.9999999999999996 のような数値に対して切り捨てを行う場合、期待通りの 3 になることもあれば、誤差の影響で異なる挙動を示す可能性もゼロではありません（ただし、Pythonの組み込み関数はこれらの誤差を考慮して設計されていることが多いですが、理解しておくことは重要です）。
このような精度問題が許されない、特に金融計算のように厳密な端数処理が必要な場面では、後述する decimal モジュールを使うことが推奨されます。
一方で、一般的な用途であれば、Pythonの組み込み機能や math モジュールの関数で十分な場合がほとんどです。
Pythonで小数点以下を切り捨てる主な方法は以下の通りです。
int()関数: 組み込み関数。最も手軽。math.floor()関数:mathモジュール。数学的な床関数。math.trunc()関数:mathモジュール。ゼロ方向への切り捨て。//演算子: 整数除算。割り算に特化。decimalモジュール: 精度の高い計算が可能。
これらの方法について、それぞれ詳しく見ていきましょう。
3. 最も手軽な方法：int() 関数を使う
Pythonで最も簡単に小数点以下を切り捨てる方法は、組み込み関数である int() を使うことです。
int() 関数の基本的な使い方
int() 関数は、様々な型の値を整数に変換するために使われます。文字列を整数に変換したり、浮動小数点数を整数に変換したりできます。浮動小数点数を int() 関数で整数に変換する場合、小数点以下の部分が単純に切り捨てられます。これは「ゼロ方向への丸め」と呼ばれます。つまり、数値が正であれば小数点以下を切り捨て、負であれば小数点以下を切り上げて、ゼロに近い方の整数にします。
“`python
int() 関数の基本的な使い方
positive_float = 3.7
negative_float = -3.7
int() で小数点以下を切り捨て
int_positive = int(positive_float)
int_negative = int(negative_float)
print(f”{positive_float} を int() で切り捨てると: {int_positive}”)
print(f”{negative_float} を int() で切り捨てると: {int_negative}”)
“`
実行結果：
3.7 を int() で切り捨てると: 3
-3.7 を int() で切り捨てると: -3
正の数 3.7 は 3 に、負の数 -3.7 は -3 になりました。どちらも、元の数値よりも絶対値が小さくなっています。これは、数値がゼロに近づく方向に丸められているためです。
正の数での挙動
正の浮動小数点数に対して int() を使うと、小数点以下の桁が完全に削除されます。
python
print(int(5.9))
print(int(10.0)) # 小数点以下がゼロでもfloat型なら有効
print(int(0.1))
実行結果：
5
10
0
小数点以下の値がどれだけ大きくても（例: 5.9）、単に切り捨てられます。整数部分がゼロの場合（例: 0.1）も同様です。
負の数での挙動：ゼロ方向への丸め
負の浮動小数点数に対する int() の挙動は、正の数とは少し感覚が異なるかもしれません。int() は「ゼロ方向への丸め」を行うため、負の数の場合は小数点以下を「切り上げて」ゼロに近い整数にします。
例えば、数直線上で考えてみましょう。
-3.7 は -4 と -3 の間にあります。ゼロに近いのは -3 です。
int(-3.7) は -3 になります。
-3.1 も同様に、-4 と -3 の間にありますが、ゼロに近いのは -3 です。
int(-3.1) は -3 になります。
python
print(int(-1.1))
print(int(-5.9))
print(int(-10.0))
print(int(-0.1))
実行結果：
-1
-5
-10
0
このように、負の数に対して int() を使うと、小数点以下の値が0でなければ、元の数値よりも値が大きくなります（例えば、-3.7 は -3 より小さい値ですが、int() の結果は -3 というより大きい値になります）。これは、「常に小さい方の整数にする」という切り捨て（後述の math.floor）とは異なる挙動です。
文字列からの変換と数値からの変換
int() 関数は、数値型（intやfloat）だけでなく、数値を表す文字列も整数に変換できます。ただし、浮動小数点数を表す文字列（例: “3.7”）を int() に直接渡すとエラーになります。小数点以下を含む文字列を整数に変換したい場合は、一度 float() で浮動小数点数に変換してから int() に渡す必要があります。
“`python
整数を表す文字列
print(int(“100”))
小数点以下を含む文字列 (エラーになる例)
print(int(“3.7”)) # <- これを実行すると ValueError
小数点以下を含む文字列を変換する場合
print(int(float(“3.7”)))
print(int(float(“-5.2”)))
“`
実行結果：
100
3
-5
int() の利点と注意点
利点:
- Pythonの組み込み関数であり、追加のモジュールをインポートする必要がないため、最も手軽に使えます。
- 構文がシンプルで分かりやすいです。
- 正の数に対しては、直感的な「小数点以下切り捨て」として機能します。
注意点:
- 負の数に対しては「ゼロ方向への丸め」となり、数学的な「床関数」（常に小さい方の整数にする）とは挙動が異なります。負の数を扱う場合は、期待する結果と一致するか確認が必要です。
- 小数点以下を含む文字列を直接変換しようとするとエラーになります。
- 浮動小数点数の精度問題の影響を完全に回避できるわけではありません（ただし、ほとんどの場合は期待通りに動作します）。
コード例
簡単な例をいくつか示します。
“`python
例1: 標準的な切り捨て (正の数)
price = 123.45
integer_price = int(price)
print(f”価格 {price} の整数部分は {integer_price} です。”)
例2: 負の数での int() の挙動
temperature = -7.8
integer_temp = int(temperature)
print(f”温度 {temperature} を int() で変換すると {integer_temp} です。”) # -7 になる
例3: ゼロに近い数値
small_positive = 0.99
small_negative = -0.01
print(f”{small_positive} を int() で変換すると {int(small_positive)} です。”)
print(f”{small_negative} を int() で変換すると {int(small_negative)} です。”)
例4: 文字列からの変換
str_num = “98.6”
int(str_num) はエラー
int_from_str = int(float(str_num))
print(f”文字列 ‘{str_num}’ を int() で変換すると {int_from_str} です。”)
“`
実行結果：
価格 123.45 の整数部分は 123 です。
温度 -7.8 を int() で変換すると -7 です。
0.99 を int() で変換すると 0 です。
-0.01 を int() で変換すると 0 です。
文字列 '98.6' を int() で変換すると 98 です。
int() 関数は非常に便利ですが、特に負の数を扱う際には、その挙動（ゼロ方向への丸め）をしっかり理解しておくことが重要です。
4. 数学的な「床関数」：math.floor() を使う
数学やプログラミングにおいて、「床関数 (floor function)」は非常に一般的な概念です。床関数は、ある実数に対して、それ以下の最大の整数を返します。Pythonでは、math モジュールにある floor() 関数がこの機能を提供します。
math モジュールのインポート
floor() 関数を使うには、まず math モジュールをインポートする必要があります。
python
import math
この1行をコードの先頭に書くことで、math モジュールに含まれる様々な数学関数（三角関数、対数関数、平方根など）と合わせて floor() 関数も使えるようになります。
math.floor() の基本的な使い方
math.floor(x) は、引数 x 以下の最大の整数（床関数）を返します。戻り値は浮動小数点数（float型）になりますが、値としては常に整数です。
“`python
import math
positive_float = 3.7
negative_float = -3.7
math.floor() で床関数を計算
floor_positive = math.floor(positive_float)
floor_negative = math.floor(negative_float)
print(f”{positive_float} の床関数は: {floor_positive} (型: {type(floor_positive)})”)
print(f”{negative_float} の床関数は: {floor_negative} (型: {type(floor_negative)})”)
“`
実行結果：
3.7 の床関数は: 3.0 (型: <class 'float'>)
-3.7 の床関数は: -4.0 (型: <class 'float'>)
正の数 3.7 に対しては 3.0 が返されました。これは int(3.7) と同じ結果ですが、型は float です。
負の数 -3.7 に対しては -4.0 が返されました。これは int(-3.7) の -3 とは異なる結果です。math.floor() は、常に「元の数値以下の最も大きい整数」を返すため、負の数の場合はより小さい方向（負の無限大方向）に丸められます。
正の数での挙動
正の浮動小数点数に対して math.floor() を使うと、小数点以下の桁が切り捨てられた整数部分が得られます。これは int() と同じ結果になります。
“`python
import math
print(math.floor(5.9))
print(math.floor(10.0))
print(math.floor(0.1))
“`
実行結果：
5.0
10.0
0.0
結果の型が float である点に注意してください。もし厳密に整数型 (int) が欲しい場合は、さらに int() 関数で変換する必要があります (int(math.floor(x)))。ただし、Pythonでは float 型であっても値が整数であれば、多くの場面で int 型と同様に扱うことができます。
負の数での挙動：負の無限大方向への丸め
math.floor() の最大の特徴は、負の数に対する挙動です。床関数は「元の数値以下の最大の整数」なので、負の数の場合は数直線上を左方向（負の無限大方向）に進んで見つかる最初の整数を返します。
例えば、数直線上で考えてみましょう。
-3.7 は -4 と -3 の間にあります。-3.7 以下の最大の整数は -4 です。
math.floor(-3.7) は -4.0 になります。
-3.1 は -4 と -3 の間にありますが、-3.1 以下の最大の整数は -4 です。
math.floor(-3.1) は -4.0 になります。
“`python
import math
print(math.floor(-1.1))
print(math.floor(-5.9))
print(math.floor(-10.0))
print(math.floor(-0.1))
“`
実行結果：
-2.0
-6.0
-10.0
-1.0
負の数に対して math.floor() を使うと、元の数値よりも値が小さくなります（例えば、-3.7 は -4.0 より大きい値ですが、math.floor() の結果は -4.0 というより小さい値になります）。
int() と math.floor() の違いを徹底比較
ここで、int() と math.floor() の違いを明確に比較しておきましょう。最も重要な違いは、負の数に対する挙動です。
| 特徴 | int(x) |
math.floor(x) |
|---|---|---|
| 基本的な考え方 | ゼロ方向への丸め（小数点以下切り捨て） | 元の数値以下の最大の整数（床関数） |
| 正の数 (x > 0) | 小数点以下を切り捨てる (例: 3.7 → 3) | 小数点以下を切り捨てる (例: 3.7 → 3.0) |
| 負の数 (x < 0) | ゼロ方向へ丸める (例: -3.7 → -3) | 負の無限大方向へ丸める (例: -3.7 → -4.0) |
| 結果の型 | 整数 (int) |
浮動小数点数 (float) |
| 利用方法 | 組み込み関数 | math モジュールをインポートが必要 |
| 適用対象 | 数値、数値を表す文字列 (float経由) | 数値 |
具体的な比較例:
“`python
import math
value1 = 3.7
value2 = -3.7
value3 = 3.0
value4 = -3.0
print(f”— int() と math.floor() の比較 —“)
print(f”数値: {value1}”)
print(f” int({value1}) 結果: {int(value1)}, 型: {type(int(value1))}”)
print(f” math.floor({value1}) 結果: {math.floor(value1)}, 型: {type(math.floor(value1))}”)
print(“-” * 20)
print(f”数値: {value2}”)
print(f” int({value2}) 結果: {int(value2)}, 型: {type(int(value2))}”)
print(f” math.floor({value2}) 結果: {math.floor(value2)}, 型: {type(math.floor(value2))}”)
print(“-” * 20)
print(f”数値: {value3}”)
print(f” int({value3}) 結果: {int(value3)}, 型: {type(int(value3))}”)
print(f” math.floor({value3}) 結果: {math.floor(value3)}, 型: {type(math.floor(value3))}”)
print(“-” * 20)
print(f”数値: {value4}”)
print(f” int({value4}) 結果: {int(value4)}, 型: {type(int(value4))}”)
print(f” math.floor({value4}) 結果: {math.floor(value4)}, 型: {type(math.floor(value4))}”)
print(“-” * 20)
“`
実行結果：
“`
— int() と math.floor() の比較 —
数値: 3.7
int(3.7) 結果: 3, 型:
math.floor(3.7) 結果: 3.0, 型:
数値: -3.7
int(-3.7) 結果: -3, 型:
math.floor(-3.7) 結果: -4.0, 型:
数値: 3.0
int(3.0) 結果: 3, 型:
math.floor(3.0) 結果: 3.0, 型:
数値: -3.0
int(-3.0) 結果: -3, 型:
math.floor(-3.0) 結果: -3.0, 型:
“`
この比較から分かるように、正の数やちょうど整数の場合は int(x) と math.floor(x) は（型の違いを除けば）同じ結果になりますが、負の数の場合は結果が異なります。あなたが求める「切り捨て」が、負の数に対しても常に小さい方の整数にする必要があるのか、それともゼロに近い整数にする必要があるのかによって、適切な関数を選択する必要があります。
数学的な意味での「床関数」が必要な場合、あるいは負の数に対しても常に小さい方の整数にしたい場合は、math.floor() を使いましょう。
math.floor() の利点と注意点
利点:
- 数学的な定義に基づく「床関数」を正確に実行します。
- 負の数に対しても一貫して「常に小さい方の整数にする」という挙動をします。
- 浮動小数点数の精度問題の影響を受けにくいように設計されています。
注意点:
mathモジュールをインポートする必要があります。- 戻り値が浮動小数点数 (
float) になるため、厳密に整数 (int) が必要な場合はさらにint()で変換が必要です。
コード例
いくつかの応用的な例です。
“`python
import math
例1: 負の数の floor() の挙動を理解する
ユーザーからの入力が負の浮動小数点数だった場合などを想定
user_input_temp = -10.5
floor_temp = math.floor(user_input_temp)
int_temp = int(user_input_temp) # int() と比較
print(f”入力温度: {user_input_temp}”)
print(f” math.floor() で切り捨て: {floor_temp}”) # -11.0 になる
print(f” int() で切り捨て: {int_temp}”) # -10 になる
例2: float型で結果が必要な場合
後続の計算でfloat型が都合が良い場合など
calculated_value = 15.8
processed_value = math.floor(calculated_value) / 2.0 # 例として floor の結果を割る
print(f”計算値 {calculated_value} を floor して 2で割ると: {processed_value}”) # 7.5 になる (8.0 / 2.0 = 4.0 ではない)
例3: floatの結果を int に変換する必要がある場合
number_of_items = 50.1 / 10
50.1 / 10 = 5.01
完全に詰め込める箱の数を計算する場合など (math.floorが必要なケース)
full_boxes_float = math.floor(number_of_items)
full_boxes_int = int(math.floor(number_of_items)) # int型に変換
print(f”アイテム数 / 10: {number_of_items}”)
print(f” math.floor(): {full_boxes_float} (型: {type(full_boxes_float)})”)
print(f” int(math.floor()): {full_boxes_int} (型: {type(full_boxes_int)})”)
“`
実行結果：
入力温度: -10.5
math.floor() で切り捨て: -11.0
int() で切り捨て: -10
計算値 15.8 を floor して 2で割ると: 7.5
アイテム数 / 10: 5.01
math.floor(): 5.0 (型: <class 'float'>)
int(math.floor()): 5 (型: <class 'int'>)
math.floor() は、数学的な床関数が必要な場合や、負の数に対しても常に「より小さい整数」へ丸めたい場合に非常に役立ちます。
5. ゼロ方向への切り捨てを明示的に行う：math.trunc() を使う
Python 3.2 以降では、math モジュールに trunc() という関数が追加されました。この関数は、数値の小数点以下の部分を単純に切り捨てて、ゼロ方向への最も近い整数を返します。これは、int() 関数が浮動小数点数に対して行う切り捨てと同じ挙動です。
math.trunc() の基本的な使い方
math.trunc(x) は、引数 x の小数点以下を切り捨てた整数部分を返します。戻り値は整数 (int) または浮動小数点数 (float) になりますが、値としては常に整数です。
“`python
import math
positive_float = 3.7
negative_float = -3.7
math.trunc() で小数点以下を切り捨て
trunc_positive = math.trunc(positive_float)
trunc_negative = math.trunc(negative_float)
print(f”{positive_float} を math.trunc() で切り捨てると: {trunc_positive} (型: {type(trunc_positive)})”)
print(f”{negative_float} を math.trunc() で切り捨てると: {trunc_negative} (型: {type(trunc_negative)})”)
“`
実行結果：
3.7 を math.trunc() で切り捨てると: 3 (型: <class 'int'>)
-3.7 を math.trunc() で切り捨てると: -3 (型: <class 'int'>)
正の数 3.7 は 3 に、負の数 -3.7 は -3 になりました。これは int() 関数を使った場合と全く同じ結果、そして同じ型 (int) です。
int() と math.trunc() の関係
ご覧の通り、浮動小数点数に対して int() と math.trunc() は同じ結果を返します。では、なぜ trunc() が存在するのでしょうか？
主な理由としては、以下の点が考えられます。
- 意図の明確化:
math.trunc()を使うことで、「小数点以下を単純に切り捨てて、ゼロ方向への最も近い整数を得たい」という意図をコード上でより明確に表現できます。int()は型変換全般に使われるため、浮動小数点数の切り捨て目的でmath.trunc()を使う方が、その意図が伝わりやすい場合があります。 int()の多機能性:int()は浮動小数点数だけでなく、文字列など他の型の値を整数に変換する機能も持っています。math.trunc()は数値（整数または浮動小数点数）に対してのみ機能し、その目的は純粋に小数点以下の切り捨て（ゼロ方向への丸め）に特化しています。- 抽象基底クラスとの関連: Pythonの数値型の内部的な仕組みに関わりますが、
math.trunc()は__trunc__()という特殊メソッドを呼び出します。これは、カスタムクラスで独自の切り捨てロジックを定義する際に利用できます。一方、int()はオブジェクトの__int__()メソッドや__trunc__()メソッドを呼び出します。
初心者にとっては、int() と math.trunc() の違いはそれほど大きくありません。浮動小数点数の小数点以下をゼロ方向へ切り捨てたい場合は、どちらを使っても構いません。手軽さでは int() に軍配が上がりますが、意図を明確にしたい場合は math.trunc() を選ぶのも良いでしょう。
正の数、負の数での挙動
math.trunc() は、正の数でも負の数でも、小数点以下の部分を単純に取り除きます。
“`python
import math
print(math.trunc(5.9))
print(math.trunc(10.0))
print(math.trunc(0.1))
print(math.trunc(-1.1))
print(math.trunc(-5.9))
print(math.trunc(-10.0))
print(math.trunc(-0.1))
“`
実行結果：
5
10
0
-1
-5
-10
0
これらの結果は、すべて int() 関数を使った場合と同じです。
math.trunc() の利点と注意点
利点:
- 小数点以下の切り捨て（ゼロ方向への丸め）という目的がコード上で明確になります。
- 戻り値が
int型になります（入力がfloat型の場合）。
注意点:
mathモジュールをインポートする必要があります。int()関数と同じく、負の数に対しては「ゼロ方向への丸め」となります。
コード例
“`python
import math
例1: int() と math.trunc() が同じ結果を返すことを確認
value = -15.3
int_result = int(value)
trunc_result = math.trunc(value)
print(f”数値: {value}”)
print(f” int() の結果: {int_result} (型: {type(int_result)})”)
print(f” math.trunc() の結果: {trunc_result} (型: {type(trunc_result)})”)
print(f”結果は同じか? {int_result == trunc_result}”)
例2: 正の数での使用
pi_value = 3.1415926535
truncated_pi = math.trunc(pi_value)
print(f”円周率 {pi_value} を trunc() で切り捨てると: {truncated_pi}”)
“`
実行結果：
数値: -15.3
int() の結果: -15 (型: <class 'int'>)
math.trunc() の結果: -15 (型: <class 'int'>)
結果は同じか? True
円周率 3.1415926535 を trunc() で切り捨てると: 3
math.trunc() は int() とほぼ同じ挙動をするため、どちらを使うかはコーディングスタイルや意図の明確さに応じて選択すると良いでしょう。
6. 割り算の結果を切り捨てる：整数除算演算子 // を使う
Pythonには、割り算の結果が必ず整数になる特殊な演算子があります。それが「整数除算演算子 //」です。この演算子は、割り算を行った後、小数点以下を切り捨てるという処理を同時に行います。
// 演算子の基本的な使い方
a // b という形で使います。これは「a を b で割って、小数点以下を切り捨てた結果」を意味します。結果は常に整数（int）になります。
“`python
整数除算演算子 // の基本的な使い方
dividend1 = 10
divisor1 = 3
dividend2 = -10
divisor2 = 3
dividend3 = 10.5
divisor3 = 3.0
// 演算子で整数除算
result1 = dividend1 // divisor1
result2 = dividend2 // divisor2
result3 = dividend3 // divisor3 # 浮動小数点数同士でも使える
print(f”{dividend1} // {divisor1} の結果: {result1} (型: {type(result1)})”)
print(f”{dividend2} // {divisor2} の結果: {result2} (型: {type(result2)})”)
print(f”{dividend3} // {divisor3} の結果: {result3} (型: {type(result3)})”)
“`
実行結果：
10 // 3 の結果: 3 (型: <class 'int'>)
-10 // 3 の結果: -4 (型: <class 'int'>)
10.5 // 3.0 の結果: 3.0 (型: <class 'float'>)
10 // 3 は、10 / 3 が 3.33... なので、小数点以下を切り捨てて 3 になります。
-10 // 3 は、-10 / 3 が -3.33... なので、小数点以下を切り捨てて -4 になります。
10.5 // 3.0 は、10.5 / 3.0 が 3.5 なので、小数点以下を切り捨てて 3.0 になります。
正の数、負の数での挙動：math.floor() と同じ
// 演算子による整数除算は、結果の小数点以下を切り捨てる際に、math.floor() と同じく「常に小さい方の整数（負の無限大方向）へ丸める」という挙動をします。
これは、割り算の定義に基づいています。a = (a // b) * b + (a % b) という関係が成り立ち、ここで a % b は剰余（あまり）を表します。Pythonの剰余演算子 % は、結果の符号が割る数 b と一致するか、あるいはゼロになるように定義されています。この定義を満たすためには、// 演算子の結果は math.floor(a / b) と同じになる必要があるのです。
“`python
import math
// 演算子と math.floor() の比較
value1 = 10 / 3 # 約 3.33
value2 = -10 / 3 # 約 -3.33
print(f”10 / 3 = {value1}”)
print(f” 10 // 3 = {10 // 3}”)
print(f” math.floor(10 / 3) = {math.floor(10 / 3)}”)
print(f”-10 / 3 = {value2}”)
print(f” -10 // 3 = {-10 // 3}”)
print(f” math.floor(-10 / 3) = {math.floor(-10 / 3)}”)
“`
実行結果：
10 / 3 = 3.3333333333333335
10 // 3 = 3
math.floor(10 / 3) = 3.0
-10 / 3 = -3.3333333333333335
-10 // 3 = -4
math.floor(-10 / 3) = -4.0
このように、// 演算子は math.floor(a / b) と同じ結果（ただし型は int または float）になります。負の数を割る場合は、結果がより小さい整数になることに注意が必要です。
通常の除算 / との違い
通常の除算演算子 / は、常に浮動小数点数 (float) を返します。
python
print(10 / 3)
print(-10 / 3)
print(9 / 3) # 割り切れる場合でもfloat
実行結果：
3.3333333333333335
-3.3333333333333335
3.0
// 演算子は、割り算と小数点以下切り捨て（floor方向）を一度に行うための演算子です。結果の型は、オペランド（割られる数と割る数）が両方整数であれば int、いずれか一方でも浮動小数点数であれば float になります（ただし、値は常に整数部分のみ）。
// の利点と注意点
利点:
- 割り算の結果をすぐに整数として得たい場合に非常に簡潔に記述できます。
- パフォーマンスが良い場合があります（特に整数同士の割り算）。
- 数学的な床関数としての切り捨て（負の無限大方向）を行います。
注意点:
- 割り算にしか使えません。既に浮動小数点数として存在する変数に対して小数点以下を切り捨てたい場合は、
int(),math.floor(),math.trunc()などを利用する必要があります。 - 負の数に対しては
math.floor()と同じく負の無限大方向への丸めとなるため、ゼロ方向への丸めが必要な場合はint()やmath.trunc()を使う必要があります。
コード例
“`python
例1: ページ数を計算する（切り捨て）
total_items = 100
items_per_page = 12
100 // 12 = 8.33… -> 8
complete_pages = total_items // items_per_page
print(f”全 {total_items} 件を 1ページ {items_per_page} 件で表示する場合、完全に表示できるのは {complete_pages} ページです。”)
例2: 時間計算 (秒を分に変換して切り捨て)
total_seconds = 250
250 // 60 = 4.16… -> 4
complete_minutes = total_seconds // 60
print(f”{total_seconds} 秒は {complete_minutes} 分です (小数点以下切り捨て)。”)
例3: 負の数を含む整数除算
score_deduction = -50
penalties = 3
-50 // 3 = -16.66… -> -17 (floor方向)
deduction_per_penalty = score_deduction // penalties
print(f”合計 {score_deduction} 点の減点を {penalties} 人で均等に分けると、一人あたり {deduction_per_penalty} 点の減点です (// 演算子)。”)
もし int() で計算したら -50 / 3 -> -16.66… -> int(-16.66…) -> -16
print(f” int({score_deduction / penalties}) の結果: {int(score_deduction / penalties)}”)
“`
実行結果：
全 100 件を 1ページ 12 件で表示する場合、完全に表示できるのは 8 ページです。
250 秒は 4 分です (小数点以下切り捨て)。
合計 -50 点の減点を 3 人で均等に分けると、一人あたり -17 点の減点です (// 演算子)。
int(-16.666666666666668) の結果: -16
整数除算 // は、割り算の結果をすぐに整数にしたい場合に非常に便利で、負の数の挙動は math.floor() と同じになります。
7. 正確な計算が求められる場面で：decimal モジュールを使う
これまでの方法、特に int() や math.floor() は、ほとんどの場合で期待通りに動作します。しかし、前述の「浮動小数点数の精度問題」がどうしても許容できない、例えば金融計算のように厳密な端数処理が必要な場面では、標準の浮動小数点数 float を使うべきではありません。
このような場合に役立つのが、Pythonの標準ライブラリに含まれる decimal モジュールです。decimal モジュールは、十進数による正確な計算を提供します。
なぜ decimal が必要なのか？浮動小数点数の限界
改めて、浮動小数点数 float の問題を考えてみましょう。コンピュータは数を2進数で扱いますが、10進数の小数を正確な2進数で表現できない場合があります（例: 0.1, 0.2）。これにより、計算にわずかな誤差が生じます。
“`python
print(0.1 + 0.1 + 0.1 – 0.3)
実行結果: 5.551115123125783e-17 (非常に小さいがゼロではない誤差)
“`
このような誤差は、単に値を表示するだけなら問題にならないことが多いですが、計算を重ねたり、特定の丸め処理を行ったり、金額を扱ったりする際には、重大な問題を引き起こす可能性があります。
decimal モジュールは、数値を10進数そのままの形で内部的に保持するため、このような2進数表現による誤差が発生しません。
Decimal オブジェクトの作成
decimal モジュールを使うには、まず Decimal クラスをインポートし、数値を Decimal オブジェクトとして扱います。数値を文字列として渡すことで、精度を保ったまま Decimal オブジェクトを作成できます。浮動小数点数 float を直接渡すと、その float がすでに含む誤差が引き継がれてしまう可能性があるため、推奨されません。
“`python
from decimal import Decimal, ROUND_FLOOR
Decimal オブジェクトの作成
decimal_value1 = Decimal(‘3.7’)
decimal_value2 = Decimal(‘-3.7’)
decimal_value3 = Decimal(‘0.1’)
decimal_value4 = Decimal(‘0.2’)
print(decimal_value1)
print(decimal_value2)
print(decimal_value3 + decimal_value4) # Decimal同士の計算は正確
“`
実行結果：
3.7
-3.7
0.3
decimal_value3 + decimal_value4 の結果が正確に 0.3 になっていることに注目してください。
quantize() メソッドと丸めモード（ROUND_FLOOR）
Decimal オブジェクトの小数点以下を処理するには、主に quantize() メソッドを使います。quantize() メソッドは、数値を指定した小数点以下の桁数で丸めるために使われ、様々な丸めモードを指定できます。
小数点以下を「切り捨てる」ための丸めモードはいくつかあります。
ROUND_FLOOR:math.floor()と同じように、常に小さい方の整数（負の無限大方向）に丸めます。ROUND_DOWN:int()やmath.trunc()と同じように、常にゼロ方向へ丸めます。
小数点以下を全て切り捨てて整数にしたい場合は、quantize() メソッドに Decimal('1')（小数点以下の桁数ゼロを指定するテンプレート）と、丸めモードを指定します。
“`python
from decimal import Decimal, ROUND_FLOOR, ROUND_DOWN
value1 = Decimal(‘3.7’)
value2 = Decimal(‘-3.7’)
ROUND_FLOOR (math.floor() と同じ挙動)
floor_value1 = value1.quantize(Decimal(‘1.’), rounding=ROUND_FLOOR)
floor_value2 = value2.quantize(Decimal(‘1.’), rounding=ROUND_FLOOR)
print(f”{value1} を ROUND_FLOOR で切り捨てると: {floor_value1}”)
print(f”{value2} を ROUND_FLOOR で切り捨てると: {floor_value2}”)
ROUND_DOWN (int(), math.trunc() と同じ挙動)
down_value1 = value1.quantize(Decimal(‘1.’), rounding=ROUND_DOWN)
down_value2 = value2.quantize(Decimal(‘1.’), rounding=ROUND_DOWN)
print(f”{value1} を ROUND_DOWN で切り捨てると: {down_value1}”)
print(f”{value2} を ROUND_DOWN で切り捨てると: {down_value2}”)
“`
実行結果：
3.7 を ROUND_FLOOR で切り捨てると: 3
-3.7 を ROUND_FLOOR で切り捨てると: -4
3.7 を ROUND_DOWN で切り捨てると: 3
-3.7 を ROUND_DOWN で切り捨てると: -3
ROUND_FLOOR は math.floor() と同様に負の数をより小さい整数に、ROUND_DOWN は int() や math.trunc() と同様に負の数をゼロに近い整数に丸めていることが分かります。
小数点以下の桁数ゼロを指定するために Decimal('1') や Decimal('1.') を使っていますが、これは「小数点以下0桁」という精度を表すテンプレートです。より分かりやすく Decimal(0) としても同じ結果になることが多いですが、小数点以下の桁数を明示するために Decimal('1e-K') のような形式（例: Decimal('1e-2') は小数点以下第2位まで）や、整数テンプレート Decimal('0') または Decimal('1.') を使うのが一般的です。小数点以下ゼロ桁を意味するテンプレートとしては、Decimal(1).quantize(0) といった書き方でも同じです。一番簡単なのは Decimal(0) をテンプレートとして使うことでしょう。
“`python
from decimal import Decimal, ROUND_FLOOR, ROUND_DOWN
value1 = Decimal(‘3.7’)
value2 = Decimal(‘-3.7’)
Decimal(0) をテンプレートとして使う例
print(f”{value1} ROUND_FLOOR (Decimal(0)): {value1.quantize(Decimal(0), rounding=ROUND_FLOOR)}”)
print(f”{value2} ROUND_FLOOR (Decimal(0)): {value2.quantize(Decimal(0), rounding=ROUND_FLOOR)}”)
print(f”{value1} ROUND_DOWN (Decimal(0)): {value1.quantize(Decimal(0), rounding=ROUND_DOWN)}”)
print(f”{value2} ROUND_DOWN (Decimal(0)): {value2.quantize(Decimal(0), rounding=ROUND_DOWN)}”)
“`
実行結果：
3.7 ROUND_FLOOR (Decimal(0)): 3
-3.7 ROUND_FLOOR (Decimal(0)): -4
3.7 ROUND_DOWN (Decimal(0)): 3
-3.7 ROUND_DOWN (Decimal(0)): -3
特定の小数点以下の桁数で切り捨てる
decimal モジュールを使えば、「小数点以下第N位で切り捨てて、第N-1位までを残す」という処理も正確に行えます。例えば、「小数点以下第2位で切り捨てて、第1位までを残す」（例: 3.1415 → 3.14）といった場合です。
これは、quantize() メソッドに、残したい小数点以下の桁数に対応するテンプレート Decimal('1e-N') を渡し、丸めモードとして ROUND_FLOOR または ROUND_DOWN を指定することで実現できます。
“`python
from decimal import Decimal, ROUND_FLOOR, ROUND_DOWN
value = Decimal(‘3.14159’)
小数点以下第2位で切り捨てる (第1位まで残す)
テンプレートは Decimal(‘0.01’) または Decimal(‘1e-2’)
template_2_decimal_places = Decimal(‘0.01’)
ROUND_FLOOR で切り捨て (より小さい値へ)
truncated_floor = value.quantize(template_2_decimal_places, rounding=ROUND_FLOOR)
print(f”{value} を小数点以下第2位で ROUND_FLOOR 切り捨て: {truncated_floor}”) # 3.14
ROUND_DOWN で切り捨て (ゼロ方向へ)
truncated_down = value.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
print(f”{value} を小数点以下第2位で ROUND_DOWN 切り捨て: {truncated_down}”) # 3.14
負の数で比較
negative_value = Decimal(‘-3.14159’)
truncated_floor_neg = negative_value.quantize(template_2_decimal_places, rounding=ROUND_FLOOR)
truncated_down_neg = negative_value.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
print(f”{negative_value} を小数点以下第2位で ROUND_FLOOR 切り捨て: {truncated_floor_neg}”) # -3.15
print(f”{negative_value} を小数点以下第2位で ROUND_DOWN 切り捨て: {truncated_down_neg}”) # -3.14
“`
実行結果：
3.14159 を小数点以下第2位で ROUND_FLOOR 切り捨て: 3.14
3.14159 を小数点以下第2位で ROUND_DOWN 切り捨て: 3.14
-3.14159 を小数点以下第2位で ROUND_FLOOR 切り捨て: -3.15
-3.14159 を小数点以下第2位で ROUND_DOWN 切り捨て: -3.14
正の数では ROUND_FLOOR と ROUND_DOWN の結果は同じですが、負の数では異なる結果になることが分かります。これは、整数への切り捨ての場合と同様です。小数点以下第N位で切り捨てる場合、ROUND_FLOOR は元の数値以下の、指定桁数で表現できる最大の数に丸め、ROUND_DOWN は元の数値とゼロの間にある、指定桁数で表現できる数に丸めます。
decimal を使うことの利点と注意点
利点:
- 浮動小数点数の精度問題を完全に回避し、正確な10進数計算が可能です。
- 様々な丸めモードを明示的に指定できます。
- 特に金額計算など、厳密な端数処理が求められる場面で必須と言えます。
- 特定の小数点以下の桁数での丸め（切り捨て含む）が容易です。
注意点:
- 標準の
floatやintよりも扱いが少し複雑になります (Decimalオブジェクトを作成する必要があるなど)。 Decimalオブジェクト間の計算は、floatやintの計算に比べて少し遅くなる可能性があります（一般的なアプリケーションではほとんど気になりませんが、大量の数値を高速に処理する場合は考慮が必要です）。Decimalを使う場合、計算に関わる全ての数値をDecimalオブジェクトに変換して統一的に扱うのが望ましいです。floatとDecimalを混在させるとエラーになることがあります。
コード例
消費税計算を decimal で行う例です。
“`python
from decimal import Decimal, ROUND_DOWN
消費税率 (10%) を Decimal で定義
tax_rate = Decimal(‘0.10’)
商品価格を Decimal で定義
price1 = Decimal(‘100’) # ちょうど整数
price2 = Decimal(‘123.45’) # 小数点以下2桁
price3 = Decimal(‘99.99’) # 小数点以下2桁
price4 = Decimal(‘123.456’) # 小数点以下3桁 (本来の精度)
価格 * 税率 で税額を計算
tax1 = price1 * tax_rate
tax2 = price2 * tax_rate
tax3 = price3 * tax_rate
tax4 = price4 * tax_rate
print(f”価格 {price1}, 税額: {tax1}”) # 100 * 0.10 = 10.00
print(f”価格 {price2}, 税額: {tax2}”) # 123.45 * 0.10 = 12.345
print(f”価格 {price3}, 税額: {tax3}”) # 99.99 * 0.10 = 9.999
print(f”価格 {price4}, 税額: {tax4}”) # 123.456 * 0.10 = 12.3456
税額を小数点以下第1位で切り捨てて計算する (金額の端数処理)
例: 小数点以下第2位で切り捨てて、第1位までを残す
テンプレートは Decimal(‘0.01’)
template_2_decimal_places = Decimal(‘0.01’)
tax1_truncated = tax1.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
tax2_truncated = tax2.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
tax3_truncated = tax3.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
tax4_truncated = tax4.quantize(template_2_decimal_places, rounding=ROUND_DOWN)
print(f”— 税額を小数点以下第2位で切り捨て (ROUND_DOWN) —“)
print(f”価格 {price1}, 税額: {tax1_truncated}”) # 10.00 -> 10.00
print(f”価格 {price2}, 税額: {tax2_truncated}”) # 12.345 -> 12.34
print(f”価格 {price3}, 税額: {tax3_truncated}”) # 9.999 -> 9.99
print(f”価格 {price4}, 税額: {tax4_truncated}”) # 12.3456 -> 12.34
合計金額を計算
total1 = price1 + tax1_truncated
total2 = price2 + tax2_truncated
total3 = price3 + tax3_truncated
total4 = price4 + tax4_truncated
print(f”— 合計金額 —“)
print(f”価格 {price1}, 合計: {total1}”) # 100 + 10.00 = 110.00
print(f”価格 {price2}, 合計: {total2}”) # 123.45 + 12.34 = 135.79
print(f”価格 {price3}, 合計: {total3}”) # 99.99 + 9.99 = 109.98
print(f”価格 {price4}, 合計: {total4}”) # 123.456 + 12.34 = 135.796
“`
実行結果：
価格 100, 税額: 10.00
価格 123.45, 税額: 12.345
価格 99.99, 税額: 9.999
価格 123.456, 税額: 12.3456
--- 税額を小数点以下第2位で切り捨て (ROUND_DOWN) ---
価格 100, 税額: 10.00
価格 123.45, 税額: 12.34
価格 99.99, 税額: 9.99
価格 123.456, 税額: 12.34
--- 合計金額 ---
価格 100, 合計: 110.00
価格 123.45, 合計: 135.79
価格 99.99, 合計: 109.98
価格 123.456, 合計: 135.796
このように、decimal モジュールを使うことで、金額計算でよく行われる「小数点以下第○位で切り捨て」といった処理を正確に行うことができます。もしこれらの計算を float で行っていたら、わずかな誤差が蓄積し、最終的な合計金額が期待と異なる値になる可能性がありました。
decimal モジュールは少し複雑に感じられるかもしれませんが、正確な計算が必要な場面では非常に強力なツールとなります。
8. どの方法を選べば良い？状況に応じた使い分けガイド
ここまで、Pythonで小数点以下を切り捨てる様々な方法を見てきました。それぞれに特徴があり、得意な場面や注意点があります。ここでは、あなたの目的に応じてどの方法を選ぶべきかのガイドラインを示します。
1. 単に整数部分が欲しい場合（特に正の数）
計算結果の小数点以下を無視して、手軽に整数部分だけを取り出したい場合、最も簡単なのは int() 関数です。
* メリット: 組み込み関数で最もシンプル。
* 注意点: 負の数に対してはゼロ方向への丸めになることに注意。
“`python
value = 150.75
integer_part = int(value) # 150
print(integer_part)
negative_value = -10.1
integer_part_neg = int(negative_value) # -10
print(integer_part_neg)
“`
2. 数学的な「床関数」が必要な場合
常に「元の数値以下の最大の整数」を得たい場合、つまり数学的な床関数が必要な場合は、math.floor() 関数を使います。これは特に負の数に対して重要です。
* メリット: 数学的な定義に忠実。負の数でも一貫した「小さい方へ」の丸め。
* 注意点: math モジュールのインポートが必要。結果は float 型。
“`python
import math
value = 150.75
floor_value = math.floor(value) # 150.0
print(floor_value)
negative_value = -10.1
floor_value_neg = math.floor(negative_value) # -11.0
print(floor_value_neg)
“`
3. ゼロ方向への切り捨てを明確にしたい場合
int() と同じくゼロ方向への丸めを行いますが、その意図をコードでより明確に示したい場合は math.trunc() を使うことができます。
* メリット: 意図が明確。結果は int 型。
* 注意点: math モジュールのインポートが必要。
“`python
import math
value = 150.75
trunc_value = math.trunc(value) # 150
print(trunc_value)
negative_value = -10.1
trunc_value_neg = math.trunc(negative_value) # -10
print(trunc_value_neg)
``int()とmath.trunc()` は、浮動小数点数に対してはほぼ同じものと考えて良いでしょう。
4. 割り算の結果を切り捨てたい場合
割り算を行い、その結果の小数点以下を切り捨てて整数を得たい場合に最も便利なのが整数除算演算子 // です。
* メリット: 割り算と切り捨てを一度に行えるため簡潔。
* 注意点: 割り算にしか使えない。負の数の場合、math.floor() と同じく負の無限大方向への丸め。
“`python
total_seconds = 300
minutes = total_seconds // 60 # 300 // 60 = 5
print(minutes)
negative_total = -300
negative_result = negative_total // 60 # -300 // 60 = -5 (厳密には math.floor(-300/60) = math.floor(-5) = -5)
print(negative_result) # この場合はちょうど割り切れたのでfloorやintで結果は同じ -5
negative_total_partial = -301
negative_result_partial = negative_total_partial // 60 # -301 / 60 = -5.016… -> math.floor(-5.016…) = -6
print(negative_result_partial) # -6
“`
5. 正確な数値計算が必要な場合（特に金額など）
浮動小数点数の精度問題が許容できず、厳密な10進数計算や正確な丸め処理が必要な場合は、decimal モジュールを使います。
* メリット: 精度の高い計算が可能。柔軟な丸めモード（ROUND_FLOOR, ROUND_DOWN など）を指定できる。特定の桁数での切り捨てが正確に行える。
* 注意点: 標準の数値型より扱いが複雑。パフォーマンスはやや劣る可能性がある。
“`python
from decimal import Decimal, ROUND_DOWN
price = Decimal(‘123.45’)
tax_rate = Decimal(‘0.10’)
tax = price * tax_rate # 12.345
税額を小数点以下第2位で切り捨て (第1位まで残す)
tax_truncated = tax.quantize(Decimal(‘0.01’), rounding=ROUND_DOWN) # 12.34
print(tax_truncated)
負の値を整数に ROUND_FLOOR で切り捨て
negative_dec = Decimal(‘-3.7’)
floor_dec = negative_dec.quantize(Decimal(0), rounding=ROUND_FLOOR) # -4
print(floor_dec)
“`
負の数の扱いに注意！
繰り返しになりますが、最も重要な選択基準の一つは、負の数に対してどのような「切り捨て」を期待するかです。
- ゼロ方向への丸め (int, trunc, decimal + ROUND_DOWN):
-3.7→-3 - 負の無限大方向への丸め (floor, //, decimal + ROUND_FLOOR):
-3.7→-4
あなたのプログラムで負の数を扱う可能性がある場合は、これらの挙動の違いを理解し、目的に合った関数や演算子を選択することが非常に重要です。
9. よくある質問とトラブルシューティング
浮動小数点数の精度問題についてもう少し詳しく
なぜ 0.1 + 0.2 が 0.3 にならないのか、もう少し具体的に説明します。コンピュータは内部で数値を2進数（0と1）で表現します。例えば、10進数の 0.5 は2進数では 0.1 と正確に表現できます（2⁻¹ = 0.5）。しかし、10進数の 0.1 や 0.2 は、2進数では無限小数になります。
0.1 を2進数で書くと 0.00011001100110011... と、1100 の繰り返しになります。コンピュータは限られたビット数でしか数値を表現できないため、この無限小数を途中で打ち切るしかありません。これにより、わずかな誤差が生じます。
標準の浮動小数点数 float は、この2進数での近似表現を使用します。そのため、計算を重ねるにつれて誤差が蓄積したり、人間が期待する通りの正確な結果が得られなかったりすることがあります。
ほとんどの場合、この誤差は非常に小さく、計算や表示に大きな影響を与えません。しかし、金融システムのように1円の誤差も許されない場面や、多数の浮動小数点数計算を繰り返す科学技術計算などでは問題になることがあります。
int(), math.floor(), math.trunc(), // といった関数や演算子は、内部的にはこの float の値に対して操作を行います。そのため、int(3.9999999999999996) が 3 になるように、元の float 値が含む誤差によって結果が左右される可能性は理論上ゼロではありません。ただし、Pythonのこれらの機能は、一般的な誤差の範囲内であれば期待通りに動作するように設計されています。
より高い精度が必要な場合は、decimal モジュールを使うことで、10進数での正確な計算と丸め処理が可能になります。
小数点以下第N位で切り捨てたい
「小数点以下を全て切り捨てる」のではなく、「小数点以下第N+1位以下を切り捨てて、第N位までを残す」という処理は、通常 float 型に対して直接行うのはお勧めしません。前述の精度問題があるため、意図しない結果になる可能性があるからです。
このような処理を正確に行いたい場合は、decimal モジュールを使うのが最も安全で確実な方法です。Decimal オブジェクトの quantize() メソッドと適切な丸めモード（ROUND_FLOOR または ROUND_DOWN）を使います。
“`python
from decimal import Decimal, ROUND_DOWN, ROUND_FLOOR
value = Decimal(‘123.456789’)
小数点以下第3位で切り捨てたい (第2位まで残す)
テンプレートは小数点以下2桁を意味する Decimal(‘0.01’)
template = Decimal(‘0.01’)
ROUND_DOWN (ゼロ方向へ)
truncated_down = value.quantize(template, rounding=ROUND_DOWN)
print(f”{value} を小数点以下第3位で ROUND_DOWN 切り捨て: {truncated_down}”) # 123.45
ROUND_FLOOR (負の無限大方向へ)
negative_value = Decimal(‘-123.456789’)
truncated_floor_neg = negative_value.quantize(template, rounding=ROUND_FLOOR)
print(f”{negative_value} を小数点以下第3位で ROUND_FLOOR 切り捨て: {truncated_floor_neg}”) # -123.46
ROUND_DOWN (ゼロ方向へ)
truncated_down_neg = negative_value.quantize(template, rounding=ROUND_DOWN)
print(f”{negative_value} を小数点以下第3位で ROUND_DOWN 切り捨て: {truncated_down_neg}”) # -123.45
“`
もし float 型のまま処理したい場合は、一度数値を 10**N 倍して整数化し、切り捨て（int または math.floor）、再び 10**N で割るという方法も考えられますが、これも元の float 値の精度に依存するため、完全に安全とは言えません。
“`python
import math
float のまま小数点以下第2位で切り捨てを試みる例 (非推奨)
value_float = 123.456789
100倍して int で切り捨てて 100で割る
(int() はゼロ方向への丸め)
truncated_float_int = int(value_float * 100) / 100.0
print(f”{value_float} を int で切り捨てて戻す (非推奨): {truncated_float_int}”) # 123.45
100倍して math.floor で切り捨てて 100で割る
(math.floor() は負の無限大方向への丸め)
truncated_float_floor = math.floor(value_float * 100) / 100.0
print(f”{value_float} を floor で切り捨てて戻す (非推奨): {truncated_float_floor}”) # 123.45
negative_value_float = -123.456789
truncated_float_int_neg = int(negative_value_float * 100) / 100.0
print(f”{negative_value_float} を int で切り捨てて戻す (非推奨): {truncated_float_int_neg}”) # -123.45
truncated_float_floor_neg = math.floor(negative_value_float * 100) / 100.0
print(f”{negative_value_float} を floor で切り捨てて戻す (非推奨): {truncated_float_floor_neg}”) # -123.46
``float
正の数では int と floor の結果を戻しても同じになりますが、負の数ではやはり違いが出ます。そして、元の値が例えば123.45000000000001のような微妙な値だった場合、掛け算や割り算の過程で誤差が影響し、期待通りの結果にならない可能性が完全に排除できません。小数点以下の特定の桁数での正確な切り捨ては、decimal` モジュールを使うのが最も確実な方法です。
文字列を切り捨てたい
小数点以下を含む数値を文字列として持っている場合（例: "123.45"）、直接 int() に渡すことはできません (ValueError になります)。
“`python
str_value = “123.45”
int(str_value) # これはエラー
“`
文字列を数値として扱い、小数点以下を切り捨てるには、まず文字列を数値型（float または Decimal）に変換してから、それぞれの方法で切り捨てを行います。
-
floatに変換してからint()またはmath.floor(): 手軽ですが、floatの精度問題の影響を受ける可能性があります。“`python
import math
str_value = “123.45”
float_value = float(str_value)
print(f”{str_value} を int() で切り捨て: {int(float_value)}”)
print(f”{str_value} を math.floor() で切り捨て: {math.floor(float_value)}”)str_negative_value = “-67.89″
float_negative_value = float(str_negative_value)
print(f”{str_negative_value} を int() で切り捨て: {int(float_negative_value)}”) # -67
print(f”{str_negative_value} を math.floor() で切り捨て: {math.floor(float_negative_value)}”) # -68
“` -
Decimalに変換してからquantize(): 最も正確で、どの丸めモードを使うか選択できます。“`python
from decimal import Decimal, ROUND_DOWN, ROUND_FLOOR
str_value = “123.45”
decimal_value = Decimal(str_value)
print(f”{str_value} を Decimal + ROUND_DOWN で切り捨て: {decimal_value.quantize(Decimal(0), rounding=ROUND_DOWN)}”)str_negative_value = “-67.89″
decimal_negative_value = Decimal(str_negative_value)
print(f”{str_negative_value} を Decimal + ROUND_DOWN で切り捨て: {decimal_negative_value.quantize(Decimal(0), rounding=ROUND_DOWN)}”) # -67
print(f”{str_negative_value} を Decimal + ROUND_FLOOR で切り捨て: {decimal_negative_value.quantize(Decimal(0), rounding=ROUND_FLOOR)}”) # -68
“`
数値を含む文字列を扱う場合は、まず適切な数値型に変換し、その後目的の方法で切り捨てるという手順を踏みましょう。そして、正確性が求められるなら Decimal を使うことを検討してください。
10. Pythonでの小数点以下切り捨て：応用例
実際のプログラミングで、小数点以下を切り捨てる操作がどのように使われるか、具体的な応用例を見てみましょう。
消費税計算
商品価格に税率をかけて税額を求め、小数点以下の端数を切り捨てる計算です。特に金額計算なので、decimal モジュールを使うのが推奨されます。
“`python
from decimal import Decimal, ROUND_DOWN
消費税率 10%
tax_rate = Decimal(‘0.10’)
商品リスト (価格は Decimal)
items = [Decimal(‘100’), Decimal(‘250.50’), Decimal(‘980.75’)]
total_price = sum(items) # 合計金額
print(f”商品合計金額 (税抜): {total_price}”)
税額を計算
total_tax = total_price * tax_rate
print(f”合計税額 (端数処理前): {total_tax}”)
税額の小数点以下を切り捨て (例: 小数点以下第1位で切り捨て、円未満を切り捨て)
テンプレートは Decimal(‘1’) または Decimal(‘0.00’)
tax_truncated = total_tax.quantize(Decimal(‘1.’), rounding=ROUND_DOWN) # または Decimal(‘0.00’)を使う場合
print(f”合計税額 (小数点以下切り捨て – ROUND_DOWN): {tax_truncated}”)
税込合計金額
total_price_incl_tax = total_price + tax_truncated
print(f”税込合計金額: {total_price_incl_tax}”)
“`
実行例 (出力は環境や Decimal の設定により微細に異なる場合があります)：
商品合計金額 (税抜): 1331.25
合計税額 (端数処理前): 133.125
合計税額 (小数点以下切り捨て - ROUND_DOWN): 133.12
税込合計金額: 1464.37
この例では、税額を小数点以下第2位で切り捨て（第1位まで残す）ために Decimal('0.01') をテンプレートとして使うべきでした。上記の例は Decimal('1.') をテンプレートとして使っているため、結果が 133.00 となってしまいます。（修正）
“`python
from decimal import Decimal, ROUND_DOWN
消費税率 10%
tax_rate = Decimal(‘0.10’)
商品リスト (価格は Decimal)
items = [Decimal(‘100’), Decimal(‘250.50’), Decimal(‘980.75’)]
total_price = sum(items) # 合計金額
print(f”商品合計金額 (税抜): {total_price}”) # 1331.25
税額を計算
total_tax = total_price * tax_rate
print(f”合計税額 (端数処理前): {total_tax}”) # 133.125
税額を小数点以下第2位で切り捨て (第1位まで残す、つまり円未満を切り捨て)
テンプレートは Decimal(‘0.01’)
template_yen = Decimal(‘0.01’) # 銭まで残す精度を指定
tax_truncated = total_tax.quantize(template_yen, rounding=ROUND_DOWN)
print(f”合計税額 (小数点以下第2位で切り捨て – ROUND_DOWN): {tax_truncated}”) # 133.12
税込合計金額
total_price_incl_tax = total_price + tax_truncated
print(f”税込合計金額: {total_price_incl_tax}”) # 1331.25 + 133.12 = 1464.37
実行結果 (修正後)：
商品合計金額 (税抜): 1331.25
合計税額 (端数処理前): 133.125
合計税額 (小数点以下第2位で切り捨て – ROUND_DOWN): 133.12
税込合計金額: 1464.37
``decimal` を使うことで、金額計算で求められる特定の桁数での正確な切り捨て（または他の丸め処理）を間違いなく行うことができます。
このように、
ページの表示件数計算
Webサイトなどで、全件数と1ページあたりの表示件数から、必要なページ数を計算する場合を考えます。
例えば、全100件を1ページ12件で表示する場合、100 / 12 = 8.33… ページが必要です。最後のページに満たない数のアイテムがあっても、そのページ自体は表示されるので、このような場合は通常「切り上げ」が必要になります（この例だと9ページ）。
しかし、もし「1ページ12件として、完全に表示できるページは何ページか？」という質問であれば、100件を12件ずつに分けると、8ページが完全に埋まり、残りが4件となります。この場合、答えは8ページとなり、「切り捨て」が使われます。
これは、整数除算 // がぴったりです。
“`python
total_items = 100
items_per_page = 12
完全に表示できるページ数 (切り捨て)
complete_pages = total_items // items_per_page
print(f”全 {total_items} 件を 1ページ {items_per_page} 件で表示する場合、完全に表示できるのは {complete_pages} ページです。”)
必要となる総ページ数 (切り上げ) – 参考として
切り上げは math.ceil() を使います
import math
total_pages = math.ceil(total_items / items_per_page)
print(f”必要となる総ページ数 (切り上げ): {total_pages} ページです。”)
“`
実行結果：
全 100 件を 1ページ 12 件で表示する場合、完全に表示できるのは 8 ページです。
必要となる総ページ数 (切り上げ): 9 ページです。
時間単位の変換
秒数を分や時間に変換し、小数点以下を切り捨てて「何分ぴったり」「何時間ぴったり」といった値を求めたい場合があります。
“`python
total_seconds = 5000
秒を分に変換して切り捨て
5000秒 / 60秒/分 = 83.33…分
minutes = total_seconds // 60
print(f”{total_seconds} 秒は {minutes} 分です (小数点以下切り捨て)。”)
分を時間 に変換して切り捨て
83分 / 60分/時間 = 1.38…時間
hours = minutes // 60
print(f”{minutes} 分は {hours} 時間です (小数点以下切り捨て)。”)
または、秒から直接時間に変換して切り捨て
5000秒 / 3600秒/時間 = 1.38…時間
hours_from_seconds = total_seconds // 3600
print(f”{total_seconds} 秒は {hours_from_seconds} 時間です (小数点以下切り捨て)。”)
float を int() で切り捨て
float_seconds = 5000.0
float_minutes = int(float_seconds / 60.0)
print(f”{float_seconds} (float) 秒は int() で切り捨てると {float_minutes} 分です。”)
“`
実行結果：
5000 秒は 83 分です (小数点以下切り捨て)。
83 分は 1 時間です (小数点以下切り捨て)。
5000 秒は 1 時間です (小数点以下切り捨て)。
5000.0 (float) 秒は int() で切り捨てると 83 分です。
このような単位変換で「ぴったり」の値を求めたい場合に、切り捨てが頻繁に利用されます。整数除算 // はこのような場合に非常に直感的で使いやすい方法です。
11. まとめ：最適な切り捨て方法を選ぼう
この記事では、Pythonで小数点以下を切り捨てるための様々な方法を、初心者向けに詳しく解説しました。
- 最も手軽なのは組み込みの
int()関数 です。正の数に対しては直感的な切り捨てを行いますが、負の数に対してはゼロ方向への丸めになります。 - 数学的な「床関数」として、常に小さい方の整数（負の無限大方向）へ丸めるのが
math.floor()関数 です。mathモジュールのインポートが必要で、結果はfloat型になります。負の数の扱いがint()と異なります。 int()と同様にゼロ方向への丸めを行うのがmath.trunc()関数 です。mathモジュールのインポートが必要ですが、結果はint型になり、小数点以下の切り捨ての意図をより明確に示せます。- 割り算の結果をすぐに整数として得たい場合は、整数除算演算子
//が便利です。負の数の場合、math.floor()と同じく負の無限大方向への丸めになります。 - 浮動小数点数の精度問題を回避し、正確な10進数計算や特定の桁数での丸めを行いたい場合は、
decimalモジュール を使います。Decimalオブジェクトのquantize()メソッドとROUND_FLOORまたはROUND_DOWN丸めモードを使用します。
これらの方法のどれを選ぶかは、あなたの目的、特に 負の数に対する切り捨ての定義、結果に求める精度、そして コードの簡潔さや意図の明確さ によって異なります。
| 方法 | 手軽さ | 負の数の挙動 | 精度の高さ | 特定桁での切り捨て | 備考 |
|---|---|---|---|---|---|
int() |
◎ | ゼロ方向へ | 標準 (float に依存) |
△ (非推奨) | 組み込み関数 |
math.floor() |
○ | 負の無限大方向へ | 標準 (float に依存) |
△ (非推奨) | math インポート要, 結果 float |
math.trunc() |
○ | ゼロ方向へ | 標準 (float に依存) |
△ (非推奨) | math インポート要, 結果 int |
// |
○ | 負の無限大方向へ | 標準 (float に依存) |
× (割り算のみ) | 整数除算演算子 |
decimal (quantize) |
△ | ROUND_DOWN or ROUND_FLOOR |
高い (10進数) | ◎ | decimal インポート要, Decimal 型 |
初心者の方へのアドバイス:
- まずは最も簡単な
int()を試してみましょう。正の数を扱う場合はこれで十分なことが多いです。 - 負の数を扱う場合や、結果の正確性が重要な場合は、
math.floor()やdecimalの利用を検討してください。特に負の数でのint()とmath.floor()の違いは、多くの初心者が戸惑うポイントです。数直線をイメージして理解を深めましょう。 - 割り算の結果を切り捨てたい場合は
//演算子を思い出してください。
Pythonには様々な便利な機能がありますが、それぞれの特性を理解して適切に使い分けることが、バグの少ない、意図が明確なコードを書くために重要です。
この記事が、あなたがPythonでの数値計算、特に小数点以下の切り捨てをマスターするための一助となれば幸いです。
12. 付録：関連情報
小数点以下の処理には、「切り捨て」以外にも「切り上げ」や「四捨五入」といった操作があります。混同しないように、関連する組み込み関数やモジュールも簡単に紹介しておきます。
-
math.ceil(x):mathモジュールにある関数で、数学的な「天井関数」を提供します。引数x以上の最小の整数を返します（常に大きい方の整数に丸めます）。これは「切り上げ」に使われます。結果はfloat型になります。python
import math
print(math.ceil(3.1)) # 4.0
print(math.ceil(3.9)) # 4.0
print(math.ceil(-3.1)) # -3.0
print(math.ceil(-3.9)) # -3.0 -
round(x, n=0): 組み込み関数で、数値を四捨五入します。引数nは小数点以下何桁まで残すかを指定します（デフォルトは0で整数に丸めます）。Python 3 では、小数点以下がちょうど.5の場合、最も近い偶数に丸める「最近接偶数への丸め (Bankers’ rounding)」という方法がデフォルトになっています。結果の型はint(n=0の場合) またはfloat(n>0の場合) になります。python
print(round(3.1)) # 3 (int)
print(round(3.9)) # 4 (int)
print(round(3.5)) # 4 (int, 最近接偶数)
print(round(2.5)) # 2 (int, 最近接偶数)
print(round(3.14159, 2)) # 3.14 (float)
print(round(3.145, 2)) # 3.14 (float, 最近接偶数)
print(round(3.155, 2)) # 3.16 (float, 最近接偶数)
print(round(-3.7)) # -4 (int)
print(round(-3.5)) # -4 (int) -
decimalモジュール:quantize()メソッドは、ROUND_FLOOR,ROUND_DOWN以外にも、ROUND_CEILING(切り上げ、math.ceilと同じ),ROUND_HALF_UP(一般的な四捨五入),ROUND_HALF_EVEN(最近接偶数への丸め、roundと同じ) など、様々な丸めモードに対応しています。
これらの関数やモジュールも理解しておくと、Pythonでの数値計算の幅がさらに広がります。
公式ドキュメント:
- 組み込み関数
int(): https://docs.python.org/ja/3/library/functions.html#int mathモジュール: https://docs.python.org/ja/3/library/math.html (floor,trunc,ceilが含まれます)decimalモジュール: https://docs.python.org/ja/3/library/decimal.html
公式ドキュメントは、より詳細な情報や高度な使い方を知りたい場合に非常に役立ちます。
さあ、これであなたはPythonで小数点以下を切り捨てるための知識をしっかりと身につけました。これらの知識を活かして、様々なプログラムを作成してみてください。学習の過程で疑問が出てきたら、この記事を再度参照したり、他の資料を調べたりしながら、一つずつ解決していきましょう。応援しています！