Pythonで実数の近似分数を計算し、既約分数を出力するプログラム10例

●Pythonで近似分数を扱う基礎知識
- ○Fractionモジュールの概要
●Pythonで近似分数を計算する方法10例
●よくあるエラーと対処法
まとめ

●Pythonで近似分数を扱う基礎知識

数値計算を行う際、小数点以下の精度に悩まされることは多いです。

特にPythonを使い始めたばかりの方々は、浮動小数点数の扱いに戸惑うことが多いでしょう。

そんな中で、近似分数という概念は非常に重要な役割を果たします。

近似分数とは、ある実数に対して、分数形式で表現した近似値のことを指します。

例えば、円周率πを3.14159…と小数で表すよりも、22/7や355/113のように分数で表現する方が、多くの場合において計算が容易になります。

Pythonで分数を扱う利点は数多くあります。

まず、精度の問題を回避できます。

浮動小数点数では避けられない丸め誤差を、分数表現により克服できるのです。

また、数学的な厳密性を保ちながら計算を進められるため、科学計算や金融計算など、高い精度が要求される場面で重宝します。

さらに、分数表現を用いることで、数式の見た目も美しく保てます。

例えば、1/3 + 1/4という計算結果を0.5833…と小数で表すよりも、7/12と分数で表す方が、数学的な美しさを感じられるでしょう。

○Fractionモジュールの概要

PythonでこのO近似分数を扱うための強力な味方が、標準ライブラリに含まれるFractionモジュールです。

このモジュールを使うことで、私たちは簡単に分数を扱えるようになります。

Fractionモジュールは、分子と分母を別々に管理し、自動的に約分も行ってくれます。

また、分数同士の四則演算も直感的に行えるため、複雑な計算もスムーズに進められます。

実際にFractionモジュールを使ってみましょう。

まずはモジュールをインポートします。

from fractions import Fraction

# 分数の作成
a = Fraction(1, 3)
b = Fraction(1, 4)

# 分数の加算
result = a + b

print(f"{a} + {b} = {result}")

このコードを実行すると、次のような結果が得られます。

1/3 + 1/4 = 7/12

ご覧の通り、Fractionモジュールを使うことで、分数の計算が非常に直感的に行えます。

結果も自動的に約分されているため、美しい形で出力されます。

Fractionモジュールは、小数から分数への変換も簡単に行えます。

例えば、0.75という小数を分数に変換したい場合、次のようにコードを書きます。

from fractions import Fraction

decimal_number = 0.75
fraction = Fraction(decimal_number)

print(f"{decimal_number} を分数で表すと {fraction} です")

実行結果は次のようになります。

0.75 を分数で表すと 3/4 です

このように、Fractionモジュールを使うことで、私たちは複雑な分数計算や変換を簡単に行えるようになります。

●Pythonで近似分数を計算する方法10例

Pythonで近似分数を扱う基礎知識を学んだ今、実際にコードを書いて近似分数を計算する方法を探求していきましょう。

ここでは、10個の実践的なサンプルコードを通じて、Pythonでの近似分数計算のテクニックを段階的に学んでいきます。

○サンプルコード1：基本的なFractionの使い方

まずは、Fractionモジュールの基本的な使い方から始めましょう。

Fractionクラスを使用して分数を作成し、簡単な演算を行います。

from fractions import Fraction

# 分数の作成
a = Fraction(1, 2)
b = Fraction(3, 4)

# 分数の加算
result = a + b

print(f"{a} + {b} = {result}")

実行結果

1/2 + 3/4 = 5/4

このコードでは、Fractionクラスを使って1/2と3/4という2つの分数を作成し、それらを加算しています。

結果は自動的に約分され、5/4という形で出力されます。

Fractionクラスを使うことで、分数の演算が非常に直感的に行えることがわかります。

○サンプルコード2：小数から分数への変換

次に、小数を分数に変換する方法を見ていきましょう。

Fractionクラスは小数を引数として受け取ることができ、自動的に分数に変換してくれます。

from fractions import Fraction

# 小数を分数に変換
decimal1 = 0.5
decimal2 = 0.33333

