No. Each value belongs to one of three regions, and one unknown item is classified per iteration.

Do not think “sorting.” Think “classify the next unknown.” The invariant makes every swap’s destination obvious and guarantees the unknown region shrinks.

What the function promises: Mutate and return a list containing only integers 0, 1, and 2. Reject other values before mutation.

def sort_colors(values):
    if any(value not in (0, 1, 2) for value in values):
        raise ValueError("Only 0, 1, 2 are allowed")
    low = scan = 0
    high = len(values) - 1
    while scan <= high:
        if values[scan] == 0:
            values[low], values[scan] = values[scan], values[low]
            low += 1; scan += 1
        elif values[scan] == 1:
            scan += 1
        else:
            values[scan], values[high] = values[high], values[scan]
            high -= 1
    return values

assert sort_colors([2,0,2,1,1,0]) == [0,0,1,1,2,2]

Work and storage: O(n) time and O(1) extra space.

When to recognize it: Each value belongs to one of three regions, and one unknown item is classified per iteration.

Check before applying it: Advancing after a right swap can skip an unclassified incoming value.

Use counting for a small key range or a general sorting method; the three-region invariant does not scale directly.