Yes, calling s[0:-1] is exactly the same as calling s[:-1].
Using a negative number as an index in python returns the nth element from the right-hand side of the list (as opposed to the usual left-hand side).
so if you have a list as so:
myList = ['a', 'b', 'c', 'd', 'e']
print myList[-1] # prints 'e'
the print statement will print "e".
Once you understand that (which you may already, it's not entirely clear if that's one of the things you're confused about or not) we can start talking about slicing.
I'm going to assume you understand the basics of a slice along the lines of myList[2:4] (which will return ['c', 'd']) and jump straight into the slicing notation where one side is left blank.
As you suspected in your post, myList[:index] is exactly the same as myList[0:index].
This is also works the other way around, by the way... myList[index:] is the same as myList[index:len(myList)] and will return a list of all the elements from the list starting at index and going till the end (e.g. print myList[2:] will print ['c', 'd', 'e']).
As a third note, you can even do print myList[:] where no index is indicated, which will basically return a copy of the entire list (equivalent to myList[0:len(myList)], returns ['a', 'b', 'c', 'd', 'e']). This might be useful if you think myList is going to change at some point but you want to keep a copy of it in its current state.
If you're not already doing it I find just messing around in a Python interpreter a whole bunch a big help towards understanding these things. I recommend IPython.
Answer from Redwood on Stack OverflowVideos
Yes, calling s[0:-1] is exactly the same as calling s[:-1].
Using a negative number as an index in python returns the nth element from the right-hand side of the list (as opposed to the usual left-hand side).
so if you have a list as so:
myList = ['a', 'b', 'c', 'd', 'e']
print myList[-1] # prints 'e'
the print statement will print "e".
Once you understand that (which you may already, it's not entirely clear if that's one of the things you're confused about or not) we can start talking about slicing.
I'm going to assume you understand the basics of a slice along the lines of myList[2:4] (which will return ['c', 'd']) and jump straight into the slicing notation where one side is left blank.
As you suspected in your post, myList[:index] is exactly the same as myList[0:index].
This is also works the other way around, by the way... myList[index:] is the same as myList[index:len(myList)] and will return a list of all the elements from the list starting at index and going till the end (e.g. print myList[2:] will print ['c', 'd', 'e']).
As a third note, you can even do print myList[:] where no index is indicated, which will basically return a copy of the entire list (equivalent to myList[0:len(myList)], returns ['a', 'b', 'c', 'd', 'e']). This might be useful if you think myList is going to change at some point but you want to keep a copy of it in its current state.
If you're not already doing it I find just messing around in a Python interpreter a whole bunch a big help towards understanding these things. I recommend IPython.
>>> l = ['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stu', 'vwx', 'yz&']
# I want a string up to 'def' from 'vwx', all in between
# from 'vwx' so -2;to 'def' just before 'abc' so -9; backwards all so -1.
>>> l[-2:-9:-1]
['vwx', 'stu', 'pqr', 'mno', 'jkl', 'ghi', 'def']
# For the same 'vwx' 7 to 'def' just before 'abc' 0, backwards all -1
>>> l[7:0:-1]
['vwx', 'stu', 'pqr', 'mno', 'jkl', 'ghi', 'def']
Please do not become listless about list.
- Write the first element first. You can use positive or negative index for that. I am lazy so I use positive, one stroke less (below 7, or -3 for the start).
- Index of the element just before where you want to stop. Again, you can use positive or negative index for that (below 2 or -8 for stop).
Here sign matters; of course - for backwards; value of stride you know. Stride is a 'vector' with both magnitude and direction (below -1, backwards all).
l = [0,1,2,3,4,5,6,7,8,9] l[7:2:-1], l[-3:2:-1], [-3:-8:-1],l[7:-8:-1]All result in
[7, 6, 5, 4, 3].
You should use in reverse order
a[-4:-1]
# gjo
you should actually use
a[-3:]
# job
if you want to reverse the string
a[-1:-4:-1]
# boj
Slice notation is like this:
a[start:stop:step]
This gets the elements from index start up to (but not including) index stop incremented by step. By default step is 1, so you get an empty string since your start is already bigger than your stop.
Our first step is to fix the order of the indexes:
>>> a[-4:-1]
'gjo'
But this still isn't quite right. For negative indexing, the last character is at index -1, the next to the last at -2, etc. The best way to think about this is to get the last n characters of the string, you need to start at index -n. So let's starting at -3 to get the last three characters:
>>> a[-3:-1]
'jo'
But we are still missing the last character. This is because the last index is not included in the slice. The last fix is to leave out the last index:
>>> a[-3:]
'job'
Leaving out the last index tells python to slice the string until the end of the string.
0 is the start of the sequence. Always, unambiguously. Changing its meaning to sometimes be the end would lead to a lot of confusion, especially when using variables for those two values.
Using negative indices is also not a different mode; negative indices are converted to positive indices relative to the length. Changing what element 0 refers to because the other slice input (start or stop) was a negative number makes no sense.
Because 0 always means the first element of the sequence, and there is no spelling for a negative zero, you cannot use 0 to mean the end of the sequence.
You can use None as the stop element to mean this instead, if you need to parameterise your indices:
start = -3
stop = None
result = a[start:stop]
You can also create a slice() object; the same rules apply for how indices are interpreted:
indices = slice(-3, None)
result = a[indices]
In fact, the interpreter translates the slice notation into a slice() object, which is then passed to the object to distinguish from straight-up indexing with a single integer; the a[start:stop] notation translates to type(a).__getitem__(a, slice(start, stop)) whereas a[42] becomes type(a).__getitem__(a, 42).
So by using a slice() object you can record either slicing or single-element indexing with a single variable.
It is boring to use negative slice in a loop if there is some chance to slice to 'negative zero', because [:-0] is not interpreted as expected.
But there is a simple way to solve the problem, just convert negative index to positive index by adding the length of the container.
E.g. Negative Slice Loop:
a = np.arange(10)
for i in range(5):
print(a[5-i:-i])
Answer:
[]
[4 5 6 7 8]
[3 4 5 6 7]
[2 3 4 5 6]
[1 2 3 4 5]
Convert to positive by adding the lenght:
for i in range(5):
print(a[5-i:len(a)-i])
Get the right answer:
[5 6 7 8 9]
[4 5 6 7 8]
[3 4 5 6 7]
[2 3 4 5 6]
[1 2 3 4 5]