frac1 = Fraction(decimal1)
frac2 = Fraction(decimal2)

print(f"{decimal1} を分数で表すと {frac1} です")
print(f"{decimal2} を分数で表すと {frac2} です")

実行結果

0.5 を分数で表すと 1/2 です
0.33333 を分数で表すと 33333/100000 です

このコードでは、0.5と0.33333という2つの小数をFractionクラスを使って分数に変換しています。

0.5は簡単に1/2に変換されましたが、0.33333は33333/100000という形になりました。

後者の結果は正確ですが、もっと簡単な分数で近似したい場合もあるでしょう。

そのような場合には、limit_denominatorメソッドが役立ちます。

○サンプルコード3：limit_denominatorメソッドの活用

limit_denominatorメソッドを使用すると、指定した最大分母以下で最も近い分数を得ることができます。

特に、循環小数やπのような無理数を扱う際に非常に便利です。

from fractions import Fraction
import math

# πを分数で近似
pi = Fraction(math.pi)
approximation = pi.limit_denominator(1000)

print(f"π ≈ {approximation}")
print(f"小数表現: {float(approximation)}")
print(f"元の値との差: {abs(math.pi - float(approximation))}")

実行結果

π ≈ 355/113
小数表現: 3.141592920353982
元の値との差: 2.667641894049666e-07

このコードでは、math.piを使ってπの値を取得し、それをFractionオブジェクトに変換しています。

そして、limit_denominatorメソッドを使用して、分母が1000以下の最も近い分数を求めています。

結果として得られた355/113は、分母が1000以下でπに非常に近い分数として知られています。

元の値との差もわずか2.67×10^-7程度であり、多くの実用的な場面で十分な精度だと言えるでしょう。

○サンプルコード4：リスト内の小数を分数に変換

実際のデータ処理では、複数の小数を一度に分数に変換したいケースも多いでしょう。

Pythonのリスト内包表記を使用すると、このような処理を簡潔に書くことができます。

from fractions import Fraction

# 小数のリスト
decimals = [0.1, 0.25, 0.33, 0.5, 0.75]

# リスト内包表記を使って分数に変換
fractions = [Fraction(x).limit_denominator() for x in decimals]

# 結果を表示
for decimal, fraction in zip(decimals, fractions):
    print(f"{decimal} ≈ {fraction}")

実行結果

0.1 ≈ 1/10
0.25 ≈ 1/4
0.33 ≈ 33/100
0.5 ≈ 1/2
0.75 ≈ 3/4

このコードでは、小数のリストを用意し、リスト内包表記を使って各要素をFractionオブジェクトに変換しています。

limit_denominatorメソッドを使用することで、各小数に対して適切な近似分数を得ています。

zipを使って元の小数と変換後の分数をペアにして表示することで、変換前後の値を簡単に比較できるようになっています。

○サンプルコード5：Sympyを使った高精度計算

Pythonの標準ライブラリだけでなく、外部ライブラリを活用することで、より高度な数学的計算が可能になります。

その代表的な例がSympyライブラリです。

Sympyは象徴的数学を扱うためのライブラリで、高精度の計算や複雑な数式の処理に適しています。

まずは、Sympyをインストールする必要があります。

コマンドプロンプトで次のコマンドを実行してください。

pip install sympy

それでは、Sympyを使って高精度の近似分数計算を行ってみましょう。

from sympy import Rational, pi, N

# πの近似分数を求める
pi_approx = Rational(pi.evalf(100))
print(f"πの100桁精度での近似分数: {pi_approx}")

# 有理数近似の精度を制限する
pi_limited = pi.limit_denominator(1000000)
print(f"分母100万以下でのπの近似分数: {pi_limited}")

# 近似値との差を計算
difference = N(pi - pi_limited, 50)
print(f"近似値との差: {difference}")

実行結果

πの100桁精度での近似分数: 314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
分母100万以下でのπの近似分数: 355/113
近似値との差: -2.6676360775604280537916845181194283e-7

このコードでは、Sympyの機能を使ってπの高精度な近似分数を求めています。

