3 cool things you can do with Python indexing

You can do so much with slicing and indexing in Python! Here are some of my favorite tricks:

1. Easily grab values from the end of a list

If you have a list say animals = ['cat', 'dog', 'squirrel','mouse','dolphin'] and you want to grab the last value you could use animals[len(animals - 1)].

However, Python offers you a way to easily access values from the other end of the list with negative indices:

animals = ['cat', 'dog', 'squirrel','mouse','dolphin']

animals[-1] -> 'dolphin'
animals[-2] -> 'mouse'
animals[-5] -> 'cat'

2. Reverse a list

If you want to reverse a list you could use a for loop or the built-in reversed() method...

OR... you can use Python slicing and negative indices:

num_list = [4, 6, 3, 2, 1]
reversed_num_list = num_list[::-1]
print(reversed_num_list) -> [1,2,3,6,4]

One thing to remember is that slicing returns a new list, so using [::-1] will return a new list and it doesn't modify the original list. This also applies to the next trick!

3. Skip every n-th element is a list

If you have a list and you want to select every other element in it, Python easy way to do this is:

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
num_list[::2] -> [1, 3, 5, 7, 9]

Let's unpack what's going on in here:

• ':' tells Python to look at the whole list from start to finish
• ':2' tells Python to skip every other element of the list

You can customize this by providing the start and the steps to skip:

num_list[3::2] -> [4, 6, 8]

You can provide the end and the steps to skip:

num_list[:6:2] -> [1, 3, 5]

Or by providing the start, end and the steps to skip:

num_list[3:-2:2] -> [4,6]

You can even combine it with the previous tip and reverse your list whilst skipping elements!

num_list[::-2] -> [9, 7, 5, 3, 1]
num_list[-2::-2] -> [8, 6, 4, 2]

Of course, this is just a short list of python’s capabilities, but these are the things that impressed me the most when I started learning.

I encourage you to play around with the indices and slicing as this is the best way to get familiar and comfortable with them!

---

Thanks for reading! If you want you can follow me here or on Twitter

Comments

[David Griffin]

Two important things: Firstly, the second two examples are slicing, not indexing.

Second off, slicing doesn't quite work how you think it does (assuming you think x[::-1] == reversed(x), which your post seems to imply). Creating a slice creates a copy of that list segment. Pythons memory model means you don't copy the contents itself, but you're creating more references to the objects in the copy at around 28 bytes an element. So if you're memory constrained, or working with really big lists, you should probably use generators - like reversed (because reversed(x) != x[::-1]; they're not even the same type).

[Maria]

Thank you for your observations! I didn't mean to imply that think x[::-1] == reversed(x), just that reversed is another way to reverse a list. It completely escaped my mind that slicing creates new lists, I've edited the post to include it :)

[MxL Devs]

An interesting syntax. Feels like something I'd only use for code golfing though lol. What's the performance comparison between using reverse, or using a standard for loop

[Maria]

Haha yeah on a regular basis I only use negative indexes to grab the last couple values in a list.

That's actually a really good question 🤔 It's 9 pm here so I'll look into it tomorrow and probably write another post it 💪

[MxL Devs]

Negative indexing is a god-send.

In Java, I can't do negative indexing, so I always need to say "length - 1" to get the last element instead of just -1. This becomes annoying because for example if I wanted to split a string into an array and grab the last element (which might not always be the last character for example), I need to store the split results into a variable just so I can access the length, and then subtract 1.

Actually I guess python lists basically store the length as a property, so -1 is possible because you don't need to calculate the length separately.

[Dominik Aksamit]

The article brings me thought about similar solution in javascript.
Of course, there is a serious lack of something like negative indexing (you need access with arr[arr.length -1])
But, proxies come to the rescue!
it's something like a wrapper object for your data give them superpowers. Let me show you a simple example with arrays:

let arr = [4, 6, 3, 2, 1]

const arrProxy = {
  get(target, prop, receiver) {
    if (prop.startsWith('::')) {
      prop = +prop.slice(2)
      if (prop < 0) {
        return target.reverse().filter((n, i) => (i + 1) % prop === 0)
      }
      return target.filter((n, i) => (i + 1) % prop === 0)
    } else if (prop < 0) {
      prop = +prop + target.length
    }
    return Reflect.get(target, prop, receiver)
  },
}
arr = new Proxy(arr, arrProxy)

console.log(arr['::-2']) // [2, 6]
console.log(arr[-1]) // 1

arrProxy applies an internal method that gives an ability to do more with your objects.
the prop is always a string, so we need to convert it into a number.
Another caveat - In js ':' is the invalid syntax in this case so wrapping '::-2' in quotes as string

More about proxy:

• javascript.info/proxy
• developer.mozilla.org/en-US/docs/W...

[Maria]

That's a really nice workaround to use slicing and negative indexes in JavaScript! I do wish sometimes that js array would be as neat to work with as python lists haha

[Dominik Aksamit]

Maybe someday :)
Generally, proxies are a really interesting way to enhance javascript objects and arrays and use them in a way we didn't even imagine what is possible :D

[George Offley]

This is a great find. A lot of this people see some of this in interview questions. Nice work!

[Maria]

Thank you!