arglist = [(2, 90), (1, 140), (3, -40), (4, 60)]
for args in arglist:
    do.something(*args)
    time.sleep(1)
    print "Did something (%d,%d)" % args

The * means "use the values in this tuple as the arguments". Hint: you can do the same with keyword arguments by using ** and a dict.

If

function is useful (....) Because many functions take list parameter

it is a good sign that lambda expression is not a right fit. You don't want to repeat yourself every time you want to apply this pattern.

Sadly we are far from Clojure conciseness:

user=> (map + [1 2] [3 4] [6 7])
(10 13)

but we can still express it in a fairly Pythonic and elegant way:

def apply(f):
    def _(*args):
        return f(args)
    return _ 

which can be used as:

from toolz.curried import reduce 

map(apply(reduce(op.add)), [1,2], [3,4], [6,7])

or even better

map(apply(sum), [1,2], [3,4], [6,7])

although in this case map, can be combined with zip:

map(sum, zip([1, 2], [3, 4], [6, 7])))

Similar to list comprehension, but a bit different.

This is the map function.

lst = ["Red", "Green", "Blue"]
new_lst = map(lambda x: (x.upper(), x, ""), lst)

It basically changes every element of a list one-by-one according to the function you enter as the first parameter. Which is in this case:

lambda x: (x.upper(), x, "")

If you don't have an idea what lambda is, it is almost like in the high school math:

f(x) = (x.upper(), x, "") # basically defines a function in one line.

If you are passing A as an argument to a function fn(A1, A2, A3), you can pass the elements of A individually as follows:

fn( *A )

The * operation on a list/tuple when passed to a function unpacks the elements in the list/tuple.