索引错误：列表超出范围（Python）排序问题+枚举（）

Question

For one of my classes, we are doing debugging activities. So for this, we are supposed to Sort a list by locating the minimum value and swapping elements at position i and index_of_min_item.

The enumerate function was given as part of the template so I have to include it in the code. But I wasn't sure how I should use it if anyone can explain and help me out.

I wrote a test case but I kept getting the error message "IndexError: list index out of range" when I tried running it. I have checked many times already but couldn't figure out what's wrong with the code. Can someone help me to identify the problem?

import sys
from typing import Iterable, List, TypeVar, Any

T = TypeVar('T')


def swap(values: List, index1: int, index2: int) -> None:
    a = index1
    b = index2
    temp = values[a]
    values[a] = values[b]
    values[b] = temp
    # return values


def get_index_of_min_item(items: List[T]) -> int:
    index_of_min_item = 0
    min_item = items[index_of_min_item]
    for index in range(len(items)):
        cur_item = items[index]
        if cur_item < min_item:
            index_of_min_item = index
            min_item = cur_item
    return index_of_min_item


def sort_items(items: Iterable[T]) -> List[T]:
    n_items=[]
    for pos, items in enumerate(items):
        n_items.append(items)
    for i in n_items:
        index_of_min_item = get_index_of_min_item(n_items[i:-1])
        swap(n_items, n_items[i], n_items[index_of_min_item])
        return n_items

Debugger for sort_items function:

import unittest
from typing import TypeVar
from src import sorting

T = TypeVar('T')


class TestSorting(unittest.TestCase):
    def test_sortNum(self):
        self.assertEqual(sorting.sort_items([13, 18, 6, 5, 0]),[0,5,6,13,18])

if __name__ == '__main__':
    unittest.main()

Error Message: File "/Users/Downloads/Sorting/src/sorting.py", line 30, in get_index_of_min_item min_item = items[index_of_min_item] IndexError: list index out of range

Answer 1

Welcome to SO, @vsc.

I have a bit of free time for checking your code and optimize it for you.

• First, your error reason is:

  for i in n_items: with n_items = [13, 18, 6, 5, 0] , list index range is [0-4]

  Start with first item value i=13 => n_items[i:-1] (13 > 4) => IndexError: list index out of range

• OK, let move to the first suggestion: for i in range(len(n_items)) , this for loop with check with i => [0-4] .

  With i=0 => index_of_min_item=3 (wrong, right is 4) => swap(n_items, n_items[i], n_items[index_of_min_item]) will become swap(n_items, 13, 5) => temp = values[a=index1] => n_items[13] => IndexError: list index out of range

Whatever your code has too many issues here:D

Python also supports some faster ways to handle these things like:

• swap: a,b = b,a or items[a], items[b] = items[b], items[a]

• get_index_min_value: items.index(min(items[i:]))

Try your best to correct your code, that is all my helps.

Answer 2

Here is your homework with some explaining also in python 3+ (items: List[T]) -> int is kinda usless and will make no diference removing it.

import unittest

def swap(values, index1, index2):
    values_tmp = values[index1]
    values[index1] = values[index2]
    values[index2] = values_tmp

def get_index_of_min_item(items):
    # > len() returns the number of items on a list
    # > range() by deafults uses 0 to start and the end
    # > for a loop shuld be (nº items - 1)

    # > Use of range >
    # >   range(end_index)
    # >   range(start_index, end_index)

    cur_item = items[0]
    out_index = 0
    for index in range(1, len(items)):
        if items[index] < cur_item:
            cur_item = items[index]
            out_index = index
    return out_index

def sort_items(items, descendent=False):
    # n_items = []
    # for pos, item in enumerate(items):
    #     n_items.append(item)
    # > equivelant to :
    n_items = items

    # for i in n_items:
    # > in this case i is not the correct variable,
    # > it is a int() but is conent of the list and
    # > not the index of the content

    last_index = len(n_items) - 1
    for i in range(last_index):
        # > [i:-1] means for x index up to the previus last
        # > [ start_index : end_index ] (end_index is not included)
        lowest_of_reamining = get_index_of_min_item(n_items[i:])
        # > each time get_index_of_min_item() is getting smaller and
        # > smaller list, an offset is needed
        lowest_of_reamining += i

        # swap(n_items, n_items[i], n_items[index_of_min_item])
        # > if swap() ask for a index give a index
        # > not the content of the index
        swap(n_items, i, lowest_of_reamining)

    return n_items

class TestSorting(unittest.TestCase):
    def test_sortNum(self):
        self.assertEqual(
            sort_items(
               [13, 18, 6, 5, 0]
            ), [0, 5, 6, 13, 18]
        )

if __name__ == '__main__':
    unittest.main()