Polymorphism in python | operator overloading | method overriding

Here is an explanation of how the video explains the concept of polymorphism in Python.

* The video begins by defining **polymorphism**, which means "having many forms". In programming, it refers to using the same function name for different data types and numbers of arguments.

* The video explains that there are four types of polymorphism in programming languages:
* Overloading of operators
* Class polymorphism
* Method overriding (runtime polymorphism)
* Method overloading (compile time polymorphism)

* The video states that **Python supports polymorphism through method overriding and operator overloading**. However, **Python does not support method overloading in the traditional sense**, but it can be achieved using other methods.

* The video provides an example of polymorphism using the **`len()` function**. This function behaves differently depending on the data type it is used with. For example:
* For strings, `len()` returns the number of characters.
* For lists, `len()` returns the number of elements.
* For dictionaries, `len()` returns the number of key-value pairs.

* The video then discusses **class polymorphism**. This is demonstrated using two classes, `Car` and `Boat`, both of which have a `move()` method. Even though the method has the same name in both classes, it performs different actions depending on the class.

* Next, the video covers **inheritance polymorphism**. This involves a parent class (`Vehicle`) with a `move()` method and two child classes (`Car` and `Boat`) that inherit from the parent class. The child classes override the `move()` method to perform different actions.

* The video also explains **operator overloading**, which allows operators like `+` and `*` to be used for different purposes depending on the context. For instance, `+` can be used to add numbers or concatenate strings.

* Finally, the video shows how to **achieve method overloading in Python using the `multipledispatch` library**. This library allows you to define multiple functions with the same name but different arguments, and Python will automatically call the correct function based on the types of the arguments.

In summary, the video provides a thorough overview of polymorphism in Python, covering different types of polymorphism, providing examples of each type, and demonstrating how to achieve method overloading despite its lack of direct support in the language.

Here is a comprehensive explanation of function overloading in Python, based on the provided source:

* **Function overloading, also known as compile-time polymorphism, is not directly supported in Python**.

* Traditional function overloading involves defining multiple functions with the same name but different parameters (number and/or types of arguments) within the same scope. The compiler then determines which function to call at compile time based on the arguments provided.

* While Python does not natively support this mechanism, **the source demonstrates how to achieve function overloading using the `multipledispatch` library**.

* The source provides a practical example using the `product` function. Two versions of the function are defined:
* `product(first: int, second: int)`: calculates the product of two integers.
* `product(first: int, second: int, third: int)`: calculates the product of three integers.

In essence, the `multipledispatch` library provides a way to mimic function overloading in Python by leveraging dynamic dispatch based on argument types. While not a native feature of the language, this technique allows for more readable and flexible code by enabling multiple functions with the same name to handle different scenarios.

All chapters:
00:00 Intro to Polymorphism
01:17 len() function as polymorphism
03:23 polymorphism in class
05:01 polymorphism in Inheritance
06:34 Operator overloading
08:00 Method overloading(using dispatch)