<center>![Python Iterators and Tricks](https://files.peakd.com/file/peakd-hive/albro/EoiTEvYapeiZiNL8t6J3aEkSrArQQKhdkYAxV59K1PQafTAy4e6RJTUmgwFPp2uxM6y.jpg)</center>

<p><strong>Iterator</strong>s have many uses in <i>programming languages</i>. Programmers frequently use iterators when using ready-made data structures. In simpler words, with <strong>iterator</strong>s, we can traverse a <a href="https://peakd.com/hive-169321/@albro/python-list-and-tricks-by-albro">list</a>, array, or other specific data structure and check each of its elements in a <a href="https://peakd.com/hive-169321/@albro/python-loops-and-tricks-by-albro">loop</a>.</p>
<h3>What is an iterator?</h3>
<p>Maybe understanding the concept of <i>iterator</i> is a bit difficult and confusing!</p>
<p>Let's see the concept and situation of using iterators with a very simple example in the Python programming language.</p>
<p>Suppose you have a <a href="https://peakd.com/hive-169321/@albro/python-list-and-tricks-by-albro">list</a> of some numbers and you want to traverse on this list. As you know, this is possible simply by using a <a href="https://peakd.com/hive-169321/@albro/python-loops-and-tricks-by-albro">for loop</a>.</p>
<pre><code>my_list = [1, 2, 3, 4]<br />
for x in my_list:
    print(x) #or do something ...</code></pre>
<p><strong>But what happens behind the performance of the above loop?</strong></p>
<p>In a very simple case, suppose we have a pointer <a href="https://peakd.com/hive-169321/@albro/python-variable-and-constant-by-albro">variable</a> to the first element of this list (in the <a href="https://peakd.com/hive-169321/@albro/python-list-and-tricks-by-albro">Python list data structure</a>). When we use the list in a <code>for</code> loop, in the first execution of the loop, the first element is checked and traversed.</p>
<p>In the second iteration of <a href="https://peakd.com/hive-169321/@albro/python-loops-and-tricks-by-albro">the loop</a>, we must move one element forward, that is, our pointer must point to the second element (the element after the current element).</p>
<p>The said process is repeated for the number of elements in the list so that we don't have any more elements to replace with the previous element; In this case, our loop is completed. simply!</p>
<p>The concept of iterator in an object is as simple as it was said!!</p>
<p>In the picture below, the general and sequential process of iterators is drawn.</p>

<center>![What is python Iterators](https://files.peakd.com/file/peakd-hive/albro/Eo8SHaZJXrWjccJ8zbas1mcBNcttyBY2zmCJwtfpZW6e8fRp98XAZnt1kYDZRu9MKxN.jpg)</center>

<p>When we are creating an arbitrary data structure in Python, if we want our data structure to have the feature of being iterated, we must implement two methods related to iterators in our <a href="https://peakd.com/hive-169321/@albro/python-calss-by-albro">class</a>.</p>
<p><strong><code>__iter__</code> function</strong></p>
<p>This function is called when an object of our data structure is placed in a location for navigation. (for example in the <code>for</code> loop)</p>
<p>The <code>__iter__</code> method actually returns an object that has a method named <code>__next__</code>.</p>
<p><strong><code>__next__</code> function</strong></p>
<p>In the <code>__next__</code> method, a process is performed that the navigation pointer of our elements moves one step forward, points to the next element and finally outputs the current element.</p>
<h3>An example to understand the structure of iterators in Python</h3>
<p>To better understand the structure of iterators, suppose we have a <a href="https://peakd.com/hive-169321/@albro/python-calss-by-albro">class</a> with a <a href="https://peakd.com/hive-169321/@albro/python-variable-and-constant-by-albro">variable</a> named <code>current</code> and set its initial value to <code>1</code>.</p>
<pre><code>class Numbers:
    def __init__(self):
        self.current = 1</code></pre>
<p>Now, if we create an example from our test class and try to use it in a simple <a href="https://peakd.com/hive-169321/@albro/python-loops-and-tricks-by-albro">for loop</a>, we will encounter an error!</p>
<pre><code>obj = Numbers()<br />
for x in obj:
      print(x)<br /><br />
# Run Result:
# Traceback (most recent call last):
#   File "<pyshell#7>", line 1, in <module>
#     for x in obj:
# TypeError: 'Numbers' object is not iterable</code></pre>
<p>As it is clear from the last line of the given error, the objects of the <code>Numbers</code> class cannot be iterated, or in other words, they're not iterable.</p>
<p>
As mentioned before, we need two more helper functions to make the desired class iterable. Next, we will add two necessary methods to our class. That is, our class will be something like the code below.</p>
<pre><code>class Numbers:
    def __init__(self):
        self.current = 1<br />
    def __iter__(self):
        return self<br />
    def __next__(self): #have infinit end!
        output = self.current
        self.current += 1
        return output</code></pre>
<p>Now, if we run the same loop as before, we will see the number 1 printed in the output at the beginning, and the number 2 in the next line, and this process continues to infinity.</p>
<p>Usually, there is a certain limitation in the data structure we have; For example, there is a countable number of elements in it, or in our educational example (<code>Numbers</code> class), it can be considered that the iteration will advance to a certain ceiling.</p>
<p>In order to take the expected ceiling as input, we change the constructor of the class and we will take the two values <code>low</code> and <code>high</code> as input when creating the object.</p>
<p>Also, to control the non-overflow of the expected limit, a condition should be placed in the <code>__next__</code> method to check that the expected limit has been reached. If we reach our ceiling, we can use the <code>StopIteration</code> statement to announce to the <code>for</code> loop that the iteration is over.</p>
<pre><code>class Numbers:
    def __init__(self, low, high):
        self.current = low
        self.limit = high<br />
    def __iter__(self):
        return self<br />
    def __next__(self):
        if self.current > self.limit:
            raise StopIteration
        output = self.current
        self.current += 1
        return output</code></pre>
<p>As a result of executing the following test code, we will have the numbers 1 to 10 in the output.</p>
<pre><code>obj = Numbers(1, 10)<br />
for x in obj:
    print(x)</code></pre>
<p>Now if we use the same object <code>obj</code> in another loop, you will see that no result will be obtained!</p>
<p>The reason for this is that the variable related to <code>current</code> has reached its maximum once the iteration operation has been executed, and in other times the iteration, because it has reached the <code>limit</code>, terminates the loop at the beginning of the execution by declaring <code>StopIteration</code>.</p>
<p>To avoid this, we can return the variables used as pointers (iterations) to their initial value in the <code>__iter__</code> method.</p>
<p>Here only the value of the <code>current</code> variable changes and our problem is exactly this variable.</p>
<p>The problem can be easily solved by keeping the <code>low</code> value when creating an object from the class and assigning it to the <code>current</code> variable when executing the <code>__iter__</code> method.</p>
<pre><code>class Numbers:
    def __init__(self, low, high):
        self.low = low
        self.limit = high<br />
    def __iter__(self):
        self.current = self.low
        return self<br />
    def __next__(self):
        if self.current > self.limit:
            raise StopIteration
        output = self.current
        self.current += 1
        return output</code></pre>
<p>Sometimes, due to the complexity of the process of maintaining the current element and jumping to its next element in each iteration step, the <code>iterable</code> class is defined as a separate class and only the <code>__iter__</code> method is used in the main class.</p>
<p>If <code>__iter__</code> is called, an object of the auxiliary class is created and returned; It should be noted that the auxiliary class must have two functions <code>__iter__</code> and <code>__next__</code>.</p>