5 Best Ways to Get the First Element of Each Sublist in Python

Rate this post

πŸ’‘ Problem Formulation: When working with a list of lists (sublists) in Python, a common task involves retrieving the first element from each sublist. For example, given a list [[1, 2, 3], [4, 5, 6], [7, 8, 9]], the desired output is [1, 4, 7]. This article will explore several methods to achieve this.

Method 1: Using a For Loop

This traditional method involves iterating over the list with a for loop and appending the first element of each sublist to a new list. It is a straightforward approach and easily understandable even for those new to programming.

Here’s an example:

sublists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
first_elements = []
for sublist in sublists:

Output: [1, 4, 7]

The code initializes an empty list called first_elements. It then loops through each sublist in the list sublists, appending the first element (sublist[0]) of each sublist to first_elements.

Method 2: Using List Comprehension

List comprehension offers a more concise and Pythonic way to create a list based on an existing list. This method executes faster and is generally considered more readable for those familiar with Python.

Here’s an example:

sublists = [[1, 'a'], ['b', 2], [3, 'c']]
first_elements = [sublist[0] for sublist in sublists]

Output: [1, 'b', 3]

The one-liner list comprehension works by creating a new list, first_elements, where for each sublist in sublists, the first element is extracted (sublist[0]) and included in the new list.

Method 3: Using the map() Function

The map() function applies a given function to each item of an iterable (such as a list) and returns a list of the results. In this case, we use a lambda function to select the first element of each sublist.

Here’s an example:

sublists = [[-1, 0], [1, 2], [5, 6]]
first_elements = list(map(lambda x: x[0], sublists))

Output: [-1, 1, 5]

The map() function applies a lambda function that takes x (each sublist) and returns x[0]. The result is then cast to a list to get first_elements.

Method 4: Using a Generator Expression

A generator expression is similar to list comprehension but it generates items one at a time and is more memory-efficient. This approach is suitable for large lists where you want to use items as they are generated.

Here’s an example:

sublists = [[100], [200, 300], [400, 500, 600]]
first_elements = (sublist[0] for sublist in sublists)

Output: [100, 200, 400]

A generator expression is defined, first_elements, which is then converted to a list to get the output. This effectively defers the computation until it is specifically iterated over or materialized as a list.

Bonus One-Liner Method 5: Using the zip() Function

The zip() function makes an iterator that aggregates elements from each of the iterables. By zipping the sublists, we can extract the first element of each using the asterisk operator for unpacking.

Here’s an example:

sublists = [['a', 1], ['b', 2], ['c', 3]]
first_elements = list(zip(*sublists))[0]

Output: ('a', 'b', 'c')

The zip(*sublists) unpacks each sublist into separate arguments for zip, which then pairs up the corresponding items, effectively transposing the list of lists. The first set of elements is then selected and turned into a list.


  • Method 1: For Loop. Simplicity. Ideal for beginners. Can be slow for large lists.
  • Method 2: List Comprehension. Conciseness. Pythonic and more performant than loops.
  • Method 3: map() Function. Functional programming approach. Clean one-liner but requires lambda function understanding.
  • Method 4: Generator Expression. Memory efficiency. Good for large datasets, though slightly less intuitive for some.
  • Bonus Method 5: zip() Function. Clever usage. Best for uniform-length sublists, not as straightforward as other methods.