python newbie: for j in range

Question

I am new to learn python these days. While reading a book, I found a line of code that I can't understand. Please see line 46 under print_progression() method, print(' '.join(str(next(self)) for j in range(n))).

class Progression:
    '''Iterator producing a generic progression.
    Default iterator produces the whole number, 0, 1, 2, ...
    '''

def __init__(self, start = 0):
    '''
    Initialize current to the first value of the progression.
    '''
    self._current = start

def _advance(self):
    '''
    Update self.current to a new value.
    This should be overriden by a subclass to customize progression.
    By convension, if current is set to None, this designates the
    end of a finite progression.
    '''
    self._current += 1

def __next__(self):
    '''
    Return the next element, or else raise StopIteration error.
    '''
    # Our convention to end a progression
    if self._current is None:
        raise StopIteration()
    else:
        # record current value to return
        answer = self._current
        # advance to prepare for next time
        self._advance()
        # return the answer
        return answer

def __iter__(self):
    '''
    By convention, an iterator must return itself as an iterator.
    '''
    return self

def print_progression(self, n):
    '''
    Print next n values of the progression.
    '''
    print(' '.join(str(next(self)) for j in range(n)))


class ArithmeticProgression(Progression): # inherit from Progression
    pass

if __name__ == '__main__':
    print('Default progression:')
    Progression().print_progression(10)

'''Output is
Default progression:
0 1 2 3 4 5 6 7 8 9 10'''

I have no idea how next(self) and j works.

1. I think it should be str(Progression.next()). (solved)

2. I cannot find j anywhere. What is j for? Why not using while loop such as while Progression.next() <= range(n)?

For my final thought, it should be

print(' '.join(str(next(self)) while next(self) <= range(n)))

Save this newbie.

Thanks in advance!

Answer 1

I think @csevier added a reasonable discussion about your first question, but I'm not sure the second question is answered as clearly for you based on your comments so I'm going to try a different angle.

Let's say you did:

for x in range(10):
    print(x)

That's reasonably understandable - you created a list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] and you printed each of the values in that list in-turn. Now let's say that we wanted to just print "hello" 10 times; well we could modify our existing code very simply:

for x in range(10):
    print(x)
    print('hello')

Umm, but now the x is messing up our output. There isn't a:

do this 10 times:
    print('hello')

syntax. We could use a while loop but that means defining an extra counter:

loop_count = 0
while loop_count < 10:
    print('hello')
    loop_count += 1 

That's baggage. So, the better way would be just to use for x in range(10): and just not bother doing print(x); the value is there to make our loop work, not because it's actually useful in any other way. This is the same for j (though I've used x in my examples because I think you're more likely to encounter it in tutorials, but you could use almost any name you want). Also, while loops are generally used for loops that can run indefinitely, not for iterating over an object with fixed size: see here.

Answer 2

Welcome to the python community! This is a great question. In python, as in other languages, there are many ways to do things. But when you follow a convention that the python community does, that is often referred to as a "pythonic" solution. The method print_progression is a common pythonic solution to iteration of a user defined data structure. In the case above, lets explain first how the code works and then why we would do it that way.

Your print_progression method takes advantage of the fact that your Progression class implements the iteration protocol by implementing the next and iter dunder/magic methods. Because those are implemented you can iterate your class instance both internally as next(self) has done, and externally next(Progression()) which is the exactly what you were getting at with you number 1. Because this protocol is implemented already, this class can by used in any builtin iterator and generator context for any client! Thats a polymorphic solution. Its just used internally as well because you don't need to do it in 2 different ways.

Now for the unused J variable. They are just using that so they can use the for loop. Just using range(n) would just return an itterable but not iterate over it. I dont quite agree with the authors use of the variable named J, its often more common to denote an unused variable that is just used because it needs to be as a single underscore. I like this a little better:

 print(' '.join(str(next(self)) for _ in range(n)))