list comprehensions

[Paul McGuire]

"Elaine Jackson" <elainejackson7355 at home.com> wrote in message
news:yjZcc.42823$Pk3.9547 at pd7tw1no...
>
> List comprehensions don't work the way you intuitively expect them to
work. I
> realize many people have no intuitions about how list comprehensions
'should'
> work, so if you recognize yourself in this description, feel free to go
back to
> whatever you were doing before. If you're still here, though, I invite you
to
> consider the following definition:
>
> partitions = lambda n: [[n]]+[[k]+x for x in partitions(n-k) for k in
> range(1,n)]
>
> As defined above, the function raises an exception when you call it ('k'
> referenced before assignment). For the sake of clarity, here is workable
code
> expressing the same intention:
>
> def partitions(n):
>     reVal=[[n]]
>     for k in range(1,n):
>         for x in partitions(n-k):
>             reVal.append([k]+x)
>     return reVal
>
> So I guess what I want to ask is: Can somebody explain the semantics of
list
> comprehensions to me? Or even better: Can somebody tell me where to look
in the
> documentation to find out about list comprehensions? All donations
gratefully
> received.
>
> Peace
>
>
Elaine -

I suspect you wrote your listcomp by thinking this is an inversion of the
nested for loops.  That is, if you think of some arbitrary nesting of loops
as:

    for i in firstRange:
        for j in secondRange:
            for k in thirdRange:
                ...<as many more fors as you like>...
                    <build up list using i,j,k,...>

then you looked at the list comp as working its way inside out, since it
starts with the <build up list> part.

But as the other posters have already stated, even though the listcomp
starts with the most deeply nested body, the remaining 'for... for ...
for... ' clauses match the nested loops, as if you had just removed the
colons and copied them all onto one line.  So the listcomp ends up looking
like:

     [<build up list using i,j,k,...> for i in firstRange for j in
secondRange for k in thirdRange...]

If you want some kind of model for how to conceptualize this, then  I'd say
that a listcomp starts with its most important part being the actual list
element assembly/definition, followed by the iteration specifiers in
successive outer-to-inner order, that will get the loop variables to the
necessary values to satisfy the list assembly code.

You also asked for doc references.  The Python Tutorial includes an obscure
example (you have do a bit of in-your-head multiplication to get it), but
try these other articles describing listcomps when they were a new feature:
http://www-106.ibm.com/developerworks/linux/library/l-py20.html
http://python.org/2.0/new-python.html#SECTION000600000000000000000
Perhaps the tutorial could lift some of the examples from these other pages,
as I'm sure people don't necessarily go back to the "What's New" pages for
version x-2, x-3, etc.

HTH,
-- Paul