Tools: I Implemented Every Sorting Algorithm in Python — And Python's Built-in Sort Crushed Them All

The Surprise Results (Real Benchmarks) ## Why Hand-Written Sorts Lose in Python ## The Verdict ## Want the full deep dive? ## Run the benchmarks yourself Last month, I went down a rabbit hole: I implemented six classic sorting algorithms from scratch in pure Python (Bubble, Selection, Insertion, Merge, Quick, Heap) and benchmarked them properly on CPython. I expected the usual Big-O story. What I got was a reality check: Python's interpreter overhead changes everything. Textbooks say Quick/Merge/Heap are fast. In Python? They're okay... but sorted() (Timsort) beats them by 5–150×. Here's why — and when you should never write your own sort. I tested on random, nearly-sorted, reversed, and duplicate-heavy data using timeit with warm-ups, median timing, and GC controls. Example: Insertion sort (often the small-data winner): Never implement your own sort in production Python. Use sorted() or .sort() — they’re faster, stable, and battle-tested. Do it only for learning purposes or rare edge cases. 👉 Read the complete post on my blog: https://emitechlogic.com/sorting-algorithm-in-python/ What surprised you most about Python’s sorting performance? Drop a comment — curious to hear your take. Templates let you quickly answer FAQs or store snippets for re-use. Are you sure you want to ? It will become hidden in your post, but will still be visible via the comment's permalink. as well , this person and/or COMMAND_BLOCK: def insertion_sort(arr): arr = arr.copy() for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr COMMAND_BLOCK: def insertion_sort(arr): arr = arr.copy() for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr COMMAND_BLOCK: def insertion_sort(arr): arr = arr.copy() for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr - Insertion sort beats Merge/Quick on <100 elements (low overhead wins). - Bubble sort dies at ~1,000 elements due to expensive comparisons. - Timsort (built-in) exploits real-world patterns and runs in C — untouchable. - Comparisons are expensive: a > b → method dispatch, type checks (not one CPU instruction). - Recursion overhead: Quick sort's function calls are costly. - Memory allocations: Merge sort creates thousands of temporary lists → GC pauses. - Timsort is a hybrid genius: Detects runs, uses insertion sort for small chunks, merges adaptively — all in optimized C. - Detailed explanations - All source code - Benchmark script - Raw benchmark data - GitHub Repository: https://github.com/Emmimal/python-sorting-benchmarks