在 Python class 定义中放置多个 function 并返回是否是正确的做法？

Question

Here is the code for finding the area of triangle, in which i have initialized the dimensions of triangle in the def __init__ and also i need its area to be initialized for these initial dimensions, for this i have placed self.a1 in the def __init__ also. A Function def tarea() is returning the value to self.a1 in the __init__ function. An another function def getarea() is inside the class definition for returning the area of triangle, when the dimensions of triangle is set. Just need to know if this task can be implemented in more efficient manner? To write two functions with return inside a class definition is ok?

class triangle:

    def __init__(self, sa1, sa2, sa3 ):
        self.s1 = sa1
        self.s2 = sa2
        self.s3 = sa3
        self.a1 = self.tarea()

    def sets1(self, ss1):
        self.s1 = ss1

    def sets2(self, ss2):
        self.s2 = ss2

    def sets3(self, ss3):
        self.s3 = ss3 

    def tarea(self):
        a = (self.s1 + self.s2 +self.s3)/2
        return (a*(a - self.s1)*(a-self.s2)*(a-self.s3))**0.5

    def getarea(self):
        self. a1 = self.tarea()
        return self.a1

tri = triangle(3,4,5)
print("Area of triangle=", tri.a1)
tri.sets1(4)
tri.sets2(5)
tri.sets3(6)
print("Area of triangle with another values",f'{tri.getarea():.2f}')

Answer 1

I would define the area as a property that computes the area based on the current sides.

class Triangle:

    def __init__(self, sa1, sa2, sa3 ):
        self.s1 = sa1
        self.s2 = sa2
        self.s3 = sa3

    @property
    def area(self):
        a = (self.s1 + self.s2 +self.s3)/2
        return (a*(a - self.s1)*(a-self.s2)*(a-self.s3))**0.5

If you consider the area to expensive to calculate on-demand each if the sides haven't changed, you can cache the area. We make each of the sides a property that can invalidate the cache when a side changes.

The boilerplate-heavy version:

class Triangle:

    def __init__(self, sa1, sa2, sa3 ):
        self._s1 = sa1
        self._s2 = sa2
        self._s3 = sa3
        self._area = None
        # We could also use the setters to set self.s1 = sa1,
        # etc, and let them initialize self._area to None.

    @property
    def s1(self):
        return self._s1

    @s1.setter
    def s1(self, value):
        self._s1 = value
        self._area = None

    @property
    def s2(self):
        return self._s2

    @s2.setter
    def s2(self, value):
        self._s2 = value
        self._area = None

    @property
    def s3(self):
        return self._s3

    @s3.setter
    def s3(self, value):
        self._s3 = value
        self._area = None

    @property
    def area(self):
        if self._area is None:
            self._area = self._compute_area()
        return self._area

    def _compute_area(self):
        a = (self.s1 + self.s2 +self.s3)/2
        return (a*(a - self.s1)*(a-self.s2)*(a-self.s3))**0.5

A lighter version, without getting into a full-blown descriptor implementation.

def make_side_property(name):
    def get(self):
        return getattr(self, name)

    def set(self, value):
        setattr(self, name, value)
        self._area = None

    return property(get, set)


class Triangle:

    def __init__(self, sa1, sa2, sa3 ):
        self.s1 = sa1
        self.s2 = sa2
        self.s3 = sa3
        # Here we do let the setters initialize self._area

    s1 = make_side_property("_s1")
    s2 = make_side_property("_s2")
    s3 = make_side_property("_s3")

    @property
    def area(self):
        if self._area is None:
            self._area = self._compute_area()
        return self._area

    def _compute_area(self):
        a = (self.s1 + self.s2 +self.s3)/2
        return (a*(a - self.s1)*(a-self.s2)*(a-self.s3))**0.5