[10, 20, 30, 40]\n['crunchy frog', 'ram bladder', 'lark vomit']<\/code><\/pre>\nThe first example is a list of four integers. The second is three strings. The elements of a list don't have to be the same type. The following list contains a string, a float, an integer, and (lo!) another list:<\/p>\n
['spam', 2.0, 5, [10, 20]]<\/code><\/pre>\nA list within another list is nested.<\/p>\n
A list that contains no elements is called an empty list; you can create one with empty brackets, []<\/code>.<\/p>\nAs you might expect, you can assign list values to variables:<\/p>\n
>>> cheeses = ['Cheddar', 'Edam', 'Gouda']\n>>> numbers = [17, 123]\n>>> empty = []\n>>> print(cheeses, numbers, empty)\n['Cheddar', 'Edam', 'Gouda'] [17, 123] []<\/code><\/pre>\nLists are mutable<\/h3>\n
The syntax for accessing the elements of a list is the same as for accessing the characters of a string: the bracket. The expression inside the brackets specifies the index. Remenber that the indices start at 0:<\/p>\n
>>> print(cheeses[0])\nCheddar<\/code><\/pre>\nUnlike strings, lists are mutable because you can change the order of items in a list or reassign an item in a list. When the bracket operate appears on the left side of an assignment, it identifies the element of the list that will be assigned.<\/p>\n
>>> numbers = [17, 123]\n>>> numbers[1] = 5\n>>> print(numbers)\n[17, 5]<\/code><\/pre>\nThe one-th element of numbers<\/code>, which used to be 123, is now 5.<\/p>\nYou can think of a list as a relationship between indices and elements. This relationship is called a mapping, each index "maps to" one of the elements.<\/p>\n
list indices work the same way as string indices:<\/p>\n
\n- \n
Any integer expression can be used as an index.<\/p>\n<\/li>\n
- \n
If you try to read or write an element that does not exist, you get an IndexError<\/code>.<\/p>\n<\/li>\n- \n
If an index has a negative value, it counts backward from the end of the list.<\/p>\n<\/li>\n<\/ul>\n
The in<\/code> operator also works on lists.<\/p>\n>>> cheeses = ['Cheddar', 'Edam', 'Gouda']\n>>> 'Edam' in cheeses\nTrue\n>>> 'Brie' in cheeses\nFalse<\/code><\/pre>\nTraversing a list<\/h3>\n
The most common way to traverse the elements of a list is with a for<\/code> loop. The syntax is the same as for string:<\/p>\nfor cheese in cheeses:\n print(cheese)<\/code><\/pre>\nThis works well if you only need to read the elements of the list. But if you want to write or update the elements, you need the indices. A common way to do that is to combine the functions range<\/code> and len<\/code>:<\/p>\nfor i in range(len(numbers)):\n numbers[i] = numbers[i] * 2<\/code><\/pre>\nThis loop traverses the list and updates each element. len<\/code> returns the number of elements in the list. range<\/code> returns a list of indices from 0 to n-1, where n is the length of the list. Each time through the loop, i<\/code> gets the index of the element. The assignment statements in the body uses i<\/code> to read the old value of the element and to assign the new value.<\/p>\nA for<\/code> loop over a empty list never executes the body:<\/p>\nfor x in empty:\n print('This never happens.')<\/code><\/pre>\nAlthough a list can contain another list, the nested list counts as a single element. The length of this list is four:<\/p>\n
['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]<\/code><\/pre>\nList Operations<\/h3>\n
The +<\/code> operator concatenates lists:<\/p>\n>>> a = [1, 2, 3]\n>>> b = [4, 5, 6]\n>>> c = a + b\n>>> print(c)\n[1, 2, 3, 4, 5, 6]<\/code><\/pre>\nSimilarly, the *<\/code> operator repeats a list a given number of times:<\/p>\n>>> [0] * 4\n[0, 0, 0, 0]\n>>> [1, 2, 3] * 3\n[1, 2, 3, 1, 2, 3, 1, 2, 3]<\/code><\/pre>\nThe first example repeats four times. The second example repeats the list three times.<\/p>\n
List slices<\/h3>\n
The slice operator also works on lists:<\/p>\n
>>> t = ['a', 'b', 'c', 'd', 'e', 'f']\n>>> t[1:3]\n['b', 'c']\n>>> t[:4]\n['a', 'b', 'c', 'd']\n>>> t[3:]\n['d', 'e', 'f']<\/code><\/pre>\nIf you omit the fist index, the slice starts at the beginning. If you omit the second, the slice goes to the end. So if you omit both, the slice is a copy of the whole list.<\/p>\n
>>> t[:]\n['a', 'b', 'c', 'd', 'e', 'f']<\/code><\/pre>\nSince lists are mutable, it is often useful to make a copy before performing operations that fold, spindle, or mutilate lists.<\/p>\n
A slice operator on the left side of an assignment can update multiple elements:<\/p>\n
>>> t = ['a', 'b', 'c', 'd', 'e', 'f']\n>>> t[1:3] = ['x', 'y']\n>>> print(t)\n['a', 'x', 'y', 'd', 'e', 'f']<\/code><\/pre>\nLists methods<\/h3>\n
Python provides methods that operate on lists. For example, append<\/code> adds a new element to the end of a list:<\/p>\n>>> t = ['a', 'b', 'c']\n>>> t.append('d')\n>>> print(t)\n['a', 'b', 'c', 'd']<\/code><\/pre>\nextend<\/code> takes a list as an argument and appends all of the elements:<\/p>\n>>> t1 = ['a', 'b', 'c']\n>>> t2 = ['d', 'e']\n>>> t1.extend(t2)\n>>> print(t1)\n['a', 'b', 'c', 'd', 'e']<\/code><\/pre>\nThis example leaves t2<\/code> unmodified.<\/p>\nsort<\/code> arranges the elements of the list from low to high:<\/p>\n>>> t = ['d', 'c', 'e', 'b', 'a']\n>>> t.sort()\n>>> print(t)\n['a', 'b', 'c', 'd', 'e']<\/code><\/pre>\nMost list methods are void; they modify the list and return None<\/code>. If you accidentally wirt t = t.sort()<\/code>, you will be disappointed with the result.<\/p>\nDeleting elements<\/h3>\n
There are several ways to delete elements from a list. If you know the index of the element you want, you can use pop<\/code>:<\/p>\n>>> t = ['a', 'b', 'c']\n>>> x = t.pop(1)\n>>> print(t)\n['a', 'c']\n>>> print(x)\nb<\/code><\/pre>\npop<\/code> modifies the list and returns the elements that was removed. If you don't provide an index, it deletets and returns the last element.<\/p>\nIf you don't need the removed value, you can use the del<\/code> statement:<\/p>\n>>> t = ['a', 'b', 'c']\n>>> del t[1]\n>>> print(t)\n['a', 'c']<\/code><\/pre>\nIf you know the element you want to remove (but not the index), you can use remove<\/code>:<\/p>\n>>> t = ['a', 'b', 'c']\n>>> t.remove('b')\n>>> print(t)\n['a', 'c']<\/code><\/pre>\nThe return value from remove<\/code> is None<\/code>.<\/p>\nTo remove more than one element, you can use del<\/code> with a slice index:<\/p>\n>>> t = ['a', 'b', 'c', 'd', 'e', 'f']\n>>> del t[1:5]\n>>> print(t)\n['a', 'f']<\/code><\/pre>\nAs usual, the slice selects all the elements up to , but not including, the second index.<\/p>\n
Lists and functions<\/h3>\n
There are a number of built-in functions that can be used on lists that allow you to quickly look through a list without writing your own loops:<\/p>\n
>>> nums = [3, 41, 12, 9, 74, 15]\n>>> print(len(nums))\n6\n>>> print(max(nums))\n74\n>>> print(min(nums))\n3\n>>> print(sum(nums))\n154\n>>> print(sum(nums)\/len(nums))\n25<\/code><\/pre>\nThe sum()<\/code> function only works when the list elements are numbers. The other functions \uff08max()<\/code>, len()<\/code>, etc.) work with lists of strings and other types that can be comparable.<\/p>\nWe could rewrite an earlier program that computed the average of a list of numbers entered by the user using a list.<\/p>\n
First, the program to compute an average without a list:<\/p>\n
total = 0\ncount = 0\nwhile (True):\n inp = input('Enter a number: ')\n if inp == 'done': break\n value = float(inp)\n total = total + value\n count = count + 1\n\naverage = total \/ count\nprint('Average:', average)<\/code><\/pre>\nIn this program, we have count<\/code> and total<\/code> variables to keep the number and running total of the user's numbers as we repeatedly prompt the user for a number.<\/p>\nWe could simply remember each number as the user entered it and use built-in functions to computer the sum and count at the end.<\/p>\n
numlist = list()\nwhile (True):\n inp = input('Enter a number: ')\n if inp == 'done': break\n value = float(inp)\n numlist.append(value)\n\naverage = sum(numlist) \/ len(numlist)\nprint('Average:', average)<\/code><\/pre>\nWe make an empty list before the loop starts, and then each time we have a number, we append it to the list. At the end of the program, we simply compute the sum of the numbers in the list and divide it by the count of the numbers in the list to come up with the average.<\/p>\n
Lists and strings<\/h3>\n
A string is a sequence of characters and a list is a sequence of values, but a list of characters is not the same as a string. To convert from a string to a list of characters, you can use list<\/code>:<\/p>\n>>> s = 'spam'\n>>> t = list(s)\n>>> print(t)\n['s', 'p', 'a', 'm']<\/code><\/pre>\nBecause list<\/code> is the name of a built-in function, you should avoid using it as a variable name. I also avoid the letter "l" because it looks too much like the number "1". So that's I use "t".<\/p>\nThe list<\/code> function breaks a string into individual letters. If you want to break a string into words, you can use the split<\/code> method:<\/p>\n>>> s = 'pining for the fjords'\n>>> t = s.split()\n>>> print(t)\n['pining', 'for', 'the', 'fjords']\n>>> print(t[2])\nthe<\/code><\/pre>\nOnce you have used split<\/code> to break the string into a list of words, you can use the index operator (square bracket) to look at a particular word in the list.<\/p>\nYou can call split<\/code> with an optional argument called a delimiter that specifies which characters to use as word boundaries. The following example uses a hyphen as a delimiter:<\/p>\n>>> s = 'spam-spam-spam'\n>>> delimiter = '-'\n>>> s.split(delimiter)\n['spam', 'spam', 'spam']<\/code><\/pre>\njoin<\/code> is the inverse of split<\/code>. It takes a list of strings and concatenates the elements. join<\/code> is a string method, so you have to invoke it on the delimiter and pass the list as a parameter:<\/p>\n>>> t = ['pining', 'for', 'the', 'fjords']\n>>> delimiter = ' '\n>>> delimiter.join(t)\n'pining for the fjords'<\/code><\/pre>\nIn this case the delimiter is a space character, so join<\/code> puts a space between words. To concatenate strings without spaces, you can use the empty string, "", as a delimiter.<\/p>\nParsing lines<\/h3>\n
Usually when we are reading a file we want to do something to the lines other than just printing the whole line. Often we want to find the "interesting lines" and then parse the line to find some intersting part of the line. What if we wanted to print out the day of the week from those lines that start with "From"?<\/p>\n
From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008<\/code><\/pre>\nThe split<\/code> method is very effective when faced with this kind of problem. We can write a small program that looks for lines where the line starts withe "From", split<\/code> those lines, and then print out the third word in the line:<\/p>\nfhand = open('mbox-short.txt')\nfor line in fhand:\n line = line.rstrip()\n if not line.startswith('From '): continue\n words = line.split()\n print(words[2])<\/code><\/pre>\nThe program produces the following output:<\/p>\n
Sat\nFri\nFri\nFri\n...<\/code><\/pre>\nLater, we will learn increasingly sophisticated techniques for picking the lines to work on and how we pull those lines apart to find the exact bit of information we are looking for.<\/p>\n
Objects and values<\/h3>\n
If we execute these assignment statements:<\/p>\n
a = 'banana'\nb = 'banana'<\/code><\/pre>\nWe know that a<\/code> and b<\/code> both refer to a string, but we don't know whether they refer to the same string. There are two possible states:<\/p>\n![\"file\"](\"\/wp-content\/uploads\/2025\/09\/image-1758704506001.png\")
<\/p>\n
Variables and Objects
\nIn one case, a<\/code> and b<\/code> refer to two different objects that have the same value. In the second case, they refer to the same object.<\/p>\nTo check whether two variables refer to the same object, you can use the is<\/code> operator.<\/p>\n>>> a = 'banana'\n>>> b = 'banana'\n>>> a is b\nTrue<\/code><\/pre>\nIn this example, Python only created one string object, and both a<\/code> and b<\/code> refer to it.<\/p>\nBut when you create two lists, you get two objects:<\/p>\n
>>> a = [1, 2, 3]\n>>> b = [1, 2, 3]\n>>> a is b\nFalse<\/code><\/pre>\nIn this case we would say that the two lists are equivalent, because they have the same elements, but not identical, because they are not the same object. If two objects are identical, they are also equivalent, but if they are equivalent, they are not necessarily identical<\/p>\n
Until now, we have bee using "object" and "value" interchangeably, but it is more precise to say that an object has a value. If you execute a = [1,2,3]<\/code>, a<\/code> refers to a list object whose value is a particular sequece of elements. If another list has the same elements, we would say it has the same value.<\/p>\nAliasing<\/h3>\n
If a<\/code> refers to an object and you assign b = a<\/code>, then both variables refer to the same object:<\/p>\n>>> a = [1, 2, 3]\n>>> b = a\n>>> b is a\nTrue<\/code><\/pre>\nThe association of a variable with an object is called a reference. In this example, there are two references to the same object.<\/p>\n
An object with more than one reference has more than one name, so we say that the object is aliased.<\/p>\n
If the aliased object is mutable, changes made with one alias affect the other:<\/p>\n
>>> b[0] = 17\n>>> print(a)\n[17, 2, 3]<\/code><\/pre>\nAlthough this behavior can be useful, it is error-prone. In general, it is safer to avoid aliasing when you are working with mutable objects.<\/p>\n
For immutable objects like strings, aliasing is not as much of a problem. In this example:<\/p>\n
a = 'banana'\nb = 'banana'<\/code><\/pre>\nIt almost never makes a difference whether a<\/code> and b<\/code> refer to the same string or not.<\/p>\nList arguments<\/h3>\n
When you pass a list to a function, the function gets a reference to the list. If the function modifies a list parameter, the caller sees the change. For example, delete_head<\/code> removes the first element from a list:<\/p>\ndef delete_head(t):\n del t[0]<\/code><\/pre>\nHere's how it is used:<\/p>\n
>>> letters = ['a', 'b', 'c']\n>>> delete_head(letters)\n>>> print(letters)\n['b', 'c']<\/code><\/pre>\nThe parameter t<\/code> and the variable letters<\/code> are aliases for the same object.<\/p>\nIt is important to distinguish between operations that modify lists and operations that create new lists. For example, the append<\/code> method modifies a list, but the +<\/code> operator creats a new list:<\/p>\n>>> t1 = [1, 2]\n>>> t2 = t1.append(3)\n>>> print(t1)\n[1, 2, 3]\n>>> print(t2)\nNone\n\n>>> t3 = t1 + [3]\n>>> print(t3)\n[1, 2, 3]\n>>> t1 is t3\nFalse<\/code><\/pre>\nThis difference is important when you write functions that are supposed to modify lists. For example, this function does not delete the head of a list:<\/p>\n
def bad_delete_head(t):\n t = t[1:] # WRONG!<\/code><\/pre>\nThe slice operator creats a new list and the assignment makes t<\/code> refer to it, but none of that has any effect on the list that was passed as an argument.<\/p>\nAn alternative is to write a function that creates and returns a new list. For example, tail<\/code> returns all but the first element of a list:<\/p>\ndef tail(t):\n return t[1:]<\/code><\/pre>\nThis function leaves the original list unmodified. Here's how it is used:<\/p>\n
>>> letters = ['a', 'b', 'c']\n>>> rest = tail(letters)\n>>> print(rest)\n['b', 'c']<\/code><\/pre>\nExercise 1:<\/strong> Write a function called chop<\/code> that takes a list and modifies it, removing the first and last elements, and returns None<\/code>. Then write a function called middle<\/code> that takes a list and returns a new list that contains all but the first and last elements.<\/p>\ndef chop(t):\n del t[0]\n del t[-1]\nletters = [1,2,3,4,5]\nprint(chop(letters))\nprint(letters)\nNone\n[2, 3, 4]<\/code><\/pre>\ndef middle(t):\n return t[1:-1]\nletters = [1,2,3,4,5]\nprint(middle(letters))\nprint(letters)\n[2, 3, 4]\n[1, 2, 3, 4, 5]<\/code><\/pre>\nDebugging<\/h3>\n
Careless use of lists (and other mutable objects) can lead to long hours of debugging. Here are some common pitfalls and ways to avoid them:<\/p>\n
\n- Don't forget that most list methods modify the argumet and return
None<\/code>. This is the opposite of the string methods, which return a new string and leave the original alone.<\/li>\n<\/ol>\nIf you are used to writing string code like this:<\/p>\n
word = word.strip()<\/code><\/pre>\nIt is tempting to write list code like this:<\/p>\n
t = t.sort() # WRONG!<\/code><\/pre>\nBecause sort<\/code> returns None<\/code>, the next operation you perform with t<\/code> is likely to fail.<\/p>\nBefore using list methods and operators, you should read the documentation carefully and then test them in interactive mode. The methods and operators that lists share with other sequence (like strings) are documented at:<\/p>\n