Skip to main content

How to Access Multiple List Elements by Index in Python

Often when working with Python lists, you need to retrieve not just one element, but several specific elements based on their positions (indices). Instead of accessing them one by one, Python offers several convenient and efficient ways to extract multiple elements using a list of indices.

This guide demonstrates the most common methods, including list comprehensions, operator.itemgetter, NumPy array indexing, and standard loops, to access multiple list elements by their indices.

The Goal: Selecting Multiple Elements by Position​

Given an existing list and a separate list containing the indices of the desired elements, we want to create a new list containing only the elements from the original list at those specific indices.

Example Data:

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5] # We want elements at index 0, 3, and 5
# Expected Result: ['a', 'd', 'f']

List comprehensions offer a concise, readable, and Pythonic way to create a new list based on an existing iterable. This is often the preferred method for this task in standard Python.

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ Iterate through target_indices and access source_list at each index
selected_elements = [source_list[index] for index in target_indices]

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Elements (List Comp): {selected_elements}")
# Output: Selected Elements (List Comp): ['a', 'd', 'f']
  • for index in target_indices: Loops through each index (0, 3, 5) in our target list.
  • source_list[index]: For each index, it retrieves the element from source_list at that position.
  • [...]: Collects the retrieved elements into a new list.

Method 2: Using operator.itemgetter​

The operator module provides itemgetter, which creates a callable object that can fetch items from a sequence based on indices.

from operator import itemgetter # Required import

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ 1. Create an itemgetter callable for the desired indices
#    The * unpacks the target_indices list into separate arguments for itemgetter
getter = itemgetter(*target_indices) # Equivalent to itemgetter(0, 3, 5)

# ✅ 2. Call the getter object with the source list
#    This returns a tuple containing the elements at the specified indices
selected_tuple = getter(source_list)

# ✅ 3. Convert the resulting tuple to a list (optional)
selected_elements = list(selected_tuple)

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Tuple (itemgetter): {selected_tuple}") # Output: ('a', 'd', 'f')
print(f"Selected Elements (itemgetter): {selected_elements}")
# Output: Selected Elements (itemgetter): ['a', 'd', 'f']

# Can also be done in one line:
# selected_elements_oneline = list(itemgetter(*target_indices)(source_list))
  • itemgetter(*target_indices): Creates a function-like object that knows how to fetch elements at indices 0, 3, and 5. The * unpacks the target_indices list into individual arguments 0, 3, 5.
  • getter(source_list): Applies this getter to the source_list, returning a tuple ('a', 'd', 'f').
  • list(...): Converts the tuple result into a list.

Method 3: Using NumPy Array Indexing​

If you are working with numerical data or already using the NumPy library, its powerful array indexing capabilities are very efficient.

# Requires: pip install numpy
import numpy as np

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ 1. Convert the Python list to a NumPy array
np_array = np.array(source_list)
print(f"NumPy array: {np_array}")

# ✅ 2. Index the NumPy array directly with the list of target indices
selected_np_array = np_array[target_indices]
print(f"Selected NumPy sub-array: {selected_np_array}")
# Output: Selected NumPy sub-array: ['a' 'd' 'f']

# ✅ 3. Convert the resulting NumPy array back to a list (optional)
selected_elements = selected_np_array.tolist()

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Elements (NumPy): {selected_elements}")
# Output: Selected Elements (NumPy): ['a', 'd', 'f']
  • np.array(source_list): Creates a NumPy array from the list.
  • np_array[target_indices]: NumPy allows passing a list or array of indices directly within the square brackets to select multiple elements simultaneously. This is called "fancy indexing".
  • .tolist(): Converts the resulting NumPy array back to a standard Python list if needed.

Method 4: Using a for Loop​

The most explicit, step-by-step approach uses a standard for loop.

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ Initialize an empty list to store results
selected_elements_loop = []

# ✅ Loop through the target indices
for index in target_indices:
    try:
        # Append the element from the source list at the current index
        selected_elements_loop.append(source_list[index])
    except IndexError:
        # Optional: Handle cases where an index might be out of bounds
        print(f"Warning: Index {index} is out of bounds for the source list.")

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Elements (Loop): {selected_elements_loop}")
# Output: Selected Elements (Loop): ['a', 'd', 'f']

This is easy to understand but more verbose than list comprehensions or itemgetter.

Method 5: Using map() with lambda​

A functional programming approach using map() and a lambda function.

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ map applies the lambda function to each index in target_indices
# The lambda function retrieves the element from source_list using the index
map_iterator = map(lambda index: source_list[index], target_indices)

# ✅ Convert the map object (iterator) to a list
selected_elements = list(map_iterator)

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Elements (map): {selected_elements}")
# Output: Selected Elements (map): ['a', 'd', 'f']

This works but is often considered slightly less readable than a list comprehension for this specific task.

Method 6: Using Pandas Series Indexing (Optional)​

Similar to NumPy, if you are using the Pandas library, you can convert the list to a Series and use its indexing.

# Requires: pip install pandas
import pandas as pd

source_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
target_indices = [0, 3, 5]

# ✅ 1. Convert list to Pandas Series
pd_series = pd.Series(source_list)
print(f"Pandas Series:\n{pd_series}\n")

# ✅ 2. Index the Series using the list of target indices
#    Need .iloc for positional integer indexing if series index isn't default
#    Or directly if using default 0-based integer index.
# selected_pd_series = pd_series[target_indices] # Works if Series index matches target_indices values
selected_pd_series = pd_series.iloc[target_indices] # More robust using positional index


print(f"Selected Pandas sub-series:\n{selected_pd_series}\n")
# Output:
# Selected Pandas sub-series:
# 0    a
# 3    d
# 5    f
# dtype: object

# ✅ 3. Convert the result back to a list
selected_elements = selected_pd_series.tolist()

print(f"Original List: {source_list}")
print(f"Target Indices: {target_indices}")
print(f"Selected Elements (Pandas): {selected_elements}")
# Output: Selected Elements (Pandas): ['a', 'd', 'f']

This is mainly useful if your data is already within a Pandas workflow.

Choosing the Right Method​

  • List Comprehension: Recommended standard Python approach. Concise, readable, efficient.
  • operator.itemgetter: Elegant functional alternative. Good performance. Slightly less common syntax for beginners.
  • NumPy Indexing: Best performance if working with NumPy arrays, especially for large datasets. Requires NumPy dependency.
  • for Loop: Most explicit, good for understanding the process or if more complex logic per index is needed. More verbose.
  • map + lambda: Functional alternative, often less preferred than list comprehension for readability in this case.
  • Pandas Indexing: Suitable if already using Pandas. Requires Pandas dependency.

For standard Python lists without external libraries, list comprehensions are usually the top choice.

Conclusion​

Selecting multiple elements from a Python list based on their indices can be achieved in several ways.

  • The list comprehension ([my_list[i] for i in indices]) provides a concise and idiomatic Python solution.
  • operator.itemgetter offers a functional alternative.
  • If using numerical libraries, NumPy's array indexing (np_array[indices]) is highly efficient.

Choose the method that best balances readability, performance, and the dependencies of your project.

Table of Contents