Python無限大inf完全ガイド：作成・演算・判定・比較の全てを解説

無限大（inf）とは

Pythonでは、IEEE 754標準に準拠した無限大（infinity）を表現できます。無限大は数学的概念で、どんな実数よりも大きい値を表します。

import math

# 無限大の作成方法
pos_inf1 = float('inf')
pos_inf2 = math.inf
neg_inf1 = float('-inf')
neg_inf2 = -math.inf

print(f"正の無限大: {pos_inf1}")
print(f"負の無限大: {neg_inf1}")
print(f"同じ値: {pos_inf1 == pos_inf2}")

無限大の作成方法

基本的な作成方法

import math

# 文字列から作成
inf_from_str = float('inf')
neg_inf_from_str = float('-inf')

# mathモジュールから取得
inf_from_math = math.inf
neg_inf_from_math = -math.inf

# 計算結果として生成
inf_from_calc = 1.0 / 0.0  # ZeroDivisionError in Python
# 代わりに以下の方法
inf_from_overflow = float('1e400')  # オーバーフロー

print(f"文字列から: {inf_from_str}")
print(f"mathから: {inf_from_math}")
print(f"オーバーフローから: {inf_from_overflow}")

計算による無限大の生成

import sys
import math

# 最大浮動小数点数を超えた計算
max_float = sys.float_info.max
overflow_inf = max_float * 10

print(f"最大値: {max_float:.2e}")
print(f"オーバーフロー結果: {overflow_inf}")

# 指数関数での無限大
exp_inf = math.exp(1000)  # e^1000
print(f"exp(1000): {exp_inf}")

# 対数関数での無限大（底が1より大きい場合）
log_inf = math.log(0)  # ValueError が発生
# 代わりに以下で確認
print(f"1/0に近い値: {1.0/1e-300}")

無限大の演算

基本演算

import math

inf = math.inf

# 加算・減算
print(f"inf + 100: {inf + 100}")          # inf
print(f"inf - 100: {inf - 100}")          # inf
print(f"inf + inf: {inf + inf}")          # inf
print(f"inf - inf: {inf - inf}")          # nan

# 乗算・除算
print(f"inf * 2: {inf * 2}")              # inf
print(f"inf * 0: {inf * 0}")              # nan
print(f"inf / 2: {inf / 2}")              # inf
print(f"inf / inf: {inf / inf}")          # nan

特殊な演算結果

import math

inf = math.inf

# NaN（非数）が生成されるケース
undefined_operations = [
    inf - inf,    # 無限大 - 無限大
    inf / inf,    # 無限大 / 無限大
    inf * 0,      # 無限大 * 0
    0 / 0         # 0で除算（エラーになる場合もある）
]

for i, result in enumerate(undefined_operations[:-1]):  # 最後は除く
    print(f"演算{i+1}: {result}")

# 0除算は例外が発生する場合がある
try:
    zero_div = 0 / 0
except ZeroDivisionError:
    print("0/0: ZeroDivisionError")

比較演算

import math

inf = math.inf
neg_inf = -math.inf

# 無限大同士の比較
print(f"inf > 1000000: {inf > 1000000}")    # True
print(f"inf == inf: {inf == inf}")          # True
print(f"inf > neg_inf: {inf > neg_inf}")    # True

# NaNとの比較
nan = float('nan')
print(f"inf > nan: {inf > nan}")            # False
print(f"inf < nan: {inf < nan}")            # False
print(f"inf == nan: {inf == nan}")          # False

無限大の判定

math.isinf()による判定

import math

values = [
    1.0,
    math.inf,
    -math.inf,
    float('inf'),
    float('-inf'),
    float('nan'),
    1e400
]

for val in values:
    print(f"{val}: isinf={math.isinf(val)}")

カスタム判定関数

import math

def check_infinity_type(value):
    """無限大の種類を判定"""
    if not math.isinf(value):
        return "非無限大"
    elif value > 0:
        return "正の無限大"
    else:
        return "負の無限大"

