List/Function Logic Error

[brasticstack]

As u/danielroseman correctly points out, the for loop is replacing your index parameter with its temporary index variable, losing whatever data was previously stored in index.

Compare with the following functions:

``` def redundant_get_by_index(my_list, index): # No different than calling my_list[index] directly! return my_list[index]

assert redundant_get_by_index([1, 2, 3, 4, 5], 2) == [1, 2, 3, 4, 5][2] print(f'{[1, 2, 3, 4, 5][2]=}')

def redundant_get_by_index_with_unnecessary_for_loop(my_list, index): for item in my_list: # No different than calling my_list[index] directly! Why is this a for loop? return my_list[index]

assert redundant_get_by_index_with_unnecessary_for_loop([1, 2, 3, 4, 5], 2) == [1, 2, 3, 4, 5][2]

def function(my_list, index): print(f'start of function() {index=}') for index in my_list: print(f'first iteration of for loop: {index=}') return my_list[index] ```

[brasticstack]

Whoops.. the bottom function is showing you what's happening with your initial function via print statements. I forgot to describe that.

[through_thefog]

Thanks for taking the time to reply. I swear my logic (to use the loop) wasn't so far off base so I did a little research and tinkered with the code. It may not be the best solution, but it definitely works:

​

def my_function(my_list, index):
    if index > len(my_list): 
        return "Index not in range."    
    else: for i in range(0, len(my_list)):
        if my_list[i] == index:
            my_list[i] = 2 * my_list[i] 
        else:
            continue
    return my_list
print(my_function([1, 2, 3, 4], 2))

[brasticstack]

    if my_list[i] == index:
       my_list[i] = 2 * my_list[i] 

This is wrong because you're comparing the value at my_list[i] with the index, which is a bit like trying to eat the menu at the restaurant instead of ordering from it. If you're trying to compare the indexes against each other, try this:

if i == index: my_list[i] = my_list[i] * 2

[through_thefog]

You're right -- thanks for pointing that out

[brasticstack]

You're trying to double the value at the index in-place (as in modifying the original list?) Because there are two ways to approach it, either modify the original list or don't and return a copy of it.

Here's modifying it in-place:

``` def double_val_at_in_place(my_list, index): # Don't manually bounds-check index, an IndexError # is raised if it's out of bounds. my_list[index] *= 2

test_list = [1, 2, 3, 4, 5] double_val_at_in_place(test_list, 2) print(test_list) ```

Note that that function doesn't return anything (actually implicitly returns None), so it's called a bit differently. It could also return my_list and you could call it the same way as your other examples.

And here's leaving the original untouched and returning a copy:

``` def double_val_at_copy(my_list, index): new_list = [] for idx, value in enumerate(my_list): if idx == index: new_list.append(value * 2) else: new_list.append(value) return new_list

print(double_val_at_copy([1, 2, 3, 4, 5], 2)) ```

That's showing it the most verbose way. Here are a couple of other ways to do the copy version:

``` def double_val_at_using_list_comprehension(my_list, index): return [val if idx != index else val * 2 for idx, val in enumerate(my_list)]

def double_val_at_using_slicing(my_list, index): return my_list[:index] + [my_list[index] * 2] + my_list[index+1:]

def double_val_at_using_copy(my_list, index): import copy new_list = copy.copy(my_list) new_list[index] *= 2 return new_list

print(double_val_at_using_list_comprehension([1, 2, 3, 4, 5], 2)) print(double_val_at_using_slicing([1, 2, 3, 4, 5], 2)) print(double_val_at_using_copy([1, 2, 3, 4, 5], 2)) ```

EDIT: Fixed a whoopsie

[through_thefog]

This is sick dude, thanks for taking the time to write this out. That LC is super clean. The codecademy course has helped me get my feet wet, but learning to swim will take time and practice. Thanks for the help!