Question

(Rectangle Class) Create a class Rectangle with attributes length and width, each of which defaults to \(1 .\) Provide member functions that calculate the perimeter and the area of the rectangle. Also, provide set and get functions for the length and width attributes. The set functions should verify that length and width are each floating-point numbers larger than 0.0 and less than 20.0.

Short answer

Define a Rectangle class with init, setters, getters, area, and perimeter methods.

Step-by-step solution

Define the Rectangle Class

First, we define a class named `Rectangle` in Python. A class in Python is created using the `class` keyword followed by the name of the class.

Initialize Class Attributes

Create an initializer method `__init__` to define the attributes `length` and `width`. These should default to 1.0 if not specified. Use `self.length` and `self.width` to refer to instance variables.

Implement Setter and Getter Methods

Implement `set_length` and `set_width` methods to assign values to `length` and `width`. Ensure they are floating-point numbers between 0.0 and 20.0. Use `get_length` and `get_width` methods to return these values.

Code Example for Step 3

```python class Rectangle: def __init__(self, length=1.0, width=1.0): self.set_length(length) self.set_width(width) def set_length(self, length): if 0.0 < length < 20.0: self._length = float(length) else: raise ValueError("Length must be between 0.0 and 20.0") def get_length(self): return self._length def set_width(self, width): if 0.0 < width < 20.0: self._width = float(width) else: raise ValueError("Width must be between 0.0 and 20.0") def get_width(self): return self._width ```

Implement Area Calculation

Define a method `calculate_area` that multiplies `self.length` by `self.width` to calculate the area of the rectangle.

Implement Perimeter Calculation

Define a method `calculate_perimeter` that adds `self.length` and `self.width`, then multiplies the sum by 2 to find the perimeter.

Complete Code Example

```python class Rectangle: def __init__(self, length=1.0, width=1.0): self.set_length(length) self.set_width(width) def set_length(self, length): if 0.0 < length < 20.0: self._length = float(length) else: raise ValueError("Length must be between 0.0 and 20.0") def get_length(self): return self._length def set_width(self, width): if 0.0 < width < 20.0: self._width = float(width) else: raise ValueError("Width must be between 0.0 and 20.0") def get_width(self): return self._width def calculate_area(self): return self._length * self._width def calculate_perimeter(self): return 2 * (self._length + self._width) ```

Key concepts

Class Definition

When we talk about object-oriented programming, the concept of a class is fundamental. A class serves as a blueprint for creating objects, providing initial values for state or attributes, and implementations of behavior or methods.
In Python, you define a class using the keyword `class`, followed by the class name. For example, in the exercise provided, a `Rectangle` class is defined as:

• Start with the keyword `class`.
• Follow it with the name of the class, which is `Rectangle`.
• Use a colon `:` to indicate the start of an indented code block.

```python class Rectangle: ``` This code does not yet define any behavior or attributes on its own, but it sets up the structure for more detailed parts of the class, like attributes and methods.

Method Implementation

Methods in a class are similar to functions, but they are associated with class instances. These methods define behaviors for objects created from the class. Implementing methods involves defining specific operations the class should perform, which can be either instance-specific or class-wide.
In the `Rectangle` class example:

• The `__init__` method: This is a special method in Python known as a constructor. It's called automatically whenever a new `Rectangle` object is created. It assigns initial values to the class attributes, `length` and `width`.
• Setter methods: `set_length` and `set_width` ensure the attributes are correctly set to floating-point values between 0.0 and 20.0, raising an error if the conditions are not met.
• Getter methods: `get_length` and `get_width` return the current values of the attributes.

These methods ensure that the rectangle class not only stores attribute state but also performs calculations needed for its functionality, such as calculating area and perimeter.

Data Encapsulation

Data encapsulation is one of the core principles of object-oriented programming. It is the practice of keeping the details of how data is stored or manipulated hidden from the outside world. This is achieved by restricting access to certain components of the object.
In the `Rectangle` class, encapsulation is demonstrated by:

• Using private attributes, often denoted with a single underscore (e.g., `_length`). This signals to developers that these attributes should not be accessed directly.
• Providing public setter methods that include validation logic to enforce constraints on data (e.g., ensuring the `length` and `width` are between 0.0 and 20.0).
• Using getter methods to access the values of these private attributes safely, without exposing the internal structure directly.

This separation ensures that the user of the class interacts with it through a controlled interface, mitigating errors and enhancing maintainability.