COMP 1000: Think Like a Computer: The PreTeXt Interactive Edition

Strings can be defined as sequential collections of characters. This means that the individual characters that make up a string are in a particular order from left to right.

A string that contains no characters, often referred to as the empty string, is still considered to be a string. It is simply a sequence of zero characters and is represented by ‘’ or “” (two single or two double quotes with nothing in between).

A list is a sequential collection of Python data values, where each value is identified by an index. The values that make up a list are called its elements. Lists are similar to strings, which are ordered collections of characters, except that the elements of a list can have any type and for any one list, the items can be of different types.

There are several ways to create a new list. The simplest is to enclose the elements in square brackets ( [ and ]).

list_of_nums = [10, 20, 30, 40]
bird_list = ["parrot", "dove", "swallow"]

The first example is a list of four integers. The second is a list of three strings. As we said above, the elements of a list don’t have to be the same type. The following list contains a string, a float, an integer, and another list.

list_of_things = ["hello", 2.0, 5, [10, 20]]

A tuple, like a list, is a sequence of items of any type. The printed representation of a tuple is a comma-separated sequence of values, enclosed in parentheses. In other words, the representation is just like lists, except with parentheses () instead of square brackets [].

One way to create a tuple is to write an expression, enclosed in parentheses, that consists of multiple other expressions, separated by commas.

julia = ("Julia", "Roberts", 1967, "Duplicity", 2009, "Actress", "Atlanta, Georgia")

The key difference between lists and tuples is that a tuple is immutable, meaning that its contents can’t be changed after the tuple is created. So, once a tuple is created, it’s not possible to add another value to it, to remove a value from it, or replace any of the values in the tuple.

To create a tuple with a single element (but you’re probably not likely to do that too often), you have to include a comma after the item, because without that comma, Python treats the item as a string, float or integer. For example, in the code below, Python treats (5) as an integer in parentheses, but treats (5,) as a tuple:

You might wonder why anyone would create a tuple - what’s the point of data that can’t be changed? Tuples are often used for exactly that purpose - to create data that can’t be accidentally tampered with. For really important information, it may be critical to be able to verify that data was not edited after it was entered/created.

In Chapter 5, we introduced the index operator and how it is used to access elements of a string or list. We review this briefly here - the index operator applies to tuples in the same way.

We use the index operator [] to access an individual element of a string, list, or tuple. The expression inside the square brackets specifies the index and must evaluate to an integer (the 3.75th element of a list doesn’t make any sense!). Remember that indices start at 0. Any integer expression can be used as an index and a negative index value will locate items from the right instead of from the left.

While we are taught as children to count from 1, in most programming languages we count/index from zero. This means that when we talk about the first item, we need to remember that is at index 0, and when we talk about the second item, it is at index 1. The nth character and the character AT INDEX n are different then: The nth character is at index n-1. Make sure you are clear on what you mean! If you find indexing from zero weird, it might help to think about the index as the offset from the first position in the list, tuple, or string. So if we declare a string variable like this: greeting = "hello", the letter ‘e’ is offset by 1 from the first character and we access the ‘e’ by using greeting[1].

A different way to build a list is to add items to it one at a time using the append method, like this:

You can also use append to add more items to an existing list. New items are added on to the end of the list:

You can remove items from a list using the remove() method, but you have to make sure the item is in the list before you remove it, otherwise, you will get an error:

Note that if the item you want to remove is in the list multiple times, the remove method will only remove the first instance of the item:

There is one other useful method on lists: pop(). Pop removes an item from the end of a list (if you want that item, you need to capture it into a return variable). For example:

It is important to remember that append(), pop(), and remove() only apply to lists, because only lists can be changed. You cannot call append() or remove() or pop() on a tuple or on a string.