python

hrh1023

class Fraction:
    def __init__(self, a, b):
        self.numerator = a
        self.denominator = b

    def __eq__(self, other):
        return(self.numerator * other.denominator == self.denominator * other.numerator)

    def __str__(self):
        return str(self.numerator) + " / " + str(self.denominator)

    def __mul__(self, other):
        return int(self.numerator * other.denominator == self.denominator * other.numerator)

x = Fraction(1, 2)
y = Fraction(3, 5)
print(x * x) # should be 1 / 4, or any fraction equal to this
print(x * y) # should be 3 / 10, or any fraction equal to this






怎么样才可以让那个最后验算的结果不是false 而是数字啊

qiuyouzhi

return int(...)

hrh1023

qiuyouzhi 发表于 2021-2-3 21:22

你好
return int(self.numerator+other.numerator == self.denominator+other.denominator)
我这样输入后 最后结果变成两个0了 请问还有哪里出错了吗

qiuyouzhi

hrh1023 发表于 2021-2-3 21:33
你好
return int(self.numerator+other.numerator == self.denominator+other.denominator)
我这样输 ...

蛤？
我这里是1和0

hrh1023

qiuyouzhi 发表于 2021-2-3 21:59
蛤？
我这里是1和0

可是答案应该要是1/4 和3/10

qiuyouzhi

hrh1023 发表于 2021-2-3 22:03
可是答案应该要是1/4 和3/10

这是我以前写过的一个简陋分数类，你可以参考一下：

import math
from copy import deepcopy

class Fraction:
    """一个简单的分数类，模仿fractions.Fraction"""

    def __init__(self, num, den = 1):
        if isinstance(num, float):
            self.convert(float(num), flag = True)
            return
        elif isinstance(num, str):
            num, den = map(int, num.split('/'))
        self.numerator = num
        self.denominator = den
        self._rof()

    def convert(self, obj = None, flag = False):
        """
        将一个数字转换为Fraction类型
        """
        if isinstance(obj, int):
            return Fraction(obj)
        elif isinstance(obj, float):
            res = str(obj).replace('.', '')
            den = int("1" + ((len(res) - 1) * "0"))
            fc = Fraction(int(res), den)
            if not flag:
                return fc
            else:
                self.numerator, self.denominator = fc.numerator, fc.denominator
        else:
            raise ValueError("Object's type is wrong")
            

    # 约分函数, reduction of a fraction
    def _rof(self):
        print(self.numerator, self.denominator)
        gcd = math.gcd(self.numerator, self.denominator)
        self.numerator //= gcd
        self.denominator //= gcd
        if self.numerator == self.denominator:
            return 1.0

    # 通分函数, reduction of fractions to a common denominator
    def _rofcd(self, other):
        fc1 = deepcopy(self)
        fc2 = deepcopy(other)
        fc1.denominator *= fc2.denominator
        fc1.numerator *= fc2.denominator
        fc2.denominator *= self.denominator
        fc2.numerator *= self.denominator
        return fc1, fc2

    def __setattr__(self, key, value):
        if key == "denominator" and value == 0:
            raise ValueError("The denominator can't be zero")
        else:
            self.__dict__[key] = value

    def __add__(self, other):
        if isinstance(other, Fraction):
            if self.denominator != other.denominator:
                fc1, fc2 = self._rofcd(other)
            else:
                fc1 = deepcopy(self)            
        else:
            fc1 = deepcopy(self)
            fc2 = self.convert(other)

        fc1.numerator += fc2.numerator
        k = fc1._rof()
        return k if k else fc1

    def __sub__(self, other):
        if isinstance(other, Fraction):
            if self.denominator != other.denominator:
                fc1, fc2 = self._rofcd(other)
                fc1.numerator -= fc2.numerator
                fc1._rof()
                return fc1
        elif isinstance(other, (float, int)):
            return self.numerator / self.denominator - other

    def __mul__(self, other):
        if isinstance(other, Fraction):
            num = self.numerator * other.numerator
            den = self.denominator * other.denominator
            return Fraction(num, den)
        elif isinstance(other, (float, int)):
            return self.numerator / self.denominator * other
        
    def __truediv__(self, other):
        if isinstance(other, Fraction):
            fc = deepcopy(other)
            fc.numerator, fc.denominator = fc.denominator, fc.numerator
            return self * fc
        elif isinstance(other, (float, int)):
            return self.numerator / self.denominator / other
    
    def __float__(self):
        return self.numerator / self.denominator

    def __repr__(self):
        return f"Fraction({self.numerator}, {self.denominator})"

    __str__ = __repr__

x = Fraction(1, 2)
y = Fraction(3, 5)
print(x * x) # should be 1 / 4, or any fraction equal to this
print(x * y) # should be 3 / 10, or any fraction equal to this

hrh1023

