蟒蛇。 在两个内置类型之间定义新操作

Question

First of all I have to say that I am quite new to Python and programming in general, so this question may have been asked before, but I just do not know what specific words I should use to look for this.

I am trying to create a module for personal use that operates with rational numbers in a more symbolic way. I am aware that there are modules to do this, but my objective is not to use the module but to learn by making it. My question is whether there is a some way to have Python instatiate a new Rational object when I write a specific operation (ie 2 f 3) instead of having to write Rational(2,3) every time I want to create a new Rational. This is the code so far:

class Rational:
    """Contains a rational number and the 
    information to simplify it and operate."""

    def __init__(self, a, b):
        if type(a) == int and type(b) == int:
            self.num = a
            self.den = b
            self.simplify()
        else:
            raise TypeError("Both arguments must be int.")

    def __repr__(self):
        """Returns the explicit syntax to create
        an object with the same attributes."""

        return "Rational({}, {})".format(self.num, self.den)

    def __str__(self):
        """Returns the fraction as a/b unless the denominator 
        is 1, in which case it returns only the numerator."""
        if self.den != 1:
            return str(self.num) + "/" + str(self.den)
        else:
            return str(self.num)

    def __add__(self, other):
        """Rationals can be added to other rationals, int and float."""

        if type(other) == float:
            return self.to_float() + other
        elif type(other) == int:
            s = Rational(self.num + other * self.den, self.den)
            return s
        elif type(other) == Rational:
            s = Rational(
                self.num * other.den + other.num * self.den, 
                self.den * other.den)
            s.simplify()
            return s
        else:
            return NotImplemented

    def simplify(self):
        """Simplifies the fraction and takes the sign to the numerator."""

        # If the num is 0 we don't care about the den.
        if self.num == 0:
            self.den = 1
        else:
            # Divide num and den by their gcd.
            d = gcd(self.num, self.den)
            self.num //= d
            self.den //= d

            # If the den is negative, move the sign to the num.
            if self.den > 0:
                pass
            else:
                self.num = -self.num
                self.den = -self.den

    def to_float(self):
        return float(self.num / self.den)

def gcd(a, b):
    """Returns the gcd of two integers."""

    while b:
        a, b = b, a % b
    return abs(a)

Apart of answering the question, if you have any advice about my code I am more than happy to listen to your feedback and learn :)

Answer 1

No you cannot define new operators in python. You can however override the behavior of existing operators.

The python docs have more details: https://docs.python.org/2/reference/datamodel.html

Answer 2

Wow, what you are looking for is impossible, not just in python but almost in every programming language.

Because what you want is defining a new operator, that also means you need a new key word to achieve this. But the key words list must be fixed as the compiler/interpreter will not also be updated by your code.