14 - Inheritance & Polymorphism

Explore how inheritance and aggregation create dynamic class relationships in Python, modeling customer data with nested address details.

Output

Example 2

Explanation

• Creates two classes Customer and Address to model customer data with aggregation relationship
• Address class has private attribute __city and public pin and state attributes
• Customer class stores name, gender, and an Address object, with method to print address details
• When cust.print_address() is called, it accesses the Address object's private __city attribute directly
• The code demonstrates that private attributes in aggregation relationships can still be accessed directly in Python, though this breaks encapsulation principles

Output

Example 3

Explanation

• Creates two classes Customer and Address to model customer data with encapsulated address information
• The Address class uses private attribute __city with a getter method get_city() to access it safely
• Customer class stores a reference to an Address object and has a method to print address details
• When cust.print_address() is called, it outputs the city, pin code, and state from the embedded address object
• The code demonstrates object composition where Customer contains an Address instance, and proper encapsulation through private attributes

Output

Example 4

Explanation

• Creates two classes Customer and Address to model customer data with encapsulated address information
• Address class stores city, pin, and state with private city attribute and methods to access/edit it
• Customer class holds customer details and has methods to print address and edit profile information
• When edit_profile is called, it updates customer name and calls edit_address on the associated address object
• Prints the address information twice - first showing original Vizag address, then updated Hyderabad address after editing

Output

Aggregation class diagram

Inheritance

• What is inheritance
• Example
• What gets inherited?

Inheritance and it's benefits

-Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class (called a child or derived class) to inherit attributes and methods from another class (called a parent or base class).

Example 5

Explanation

• Creates a parent class User with a constructor setting name to 'madhu' and a login method that prints 'login'
• Creates a child class Student that inherits from User but has its own constructor setting rollno to 100 and an enroll method that prints 'enroll into the course'
• The Student class doesn't call the parent's __init__ method, so it doesn't inherit the name attribute, which leads to an AttributeError when trying to access s.name
• Attempts to print s.name will raise an AttributeError because the Student class doesn't initialize the name attribute from the parent class
• Calls s.login() work because inheritance allows access to parent methods, but s.enroll() works because it's defined in the child class

Output

Example 6

Explanation

• Creates a parent class User with a constructor setting name to 'madhu' and a login method that prints 'login'
• Creates a child class Student that inherits from User, gaining access to all parent attributes and methods
• Instantiates one User object and one Student object
• Prints the inherited name attribute from the parent class, then calls inherited login method and child class method
• Output shows 'madhu', followed by 'login' and 'enroll into the course' printed to console

Output

Class Diagram (Triangle)

What gets inherited?

• Constructor
• Non Private Attributes
• Non Private Methods

Example 7

Explanation

• Creates a Phone class with a constructor that prints a message and stores price, brand, and camera attributes
• Defines a SmartPhone class that inherits from Phone using pass (no additional methods)
• Instantiates a SmartPhone object with price 20000, brand "Apple", and camera 13
• Calls the buy method inherited from Phone class which prints "Buying a phone"
• Output shows "Inside phone constructor" followed by "Buying a phone" due to inheritance

Output

Example 8

Explanation

• This code defines a parent Phone class with a constructor that initializes price, brand, and camera attributes, plus prints a message when called
• It creates a child SmartPhone class that inherits from Phone but has its own constructor that only initializes os and ram attributes
• The SmartPhone constructor doesn't call the parent constructor using super(), so the Phone.__init__ method never executes
• When creating a SmartPhone instance, only "Inside SmartPhone constructor" gets printed, not "Inside phone constructor"
• Accessing s.brand raises an AttributeError because the parent constructor was never called, so the brand attribute was never created

Output

Example 9

Explanation

• The code defines a parent Phone class with a private attribute __price and a public show method that prints the price
• The SmartPhone class inherits from Phone and tries to access the private __price attribute in its check method using name mangling (_Phone__price)
• The show method in the parent class successfully prints the private price value using print (self.__price)
• The child class can access the parent's private attributes through name mangling but cannot directly access them with self.__price
• When executed, it prints "Inside phone constructor" followed by the price value 20000

Output

Example 10

Explanation

