在Python中计算大分数？

我试图在Python2.7中计算分数。

limit\u分母

方法在该代码的前15次迭代中非常有效。然而，随后代码陷入循环，输出的分母小于1000000

Fraction = 1217471/860882

当我不使用

limit\u分母时，我会得到如下重复输出：

Fraction = 141421356237/100000000000

最后我想迭代
I
到1000，所以我的分数会非常大。有什么帮助吗

from fractions import *
i = 0
x = 1/2.0
x1 = 0
count = 0
while i < 20:
    (y) = (1.0 + (x))
    (x) = (1 / (2.0 + (x)))
    y1 = Fraction(str(y)).limit_denominator()
    print("\nFraction = " + str(y1))
    i += 1

从分数导入*
i=0
x=1/2.0
x1=0
计数=0
而我<20：
（y） =（1.0+（x））
（x） =（1/（2.0+（x）））
y1=分数（str（y））。极限分母（）
打印（“\nFraction=“+str（y1））
i+=1
这些值收敛到sqrt（2.0），这为您提供了精确表示64位浮点值的小数范围。你的有理分数不能比你给它的
浮点数更精确

如果需要更大的分母，则必须指定更大的分母限制。您仍然受到
float
精度的限制：一旦您在计算类型的精度范围内收敛（很可能
float64
），您将无法在其理性表示中获得更高的精度。如果需要更高的精度，请将整体转换为
分数
计算：

from fractions import *

x = Fraction(1,2)

for i in range(40):
    y = Fraction(1) + x
    x = Fraction(1) / (Fraction(2) + x)
    print("Fraction = " + str(y))

输出：

Fraction = 3/2
Fraction = 7/5
Fraction = 17/12
Fraction = 41/29
Fraction = 99/70
Fraction = 239/169
Fraction = 577/408
Fraction = 1393/985
Fraction = 3363/2378
Fraction = 8119/5741
Fraction = 19601/13860
Fraction = 47321/33461
Fraction = 114243/80782
Fraction = 275807/195025
Fraction = 665857/470832
Fraction = 1607521/1136689
Fraction = 3880899/2744210
Fraction = 9369319/6625109
Fraction = 22619537/15994428
Fraction = 54608393/38613965
Fraction = 131836323/93222358
Fraction = 318281039/225058681
Fraction = 768398401/543339720
Fraction = 1855077841/1311738121
Fraction = 4478554083/3166815962
Fraction = 10812186007/7645370045
Fraction = 26102926097/18457556052
Fraction = 63018038201/44560482149
Fraction = 152139002499/107578520350
Fraction = 367296043199/259717522849
Fraction = 886731088897/627013566048
Fraction = 2140758220993/1513744654945
Fraction = 5168247530883/3654502875938
Fraction = 12477253282759/8822750406821
Fraction = 30122754096401/21300003689580
Fraction = 72722761475561/51422757785981
Fraction = 175568277047523/124145519261542
Fraction = 423859315570607/299713796309065
Fraction = 1023286908188737/723573111879672
Fraction = 2470433131948081/1746860020068409

这些值收敛到sqrt（2.0），这为您提供了精确表示64位浮点值的小数范围。你的有理分数不能比你给它的
浮点数更精确

如果需要更大的分母，则必须指定更大的分母限制。您仍然受到
float
精度的限制：一旦您在计算类型的精度范围内收敛（很可能
float64
），您将无法在其理性表示中获得更高的精度。如果需要更高的精度，请将整体转换为
分数
计算：

from fractions import *

x = Fraction(1,2)

for i in range(40):
    y = Fraction(1) + x
    x = Fraction(1) / (Fraction(2) + x)
    print("Fraction = " + str(y))

输出：

Fraction = 3/2
Fraction = 7/5
Fraction = 17/12
Fraction = 41/29
Fraction = 99/70
Fraction = 239/169
Fraction = 577/408
Fraction = 1393/985
Fraction = 3363/2378
Fraction = 8119/5741
Fraction = 19601/13860
Fraction = 47321/33461
Fraction = 114243/80782
Fraction = 275807/195025
Fraction = 665857/470832
Fraction = 1607521/1136689
Fraction = 3880899/2744210
Fraction = 9369319/6625109
Fraction = 22619537/15994428
Fraction = 54608393/38613965
Fraction = 131836323/93222358
Fraction = 318281039/225058681
Fraction = 768398401/543339720
Fraction = 1855077841/1311738121
Fraction = 4478554083/3166815962
Fraction = 10812186007/7645370045
Fraction = 26102926097/18457556052
Fraction = 63018038201/44560482149
Fraction = 152139002499/107578520350
Fraction = 367296043199/259717522849
Fraction = 886731088897/627013566048
Fraction = 2140758220993/1513744654945
Fraction = 5168247530883/3654502875938
Fraction = 12477253282759/8822750406821
Fraction = 30122754096401/21300003689580
Fraction = 72722761475561/51422757785981
Fraction = 175568277047523/124145519261542
Fraction = 423859315570607/299713796309065
Fraction = 1023286908188737/723573111879672
Fraction = 2470433131948081/1746860020068409

