Quicksort for Just 2 Elements

In "Grokking Algorithms", the author gives this code for the base case of a quicksort implementation:

def quicksort(array):
  if len(array) < 2:
    # base case, arrays with 0 or 1 element are already "sorted"
    return array

and then writes "Let's look at bigger arrays. An array with with two elements is pretty easy to sort, too - check if the first elements is smaller than the second, and of it isn't, swap them."

A bit later, walking through an example, he writes "Well, the quicksort base case already knows how to sort arrays of two elements."

I can't see how this is so. Isn't there a missing step? The code works, of course, but I see not part of the algorithm which explicitly handles a 2-element list, so how does a list of 2 elements get sorted please? I.e. where is the logic to "check if the first elements is smaller than the second, and of it isn't, swap them"?

The full algorithm is below:

def quicksort(array):
  if len(array) < 2:
    # base case, arrays with 0 or 1 element are already "sorted"
    return array
  else:
    # recursive case
    pivot = array[0]
    # sub-array of all the elements less than the pivot
    less = [i for i in array[1:] if i <= pivot]
    # sub-array of all the elements greater than the pivot
    greater = [i for i in array[1:] if i > pivot]
    return quicksort(less) + [pivot] + quicksort(greater)

print quicksort([10, 5, 2, 3])

As per the comment, arrays with 0 or 1 element are already "sorted"

len(array) < 2

Consider a list of two elements [2, 1]

pivot = array[0] # pivot = 2
less = [i for i in array[1:] if i <= pivot] # less = [1]
greater = [i for i in array[1:] if i > pivot]  # greater = []
return quicksort(less) + [pivot] + quicksort(greater)

Now we know that the function returns single elements as is, so
this function returns

return less + [pivot] + greater
return [1] +  [2]  + []
return [1, 2]

Similarly, this works for elements in order

[1, 2]
pivot = array[0] # pivot = 1
less = [i for i in array[1:] if i <= pivot] # less = []
greater = [i for i in array[1:] if i > pivot]  # greater = [2]
return quicksort(less) + [pivot] + quicksort(greater)
return [] + [1] + [2]
return [1, 2]

You should take a look at the # recursive case:

# recursive case
pivot = array[0]
# sub-array of all the elements less than the pivot
less = [i for i in array[1:] if i <= pivot]
# sub-array of all the elements greater than the pivot
greater = [i for i in array[1:] if i > pivot]
return quicksort(less) + [pivot] + quicksort(greater)

In case of 2 elements, either less or greater will be an empty list, and the other one (non-empty) will be concatenated to the first element (pivot) on the left on the right side depending on being larger or smaller.

BTW. the quicksort algorithm does not work well for very short arrays, the common wisdom is to use something simpler, like even bubble sort if the number of the elements is less than, say, five.