Sorting a string isn’t something you do every day, but when it’s needed, it should be quick and simple. In Python, you can treat strings like sequences, which means you can rearrange their characters just like you’d sort numbers in a list. Sorting a string can help with comparisons, anagram checking, data cleanup, or even basic encryption.

Since strings are immutable in Python, any sorting operation always creates a new string rather than modifying the original. That behavior keeps things safe and predictable while giving you the flexibility to try different methods based on what you're trying to achieve.

7 Ways to Sort a String in Python

Using sorted() Function with join()

The easiest way to sort a string in Python is by combining the sorted() function with join(). The sorted() function works on any iterable, and it returns a list of characters when used on a string. Since you usually want the result back as a string, join() helps glue the characters back together. Here’s a quick example:

python

CopyEdit

text = "python"

sorted_text = ''.join(sorted(text))

print(sorted_text) # hnopty

This method sorts characters in ascending order, based on their Unicode values. That means uppercase letters will come before lowercase ones. If your input includes symbols or numbers, they will also be sorted in that order unless you adjust it manually.

If you want to reverse the result, just add reverse=True to the sorted() call:

python

CopyEdit

''.join(sorted(text, reverse=True))

This approach is reliable for most basic tasks in Python, such as string manipulation.

Custom Sorting Using sorted() with key

If you want to sort a string with a custom rule—for example, ignoring case while still preserving original casing—you can use the key argument. Here’s an example:

python

CopyEdit

text = "PyThoN"

sorted_case_insensitive = ''.join(sorted(text, key=str.lower))

print(sorted_case_insensitive) # hNoPTy

The characters are ordered alphabetically regardless of their case, but the actual case remains untouched. This is useful when you're sorting names or text where case matters visually, but you still want logical alphabetical order.

You can define your key functions too. Let's say you want to move all vowels to the front and then sort the rest:

python

CopyEdit

def custom_key(char):

return (char.lower() not in "aeiou", char.lower())

sorted_text = ''.join(sorted("algorithm", key=custom_key))

print(sorted_text) # aiohlgrtm

This level of control makes Python strong for custom string manipulation, especially when you want to go beyond simple sorting.

Sorting Using Recursion

If you want to write your sorting logic for a string without using built-in sort functions, recursion is one way to go. This won't be as fast as Python's built-ins, but it's useful for learning or interview settings.

python

CopyEdit

def recursive_sort(s):

if len(s) <= 1:

return s

pivot = s[0]

less = ''.join([char for char in s[1:] if char < pivot])

more = ''.join([char for char in s[1:] if char >= pivot])

return recursive_sort(less) + pivot + recursive_sort(more)

text = "python"

print(recursive_sort(text)) # hnopty

This simulates a quicksort, sorting characters by choosing a pivot and recursively organizing the rest around it.

Sorting with ASCII Values

You can also sort characters in a string based on their ASCII values manually using the ord() function and a basic sorting algorithm like bubble sort. Here’s how that might look:

python

CopyEdit

def ascii_sort(s):

chars = list(s)

n = len(chars)

for i in range(n):

for j in range(0, n-i-1):

if ord(chars[j]) > ord(chars[j+1]):

chars[j], chars[j+1] = chars[j+1], chars[j]

return ''.join(chars)

text = "Python"

print(ascii_sort(text)) # Phnoty

This kind of low-level control gives you more understanding of what happens under the hood, especially when exploring string manipulation in Python without built-ins.

Sorting a String with collections.Counter

Although Counter isn’t a sorting tool by itself, you can use it to count and then sort characters by frequency or alphabetical order. Here’s an example that sorts a string by character frequency:

python

CopyEdit

from collections import Counter

def sort_by_frequency(s):

count = Counter(s)

sorted_chars = sorted(count.items(), key=lambda item: (item[1], item[0]))

return ''.join([char * freq for char, freq in sorted_chars])

text = "banana"

print(sort_by_frequency(text)) # bnnnaa or aabnnn depending on logic

This technique is more niche but useful for tasks like compression algorithms or detecting character trends in data.

Using heapq for Partial Sorting

If you only want the smallest or largest few characters from a string and don't want to sort the entire thing, heapq can help:

python

CopyEdit

import heapq

text = "datastructure"

smallest = heapq.nsmallest(5, text)

print(''.join(smallest)) # aacde or similar

This approach is faster when working with large strings where you don't need full sorting. It's not common, but it's good to know in performance-sensitive applications.

Sorting a String with Locale-Based Rules

The default string sorting in Python is based on Unicode code points, which doesn’t always work well when you need natural alphabetical order in other languages. The locale module adjusts sorting based on cultural conventions. This is useful when you want "ä" to be treated like "a", or when working with multilingual data.

python

CopyEdit

import locale

def locale_sort(s):

locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # Set locale

return ''.join(sorted(s, key=locale.strxfrm))

text = "résumé"

print(locale_sort(text)) # émrsué or similar, depending on locale

In this case, locale.strxfrm transforms each character into a form that the locale recognizes for comparison. This is especially handy in user-facing applications where sorting should match natural reading expectations. You can replace 'en_US.UTF-8' with other locale settings like 'de_DE.UTF-8' for German or 'fr_FR.UTF-8' for French.

Conclusion

Sorting strings in Python can be done in several ways, depending on what you need. The sorted() function works for basic tasks, but other methods offer more control. Use custom keys for logic-based sorting, recursion for learning purposes, and ASCII values when you need fine-grained comparison. For specific needs, heapq and Counter offer unique benefits. Each approach has its place, and with some hands-on use, it becomes easier to match the right method with the job.