How does Python handle multiple conditions in a list comprehension?

Question

I was trying to create a list comprehension from a function that I had and I came across an unexpected behavior. Just for a better understanding, my function gets an integer and checks which of its digits divides the integer exactly:

# Full function
divs = list()
for i in str(number):
    digit = int(i)
    if digit > 0 and number % digit == 0:
        divs.append(digit)
return len(divs)

# List comprehension
return len([x for x in str(number) if x > 0 and number % int(x) == 0])

The problem is that, if I give a 1012 as an input, the full function returns 3, which is the expected result. The list comprehension returns a ZeroDivisionError: integer division or modulo by zero instead. I understand that it is because of this condition:

if x > 0 and number % int(x) == 0

In the full function, the multiple condition is handled from the left to the right, so it is fine. In the list comprehension, I do not really know, but I was guessing that it was not handled in the same way.

Until I tried with a simpler function:

# Full function
positives = list()
for i in numbers:
    if i > 0 and 20 % i ==0:
        positives.append(i)
return positives

# List comprehension
return [i for i in numbers if i > 0 and 20 % i == 0]

Both of them worked. So I am thinking that maybe it has something to do with the number % int(x)? This is just curiosity on how this really works? Any ideas?

Answer 1

The list comprehension is different, because you compare x > 0 without converting x to int. In Py2, mismatched types will compare in an arbitrary and stupid but consistent way, which in this case sees all strs (the type of x) as greater than all int (the type of 0) meaning that the x > 0 test is always True and the second test always executes (see Footnote below for details of this nonsense). Change the list comprehension to:

[x for x in str(number) if int(x) > 0 and number % int(x) == 0]

and it will work.

Note that you could simplify a bit further (and limit redundant work and memory consumption) by importing a Py3 version of map at the top of your code (from future_builtins import map), and using a generator expression with sum, instead of a list comprehension with len:

return sum(1 for i in map(int, str(number)) if i > 0 and number % i == 0)

That only calls int once per digit, and constructs no intermediate list.

---

Footnote: 0 is a numeric type, and all numeric types are "smaller" than everything except None, so a str is always greater than 0. In non-numeric cases, it would be comparing the string type names, so dict < frozenset < list < set < str < tuple, except oops, frozenset and set compare "naturally" to each other, so you can have non-transitive relationships; frozenset() < [] is true, [] < set() is true, but frozenset() < set() is false, because the type specific comparator gets invoked in the final version. Like I said, arbitrary and confusing; it was removed from Python 3 for a reason.