sort() vs sorted() in Python

sort is a method on the list and modifies it in place. sorted is a function that takes any iterable and returns a new sorted list, leaving the original alone.

numbers = [3, 1, 2]

result = numbers.sort()
print(result)                # None - sort returns nothing
print(numbers)               # [1, 2, 3] - but the list is sorted

copy = sorted([3, 1, 2], reverse=True)
print(copy)                  # [3, 2, 1]
print([3, 1, 2])             # [3, 1, 2] - the original is untouched

# The key argument chooses what to sort on
words = ["banana", "fig", "apple"]
print(sorted(words, key=len))         # ['fig', 'apple', 'banana']

The None that sort returns is the detail that catches people out, because it means the whole statement result = numbers.sort() does nothing useful. If you find that in your own code, you want sorted instead.

The key argument is where most of the real work happens. It takes a function that is applied to each element to produce the value used for comparison, and the original elements are what end up in the result — so sorting by len gives the words in order of length but still spelled normally. The reverse=True argument flips the order without needing a reversed key function.

Two more things to know. Python's sort is stable, so elements that compare equal keep their original relative order, which matters when you sort by one field of a record and want the other fields to stay in a predictable order. And a key function is called exactly once per element, so it is the right place to put an expensive computation — writing a lambda that recomputes a value on every comparison is a well-known performance mistake.

Sorting dicts is a key-function job, because Python cannot compare dicts to each other directly.

people = [
    {"name": "Ada", "age": 36},
    {"name": "Alan", "age": 41},
    {"name": "Grace", "age": 45},
]

by_age = sorted(people, key=lambda person: person["age"])
print([p["name"] for p in by_age])          # ['Ada', 'Alan', 'Grace']

youngest_first = sorted(people, key=lambda person: person["age"], reverse=True)
print([p["name"] for p in youngest_first])  # ['Grace', 'Alan', 'Ada']

# sort() modifies in place and returns None
people.sort(key=lambda person: person["age"])
print(type(people))                          # <class 'list'>
print([p["name"] for p in people])          # ['Ada', 'Alan', 'Grace']

# A tuple key gives a stable multi-field sort
people.sort(key=lambda person: (person["age"], person["name"]))

The key function extracts the field to compare on, and the result contains the original dicts — you are sorting the records, not the extracted values. Using reverse=True flips the ordering without needing a negated key, which is much easier to read than trying to negate the value yourself.

The last two lines show the more advanced form. A key that returns a tuple sorts by the first component, then by the second for ties. That is the standard way to get a multi-field sort, and because Python's sort is stable, you can also achieve it by sorting twice — first by the secondary key, then by the primary — and get the same result.

One performance note worth mentioning in an interview: the key function is called once per element, so if the key is expensive, compute it once with a list of tuples and sort that instead. Sorting a list of (key, value) pairs is the classic technique when the key computation dominates.

sort is a method of the list object and sorts that list in place, changing the object the name refers to. sorted is a built-in function that takes any iterable and returns a new sorted list, leaving its input untouched.

sort returns None because it modifies the list rather than producing a value. Returning the same list would be redundant — you already have it — and returning None makes the in-place semantics unambiguous: if you want a new list, use sorted. It is the same design decision as the list methods append, insert and extend, all of which also return None, and it is the reason list.sort and list.reverse are chainable but not usable in an expression.

That last point is the practical trap. Writing result = items.sort() gives you None and looks like it should have sorted something, and the same mistake is common with reverse and with the in-place dictionary and set methods. If a line of code assigns the result of an in-place method, the bug is always there.

Choosing between them comes down to one question: do you want to keep the original? Use sorted when you do — sorting a copy, sorting a generator, sorting the keys of a dict, or sorting a list you still need in its original order. Use sort when the list is yours to reorder and you want to avoid the extra allocation, which matters on large lists in tight loops.