Python - What do these two lines do?

Question

Being new to Python, I'm having a heck of a time figuring out what these two lines do:

for i in [j for j in xrange(0, N) if [k for k in xrange(j) if now[k] == now[j]] == []]:
   for j in [k for k in xrange(1, K + 1) if [l for l in xrange(i) if now[l] == k] == []]:

Is there a way to rewrite this so noobs like myself could understand it? Thanks.

Might help to have a little context. What are `N` and `now` ? — Jonathon Reinhart, Mar 07 '12 at 04:34
That capital `K` in the second line is almost certainly a mistake. Or is captial `K` defined elsewhere in the code? — Taymon, Mar 07 '12 at 04:41
@Taymon: I'm pretty positive that it's the counterpart to the capital `N`, which is also undefined. — Niklas B., Mar 07 '12 at 04:43
@NiklasB. Yeah, I think I see that...wow. This code uses both `K` and `k` to mean different things. That is just seriously...wtf. — Taymon, Mar 07 '12 at 04:53

score 4 · Answer 1 · answered Mar 07 '12 at 04:52

Ugh. Reading that was physically painful. This is an excellent example of how not to use list comprehensions.

Here's a strict rewriting that doesn't use list comprehensions:

for i in xrange(0, N):
    implicit_list_1 = []
    for k in xrange(i):
        if now[k] == now[i]:
            implicit_list_1.append(i)
    if implicit_list_1 == []:
        for j in xrange(1, K + 1):
            implicit_list_2 = []
            for l in xrange(i):
                if now[l] == j:
                    implicit_list_2.append(l)
            if implicit_list_2 == []:

And here's a more idiomatic rewriting:

for i in xrange(N):
    if now[i] not in now[:i]:
        for j in xrange(1, K + 1):
            if j not in now[:i]:

This is assuming that K is a separate variable, and not a mistyped k.

Also, those one-letter variable names are poor style. Better to use variable names that actually reflect the use of the variable.

Niklas B. · Accepted Answer · 2012-03-07T13:25:50.310

3

I'm almost positive that this code is equivalent to:

for i in range(0, N):
  prefix = set(now[:i])
  if now[i] in prefix: continue

  for j in range(1, K + 1):
    if j in prefix: continue

    # do something

or (which would be a bit less efficient, but nicely reflects the idea behind the code):

for i, j in itertools.product(range(0, N), range(1, K + 1)):
  prefix = now[:i]
  if now[i] not in prefix and j not in prefix:
    # do something with i and j

BUT it's written in a convulted, inefficient way (especially the [...] == [] is nasty and pointless). Maybe by someone who feels pretty clever using complex structures where simple ones would be much better suited.

edited Mar 07 '12 at 13:25

answered Mar 07 '12 at 04:48

Niklas B.

92,950
18
194
224

I think you are spot on. Probably worth using `prefix=set(now[:i])` since the `in` test might be performed quite often – John La Rooy Mar 07 '12 at 05:10
Thank you. That makes sense. Whoever wrote this code (the text is in Japanese) also used a complex structure here(?): p = [i for i in xrange(0, len(now)) if now[i] != prev[i]][0] why? isn't there an easier way? I know that Python is a powerful language but seeing things like this makes me want to go back to BASIC – user1253798 Mar 07 '12 at 05:17
@user: that's not as bad as the other code. It just finds the first index where the lists `now` and `prev` differ. Could be written more efficient as `next(i for i,(x,y) in zip(now, prev) if x != y)`. – Niklas B. Mar 07 '12 at 05:30

score 0 · Answer 3 · answered Mar 07 '12 at 04:40

I suspect what's confusing you are the nested list comprehensions.

To begin with, you could pull them out into variables

firstlist = [j for j in xrange(0, N) if [k for k in xrange(j) if now[k] == now[j]] == []]
for i in firstlist:
   secondlist = [k for k in xrange(1, K + 1) if [l for l in xrange(i) if now[l] == k] == []]
   for j in secondlist:

You could further make it more readable by changing the nested list comprehensions to construct the lists entirely with ordinary for loops.

You should definitely check out that documentation link to try to grasp list comprehensions. They're powerful constructs, and in my opinion more readable for those who understand them. But nested list comprehensions can be rather difficult to sort out.

The frightening thing is, you could make it even more obfuscated and turn those two lines, with two loops, as well as possibly what the inner loop actually does, into an even-more-nested list comprehension. — rob05c, Mar 07 '12 at 04:42

score 0 · Answer 4 · edited May 23 '17 at 12:21

You are probably confused with list comprehension. Its difficult even for me to write list comprehension. But its not difficult to interpret whats already written list comprehension script means. Since you said you want noob-friendly code, the below code might be something like new-user friendly. (The execution of the code might be slightly different, the code is presented for understanding purpose only)

#first list comprehension expanded ...
first_list = []
for j in xrange(0, N):
    inner_first_list = []
    for k in xrange(j):
        if now[k] == now[j]:
            inner_first_list.append(k)
    if inner_first_list == []:
        first_list.append(j)

#second list comprehension expanded ...
second_list = []
for k in xrange(1, K + 1):
    inner_second_list = []
    for l in xrange(i):
        if now[l] == k:
            inner_second_list.append(l)
    if inner_second_list == []:
        second_list.append(k)

#the actual loop ...
for i in first_list:
    for j in second_list:
        #your loop statement

You will get better understanding of list comprehension over here: Why are Python lambdas useful?

Python - What do these two lines do?

4 Answers4