61. Iterator Protocol

In Python, the iterator protocol consists of two main methods: __iter__() and __next__(). These methods allow you to create custom iterators, enabling you to iterate over an object. Here's a detailed explanation and examples of how to implement a custom iterator.

1. Basic Custom Iterator

To create a basic custom iterator, you need to define a class that implements both __iter__() and __next__() methods. The __iter__() method returns the iterator object itself, while __next__() returns the next value in the iteration.

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current

# Using the iterator
countdown = Countdown(5)
for num in countdown:
    print(num)

Output:

4
3
2
1

In this example, the Countdown class counts down from a starting number. The __next__() method decreases the current value until it reaches 0, at which point it raises StopIteration to signal the end of the iteration.

---

2. Custom Range Class

You can implement your own version of the range function using the iterator protocol. This will give you control over the iteration behavior.

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        self.current += 1
        return self.current - 1

# Using the custom range
for i in MyRange(1, 5):
    print(i)

Output:

1
2
3
4

Here, MyRange implements a custom range where you can specify a start and end value. The __next__() method increments the current value and returns it until the current value reaches or exceeds the end value.

---

3. Fibonacci Iterator

A Fibonacci sequence iterator is another good example of using the iterator protocol.

class Fibonacci:
    def __init__(self, limit):
        self.limit = limit
        self.a, self.b = 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.limit <= 0:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        self.limit -= 1
        return self.a

# Using the Fibonacci iterator
fib = Fibonacci(5)
for number in fib:
    print(number)

Output:

1
1
2
3
5

This example shows a Fibonacci sequence generator, where each call to __next__() produces the next Fibonacci number in the sequence until the specified limit is reached.

---

4. Iterating Over Multiple Items

If you want to iterate over multiple items or collections, you can customize the iteration logic by combining the __iter__() and __next__() methods.

class MultiIterator:
    def __init__(self, *args):
        self.iterators = [iter(arg) for arg in args]

    def __iter__(self):
        return self

    def __next__(self):
        for it in self.iterators:
            try:
                return next(it)
            except StopIteration:
                pass
        raise StopIteration

# Using the multi iterator
multi_iter = MultiIterator([1, 2, 3], ['a', 'b'], [7, 8, 9])
for item in multi_iter:
    print(item)

Output:

1
2
3
a
b
7
8
9

In this example, MultiIterator takes multiple iterables (lists) and iterates through them sequentially. Each time __next__() is called, it retrieves the next value from each iterable in turn.

---

5. Custom Infinite Iterator

You can implement an iterator that doesn't stop, such as one that generates an infinite sequence of numbers.

class InfiniteCounter:
    def __init__(self, start=0):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        self.current += 1
        return self.current - 1

# Using the Infinite Counter iterator
counter = InfiniteCounter(10)
for _ in range(5):
    print(next(counter))

Output:

10
11
12
13
14

This InfiniteCounter iterator will keep generating numbers starting from the specified value. It never stops, but we limit the number of iterations to 5 in this example.

---

6. Iterator for File Lines

You can create a custom iterator for reading lines from a file.

class FileIterator:
    def __init__(self, file_name):
        self.file = open(file_name, 'r')

    def __iter__(self):
        return self

    def __next__(self):
        line = self.file.readline()
        if not line:
            self.file.close()
            raise StopIteration
        return line.strip()

# Using the FileIterator
file_iter = FileIterator('sample.txt')  # Use an actual file for this to work
for line in file_iter:
    print(line)

This custom iterator reads lines from a file one at a time. When all lines have been read, it raises StopIteration.

---

7. Prime Numbers Iterator

Here is an example of an iterator that generates prime numbers.

class PrimeNumbers:
    def __init__(self):
        self.number = 2

    def __iter__(self):
        return self

    def __next__(self):
        while True:
            for i in range(2, self.number):
                if self.number % i == 0:
                    break
            else:
                prime = self.number
                self.number += 1
                return prime
            self.number += 1

# Using the Prime Numbers iterator
primes = PrimeNumbers()
for _ in range(5):
    print(next(primes))

Output:

2
3
5
7
11

This example shows a prime number generator that continuously checks for prime numbers, starting from 2.

---

8. Custom Iterator with Reset

You can implement an iterator that allows resetting the iteration state.

class ResettableIterator:
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.current = start

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        self.current += 1
        return self.current - 1

    def reset(self):
        self.current = self.start

# Using the ResettableIterator
iterator = ResettableIterator(1, 5)
for item in iterator:
    print(item)

iterator.reset()
for item in iterator:
    print(item)

Output:

1
2
3
4
1
2
3
4

This example shows an iterator that can be reset to the start value using the reset() method.

---

9. Multiple Iterators in Parallel

This example shows how to iterate over multiple collections in parallel, yielding elements from each one.

class ParallelIterator:
    def __init__(self, *args):
        self.iterators = [iter(arg) for arg in args]

    def __iter__(self):
        return self

    def __next__(self):
        result = []
        for it in self.iterators:
            try:
                result.append(next(it))
            except StopIteration:
                pass
        if not result:
            raise StopIteration
        return result

# Using ParallelIterator
iterator = ParallelIterator([1, 2], ['a', 'b', 'c'], [10, 20])
for item in iterator:
    print(item)

Output:

[1, 'a', 10]
[2, 'b', 20]

This iterator iterates through multiple iterables and returns a list of corresponding elements from each iterable.

---

10. Custom Range with Step

You can add a custom step value to your iterator.

class MyRangeWithStep:
    def __init__(self, start, end, step):
        self.start = start
        self.end = end
        self.step = step

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        current_value = self.current
        self.current += self.step
        return current_value

# Using MyRangeWithStep
for num in MyRangeWithStep(1, 10, 2):
    print(num)

Output:

1
3
5
7
9

This iterator generates numbers from start to end with a custom step value.

---

These examples demonstrate how you can implement the iterator protocol using `iter

()andnext()` methods in Python. You can adapt the iterator behavior to your specific needs, whether you want to create infinite sequences, iterate over files, or create custom stepping patterns.