This:

puts all the words in a list, like I want.

How to do this with [lc] instead of for-loops?

I tried funnies like [[w for w in L] for L in data],
that is correct syntax, but you'd never guess.

I know, silly!  No need for [lc]!  So there's my
question.  I am sure a one-liner using [lc] will be very
enlightening.  Like studying LISP.

In that case you might be more comfortable with:

data = [['foo','bar','baz'],['my','your'],['holy','grail']]
result = []
for l in data:
     result += l

--

hilsen/regards Max M, Denmark

 >>> data = [['foo','bar','baz'],['my','your'],['holy','grail']]
 >>> [item for item_list in data for item in item_list]
['foo', 'bar', 'baz', 'my', 'your', 'holy', 'grail']

See how the for expressions in the list comprehension exactly match your
nested for loops? That's all there is to it.

    result = []; map(result.extend, data)

That example could have been expressed more clearly as:

     result = data

;-)

--

hilsen/regards Max M, Denmark

def unroll(ary):
  unrolled = []
  for item in ary:
    # add test for your favorite sequence type
    if ( type(item) == types.ListType or   \
         type(item) == types.TupleType     \
       ):
      unrolled.extend(unroll(item))
    else:
      unrolled.append(item)
  return unrolled

On Monday 13 December 2004 12:51 pm, Will Stuyvesant wrote:

['foo', 'bar', 'baz', 'my', 'your', 'holy', 'grail']

The second parameter passed to sum is just to overrride default
initial value "zero".

 > python -m timeit -s "data = [range(10) for _ in range(100)]"
"sum(data, [])"
1000 loops, best of 3: 530 usec per loop

 > python -m timeit -s "data = [range(10) for _ in range(100)]" "[w for
d in data for w in d]"
10000 loops, best of 3: 151 usec per loop

 > python -m timeit -s "data = [range(10) for _ in range(1000)]"
"sum(data, [])"
10 loops, best of 3: 54.2 msec per loop

 > python -m timeit -s "data = [range(10) for _ in range(1000)]" "[w for
d in data for w in d]"
100 loops, best of 3: 1.75 msec per loop

The sum function used in this way (or a loop with a +=) is O(N**2) while
the LC is O(N).

timeit -s "data = [range(10) for _ in range(1000)]" "L = sum(data, [])"
10 loops, best of 3: 4.02e+004 usec per loop

timeit -s "data = [range(10) for _ in range(1000)]" "L = [w for d in data for w in d]"
1000 loops, best of 3: 1.12e+003 usec per loop

timeit -s "data = [range(10) for _ in range(1000)]" "L = []; map(L.extend, data)"
1000 loops, best of 3: 283 usec per loop

timeit -s "data = [range(10) for _ in range(1000)]; from Tkinter import _flatten" "L =
_flatten(data)"
1000 loops, best of 3: 308 usec per loop

(the last one supports arbitrary nestings, the others don't)

.>>> data = [['foo','bar','baz'],['my','your'],['holy','grail']]
.>>> from itertools import chain
.>>> result = "".join(chain(*data))
'foobarbazmyyourholygrail'

Some timing with integers:

C:\>python -m timeit -s "data = [range(x) for x in range(1000)]" "L= []; map(L.e
xtend, data); max(L)"
10 loops, best of 3: 78.5 msec per loop

C:\>python -m timeit -s "data = [range(x) for x in range(1000)]; from Tkinter im
port _flatten" "max(_flatten(data))"
10 loops, best of 3: 58.4 msec per loop

C:\>python -m timeit -s "data = [range(x) for x in range(1000)]; from itertools
import chain" "max(chain(*data))"
10 loops, best of 3: 43 msec per loop

And with strings:

C:\>python -m timeit -s "data = [map(str, range(x)) for x in range(1000)]" "L= [
]; map(L.extend, data); ''.join(L)"
10 loops, best of 3: 106 msec per loop

C:\>python -m timeit -s "data = [map(str, range(x)) for x in range(1000)]; from
Tkinter import _flatten" "''.join(_flatten(data))"
10 loops, best of 3: 85.4 msec per loop

C:\>python -m timeit -s "data = [map(str, range(x)) for x in range(1000)]; from
itertools import chain" "''.join(chain(*data))"
10 loops, best of 3: 1.2 sec per loop ****** OUCH!!

C:\>python -m timeit -s "data = [map(str, range(x)) for x in range(1000)]; from
itertools import chain" "''.join(list(chain(*data)))"
10 loops, best of 3: 107 msec per loop

Yikes - looks like chain() really sucks for str.join. However, the addition of
the 'list' call makes a big difference. Maybe PySequence_Fast should be called
PySequence_SlowAsADeadDingo() in this case ;)

(FYI, I filed bug report #1085744 on SF about this)

Cheers,
Nick.

    http://www.python.org/doc/2.3.4/ref/lists.html

    "... the elements of the new list are those that would be produced
    by considering each of the 'for' or 'if' clauses a block, nesting
    from left to right, and evaluating the expression to produce a list
    element each time the innermost block is reached."

or, conceptually, the compiler strips off the expression, and then
inserts newlines, colons and indentation, and wraps the expression
in an append statement.

so

    [e for l in data for e in l]

behaves like:

    result = []
    for l in data:
        for e in l:
            result.append(e)

except that it's an expression, and the result variable is hidden. (and
the compiler and the runtime is of course free to implement this in a
more efficient way)

Nick Coghlan schrieb:

I wish everyone would write examples that way! On the other hand - three
levels of quoting are really rare, maybe it would be easier to change that
in the mail readers...

... or in Py3k ?

Prepending every line with . is not an ideal solution though... I think
it gets tiresome very quickly.

The trick can also be useful for web tools that strip leading whitespace.

Cheers,
Nick.

Anyway, I guess the results I got emphasizes the fact that it's important to
measure performance of the actual methods you're using on representative input
data, rather than relying on overly simple demonstrators.

And, of course, don't be *too* concerned about optimisations until you know you
actually have a performance problem. . .

Cheers,
Nick.

Would it work, I wonder, with a leading space on the prompt? That might
be a valid change to the standard prompt. Let's see

  >>> This line isn't really quoted three times.

py='python -i -c '\''import interactive'\'

Which, among other things, sets the prompt to "Python> "

433 $ py
Python> print "This has no leader that screws up email programs."
This has no leader that screws up email programs.
Python>