Python 继承和变量

Question

I'm going over python and inheritance and this is the code in question:

class Shape:
    def __init__(self, area=0, perimeter=0):
        self.area = area
        self.perimeter = perimeter

    def _calc_area(self, side_a, side_b, side_c):
        pass

    def _calc_perimeter(self, side_a, side_b, side_c):
        pass

    @property
    def area(self):
        return self._area

    @area.setter
    def area(self, area):
        self._area = area

    @property
    def perimeter(self):
        return self._perimeter

    @perimeter.setter
    def perimeter(self, perimeter):
        self._perimeter = perimeter


class Triangle(Shape):
    def __init__(self, side_a, side_b, side_c):
        super().__init__(area=0, perimeter=0)
        self._side_a = side_a
        self._side_b = side_b
        self._side_c = side_c

        self._calc_area(self._side_a, self._side_b, self._side_c)
        self._calc_perimeter(self._side_a, self._side_b, self._side_c)

    def _calc_area(self, side_a, side_b, side_c):
        s = (side_a + side_b + side_c) / 2
        self.area = (s*(s-side_a)*(s-side_b)*(s-side_c)) ** 0.5

    def _calc_perimeter(self, side_a, side_b, side_c):
        self.perimeter = side_a + side_b + side_c

    @property
    def side_a(self):
        return self._side_a

    @property
    def side_b(self):
        return self._side_b

    @property
    def side_c(self):
        return self._side_c

    @side_a.setter
    def side_a(self, side_a):
        self._side_a = side_a

    @side_b.setter
    def side_b(self, side_b):
        self._side_b = side_b

    @side_c.setter
    def side_a(self, side_c):
        self._side_c = side_c


t = Triangle(1, 2, 3)
print(f"Triange: side_a = {t.side_a}, side_b = {t.side_b}, side_c = {t.side_c}")
print(f"Triangle: area = {t.area}, perimenter = {t.perimeter}")

The parameter of t.side_a keeps getting set to 3 and that returns the wrong calculation for the triangle. When I look at the variables when debugging, I'm getting this:

As I step through the code, I see that the correct values are set for side_b=2 and side_c=3, but side_a keeps getting 3, although the input is 1, as the image shows. Am I missing something?

Answer 1

The problem is that you have a typo: you decorated a function named side_a , not side_c , with @side_c.setter , so that now both side_a and side_c refer to the same property.

However, this is an easy typo to make if you are copy-and-pasting lots of similar properties. You can avoid this by defining a custom descriptor to abstract away the common code for all three sides.

class Side:
    def __get__(self, obj, type_):
        if obj is None:
            return self
        return getattr(obj, self.name)

    def __set__(self, obj, value):
        setattr(obj, self.name, value)
        # We're assuming this is used with subclasses of Shape
        # Changing a side invalidates whatever area or perimeter
        # may have been cached.
        obj._area = None
        obj._perimeter = None

    def __set_name__(self, owner, name):
        # E.g., if you write side_a = Side(), then
        # this method sets the name attribute of the descriptor
        # to "_side_a". This gets used to access the appropriate
        # attribute of an instance in __get__ and __set__
        self.name = "_" + name

Before we show how Side is used, let's clean up Shape .

# Area and perimeter are *computed* values, based on other mutable
# properties of a shape. You shouldn't be able to set them directly.
class Shape:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._area = None
        self._perimeter = None

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

    @property
    def perimeter(self):
        if self._perimeter is None:
            self._perimeter = self._calc_perimeter()
        return self._perimeter

    # "Abstract" methods. Shape doesn't do anything to
    # to implement them, but let's emphasize that they
    # should be overriden in subclasses. Use of the abc
    # module is beyond the scope of this module.

    def _calc_area(self):
        pass

Now let's define a subclass to take advantage of Side :

class Triangle(Shape):
    side_a = Side()
    side_b = Side()
    side_c = Side()

    def __init__(self, a, b, c, **kwargs):
        super().__init__(**kwargs)
        self.side_a = a
        self.side_b = b
        self.side_c = c

    # The triangle-specific definitions of _calc_area
    # and _calc_perimeiter that the area and perimeter
    # properties expect.

    def _calc_area(self):
        s = (self.side_a + self.side_b + self.side_c) / 2
        return (s*(s-self.side_a)*(s-self.side_b)*(s-self.side_c)) ** 0.5

    def _calc_perimeter(self):
        return self.side_a + self.side_b + self.side_c

---

You can also define a simpler function that just creates a property , though it requires you to specify a name to use explicitly ( property doesn't use the __set_name__ method).

def make_side(name):
    attr = "_" + name

    def get(self):
        return getattr(self, attr)

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

    return property(get, set)

class Triangle(Shape):
    side_a = make_side("side_a")
    side_b = make_side("side_b")
    side_c = make_side("side_c")

    ...