Python lists are one of the most important parts of the language. They’re functionally similar to the arrays found in other programming languages. However, a Python list is often far more flexible and easy to work with than other language’s arrays. This often means that we have multiple options for even fundamental procedures such as finding the last element in a list.
OurList = ["It's", "time", "to", "start", "working", "with", "Python", "lists"]
lastElement = OurList[-1]
print('The last element from negative index = ', lastElement)A Python last element in list script can be quite simple thanks to the language’s method of iteration. Python supports negative indexing within lists. This means that the first individual element in the sorted list is 0. However, the last element can be accessed with -1. Once we go into the negatives we essentially begin counting backward. So if we entered the list indexing with -2 we’d have a return string of “Python”.
It’s also important to keep in mind that there’s no need to create a new variable to store the last individual element within the sorted list. We’re simply assigning it to a unique index number variable to make the code more self-explanatory. We could print OurList[-1] just as easily from within the last line.
This is the easiest way to grab the last element of a Python list. But it’s far from the only one. It’s quite common to grab specific elements of a list when working with it in other processes. In those instances, we might want to maintain a single methodology. In the following example we’ll look at how we can grab the last element of a list using list slicing.
OurList = ["It's", "time", "to", "start", "working", "with", "Python", "lists"]
lastElement = OurList[-1:][0]
print('The last element from slice = ', lastElement)We begin by creating the same original list as before and assigning it to OurList in the python program. The next line is where we see two of Python’s powerful features, negative indexing and slice notation, working together. At first glance, it might look like we’re simply assigning an element from the list method to the lastElement in a standard way. But we’re actually using slicing. When we reference list elements using multiple parameters we initiate a slice due to the nature of a list object.
The first element is the starting position. You might recognize why we’re using -1 from the earlier Python code. This starts us off at the -1 position. In other words, it’s the end of the list comprehension. So when we create a slice containing one index value we end up with the last item from the list comprehension. Finally, with that index value assigned to lastElement we can print it to screen from the data structure of the given list.
However, any given Python function can grow in complexity. We might need to find the last single element of a nested list with multiple elements. Thankfully, the list data type makes this fairly simple due to the fact that variable assignment can include programming logic. Consider the following example to see how we can access the final given index for a nested list.
OurList = [["It's", "time", "to", "start"],["working", "with", "Python", "lists"]]
lastElementList = [sublist[-1] for sublist in OurList]
print(lastElementList) We use a variant of the standard OurList that we’ve been working with up to now. The main difference is that we now have two lists contained within a larger given list. The first given list data structure ends with a string, “start”. The second list ends with “lists”.
We create a new list that will contain the final values of both nested lists by doing a quick loop during the initial assignment of lastElementList. This goes over the length of Ourlist and finds the variable in their -1 position. Again, recall that -1 moves to the final element within an original list. On the last line we print out the lastElementList which now contains the final single element of each sublist.