I've just been learning lambda (About time) and I've figured some things out, I get the general idea.
I have a map() with a lambda here that can surely be made shorter, but I don't know how:
map(lambda x: [ x.split()[0], x.split()[2], x.split()[4] ] , y)
I hoped it would be possible to get the 0, 2 and 4 elements of the split 'x' at once, but currently I have to split it 3 times to get them...
lambda x: operator.itemgetter(0, 2, 4)(x.split())
list does not support arbitrary sequences of indexes.list does not support arbitrary sequences of indexes.map(lambda x: x.split()[0:5:2] , y)
Meaning - take x.split() and take the sublist [0:5] with each second item in it.
[0:4:2] will only give the first two. Try [0:5:2]Just for variety's sake, featuring no itemgetter() call:
map(lambda x: [x[i] for i in (0,2,4)], (s.split() for s in y))
The (0,2,4) could be replaced with range(0,5,2), of course.
For such a small number of items you could just be explicit with: [x[0], x[2], x[4]]
How it works: The lambda function simply returns a list of the desired elements of the list it is passed. The (s.split() for s in y) is a generator that produces split() versions of the items in list y. Driving all this is the call to map() which applies the lambda function to each one of the split() items from y. In Python 2.x it creates a list of the results from each of these calls.
To answer your follow-up question in the comments about using g = lambda x: [x[i] for i in (0,2,4)]
along with (g(s.split()) for s in y) to get rid of map(). That's basically the right idea, but the second expression results in just a generator object. That would need to be wrapped in something like: [g(s.split()) for s in y] to get the result.
If you didn't want to have a separate lambda named g you could use:
[(lambda x: [x[i] for i in (0,2,4)])(s.split()) for s in y]
lambda function, so something will have to call it and map is the obvious choice. If you don't want to use lambda, as @Glenn Maynard said, list comprehensions are the way to go.lambda function: such as <function <lambda> at 0x00AD44F0>. Something else needs to call the function multiple times and collect the results. That's why map() is used.
map; it's almost completely obsoleted by list comprehensions. If you're reading a tutorial that's telling you to use it, it's probably very old and may be teaching you bad habits. The clean way of writing this (starting from @Yuval's answer) is[x.split()[0:5:2] for x in y].