qiuyouzhi 发表于 2021-2-3 22:16
这是我以前写过的一个简陋分数类，你可以参考一下：

谢谢

qiuyouzhi

hrh1023 发表于 2021-2-3 22:28
谢谢

如果问题已解决，请设置【最佳答案】

°蓝鲤歌蓝

class Fraction:
    def __init__(self, a, b):
        self.numerator = a
        self.denominator = b

    def __eq__(self, other):
        return (self.numerator == other.numerator) and (
            self.denominator == other.denominator
        )

    def __str__(self):
        return str(self.numerator) + "/" + str(self.denominator)

    def __mul__(self, other):
        return Fraction(
            self.numerator * other.numerator, self.denominator * other.denominator
        )

代码稍微改一下就好了。不过没实现约数，你自己试试看。
而且你的图里问题不是两个分数相加吗？ 怎么写出来却是要分数相乘啊？

kogawananari

    def __mul__(self, other):
        return Fraction(self.numerator * other.numerator, self.denominator * other.denominator)
    def __add__(self, other):
        if self.denominator == other.denominator:
            return Fraction(self.numerator + other.numerator, self.denominator)
        return Fraction(self.numerator*other.denominator, self.denominator*other.denominator) + Fraction(other.numerator*self.denominator, other.denominator*self.denominator)
   

°蓝鲤歌蓝

class ZeroDenominatorError(ArithmeticError):
    pass


class Fraction:
    def __init__(self, a, b):
        self.numerator = a
        self.denominator = b

        self.__symbol = 1

        if a * b < 0:
            self.__symbol = 0

    def __setattr(self, name, value):
        if name == "denominator" and value == 0:
            raise ZeroDenominatorError("denominator by zero")
        return super().__setattr(self, name, value)

    # -self
    def __neg__(self):
        a, b = self.numerator, self.denominator
        if self.__symbol:
            return Fraction(a, b)
        return Fraction(abs(a), abs(b))

    # +self
    def __pos__(self):
        return self

    def __str__(self):
        a, b = self.numerator, self.denominator
        if a == 0:
            return "0"
        return "-" * abs(self.__symbol - 1) + f"{abs(a)}/{abs(b)}"

    def __repr__(self):
        ...

    __repr__ == __str__

    # +
    def __add__(self, other):
        a, b = self.numerator, self.denominator
        c, d = other.numerator, other.denominator
        if a == 0:
            return Fraction(c, d)
        if c == 0:
            return Fraction(a, b)

        ad = a * d
        bc = b * c
        bd = b * d

        return Fraction(ad + bc, bd)

    # -
    def __sub__(self, other):
        a, b = self.numerator, self.denominator
        c, d = other.numerator, other.denominator
        if a == 0:
            return -Fraction(c, d)
        if c == 0:
            return Fraction(a, b)

        ad = a * d
        bc = b * c
        bd = b * d

        return Fraction(ad + bc, bd)

    # *
    def __mul__(self, other):
        return Fraction(
            self.numerator * other.numerator, self.denominator * other.denominator
        )

    # /
    def __truediv__(self, other):
        if other.numerator == 0:
            raise ZeroDivisionError("division by zero")
        ad, bc = self.numerator * other.denominator, self.denominator * other.numerator

        return Fraction(ad, bc)

    # int(self)
    def __int__(self):
        return int(self.numerator / self.denominator)

    # float(self)
    def __float__(self):
        return self.numerator / self.denominator

    #  !=
    def __ne__(self, other) -> bool:
        if isinstance(other, Fraction):
            return str(self) != str(other)
        return True

    # ==
    def __eq__(self, other):
        if isinstance(other, Fraction):
            return str(self) == str(other)
        return False

    # <
    def __lt__(self, other) -> bool:
        if isinstance(other, Fraction):
            return float(self) < float(other)
        raise TypeError(
            f"'<' not supported between instances of 'Fraction' and {type(other)}"
        )

    # <=
    def __le__(self, other) -> bool:
        if isinstance(other, Fraction):
            return float(self) <= float(other)
        raise TypeError(
            f"'<=' not supported between instances of 'Fraction' and {type(other)}"
        )

    # >
    def __gt__(self, other) -> bool:
        if isinstance(other, Fraction):
            return float(self) > float(other)
        raise TypeError(
            f"'>' not supported between instances of 'Fraction' and {type(other)}"
        )

    # >=
    def __ge__(self, other) -> bool:
        if isinstance(other, Fraction):
            return float(self) >= float(other)
        raise TypeError(
            f"'>=' not supported between instances of 'Fraction' and {type(other)}"
        )

    # abs(self)
    def __abs__(self):
        a, b = self.numerator, self.denominator
        if self.__symbol:
            return Fraction(a, b)
        return Fraction(-a, b)

    # bool(self)
    def __bool__(self):
        if self.numerator == 0:
            return False
        return True

这个的功能雏形差不多了，约分没实现