• Prints the value of the brand attribute from the object s
• Uses dot notation to access an attribute of an object
• Likely outputs the brand name if s is an instance of a class with a brand attribute
• No function calls or complex operations involved
• Side effect is displaying text output to console

Output

Example 11

Explanation

• Runs a validation check on the schema object s to verify its structure and data types
• Uses the .check() method which is likely part of a schema validation library like Great Expectations or similar
• This operation typically returns a boolean result indicating whether the schema passes all validation rules
• May raise exceptions or log errors if validation fails, depending on the library implementation
• Side effect is that it triggers any configured validation callbacks or logging mechanisms within the schema object

Output

Example 12

Explanation

• The code defines a parent Phone class with a private __price attribute and a private method __show that prints the price
• The SmartPhone class inherits from Phone but tries to access the private __price attribute directly and through name mangling
• The __init__ method prints a message when a Phone object is created and sets up the private __price attribute
• When s.show() is called, it will raise an AttributeError because show() is not defined in either class, though __show exists
• The code demonstrates Python's name mangling where __price becomes _Phone__price internally, but direct access still fails due to inheritance limitations

Output

Example 13

Explanation

• Creates a Parent class with private attribute __num and getter method get_num()
• Creates a Child class that inherits from Parent class using inheritance syntax Child(Parent)
• Instantiates a Child object with num=100 and calls get_num() to retrieve the private attribute value
• Calls show() method on the Child object which prints "This is in child class"
• Output shows 100 followed by "This is in child class" printed to console

Output

Example 14

Explanation

• Code defines a Parent class with private attribute __num and getter method get_num(), then a Child class inheriting from Parent but with its own private attribute __val and getter method get_val()
• Child class constructor overrides parent constructor but doesn't call super().__init__(), so Parent's __num remains uninitialized
• When trying to access son.get_num() it will raise an AttributeError because __num was never set in the Child instance
• The code demonstrates inheritance but has a bug where child class doesn't properly initialize parent class attributes
• Expected output would be an AttributeError when calling son.get_num() since the parent's __num attribute was never initialized

Output

Example 15

Explanation

• Creates a Parent class with private attribute __num and getter method get_num
• Creates a Child class that inherits from Parent but has its own private attribute __val and getter method get_val
• Child constructor takes two parameters but only initializes __val, not calling parent constructor with super()
• Attempts to access son.get_val() which returns 100, but son.get_num() would raise AttributeError since Parent's __num was never initialized
• Output shows "Child: Val: 100" because only the Child class's get_val() method works, not the Parent's methods due to incomplete inheritance setup

Output

Example 16

Explanation

• Creates two classes A and B where B inherits from A, with class A having an initializer that sets var1 to 100 and a method to display var1
• Defines a subclass B that inherits all methods and attributes from class A and adds its own display2 method
• Instantiates an object of class B and calls both inherited display1 method (from A) and B's own display2 method
• Both methods print their respective class names along with the value passed as argument (200), showing inheritance working correctly
• Output shows "class A : 100" followed by "class B : 200" demonstrating that display1 uses the inherited var1 value while display2 receives the parameter value

Output

Example 17

Explanation

• Creates two classes A and B where B inherits from A, with class A having an initializer setting var1 to 100 and a method to display values
• Defines a display1 method in class A that prints "class A :" followed by the passed variable value
• Defines a display2 method in class B that prints "class B :" followed by the passed variable value
• Creates an instance of class B called obj and calls both inherited and child methods with different arguments
• Outputs "class A : 200" and "class B : 300" to the console showing inheritance and method calling behavior

Output

Example 18

Explanation

• Class A defines an initializer that sets instance variable var1 to 100, and a method display1 that updates and prints var1
• Class B inherits from class A and adds its own method display2 that prints the inherited var1
• An object of class B is created and display1 is called with argument 200, which updates var1 to 200 and prints "class A : 200"
• The same object then calls display2 with argument 300, but this prints the current value of var1 (which is 200 from previous call) as "class B : 200"
• The code demonstrates inheritance where B inherits var1 from A, and shows how method calls affect instance variables across the inheritance hierarchy

Output

Example 19

Explanation

