About Python for loops

The goal of this story

• Know what a Python for loop is (I'm curious)
• Know the difference between list comprehension and generator representation

for loop

for_loop.py

for i in [0, 1, 2, 3, 4]:
    print(i)

When you run

% python for_loop.py
0
1
2
3
4

for i inI want to know how the thing behind is used. (In the case of the above example, it seems that the elements of ``` [0, 1, 2, 3, 4]` `` are extracted in order.)

Try putting in a nice object

Let's see how it is hit with reference to the runtime error

duck.py

class Duck(object):
    pass


if __name__ == '__main__':
    for i in Duck():
        print(i)

When I run it, I get angry if it is not iterable

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 6, in <module>
    for i in Duck():
TypeError: 'Duck' object is not iterable

• iterable is an object that has a `__ iter__ ()` method
• Because of that definition, I believe it for the time being

Try implementing iterable

I was told to implement it, so I will implement it. But just return an empty object

duck.py

class DuckIter(object):
    def __init__(self):
        pass


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

The error has changed (one step forward!)

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 12, in <module>
    for i in Duck():
TypeError: iter() returned non-iterator of type 'DuckIter'

• an iterator is an object that has a next () `` method
• For Python3, the `` `__ next__ () ``` method

Try implementing iterator

Try to squeal three times.

duck.py

class DuckIter(object):
    def __init__(self):
        self._count = 3

    def next(self):
        if self._count > 0:
            self._count -= 1
            return "quack"
        raise StopIteration()


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

No more errors when run

% python duck.py
quack
quack
quack

The duck rang!

Duck typing

If it walks like a duck and quacks like a duck, it must be a duck https://ja.wikipedia.org/wiki/ダック・タイピング

The object itself determines what the object can do (Regardless of what inheritance they have)

In the case of the previous example

• Duck: It was considered iterable because it has a `__ iter__ ()` method.
• DuckIter: It was considered an iterator because it has a next () `` method.

This allowed us to turn the for loop:

for i in Duck():
    print(i)

This notation is roughly the same as below

iter = Duck().__iter__()
while True:
    try:
        i = iter.next()
        print(i)
    except StopIteration:
        break

In other words, the processing flow of the for loop is

1. Get iterator
2. Call the iterator's next () method
3. If it is not StopIteration, perform "Processing in the loop" and go to 2. again.

A little practice

Let's create an object with iterator in reverse order from list

>>> lst = [0, 1, 2, 3, 4]
>>> rev = RevList(lst)
>>> for r in rev:
...     print(r)
...
4
3
2
1
0

Tip:

• Now you can get "object with `` next () `` method" with ``` __iter__ () ``
• `next ()` returns from the end of the original list

Answer 1

• Follow the tips obediently
• Do not copy the original list, just refer to it

class RevListIter(object):
    def __init__(self, lst):
        self._orig = lst
        self._i = len(lst)

    def next(self):
        if self._i > 0:
            self._i -= 1
            return self._orig[self._i]
        raise StopIteration()


class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return RevListIter(self._orig)


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Answer 2

• Make a list in reverse order with slices of step = -1
• Returns an iterator for that list

class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return self._orig[::-1].__iter__()


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Difference between the two answers

• Answer 1 creates an element each time you use it, not when you create iterator.
• Answer 2 generates a list in reverse order when creating an iterator

List comprehension and generator representation

Another practice

Let's create an iterator that squares each element of a list of integers

>>> lst = [0, 1, 2, 3, 4]
>>>for i in something(lst):
...     print(i)
...
0
1
4
9
16

Two sample answers

>>> lst = [0, 1, 2, 3, 4]
>>> for i in [x*x for x in lst]:
...     print(i)
...
0
1
4
9
16
>>> for i in (x*x for x in lst):
...     print(i)
...
0
1
4
9
16

Both are solutions. Let's see the difference between the two.

List comprehension

notation

[f(x) for x in lst]

Sample code

list_comprehension.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = [f(x) for x in lst]
    print(type(x))
    for i in x:
        print(i)

Execution result

% python list_comprehension.py
0*0
1*1
2*2
3*3
4*4
<type 'list'>
0
1
4
9
16

• Returns list
• Calculate before the for loop and generate a list of results
• In a for loop, just retrieve the values in order

Generator representation

notation

(f(x) for x in lst)

Sample code

generator_expression.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = (f(x) for x in lst)
    print(type(x))
    for i in x:
        print(i)

Execution result

% python generator_expression.py
<type 'generator'>
0*0
0
1*1
1
2*2
4
3*3
9
4*4
16

• Returns a generator
• Not calculated before using in for loop
• Calculated each time a value is retrieved in a for loop

Summary

• Python is duck typing
• By implementing __iter__ ()` ``, next ()` ``, iterable is completed.
• In Python3 `` `__ next () __```
• The for loop retrieves the values in order from the iterator and turns the process.
• Notation to make iterable from list
• list comprehension: Calculate when creating and generate list of results
• generator expression: Do not calculate when creating. Calculated each time you use
• Related: map function
• In Python2, equivalent to list comprehension → returns list
• In Python3, equivalent to generator expression → returns iterator