Question

I have a type from a dictionary (example)

l =('1037_97',["a","b","c","d","e"])

I wish to save a file (las format) but Liblas can write only single point.

for l in Groups.iteritems():
    for p in xrange(len(l[1])):
        file_out.write(l[1][p])

I am trying to use if it’s possible a List Comprehensions in order to save code and speed the loop

Answer 1

If you want a shorter solution, consider using map() for inner cycle, or even for both. But it is unlikely to get a significant performance boost. However, for p in l[1]: still may be faster than that construction with xrange. The following example should do what you wanted in a single line:

map(lambda g: map(file_out.write, g), groups.itervalues())

Now let’s compare performance of different implementations. Here I tried to measure times on some test data:

import timeit

groups = dict(('1037_%d' % i, ["a","b","c","d","e"]) for i in xrange(100))

class FOut(object):
    def write(self, v):
        #print v
        pass

file_out = FOut()

def using_map():
    map(lambda g: map(file_out.write, g), groups.itervalues())

def initial_version():
    for l in groups.iteritems():
        for p in xrange(len(l[1])):
            file_out.write(l[1][p])

def seq_iteration():
    for l in groups.iteritems():
        for p in l[1]:
            file_out.write(p)

def seq_iteration_values():
    for l in groups.itervalues():
        for p in l:
            file_out.write(p)

def list_compr():
    [[file_out.write(v) for v in g] for g in groups.itervalues()]



tests = ('initial_version', 'using_map', 'seq_iteration', 'list_compr', 'seq_iteration_values')


for test in tests:
    print test, timeit.timeit('%s()'%test, 'from __main__ import %s'%test, number=10000)

And the result is:

initial_version 0.862531900406
using_map 0.703296899796
seq_iteration 0.541372060776
list_compr 0.632550954819
seq_iteration_values 0.493131160736

As you can see, your initial version is the slowest, fixing iteration helps a lot, map() version is short, but not as fast as the version with itervalues(). List comprehension that creates unneeded lists is not bad, but still slower than the plain cycle.