method overloading

Author: PTHARRISH

.idea/workspace.xml

@@ -1,3 +1,155 @@
 print("------------------------------------------------------------------------------------------")
 print("-------------------------------------Tuple------------------------------------------------")
 print("------------------------------------------------------------------------------------------")
+
+# Tuple
+# A tuple is a collection of ordered elements that can be of different data types.
+# Tuples are immutable, meaning that once they are created, their elements cannot be changed.
+# Tuples are defined using parentheses () and can contain any number of elements.
+# Tuples can also be nested, meaning that a tuple can contain other tuples as elements.
+# Tuples are similar to lists, but they are immutable, 
+# meaning that their elements cannot be changed after they are created.
+# Tuples are often used to group related data together,
+# such as coordinates (x, y) or RGB color values (red, green, blue).
+# Tuples can also be used as keys in dictionaries,
+# while lists cannot be used as keys in dictionaries because they are mutable.
+# Tuples are also more memory efficient than lists,
+# making them a better choice for storing large amounts of data.
+# time complexity of tuple is O(1) for accessing elements,
+# O(n) for searching elements, and O(n) for iterating through the elements.
+# Tuples are also faster than lists for certain operations,
+# such as concatenation and repetition.
+# Tuples are also hashable, meaning that they can be used as keys in dictionaries,
+# while lists are not hashable and cannot be used as keys in dictionaries.
+# Tuples are also more memory efficient than lists,
+# making them a better choice for storing large amounts of data.
+
+# Methods of Tuple
+# 1. count() - Returns the number of occurrences of a specified value in a tuple.
+# 2. index() - Returns the index of the first occurrence of a specified value in a tuple.
+# 3. len() - Returns the number of elements in a tuple.
+# 4. max() - Returns the largest element in a tuple.
+# 5. min() - Returns the smallest element in a tuple.
+# 6. sum() - Returns the sum of all elements in a tuple.
+# 7. sorted() - Returns a sorted list of the elements in a tuple.
+# 8. all() - Returns True if all elements in a tuple are true (or if the tuple is empty).
+# 9. any() - Returns True if any element in a tuple is true. If the tuple is empty, returns False.
+# 10. tuple() - Converts an iterable (like a list) into a tuple.
+# 11. zip() - Combines two or more tuples into a single tuple of tuples.
+# 12. enumerate() - Returns an enumerate object, which contains pairs of index and value from the tuple.
+# 13. reversed() - Returns a reversed iterator of the tuple.
+# 14. map() - Applies a function to all items in the tuple and returns a new tuple.
+# 15. filter() - Filters elements from the tuple based on a function and returns a new tuple.
+# 16. repeat() - Repeats the elements of a tuple a specified number of times.
+# 17. unpacking - Unpacks the elements of a tuple into separate variables.
+# 18. slicing - Returns a new tuple that contains a portion of the original tuple.
+# 19. concatenation - Combines two or more tuples into a single tuple.
+# 20. repetition - Repeats the elements of a tuple a specified number of times.
+# 21. membership - Checks if an element is present in a tuple.
+# 22. iteration - Iterates through the elements of a tuple.
+# 23. copying - Creates a shallow copy of a tuple.
+# 24. deep copying - Creates a deep copy of a tuple.
+# 25. sorting - Sorts the elements of a tuple and returns a new tuple.
+# 26. reversing - Reverses the elements of a tuple and returns a new tuple.
+# 27. converting - Converts a tuple to a list and vice versa.
+# 28. packing - Packs multiple values into a tuple.
+
+# Example of Tuple
+# Creating a tuple
+my_tuple = (1, 2, 3, 4, 5)
+print("Tuple:", my_tuple)
+
+# Accessing elements in a tuple
+print("First element:", my_tuple[0])
+print("Last element:", my_tuple[-1])
+print("Slice of tuple:", my_tuple[1:4])
+print("Tuple length:", len(my_tuple))
+
+# Concatenating tuples
+tuple1 = (1, 2, 3)
+tuple2 = (4, 5, 6)
+tuple3 = tuple1 + tuple2
+print("Concatenated tuple:", tuple3)
+
+# Repeating tuples
+tuple4 = tuple1 * 3
+print("Repeated tuple:", tuple4)
+
+# Unpacking tuples
+a, b, c = tuple1
+print("Unpacked values:", a, b, c)
+
+# Nested tuples
+nested_tuple = (1, (2, 3), (4, 5))
+print("Nested tuple:", nested_tuple)
+
+# Accessing nested tuple elements
+print("Nested tuple element:", nested_tuple[1][0])
+print("Nested tuple length:", len(nested_tuple[1]))
+
+# Tuple methods
+# Count method
+count_tuple = (1, 2, 3, 1, 4, 5)
+print("Count of 1 in tuple:", count_tuple.count(1))
+
+# Index method
+print("Index of 3 in tuple:", count_tuple.index(3))
+
+# Max method
+print("Max element in tuple:", max(count_tuple))
+
+# Min method
+print("Min element in tuple:", min(count_tuple))
+
+# Sum method
+print("Sum of elements in tuple:", sum(count_tuple))
+
+# Sorted method
+print("Sorted tuple:", sorted(count_tuple))
+
+# All method
+print("All elements are true:", all(count_tuple))
+
+# Any method
+print("Any element is true:", any(count_tuple))
+
+# Tuple conversion
+list_to_tuple = [1, 2, 3, 4, 5]
+tuple_from_list = tuple(list_to_tuple)
+print("Tuple from list:", tuple_from_list)
+
+# Zip method
+tuple1 = (1, 2, 3)
+tuple2 = (4, 5, 6)
+zipped_tuple = zip(tuple1, tuple2)
+print("Zipped tuple:", list(zipped_tuple))
+
+# Enumerate method
+tuple1 = (1, 2, 3)
+enumerated_tuple = enumerate(tuple1)
+print("Enumerated tuple:", list(enumerated_tuple))
+
+# Reversed method
+tuple1 = (1, 2, 3)
+reversed_tuple = reversed(tuple1)
+print("Reversed tuple:", list(reversed_tuple))
+
+# Map method
+def square(x):
+    return x * x
+tuple1 = (1, 2, 3)
+mapped_tuple = map(square, tuple1)
+print("Mapped tuple:", tuple(mapped_tuple))
+
+# Filter method
+def is_even(x):
+    return x % 2 == 0
+tuple1 = (1, 2, 3, 4, 5)
+filtered_tuple = filter(is_even, tuple1)
+print("Filtered tuple:", tuple(filtered_tuple))
+
+# Repeat method
+from itertools import repeat
+tuple1 = (1, 2, 3)
+repeated_tuple = repeat(tuple1, 3)
+print("Repeated tuple:", list(repeated_tuple))

