Equals support for self-built Fraction class

Question

class Fraction:
    """Class for performing fraction arithmetic.
    Each Fraction has two attributes: a numerator, n and a deconominator, d.
    Both must be integer and the deonominator cannot be zero."""

    def __init__(self,n,d):
        """Performs error checking and standardises to ensure denominator is 
positive"""
        if type(n)!=int or type(d)!=int:
            raise TypeError("n and d must be integers")
        if d==0:
            raise ValueError("d must be positive")
        elif d<0:
            self.n = -n
            self.d = -d
        else:
            self.n = n
            self.d = d

    def __str__(self):
        """Gives string representation of Fraction (so we can use print)"""
        return(str(self.n) + "/" + str(self.d))

    def __add__(self, otherFrac):
        """Produces new Fraction for the sum of two Fractions"""
        newN = self.n*otherFrac.d + self.d*otherFrac.n
        newD = self.d*otherFrac.d
        newFrac = Fraction(newN, newD)
        return(newFrac)

    def __sub__(self, otherFrac):
        """Produces new Fraction for the difference between two Fractions"""        
        newN = self.n*otherFrac.d - self.d*otherFrac.n
        newD = self.d*otherFrac.d
        newFrac = Fraction(newN, newD)
        return(newFrac)

    def __mul__(self, otherFrac):
        """Produces new Fraction for the product of two Fractions"""        
        newN = self.n*otherFrac.n
        newD = self.d*otherFrac.d
        newFrac = Fraction(newN, newD)
        return(newFrac)

    def __truediv__(self, otherFrac):
        """Produces new Fraction for the quotient of two Fractions"""        
        newN = self.n*otherFrac.d
        newD = self.d*otherFrac.n
        newFrac = Fraction(newN, newD)
        return(newFrac)

As code showed above, how can I print

Fraction(1,3) == Fraction(2,6)

As example:

Fraction(1,2) + Fraction(1,3)
Fraction(1,2) - Fraction(1,3)
Fraction(1,2) * Fraction(1,3)
Fraction(1,2) / Fraction(1,3)

They are all work for calculation every time. And when I try to print fraction(1,3) == fraction(2,6), it come out as False. How can I let it calculate as True?

How can I do it without using import fraction.

You need to implement `__eq__` . This is the method that decides if two objects are equal. — khelwood, May 16 '17 at 13:46

score 4 · Accepted Answer · edited May 23 '17 at 12:18

4

Try this:

def __eq__(self, other):
    return  self.n*other.d == self.d*other.n

As pointed out in the comments, there is no need to implement the __ne__.

EDIT: As requested in the comments to this answer, here is a method for simplifying fractions.

The simplification of fraction implies dividing both numbers by the greatest common divisor. As posted in here the code is rather simple

# return the simplified version of a fraction
def simplified(self):
    # calculate the greatest common divisor
    a = self.n
    b = self.d
    while b:
        a, b = b, a%b
    # a is the gcd
    return Fraction(self.n/a, self.d/a)

I hope it helps.

edited May 23 '17 at 12:18

Community

1
1

answered May 16 '17 at 13:58

Pablo Gutierrez Marques

432
2
8

The last comment is incorrect. If there's no `__ne__` method it will negate the result of `__eq__`: "By default, `__ne__()` delegates to `__eq__()` and inverts the result unless it is `NotImplemented`." (https://docs.python.org/3/reference/datamodel.html#object.__eq__) – MSeifert May 16 '17 at 14:00
@ko-ko As an aside, you are reporting `("d must be positive")` where you actually mean `("d must be non-zero")` – Pablo Gutierrez Marques May 16 '17 at 14:01
Thank you @MSeifert ! I was not aware of that – Pablo Gutierrez Marques May 16 '17 at 14:03
Not sure about the first comment, I guess that was directed at the questioner? – MSeifert May 16 '17 at 14:04
1

Shoud it not be `return self.n*other.d == self.d*other.n`? – Mark Beilfuss May 16 '17 at 14:06
You are right, @MarkBeilfuss . Thanks for the correction! – Pablo Gutierrez Marques May 16 '17 at 14:09
Very clever way to solve this! +1. Personally I would "simplify" the fractions during `__init__` because it's just more convenient for all operations but your approach definetly works. – MSeifert May 16 '17 at 14:15
I like the simplicity of this, no need to make things difficult when it is simple. – Ludisposed May 16 '17 at 14:28

MSeifert · Answer 2 · 2017-05-16T14:02:28.860

2

The data model specifies __eq__ as method that implements == checks.

A very simple implementation of __eq__ would be:

def __eq__(self, other):
    return self.n == other.n and self.d == other.d

It would work for Fraction(1, 2) == Fraction(1, 2) but it wouldn't work for Fraction(1, 2) == Fraction(2, 4).

You would need modify the contents of the __eq__ method so it allows even to compare multiples.

edited May 16 '17 at 14:02

answered May 16 '17 at 13:55

MSeifert

145,886
38
333
352

Mark Beilfuss · Answer 3 · 2017-05-16T13:48:54.300

1

In python to get custom behavior for the == operator you must provide an implementation for the method __eq__. If you don't override it the default behavior is to check if the objects are really the same object, which in this case they are not.

edited May 16 '17 at 13:48

answered May 16 '17 at 13:48

Mark Beilfuss

602
4
12

Equals support for self-built Fraction class

3 Answers3