Zenn
👏

【Python】n//2とint(n/2)の違い

に公開
Python
tech

今日は一見よく似た二つの計算方法「n//2」と「int(n/2)」の違いについて、わかりやすく解説していきます。

「え？どちらも同じじゃないの？」と思った方、実はこの二つ、微妙に違うんです！

その違いを知ることで、バグを防いだり、より効率的なコードが書けるようになります。

基本的な違い

まずは基本から見ていきましょう。

  • n//2 は「切り捨て除算」と呼ばれるフロア除算（floor division）です。
  • int(n/2) は「普通の除算の結果を整数に変換」する方法です。

これだけだと分かりにくいので、実際のコードで確認してみましょう！

n = 5
result1 = n // 2
result2 = int(n / 2)

print(f"n = {n} の場合")
print(f"n // 2 = {result1}")  # 切り捨て除算の結果
print(f"int(n / 2) = {result2}")  # 通常の除算結果を整数変換

実行結果:

n = 5 の場合
n // 2 = 2
int(n / 2) = 2

同じ結果になりました。

もう少し例を見てみましょう。

負の数での違い

ここからが重要ポイント！

負の数を使うと、二つの方法で結果が変わってきます。

n = -5
result1 = n // 2
result2 = int(n / 2)

print(f"n = {n} の場合")
print(f"n // 2 = {result1}")  # 切り捨て除算の結果
print(f"int(n / 2) = {result2}")  # 通常の除算結果を整数変換

実行結果:

n = -5 の場合
n // 2 = -3
int(n / 2) = -2

結果が違いました！

なぜでしょうか？

違いの理由を理解しよう

理由を詳しく説明すると：

  1. n // 2（フロア除算）は、結果を数直線上で左側の最も近い整数に丸めます。結果を負の無限大方向へ丸める（floor = 床関数）ともいいます。-5 ÷ 2 = -2.5 なので、これを左方向に丸めると -3 になります。

  2. int(n / 2) は、まず -5 / 2 = -2.5 を計算し、その後 int() 関数で小数点以下を切り捨てて -2 になります。

表で整理すると、より分かりやすいですね：

計算式 正の数での例 (n=5) 負の数での例 (n=-5) 動作の説明
n // 2 2 -3 結果を最も近い小さい整数に切り捨て
int(n/2) 2 -2 除算後、小数点以下を切り捨て

様々な例で確認してみよう

もう少し例を増やして確認してみましょう：

numbers = [10, 9, 5, 4, 1, 0, -1, -4, -5, -9, -10]

print("n\t| n//2\t| int(n/2)")
print("-" * 24)

for n in numbers:
    print(f"{n}\t| {n//2}\t| {int(n/2)}")

実行結果:

n	| n//2	| int(n/2)
------------------------
10	| 5	| 5
9	| 4	| 4
5	| 2	| 2
4	| 2	| 2
1	| 0	| 0
0	| 0	| 0
-1	| -1	| 0
-4	| -2	| -2
-5	| -3	| -2
-9	| -5	| -4
-10	| -5	| -5

-1、-5、-9で違いがあるのが分かります。

実際のプログラミングでの選び方

では、実際のプログラミングではどちらを使うべきでしょうか？

これは「何をしたいか」によって変わります：

  1. 数学的な「床関数（floor function）」の動作が必要なら n // 2 を使います。

  2. 単純に「小数点以下を捨てたい」なら int(n / 2) を使います。

例えば、配列のインデックスを半分にする場合は、通常 int(n / 2) の方が期待通りの動作になりやすいです。

array = [1, 2, 3, 4, 5]
middle_index = int(len(array) / 2)
print(f"配列の中央インデックス: {middle_index}")  # 結果: 2
print(f"中央の値: {array[middle_index]}")  # 結果: 3

パフォーマンスの違い

実は、速度にも若干の違いがあります！

import time

# パフォーマンス比較
n = 1000000
iterations = 10000000

# n // 2 のパフォーマンス測定
start = time.time()
for _ in range(iterations):
    result = n // 2
end = time.time()
floor_time = end - start

# int(n / 2) のパフォーマンス測定
start = time.time()
for _ in range(iterations):
    result = int(n / 2)
end = time.time()
int_time = end - start

print(f"n // 2 の実行時間: {floor_time:.6f}秒")
print(f"int(n / 2) の実行時間: {int_time:.6f}秒")
print(f"速度比: {int_time/floor_time:.2f}倍")

一般的に n // 2 の方が少し速いことが多いです。

なぜなら一度の演算で済むから。

一方、int(n / 2) は除算と整数変換の2つの処理が必要です。

まとめ

一見同じように見える n // 2 と int(n / 2) ですが、負の数の扱いが違うという重要な違いがありました！

  • n // 2: 常に下に切り捨て（フロア除算）
  • int(n / 2): 小数点以下を切り捨て

プログラミングでは、こういった小さな違いが大きなバグを生むこともあります。

特に負の数を扱う可能性がある場合は、この違いをしっかり理解しておくことが大切です。

それではみなさん、楽しいPythonライフを！

Discussion