And if you want to know the lowest level nitty gritty of how they work, there's documentation to point you to the right place, and then the code is relatively readable, at least if you understand C well and know the basics of how CPython works.
But what if you're somewhere between the two extremes? People occasionally ask this on StackOverflow, and the questions invariably get closed because "explain to me how this works" is not a good question for the SO format, but it's a perfectly good question for, say, a blog.
List comprehensions
Under the covers, Python compiles the guts of your list comprehension into a function, and then compiles the comprehension itself into a call to that function. I'll oversimplify it a bit, but the basic idea is this:
[random.choice(string.ascii_lowercase + " ") for i in range(n)]… turns into:
def _comprehension(source):
result = []
for i in source:
result.append(random.choice(string.ascii_lowercase + " "))
return result
_comprehension(iter(range(n)))
Of course the function isn't defined in the middle of the expression, it's sort of but not quite as if it were defined in the previous statement (it is definitely defined in the local scope, of course, so it can access your variables as closure cells). And it doesn't have a visible name like _comprehension. Also, because comprehensions are limited in form, it can optimize things a bit. But that's the basic idea.
Set and dict comprehensions
A set comprehension looks exactly like a list comprehension, except it starts with result = set() and does add instead of append.A dict comprehension is basically the same, but the function it calls on each colon-separated key-value tuple doesn't really exist, so just think of it as result[key] = value.
Generator expressions
A generator expression looks a lot like a list comprehension, except that it's a generator function instead of a regular function. In other words: def _comprehension(source):
for i in source:
yield random.choice(string.ascii_lowercase + " ")
_comprehension(iter(range(n)))
In fact, generator expressions (even though they came later than list comprehensions in Python history) are really the core concept; you can almost build everything else on top of them: a = [i*2 for i in range(10)]
b = list(i*2 for i in range(10))
assert a == b
a = {i*2 for i in range(10)}
b = set(i*2 for i in range(10))
assert a == b
a = {i: i*2 for i in range(10)}
b = dict((i, i*2) for i in range(10))
assert a == b
But the other comprehensions aren't quite pure syntactic sugar.First, they're up to 40% faster (in the worst case, where you're basically doing nothing).
Second, raising StopIteration just ends a generator expression early, but in a list/set/dict comprehension it ends the whole containing expression; you don't get a list up to the point where you raised StopIteration, you get nothing. (This difference is apparently actually a bug, but not one worth fixing; see my post Can you optimize list(genexp) for further details on what it would take to fix it.) So, in the rare cases where you need to handle StopIteration properly (which I personally have only come across once, and it was write writing code to experiment with an idea for changing the language, not real code…), you have to use list(…), not […].
Finally, if you're writing code that's backward compatible with Python 2.x, generator expressions worked the same way they do in 3.x, but the other comprehensions didn't; they were inlined into the current function, meaning they leaked the iteration variable into the outer scope (overwriting any existing variable with the same name). And if you're still using Python 2.6 or earlier, you don't have set or dict comprehensions, so you have no choice but to use set(…) or dict(…).
Disassembling comprehensions
If you want to dive in further yourself, you might think about disassembling the comprehension. But if you try that, you're just going to be disassembling the code that builds and calls a function, not the actual internal comprehension function's code.Of course you run into that problem with any local function, and you can get around that easily by having the outer function return the local function (or its disassembly, or whatever), but that doesn't work here, because you don't have a name for the local to return (and it's not in locals() or anywhere else introspectable).
Well, you can always put a comprehension in a module and disassemble everything in the module.
Or you can use this quick&dirty hack:
>>> frame = [sys._getframe() for _ in range(1)][0]
>>> dis.dis(frame.f_code)
1 0 BUILD_LIST 0
3 LOAD_FAST 0 (.0)
>> 6 FOR_ITER 18 (to 27)
9 STORE_FAST 1 (_)
12 LOAD_GLOBAL 0 (sys)
15 LOAD_ATTR 1 (_getframe)
18 CALL_FUNCTION 0 (0 positional, 0 keyword pair)
21 LIST_APPEND 2
24 JUMP_ABSOLUTE 6
>> 27 RETURN_VALUE
If you know Python bytecode, you can see some of the optimizations I mentioned—there's no GET_ITER before the FOR_ITER, because the source is always passed in as an iterator; it uses special BUILD_LIST and LIST_APPEND bytecodes instead of calling the list constructor and looking up and calling its append method and then having to push the list again; it jumps straight from the loop to the RETURN_VALUE rather than doing the extra POP_BLOCK work and pushing some value, because the list set up in BUILD_LIST is already guaranteed to be on top of the stack.You can probably guess how set and dict comprehensions work: they do BUILD_SET and BUILD_MAP, and SET_ADD and MAP_ADD instead of the list equivalents. And MAP_ADD requires two things on the stack instead of one.
Generator expressions are similar. No BUILD_LIST, a YIELD_VALUE followed by POP_TOP instead of LIST_APPEND, and they have to LOAD_CONST None at the end because they have nothing to return, but that's the only differences.
View comments