Use enumerate:

In [3]: user_details = [{'name':x, 'rank':i} for i,x in enumerate(ranked_users)] 

In [4]: user_details
Out[4]: 
[{'name': 'jon', 'rank': 0},
 {'name': 'bob', 'rank': 1},
 {'name': 'jane', 'rank': 2},
 {'name': 'alice', 'rank': 3},
 {'name': 'chris', 'rank': 4}]

PS. My first answer was

user_details = map(lambda (i,x): {'name':x, 'rank':i}, enumerate(ranked_users))

I'd strongly recommend using a list comprehension or generator expression over map and lambda whenever possible. List comprehensions are more readable, and tend to be faster to boot.

You could do that in a one-liner using generators:

next(i for i,v in enumerate(l) if is_odd(v))

The nice thing about generators is that they only compute up to the requested amount. So requesting the first two indices is (almost) just as easy:

y = (i for i,v in enumerate(l) if is_odd(v))
x1 = next(y)
x2 = next(y)

Though, expect a StopIteration exception after the last index (that is how generators work). This is also convenient in your "take-first" approach, to know that no such value was found --- the list.index() function would raise ValueError here.

Use the enumerate() function to add indices:

map(function, enumerate(a))

Your function will be passed a tuple, with (index, value). In Python 2, you can specify that Python unpack the tuple for you in the function signature:

map(lambda (i, el): i * el, enumerate(a))

Note the (i, el) tuple in the lambda argument specification. You can do the same in a def statement:

def mapfunction((i, el)):
    return i * el

map(mapfunction, enumerate(a))

To make way for other function signature features such as annotations, tuple unpacking in function arguments has been removed from Python 3.

Demo:

>>> a = [1, 3, 5, 6, 8]
>>> def mapfunction((i, el)):
...     return i * el
...
>>> map(lambda (i, el): i * el, enumerate(a))
[0, 3, 10, 18, 32]
>>> map(mapfunction, enumerate(a))
[0, 3, 10, 18, 32]

Python's closures are late binding. This means that the values of variables used in closures are looked up at the time the function is called.

To avoid the late binding effect you can use a lambda with a default arg:

index = 1
test = lambda t, index=index: t[index]+1  # binds index at definition time
index = 0
print(test([5, 0]))  # 1

I think this code is closer to what you are asking for:

def indexMatching(seq, condition):
    for i,x in enumerate(seq):
        if condition(x):
            return i
    return -1

class Z(object):
    def __init__(self, name):
        self.name = name

class X(object):
    def __init__(self, zs):
        self.mylist = list(zs)

    def indexByName(self, name):
        return indexMatching(self.mylist, lambda x: x.name==name)

x = X([Z('Fred'), Z('Barney'), Z('Wilma'), Z('Betty')])

print x.indexByName('Wilma')

Returns 2.

The key idea is to use enumerate to maintain an index value while iterating over the sequence. enumerate(seq) returns a series of (index,item) pairs. Then when you find a matching item, return the index.

You can use a list comprehension and enumerate() instead:

>>> fruits = [{'name': 'apple', 'qty': 233}, {'name': 'orange', 'qty': '441'}]
>>> [(idx, fruit) for idx, fruit in enumerate(fruits) if fruit['name'] == 'orange']
[(1, {'name': 'orange', 'qty': '441'})]

Like @ChrisRands posted in the comments, you could also use filter by creating a enumeration object for your fruits list:

>>> list(filter(lambda fruit: fruit[1]['name'] == 'orange', enumerate(fruits)))
[(1, {'name': 'orange', 'qty': '441'})]
>>> 

Here are some timings for the two methods:

>>> setup = \
      "fruits = [{'name': 'apple', 'qty': 233}, {'name': 'orange', 'qty': '441'}]"
>>> listcomp = \
     "[(idx, fruit) for idx, fruit in enumerate(fruits) if fruit['name'] == 'orange']"
>>> filter_lambda = \
     "list(filter(lambda fruit: fruit[1]['name'] == 'orange', enumerate(fruits)))"
>>> 
>>> timeit(setup=setup, stmt=listcomp)
1.0297133629997006
>>> timeit(setup=setup, stmt=filter_lambda)
1.6447856079998928
>>> 

You can pass the array as a parameter to the lambda, and access the elements inside the lambda using its indexes:

print map(lambda x: x[0]/(x[1]**2), [a])

Also, you're using the bitwise XOR operator (^), not the "power" operator (**)

But... I don't see the point of using a lambda here, you just want to do some calculation of those 2 elements. So you can just do:

print a[0]/a[1]**2

You can analyze this example. Source

# importing pandas and numpylibraries
import pandas as pd
import numpy as np
 
# creating and initializing a nested list
values_list = [[15, 2.5, 100], [20, 4.5, 50], [25, 5.2, 80],
               [45, 5.8, 48], [40, 6.3, 70], [41, 6.4, 90],
               [51, 2.3, 111]]
 
# creating a pandas dataframe
df = pd.DataFrame(values_list, columns=['Field_1', 'Field_2', 'Field_3'],
                  index=['a', 'b', 'c', 'd', 'e', 'f', 'g'])
 
 
# Apply function numpy.square() to square
# the values of 3 rows only i.e. with row
# index name 'a', 'e' and 'g' only
df = df.apply(lambda x: np.square(x) if x.name in [
              'a', 'e', 'g'] else x, axis=1)
df