Access Modifers in Python

Welcome to another tutorial, here you will learn how about Python Access modifiers.

Access modifiers in most OOPs are used to limit access to the variables and functions of a class. The majority of programming languages employ three types of access modifiers. They are listed below:

Private
Public
Protected

Access modifiers can also be used to limit variables or functions in Python. This is done by the use of underscores to specify the access modifier for a specific data member and member function in a class.

In programming, the use of Access modifiers is crucial in the protection of data from unauthorized access and protecting it from being manipulated. If inheritance is implemented in a program, there lies a huge risk for the data to get destroyed (i.e. manipulated), because of the transfer of unwanted data from the parent class to the child class. Hence, it is very important to use the right access modifiers for different data members and member functions based on the project requirements.

Python: Types of Access Modifiers

Python has there 3 types of access modifiers for a class. The access modifiers virtually define how the members of the class will be accessed. Fortunately, every member of a class is accessible inside any member function of that class. Below are the access modifiers in Python.

Access Modifier: Public

In a Public access modifier, the members declared as Public are accessible from outside the Class through an object of the class.

Access Modifier: Protected

In this type of access modifier, the members declared as Protected are accessible from outside the class but only in a class derived from it, which is the child or subclass.

Access Modifier: Private

Here, the members are only accessible from within the class. In short, outside Access is not allowed.

Examples of Access Modifiers

Here, we will take look at an example of each of the types of access modifiers.

public Access Modifier

In Python programming, by default, every variable and member functions of a class are public.

# defining a class Employee
class Employee:
    # constructor
    def __init__(self, name, sal):
        self.name = name;
        self.sal = sal;

From the code above, every member variable of the class is by default public.

>>> emp = Employee("Ironman", 999000);
>>> emp.sal;
999000

Protected Access Modifier

In Python, adding a prefix ‘_’ (i.e. single underscore) to a variable name makes it protected. As such, an additional keyword is not required.

# defining a class Employee
class Employee:
    # constructor
    def __init__(self, name, sal):
        self._name = name;   # protected attribute 
        self._sal = sal;     # protected attribute

From the example above, we made the class variables, name, and sal protected by adding the underscore ‘_’ as a prefix, so now we can access them as follows:

>>> emp = Employee("Captain", 10000);
>>> emp._sal;
10000

Also, in case there is a child class that extends the class Employee, then it can as well access the protected member variables of the class Employee. Check the example below:

# defining a child class
class HR(Employee):
    
    # member function task
    def task(self):
        print ("We manage Employees")

Let’s try another thing by accessing the protected member variable class Employee from HR.

>>> hrEmp = HR("Captain", 10000);
>>> hrEmp._sal;
10000
>>> hrEmp.task();
We manage Employees

private Access Modifier

The addition of prefix double underscore ‘__’ results in a member variable or function becoming private.

# defining class Employee
class Employee:
    def __init__(self, name, sal):
        self.__name = name;    # private attribute 
        self.__sal = sal;      # private attribute

Now, if you want to access the private member variable, we will get an error.

>>> emp = Employee("Bill", 10000);
>>> emp.__sal;

Output:

AttributeError: 'employee' object has no attribute '__sal'

All in one Example

With the examples above, we have seen the different access modifiers in action. In the example below, we will combine all the access modifiers.

# define parent class Company
class Company:
    # constructor
    def __init__(self, name, proj):
        self.name = name      # name(name of company) is public
        self._proj = proj     # proj(current project) is protected
    
    # public function to show the details
    def show(self):
        print("The code of the company is = ",self.ccode)

# define child class Emp
class Emp(Company):
    # constructor
    def __init__(self, eName, sal, cName, proj):
        # calling parent class constructor
        Company.__init__(self, cName, proj)
        self.name = eName   # public member variable
        self.__sal = sal    # private member variable
    
    # public function to show salary details
    def show_sal(self):
        print("The salary of ",self.name," is ",self.__sal,)

# creating instance of Company class
c = Company("Stark Industries", "Mark 4")
# creating instance of Employee class
e = Emp("Steve", 9999999, c.name, c._proj)

print("Welcome to ", c.name)
print("Here ", e.name," is working on ",e._proj)

# only the instance itself can change the __sal variable
# and to show the value we have created a public function show_sal()
e.show_sal()

Finally, the program above shows the use of the Public, Protected, and Private member variables and methods.