• This code demonstrates method overriding by defining a buy method in both a parent Phone class and a child SmartPhone class
• The SmartPhone class inherits from Phone and overrides the buy method to provide its own implementation
• When creating a SmartPhone instance with SmartPhone(20000, "Apple", 13), it calls the parent's __init__ method first, then stores the price, brand, and camera attributes
• The buy() method call on the SmartPhone instance executes the overridden version in the child class, printing "Buying a smartphone"
• The parent constructor prints "Inside phone constructor" when the object is created, showing the inheritance chain execution

Output

Super Keyword

Example 20

Explanation

• This code defines a parent class Phone with a constructor that initializes price, brand, and camera attributes, plus a buy method that prints "Buying a phone"
• It creates a child class SmartPhone that inherits from Phone and overrides the buy method to print "Buying a smartphone" before calling the parent's buy method using super().buy()
• The __price attribute is private (dunder prefix) while brand and camera are public instance variables
• When creating a SmartPhone object with price 20000, brand "Apple", and camera 13, it triggers the parent constructor which prints "Inside phone constructor"
• Calling s.buy() outputs "Buying a smartphone" followed by "Buying a phone" due to the method override and super() call

Output

Example 21

Explanation

• This code defines a parent class Phone with an __init__ constructor and buy method, plus a child class SmartPhone that inherits from Phone and overrides the buy method
• The SmartPhone class tries to call super().buy() but this will cause an error because super() can only be used inside the class hierarchy, not from outside
• The __init__ method initializes private price attribute, brand, and camera attributes of the phone
• When creating a SmartPhone instance, it calls the parent's __init__ method which prints "Inside phone constructor"
• The code demonstrates that super() must be called within the child class methods to access parent class functionality, not from external code

Output

Example 22

Explanation

• Defines a Phone class with an initializer that sets price, brand, and camera attributes, and a buy method that prints a message.
• Defines a SmartPhone class that inherits from Phone, overrides the buy method to print a different message, and accesses the parent class's brand attribute using super().
• Creates an instance of SmartPhone with specific values for price, brand, and camera.
• Calls the buy method on the SmartPhone instance, which prints "Buying a smartphone" followed by the brand "Apple".

Output

Example 23

Explanation

• Defines a Phone class with an initializer that sets price, brand, and camera attributes, printing a message when called.
• Defines a SmartPhone class that inherits from Phone, with its own initializer that adds operating system and RAM attributes, also printing a message.
• Uses super() to call the parent class's initializer, ensuring the Phone attributes are set when creating a SmartPhone instance.
• Creates an instance of SmartPhone with specific values for price, brand, camera, operating system, and RAM.
• Prints the operating system and brand of the SmartPhone instance, which outputs "Android" and "Samsung" respectively.

Output

Inheritance in summary

• A class can inherit from another class.

• Inheritance improves code reuse

• Constructor, attributes, methods get inherited to the child class

• The parent has no access to the child class

• Private properties of parent are not accessible directly in child class

• Child class can override the attributes or methods. This is called method overriding

• super() is an inbuilt function which is used to invoke the parent class methods and constructor

Example 24

Explanation

• Defines a Parent class with a private attribute __num and a method get_num() to access it.
• Defines a Child class that inherits from Parent, adds a private attribute __val, and has a method get_val() to access it.
• Creates an instance of Child named son with num set to 100 and val set to 200.
• Calls get_num() on son, which returns 100, and get_val(), which returns 200.
• Outputs the values 100 and 200 to the console.

Output

Example 25

Explanation

• Defines a Parent class with an __init__ method that initializes an attribute num to 100.
• Defines a Child class that inherits from Parent, calls the parent's __init__ method using super(), and initializes its own attribute var to 200.
• Contains a show method in the Child class that prints the values of num and var.
• Creates an instance of Child named son and calls its show method.
• The expected output is:

Output

Example 26

Explanation

• Defines a Parent class with a private attribute __num initialized to 100 and a method show() that prints its value.
• Defines a Child class that inherits from Parent, initializes its own private attribute __var to 10, and overrides the show() method to call the parent's show() and print its own attribute.
• Creates an instance of Child and calls its show() method, which prints both the parent's and child's private attributes.
• The expected output is:
• The use of super() allows the child class to access methods from the parent class.

Output

Example 27

Explanation