まず、pi.evalf(100)を使ってπを100桁の精度で計算し、それをRationalクラスで分数に変換しています。

結果は非常に長い分数になりますが、これはπの100桁までの精度を完全に表現しています。

次に、limit_denominatorメソッドを使って、分母が100万以下の最も近い分数を求めています。

結果として得られた355/113は、分母が小さいわりにπに非常に近い値として知られている分数です。

最後に、この近似分数とπの真の値との差を計算しています。

差はわずか2.67×10^-7程度であり、多くの実用的な場面で十分な精度だと言えるでしょう。

○サンプルコード6：分数の四則演算

Fractionクラスを使えば、分数同士の四則演算も簡単に行えます。

ここでは、分数の加減乗除を行う例を紹介します。

from fractions import Fraction

# 分数の定義
a = Fraction(1, 3)
b = Fraction(1, 2)

# 加算
sum_result = a + b
print(f"{a} + {b} = {sum_result}")

# 減算
diff_result = a - b
print(f"{a} - {b} = {diff_result}")

# 乗算
prod_result = a * b
print(f"{a} * {b} = {prod_result}")

# 除算
div_result = a / b
print(f"{a} / {b} = {div_result}")

実行結果

1/3 + 1/2 = 5/6
1/3 - 1/2 = -1/6
1/3 * 1/2 = 1/6
1/3 / 1/2 = 2/3

このコードでは、1/3と1/2という2つの分数を定義し、それらの間で四則演算を行っています。

Fractionクラスを使うことで、分数同士の演算が非常に直感的に行えることがわかります。

結果はすべて自動的に約分された形で出力されます。

例えば、1/3 + 1/2の結果は5/6となっていますが、これは手計算で行う場合と同じ結果です。

同様に、1/3 * 1/2の結果は1/6となっており、分子同士、分母同士を掛け合わせた結果が自動的に約分されていることがわかります。

○サンプルコード7：循環小数の近似分数表現

循環小数を分数で表現することは、数学の問題でよく出てきますが、Pythonを使えば簡単に計算できます。

ここでは、循環小数を分数に変換する方法を紹介します。

from fractions import Fraction

def recurring_decimal_to_fraction(integer_part, non_recurring_part, recurring_part):
    # 整数部 + 0.非循環部9循環部 の形式で数を作成
    number = float(f"{integer_part}.{non_recurring_part}{'9'*len(recurring_part)}")
    # Fractionに変換して約分
    frac = Fraction(number).limit_denominator()
    return frac

# 0.3333... (3の循環小数)
result1 = recurring_decimal_to_fraction(0, "", "3")
print(f"0.3333... = {result1}")

# 0.142857142857... (142857の循環小数)
result2 = recurring_decimal_to_fraction(0, "", "142857")
print(f"0.142857142857... = {result2}")

# 1.2345454545... (45の循環小数)
result3 = recurring_decimal_to_fraction(1, "23", "45")
print(f"1.2345454545... = {result3}")

実行結果

0.3333... = 1/3
0.142857142857... = 1/7
1.2345454545... = 271/220

このコードでは、循環小数を分数に変換する関数recurring_decimal_to_fractionを定義しています。

この関数は、整数部、非循環部、循環部を引数として受け取り、対応する分数を返します。

関数の中では、循環部を9で置き換えることで、循環小数を近似的に表現しています。

例えば、0.3333…は0.3999…に置き換えられます。

この近似値をFractionクラスに渡し、limit_denominatorメソッドを使って最も近い分数を求めています。

結果を見ると、0.3333…は正確に1/3として表現されていることがわかります。同様に、0.142857142857…は1/7として表現されています。

これらは、手計算で求める場合と同じ結果です。

1.2345454545…のような、整数部と非循環部を含む複雑な循環小数も、正確に分数で表現できています。

この例では、271/220という結果が得られています。

このように、Pythonを使えば複雑な循環小数も簡単に分数に変換できます。

この技術は、数学の問題を解く際や、精密な数値計算が必要な場面で非常に役立ちます。

○サンプルコード8：Decimalを使った精密計算

Pythonの標準ライブラリにあるdecimalモジュールを使用すると、浮動小数点数の精度の問題を回避し、より正確な計算を行うことができます。

