Python is a multi-paradigm programming language. It supports different programming approaches.
One of the popular approaches to solve a programming problem is by creating objects. This is known as Object-Oriented Programming (OOP).
An object has two characteristics:
- attributes
- behavior
The concept of OOP in Python focuses on creating reusable code.
In Python, object-oriented Programming (OOPs) is a programming paradigm that uses objects and classes in programming. It aims to implement real-world entities like inheritance, polymorphisms, encapsulation, etc. in the programming. The main concept of OOPs is to bind the data and the functions that work on that together as a single unit so that no other part of the code can access this data.
Encapsulation in Python
When working with an Object Oriented Programming language like Python, encapsulation in Python is one of the 4 important concepts to understand. The other three are inheritance, polymorphism, and abstraction.
What is Encapsulation?
When working with classes and dealing with sensitive data, providing global access to all the variables used within the program is not a good choice. Encapsulation offers a way for us to access the required variables without providing the program full-fledged access to any of those variables.
Updating, modifying, or deleting data from variables can be done through the use of methods that are defined specifically for the purpose. The benefit of using this approach to programming is improved control over the input data and better security.
“Ready to take your python skills to the next level? Sign up for a free demo today!”
What is Encapsulation in Python?
The concept of encapsulation is the same in all object-oriented programming languages. The difference is seen when the concepts are applied to particular languages.
Compared to languages like Java that offer access modifiers (public or private) for variables and methods, Python provides access to all the variables and methods globally.
Check the below demonstration of how variables can easily be accessed.
class Person: def __init__(self, name, age=0): self.name = name self.age = age def display(self): print(self.name) print(self.age)person = Person('Dev', 30)#accessing using class methodperson.display()#accessing directly from outsideprint(person.name)print(person.age) |
Output
Dev30Dev30 |
Since we do not have access modifiers in Python, we will use a few different methods to control the access of variables within a Python program.
Methods to Control Access
There are multiple methods that are offered by Python to limit variable and method access across the program. Let’s go over the methods in detail.
Using Single Underscore
A common Python programming convention to identify a private variable is by prefixing it with an underscore. Now, this doesn’t really make any difference on the compiler side of things. The variable is still accessible as usual. But being a convention that programmers have picked up on, it tells other programmers that the variables or methods have to be used only within the scope of the class.
See the below example:
class Person: def __init__(self, name, age=0): self.name = name self._age = age def display(self): print(self.name) print(self._age)person = Person('Dev', 30)#accessing using class methodperson.display()#accessing directly from outsideprint(person.name)print(person._age) |
Output
Dev30Dev30 |
It’s clear that the variable access is unchanged. But can we do anything to really make it private? Let’s have a look further.
Using Double Underscores
If you want to make class members i.e. methods and variables private, then you should prefix them with double underscores. But Python offers some sort of support to the private modifier. This mechanism is called Name mangling. With this, it is still possible to access the class members from outside it.
Name Mangling
In Python, any identifier with __Var is rewritten by a python interpreter as _Classname__Var, and the class name remains as the present class name. This mechanism of changing names is called Name Mangling in Python.
In the below example, in Class person, the age variable is changed and it’s prefixed by leading double underscores.
class Person: def __init__(self, name, age=0): self.name = name self.__age = age def display(self): print(self.name) print(self.__age)person = Person('Dev', 30)#accessing using class methodperson.display()#accessing directly from outsideprint('Trying to access variables from outside the class ')print(person.name)print(person.__age) |
Output
Dev30Trying to access variables from outside the classDevTraceback (most recent call last): File "Person.py", line 16, in <module> print(person.__age)AttributeError: 'Person' object has no attribute '__age' |
You can observe that variables are still be accessed using methods, which is a part of the class. But you cannot access age directly from outside, as it is a private variable.
“Experience the power of our web development course with a free demo – enroll now!”
Using Getter and Setter methods to access private variables
If you want to access and change the private variables, accessor (getter) methods and mutators(setter methods) should be used, as they are part of Class.
class Person: def __init__(self, name, age=0): self.name = name self.__age = age def display(self): print(self.name) print(self.__age) def getAge(self): print(self.__age) def setAge(self, age): self.__age = ageperson = Person('Dev', 30)#accessing using class methodperson.display()#changing age using setterperson.setAge(35)person.getAge() |
Output
Dev3035 |
“Get hands-on with our python course – sign up for a free demo!”
Benefits of Encapsulation in Python
Encapsulation ensures better data flow and also protects the data from outside sources. The concept of encapsulation makes the code self-sufficient. It is very helpful in the implementation level, as it prioritizes the ‘how’ type questions, leaving behind the complexities. You should hide the data in the unit to make encapsulation easy and also to secure the data.
What is the need for Encapsulation in Python
The following reasons show why developers find the Encapsulation handy and why the Object-Oriented concept is outclassing many programming languages.
- Encapsulation helps in achieving the well-defined interaction in every application.
- The Object-Oriented concept focuses on the reusability of code in Python. (DRY – Don’t Repeat Yourself).
- The applications can be securely maintained.
- It ensures the flexibility of the code through a proper code organization.
- It promotes a smooth experience for the users without exposing any back-end complexities.
- It improves the readability of the code. Any changes in one part of the code will not disturb another.
- Encapsulation ensures data protection and avoids the access of data accidentally.
Encapsulation in Python is, the data is hidden outside the object definition. It enables developers to develop user-friendly experience. This is also helpful in securing data from breaches, as the code is highly secured and cannot be accessed by outside sources.
Main Concepts of Object-Oriented Programming (OOPs)
- Class
- Objects
- Polymorphism
- Encapsulation
- Inheritance
- Data Abstraction
OOPs
Class
A class is a collection of objects. A class contains the blueprints or the prototype from which the objects are being created. It is a logical entity that contains some attributes and methods.
To understand the need for creating a class let’s consider an example, let’s say you wanted to track the number of dogs that may have different attributes like breed, age. If a list is used, the first element could be the dog’s breed while the second element could represent its age. Let’s suppose there are 100 different dogs, then how would you know which element is supposed to be which? What if you wanted to add other properties to these dogs? This lacks organization and it’s the exact need for classes.
Some points on Python class:
- Classes are created by keyword class.
- Attributes are the variables that belong to a class.
- Attributes are always public and can be accessed using the dot (.) operator. Eg.: Myclass.Myattribute
Class Definition Syntax:
class ClassName: # Statement-1 . . . # Statement-N
Example: Creating an empty Class in Python
# Python3 program to# demonstrate defining# a classclass Dog: pass |
In the above example, we have created a class named dog using the class keyword.
“Ready to take your python skills to the next level? Sign up for a free demo today!”
Objects
The object is an entity that has a state and behavior associated with it. It may be any real-world object like a mouse, keyboard, chair, table, pen, etc. Integers, strings, floating-point numbers, even arrays, and dictionaries, are all objects. More specifically, any single integer or any single string is an object. The number 12 is an object, the string “Hello, world” is an object, a list is an object that can hold other objects, and so on. You’ve been using objects all along and may not even realize it.
An object consists of :
- State: It is represented by the attributes of an object. It also reflects the properties of an object.
- Behavior: It is represented by the methods of an object. It also reflects the response of an object to other objects.
- Identity: It gives a unique name to an object and enables one object to interact with other objects.
Example: Creating an object
obj = Dog() |
This will create an object named obj of the class Dog defined above. Before diving deep into objects and class let us understand some basic keywords that will be used while working with objects and classes.
The self
- Class methods must have an extra first parameter in the method definition. We do not give a value for this parameter when we call the method, Python provides it.
- If we have a method that takes no arguments, then we still have to have one argument.
- This is similar to this pointer in C++ and this reference in Java.
When we call a method of this object as myobject.method(arg1, arg2), this is automatically converted by Python into MyClass.method(myobject, arg1, arg2) – this is all the special self is about.
The __init__ method
The __init__ method is similar to constructors in C++ and Java. It is run as soon as an object of a class is instantiated. The method is useful to do any initialization you want to do with your object.
Now let us define a class and create some objects using the self and __init__ method.
“Experience the power of our web development course with a free demo – enroll now!”
Example 1: Creating a class and object with class and instance attributes
class Dog: # class attribute attr1 = "mammal" # Instance attribute def __init__(self, name): self.name = name# Driver code# Object instantiationRodger = Dog("Rodger")Tommy = Dog("Tommy")# Accessing class attributesprint("Rodger is a {}".format(Rodger.__class__.attr1))print("Tommy is also a {}".format(Tommy.__class__.attr1))# Accessing instance attributesprint("My name is {}".format(Rodger.name))print("My name is {}".format(Tommy.name)) |
Output
Rodger is a mammal Tommy is also a mammal My name is Rodger My name is Tommy
Example 2: Creating Class and objects with methods
class Dog: # class attribute attr1 = "mammal" # Instance attribute def __init__(self, name): self.name = name def speak(self): print("My name is {}".format(self.name))# Driver code# Object instantiationRodger = Dog("Rodger")Tommy = Dog("Tommy")# Accessing class methodsRodger.speak()Tommy.speak() |
Output
My name is Rodger My name is Tommy
Inheritance
Inheritance is the capability of one class to inherit the properties from another class. The class that derives properties is called the derived class or child class and the class from which the properties are being derived is called the base class or parent class. The benefits of inheritance are:
- It represents real-world relationships well.
- It provides the reusability of a code. We don’t have to write the same code again and again. It also allows us to add more features to a class without modifying it.
- It is transitive in nature, which means that if class B inherits from another class A, then all the subclasses of B would automatically inherit from class A.
Types of Inheritance
Single Inheritance:
Single-level inheritance enables a derived class to inherit characteristics from a single-parent class.
Multilevel Inheritance:
Multi-level inheritance enables a derived class to inherit properties from an immediate parent class which in turn inherits properties from his parent class.
Hierarchical Inheritance:
Hierarchical level inheritance enables more than one derived class to inherit properties from a parent class.
Multiple Inheritance:
Multiple level inheritance enables one derived class to inherit properties from more than one base class.
Example: Inheritance in Python
# Python code to demonstrate how parent constructors# are called.# parent classclass Person(object): # __init__ is known as the constructor def __init__(self, name, idnumber): self.name = name self.idnumber = idnumber def display(self): print(self.name) print(self.idnumber) def details(self): print("My name is {}".format(self.name)) print("IdNumber: {}".format(self.idnumber)) # child classclass Employee(Person): def __init__(self, name, idnumber, salary, post): self.salary = salary self.post = post # invoking the __init__ of the parent class Person.__init__(self, name, idnumber) def details(self): print("My name is {}".format(self.name)) print("IdNumber: {}".format(self.idnumber)) print("Post: {}".format(self.post))# creation of an object variable or an instancea = Employee('Rahul', 886012, 200000, "Intern")# calling a function of the class Person using# its instancea.display()a.details() |
Output
Rahul 886012 My name is Rahul IdNumber: 886012 Post: Intern
In the above, we have created two classes i.e. Person (parent class) and Employee (Child Class). The Employee class inherits from the Person class. We can use the methods of the person class through employee class as seen in the display function in the above code. A child class can also modify the behavior of the parent class as seen through the details() method.
“Get hands-on with our python course – sign up for a free demo!”
Polymorphism
Polymorphism simply means having many forms. For example, we need to determine if the given species of birds fly or not, using polymorphism we can do this using a single function.
Example: Polymorphism in Python
class Bird: def intro(self): print("There are many types of birds.") def flight(self): print("Most of the birds can fly but some cannot.")class sparrow(Bird): def flight(self): print("Sparrows can fly.")class ostrich(Bird): def flight(self): print("Ostriches cannot fly.")obj_bird = Bird()obj_spr = sparrow()obj_ost = ostrich()obj_bird.intro()obj_bird.flight()obj_spr.intro()obj_spr.flight()obj_ost.intro()obj_ost.flight() |
Output
There are many types of birds. Most of the birds can fly but some cannot. There are many types of birds. Sparrows can fly. There are many types of birds. Ostriches cannot fly.
Encapsulation
Encapsulation is one of the fundamental concepts in object-oriented programming (OOP). It describes the idea of wrapping data and the methods that work on data within one unit. This puts restrictions on accessing variables and methods directly and can prevent the accidental modification of data. To prevent accidental change, an object’s variable can only be changed by an object’s method. Those types of variables are known as private variables.
A class is an example of encapsulation as it encapsulates all the data that is member functions, variables, etc.
Example: Encapsulation in Python
# Python program to# demonstrate private members# Creating a Base classclass Base: def __init__(self): self.a = "GeeksforGeeks" self.__c = "GeeksforGeeks"# Creating a derived classclass Derived(Base): def __init__(self): # Calling constructor of # Base class Base.__init__(self) print("Calling private member of base class: ") print(self.__c)# Driver codeobj1 = Base()print(obj1.a)# Uncommenting print(obj1.c) will# raise an AttributeError# Uncommenting obj2 = Derived() will# also raise an AtrributeError as# private member of base class# is called inside derived class |
Output
GeeksforGeeks
In the above example, we have created the c variable as the private attribute. We cannot even access this attribute directly and can’t even change its value.
Data Abstraction
It hides the unnecessary code details from the user. Also, when we do not want to give out sensitive parts of our code implementation , data abstraction came.
Data Abstraction in Python can be achieved through creating abstract classes.
Conclusion
- Object-Oriented Programming makes the program easy to understand as well as efficient.
- Since the class is sharable, the code can be reused.
- Data is safe and secure with data abstraction.
- Polymorphism allows the same interface for different objects, so programmers can write efficient code.
