mdickinson · Feb 27, 2023 · Feb 10, 2023 · Feb 10, 2023 · Feb 11, 2023 · Feb 11, 2023
diff --git a/Lib/fractions.py b/Lib/fractions.py
@@ -301,7 +301,7 @@ def from_float(cls, f):
         elif not isinstance(f, float):
             raise TypeError("%s.from_float() only takes floats, not %r (%s)" %
                             (cls.__name__, f, type(f).__name__))
-        return cls(*f.as_integer_ratio())
+        return cls._from_pair(*f.as_integer_ratio())
 
     @classmethod
     def from_decimal(cls, dec):
@@ -313,7 +313,19 @@ def from_decimal(cls, dec):
             raise TypeError(
                 "%s.from_decimal() only takes Decimals, not %r (%s)" %
                 (cls.__name__, dec, type(dec).__name__))
-        return cls(*dec.as_integer_ratio())
+        return cls._from_pair(*dec.as_integer_ratio())
+
+    @classmethod
+    def _from_pair(cls, numerator, denominator, /):
+        """Convert a pair of int's to a rational number, for internal use.
+
+        The ratio of integers should be in lowest terms and
+        the denominator is positive.
+        """
+        obj = super(Fraction, cls).__new__(cls)
+        obj._numerator = numerator
+        obj._denominator = denominator
+        return obj
 
     def is_integer(self):
         """Return True if the Fraction is an integer."""
@@ -380,9 +392,9 @@ def limit_denominator(self, max_denominator=1000000):
         # the distance from p1/q1 to self is d/(q1*self._denominator). So we
         # need to compare 2*(q0+k*q1) with self._denominator/d.
         if 2*d*(q0+k*q1) <= self._denominator:
-            return Fraction(p1, q1, _normalize=False)
+            return Fraction._from_pair(p1, q1)
         else:
-            return Fraction(p0+k*p1, q0+k*q1, _normalize=False)
+            return Fraction._from_pair(p0+k*p1, q0+k*q1)
 
     @property
     def numerator(a):
@@ -703,13 +715,13 @@ def _add(a, b):
         nb, db = b._numerator, b._denominator
         g = math.gcd(da, db)
         if g == 1:
-            return Fraction(na * db + da * nb, da * db, _normalize=False)
+            return Fraction._from_pair(na * db + da * nb, da * db)
         s = da // g
         t = na * (db // g) + nb * s
         g2 = math.gcd(t, g)
         if g2 == 1:
-            return Fraction(t, s * db, _normalize=False)
-        return Fraction(t // g2, s * (db // g2), _normalize=False)
+            return Fraction._from_pair(t, s * db)
+        return Fraction._from_pair(t // g2, s * (db // g2))
 
     __add__, __radd__ = _operator_fallbacks(_add, operator.add)
 
@@ -719,13 +731,13 @@ def _sub(a, b):
         nb, db = b._numerator, b._denominator
         g = math.gcd(da, db)
         if g == 1:
-            return Fraction(na * db - da * nb, da * db, _normalize=False)
+            return Fraction._from_pair(na * db - da * nb, da * db)
         s = da // g
         t = na * (db // g) - nb * s
         g2 = math.gcd(t, g)
         if g2 == 1:
-            return Fraction(t, s * db, _normalize=False)
-        return Fraction(t // g2, s * (db // g2), _normalize=False)
+            return Fraction._from_pair(t, s * db)
+        return Fraction._from_pair(t // g2, s * (db // g2))
 
     __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub)
 
@@ -741,15 +753,17 @@ def _mul(a, b):
         if g2 > 1:
             nb //= g2
             da //= g2
-        return Fraction(na * nb, db * da, _normalize=False)
+        return Fraction._from_pair(na * nb, db * da)
 
     __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul)
 
     def _div(a, b):
         """a / b"""
         # Same as _mul(), with inversed b.
-        na, da = a._numerator, a._denominator
         nb, db = b._numerator, b._denominator
+        if nb == 0:
+            raise ZeroDivisionError('Fraction(%s, 0)' % db)
+        na, da = a._numerator, a._denominator
         g1 = math.gcd(na, nb)
         if g1 > 1:
             na //= g1
@@ -761,7 +775,7 @@ def _div(a, b):
         n, d = na * db, nb * da
         if d < 0:
             n, d = -n, -d
-        return Fraction(n, d, _normalize=False)
+        return Fraction._from_pair(n, d)
 
     __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv)
 
@@ -798,17 +812,17 @@ def __pow__(a, b):
             if b.denominator == 1:
                 power = b.numerator
                 if power >= 0:
-                    return Fraction(a._numerator ** power,
-                                    a._denominator ** power,
-                                    _normalize=False)
-                elif a._numerator >= 0:
-                    return Fraction(a._denominator ** -power,
-                                    a._numerator ** -power,
-                                    _normalize=False)
+                    return Fraction._from_pair(a._numerator ** power,
+                                               a._denominator ** power)
+                elif a._numerator > 0:
+                    return Fraction._from_pair(a._denominator ** -power,
+                                               a._numerator ** -power)
+                elif a._numerator == 0:
+                    raise ZeroDivisionError('Fraction(%s, 0)' %
+                                            a._denominator ** -power)
                 else:
-                    return Fraction((-a._denominator) ** -power,
-                                    (-a._numerator) ** -power,
-                                    _normalize=False)
+                    return Fraction._from_pair((-a._denominator) ** -power,
+                                               (-a._numerator) ** -power)
             else:
                 # A fractional power will generally produce an
                 # irrational number.
@@ -832,15 +846,15 @@ def __rpow__(b, a):
 
     def __pos__(a):
         """+a: Coerces a subclass instance to Fraction"""
-        return Fraction(a._numerator, a._denominator, _normalize=False)
+        return Fraction._from_pair(a._numerator, a._denominator)
 
     def __neg__(a):
         """-a"""
-        return Fraction(-a._numerator, a._denominator, _normalize=False)
+        return Fraction._from_pair(-a._numerator, a._denominator)
 
     def __abs__(a):
         """abs(a)"""
-        return Fraction(abs(a._numerator), a._denominator, _normalize=False)
+        return Fraction._from_pair(abs(a._numerator), a._denominator)
 
     def __int__(a, _index=operator.index):
         """int(a)"""

diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
@@ -488,6 +488,7 @@ def testArithmetic(self):
         self.assertEqual(F(5, 6), F(2, 3) * F(5, 4))
         self.assertEqual(F(1, 4), F(1, 10) / F(2, 5))
         self.assertEqual(F(-15, 8), F(3, 4) / F(-2, 5))
+        self.assertRaises(ZeroDivisionError, operator.truediv, F(1), F(0))
         self.assertTypedEquals(2, F(9, 10) // F(2, 5))
         self.assertTypedEquals(10**23, F(10**23, 1) // F(1))
         self.assertEqual(F(5, 6), F(7, 3) % F(3, 2))

diff --git a/Lib/test/test_numeric_tower.py b/Lib/test/test_numeric_tower.py
@@ -145,7 +145,7 @@ def test_fractions(self):
         # The numbers ABC doesn't enforce that the "true" division
         # of integers produces a float.  This tests that the
         # Rational.__float__() method has required type conversions.
-        x = F(DummyIntegral(1), DummyIntegral(2), _normalize=False)
+        x = F._from_pair(DummyIntegral(1), DummyIntegral(2))
         self.assertRaises(TypeError, lambda: x.numerator/x.denominator)
         self.assertEqual(float(x), 0.5)
 

diff --git a/Misc/NEWS.d/next/Library/2023-02-10-11-59-13.gh-issue-101773.J_kI7y.rst b/Misc/NEWS.d/next/Library/2023-02-10-11-59-13.gh-issue-101773.J_kI7y.rst
@@ -0,0 +1 @@
+Optimize :class:`fractions.Fraction` for small components.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Optimize :class:`fractions.Fraction` for small components.
Comment thread skirpichev marked this conversation as resolved. Outdated