# テスト
test_values = [1.0, math.inf, -math.inf, float('nan')]
for val in test_values:
    print(f"{val}: {check_infinity_type(val)}")

isfinite()による有限数判定

import math

def analyze_number(value):
    """数値の分類を詳しく調べる"""
    info = {
        'value': value,
        'is_finite': math.isfinite(value),
        'is_infinite': math.isinf(value),
        'is_nan': math.isnan(value)
    }
    return info

# 様々な値で検証
test_numbers = [
    42,
    3.14,
    math.inf,
    -math.inf,
    float('nan'),
    1e308,
    1e400
]

for num in test_numbers:
    result = analyze_number(num)
    print(f"{result['value']}: finite={result['is_finite']}, inf={result['is_infinite']}, nan={result['is_nan']}")

無限大の比較

正確な比較方法

import math

def safe_compare(a, b):
    """無限大を考慮した安全な比較"""
    # 両方ともNaNの場合
    if math.isnan(a) and math.isnan(b):
        return "両方NaN（比較不能）"
    
    # どちらかがNaNの場合
    if math.isnan(a) or math.isnan(b):
        return "NaNを含む（比較不能）"
    
    # 無限大同士の比較
    if math.isinf(a) and math.isinf(b):
        if a == b:
            return "同じ無限大"
        else:
            return "異なる無限大"
    
    # 通常の比較
    if a == b:
        return "等しい"
    elif a > b:
        return "a > b"
    else:
        return "a < b"

# テストケース
test_pairs = [
    (math.inf, math.inf),
    (math.inf, -math.inf),
    (math.inf, 1000),
    (float('nan'), math.inf),
    (float('nan'), float('nan'))
]

for a, b in test_pairs:
    result = safe_compare(a, b)
    print(f"{a} vs {b}: {result}")

ソート処理での無限大

import math

# 無限大を含むリストのソート
numbers = [1, 5, math.inf, 3, -math.inf, 2, float('nan')]
print(f"元のリスト: {numbers}")

# ソート（NaNの扱いに注意）
sorted_numbers = sorted(numbers, key=lambda x: (math.isnan(x), x))
print(f"ソート後: {sorted_numbers}")

# NaNを除いてソート
filtered_numbers = [x for x in numbers if not math.isnan(x)]
sorted_filtered = sorted(filtered_numbers)
print(f"NaN除去後ソート: {sorted_filtered}")

実用的な活用例

最大値・最小値の初期化

import math

def find_min_max(numbers):
    """リストから最小値・最大値を見つける"""
    if not numbers:
        return None, None
    
    min_val = math.inf    # 正の無限大で初期化
    max_val = -math.inf   # 負の無限大で初期化
    
    for num in numbers:
        if not math.isnan(num):  # NaNは除外
            min_val = min(min_val, num)
            max_val = max(max_val, num)
    
    return min_val, max_val

# テスト
test_list = [3, 1, 4, 1, 5, 9, 2, 6]
min_result, max_result = find_min_max(test_list)
print(f"最小値: {min_result}, 最大値: {max_result}")

# 空リストのテスト
empty_min, empty_max = find_min_max([])
print(f"空リスト - 最小値: {empty_min}, 最大値: {empty_max}")

数値の制限処理

import math

def clamp(value, min_val=-math.inf, max_val=math.inf):
    """値を指定範囲内に制限"""
    if math.isnan(value):
        return value  # NaNはそのまま返す
    
    return max(min_val, min(value, max_val))

# テスト例
test_values = [5, 15, -5, math.inf, -math.inf, float('nan')]
for val in test_values:
    clamped = clamp(val, 0, 10)  # 0-10の範囲に制限
    print(f"{val} → {clamped}")

数学関数での無限大処理

import math

def safe_log(x):
    """安全な対数計算"""
    if x <= 0:
        return -math.inf
    elif math.isinf(x):
        return math.inf
    else:
        return math.log(x)

def safe_exp(x):
    """安全な指数計算"""
    try:
        result = math.exp(x)
        return result
    except OverflowError:
        return math.inf