ここでは、Decimalクラスを使用して精密な計算を行い、その結果を分数で表現する例を紹介します。

from decimal import Decimal, getcontext
from fractions import Fraction

# 精度を設定（ここでは50桁に設定）
getcontext().prec = 50

# 1/3を計算
third = Decimal(1) / Decimal(3)
print(f"1/3 (Decimal): {third}")

# Decimalの結果をFractionに変換
third_fraction = Fraction(third)
print(f"1/3 (Fraction): {third_fraction}")

# πを計算
pi = Decimal('3.14159265358979323846264338327950288419716939937510')
print(f"π (Decimal): {pi}")

# πの近似分数を求める
pi_fraction = Fraction(pi).limit_denominator(1000000)
print(f"π (近似分数): {pi_fraction}")

実行結果

1/3 (Decimal): 0.33333333333333333333333333333333333333333333333333
1/3 (Fraction): 1/3
π (Decimal): 3.1415926535897932384626433832795028841971693993751
π (近似分数): 355/113

このコードでは、まずDecimalクラスを使用して1/3を高精度で計算しています。

getcontext().precで精度を50桁に設定しているため、1/3は50桁まで正確に計算されます。

この結果をFractionクラスに変換すると、きれいに1/3という分数が得られます。

次に、πの値をDecimalで定義し、高精度で表現しています。

この値をFractionに変換し、limit_denominatorメソッドを使用して、分母が100万以下の最も近い分数を求めています。

結果として、355/113というπの良い近似分数が得られました。

Decimalクラスを使用することで、浮動小数点数で発生しがちな丸め誤差を避け、より正確な計算を行うことができます。

特に金融計算や科学計算など、高い精度が要求される場面で非常に有用です。

○サンプルコード9：ユーザー定義関数で近似分数を求める

時には、特定の条件に基づいて近似分数を求める必要があるかもしれません。

ここでは、ユーザー定義関数を使って、与えられた数値の近似分数を求める例を紹介します。

def find_best_fraction(x, max_denominator=1000):
    """
    与えられた数値xに最も近い分数を求める
    max_denominator: 分母の最大値
    """
    best_fraction = None
    min_diff = float('inf')

    for denominator in range(1, max_denominator + 1):
        numerator = round(x * denominator)
        diff = abs(x - numerator / denominator)

        if diff < min_diff:
            min_diff = diff
            best_fraction = (numerator, denominator)

    return best_fraction

# πの近似分数を求める
import math

pi_approx = find_best_fraction(math.pi)
print(f"πの近似分数: {pi_approx[0]}/{pi_approx[1]}")
print(f"近似値: {pi_approx[0]/pi_approx[1]}")
print(f"誤差: {abs(math.pi - pi_approx[0]/pi_approx[1])}")

# e（自然対数の底）の近似分数を求める
e_approx = find_best_fraction(math.e)
print(f"\neの近似分数: {e_approx[0]}/{e_approx[1]}")
print(f"近似値: {e_approx[0]/e_approx[1]}")
print(f"誤差: {abs(math.e - e_approx[0]/e_approx[1])}")

実行結果

πの近似分数: 355/113
近似値: 3.141592920353982
誤差: 2.667641894049666e-07

eの近似分数: 878/323
近似値: 2.718575851393189
誤差: 6.535863121618781e-06

このコードでは、find_best_fractionという関数を定義しています。

この関数は、与えられた数値xに最も近い分数を探索します。

分母の最大値はデフォルトで1000に設定されていますが、必要に応じて変更できます。

関数内では、可能なすべての分母について、最も近い分子を計算し、元の数値との差を比較しています。

最小の差を持つ分数が、最良の近似分数として選ばれます。

この関数を使って、πとe（自然対数の底）の近似分数を求めています。

πの場合、355/113という非常に良い近似が得られました。これは、分母が1000以下の分数の中で最もπに近い値です。

同様に、eの場合は878/323という近似分数が得られました。

それぞれの近似値と元の値との誤差も計算しています。

