Lists and tuples

Why should we use lists?

Sometimes we may end up doing something like this.

name1 = 'wub_wub'
name2 = 'theelous3'
name3 = 'RubyPinch'
name4 = 'go|dfish'
name5 = 'Nitori'

name = input("Enter your name: ")
if name == name1 or name == name2 or name == name3 or name == name4 or name == name5:
    print("I know you!")
else:
    print("Sorry, I don't know who you are :(")

This code works just fine, but there’s a problem. The name check is repetitive, and adding a new name requires adding even more repetitive, boring checks.

Our first list

Instead of adding a new variable for each name it might be better to store all names in one variable.

This means that our one variable needs to point to multiple values. An easy way to do this is using a list:

names = ['wub_wub', 'theelous3', 'Nitori', 'RubyPinch', 'go|dfish']

Here the names variable points to a list, which then points to strings, like this:

What can we do with lists?

Let’s open the >>> prompt and create a name list.

>>> names = ['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
>>> names
['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
>>>

There’s many things we can do with strings, and some of these things also work with lists.

>>> len(names)   # len is short for length, we have 5 names
5
>>> names + ['Akuli']   # create a new list with me in it
['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori', 'Akuli']
>>> ['theelous3', 'RubyPinch'] * 2    # repeating
['theelous3', 'RubyPinch', 'theelous3', 'RubyPinch']
>>>

With strings indexing and slicing both returned a string, but with lists we get a new list when we’re slicing and an element from the list if we’re indexing.

>>> names[:2]    # first two names
['wub_wub', 'theelous3']
>>> names[0]     # the first name
'wub_wub'
>>>

If we want to check if the program knows a name all we need to do is to use the in keyword.

>>> 'lol' in names
False
>>> 'RubyPinch' in names
True
>>>

We can’t use this for checking if a list of names is a part of our name list.

>>> ['RubyPinch', 'go|dfish'] in names
False
>>> ['RubyPinch'] in names
False
>>>

Lists have a few useful methods.

Some of the most commonly used ones are append, extend and remove.

append adds an item to the end of a list, extend adds multiple items from another list and remove removes an item.

>>> names
['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
>>> names.remove('theelous3')  # sorry theelous3
>>> names.remove('go|dfish')   # and sorry go|dfish
>>> names
['wub_wub', 'RubyPinch', 'Nitori']
>>> names.append('Akuli')    # let's add me here
>>> names
['wub_wub', 'RubyPinch', 'Nitori', 'Akuli']
>>> names.extend(['go|dfish', 'theelous3'])  # wb guys
>>> names
['wub_wub', 'RubyPinch', 'Nitori', 'Akuli', 'go|dfish', 'theelous3']
>>>

Note that remove removes only the first match it finds.

>>> names = ['theelous3', 'go|dfish', 'theelous3']
>>> names.remove('theelous3')
>>> names    # the second theelous3 is still there!
['go|dfish', 'theelous3']
>>>

If we need to remove all matching items we can use a simple while loop.

>>> names = ['theelous3', 'go|dfish', 'theelous3']
>>> while 'theelous3' in names:
...     names.remove('theelous3')
...
>>> names
['go|dfish']
>>>

Another useful thing about lists is list comprehension.

It’s a handy way to construct a list in single line. It often makes code cleaner, shorter and easier to read.

>>> numbers = [1,2,3,4,5]
>>> numbers_squared = [number ** 2 for number in numbers]
>>> numbers_squared
[1, 4, 9, 16, 25]
>>>

Without a list comprehension, doing the same thing looks like this:

>>> numbers = [1,2,3,4,5]
>>> numbers_squared = []
>>> for number in numbers:
...     numbers_squared.append(number**2)
>>> numbers_squared
[1, 4, 9, 16, 25]
>>>

We can also use slicing and indexing to change the content:

>>> names = ['theelous3', 'LOL', 'RubyPinch', 'go|dfish', 'Nitori']
>>> names[1] = 'wub_wub'   # replace LOL with wub_wub
>>> names
['theelous3', 'wub_wub', 'RubyPinch', 'go|dfish', 'Nitori']
>>>

As you can see, list can be changed in-place. In other words, they are mutable. Integers, floats, strings and many other built-in types can’t, so they are immutable.

With strings we did something to them and then set the result back to the same variable, like message = message.strip().

This just doesn’t work right with most mutable things because they’re designed to be changed in-place.

>>> names = names.remove('Akuli')
>>> print(names)     # now it's None!
None
>>>

This is the same thing that happened way back when we assigned
print’s return value to a variable.

What is what?

After working with lists a while you’ll find out that they behave like this:

>>> a = [1, 2, 3]
>>> b = a
>>> b.append(4)
>>> a    # this changed also!
[1, 2, 3, 4]
>>>

This can be confusing at first, but it’s actually easy to explain. The problem with this code example is the b = a line.

This is when the is keyword comes in. It can be used to check if two variables point to the same thing.

>>> a is b
True
>>>

Typing [] creates a new list every time.

>>> [] is []
False
>>> [1, 2, 3] is [1, 2, 3]
False
>>>

If we need a new list with similar content we can use the copy method.

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b is a
False
>>> b.append(4)
>>> b
[1, 2, 3, 4]
>>> a
[1, 2, 3]
>>>

If we draw a picture of our variables in this example it looks like this:

Tuples

Tuples are a lot like lists, but they’re immutable so they can’t be changed in-place. We create them like lists, but with () instead of [].

>>> thing = (1, 2, 3)
>>> thing
(1, 2, 3)
>>> thing = ()
>>> thing
()
>>>

If we need to create a tuple that contains only one item we need to use (item,) instead of (item) because (item) is used in places like (1 + 2) * 3.

>>> (3)
3
>>> (3,)
(3,)
>>> (1 + 2) * 3
9
>>> (1 + 2,) * 3
(3, 3, 3)
>>>

It’s also possible to create tuples by just separating things with commas and adding no parentheses. Personally I don’t like this feature, but some people like to do it this way.

>>> 1, 2, 3
(1, 2, 3)
>>> 'hello',
('hello',)
>>>

Tuples don’t have methods like append, extend and remove because they can’t change themselves in-place.

>>> stuff = (1, 2, 3)
>>> stuff.append(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>>

Summary

• Lists are a way to store multiple values in one variable.
• Lists can be changed in-place and they have methods that change them in-place, like append, extend and remove.
• Slicing lists returns a new list, and indexing them returns an item from them.
• thing = another_thing does not create a copy of another_thing.
• Tuples are like lists, but they can’t be changed in-place. They’re also used in different places.

Examples

Here’s the same program we had in the beginning of this tutorial, but using a list:

namelist = ['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']

name = input("Enter your name: ")
if name in namelist:
    print("I know you!")
else:
    print("Sorry, I don't know who you are :(")