复制枚举函数的功能而不使用它

Question

I have been asked to replicate the enumerate function. That is, when a list of int or string in given, the output should be a list of tuples for each element with its index.

list entered = [1, 2, 3, 4]

expected outcome = [(0, 1), (1, 2), (2, 3), (3, 4)]

It's doable for the most part. The problem occurs when an element is repeated.

This is my code:

def my_enumerate(items):
    """ return tuples with index and number"""
    tuple_list = []
    for i in items:
        tuple_list.append((items.index(i), i))
    return tuple_list

When a list containing repeated elements in entered,

ans = my_enumerate(['x', 'x', 'x'])
print(ans)

expected outcome : [ (0, 'x'), (1, 'x'), (2, 'x') ]

actual outcome : [ (0, 'x'), (0, 'x'), (0, 'x') ]

What changes should I do to my code?

Thank you

Answer 1

Your problem is that elements can repeat but indices are unique. Also, looking for an index according to the element is generally O(n) while the whole point of lists is that acquiring an element according to its index, is O(1) .

So, instead of iterating elements, iterate indices and get the elements:

def my_enumerate(items):
    tuple_list = []
    for i in range(len(items)):
        tuple_list.append((i, items[i]))
    return tuple_list

Or more neatly:

def my_enumerate(items):
    return [(i, items[i]) for i in range(len(items))]

And both gives:

>>> my_enumerate([1, 2, 3, 4])
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> my_enumerate(['x', 'x', 'x'])
[(0, 'x'), (1, 'x'), (2, 'x')]

---

To make it more inline with the generator-y spirit of enumerate we could respectively change the function to:

def my_enumerate(items):
    for i in range(len(items)):
        yield (i, items[i])

And:

def my_enumerate(items):
    yield from ((i, items[i]) for i in range(len(items)))

Now you can iterate over it just as regular enumerate , or if you want it as a list simply do: list(my_enumerate(items))

Answer 2

You could use zip if you want:

def my_enumerate(items):
    return list(zip(range(len(items)),items))

though perhaps if you are reproducing (some of) the functionality of enumerate in terms of more primitive elements, using zip might be against the spirit of the problem (in which case Tomerikoo's solution is preferable). Nevertheless, it doesn't hurt to know multiple ways of solving a problem.

Answer 3

Your problem is index is always finding the index of the first occurrence of 'x' . An idea would be to use an int index instead of the index method.

for i in range(len(items)):
    tuple_list.append((i, items[i]))