{"id":309,"date":"2021-05-11T15:24:30","date_gmt":"2021-05-11T14:24:30","guid":{"rendered":"https:\/\/glennrowe.net\/programmingpages\/?p=309"},"modified":"2021-05-31T12:14:33","modified_gmt":"2021-05-31T11:14:33","slug":"lists-the-basics","status":"publish","type":"post","link":"https:\/\/glennrowe.net\/programmingpages\/2021\/05\/11\/lists-the-basics\/","title":{"rendered":"Lists: the basics"},"content":{"rendered":"

The Python list<\/code> is a powerful data type with a lot of functionality, so we’ll cover it in several posts. Here we start with some of its basic properties.<\/p>\n

First, it’s important to understand that Python supports four different built-in compound data types: lists, tuples, sets and dictionaries. Each of these has its own set of rules and peculiarities.<\/p>\n

A list is an ordered, mutable collection of data elements. It allows duplicate elements, that is, you can have 2 or more elements of the same datum in a list.<\/p>\n

By\u00a0ordered<\/em>, we mean that the items in a list are stored in a definite order, so that, if we access say the fourth element of the list, it will always be the same datum (unless we’ve modified the list in the meantime). It’s important to note that ‘ordered’ does\u00a0not<\/em> necessarily mean ‘sorted’, so, for example, numeric values in a list need not be in ascending order (although it is possible to sort the items in a list, but that’s a different operation, as we’ll see).<\/p>\n

By\u00a0mutable<\/em>, we mean that the contents of a list can be changed, either by adding or removing elements, or by changing the data stored at an existing list position.<\/p>\n

As Python is a dynamically typed<\/a> language, the elements in a list need not all be of the same data type, so we can mix ints, floats, strings and even other lists as elements within a given list.<\/p>\n

At this stage, it’s useful to play around with lists in the PowerShell<\/a>, so start one up and type ‘python’ at the prompt to enter the Python interpreter.<\/p>\n

A list is specified by typing its elements, separated by commas, between square brackets. For example:<\/p>\n

x = [1,2,2,3,4,4,5]<\/pre>\n
If you now type x<\/code> at the prompt, you’ll just get [1,2,2,3,4,4,5]<\/code> as the response.<\/p>\n
To access a particular element within a list, give the list’s name followed by the element’s position in square brackets. The elements of a list are indexed starting with 0 for the first item, so x[2]<\/code> gives the third element. Typing x[2]<\/code> after the above gives us 2.<\/p>\n
We can use the same notation to change a list element. Try typing x[2] = 'wibble'<\/code> followed by x<\/code>. You’ll see the list is now [1, 2, 'wibble', 3, 4, 4, 5]<\/code>. This illustrates that you can mix data types within a list.<\/p>\n
Now try y = [x, 3.14, -7+4j]<\/code>, and then type y<\/code> to see what y looks like. You’ll see that it is [[1, 2, 'wibble', 3, 4, 4, 5], 3.14, (-7+4j)]<\/code>. The list x<\/code> is now the first element of y<\/code>, followed by the float 3.14 and the complex number -7+4j.<\/p>\n
If you want a single list consisting of the elements of x<\/code> followed by 3.14 and -7+4j, you can use the + operator: z = x + [3.14, -7+4j]<\/code>. If you print out z<\/code>, you’ll see that it is [1, 2, 'wibble', 3, 4, 4, 5, 3.14, (-7+4j)].<\/code> Note that the inner pair of brackets around the first 7 elements is now absent, so all the primitive data elements are part of a single list. If you want to append a list to an existing list, you can use the += operator, as in x += [3.14, -7+4j]<\/code>.<\/p>\n
The number of elements in a list x<\/code> can be obtained using len(x)<\/code>.<\/p>\n
Exercises<\/h2>\n
1. Write a program that generates 10 random floats between 0 and 1 and stores them in a list. Given that, for a list x, the statement x.sort()<\/code> sorts the list into ascending order, print out both the original list and the sorted list. You’ll need the random()<\/code> function from the module random<\/code> to generate the random numbers.<\/p>\nSee answer<\/span>
\n
from random import *\r\nranList = []\r\nfor i in range(10):\r\n    ranList += [random()]\r\nprint('Unsorted list:')\r\nprint(ranList)\r\nranList.sort()\r\nprint('Sorted list:')\r\nprint(ranList)<\/pre>\n<\/div>\n
2. You’ll see from the above exercise that running the sort()<\/code> function on a list replaces the list with its sorted version. If you want to retain the original list as well as have a sorted version of the list, you’ll need to copy the list before you sort it. Investigate the copy()<\/code> function for a list, and modify the above program so that both the original list and its sorted version are present at the end (so you can print them both out after<\/em> doing the sort).<\/p>\nSee answer<\/span>
\n
from random import *\r\nranList = []\r\nfor i in range(10):\r\n    ranList += [random()]\r\nranCopy = ranList.copy()\r\nranList.sort()\r\nprint('Unsorted list:')\r\nprint(ranCopy)\r\nprint('Sorted list:')\r\nprint(ranList)\r\n<\/pre>\n<\/div>\n
Accessing and changing list elements<\/h2>\n
As mentioned above, a single list element can be accessed or changed by specifying its index, as in x[2]<\/code>. We can also use a negative index to count backwards from the end of the list, so x[-2]<\/code> is the second element from the end. When counting backwards, the last element of the list has index -1, the second last by -2 and so on. When counting forwards, the index starts at 0.<\/p>\n
We can also specify a range of indexes from within a list. The notation z[m:n]<\/code> returns a new list containing elements m…n-1 from the original list. With the list z = [1, 2, 'wibble', 3, 4, 4, 5, 3.14, (-7+4j)]<\/code>, z[1:3]<\/code> is the list [2, 'wibble']<\/code> (that is, the elements 1 and 2 from the original list). It’s often confusing that the index n in z[m:n]<\/code> is\u00a0not<\/em> the index of the last element returned; rather it is the index of the element after<\/em> the last element returned.<\/p>\n
This sublist notation has a couple of shorthand versions. The list z[:3]<\/code> returns elements 0 through 2, z[3:]<\/code> returns elements 3 through to the end of the list, and z[:]<\/code> returns a\u00a0copy<\/em> of the entire list (so this is an alternative to the copy()<\/code> function for copying a list).<\/p>\n
You can use negative indexes in sublist expressions, so that z[-3:-1]<\/code> returns sublist starting with the element third from the end and ending with the element\u00a0just before<\/em> the last element (remember that the last element has index -1, and the sublist notation returns elements up to, but not including, the element with the second index).<\/p>\n
If you give an impossible combination of indexes, such as z[4:2]<\/code>, you just get back an empty list (rather than an error message, so be careful!). Also, if one of the indexes in a sublist is out of range (that is, no such element exists) you’ll still get a valid list returned, rather than an error. Specifying a\u00a0single<\/em> list element that is out of range, however,\u00a0will<\/em> give you an error. It can all be somewhat confusing, so just take care!<\/p>\n
A slice of a list can be modified using the colon notation. Consider the following:<\/p>\n
xList = []\r\nfor x in range(10):\r\n    xList += [x * x]\r\nprint(xList)\r\n\r\nxList[3:5] = ['a', 'b', 'c', 'd']\r\nprint(xList)\r\n\r\nxList[5:6] += [1.2, 2.4, 4.5]\r\nprint(xList)<\/pre>\n
The first print statement gives us a list of squares from 0 to 9: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]. The expression xList[3:5] = ['a', 'b', 'c', 'd']<\/code> replaces list elements 3 and 4 with [‘a’, ‘b’, ‘c’, ‘d’], so xList<\/code> is now [0, 1, 4, ‘a’, ‘b’, ‘c’, ‘d’, 25, 36, 49, 64, 81]. Note that when replacing a slice of a list with another list, the numbers of elements in the two lists need not be the same. In this example, we replaced 2 elements with 4 elements, so the new list expanded by 2 elements.<\/p>\n
We can use the +=<\/code> operator to add some elements to a location in the list, as the last example above shows. In this case the location 5 (currently the element ‘c’) has elements [1.2, 2.4, 4.5] added to it, so the new list is now [0, 1, 4, ‘a’, ‘b’, ‘c’, 1.2, 2.4, 4.5, ‘d’, 25, 36, 49, 64, 81].<\/p>\n
Exercise<\/h2>\n
In the last example above, since we are adding elements to a particular location in the list, you might think we could replace xList[5:6] += [1.2, 2.4, 4.5]<\/code> with xList[5] += [1.2, 2.4, 4.5]<\/code>. Try it, and explain why it doesn’t work.<\/p>\nSee answer<\/span>
\n
While xList[5:6]<\/code> refers to a slice of a list, the expression xList[5]<\/code> refers to a single element within the list, so its data type is whatever the data type of that element is. In this case, xList[5]<\/code> is ‘c’ (a string), so the expression xList[5] += [1.2, 2.4, 4.5]<\/code> attempts to concatenate a string with a list of floats, which isn’t a valid operation.<\/p>\n<\/div>\n
The double colon operator<\/h2>\n
The single-colon version of list slicing discussed above has a more general form, in which we can specify not only the start and end points of the slice, but also the step size to be used when selecting elements in the slice. Consider the following:<\/p>\n
xList = []\r\nfor x in range(10):\r\n    xList += [x * x]\r\nprint(xList)\r\n\r\nprint(xList[2:6:2])\r\n\r\nprint(xList[-2:3:-1])\r\n\r\nprint(xList[-2:-3:-1])\r\n\r\nprint(xList[::-1])<\/pre>\n
We start with a list of squares from 0 to 9 as before, so xList<\/code> starts as [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]. The expression xList[2:6:2]<\/code> starts at location 2 and ends at location 6-1=5, but proceeds in steps of 2, so elements 2 and 4 are selected. The resulting list is therefore [4, 16].<\/p>\n
The second example xList[-2:3:-1]<\/code> starts at location -2, which is the second element from the end, and proceeds to the element just before 3, in steps of -1. The slice therefore proceeds backwards, starting at element xList[8]<\/code>. The ‘element just before 3’ in this context is the last element we encounter when counting down<\/em> to 3, so it is element 4, which is xList[4]<\/code>, or 16. Thus xList[-2:3:-1]<\/code> gives us the list [64, 49, 36, 25, 16].<\/p>\n
The third example xList[-2:-3:-1]<\/code> again starts at the second-to-last element (element 8) and counts down in steps of 1, but ends at the element just before the third-to-last element (element 7). Thus this list contains only one element, which is xList[8]<\/code>, so we have [64].<\/p>\n
The last example xList[::-1]<\/code> contains only a step size of -1, meaning we step backwards through the list. When either the start or stop index is missing, the default value is to take the location that maximizes the portion of the list that is traversed. In this case, since neither start nor stop is specified, the entire list is processed, and, since we step backwards, this gives us the list in reverse order, so we have [81, 64, 49, 36, 25, 16, 9, 4, 1, 0].<\/p>\n
Exercise<\/h2>\n
Predict (without running the code) what each print statement will print in the following code:<\/p>\n
xList = []\r\nfor x in range(10):\r\n    xList += [x * x]\r\nprint(xList)\r\n\r\nprint(xList[5::-1])\r\n\r\nprint(xList[:5:-1])\r\n\r\nprint(xList[2:2:1])\r\n\r\nprint(xList[-2:2:1])\r\n\r\nprint(xList[-8:-3:2])\r\n\r\nprint(xList[::1])<\/pre>\nSee answer<\/span>