找到第3小的数，为什么左边两个数仍然没有排好？

"""Selecting a rank partitions values but does not sort both partitions."""
from itertools import product


def require(ok, message):
    if not ok:
        raise AssertionError(message)


def select(values, rank):
    if not isinstance(values, (list, tuple)) or not 1 <= len(values) <= 100:
        raise ValueError("1..100 integer values required")
    if any(type(value) is not int or not -999 <= value <= 999 for value in values):
        raise ValueError("integers in -999..999 required; bool excluded")
    if type(rank) is not int or not 0 <= rank < len(values):
        raise ValueError("zero-based rank outside array")
    values = list(values)
    low, high, comparisons = 0, len(values) - 1, 0
    trace = []
    while low <= high:
        pivot = values[high]
        boundary = low
        for scan in range(low, high):
            comparisons += 1
            if values[scan] < pivot:
                values[scan], values[boundary] = values[boundary], values[scan]
                boundary += 1
        values[boundary], values[high] = values[high], values[boundary]
        trace.append((low, high, pivot, boundary, list(values)))
        if boundary == rank:
            return values[rank], values, comparisons, trace
        if boundary < rank:
            low = boundary + 1
        else:
            high = boundary - 1
    raise AssertionError("nonempty candidate interval expected")


def main():
    values, rank = [4, 2, 5, 1, 3], 2
    chosen, partial, comparisons, _ = select(values, rank)
    print(f"input={values}; zero_based_rank={rank}")
    print(f"selected={chosen}; partitioned={partial}; fully_sorted={partial == sorted(values)}")
    print(f"left_of_rank={partial[:rank]}; comparisons={comparisons}")
    require(chosen == 3 and partial[:rank] == [2, 1], "partition is not full sorting")
    counts = []
    for size in (5, 10, 20):
        chosen, _, comparisons, _ = select(list(range(size)), 0)
        require(chosen == 0 and comparisons == size * (size - 1) // 2, "deterministic pivot worst case")
        counts.append((size, comparisons))
    print(f"sorted_input_select_min_comparisons={counts}")
    arrays = cases = 0
    for size in range(1, 7):
        for values in product((0, 1, 2), repeat=size):
            arrays += 1
            for rank in range(size):
                chosen, partial, _, _ = select(values, rank)
                expected = sorted(values)
                require(chosen == expected[rank], "independent full sort")
                require(sorted(partial) == expected, "multiset preserved")
                require(all(x <= chosen for x in partial[:rank]), "left rank boundary")
                require(all(x >= chosen for x in partial[rank+1:]), "right rank boundary")
                cases += 1
    invalid = [([], 0), ([1], -1), ([1], 1), ([1], True), ([True], 0), ([1.5], 0), ([1000], 0)]
    for args in invalid:
        try:
            select(*args)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid input accepted")
    print(f"arrays={arrays}; rank_cases={cases}; invalid_inputs=7")
    print("PASS: selected rank, partition boundaries, duplicates and preserved multiset")


if __name__ == "__main__":
    main()