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))