Implementing a Pythonic Zip Function

The zip() function in Python is a powerful built-in tool that aggregates elements from multiple iterables. It's incredibly useful for parallel iteration, processing related data streams, and simplifying code that would otherwise require manual indexing. Your challenge is to recreate this functionality from scratch.

Problem Description

You need to implement a Python function named my_zip that mimics the behavior of the built-in zip() function. This function should accept an arbitrary number of iterable arguments (lists, tuples, strings, etc.) and return an iterator of tuples. Each tuple will contain elements from the input iterables at the corresponding index.

Key Requirements:

• The function should accept one or more iterable arguments.
• It should return an iterator.
• The iterator should yield tuples.
• The length of the yielded tuples will be equal to the number of input iterables.
• The iteration stops when the shortest input iterable is exhausted.

Expected Behavior:

• If no arguments are provided, the function should return an empty iterator.
• If one or more iterables are provided, it should yield tuples.

Edge Cases to Consider:

• No arguments: my_zip()
• One argument: my_zip([1, 2, 3])
• Unequal length iterables: my_zip([1, 2], ['a', 'b', 'c'])
• Empty iterables: my_zip([], [1, 2])
• Mixed iterable types: my_zip([1, 2], ('a', 'b'))

Examples

Example 1:

Input: list1 = [1, 2, 3], list2 = ['a', 'b', 'c']
Output: Iterator yielding (1, 'a'), (2, 'b'), (3, 'c')
Explanation: Pairs elements from list1 and list2 at the same index.

Example 2:

Input: list1 = [1, 2], list2 = ['a', 'b', 'c']
Output: Iterator yielding (1, 'a'), (2, 'b')
Explanation: Iteration stops after the second element because list1 is exhausted.

Example 3:

Input: list1 = [], list2 = [1, 2, 3]
Output: Empty iterator
Explanation: The shortest iterable (list1) is empty, so no tuples are yielded.

Example 4:

Input: list1 = [1, 2, 3]
Output: Iterator yielding (1,), (2,), (3,)
Explanation: When only one iterable is provided, each yielded tuple contains a single element.

Constraints

• The function should handle any number of input iterables from 0 to potentially many.
• The input iterables can be of any type that supports iteration (e.g., lists, tuples, strings, range objects).
• The solution should be implemented using Python's iterator protocol (__iter__ and __next__). You are not allowed to use the built-in zip() function in your implementation.

Notes

• Consider how you will manage the state of each individual iterator obtained from the input iterables.
• Think about how to determine when to stop iteration.
• Using a yield statement will be crucial for creating an iterator.
• You'll need to unpack the arguments passed to your function.