Understanding Getter, Setter and Private variables in Python
Tags: python, programming, oop
Published: 2024-01-27 15:47:07

In the realm of object-oriented programming, encapsulation is a fundamental concept, crucial for ensuring data integrity and hiding implementation details from the user. Python, known for its simplicity and readability, employs getters and setters as part of this encapsulation. This article delves into the purpose and implementation of getters and setters in Python, providing insights into their role in managing data access and maintaining object integrity.

## What are Getters, Setters and Private Variables?

Getters and setters are methods used in object-oriented programming to ensure data encapsulation. In Python, they serve a twofold purpose:

* **Getters** are methods used to access or '`get`' the value of an object's attributes. They provide a way to read data without directly accessing the attributes.

* **Setters** are methods used to change or '`set`' the value of an object's attributes. They allow for data modification while implementing checks or validations.

* **Private Variables**: Attributes prefixed with an underscore (`_`) or double underscore (`__`), indicating they should not be accessed directly outside the class.

## The Role of Private Variables

**Private variables** in Python are not enforced as strictly as in some other languages. The convention is to prefix the attribute name with an underscore (`_`) for **protected** (internal use) or double underscore (`__`) for **private** (name mangled). This signals that the attribute is not intended to be accessed directly.

**Example of Private Variables**:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d1nvpvegqx3crodr289w.png)

In this example, `__price` is a private variable of the Product class.

## Why Use Private Variables?

* **Encapsulation**: They hide the internal state of an object from outside interference.

* **Security**: Prevents external entities from modifying the state in an uncontrolled manner.

* **Maintenance**: Makes it easier to change the attribute implementation without affecting external users.

## Implementing Getters and Setters in Python

**Using the `property()` Function**

Python provides a property function that makes the implementation of getters and setters straightforward and intuitive. Here’s how you can use them:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p5atednb5jriumnyop29.png)

Here, `__price` is a private variable accessed and modified through the price property. The property decorator makes the getter and setter more elegant and easy to use.

## Using the @property Decorator

Python also allows a more elegant way of defining properties using decorators:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4i24fy0t30y1ddxwiura.png)

This approach enhances readability and maintains the Pythonic style of simple and clean code.

`Getters`, `Setters`, and `Private Variables` are fundamental in Python for encapsulating data and controlling access to an object's attributes. They contribute to writing robust, maintainable, and secure code. Understanding and implementing these concepts is vital for Python developers to leverage the full potential of object-oriented programming in Python.

✨ Do you like this kind of article? I invite you to see more of that here: https://astrocodecraft.substack.com