Subsections

# Variables with more than one value

You have already seen ordinary variables that store a single value. However other variable types can hold more than one value. The simplest type is called a list. Here is a example of a list being used:

```which_one = int(input("What month (1-12)? "))
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\
'August', 'September', 'October', 'November', 'December']
if 1 <= which_one <= 12:
print("The month is", months[which_one - 1])
```

and a output example:

```What month (1-12)? 3
The month is March
```

In this example the months is a list. months is defined with the lines months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',`\` 'August', 'September', 'October', 'November', 'December'] (Note that a `\` can be used to split a long line). The `[` and `]` start and end the list with comma's (“`,”`) separating the list items. The list is used in `months[which_one - 1]`. A list consists of items that are numbered starting at 0. In other words if you wanted January you would type in 1 and that would have 1 subtracted off to use months[0]. Give a list a number and it will return the value that is stored at that location.

The statement if 1 <= which_one <= 12: will only be true if which_one is between one and twelve inclusive (in other words it is what you would expect if you have seen that in algebra). Since 1 is subtracted from which_one we get list locations from 0 to 11.

Lists can be thought of as a series of boxes. For example, the boxes created by demolist = ['life', 42, 'the', 'universe', 6, 'and', 7] would look like this:

box number
 0 1 2 3 4 5 6 demolist `life' 42 `the' `universe' 6 `and' 7

Each box is referenced by its number so the statement demolist[0] would get 'life', demolist[1] would get 42 and so on up to demolist[6] getting 7.

# More features of lists

The next example is just to show a lot of other stuff lists can do (for once, I don't expect you to type it in, but you should probably play around with lists until you are comfortable with them. Also, there will be another program that uses most of these features soon.). Here goes:
```demolist = ['life', 42, 'the', 'universe', 6, 'and', 7]
print('demolist = ', demolist)
demolist.append('everything')
print("after 'everything' was appended demolist is now:")
print(demolist)
print('len(demolist) =', len(demolist))
print('demolist.index(42) =', demolist.index(42))
print('demolist[1] =', demolist[1])
#Next we will loop through the list
c = 0
while c < len(demolist):
print('demolist[', c, ']=', demolist[c])
c = c + 1
del demolist[2]
print("After 'the universe' was removed demolist is now:")
print(demolist)
if 'life' in demolist:
print("'life' was found in demolist")
else:
if 'amoeba' in demolist:
print("'amoeba' was found in demolist")
if 'amoeba' not in demolist:
int_list = []
c = 0
while c < len(demolist):
if type(0) == type(demolist[c]):
int_list.append(demolist[c])
c = c + 1
print('int_list is', int_list)
int_list.sort()
print('The sorted int_list is ', int_list)
```

The output is:

```demolist =  ['life', 42, 'the', 'universe', 6, 'and', 7]
after 'everything' was appended demolist is now:
['life', 42, 'the', 'universe', 6, 'and', 7, 'everything']
len(demolist) = 8
demolist.index(42) = 1
demolist[1] = 42
demolist[ 0 ]= life
demolist[ 1 ]= 42
demolist[ 2 ]= the
demolist[ 3 ]= universe
demolist[ 4 ]= 6
demolist[ 5 ]= and
demolist[ 6 ]= 7
demolist[ 7 ]= everything
After 'the universe' was removed demolist is now:
['life', 42, 'universe', 6, 'and', 7, 'everything']
'life' was found in demolist
int_list is [42, 6, 7]
The sorted int_list is  [6, 7, 42]
```

This example uses a whole bunch of new functions. Notice that you can just print a whole list. Next the append function is used to add a new item to the end of the list. `len` returns how many items are in a list. The valid indexes (as in numbers that can be used inside of the []) of a list range from 0 to len - 1. The index function tell where the first location of an item is located in a list. Notice how `demolist.index(42)` returns 1 and when `demolist[1]` is run it returns 42. The line `#Next we will loop through the list` is a just a reminder to the programmer (also called a comment). Python will ignore any lines that start with a `#`. Next the lines:

```c = 0
while c < len(demolist):
print('demolist[', c, ']=', demolist[c])
c = c + 1
```
This creates a variable c which starts at 0 and is incremented until it reaches the last index of the list. Meanwhile the print function prints out each element of the list.

The `del` command can be used to remove a given element in a list. The next few lines use the in operator to test if a element is in or is not in a list.

The `sort` function sorts the list. This is useful if you need a list in order from smallest number to largest or alphabetical. Note that this rearranges the list. Note also that the numbers were put in a new list, and that was sorted, instead of trying to sort a mixed list. Sorting numbers and strings does not really make sense and results in an error.

