The functional Quicksort partitions the list into 'less than or equal to pivot' and 'greater than pivot' using two list comprehensions, then recursively sorts each side and concatenates. The base case (len(xs) <= 1) covers both the empty list and the single-element list. This is the teaching version: it is concise enough to fit on a slide and demonstrates Quicksort's divide-and-conquer shape clearly. The trade-off is O(n) extra space per recursive call (the two new lists), which makes it asymptotically slower than the in-place version for large inputs.

The Lomuto partition picks the last element as the pivot, walks the unsorted region with j, and maintains an i index for the boundary between the 'less than or equal' prefix and the 'greater than' suffix. After the loop, swapping xs[i] with the pivot puts it in its final position. The recursion sorts the two sides in place. This version uses O(1) extra space and is closer to what production sort routines look like (though they pick the pivot more carefully). Worst case is still O(n^2) for adversarial inputs; introsort fixes that.

Both Quicksort versions are educational: in production code, sorted() (and list.sort()) use Timsort, which is a stable, adaptive merge sort that runs in O(n log n) worst case and O(n) on already-sorted inputs. Timsort is implemented in C and beats hand-rolled Python by orders of magnitude. The lesson: write the one-liner to teach Quicksort, but reach for sorted for any real workload. The same advice applies in JavaScript (Array.sort is Timsort in V8) and most modern languages.