# Non-Programmer's Tutorial for Python 2.6/Lists
### 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 an example of a list being used:
and an output example:
In this example the months is a list. months is defined with the lines months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', and 'August', 'September', 'October', 'November', 'December'] (note that a \ could also be used to split a long line, but that is not necessary in this case because Python is intelligent enough to recognize that everything within brackets belongs together). The [ and ] start and end the list with commas (,) 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 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).
Lists can be thought of as a series of boxes. Each box has a different value. For example, the boxes created by demolist = ['life', 42, 'the universe', 6, 'and', 9] would look like this:
| box number | 0 | 1 | 2 | 3 | 4 | 5 |
| demolist | "life" | 42 | "the universe" | 6 | "and" | 9 |
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[5] getting 9.

### 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.). Here goes:
The output is:
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 tells 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:
create a variable c, which starts at 0 and is incremented until it reaches the last index of the list. Meanwhile the print statement 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 an 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. In summary, for a list, the following operations occur:
| example | explanation |
| demolist[2] | accesses the element at index 2 |
| demolist[2] = 3 | sets the element at index 2 to be 3 |
| del demolist[2] | removes the element at index 2 |
| len(demolist) | returns the length of demolist |
| "value" in demolist | is True if "value" is an element in demolist |
| "value" not in demolist | is True if "value" is not an element in demolist |
| demolist.sort | sorts demolist |
| demolist.index("value") | returns the index of the first place that "value" occurs |
| demolist.append("value") | adds an element "value" at the end of the list |
| demolist.remove("value") | removes the first occurrence of value from demolist (same as del demolist[demolist.index("value")]) |
This next example uses these features in a more useful way:
And here is part of the output:
That was a long program. Let's take a look at the source code. The line namelist = makes the variable namelist 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
goes through the list and prints each name. len(namelist) tells how many items are in the list. If len returns 0, then the list is empty.
Then, a few lines later, the statement namelist.append(name) appears. It uses the append function to add an item to the end of the list. Jump down another two lines, and notice this section of code:
Here the index function is used to find the index value that will be used later to remove the item. del namelist[item_number] is used to remove a element of the list.
The next section
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
The values True and False point to 1 and 0, respectively. They are often used in sanity checks, loop conditions etc. You will learn more about this a little bit later (chapter Boolean Expressions).
Sample Output:

### Exercises

Expand the test.py program so it has a 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".
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".
| Previous: Defining Functions | Front Page | Next: For Loops |