# Lists

## Overview

Teaching:10 min

Exercises:10 minQuestions

How can I store multiple values?

Objectives

Explain why programs need collections of values.

Write programs that create flat lists, index them, slice them, and modify them through assignment and method calls.

## A list stores many values in a single structure.

- Doing calculations with a hundred variables called
`pressure_001`

,`pressure_002`

, etc., would be at least as slow as doing them by hand. - Use a
*list*to store many values together.- Contained within square brackets
`[...]`

. - Values separated by commas
`,`

.

- Contained within square brackets
- Use
`len`

to find out how many values are in a list.

```
teen_primes = [12, 13, 17, 23]
```

## Use an item’s index to fetch it from a list.

- Just like strings.

```
print(len(teen_primes))
print(teen_primes[1])
print(teen_primes[1:3])
```

```
4
13
[13, 17]
```

## Strings vs Lists: Character strings are immutable.

- Cannot change the characters in a string after it has been created.
*Immutable*: can’t be changed after creation.- In contrast, lists are
*mutable*: they can be modified in place.

- Python considers the string to be a single value with parts, not a collection of values.

```
element = 'carbon'
element[0] = 'C'
```

```
TypeError: 'str' object does not support item assignment
```

- Lists and character strings are both
*collections*.

## Lists’ values can be replaced by assigning to them.

- Use an index expression on the left of assignment to replace a value.

```
teen_primes[0] = 12
print('teen_primes is now:', teen_primes)
```

```
teen_primes is now: [11, 13, 17, 23]
```

## Appending items to a list lengthens it.

- Use
`list_name.append`

to add items to the end of a list.

```
primes = [2, 3, 5]
print('primes is initially:', primes)
primes.append(7)
primes.append(9)
print('primes has become:', primes)
```

```
primes is initially: [2, 3, 5]
primes has become: [2, 3, 5, 7, 9]
```

`append`

is a*method*of lists.- Like a function, but tied to a particular object.

- Use
`object_name.method_name`

to call methods.- Deliberately resembles the way we refer to things in a library.

- We will meet other methods of lists as we go along.
- Use
`help(list)`

for a preview.

- Use
`extend`

is similar to`append`

, but it allows you to combine two lists. For example:

```
teen_primes = [11, 13, 17, 19]
middle_aged_primes = [37, 41, 43, 47]
print('primes is currently:', primes)
primes.extend(teen_primes)
print('primes has now become:', primes)
primes.append(middle_aged_primes)
print('primes has finally become:', primes)
```

```
primes is currently: [2, 3, 5, 7, 9]
primes has now become: [2, 3, 5, 7, 9, 11, 13, 17, 19]
primes has finally become: [2, 3, 5, 7, 9, 11, 13, 17, 19, [37, 41, 43, 47]]
```

Note that while `extend`

maintains the “flat” structure of the list, appending a list to a list makes the result two-dimensional.

## Use `del`

to remove items from a list entirely.

`del list_name[index]`

removes an item from a list and shortens the list.- Not a function or a method, but a statement in the language.

```
print('primes before removing last item:', primes)
del primes[4]
print('primes after removing last item:', primes)
```

```
primes before removing last item: [2, 3, 5, 7, 9]
primes after removing last item: [2, 3, 5, 7]
```

## The empty list contains no values.

- Use
`[]`

on its own to represent a list that doesn’t contain any values.- “The zero of lists.”

- Helpful as a starting point for collecting values (which we will see in the next episode).

## Lists may contain values of different types.

- A single list may contain numbers, strings, and anything else.

```
goals = [1, 'Create lists.', 2, 'Extract items from lists.', 3, 'Modify lists.']
```

## Indexing beyond the end of the collection is an error.

- Python reports an
`IndexError`

if we attempt to access a value that doesn’t exist.- This is a kind of runtime error.
- Cannot be detected as the code is parsed because the index might be calculated based on data.

```
print('99th element of element is:', element[99])
```

```
IndexError: string index out of range
```

## Fill in the Blanks

Fill in the blanks so that the program below produces the output shown.

`values = ____ values.____(1) values.____(3) values.____(5) print('first time:', values) values = values[____] print('second time:', values)`

`first time: [1, 3, 5] second time: [3, 5]`

## How Large is a Slice?

If ‘low’ and ‘high’ are both non-negative integers, how long is the list

`values[low:high]`

?

## From Strings to Lists and Back

Given this:

`print('string to list:', list('tin')) print('list to string:', ''.join(['g', 'o', 'l', 'd']))`

`['t', 'i', 'n'] 'gold'`

- Explain in simple terms what
`list('some string')`

does.- What does
`'-'.join(['x', 'y'])`

generate?

## Working With the End

What does the following program print?

`element = 'helium' print(element[-1])`

- How does Python interpret a negative index?
- If a list or string has N elements, what is the most negative index that can safely be used with it, and what location does that index represent?
- If
`values`

is a list, what does`del values[-1]`

do?- How can you display all elements but the last one without changing
`values`

? (Hint: you will need to combine slicing and negative indexing.)

## Stepping Through a List

What does the following program print?

`element = 'fluorine' print(element[::2]) print(element[::-1])`

- If we write a slice as
`low:high:stride`

, what does`stride`

do?- What expression would select all of the even-numbered items from a collection?

## Slice Bounds

What does the following program print?

`element = 'lithium' print(element[0:20]) print(element[-1:3])`

## Sort and Sorted

What do these two programs print? In simple terms, explain the difference between

`sorted(letters)`

and`letters.sort()`

.`# Program A letters = list('gold') result = sorted(letters) print('letters is', letters, 'and result is', result)`

`# Program B letters = list('gold') result = letters.sort() print('letters is', letters, 'and result is', result)`

## Copying (or Not)

What do these two programs print? In simple terms, explain the difference between

`new = old`

and`new = old[:]`

.`# Program A old = list('gold') new = old # simple assignment new[0] = 'D' print('new is', new, 'and old is', old)`

`# Program B old = list('gold') new = old[:] # assigning a slice new[0] = 'D' print('new is', new, 'and old is', old)`

## Key Points

A list stores many values in a single structure.

Use an item’s index to fetch it from a list.

Lists’ values can be replaced by assigning to them.

Appending items to a list lengthens it.

Use

`del`

to remove items from a list entirely.The empty list contains no values.

Lists may contain values of different types.

Character strings can be indexed like lists.

Character strings are immutable.

Indexing beyond the end of the collection is an error.