# テスト
log_tests = [1, 10, 0, -1, math.inf]
for val in log_tests:
    result = safe_log(val)
    print(f"safe_log({val}) = {result}")

exp_tests = [1, 10, 100, 1000, -math.inf]
for val in exp_tests:
    result = safe_exp(val)
    print(f"safe_exp({val}) = {result}")

JSON・文字列での無限大の扱い

JSON化での注意点

import json
import math

# 無限大を含むデータ
data = {
    'normal': 42,
    'positive_inf': math.inf,
    'negative_inf': -math.inf,
    'not_a_number': float('nan')
}

# 標準JSONでは無限大は扱えない
try:
    json_str = json.dumps(data)
except ValueError as e:
    print(f"JSON変換エラー: {e}")

# 代替方法：文字列に変換
def inf_to_str(obj):
    """無限大を文字列に変換するヘルパー"""
    if math.isinf(obj):
        return "Infinity" if obj > 0 else "-Infinity"
    elif math.isnan(obj):
        return "NaN"
    return obj

# データを変換
converted_data = {k: inf_to_str(v) for k, v in data.items()}
json_str = json.dumps(converted_data)
print(f"JSON文字列: {json_str}")

文字列との相互変換

import math

def str_to_number(s):
    """文字列を数値に変換（無限大対応）"""
    s = s.strip().lower()
    if s in ['inf', 'infinity', '+inf', '+infinity']:
        return math.inf
    elif s in ['-inf', '-infinity']:
        return -math.inf
    elif s in ['nan', 'not a number']:
        return float('nan')
    else:
        try:
            return float(s)
        except ValueError:
            return None

def number_to_str(num):
    """数値を読みやすい文字列に変換"""
    if math.isinf(num):
        return "正の無限大" if num > 0 else "負の無限大"
    elif math.isnan(num):
        return "非数(NaN)"
    else:
        return str(num)

# テスト
test_strings = ["42", "inf", "-infinity", "nan", "invalid"]
for s in test_strings:
    num = str_to_number(s)
    readable = number_to_str(num) if num is not None else "変換不能"
    print(f"'{s}' → {num} → {readable}")

パフォーマンスと注意点

計算速度への影響

import time
import math

def benchmark_operations():
    """無限大演算のパフォーマンステスト"""
    iterations = 1000000
    
    # 通常の数値演算
    start = time.time()
    for _ in range(iterations):
        result = 1.0 + 2.0
    normal_time = time.time() - start
    
    # 無限大演算
    start = time.time()
    for _ in range(iterations):
        result = math.inf + 2.0
    inf_time = time.time() - start
    
    # 無限大判定
    start = time.time()
    for _ in range(iterations):
        result = math.isinf(math.inf)
    check_time = time.time() - start
    
    print(f"通常演算: {normal_time:.6f}秒")
    print(f"無限大演算: {inf_time:.6f}秒")
    print(f"無限大判定: {check_time:.6f}秒")

benchmark_operations()

まとめ

Python の無限大（inf）は、数学的な無限大概念をプログラムで扱うための強力な機能です。math.inf や float('inf') で作成でき、基本的な算術演算も可能です。ただし、無限大同士の減算や乗算では NaN が生成される場合があるため、math.isinf() や math.isfinite() を使った適切な判定が重要です。科学計算や数値解析において、境界値や初期値として活用することで、より堅牢なプログラムを作成できます。

■プロンプトだけでオリジナルアプリを開発・公開してみた！！

■AI時代の第一歩！「AI駆動開発コース」はじめました！

テックジム東京本校で先行開始。

■テックジム東京本校

「武田塾」のプログラミング版といえば「テックジム」。
講義動画なし、教科書なし。「進捗管理とコーチング」で効率学習。
より早く、より安く、しかも対面型のプログラミングスクールです。

＜短期講習＞5日で5万円の「Pythonミニキャンプ」開催中。

＜月1開催＞放送作家による映像ディレクター養成講座

＜オンライン無料＞ゼロから始めるPython爆速講座