Introduction

The expression sorted(data, key=lambda x: ...) is one of those Python idioms that feels cryptic until you know what part each token plays. Once you break it apart, it is just sorted asking for a helper function and lambda providing that helper inline.

Core Sections

What sorted expects

sorted takes an iterable and returns a new list in sorted order. If you do not provide a key, Python compares the items directly. If you do provide key=..., Python first computes a comparison value for each item and sorts using those values instead.

numbers = [10, 2, 30, 4]
print(sorted(numbers))

[2, 4, 10, 30]

That works because integers already know how to compare themselves. With tuples, dictionaries, or objects, you often need to tell Python which part matters for ordering.

Reading key=lambda item: item[1]

Take this common example:

records = [("alice", 88), ("bob", 72), ("carol", 95)]
result = sorted(records, key=lambda item: item[1])
print(result)

[('bob', 72), ('alice', 88), ('carol', 95)]

Read it from left to right:

• 'sorted(records, ...) means "return a new sorted list."'
• 'key= means "sort by a derived value."'
• 'lambda item: item[1] means "for each item, return its second element."'

So Python does not sort the tuples by tuple rules here. It asks the lambda for a key for each tuple and sorts by those keys.

lambda is just a tiny unnamed function

If lambda syntax feels compressed, translate it into a normal function. The behavior is the same.

1records = [("alice", 88), ("bob", 72), ("carol", 95)]
2
3def score_key(item):
4    return item[1]
5
6print(sorted(records, key=score_key))

This is the simplest mental model: lambda item: item[1] is an inline version of a one-line function. Python uses it when the helper is short enough that naming it would add ceremony rather than clarity.

Common patterns for sort keys

Sort keys are useful far beyond tuples. You can sort case-insensitively:

names = ["Zoe", "alice", "Bob"]
print(sorted(names, key=lambda name: name.lower()))

You can sort dictionaries by one field:

1users = [
2    {"name": "Alice", "age": 31},
3    {"name": "Bob", "age": 24},
4    {"name": "Carol", "age": 29},
5]
6
7print(sorted(users, key=lambda user: user["age"]))

You can also sort by multiple criteria by returning a tuple key:

1files = [
2    ("report.txt", 2),
3    ("archive.zip", 1),
4    ("notes.txt", 1),
5]
6
7print(sorted(files, key=lambda item: (item[1], item[0])))

Python compares tuple keys lexicographically, so it sorts by item[1] first and uses item[0] as a tiebreaker.

sorted versus .sort()

Another part of the syntax that trips people up is whether the original list changes. sorted(...) always returns a new list, leaving the original iterable unchanged. .sort(...) sorts an existing list in place.

1numbers = [3, 1, 2]
2new_numbers = sorted(numbers)
3
4print(numbers)
5print(new_numbers)

Use sorted when you need a new list or when the source is not already a list. Use .sort() when mutating the original list is acceptable.

When not to use lambda

Inline lambdas are convenient, but they should stay small. If the key logic contains several conditions, a fallback lookup, or normalization steps that are meaningful on their own, give the function a name. Python code stays easier to maintain when the sort rule reads like a decision, not like punctuation.

For very common cases, the operator module is even cleaner:

1from operator import itemgetter
2
3records = [("alice", 88), ("bob", 72), ("carol", 95)]
4print(sorted(records, key=itemgetter(1)))

itemgetter(1) communicates intent immediately for tuple-like data.

Common Pitfalls

• Assuming the key function compares items directly. It only returns the value Python should compare.
• Forgetting that sorted returns a new list and does not mutate the original data.
• Returning inconsistent types from the key function, such as strings for some items and integers for others.
• Writing a long, clever lambda when a named function or itemgetter would be clearer.
• Overlooking tuple keys when you need primary and secondary sort criteria.

Summary

• 'sorted(..., key=...) sorts by a derived value rather than by the raw item.'
• 'lambda item: item[1] means "take an item and return its second element."'
• A lambda here is just a short unnamed helper function.
• Tuple keys let you express multi-column sorts cleanly.
• Use sorted, .sort(), lambda, or helper functions based on readability and whether you want a new list or an in-place sort.