• Defines a Parent class with a private attribute __num initialized to 100 and a method show that prints its value.
• Defines a Child class that inherits from Parent, initializes its own private attribute __var to 10, and overrides the show method to print __var.
• Creates an instance of Child and calls its show method.
• The output will be "Child: 10" since the show method in Child is called, which accesses its own private attribute.

Output

Types of Inheritance

• Single Inheritance
• Multilevel Inheritance
• Hierarchical Inheritance
• Multiple Inheritance(Diamond Problem)
• Hybrid Inheritance

Example 28

Explanation

• Defines a base class Phone with an initializer that sets price, brand, and camera attributes, and a method buy that prints a message.
• The SmartPhone class inherits from Phone but does not add any new functionality or attributes.
• An instance of SmartPhone is created with specific values for price, brand, and camera, triggering the Phone constructor and printing "Inside phone constructor".
• The buy method is called on the SmartPhone instance, resulting in the output "Buying a phone".

Output

Example 29

Explanation

• Defines a multilevel class hierarchy with Product as the base class, Phone as a derived class, and SmartPhone as a subclass of Phone.
• The Phone class has an __init__ method that initializes price, brand, and camera attributes, and prints a message when an instance is created.
• The buy method in the Phone class prints a message indicating a phone purchase.
• The SmartPhone class inherits from Phone but does not add any new functionality.
• When an instance of SmartPhone is created and methods buy and review are called, it outputs messages indicating the purchase and a customer review.

Output

Example 30

Explanation

• Defines a base class Phone with an initializer that sets price, brand, and camera attributes, and prints a message when an instance is created.
• Contains a buy method in the Phone class that prints "Buying a phone" when called.
• Inherits from Phone, creating two subclasses: SmartPhone and FeaturePhone, which do not add any new functionality.
• Creates an instance of SmartPhone with specific attributes and calls its buy method, resulting in the output "Buying a phone".
• Creates an instance of FeaturePhone with different attributes and also calls its buy method, producing the same output.

Output

Example 31

Explanation

• Defines a Phone class with an initializer that sets price, brand, and camera attributes, and a method to simulate buying a phone.
• Defines a Product class with a method for customer reviews.
• Creates a SmartPhone class that inherits from both Phone and Product.
• Instantiates a SmartPhone object with specific attributes and calls its buy and review methods.
• Expected output includes messages indicating the constructor execution, phone buying action, and customer review.

Output

Example 32

Explanation

• This code defines a multiple inheritance structure where SmartPhone inherits from both Phone and Product classes
• The Phone class has a constructor that initializes price, brand, and camera attributes, plus a buy method
• The Product class has a review method that prints customer reviews
• SmartPhone inherits methods from both parent classes but tries to pass 4 arguments to Phone's constructor which only expects 3
• The code will raise a TypeError because the constructor call doesn't match the expected parameter count

Output

Example 33

Explanation

• Creates a Phone class with constructor that prints message and sets private price, brand, and camera attributes
• Defines a Product class with review method that prints customer rating
• Creates SmartPhone class that inherits from both Phone and Product classes using multiple inheritance
• Instantiates SmartPhone object with price 20000, brand "Apple", and camera 12, triggering parent constructor
• Calls buy() method from Phone class and review() method from Product class on the SmartPhone instance

Output

Example 34

Explanation

• Creates a Phone class with constructor that initializes private price, brand, and camera attributes, plus a buy method that prints a message
• Defines a Product class with a review method that takes a rating parameter and prints customer review information
• Creates SmartPhone class that inherits from both Phone and Product classes using multiple inheritance
• Instantiates a SmartPhone object with price 20000, brand "Apple", camera 12, and rating 4.9, calling parent constructor via super()
• Calls buy() method from Phone class and review() method from Product class on the SmartPhone instance, printing corresponding messages

Output

Example 35

Explanation

• This code demonstrates the diamond problem in Python's multiple inheritance by creating a class hierarchy where SmartPhone inherits from both Phone and Product classes
• The SmartPhone class uses multiple inheritance with Phone and Product as parent classes, showing how Python resolves method calls through the Method Resolution Order (MRO)
• When calling s.buy(), Python follows the MRO and executes the buy method from the first parent class listed (Product) rather than the Phone class, even though both have a buy method
• The __init__ method of Phone gets called during object creation, printing "Inside phone constructor" and setting up instance variables like __price, brand, and camera
• The output shows "Product buy method" being printed because Product appears first in the inheritance list class SmartPhone(Phone,Product): making it the priority in method resolution order