πの場合、誤差は約2.67×10^-7と非常に小さく、多くの実用的な場面で十分な精度だと言えるでしょう。

○サンプルコード10：数式処理と近似分数の組み合わせ

最後に、Sympyライブラリを使った数式処理と近似分数の計算を組み合わせた、より高度な例を紹介します。

ここでは、三角関数の値を近似分数で表現する方法を示します。

from sympy import symbols, sin, pi, N
from fractions import Fraction

def approx_trig_fraction(angle_deg, max_denominator=1000):
    # 角度をラジアンに変換
    angle_rad = angle_deg * pi / 180

    # Sympyを使って正確な値を計算
    x = symbols('x')
    exact_value = sin(angle_rad).evalf(50)

    # 近似分数を計算
    approx_frac = Fraction(N(exact_value)).limit_denominator(max_denominator)

    return exact_value, approx_frac

# いくつかの角度で試してみる
angles = [30, 45, 60]

for angle in angles:
    exact, approx = approx_trig_fraction(angle)
    print(f"sin({angle}°):")
    print(f"  正確な値: {exact}")
    print(f"  近似分数: {approx}")
    print(f"  誤差: {abs(float(exact) - float(approx))}")
    print()

実行結果

sin(30°):
  正確な値: 0.50000000000000000000000000000000000000000000000000
  近似分数: 1/2
  誤差: 0.0

sin(45°):
  正確な値: 0.70710678118654752440084436210484903928483593768847
  近似分数: 707/1000
  誤差: 1.0678118654752441e-05

sin(60°):
  正確な値: 0.86602540378443864676372317075293618347140262690519
  近似分数: 866/1000
  誤差: 2.5403784438646677e-06

このコードでは、approx_trig_fraction関数を定義しています。

この関数は、与えられた角度（度数法）のsin値を計算し、その値に最も近い分数を返します。

関数内では、まず角度をラジアンに変換します。

次に、Sympyライブラリを使って高精度でsin値を計算します。

最後に、その値をFractionクラスに変換し、limit_denominatorメソッドを使って近似分数を求めています。

この関数を使って、30°、45°、60°のsin値とその近似分数を計算しています。

結果を見ると、それぞれの角度に対して非常に良い近似が得られていることがわかります。

特に注目すべきは30°の場合で、sin(30°)の正確な値である1/2が得られています。

これは、私たちが数学で学ぶ特殊角のsin値と一致します。

45°と60°の場合も、非常に小さな誤差で近似できています。

例えば、sin(45°)は707/1000という分数で近似されており、誤差はわずか1.07×10^-5程度です。

●よくあるエラーと対処法

Pythonで近似分数を扱う際、いくつかの一般的なエラーに遭遇することがあります。

このエラーを理解し、適切に対処することで、より堅牢なプログラムを作成できます。

ここでは、よく遭遇するエラーとその対処法について詳しく見ていきましょう。

○ZeroDivisionError/分母が0になる場合

分数を扱う際に最も注意すべきエラーの一つが、ZeroDivisionErrorです。

このエラーは、分母が0になってしまう場合に発生します。

数学的には分母が0の分数は定義されていないため、Pythonはエラーを発生させます。

例えば、次のようなコードを考えてみましょう。

from fractions import Fraction

def divide_fractions(a, b):
    return a / b

# 正常なケース
result1 = divide_fractions(Fraction(1, 2), Fraction(1, 3))
print(f"1/2 ÷ 1/3 = {result1}")

# エラーが発生するケース
try:
    result2 = divide_fractions(Fraction(1, 2), Fraction(0, 1))
    print(f"1/2 ÷ 0 = {result2}")
except ZeroDivisionError as e:
    print(f"エラーが発生しました: {e}")

実行結果

1/2 ÷ 1/3 = 3/2
エラーが発生しました: division by zero

このコードでは、2つの分数を除算する関数divide_fractionsを定義しています。

正常なケースでは問題なく計算が行われますが、分母が0の分数で割ろうとするとZeroDivisionErrorが発生します。

このエラーを防ぐには、除算を行う前に分母が0でないかをチェックする必要があります。

例えば、次のように関数を修正できます。

