Access Modifiers

In this lesson, you will learn about the private, public, and protected data members in Python.

WE'LL COVER THE FOLLOWING

• Public Attributes
• Private Attributes
• Private Properties
• Code Explanation
• Private Methods
• Code Explanation
• Accessing Private Attributes in the Main Code
• Not So Protected

In Python, we can impose access restrictions on different data members and

member functions. The restrictions are specified through access modifiers.
Access modifiers are tags we can associate with each member to define which
parts of the program can access it directly.

There are two types of access modifiers in Python. Let’s take a look at them
one by one.

Public Attributes #

Public attributes are those that be can be accessed inside the class and
outside the class.

Technically in Python, all methods and properties in a class are publicly

available by default. If we want to suggest that a method should not be used
publicly, we have to declare it as private explicitly.
Below is an example to implement public attributes:

class Employee:
def __init__(self, ID, salary):
# all properties are public
self.ID = ID
self.salary = salary

def displayID(self):
print("ID:", self.ID)

Steve = Employee(3789, 2500)

Steve.displayID()
print(Steve.salary)

In the code above, the properties ID and salary , and the method displayID()
are public as they can be accessed in the class as well as the outside the class.

Access granted! Calling salary

Employee property in the
Employee class

ID
salary

Main

class

Private Attributes #

Private attributes cannot be accessed directly from outside the class but
can be accessed from inside the class.

The aim is to keep it hidden from the users and other classes. Unlike in many
different languages, it is not a widespread practice in Python to keep the data

members private since we do not want to create hindrances for the users. We
can make members private using the double underscore __ prefix

Trying to access private attributes in the main code will generate an error. An
example of this is shown below:

Private Properties #
Let’s see a code example for implementing private properties:

private_properties

class Employee:
def __init__(self, ID, salary):
self.ID = ID
self.__salary = salary # salary is a private property

Steve = Employee(3789, 2500)

print("ID:", Steve.ID)
print("Salary:", Steve.__salary) # this will cause an error

Code Explanation #
In the code above, ID is a public property but __salary is a private
property, so it cannot be accessed outside the class.

When it is tried to be accessed outside the class, the following error is

generated:

'Employee' object has no attribute '__salary'

To ensure that no one from the outside knows about this private property,
the error does not reveal the identity of it.
 'Employee'
object has no Calling
Employee attribute
'__salary'
Employee to
access __salary

ID
__salary

Main

Class

Private Methods #
Let’s see a code example for implementing private methods:

private_methods

class Employee:
def __init__(self, ID, salary):
self.ID = ID
self.__salary = salary # salary is a private property

def displaySalary(self): # displaySalary is a public method

print("Salary:", self.__salary)

def __displayID(self): # displayID is a private method

print("ID:", self.ID)

Steve = Employee(3789, 2500)

Steve.displaySalary()
Steve.__displayID() # this will generate an error

Code Explanation #
ID is a public property, so it can be accessed from outside and inside the
class.
 __salary is a private property, so it cannot be accessed from outside the
class but can be accessed from inside the class.

displaySalary() method is a public method, so it can be accessed from

outside the class. This method can access the private property __salary
as well.

__displayID() method is a private method, so it cannot be accessed from

outside the class.

When displayID() tried to be accessed from outside the class, the

following error is generated:

'Employee' object has no attribute '__displayID()'

To ensure that no one from the outside knows about this private property,
the error does not reveal the identity of it.

'Employee'
calling
object has no
Employee to
Employee attribute
'__displayID()'
access
__displayID()
displaySalary()
__displayID()

ID
__salary Main

Class

Note: Methods are usually public since they provide an interface for the
class properties and the main code to interact with each other.

Accessing Private Attributes in the Main Code #

As discussed above, it is not common to have private variables in Python.

Properties and methods with __ prefix are usually present to make sure that
the user does not carelessly access them. Python allows for a free hand to the
user to avoid any future complications in the code. If the user believes it is

absolutely necessary to access a private property or a method, they can

access it using the _<ClassName> prefix for the property or method. An
example of this is shown below:

class Employee:
def __init__(self, ID, salary):
self.ID = ID
self.__salary = salary # salary is a private property

Steve = Employee(3789, 2500)

print(Steve._Employee__salary) # accessing a private property

Not So Protected #
Protected properties and methods in other languages can be accessed by
classes and their subclasses which will be discussed later in the course. As we
have seen, Python does not have a hard rule for accessing properties and
methods, so it does not have the protected access modifier.

Now, let’s test your knowledge with a quick quiz!