Output

Example 36

Explanation

• Creates a class hierarchy with A as parent, B inheriting from A, and C inheriting from B
• Defines method m1 in both A and B classes, and method m2 in both B and C classes
• Instantiates three objects: obj1 of type A, obj2 of type B, and obj3 of type C
• Calls methods on objects: obj1.m1() returns 20, obj3.m1() returns 30 (from B's override), obj3.m2() returns 20 (from C's override)
• Prints sum of 20 + 30 + 20 = 70 due to method resolution order and inheritance overrides

Output

Example 37

Explanation

• Class C inherits from class B, which inherits from class A, creating a multi-level inheritance chain
• Method m1 in class C calls self.m1() which recursively calls its own m1 method, leading to infinite recursion
• The super() function in class B correctly calls the parent class A's m1 method and adds 30 to its result
• When obj.m1() is called, it triggers infinite recursion because C's m1 calls itself without proper base case termination
• This code will raise a RecursionError due to the recursive call loop in class C's m1 method

Output

Example 38

Explanation

• Class C inherits from class B, which inherits from class A, creating a inheritance chain
• Each class has a method named m1() that overrides the parent's implementation
• The super() function calls the parent class's m1() method to get its return value and adds additional values
• Class A's m1() returns 20, B's m1() adds 30 to get 50, and C's m1() adds 20 to get 70
• The final output printed is 70 when calling obj.m1() on an instance of class C

Output

Polymorphism

• Method Overriding
• Method Overloading
• Operator Overloading

Polymorphism means "many forms". It refers to the ability of an entity (like a function or object) to perform different actions based on the context.

Technically, in Python, polymorphism allows same method, function or operator to behave differently depending on object it is working with. This makes code more flexible and reusable.

Example 39

Explanation

• Defines a base Animal class with a sound method that returns "Some generic sound"
• Creates Dog and Cat subclasses that override the sound method with their specific sounds
• Demonstrates polymorphism by creating a list containing instances of different animal types
• Calls the sound method on each animal instance, showing how each subclass provides its own implementation
• Prints "Bark", "Meow", and "Some generic sound" in sequence due to method overriding behavior

Output

Example 40

Explanation

• This code attempts to demonstrate method overloading by defining two area methods in the Shape class with different parameters
• The second area method with parameters (l, b) overwrites the first one with parameter (radius), so only the second method is actually usable
• When calling s.area(5), it will cause an error because the method expects two arguments but only receives one
• When calling s.area(5, 6), it correctly calculates and returns the rectangle area (30)
• The comment explains that Python doesn't support traditional method overloading like Java or C++ due to its dynamic nature

Output

Example 41

Explanation

• Defines a Shape class with an area method that calculates different areas based on parameters
• Uses default parameter b=0 to handle both circle (when b=0) and rectangle (when b>0) area calculations
• First print statement calculates circle area with radius 2 using formula 3.14aa
• Second print statement calculates rectangle area with length 3 and width 4 using formula a*b
• Outputs circle area of 12.56 followed by rectangle area of 12

Output

Example 42

Explanation

• Concatenates two string objects 'hello' and 'world' into a single string
• Uses Python's built-in addition operator (+) which is overloaded for string objects
• The + operator calls the add method internally for string objects
• Results in the string 'helloworld' as output
• Demonstrates how operators can have different behaviors based on data types

Output

Example 43

Explanation

• Performs simple arithmetic addition of two integers (4 and 5)
• Uses Python's built-in addition operator (+) to calculate the sum
• Returns the numeric result of 9 as the output
• This is a basic expression that evaluates to a single integer value
• No additional functions or side effects are involved in this operation

Output

Example 44

Explanation

• This code concatenates two lists in Python using the + operator.
• The first list is [1, 2, 3] and the second list is [4, 5].
• The result of the operation is a new list that combines both lists: [1, 2, 3, 4, 5].
• No side effects occur; the original lists remain unchanged.

Output