Python Property Class | Getters & Setters

In this article, you’ll get a precise idea of what is a python property class, and as this python fairy basket always has so much to offer, this time in addition, it will offer you Python getters and setters.

Read the article to know more about what exactly is a python property class and how you can modify and amend it, and of course, how it will help you with the code.

Keeping you updated with latest technology trends, Join TechVidvan on Telegram

Python Getters And Setters

Getters:- They are object-oriented programming set up which helps in extracting out the private codes from the internal dictionary in the python library.

Setters:- They help in changing/renaming the already defined internal libraries in python.

Private Attribute – Encapsulation


Class latestclass:

    def __ini__(self, a):
               self.__b= b

    ## getter method to get the properties 
    def get_b(self):
        return self.__b

    ## setter method to change the value 'b' 
    def set_b(self, b):
        self.__b = b

SampleClass has four methods, they are:

  1. __init__ :- used to execute domainial property of the attributes or the properties of a class.
  2. __a :- It is a private internal library attribute frequently used.
  3. get_a :- It is generally used to extract the internal values from library attribute a.
  4. set_a :- It is generally used to redefine the value of a using an object.

For Example

def __init1__(self, b):
        self.b = b

obj = #PythonicWay(10)




Sample Class – A Hiding Feature

SampleClass hides the private attributes and methods in the code. It implements the encapsulation feature of OOPS also. While PythonicWay doesn’t hide the data, it doesn’t implement any encapsulation feature.

Class Without Getters and Setters

Let’s assume that the coder decides to make a class that stores the weight of a class of students as a variable. And now, it would also implement a method to convert the weight in kgs into grams.

For Example

a=int(input("enter weight"))
def __init__(self,weight=0):
        self.weight= weight
def to_(self):
        return (self.weight)*1000




Using Getters and Setters in Python

If we want to extend the usability of the weight class defined above, we can’t. Because we are well aware that weight cannot be measured in any other unit such as litre.

For Example

def __init__(self,weight=0):

def to_gram(self):
        return (self.get_gram() * 1000) 
value=input("enter weight")  
self._weight = value


Traceback (most recent call last):
File “<string>”\

Property Class in Python

The property class gives a specific name and value in the executing code.

For Example

p=int(input("enter weight"))
def __init__(self,weight=0):
        self.weight= weight
def to_(self):
        return (self.weight)*1000




Property in Python

It is used to set any particular value of an attribute in the SampleClass within the runtime.

For Example:

thisistech= SampleClass1



Name error

implementation of the above class using the property decorator.

Class Property in Python

Class property identifies the class of the def variables, searches the python library for it and places the same in the code.


def __init__(self, variable):
        ## initializing the attribute
        self.beta= variable



Passing all the getter and setter methods to the property and assign it to the variable:


## creating an object for the 'AnotherWay' class
obj =(int(input("enter")))



Python – Property() function

The property() function is basically used to define properties in the Python class.

For Example:

class age:
    def __init__(self, name="enter age"):
print("enter age")


Enter age

The property() method in Python provides an interface to instance attributes in the code in runtime within the attributes. This method takes the get, set, and delete methods as arguments and returns an object of the property class side by side.

The property decorator makes it easy to declare a property instead of calling the property() function.

The python property decorator allows us to define properties easily without calling the property() function manually.

Python Add Class Properties

This is yet another important function, which allows the coder to add any other defined field, within the code.

What is the Main Decorator?

In any Python program, function is a first-order object only. This means that it can be passed as an argument to another function. It is possible to define a function in such a way that the function is inside another function. Such a function is called a nested function in a program.


def display1(str):

Decorator Function: This function basically helps the coder to know the additive feature of any particular function.

For Example:

def display(strs):
>>> ('TechVidvan')







classmethod Decorator

The class method decorator parses the code in such a way that it directly gets executed in the main source code. This helps the coder in checking the bugs of the code also.


#defining a variable as this is tech
def thisistech():


>>> thisistech()

Static method Decorator

The static method is a built-in python decorator, from the library of a python which defines a static method for any dictionary in the class in Python.


    def marks():


property(fget, fset, fdel, doc)


Parameter Description 
fget() It is technically used to get the value of an attribute.
fdel()It is technically used to delete the attribute value.
doc()It is technically a string that contains the documentation (docstring) for the attribute.


class Alphabet: 
    def __init__(self, variable): 
        self.__variable = value         
     # deleting the value 
    def delValue(self):  
    values = property(getValue, setValue, delValue, )  
# passing the value 
x = Alphabet('pass') 
del x.value 

Using Decorator in Python

Decorators are used for technically built-in functions. They are used to add functionality to the existing code in python using the predefined function only.


class Alphabet: 
    def __init__(self):
        self.__val = value 
    def value(self): 
        return self.__val

Accessing Python Class Members

To access the members of a Python class, coder uses the dot operator in any program.

>>> apple=fruit()

Now, let’s access the color attribute for apple.

>>> apple.color

This returns an empty string because that is what the coder specified in the class definition.

>>> apple.sayhello()

Here, we call the method sayhello() on apple.

Attributes Belonging to Python Class: These are the permanent parsers for any function, they carry bugs with them and hence returns error if the statement is true.


>>> classcar:
         def __init__(self,color):
         def salutation(self):
                print( {type {self.shape}")


>>> car.type
Traceback (most recent call last):

Deleting Python Class, Attribute, and Object

Sometimes a coder may want to delete or remove a few classes or attributes which are already executed in the code. This can be done with the help of delete function.


>>> del.age.numeral


Traceback (most recent call last):

Python Multiple Inheritance

As its name is indicative itself, multiple inheritances in python is when a class inherits from multiple classes.

This is done by writing multiple python classes in the same code. It is performed by linking the classes as a function of the main attribute in the first source code..

For Example:

class height:
class age:



MRO (Method Resolution Order)

This method searches for multiple inheritances in any order. And if it is not found, then it researches the same in the library and displays the result as found or error.

Complications in Python Multiple Inheritance

The class can be named first in the inheritance and passes its value to the child class for the common attribute.

Applications of Python property Method

By using property method() the coder can implement a value in a library as well. And can simultaneously check the client code in the main code and display the result. So that the implementation is backward compatible for the user as well.


In this article, we’ve learned how python property initially works, as well as what exactly a coder requires to apply it efficiently, that is, getters and setters. Prior knowledge of getter and setter would surely make the coding more effective anyway.

Learning so much about property class is all in vain if not coded well. So keep practicing and Happy Pythonning!

Leave a Reply

Your email address will not be published. Required fields are marked *

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.