In summary for a list the following operations exist:

example
 explanation list[2] accesses the element at index 2 list[2] = 3 sets the element at index 2 to be 3 del list[2] removes the element at index 2 len(list) returns the length of list "value" in list is true if "value" is an element in list "value" not in list is true if "value" is not an element in list list.sort() sorts list list.index("value") returns the index of the first place that "value" occurs list.append("value") adds an element "value" at the end of the list

This next example uses these features in a more useful way:

```menu_item = 0
list = []
print("--------------------")
print("1. Print the list")
print("2. Add a name to the list")
print("3. Remove a name from the list")
print("4. Change an item in the list")
print("9. Quit")
current = 0
if len(list) > 0:
while current < len(list):
print(current, ". ", list[current])
current = current + 1
else:
print("List is empty")
name = input("Type in a name to add: ")
list.append(name)
del_name = input("What name would you like to remove: ")
if del_name in list:
item_number = list.index(del_name)
del list[item_number]
#The code above only removes the first occurance of
# the name.  The code below from Gerald removes all.
#while del_name in list:
#       item_number = list.index(del_name)
#       del list[item_number]
else:
old_name = input("What name would you like to change: ")
if old_name in list:
item_number = list.index(old_name)
new_name = input("What is the new name: ")
list[item_number] = new_name
else:
print("Goodbye")
```

And here is part of the output:

```--------------------
1. Print the list
2. Add a name to the list
3. Remove a name from the list
4. Change an item in the list
9. Quit
```
```Pick an item from the menu: 2
Type in a name to add: Jack

Pick an item from the menu: 2
Type in a name to add: Jill

Pick an item from the menu: 1
0 .  Jack
1 .  Jill

Pick an item from the menu: 3
What name would you like to remove: Jack

Pick an item from the menu: 4
What name would you like to change: Jill
What is the new name: Jill Peters

Pick an item from the menu: 1
0 .  Jill Peters

Pick an item from the menu: 9
Goodbye
```

That was a long program. Let's take a look at the source code. The line list = [] makes the variable list a list with no items (or elements). The next important line is `while menu_item != 9:` . This line starts a loop that allows the menu system for this program. The next few lines display a menu and decide which part of the program to run.

The section:

```current = 0
if len(list) > 0:
while current < len(list):
print(current, ". ", list[current])
current = current + 1
else:
print("List is empty")
```
goes through the list and prints each name. `len(list_name)` tell how many items are in a list. If len returns `0` then the list is empty.

Then a few lines later the statement list.append(name) appears. It uses the append function to add a item to the end of the list. Jump down another two lines and notice this section of code:

```item_number = list.index(del_name)
del list[item_number]
```
Here the index function is used to find the index value that will be used later to remove the item. `del list[item_number]` is used to remove a element of the list.

The next section

```old_name = input("What name would you like to change: ")
if old_name in list:
item_number = list.index(old_name)
new_name = input("What is the new name: ")
list[item_number] = new_name
else:
```
uses index to find the `item_number` and then puts `new_name` where the `old_name` was.

Congratulations, with lists under your belt, you now know enough of the language that you could do any computations that a computer can do (this is technically known as Turing-Completeness). Of course, there are still many features that are used to make your life easier.

# Examples

test.py

```## This program runs a test of knowledge

# First get the test questions
# Later this will be modified to use file io.
def get_questions():
# notice how the data is stored as a list of lists
return [["What color is the daytime sky on a clear day?", "blue"],\
["What is the answer to life, the universe and everything?", "42"],\
["What is a three letter word for mouse trap?", "cat"]]

# This will test a single question
# it takes a single question in
# it returns true if the user typed the correct answer, otherwise false
#extract the question and the answer from the list
# give the question to the user
print("Correct")
return True
else:
return False

# This will run through all the questions
def run_test(questions):
if len(questions) == 0:
print("No questions were given.")
# the return exits the function
return
index = 0
right = 0
while index < len(questions):
#Check the question
if check_question(questions[index]):
right = right + 1
#go to the next question
index = index + 1
#notice the order of the computation, first multiply, then divide
print("You got ", right*100//len(questions), "% right out of", len(questions))

#now lets run the questions
run_test(get_questions())
```

Sample Output:

```What color is the daytime sky on a clear day?green
Incorrect, correct was: blue
What is the answer to life, the universe and everything?42
Correct
What is a three letter word for mouse trap?cat
Correct
You got  66 % right out of 3
```

# Exercises

Expand the test.py program so it has menu giving the option of taking the test, viewing the list of questions and answers, and an option to Quit. Also, add a new question to ask, “What noise does a truly advanced machine make?” with the answer of “ping”.