Notes/Tuple/Tuple.py

@@ -1,3 +1,15 @@
+# method Overloading
+# Method overloading is a feature that allows a class to have more than one method with the same name, 
+# but different parameters.
+# In Python, method overloading is not supported directly, 
+# but we can achieve it using the multipledispatch library.
+# To use the multipledispatch library, you need to install it first. You can do this using pip:
+# pip install multipledispatch
+# After installing the library, you can use it to create overloaded methods in your class.
+# Here is an example of method overloading using the multipledispatch library:
+# pip install multipledispatch
+
+
 from multipledispatch import dispatch
 
 # passing one parameter
@@ -33,3 +45,23 @@ def product(first, second, third):
 
 # calling product method with 3 arguments but all float
 obj.product(2.2, 3.4, 2.3) # this will give output of 17.985999999999997
+
+
+class table:
+    @dispatch(int)
+    def table(self, n):
+        for i in range(1, 11):
+            print(f"{n} * {i} = {n * i}")
+
+    @dispatch(int, int)
+    def table(self, n, m):
+        for i in range(1, m + 1):
+            print(f"{n} * {i} = {n * i}")
+
+
+obj = table()
+# calling table method with 1 argument
+obj.table(2)  # this will give output of 2 * 1 = 2, 2 * 2 = 4, ..., 2 * 10 = 20
+# calling table method with 2 arguments
+obj.table(2, 5)  # this will give output of 2 * 1 = 2, 2 * 2 = 4, ..., 2 * 5 = 10
+# calling table method with 3 arguments

Notes/oops/polymorphism/method_overloading.py

@@ -0,0 +1,60 @@
+# Operator Overloading 
+# Operator overloading is a feature that allows us to define the behavior of operators 
+# for user-defined classes.
+# In Python, we can overload operators by defining special methods in our class.
+# These special methods are also known as magic methods or dunder methods (double underscore methods).
+# The special methods for operator overloading are defined with double underscores 
+# before and after the method name.
+# For example, to overload the addition operator (+), we define the __add__ method in our class.
+# Other in arguments are passed to the method as parameters.
+# The first argument is always self, which refers to the instance of the class.
+# The second argument is the object that we are adding to the first object.
+# We can also overload other operators like -, *, /, %, //, **, ==, !=, <, >, <=, >=, etc.
+
+# Here is an example of operator overloading in Python:
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    # Overloading the + operator
+    def __add__(self, other):
+        return Point(self.x + other.x, self.y + other.y)
+
+    # Overloading the - operator
+    def __sub__(self, other):
+        return Point(self.x - other.x, self.y - other.y)
+
+    # Overloading the * operator
+    def __mul__(self, scalar):
+        return Point(self.x * scalar, self.y * scalar)
+
+    # Overloading the / operator
+    def __truediv__(self, scalar):
+        return Point(self.x / scalar, self.y / scalar)
+
+    # Overloading the str() function
+    def __str__(self):
+        return f"({self.x}, {self.y})"
+    
+# Example usage
+p1 = Point(2, 3)
+p2 = Point(4, 5)
+p3 = p1 + p2  # Calls __add__
+p4 = p1 - p2  # Calls __sub__
+p5 = p1 * 2   # Calls __mul__
+p6 = p1 / 2   # Calls __truediv__
+print(p3)  # Output: (6, 8)
+print(p4)  # Output: (-2, -2)
+print(p5)  # Output: (4, 6)
+print(p6)  # Output: (1.0, 1.5)
+# In this example, we have defined a Point class that represents a point in 2D space.
+# We have overloaded the +, -, *, and / operators to perform addition, subtraction, multiplication, and division on Point objects.
+# The __str__ method is also overloaded to provide a string representation of the Point object.
+# This allows us to use the operators with Point objects just like we would with built-in types.
+# Operator overloading is a powerful feature that allows us to create more intuitive and readable code.
+# It allows us to define the behavior of operators for our custom classes, making them behave like built-in types.
+# This can make our code more readable and easier to understand.
+# However, it is important to use operator overloading judiciously and not to overload operators in a way that is confusing or unexpected.
+# In general, operator overloading should be used to make the code more intuitive and readable.
+# It should not be used to create unexpected behavior or to make the code more complex.