Calculate Exact Ratios with Fraction

Select a timestamp to watch that moment on YouTube.

1. 00:00

   Some quantities are naturally ratios: one third of a recipe, two votes out of five, or a scale factor of three over seven. A floating-point number approximates many such ratios. That is often fine for measurements, but it can surprise us when a program expects an exact rational answer. Python's `fractions.Fraction` stores a numerator and denominator as integers and reduces them automatically. In this lesson we will first see a decimal approximation, then compare two ways to construct a fraction from the number 0.1. That distinction matters because a float already contains an approximation before `Fraction` sees it.

2. 00:42

   We will build exact arithmetic from integer pairs and decimal strings, then verify simplification and invalid denominators. This is not a blanket instruction to replace every float. Numerical work has different requirements: some applications need fast approximate real-number calculations, while some need exact ratios or decimal rounding rules. We will choose the representation that fits the data. Try the examples in the lesson console and inspect the printed numerator and denominator, not just the final decimal display. The first value is a finite approximation to one third.

3. 01:22

   In this particular multiplication, the rounded float result is one point zero, so this test happens to look exact. That does not mean the stored `third` was an exact rational one third. The last comparison gives us a familiar counterexample: 0.1 plus 0.2 is not stored as exactly the same float as 0.3. We must not judge the representation by one successful arithmetic identity. A recipe program might only display a rounded quantity, where a float is fine. A symbolic ratio or a test that must preserve exact numerator and denominator calls for a different representation.

4. 02:03

   A common attempted fix is to take a float that already exists and wrap it in `Fraction`, assuming this recovers the decimal value the human intended. It cannot know that intent. The next run will show the exact rational value of the float itself, then the value created from a decimal string. `Fraction(0.1)` describes the exact rational value of the stored binary float. That value has a large denominator and is slightly different from the mathematical decimal one tenth. The string form says what we actually mean: decimal text `0.1`, which becomes one tenth. The integer pair makes the same intent even more direct.

5. 02:46

   Both latter constructions compare equal. This is a subtle but useful rule: choose an exact input before constructing the fraction. Converting an already approximate float into a fraction does not reverse earlier rounding. The method `limit_denominator` can find a nearby simple rational from a float, which can be useful for recovery or display, but it is a heuristic and should not replace knowing the intended ratio. If your source data is a decimal string from a CSV file, passing the string directly can preserve the decimal meaning. If it is genuinely a sensor float, the large denominator reflects the actual stored approximation.

6. 03:28

   Those are different situations, and the constructor cannot decide which one applies. Three exact thirds sum to one exactly. `Fraction(6, 8)` is reduced to three fourths, and multiplying two fifths by fifteen produces six. The numerator and denominator attributes let us inspect the stored ratio instead of relying on a decimal rendering. These calculations use integer arithmetic internally, so they do not accumulate binary rounding error from each step. There are still practical limits. Numerators and denominators can grow large during complex calculations, which can cost time and memory.

7. 04:09

   At the edge of an application, you may need to convert a fraction to a decimal string or a float for display or for another system. That conversion is where you choose a rounding rule. Do it deliberately and as late as the application allows. A price computation may be better served by `Decimal` and currency-specific rounding than by `Fraction`; the fact that a ratio is exact does not automatically answer financial rules. In this lesson, the domain is ratios, and integer-pair construction communicates that domain clearly. These checks cover identities that should be exact when the inputs are exact.

8. 04:49

   One third times three is one; six eighths equals three fourths after simplification; and decimal strings representing one tenth and two tenths sum to three tenths. We also inspect the numerator and reject a zero denominator, because no rational number has that form. Notice that the decimal-string test has a different result from the familiar float comparison in the broken run. That is the whole point: the input representation changed. Try substituting `Fraction(0.1)` for `Fraction('0.1')` and predict whether the equality with three tenths still holds. Then print the denominator and explain why.

9. 05:30

   The practice task on the page asks you to express quantities as ratios, carry out a calculation, and test a boundary case. When you finish, you should be able to answer not just how to import `Fraction`, but when an exact ratio is a better fit than an approximate float and how to avoid importing an approximation by accident.