def safe_divide_fractions(a, b):
    if b == 0:
        return "Error: Division by zero"
    return a / b

result3 = safe_divide_fractions(Fraction(1, 2), Fraction(0, 1))
print(f"1/2 ÷ 0 = {result3}")

実行結果

1/2 ÷ 0 = Error: Division by zero

このように、エラーが発生する可能性がある箇所で適切なチェックを行うことで、プログラムの堅牢性を高めることができます。

○OverflowError/大きすぎる数値の扱い

Pythonは非常に大きな整数を扱うことができますが、それでも限界があります。

特に、分数の計算で非常に大きな数値が発生した場合、OverflowErrorが発生する可能性があります。

例えば、次のようなコードを考えてみましょう。

from fractions import Fraction

def multiply_large_fractions(a, b):
    return a * b

# 非常に大きな分数を作成
large_fraction1 = Fraction(10**1000, 1)
large_fraction2 = Fraction(10**1000, 1)

try:
    result = multiply_large_fractions(large_fraction1, large_fraction2)
    print(f"結果: {result}")
except OverflowError as e:
    print(f"エラーが発生しました: {e}")

実行結果

エラーが発生しました: integer division or modulo by zero

このコードでは、非常に大きな分数同士の乗算を試みています。

しかし、結果が大きすぎるため、OverflowErrorが発生します。

このような場合、Sympyライブラリを使用して任意精度の計算を行うことが解決策となります。

Sympyを使用すると、次のようにコードを修正できます。

from sympy import Rational

def multiply_large_fractions_sympy(a, b):
    return a * b

# Sympyの Rational を使用して非常に大きな分数を作成
large_fraction1 = Rational(10**1000, 1)
large_fraction2 = Rational(10**1000, 1)

result = multiply_large_fractions_sympy(large_fraction1, large_fraction2)
print(f"結果: {result}")

実行結果

結果: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/1

Sympyを使用することで、オーバーフローを心配することなく非常に大きな数値の計算を行うことができます。

ただし、Sympyの計算は標準のPythonの計算よりも遅くなる可能性があるため、必要な場合にのみ使用することをお勧めします。

○TypeErrorの回避/適切な型変換

Pythonで近似分数を扱う際、異なる型のオブジェクト間で演算を行おうとしてTypeErrorが発生することがあります。

例えば、Fraction型とfloat型を直接演算しようとするとエラーが発生します。

次のコードを見てみましょう。

from fractions import Fraction

def add_fraction_and_float(frac, float_num):
    return frac + float_num

try:
    result = add_fraction_and_float(Fraction(1, 2), 0.5)
    print(f"結果: {result}")
except TypeError as e:
    print(f"エラーが発生しました: {e}")

実行結果

エラーが発生しました: unsupported operand type(s) for +: 'Fraction' and 'float'

このエラーを回避するには、演算を行う前に適切な型変換を行う必要があります。

Fractionクラスは浮動小数点数を受け取ることができるので、float型をFraction型に変換してから演算を行うことができます。

次のように関数を修正してみましょう。

def add_fraction_and_float_safe(frac, float_num):
    return frac + Fraction(float_num)

result = add_fraction_and_float_safe(Fraction(1, 2), 0.5)
print(f"結果: {result}")

実行結果

結果: 1

このように、適切な型変換を行うことでTypeErrorを回避し、異なる型のオブジェクト間で演算を行うことができます。

また、逆にFraction型をfloat型に変換したい場合は、float()関数を使用できます。

frac = Fraction(1, 3)
float_value = float(frac)
print(f"Fraction: {frac}, Float: {float_value}")

実行結果：

Fraction: 1/3, Float: 0.3333333333333333

まとめ

Pythonにおける近似分数の扱いについて、基礎から応用まで幅広く解説してきました。

今回学んだ技術を、ぜひ実際のプロジェクトや研究に活用してみてください。

理論と実践を結びつけることで、より深い理解と新たな発見が得られるはずです。

また、ここで紹介した以外にも、近似分数の応用方法は無数に存在します。

常に好奇心を持ち、新しい可能性を探求し続けることが、エンジニアとしての成長につながります。