正如Prune所说，处理分数时最好避免浮动。如果你想把分数转换成十进制而不损失任何精度，你需要使用像decimal这样有足够精度的数字类型。另一种选择是只使用Python整数，并使用足够大的乘数放大分子

你的数列找到了2的平方根的收敛点。如果你想循环所有的收敛点，你可以使用Prune的答案中显示的算法。但是，如果您想快速计算大量的sqrt（2），有一种更好的方法，称为Hero方法（或Heron方法）。这是牛顿法计算代数方程根的一个特例。在Prune的算法1乘1中，我们不是计算每个
i
的项，而是在每次迭代中将
i
增加一倍，因此分子和分母增长得非常快，在每次循环迭代中使答案的精度增加一倍

这里有一个简短的演示，可以计算精确到100位的sqrt（2）。我通常会使用普通的Python整数（或Python 2中的长整数）来实现这一点，但使用分数也很容易

from __future__ import print_function
from fractions import Fraction as F

digits = 100
m = 10 ** digits

x = F(1, 1)
while x.denominator < m:
    print(x)
    x = x / 2 + 1 / x

print()
print(m * x.numerator // x.denominator)

在Python2.6和3.6上测试，正如Prune所说，在使用分数时最好避免浮动。如果你想把分数转换成十进制而不损失任何精度，你需要使用像decimal这样有足够精度的数字类型。另一种选择是只使用Python整数，并使用足够大的乘数放大分子

你的数列找到了2的平方根的收敛点。如果你想循环所有的收敛点，你可以使用Prune的答案中显示的算法。但是，如果您想快速计算大量的sqrt（2），有一种更好的方法，称为Hero方法（或Heron方法）。这是牛顿法计算代数方程根的一个特例。在Prune的算法1乘1中，我们不是计算每个
i
的项，而是在每次迭代中将
i
增加一倍，因此分子和分母增长得非常快，在每次循环迭代中使答案的精度增加一倍

这里有一个简短的演示，可以计算精确到100位的sqrt（2）。我通常会使用普通的Python整数（或Python 2中的长整数）来实现这一点，但使用分数也很容易

from __future__ import print_function
from fractions import Fraction as F

digits = 100
m = 10 ** digits

x = F(1, 1)
while x.denominator < m:
    print(x)
    x = x / 2 + 1 / x

print()
print(m * x.numerator // x.denominator)

在Python2.6和3.6上测试时，我重写了您的代码，试图解决您的问题，因为我不理解使用
limit\u分母的必要性。结果是：

from fractions import *
x = Fraction(1, 2)
for i in range(1000):
    y = 1 + Fraction(x)
    print 'Y', y
    x = 1 / (2 + x)
    print 'X', x

问题是，计算机并不能真正理解数字，相反，它们在内存中使用一种称为
浮点
（我认为是
浮点
的起源）的数字抽象表示。此表示具有给定的精度（限制），该精度取决于为数据类型保留的内存量。这就是为什么
int32
的可接受值比
int64
少的原因。

然而，
python
有一种智能而高效的大数计算方法。
此外，分数库为您提供了一种表示数字（分数）的方法，这些数字（分数）不受
浮点
数字约束的约束（毕竟它不是计算机）。
如果你想更深入地研究浮点算法，我推荐《包袱与费尔斯》的《全能的数值分析》和《大卫·汉姆博士的数值方法》，因为我不明白这两种方法的必要性，所以我重新编写了你的代码，试图解决你的问题
限制\u分母
。结果是：

from fractions import *
x = Fraction(1, 2)
for i in range(1000):
    y = 1 + Fraction(x)
    print 'Y', y
    x = 1 / (2 + x)
    print 'X', x

问题是，计算机并不能真正理解数字，相反，它们在内存中使用一种称为
浮点
（我认为是
浮点
的起源）的数字抽象表示。此表示有一个gi