Is a new copy of array formed when passed as a slice to enumerate() in python?

Question

Is a new copy of array formed when passed as a slice to enumerate()? This is my guess after running the following experiments. It seems to me that's the case but I'm not sure how to prove my thinking with code?

Below is a code snippet and 2 results. The results corresponding to option A and option B are as follows as well.

def selection_sort(arr):
    # for idx, item in enumerate(arr[:-1]):        # option A
    for idx, item in enumerate(arr):        # option B
        curr_min = item
        swap_ptr = idx
        
        print('========================================')
        print('curr_min: {}'.format(curr_min))
        print('arr before: {}'.format(arr))
        
        for j in range(idx+1, len(arr)):
            print('for item {}'.format(arr[j]))
            if arr[j] < curr_min:
                print('{} < {}'.format(arr[j], curr_min))
                curr_min = arr[j]
                swap_ptr = j
                print('swap_ptr now at {} pointing to {}'.format(swap_ptr, curr_min))
        
        (arr[idx], arr[swap_ptr]) = (arr[swap_ptr], arr[idx])
        print('arr after: {}'.format(arr))
        
    return arr
    
print(selection_sort([5,9,1,3,0,20,77,46]))

Result from running on option A (i.e. having option B commented out):

========================================
curr_min: 5
arr before: [5, 9, 1, 3, 0, 20, 77, 46]
for item 9
for item 1
1 < 5
swap_ptr now at 2 pointing to 1
for item 3
for item 0
0 < 1
swap_ptr now at 4 pointing to 0
for item 20
for item 77
for item 46
arr after: [0, 9, 1, 3, 5, 20, 77, 46]
========================================
curr_min: 9
arr before: [0, 9, 1, 3, 5, 20, 77, 46]
for item 1
1 < 9
swap_ptr now at 2 pointing to 1
for item 3
for item 5
for item 20
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 1
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 3
for item 5
for item 20
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 3
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 5
for item 20
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 0
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 20
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 20
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 77
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 46
46 < 77
swap_ptr now at 7 pointing to 46
arr after: [0, 1, 9, 3, 5, 20, 46, 77]
[0, 1, 9, 3, 5, 20, 46, 77]

Result from running on option B (i.e. having option A commented out):

========================================
curr_min: 5
arr before: [5, 9, 1, 3, 0, 20, 77, 46]
for item 9
for item 1
1 < 5
swap_ptr now at 2 pointing to 1
for item 3
for item 0
0 < 1
swap_ptr now at 4 pointing to 0
for item 20
for item 77
for item 46
arr after: [0, 9, 1, 3, 5, 20, 77, 46]
========================================
curr_min: 9
arr before: [0, 9, 1, 3, 5, 20, 77, 46]
for item 1
1 < 9
swap_ptr now at 2 pointing to 1
for item 3
for item 5
for item 20
for item 77
for item 46
arr after: [0, 1, 9, 3, 5, 20, 77, 46]
========================================
curr_min: 9
arr before: [0, 1, 9, 3, 5, 20, 77, 46]
for item 3
3 < 9
swap_ptr now at 3 pointing to 3
for item 5
for item 20
for item 77
for item 46
arr after: [0, 1, 3, 9, 5, 20, 77, 46]
========================================
curr_min: 9
arr before: [0, 1, 3, 9, 5, 20, 77, 46]
for item 5
5 < 9
swap_ptr now at 4 pointing to 5
for item 20
for item 77
for item 46
arr after: [0, 1, 3, 5, 9, 20, 77, 46]
========================================
curr_min: 9
arr before: [0, 1, 3, 5, 9, 20, 77, 46]
for item 20
for item 77
for item 46
arr after: [0, 1, 3, 5, 9, 20, 77, 46]
========================================
curr_min: 20
arr before: [0, 1, 3, 5, 9, 20, 77, 46]
for item 77
for item 46
arr after: [0, 1, 3, 5, 9, 20, 77, 46]
========================================
curr_min: 77
arr before: [0, 1, 3, 5, 9, 20, 77, 46]
for item 46
46 < 77
swap_ptr now at 7 pointing to 46
arr after: [0, 1, 3, 5, 9, 20, 46, 77]
========================================
curr_min: 77
arr before: [0, 1, 3, 5, 9, 20, 46, 77]
arr after: [0, 1, 3, 5, 9, 20, 46, 77]
[0, 1, 3, 5, 9, 20, 46, 77]

Please show me how to prove my thought on this weird phenomenon. It seems when the array is passed to enumerate() in a sliced manner, it will just iterate the 'old' array from the function argument list. But when passed without any slicing, enumerate() iterates on the new array that is modified within loop. I'm not sure if I can prove this using code and documentation instead of running this experiment? Why is this design so strange? TIA.

Does this answer your question? [What does enumerate() mean?](https://stackoverflow.com/questions/22171558/what-does-enumerate-mean) — Peter Badida, Apr 15 '22 at 03:31
@PeterBadida thanks for bringing out the definition of enumeate(), but here it is more about the effects brought to enumerate by different arguments passed to it. — Student, Apr 15 '22 at 03:38
Yes, it's mentioned [here](https://stackoverflow.com/a/22171593/5994041) in the pseudo-implementation itself i.e. taking a reference, strapping a counter to it and becoming a generator, thus not creating a copy. — Peter Badida, Apr 15 '22 at 03:39

scr · Accepted Answer · 2022-04-15T03:36:20.760

I can confirm it's the case. Let's see my work.

I start by creating a basic list:

foo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Then while we iterate of the enumerate I'll edit one of the values in place:

>>> once = True
>>> for idx, val in enumerate(foo):
...  if once:
...   once = False
...   foo[2] = 666
...  print(idx, val)
... 
0 0
1 1
2 666
3 3
4 4
5 5
6 6
7 7
8 8
9 9

And we notice that the enumerate shows the edited value when reaching it's index.

Now we do the same when passing a slice instead of the original:

>>> foo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> once = True
>>> for idx, val in enumerate(foo[:]):
...  if once:
...   once = False
...   foo[2] = 42
...  print(idx, val)
... 
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
>>> foo
[0, 1, 42, 3, 4, 5, 6, 7, 8, 9]

And we see that although foo has been edited, the enumerate isn't aware of the change, since it must be using a unmodified copy of the original.

I investigated as to why that is. When using the bracket notation we are actually calling the slice class under the hood.

This says that it returns a Slice object. Which is obviously different from your original list.

You can even see the object creation in the source code if you're interested.

I like this simple way of proving, thanks. I further check with `id(arr[:])` and `id(arr)`, they indeed refer to the different addresses. So I can say for arr[:] passed to enumerate(), a new instance of the arr is formed ONCE ONLY and to be consumed by enumerate() for the rest of its lifetime? — Student, Apr 15 '22 at 03:44
I'm not sure if arr[:] dies after enumerate() is over. So you'd have to test that. But other than that, yes. — scr, Apr 15 '22 at 04:05

Is a new copy of array formed when passed as a slice to enumerate() in python?

1 Answers1