{"id":3863,"date":"2020-08-10T12:59:30","date_gmt":"2020-08-10T07:29:30","guid":{"rendered":"http:\/\/www.pythonpool.com\/?p=3863"},"modified":"2026-07-13T12:27:50","modified_gmt":"2026-07-13T06:57:50","slug":"python-sort-list-of-lists","status":"publish","type":"post","link":"https:\/\/www.pythonpool.com\/python-sort-list-of-lists\/","title":{"rendered":"Python Sort List of Lists: key, itemgetter, and Multiple Keys"},"content":{"rendered":"

Quick answer:<\/strong> Sort a list of lists by supplying a key that extracts or computes the value to compare. Use sorted() for a new result, list.sort() for intentional in-place mutation, and tuple keys for multiple ordering fields. Validate inner-list shape and types before sorting external data.<\/p>\n

\"Python
Python sorting is driven by a key: choose the inner position or derived value, then decide whether the original list should change.<\/figcaption><\/figure>\n

Sorting a list of lists usually means keeping each inner list together while choosing one part of that row as the sort key. Python handles this cleanly with sorted()<\/code>, list.sort()<\/code>, key=<\/code>, lambda functions, and operator.itemgetter()<\/code>.<\/p>\n

The official Python documentation explains the Sorting HOWTO<\/a>, list.sort()<\/a>, and operator.itemgetter()<\/a>.<\/p>\n

Use sorted(rows, key=...)<\/code> when you want a new sorted list and need to keep the original list unchanged. Use rows.sort(key=...)<\/code> when it is fine to reorder the existing list in place.<\/p>\n

The key<\/code> function receives each inner list and returns the value Python should compare. For example, lambda row: row[1]<\/code> sorts by the second item in each row.<\/p>\n

Python sorting is stable. If two rows have the same key, their original order is preserved. Stability is useful when you sort in multiple passes or when equal values should keep a meaningful input order.<\/p>\n

Before sorting, confirm that every inner list has the position your key reads. If some rows are shorter, a position-based key can raise IndexError<\/code>. Validate messy input or write a key that handles missing fields.<\/p>\n

For simple item positions, itemgetter()<\/code> is concise and fast. For expressions such as sums, lengths, combined keys, or sign changes, a lambda is usually clearer.<\/p>\n

Use reverse=True<\/code> for descending order. Do not reverse the final list manually unless there is a specific reason; the built-in argument states the intent directly.<\/p>\n

Keep sort keys simple and cheap. Python calls the key function once for each row, stores the key internally, and then sorts using those stored keys. That makes key-based sorting efficient, but a key that performs slow work can still make the whole sort feel slow.<\/p>\n

Be consistent about row shape. If index 0<\/code> means a name in one row and a category in another row, the sort may run but the result will be hard to trust. Clean the data before sorting when rows come from user input, CSV files, or mixed sources.<\/p>\n

If the inner lists represent long records, consider switching to dictionaries, tuples with named positions, dataclasses, or small objects. Lists are fine for compact examples, but named fields are easier to maintain when the row has many columns.<\/p>\n

\n
\n

Contents<\/p>\nToggle<\/span><\/path><\/svg><\/svg><\/span><\/span><\/span><\/a><\/span><\/div>\n