# Lecture 8 — Lists Part 1¶

## Overview¶

- So far we’ve looked at working with individual values and variables.
- This is cumbersome even for just two or three variables.
- We need a way to aggregate multiple values and refer to them using a single variable.
- We have done a little bit of this with tuples and strings, but now we are going to get started for real.

Reading: This class meeting and the next are based on Chapter 5 of
*Practical Programming*.

## Lists are Sequences of Values¶

Gather together values that have common meaning, very much like tuples but much more useful – you’ll see why soon!

As a first example, here are scores of 7 judges for the free skating part of a figure skating competition:

scores = [ 59, 61, 63, 63, 68, 64, 58 ]

As a second example, here are the names of the planets in the solar system (including Pluto, for now):

planets = [ 'Mercury', 'Venus', 'Earth', 'Mras', 'Jupiter', 'Saturn', 'Neptune', 'Uranus', 'Pluto' ]

Notes on syntax:

- Begin with
`[`

and end with`]`

- Commas separate the individual values
- The spaces between values are optional and are used for clarity here.
- Any type of object may be stored in a list, and each list can mix different types.

- Begin with

## Why bother?¶

- Gather common values together, providing them with a common name,
**especially**when we don’t know how many values we will have. - Apply an operation to the values as a group.
- Apply an operation to each value in the group.
- Examples of computations on lists:
- Average and standard deviation
- Which values are above and below the average
- Correct mistakes
- Remove values (Pluto)
- Look at differences

- Watch for these themes throughout this lecture and the next.

## Accessing Individual Values — Indexing¶

Notice that we made the mistake in typing

`'Mras'`

. How do we fix this? We’ll start by looking at*indexing*.The line

>>> print planets[1]

accesses and prints the string at what’s known as index 1 of the list

`planets`

. This is similar to tuples!Each item / value in the list is associated with a unique index

Indexing in Python (and most other programming languages) starts at 0.

The notation is again to use

`[`

and`]`

with an integer (non-negative) to indicate which list item.What is the last index in

`planets`

?- We can find the length using
`len()`

and then figure out the answer.

- We can find the length using

## A Memory Model for Lists¶

We’ll draw a memory model in class that illustrates the relationship among

- The name of the list
- The indices
- The values stored in the list

## Part 1 Exercises¶

- Make a list involving the first five names you can think of and
assign this to the variable
`names`

. - What is the index of the first value in
`scores`

that is greater than 65? - Write a line of Python code to print this value and to print the previous and next values of the list.
- What is the index of the middle value in a list that is odd length? For even length lists, what are the indices of the middle two values?

## Changing Values in the List¶

Once we know about indexing, changing a value in a list is easy:

>>> planets[3] = 'Mars'

This replaces item 3 of

`planets`

with the string`'Mars'`

Now we can check the output:

>>> print planets

to make sure we got it right.

## All Indices Are Not Allowed¶

If

`t`

is a list, then the items are stored at indices from 0 to`len(t)-1`

.If you try to access indices at

`len(t)`

or beyond, you get a run-time error. We’ll take a look and see.If you access negative indices, interesting things happen:

>>> print planets[-1] Pluto

More specifically, for any list

`t`

, if`i`

is an index from 0 to`len(t)-1`

then`t[i]`

and`t[i-len(t)]`

are the same spot in the list.

## Functions on Lists: Computing the Average¶

There are many functions (methods) on lists. We can learn all about them using the

`help`

command.This is just like we did for strings and for modules, e.g.

>>> import math >>> help(math) >>> help(str)

Interestingly, we can run help in two ways, one

help(list)

gives us the list methods, and the second

help(planets)

tells us that

`planets`

is a list before giving us list methods.First, let’s see some basic functions on the list values.

The basic functions

`max`

,`sum`

and`min`

may be applied to lists as well.This gives us a simple way to compute the average of our list of scores.

>>> print "Average Scores = %.2f" %(sum(scores) / float(len(scores))) Average Scores = 62.29 >>> print "Max Score =", max(scores) Max Score = 68 >>> print "Min Score =", min(scores) Min Score = 58

Exploring, we will look at what happens when we apply

`sum`

,`max`

and`min`

to our list of planet names. Can you explain the result?

## Functions that modify the input: Sorting a list¶

We can also sort the values in a list by sorting it. Let’s try the following:

>>> planets = [ 'Mercury', 'Venus', 'Earth', 'Mras', 'Jupiter', \ 'Saturn', 'Neptune', 'Uranus', 'Pluto' ] >>> planets ['Mercury', 'Venus', 'Earth', 'Mras', 'Jupiter', 'Saturn', 'Neptune', 'Uranus', 'Pluto'] >>> planets.sort() >>> planets ['Earth', 'Jupiter', 'Mercury', 'Mras', 'Neptune', 'Pluto', 'Saturn', 'Uranus', 'Venus']

Note that we did not assign the value returned by sort to a new variable. This is the second function we have learned that modifies the input but returns nothing. (The first one was

`Image.paste`

). Try the following and see what happens:>>> scores = [ 59, 61, 63, 63, 68, 64, 58 ] >>> new_scores = scores.sort() >>> scores [58, 59, 61, 63, 63, 64, 68] >>> new_scores >>>

- Ok, what is the value of the variable
`new_scores`

? It is unclear. Let’s try in a different way.

>>> print scores [58, 59, 61, 63, 63, 64, 68] >>> print new_scores None >>>

- Ok, what is the value of the variable
So, the function returns nothing! But, it does change the value of the input list. This is the first such function we have seen.

It does so because lists are containers, and functions can manipulate what is inside containers. Functions cannot do so for simple types like integer and float.

## More Functions: Appending Values, Inserting Values, Deleting¶

- Now, we will see more functions that can change the value of a list without returning anything.
- Armed with this knowledge, we can figure out how to add and remove
values from a list:
`append()`

`insert()`

`pop()`

`remove()`

- These operations are fundamental to any “container” — an object type
that stores other objects.
- Lists are our first example of a container

## Lists of Lists¶

Note that lists can contain any mixture of values, including other lists.

For example, in

>>> L = [ 'Alice', 3.75, ['MATH', 'CSCI', 'PSYC' ], 'PA' ]

`L[0]`

is the name,`L[1]`

is the GPA`L[2]`

is a list of courses`L[2][0]`

is the 0th course,`'MATH'`

`L[3]`

is a home state abbreviation

We will write code to print the courses, to change the math course to a stats course, and to append a zipcode.

## Exercises¶

- Write three different ways of removing the last value —
`'Pluto'`

— from the list of planets. Two of these will use the method`pop`

. - Write code to insert
`'Asteroid belt'`

between`'Mars'`

and`'Jupiter'`

.

## Summary¶

- Lists are sequences of values, allowing these values to be collected and processed together.
- Individual values can be accessed and changed through indexing.
- Functions and methods can be used to
**return**important properties of lists like`min()`

,`max()`

,`sum()`

. - Functions and methods can be also used to
**modify**lists, but not return anything.