Using the map function to iterate over values in a list of dictionaries in Python

Question

I've been trying to process data stored in a list of dictionaries, and store it in another list of tuples. For example say i have the following data:

triangles= [{"name": "triangle1", "base":3, "height":4}, 
            {"name": "triangle2", "base":5, "height":12}, 
            {"name": "triangle3", "base":8, "height":15}
           ]

And I want to run all the data through the following function which i cannot change:

def hypotenuse(base, height):
    hyp_sq=base**2+height**2

    return hyp_sq**(1.0/2.0)

Ideally, after computing all the data, I want to sort the triangles based on their hypotenuse length and I want to return a list of tuples in the following format:

hypotenuse_results=[("triangle1", 5), ("triangle2", 13), ("triangle3", 17)]

I know I have to use the map() function in conjunction with sorted() but I have no idea how to pass only the values corresponding to "base" and "height" keys.

If someone could point me in the right direction, it would be greatly appreciated.

Thanks

Answer 1

Around 1993, Python got lambda, reduce(), filter() and map(), courtesy of a Lisp hacker who missed them and submitted working patches. These Lisp-flavored constructs are considered a little alien in Python specially after the introduction of list comprehensions in 2000. So no, you don't need map, you can use list comprehensions or generator expressions.

You can let your hypotenuse function take extra arguments and ignore them:

def hypotenuse(base, height, **kwargs):
    hyp_sq=base**2+height**2
    return hyp_sq**(1.0/2.0)

Then you can use a list comprehension:

hypotenuse_results = [(t['name'], hypotenuse(**t)) for t in triangles]
hypotenuse_results.sort(key=lambda pair: pair[1])

This should perform well enough even for large len(triangles). The generator expression version is:

unsorted_results = ((t['name'], hypotenuse(**t)) for t in triangles)
hypotenuse_results = sorted(unsorted_results, key=lambda pair: pair[1])

Profiling both solutions and posting here would be a great exercise.

thanks. is there a way to this without modifying the hypotenuse function? – canecse

Sure! Just call it with both arguments:

hypotenuse_results = [(t['name'], hypotenuse(t['base'], t['height'])) for t in triangles]
hypotenuse_results.sort(key=lambda pair: pair[1])

Note that the accepted solution is allocating an actual list and trowing it away so you may want to use a generator expression instead of a list comprehension if you are concerned about memory footprint (specially useful if len(triangles) is big but always a good habit):

hypotenuse_results = sorted(
    ((t['name'], hypotenuse(t['base'], t['height'])) for t in triangles), 
    key=lambda x: x[1]
)

Answer 2

You need do modify you hypotenuse function, for some like this:

def hypotenuse(triangle):
    hyp_sq=triangle["base"]**2 + triangle["height"]**2
    return (triangle["name"], hyp_sq**(1.0/2.0))

map will returns a generator of tuples, when, each tuple is (name, hyp), so, just sort using the second element of tuple:

sorted(map(hypotenuse, triangles), key=lambda x: x[1])

UPDATE:

Cause you can't change hypotenuse function, you can just use list comprehension:

sorted([(t['name'], hypotenuse(t['base'], t['height'])) for t in triangles], key=lambda x: x[1])

Answer 3

Since your hypotenuse function works fine here, you can construct a comprehension to create your list of tuples:

from operator import itemgetter

result = sorted(((x['name'], hypotenuse(x['base'], x['height'])) for x in triangles), key = itemgetter(1))

print(result)

Which gives:

[('triangle1', 5), ('triangle2', 13), ('triangle3', 17)]

or if you really wanted to use map(), you could try this:

result = sorted(map(lambda x: (x['name'], hypotenuse(x['base'], x['height'])), triangles), key = itemgetter(1))

Note: You can use lambda x: x[1] instead of operator.itemgetter(1). It's just a matter of preference here. If your interested, you can read this to see the performance between the two, and their respective pros and cons.

UPDATE:

@Paulo Scardine pointed out in the comments that if triangle gets bigger in the future, using a generator expression within sorted() is more efficient. This is because the list comprehension creates a list on the spot, but sorted() removes this list anyways in the process, so its a waste to pass in a list when its not needed. This isn't a problem for the second example, since map() already returns a generator. I updated the above code to account for these recommendations.