Gdtyjr

list = ["a", "b", "c", "d"]
print(list[3]) # Number 3 is "d"

print(list[-4]) # Number -4 is "a"

To explain it in another way, because -0 is equal to 0, if backward starts from 0, it is ambiguous to the interpreter.

If you are confused about -, and looking for another way to index backwards more understandably, you can try ~, it is a mirror of forward:

arr = ["a", "b", "c", "d"]
print(arr[~0]) # d
print(arr[~1]) # c

The typical usages for ~ are like "swap mirror node" or "find median in a sort list":

def reverse(arr):
 for i in range(len(arr)//2):
 arr[i], arr[~i] = arr[~i], arr[i]

def median(arr):
 mid = len(arr) // 2
 return (arr[mid] + arr[~mid]) / 2

~ actually is a math trick of inverse code and complement code, and it is more easy to understand in some situations.

Discussion about whether should use python tricks like ~:

In my opinion, if it is a code maintained by yourself, you can use any trick to avoid potential bug or achieve goal easier, because of maybe a high readability and usability. But in team work, avoid using 'too clever' code, may bring troubles to your co-workers.

For example, here is one concise code from Stefan Pochmann to solve this problem. I learned a lot from his code. But some are just for fun, too hackish to use.

def findStrobogrammatic(self, n):
 nums = n % 2 * list('018') or ['']
 while n > 1:
 n -= 2
 # n < 2 is so genius here
 nums = [a + num + b for a, b in '00 11 88 69 96'.split()[n < 2:] for num in nums]
 return nums

list[-1]

Is short hand for:

list[len(list)-1]

The len(list) part is implicit. That's why the -1 is the last element. That goes for any negative index - the subtraction from len(list) is always implicit

Because -0 in Python is 0.

With 0 you get first element of list and
with -1 you get the last element of the list.

list = ["a", "b", "c", "d"]
print(list[0]) # "a"
print(list[-1]) # "d"

This is the mnemonic method I use. It is just an approach of what is happening, but it works.

Don't think of those as indexes. Think of them as offsets on a circular list.

Let's use the list x = [a,b,c,d,e,f,g,h] as an example. Think about x[2] and x[-2]:

You start at offset zero. If you move two steps forward, you're going from a to b (0 to 1), and them from b to c (1 to 2).

If you move two steps backward, you're going from a to h (0 to -1), and then from h to g (-1 to -2)

Another explanation:

Your finger points to the first element. The index decides how many places you shift your finger to the right. If the number is negative, you shift your finger to the left.

Of course, you cant step to the left from the first element, so the first step to the left wraps around to the last element.