**To extract elements with specific indices from a Python list, use slicing list[start:stop:step]. If you cannot use slicing because there’s no pattern in the indices you want to access, use the list comprehension statement [lst[i] for i in indices], assuming your indices are stored in the variable indices.**

People always want to know the most Pythonic solution to a given problem. This tutorial shows you the most Pythonic solution(s) to the following problem:

**Problem**: How to extract elements with specific indices from a Python list?

**Example**: You’ve got the following elements.

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

You want to create a new list of elements with `indices = [0, 2, 6]`

in the original list:

['a', 'c', 'g']

You can get a quick overview of the most Pythonic methods in our interactive Python shell:

**Exercise**: Run the code shell. Now, try to access the element with index 7 as well in each of the given methods!

## Method 1: List Comprehension

A simple, readable, and efficient way is to use list comprehension that’s a compact way of creating lists. The simple formula is `[expression + context]`

.

**Expression**: What to do with each list element?**Context**: What elements to select? The context consists of an arbitrary number of`for`

and`if`

statements.

Here’s the code that creates a new list that contains the elements at specific indices (e.g., 0, 2, and 6) in the original list:

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] indices = [0, 2, 6] out = [lst[i] for i in indices] print(out) # ['a', 'c', 'g']

In most cases, this will be the best solution because you don’t need any library and it’s still short and readable. However, if you need to do this multiple times, it may be better to import the NumPy library:

## Method 2: NumPy Array Indexing

Python’s library for numerical computations, NumPy, is one of the most powerful tools in your toolbelt—especially if you work as a data scientist. Here’s how you can use NumPy to access arbitrary indices, given a sequence of specific indices:

import numpy as np lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] a = np.array(lst) indices = [0, 2, 6] out = a[indices]

The output is:

print(out) # ['a' 'c' 'g']

You see that NumPy indexing is far more powerful than Python indexing—it allows you to use arbitrary sequences as indices. Especially, if you need to do multiple of those numerical operations, you may want to import the NumPy library once and gain much in readability and conciseness.

**Related resources:**

- Dive into NumPy in our detailed blog tutorial.
- Become a Data Science Master by reading our book “Coffee Break NumPy”.

## Method 3: Itemgetter

The following method can be seen sometimes—using the `itemgetter`

function from the `operator`

module:

from operator import itemgetter lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] indices = [0, 2, 6] out = list(itemgetter(*indices)(lst)) print(out) # ['a', 'c', 'g']

The code performs the following steps:

- Call the
`itemgetter()`

function and pass the arguments 0, 2, and 6. We use the asterisk operator`*`

to unpack the values from the`indices`

variable into the`itemgetter()`

function. Learn more about the asterisk operator in our detailed blog article. - This returns a new itemgetter function object.
- Call the new itemgetter function object by passing the original list
`lst`

. - The new itemgetter function will now get a tuple of the items at positions 0, 2, and 6 in the original list lst.
- Convert the tuple to a list using the
`list(...`

) built-in Python function.

## Method 4: Manual Indices

Just for comprehensibility, I also want to point out the “naive” way of accessing a few elements in the original list and put them into a new list:

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] out = [lst[0], lst[2], lst[6]] print(out) # ['a', 'c', 'g']

This is a perfectly valid and efficient approach if you have only a few elements to access. For more than, say, five indices, it quickly becomes unhandy though.

## Method 5: Simple Loop

Here’s another approach that’s often used by coders who come from other programming languages such as Java or C++: using simple loops.

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] indices = [0, 2, 6] out = [] for i in indices: out.append(lst[i]) print(out) # ['a', 'c', 'g']

While there’s nothing wrong with this, it looks somehow “brutal” to an advanced coder. If you’d use this method, it would be like shouting into the world that you’re not a very sophisticated Python coder. ๐

Nothing wrong with that—don’t get me wrong! But if you want to increase your level of sophistication in Python, join my free email academy with many Python email courses that will sharpen your skills! Have I already said that it’s free?

## Where to Go From Here?

Enough theory. Letโs get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. Thatโs how you polish the skills you really need in practice. After all, whatโs the use of learning theory that nobody ever needs?

**You build high-value coding skills by working on practical coding projects!**

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

๐ If your answer is ** YES!**, consider becoming a Python freelance developer! Itโs the best way of approaching the task of improving your Python skillsโeven if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar โHow to Build Your High-Income Skill Pythonโ and learn how I grew my coding business online and how you can, tooโfrom the comfort of your own home.

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com that has taught exponential skills to millions of coders worldwide. He’s the author of the best-selling programming books Python One-Liners (NoStarch 2020), The Art of Clean Code (NoStarch 2022), and The Book of Dash (NoStarch 2022). Chris also coauthored the Coffee Break Python series of self-published books. He’s a computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.