Composition in Python
Composition in Python
Composition is one of the important concepts of Object-oriented programming (OOPs). Composition basically enables us for creating complex types objects by combining other types of objects in the program. Composition represents ‘has a relationship’ type or we can call composition as ‘has a relationship’ in the OOPs concept. It means that a composite class present in the program can contains the objects from the other class components and this type of relationship model is called as has a relationship.
- Note: The classes that contains objects from the other classes in the program are called as composites whereas the classes which we use to create more complex type of relationship models is called as components.
Look at the following UML diagram to understand about the composition or has a relationship model:
Composite
In the above UML diagram, we have represented two different type of classes i.e., composites and components. The relationship between the composites and components is the composition. As we can see that we have represented the composition through a line where diamond from the composite class is pointing towards the components class representing the composition relationship.
In the composition relation, the composite class side represents the cardinality. Basically, the cardinality means the number of valid ranges or objects of the components class that a composite class is containing in it. As we can see in the above diagram, the 1 in the composite class represents only object of component class type is present in the composite class through composition.
We can express the cardinality of the composition through the following ways:
- By using a number (1, 2, 3, etc.)
- By using the * symbol
- By defining a range in composite (1...3, 2...5 etc.)
Composition allows us to reuse our code by adding objects with the other new objects, the feature which is not present in the inheritance concept.
Composition in Python
We know that Python is object-oriented programming language so it also follows the composition method. In Python, the composition allows us to reuse the implementation of the component class object in the composite classes. We have to remember that the composite class is not actually inheriting the component class interface but it is adapting the interface of instances of component class.
The composition relationship in Python between composite class and component class is considered as loosely coupled. It means that if we make changes in component class, it will rarely affect the composite class and if we make changes in the composite class, it will never affect the component class. This feature of composition in Python provides us better adaptability with the changes. It also allows us to introduce new changes in the application according to the requirements without affecting the existing code.
First, we will understand this through a basic example where we will use the basic concept of composition in our Python program and then we will move forward with the use of composition.
Example:
# create a component class in program
class ComponentClass:
# create the composite class constructor in component
def __init__(self):
print('An object for the Component class is created ...')
# using the composite class instance method
def mk1(self):
print('The Component class method mk1() is executed successfully ...')
# create a composite class in program
class CompositeClass:
# create a class constructor for composite class
def __init__(self):
# creating an instance for the component class
self.inst1 = ComponentClass()
print('An object for the Composite class is also created ...')
# creating a class instance method for composite class
def mk(self):
print('The Composite class method mk() is also successfully executed ...')
# calling the mk1() method of component class in composite class
self.inst1.mk1()
# creating an instance for the composite class
inst2 = CompositeClass()
# calling out mk() method from the composite class
inst2.mk()
Output:
An object for the Component class is created ... An object for the Composite class is also created ... The Composite class method mk() is also successfully executed ... The Component class method mk1() is executed successfully ...
Explanation: In the above given program, we have created two classes i.e., composite class and component class and named them specifically. The ComponentClass and CompositeClass shares the ‘has a type’ relation between them i.e., Composition relation. We have also created one object for both the classes. To use the composition between the classes, we have created a constructor for the composition class. We can see that we also have defined two methods into the respective classes i.e., mk() & mk1(). We have called out mk1() method of component class inside the mk() method of composite class. So, whenever we will call out the mk1() in the program, the mk() method will also be called out. We can also see this in the output of the program.
- That’s how we use the composition relation between the composite and component class in our Python program. Now, lets move forward with the uses of composition in Python.
Use of Composition in Python:
As we already discussed that the with the help of composition, we can use the interface of component class objects in the composite class. We can also reuse the code for the instance and interfaces of it. By this we can save our lot of time and writing of code for it. Let's understand how the composition in Python will be really helpful to us in daily life through the following example program:
- First create a Python program file by writing the following program in it:
# create an address class in the program
class AddressClass:
# define the components of the address class with default function
def __init__(self, Street1, LiveinCity, LiveinState, PostalCode, Country, Street2 = ''):
# defining components of address class as variables
self.Street1 = Street1
self.Street2 = Street2
self.LiveinCity = LiveinCity
self.LiveinState = LiveinState
self.PostalCode = PostalCode
self.Country = Country
# define the properties of the address class with default function
def __str__(self):
TotalLines = [self.Street1]
# using the if method to append the lines
if self.Street2:
lines.append(self.Street2)
# printing following components in next line
TotalLines.append(f'{self.LiveinCity}, {self.LiveinState} {self.PostalCode} {self.Country}')
return '\n'.join(TotalLines) # appending the lines for output
After writing the above program, save this Python file into the disk (We saved it with changing.py name in the device).
- After that, open another Python program file and write the following program in it:
# import the python program script for the address class
from changing import AddressClass
# define the elements for the address class
Address1 = AddressClass('55 Main St.', 'Concord City', 'NH25', '03301', 'Mexico')
Address2 = AddressClass('36 Side St.', 'New Mexico City', 'NH67', '033207', 'Mexico')
# print the address elements in the output
print('The first address element we added is: ')
print(Address1)
print('The second address element we added is: ')
print(Address2)
Output:
The first address element we added is: 55 Main St. Concord City, NH25 03301 Mexico The second address element we added is: 36 Side St. New Mexico City, NH67 033207 Mexico
Explanation:
In the above program, we have used composition relation in the address class that we defined in the changing.py script file.
In the address class, we have also defined the components of it. After that, we set the components of address class to variables so that it can store values in it. Then, we have modified the components and append the lines for the components in the output.
We used if statement for it. Then, we saved the script file in the device. We opened another Python file after that as we can see above. In the second file, we imported the address class from the changing.py script file. We used the addressclass() to add the elements of address in it. After that, the elements we added, we stored them as variable. Then, we printed the address elements that are stored in variables in the output.
We have implemented the __str()__ function in address class to modify the components of the address class i.e., how they being displayed and append the line in the output. While we use the address class components, it will also invoke the __str()__ function to called out. This is because of the composition relation function we used in the address class. It will help us to reuse the code we have written and interface of the __str()__ function.