Write a program to add three fraction numbers in python

Question

Run

Nội dung chính Show

Python Math: Exercise-46 with Solution
Python: Tips of the Day
How do you add fractions in numbers in Python?
How do you add 3 or more fractions with different denominators?

def findGCD(n1, n2):
    gcd = 0
    for i in range(1, int(min(n1, n2)) + 1):
        if n1 % i == 0 and n2 % i == 0:
            gcd = i
    return gcd


# input first fraction
num1, den1 = map(int, list(input("Enter numerator and denominator of first number : ").split(" ")))

# input first fraction
num2, den2 = map(int, list(input("Enter numerator and denominator of second number: ").split(" ")))

lcm = (den1 * den2) // findGCD(den1, den2)

sum = (num1 * lcm // den1) + (num2 * lcm // den2)

num3 = sum // findGCD(sum, lcm)

lcm = lcm // findGCD(sum, lcm)

print(num1, "/", den1, " + ", num2, "/", den2, " = ", num3, "/", lcm)

Output

Enter numerator and denominator of first number : 14 10
Enter numerator and denominator of second number: 24 3
14 / 10 + 24 / 3 = 47 / 5

Last update on August 19 2022 21:51:39 (UTC/GMT +8 hours)

Python Math: Exercise-46 with Solution

Write a Python program to add, subtract, multiply and divide two fractions.

Sample Solution:-

Python Code:

import fractions

f1 = fractions.Fraction(2, 3)
f2 = fractions.Fraction(3, 7)

print('{} + {} = {}'.format(f1, f2, f1 + f2))
print('{} - {} = {}'.format(f1, f2, f1 - f2))
print('{} * {} = {}'.format(f1, f2, f1 * f2))
print('{} / {} = {}'.format(f1, f2, f1 / f2))

Sample Output:

2/3 + 3/7 = 23/21                                                                                             
2/3 - 3/7 = 5/21                                                                                              
2/3 * 3/7 = 2/7                                                                                               
2/3 / 3/7 = 14/9

Flowchart:

$Write a program to add three fraction numbers in python$

Python Code Editor:

Have another way to solve this solution? Contribute your code (and comments) through Disqus.

Previous: Write a Python program to create the fraction instances of decimal numbers.
Next: Write a Python program to convert a floating point number (PI) to an approximate rational value on the various denominator.

Python: Tips of the Day

Combining Lists Using Zip:

Takes multiple collections and returns a new collection.
The new collection contains items where each item contains one element from each input collection.
It allows us to transverse multiple collections at the same time.

name = 'abcdef'
suffix = [1,2,3,4,5,6]
zip(name, suffix)
--> returns (a,1),(b,2),(c,3),(d,4),(e,5),(f,6)

Source code: Lib/fractions.py

The fractions module provides support for rational number arithmetic.

A Fraction instance can be constructed from a pair of integers, from another rational number, or from a string.

class fractions.Fraction(numerator=0, denominator=1)¶ class fractions.Fraction(other_fraction) class fractions.Fraction(float) class fractions.Fraction(decimal) class fractions.Fraction(string)

The first version requires that numerator and denominator are instances of numbers.Rational and returns a new Fraction instance with value numerator/denominator. If denominator is 0, it raises a ZeroDivisionError. The second version requires that other_fraction is an instance of numbers.Rational and returns a Fraction instance with the same value. The next two versions accept either a float or a decimal.Decimal instance, and return a Fraction instance with exactly the same value. Note that due to the usual issues with binary floating-point (see Floating Point Arithmetic: Issues and Limitations), the argument to Fraction(1.1) is not exactly equal to 11/10, and so Fraction(1.1) does not return Fraction(11, 10) as one might expect. (But see the documentation for the limit_denominator() method below.) The last version of the constructor expects a string or unicode instance. The usual form for this instance is:

[sign] numerator ['/' denominator]

where the optional sign may be either ‘+’ or ‘-’ and numerator and denominator (if present) are strings of decimal digits. In addition, any string that represents a finite value and is accepted by the float constructor is also accepted by the Fraction constructor. In either form the input string may also have leading and/or trailing whitespace. Here are some examples:

>>> from fractions import Fraction
>>> Fraction(16, -10)
Fraction(-8, 5)
>>> Fraction(123)
Fraction(123, 1)
>>> Fraction()
Fraction(0, 1)
>>> Fraction('3/7')
Fraction(3, 7)
>>> Fraction(' -3/7 ')
Fraction(-3, 7)
>>> Fraction('1.414213 \t\n')
Fraction(1414213, 1000000)
>>> Fraction('-.125')
Fraction(-1, 8)
>>> Fraction('7e-6')
Fraction(7, 1000000)
>>> Fraction(2.25)
Fraction(9, 4)
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)
>>> from decimal import Decimal
>>> Fraction(Decimal('1.1'))
Fraction(11, 10)

The Fraction class inherits from the abstract base class numbers.Rational, and implements all of the methods and operations from that class. Fraction instances are hashable, and should be treated as immutable. In addition, Fraction has the following properties and methods:

Changed in version 3.9: The math.gcd() function is now used to normalize the numerator and denominator. math.gcd() always return a int type. Previously, the GCD type depended on numerator and denominator.

numerator¶

Numerator of the Fraction in lowest term.

denominator¶

Denominator of the Fraction in lowest term.

as_integer_ratio()¶

Return a tuple of two integers, whose ratio is equal to the Fraction and with a positive denominator.

New in version 3.8.

classmethod from_float(flt)¶

Alternative constructor which only accepts instances of float or numbers.Integral. Beware that Fraction.from_float(0.3) is not the same value as Fraction(3, 10).

Note

From Python 3.2 onwards, you can also construct a Fraction instance directly from a float.

classmethod from_decimal(dec)¶

Alternative constructor which only accepts instances of decimal.Decimal or numbers.Integral.

limit_denominator(max_denominator=1000000)¶

Finds and returns the closest Fraction to self that has denominator at most max_denominator. This method is useful for finding rational approximations to a given floating-point number:

>>> from fractions import Fraction
>>> Fraction('3.1415926535897932').limit_denominator(1000)
Fraction(355, 113)

or for recovering a rational number that’s represented as a float:

>>> from math import pi, cos
>>> Fraction(cos(pi/3))
Fraction(4503599627370497, 9007199254740992)
>>> Fraction(cos(pi/3)).limit_denominator()
Fraction(1, 2)
>>> Fraction(1.1).limit_denominator()
Fraction(11, 10)

__floor__()¶

Returns the greatest int <= self. This method can also be accessed through the math.floor() function:

>>> from math import floor
>>> floor(Fraction(355, 113))
3

__ceil__()¶

Returns the least int >= self. This method can also be accessed through the math.ceil() function.

__round__()¶ __round__(ndigits)

The first version returns the nearest int to self, rounding half to even. The second version rounds self to the nearest multiple of Fraction(1, 10**ndigits) (logically, if ndigits is negative), again rounding half toward even. This method can also be accessed through the round() function.

How do you add fractions in numbers in Python?

Algorithm.

Initialize variables of numerator and denominator..

Take user input of two fraction..

Find numerator using this condition (n1*d2) +(d1*n2 ) where n1,n2 are numerator and d1 and d2 are denominator..

Find denominator using this condition (d1*d2) for lcm..

Calculate GCD of a this new numerator and denominator..

How do you add 3 or more fractions with different denominators?

Step 1: Find LCM of denominators. Step 2: Divide the LCM by the denominator of each number which are to be added. Step 3: Multiply the numerator with the quotient ( found in the above step). Step 4: Add the numerators we get after multiplying with quotients like simple addition.