# A Beginner's Python Tutorial/Printable version
## Acknowledgments

Content from the work A Beginner's Python Tutorial Copyright © 2011 Steven Thurlow, available at https://github.com/stoive/pythontutorial and dual licensed under the Creative Commons Attribution 2.5 Australia license and MIT License was used on the creation of this book.

## What is Python?

If you don't understand this, don't worry. Just skip it and move on.
Python is an interpreted programming language. For those who don't know, a programming language is what you write down to tell a computer what to do. However, the computer doesn't read the language directly—there are hundreds of programming languages, and it couldn't understand them all. So, when someone writes a program, they will write it in their language of choice, and then compile it—that is, turn it into lots of 0s and 1s, that the computer can easily and quickly understand. A Windows program that you buy is already compiled for Windows—if you opened the program file up, you'd just get a mass of weird characters and rectangles. Give it a go—find a small Windows program, and open it up in Notepad or Wordpad. See what garbled mess you get.
But that Windows program is compiled for Windows—no other machine can run that program, unless it has Windows. What Python is, is a language which is never actually compiled in full—instead, an interpreter turns each line of code into 0s and 1s that your computer can understand. And it is done on the fly—it compiles the bits of the program you are using as you are using them. If you were to quit the program and come back another day, it would compile the bits you are using, as you are using them, again. Seems a waste of time? Maybe, but the fact is that when you come back another day, you might be using a Windows PC instead of a Mac. You might send the program to a friend, who uses another type of computer. Or you might post your program on the internet, where everyone using all different types of systems might download it. That is the wonder of an interpreted programming language—it is like a language that everyone can understand.

## How to install Python

For Python programming you need a working Python installation and a text editor. Python comes with its own editor IDLE, which is quite nice and totally sufficient for the beginning. As you get more into programming, you will probably switch to some other editor like emacs, vi or another.
The Python download page is https://www.python.org/downloads/. The most recent version is 3.12.1 (as of January 21, 2024), but any Python 2.x version since 2.2 will work for this tutorial.
There are various different installation files for different computer platforms available on the download site. Here are some specific instructions for the most common operating systems:

#### Linux, BSD and Unix users

You are probably lucky and Python is likely already installed on your machine. To test it type python on a command line. If you see something like that in the following section, you are set.
If you have to install Python, just use the operating system's package manager or go to the repository where your packages are available and get Python. If you are already comfortable with programming and Unix and are here to pick Python 2 up, you can alternatively compile Python from scratch after downloading the source code. If you get the source code make sure you compile in the Tk extension if you want to use IDLE.

#### Mac users

Starting from Mac OS X (Tiger) and ending with MacOS 12.3, Python shipped by default with MacOS. That said you might want to update to the newer version (check the version and install status by starting python in a command line terminal). Also IDLE (the Python editor) might be missing in the standard installation. If you want to (re-)install Python, you can get it from the Mac download page on the Python site.

#### Windows users

Some computer manufacturers pre-install Python. To check if you already have it installed, open command prompt (Windows Key+R then type cmd) and type python. If it says "Bad command or file name" you will need to download the appropriate Windows installer from the Windows download page. If you do not have a 64-bit AMD or Intel chip processor, you will need the Windows x86 MSI Installer; otherwise the Windows x86-64 MSI Installer is the correct one (they are very similarly named, so check carefully which one you are downloading). Start the installer by double-clicking it and follow the prompts.
After installing you will need to add the installation path to the PATH system variable if you wish to use it from the command prompt instead of the IDLE editor.

## References

* ↑ "Sunsetting Python 2". Python.org. Retrieved 21 January 2024.
* ↑ "macOS Monterey 12.3 Release Notes". Apple Developer Documentation. Retrieved 22 January 2024.
OK! We have Python installed, now what? Well, we program!
And it is that simple (at least for now!). Python makes it easy to run single lines of code—one-liner programs. Let's give it a go.

## Opening IDLE

Run the program labelled IDLE (IDLE stands for Integrated Development Environment). Now you are in the IDLE environment. This is the place you will be spending most time in. Here you can open a new window to write a program, or you can simply mess around with single lines of code, which is what we are going to do.
Type the following line and press ↵ Enter. Don't type the >>> part, it will already be there.

### Code Example 1 – Hello, world!

What happened? You just created a program, that prints the words 'Hello, world!'. The IDLE environment that you are in immediately compiles whatever you have typed in. This is useful for testing things, e.g., defining a few variables, and then testing to see if a certain line will work. That will come in a later lesson though.

## Math in Python

Now try the following examples. I've given explanations in parentheses.

### Code Example 2 – Maths

As you see, there is the code and then the result of that code. I then explain them in brackets. These are the basic commands of Python, and what they do. Here is a table to clarify them.
Table 1 – Python operators :
| Command | Name | Example | Output |
| + | Addition | 4 + 5 | 9 |
| - | Subtraction | 8 - 5 | 3 |
| * | Multiplication | 4 * 5 | 20 |
| / | Division | 19 / 3 | 6 |
| % | Remainder (modulo) | 19 % 3 | 1 |
| ** | Exponent | 2 ** 4 | 16 |
Remember that thing called order of operations that they taught in maths? Well, it applies in Python, too. Here it is, if you need reminding:
* parentheses
* exponents **
* multiplication *, division /, and remainder %
* addition + and subtraction -

## Order of Operations

Here are some examples that you might want to try, if you're rusty on this:

### Code Example 3 – Order of operations

In the first example, the computer calculates 2 * 3 first, then adds 1 to it. This is because multiplication has the higher priority (at 3) and addition is below that (at a lowly 4).
In the second example, the computer calculates 1 + 2 first, then multiplies it by 3. This is because parentheses (brackets, like the ones that are surrounding this interluding text ;) ) have the higher priority (at 1), and addition comes in later than that.
Also remember that the math is calculated from left to right, unless you put in parentheses. The innermost parentheses are calculated first. Watch these examples:

### Code Example 4 – Parentheses

In the first example, 4 - 40 is calculated, then - 3 is done.
In the second example, 40 - 3 is calculated, then it is subtracted from 4.

## Comments, Please

The final thing you'll need to know to move on to multi-line programs is the comment. You should always add comments to code to show others who might be reading your code what you've done and why. Type the following (and yes, the output is shown):

### Code Example 5 – Comments

A comment is a piece of code that is not run. In Python, you make something a comment by putting a hash (#) in front of it. A hash comments everything after it in the line, and nothing before it. So you could type this:

### Code Example 6 – Comment examples

Comments are important for adding necessary information for another programmer to read, but not the computer; for example, an explanation of a section of code, saying what it does, or what is wrong with it. You can also comment out bits of code if you don't want them to compile, but can't delete them because you might need them later.

## Simple program example

Here multiplication and adding operations have been used.
The first line а = [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1] reflects values for a parameter i in the second line (for i in a). If we set “1” instead of “i” for a parameter b we will see that “space” is multiplied for 12 and “very” is multiplied for “1”.
So addition operator “+” unites 12 “spaces” and one word “very” which we can see in the first printed line. “for line in b: print(line)” is a cycle aimed at displaying required results.
Well, we can make one-liner programs. So what? You want to send programs to other people, so that they can use them, without knowing how to write them.

## Editing in Notepad

Writing programs in Python to a file is very easy. Python programs are simply text documents—you can open them up in Notepad (or another text editor), and have a look at them, just like that. So, go and open Notepad. Type the following:

### Code Example 1 – mary.py

Keep this exactly the same, down to where the commas are placed. Save the file as mary.py—and make sure Notepad doesn't add .txt to the end of the filename (you will have to tell it to save as any file to avoid this). Turn off 'Hide known file extensions' in Windows Explorer, if it makes it easier.

## Using the IDLE environment

Now, open up the Python IDLE program (should be in your start menu). Click 'File > Open' and find mary.py and open it. If you can't find mary.py, set the open dialogue to 'Files of type: All Files (*)'. A new window will open, showing the program you just wrote. To run your program, click 'Run > Run Module' (or just press F5). Your program will now run in the main Python screen (titled 'Python Shell') and will look like this:

### Code Example 2 – mary.py output

You can also use IDLE to create Python programs, like what you did in Notepad. Simply click 'File > New'. We will be writing all of our programs now in the Python IDLE program—the Notepad thing is just a demonstration to tell you that a .py file is just a simple text file, which anyone can see.
Something to note is that the comment wasn't shown. That is good, because remember—comments aren't compiled. (Try compiling it after removing the #—it comes out messy.)
You can also run the program from your command line program (e.g., cmd or Terminal). Open the prompt up, type cd path\to\your\file (path/to/your/file for macOS/*nix) then type python mary.py. Your program will now execute in the command line.

## Variables

Now let's start introducing variables. Variables store a value, that can be looked at or changed at a later time. Let's make a program that uses variables. Open up IDLE and click 'File > New Window'. A new window now appears, and it is easy to type in programs. Type the following (or just copy and paste—just read very carefully, and compare the code to the output that the program will make):

### Code Example 3 – Variables

Note that if you just want to modify a variable's value with respect to itself, there are shortcuts. These are called augmented assignment operators:
Table 1 – Augmented operators :
| Standard form | Augmented |
| v = v + 5 | v += 5 |
| v = v - 5 | v -= 5 |
| v = v*5 | v *= 5 |
| v = v/5 | v /= 5 |

## Strings

As you can see, variables store values, for use at a later time. You can change them at any time. You can put in more than numbers, though. Variables can hold things like text. A variable that holds text is called a string. Try this program:

### Code Example 4 – Strings

The output will be:

### Code Example 5 – String output

As you see, the variables above were holding text. Variable names can also be longer than one letter—here, we had word1, word2, and word3. As you can also see, strings can be added together to make longer words or sentences. The comma adds a space and then the variable to the string, so print(word1, word2) outputs Good morning, but with the + it would print Goodmorning.
(Our final lesson before we get into interacting with human input. Can't wait, can you?)
Just imagine you needed a program to do something 20 times. What would you do? You could copy and paste the code 20 times, and have a virtually unreadable program. Or, you could tell the computer to repeat a bit of code between point A and point B, until the time comes that you need it to stop. Such a thing is called a loop.

## The while loop

The following are examples of a type of loop, called the while loop:

### Code Example 1 – The while loop

How does this program work? Let's go through it in English (this is called pseudocode):

### Code Example 2 – Plain-language while loop

What does this do? Let's go through what the computer would be 'thinking' when it is in the while loop:

### Code Example 3 – while loop process

So in short, try to think of it that way when you write while loops. This is how you write them, by the way:

### Code Example 4 – while loop form

An example:

### Code Example 5 – while loop example

Remember, to make a program, you open IDLE, click 'File > New Window', type your program in the new window, then press F5 to run.

## Boolean Expressions (Boolean... what?!?)

What do you type in the area marked {conditions that the loop continues}? The answer is a boolean expression.
What? A forgotten concept for the non-math people here. Never mind, boolean expression just means a question that can be answered with a TRUE or FALSE response. For example, if you wanted to say your age is the same as the person next to you, you would type:
My age == the age of the person next to me
And the statement would be TRUE. If you were younger than the person opposite, you'd say:
My age < the age of the person opposite me
And the statement would be TRUE. If, however, you were to say the following, and the person opposite of you was younger than you:
My age < the age of the person opposite me
The statement would be FALSE - the truth is that it is the other way around. This is how a loop thinks - if the expression is true, keep looping. If it is false, don't loop. With this in mind, lets have a look at the operators (symbols that represent an action) that are involved in boolean expressions:
Table 1 - Boolean operators :
| Expression | Function |
| < | less than |
| <= | less than or equal to |
| > | greater than |
| >= | greater than or equal to |
| != | not equal to |
| <> | not equal to (alternate, != preferred) |
| == | equal to |
Don't get '=' and '==' mixed up - the '=' operator makes what is on the left equal to what is on the right. the '==' operator says whether the thing on the left is the same as what is on the right, and returns true or false.

## Conditional Statements

OK! We've (hopefully) covered 'while' loops. Now let's look at something a little different - conditionals.
Conditionals are where a section of code is only run if certain conditions are met. This is similar to the 'while' loop you just wrote, which only runs when x doesn't equal 0. However, Conditionals are only run once. The most common conditional in any program language, is the 'if' statement. Here is how it works:

### Code Example 6 - if statement and example

Example 2 there looks tricky. But all we have done is run an 'if' statement every time the 'while' loop runs. Remember that the % just means the remainder from a division - just checking that there is nothing left over if the number is divided by two - showing it is even. If it is even, it prints what 'n' is.

## 'else' and 'elif' - When it Ain't True

There are many ways you can use the 'if' statement, to deal with situations where your boolean expression ends up FALSE. They are 'else' and 'elif'.
'else' simply tells the computer what to do if the conditions of 'if' aren't met. For example, read the following:

### Code Example 7 - the else statement

'a' is not greater than five, therefore what is under 'else' is done.
'elif' is just a shortened way of saying 'else if'. When the 'if' statement fails to be true, 'elif' will do what is under it IF the conditions are met. For example:

### Code Example 8 - The elif statement

The 'if' statement, along with 'else' and 'elif' follow this form:

### Code Example 9 - the complete if syntax

One of the most important points to remember is that you MUST have a colon (:) at the end of every line with an 'if', 'elif', 'else' or 'while' in it. I forgot that, and as a result a stack of people got stumped at this lesson (sorry ;)).

## Indentation

One other point is that the code to be executed if the conditions are met, MUST BE INDENTED. That means that if you want to loop the next five lines with a 'while' loop, you must put a set number of spaces at the beginning of each of the next five lines. This is good programming practice in any language, but Python requires that you do it. Here is an example of both of the above points:

### Code Example 10 - Indentation

Notice the three levels of indents there:
Each line in the first level starts with no spaces. It is the main program, and will always execute. Each line in the second level starts with four spaces. When there is an 'if' or loop on the first level, everything on the second level after that will be looped/'ifed', until a new line starts back on the first level again. Each line in the third level starts with eight spaces. When there is an 'if' or loop on the second level, everything on the third level after that will be looped/'ifed', until a new line starts back on the second level again. This goes on infinitely, until the person writing the program has an internal brain explosion, and cannot understand anything he/she has written. There is another loop, called the 'for' loop, but we will cover that in a later lesson, after we have learnt about lists.
A Beginner's Python Tutorial/Functions/ Your brain still hurting from the last lesson? Never worry, this one will require a little less thought. We're going back to something simple - variables - but a little more in depth.
Think about it - variables store one bit of information. They may regurgitate that information at any point, and their bit of information can be changed at any time. Variables are great at what they do - storing a piece of information that may change over time.
But what if you need to store a long list of information, which doesn't change over time? Say, for example, the names of the months of the year. Or maybe a long list of information, that does change over time? Say, for example, the names of all your cats. You might get new cats, some may die, some may run away. What about a phone book? For that you need to do a bit of referencing - you would have a list of names, and attached to each of those names, a phone number. How would you do that?

## The Solution - Lists, Tuples, and Dictionaries

For these three problems, Python uses three different solutions - lists, tuples, and dictionaries:
* Lists are what they seem - a list of values. Each one of them is numbered, starting from zero - the first one is numbered zero, the second 1, the third 2, etc. You can remove values from the list, and add new values to the end. Example: Your many cats' names.
* Tuples are just like lists, but you can't change their values (immutable in programmer-speak). The values that you give it first up, are the values that you are stuck with for the rest of the program. Again, each value is numbered starting from zero, for easy reference. Example: the names of the months of the year.
* Dictionaries are similar to what their name suggests - a dictionary. In a dictionary, you have an 'index' of words, and for each of them a definition. In Python, the word is called a 'key', and the definition a 'value'. The values in a dictionary aren't numbered - they aren't in any specific order, either - the key does the same thing. (Each key must be unique, though!) You can add, remove, and modify the values in dictionaries. Example: telephone book.

## Tuples

Tuples are pretty easy to make. You give your tuple a name, then after that the list of values it will carry. For example, the months of the year:

### Code Example 1 - creating a tuple

Note that the '\' thingy at the end of the first line carries over that line of code to the next line. It is useful way of making big lines more readable. Technically, you don't have to put those parentheses there (the '(' and ')' thingies), but it stops Python from getting things confused. You may have spaces after the commas if you feel it necessary - it doesn't really matter. Python then organises those values in a handy, numbered index - starting from zero, in the order that you entered them in. It would be organised like this:
Table 1 - tuple indicies :
| Index | Value |
| 0 | January |
| 1 | February |
| 2 | March |
| 3 | April |
| 4 | May |
| 5 | June |
| 6 | July |
| 7 | August |
| 8 | September |
| 9 | October |
| 10 | November |
| 11 | December |
And that is tuples! Really easy...

## Lists

Lists are extremely similar to tuples. Lists are modifiable (or 'mutable', as a programmer may say), so their values can be changed. Most of the time we use lists, not tuples, because we want to easily change the values of things if we need to.
Lists are defined very similarly to tuples. Say you have FIVE cats, called Tom, Snappy, Kitty, Jessie and Chester. To put them in a list, you would do this:

### Code Example 2 - Creating a list

As you see, the code is exactly the same as a tuple, EXCEPT that all the values are put between square brackets, not parentheses. Again, you don't have to have spaces after the comma, but it does make it more readable.
You recall values from lists exactly the same as you do with tuples. For example, to print the name of your 3rd cat you would do this:

### Code Example 3 - Recalling items from a list

You can also recall a range of examples, like above, for example - cats[0:2] would return your 1st and 2nd cats, or said another way, this expression would return the zero-th element and the one-th, or first, element, and would stop at two-th element. The output would look like this:
Where lists come into their own is how they can be modified. To add a value to a list, you use the append function. Let's say you got a new cat called Catherine. To add her to the list you'd do this:

### Code Example 4 - Adding items to a list

That's a little weird, isn't it? I'll explain. That function is in a funny spot - after a period, after the list name. You'll get to see those things more in a later lesson. For the meanwhile, this is the form of the function that adds a new value to a list:

### Code Example 5 - Using the append function

Clears things up? Good!
Now to a sad situation - Snappy ran away. You need to remove him (or her) from the list. Removing that sorry cat is an easy task, thankfully, so you have to wallow in sadness for as short a time as possible:

### Code Example 6 - Deleting an item

You've just removed the 2nd cat in your list - poor old Snappy.
And with that morbid message, lets move on to...

## Dictionaries

Ok, so there is more to life than the names of your cats. You need to call your sister, mother, son, the fruit man, and anyone else who needs to know that their favourite cat has run away. For that you need a telephone book.
Now, the lists we've used above aren't really suitable for a telephone book. You need to know a number based on someone's name - not the other way around, like what we did with the cats. In the examples of months and cats, we gave the computer a number, and it gave us a name. This time we want to give the computer a name, and it give us a number. For this we need dictionaries.
So how do we make a dictionary? Put away your binding equipment, it isn't that advanced.
Remember, dictionaries have keys, and values. In a phone book, you have people's names, then their numbers. See a similarity?
When you initially create a dictionary, it is very much like making a tuple or list. Tuples have ( and ) things, lists have [ and ] things. Guess what! dictionaries have { and } things - curly braces. Here is an example below, showing a dictionary with four phone numbers in it:

### Code Example 7 - Creating a dictionary

The program would then print Lewis Lame's number onscreen. Notice how instead of identifying the value by a number, like in the cats and months examples, we identify the value, using another value - in this case the person's name.
Ok, you've created a new phone book. Now you want to add new numbers to the book. What do you do? A very simple line of code:

### Code Example 8 - Adding entries to a dictionary

All that line is saying is that there is a person called Gingerbread Man in the phone book, and his number is 1234567. In other words - the key is 'Gingerbread Man', and the value is 1234567.
You delete entries in a dictionary just like in a list. Let's say Andrew Parson is your neighbour, and shot your cat. You never want to talk to him again, and therefore don't need his number. Just like in a list, you'd do this:

### Code Example 9 - Removing entries from a dictionary

Again, very easy. the 'del' operator deletes any function, variable, or entry in a list or dictionary (An entry in a dictionary is just a variable with a number or text string as a name. This comes in handy later on.)
Remember that append function that we used with the list? Well, there are quite a few of those that can be used with dictionaries. Below, I will write you a program, and it will incorporate some of those functions in. It will have comments along the way explaining what it does.
Type this program into Python IDLE (you can skip the comments). Experiment as much as you like with it. Type it where you see the lines beginning with >>>

### Code Example 10 - Functions of dictionaries
## Introduction

Well, in the first lesson about loops, I said I would put off teaching you the for loop, until we had reached lists. Well, here it is!

## The 'for' Loop

Basically, the for loop does something for every value in a list. The way it is set out is a little confusing, but otherwise is very basic. Here is an example of it in code:

### Code Example 1 - The for Loop

As you see, when the loop executes, it runs through all of the values in the list mentioned after 'in'. It then puts them into value, and executes through the loop, each time with value being worth something different. Let's see it a again, in a classic cheerleading call that we all know:

### Code Example 2 - A for loop example

A couple of things you've just learnt:
As you see, strings (remember - strings are lines of text) are just lists with lots of characters. The program went through each of the letters (or values) in word, and it printed them onscreen.

### Code Example 3 - Looping through a range

Sometimes, you may only need to loop a certain amount of times (say 10). If you're coming from another programming language, you might be looking for the usual for loop in a format somewhat like this:
Python doesn't have this type of loop. If you want to loop a certain number of times, simply use range.
A couple of things you must take note of:
* The range starts with the starting number and ends up to the ending number. If you wanted to loop from 0 through 100, your range function will be range(0,101) as the function doesn't include the ending number.
* The parameters for the range function are start (default of 0), end, and step (default is 1). A step is simply how much range will increment by. If you wanted to loop from 100 to 0, simply use a step of -1. In other words: range(100,0,-1).

## Making a Menu Function

Now to the business end of the lesson. Lets start writing programs. So far we have learnt variables, lists, loops, and functions. That is pretty much all we need for quite a bit of programming. So let's set ourselves a task.

### Code Example 4 - A menu function

That wasn't very difficult, was it? the actual program only took up five lines - this is the wonder of how much we have learnt so far! All my comments take up sixteen lines - more than three times the program length. It is a good idea to comment your programs extensively. Remember that if you are going to be publishing your code open-source, there are going to be a lot of people checking out the code that you have written. We'll see the function we just wrote in our first example program.

## Our First 'Game'

What will our first example program be? How about a (very) simple text adventure game? Sounds like fun! It will only encompass one room of a house, and will be extremely simple. There will be five things, and a door. In one of the five things, is a key to the door. You need to find the key, then open the door. I will give a plain-english version first, then do it in python:

### Code Example 5 - Plain-english version of code

From this, we can write a real program. Ready? Here it is (skip typing the comments):

### Code Example 6 - Text Adventure Game

Well, a very simple, but fun, game. Don't get daunted by the amount of code there, 53 of the lines are just the 'if' statements, which is the easiest thing to read there. (Once you comprehend all the indentation, you'll be able to make your own game, and you can make it as simple [or as complex] as you like.)

## Making the Game Better

The first question you should ask is "does this program work?". The answer here is yes. Then you should ask "does this program work well?" - not quite. The menu function is great - it reduces a lot of typing. The 'while' loop that we have, however, is a little messy - four levels of indents, for a simple program. We can do better!
Now, this will become much MUCH more straightforward when we introduce classes. But that will have to wait. Until then, let's make a function that reduces our mess. We will pass two things to it - the menu choice we made, and the location of the key. It will return one thing - whether or not the key has been found. Lets see it:

### Code Example 7 - Creating an inspect function

Now the main program can be a little simpler. Let's take it from the while loop, and change things around:

### Code Example 8 - The new game

Now the program becomes massively shorter - from a cumbersome 83 lines, to a very shapely 50 lines! Of course, you lose quite a bit of versatility - all the items in the room do the same thing. You automatically open the door when you find the key. The game becomes a little less interesting. It also becomes a little harder to change.
One thing that you will get to know about programming, is that programmers like to be lazy. If something has been done before, why should you do it again?
That is what functions cover in Python. You've already had your code do something special. Now you want to do it again. You put that special code into a function, and re-use it for all it is worth. You can refer to a function anywhere in your code, and the computer will always know what you are talking about. Handy, eh?
Of course, functions have their limitations. Functions don't store any information like variables do - every time a function is run, it starts afresh. However, certain functions and variables are related to each other very closely, and need to interact with each other a lot. For example, imagine you have a golf club. It has information about it (i.e. variables) like the length of the shaft, the material of the grip, and the material of the head. It also has functions associated with it, like the function of swinging your golf club, or the function of breaking it in pure frustration. For those functions, you need to know the variables of the shaft length, head material, etc.
That can easily be worked around with normal functions. Parameters affect the effect of a function. But what if a function needs to affect variables? What happens if each time you use your golf club, the shaft gets weaker, the grip on the handle wears away a little, you get that little more frustrated, and a new scratch is formed on the head of the club? A function cannot do that. A function only makes one output, not four or five, or five hundred. What is needed is a way to group functions and variables that are closely related into one place so that they can interact with each other.
Chances are that you also have more than one golf club. Without classes, you need to write a whole heap of code for each different golf club. This is a pain, seeing that all clubs share common features, it is just that some have changed properties - like what the shaft is made of, and its weight. The ideal situation would be to have a design of your basic golf club. Each time you create a new club, simply specify its attributes - the length of its shaft, its weight, etc.
Or what if you want a golf club, which has added extra features? Maybe you decide to attach a clock to your golf club (why, I don't know - it was your idea). Does this mean that we have to create this golf club from scratch? We would have to write code first for our basic golf club, plus all of that again, and the code for the clock, for our new design. Wouldn't it be better if we were to just take our existing golf club, and then tack the code for the clock to it?
These problems are what a thing called object-oriented-programming solves. It puts functions and variables together in a way that they can see each other and work together, be replicated, and altered as needed, and not when unneeded. And we use a thing called a 'class' to do this.

## Creating a Class

What is a class? Think of a class as a blueprint. It isn't something in itself, it simply describes how to make something. You can create lots of objects from that blueprint - known technically as instances.
So how do you make these so-called 'classes'? Very easily, with the class operator:

### Code Example 1 - defining a class

Makes little sense? That's okay, here is an example that creates the definition of a Shape:

### Code Example 2 - Example of a Class

What you have created is a description of a shape (That is, the variables) and what operations you can do with the shape (That is, the functions). This is very important - you have not made an actual shape, simply the description of what a shape is. The shape has a width (x), a height (y), and an area and perimeter (area(self) and perimeter(self)). No code is run when you define a class - you are simply making functions and variables.
The function called __init__ is run when we create an instance of Shape - that is, when we create an actual shape, as opposed to the 'blueprint' we have here, __init__ is run. You will understand how this works later.
self is how we refer to things in the class from within itself. self is the first parameter in any function defined inside a class. Any function or variable created on the first level of indentation (that is, lines of code that start one TAB to the right of where we put class Shape) is automatically put into self. To access these functions and variables elsewhere inside the class, their name must be preceded with self and a full-stop (e.g. self.variable_name).

## Using a Class

It's all well and good that we can make a class, but how do we use one? Here is an example of what we call "creating an instance of a class". Assume that the code in example 2 has already been run:

### Code Example 3 - Creating a class

What has been done? It takes a little explaining...
The __init__ function really comes into play at this time. We create an instance of a class by first giving its name (in this case, Shape) and then, in brackets, the values to pass to the __init__ function. The init function runs (using the parameters you gave it in brackets) and then spits out an instance of that class, which in this case is assigned to the name "rectangle".
Think of our class instance, rectangle, as a self-contained collection of variables and functions. In the same way that we used self to access functions and variables of the class instance from within itself, we use the name that we assigned to it now (rectangle) to access functions and variables of the class instance from outside of itself. Following on from the code we ran above, we would do this:

### Code Example 4 - accessing attributes from outside an instance

As you see, where self would be used from within the class instance, its assigned name is used when outside the class. We do this to view and change the variables inside the class, and to access the functions that are there.
We aren't limited to a single instance of a class - we could have as many instances as we like. I could do this:

### Code Example 5 - More than one instance

Both long_rectangle and fat_rectangle have their own functions and variables contained inside them - they are totally independent of each other. There is no limit to the number of instances I could create.

## Lingo

Object-oriented programming has a set of lingo that is associated with it. It's about time that we have this all cleared up:
* when we first describe a class, we are defining it (like with functions)
* the ability to group similar functions and variables together is called encapsulation
* the word 'class' can be used when describing the code where the class is defined (like how a function is defined), and it can also refer to an instance of that class - this can get confusing, so make sure you know in which form we are talking about classes
* a variable inside a class is known as an 'attribute'
* a function inside a class is known as a 'method'
* a class is in the same category of things as variables, lists, dictionaries, etc. That is, they are objects
* a class is known as a 'data structure' - it holds data, and the methods to process that data.

## Inheritance

Let's have a look back at the introduction. We know how classes group together variables and functions, known as attributes and methods, so that both the data and the code to process it, are in the same spot. We can create any number of instances of that class, so that we don't have to write new code for every new object we create. But what about adding extra features to our golf club design? This is where inheritance comes into play.
Python makes inheritance really easy. We define a new class, based on another, 'parent' class. Our new class brings everything over from the parent, and we can also add other things to it. If any new attributes or methods have the same name as an attribute or method in our parent class, it is used instead of the parent one. Remember the Shape class?

### Code Example 6 - the Shape class

If we wanted to define a new class, let's say a square, based on our previous Shape class, we would do this:

### Code Example 7 - Using inheritance

It is just like normally defining a class, but this time we put the parent class that we inherited from in brackets after the name. As you can see, this lets us describe a square really quickly. That's because we inherited everything from the shape class, and changed only what needed to be changed. In this case we redefined the __init__ function of Shape so that the X and Y values are the same.
Let's take from what we have learnt, and create another new class, this time inherited from Square. It will be two squares, one immediately left of the other:

### Code Example 8 - DoubleSquare class

This time, we also had to redefine the perimeter function, as there is a line going down the middle of the shape. Try creating an instance of this class. As a helpful hint, the IDLE command line starts where your code ends - so typing a line of code is like adding that line to the end of the program you have written.

## Pointers and Dictionaries of Classes

Thinking back, when you say that one variable equals another, e.g. variable2 = variable1, the variable on the left-hand side of the equal-sign takes on the value of the variable on the right. With class instances, this happens a little differently - the name on the left becomes the class instance on the right. So in instance2 = instance1, instance2 is 'pointing' to instance1 - there are two names given to the one class instance, and you can access the class instance via either name.
In other languages, you do things like this using pointers, however in python this all happens behind the scenes.
The final thing that we will cover is dictionaries of classes. Keeping in mind what we have just learnt about pointers, we can assign an instance of a class to an entry in a list or dictionary. This allows for virtually any amount of class instances to exist when our program is run. Lets have a look at the example below, and see how it describes what I am talking about:

### Code Example 9 - Dictionaries of Classes

As you see, we simply replaced our boring old name on the left-hand side with an exciting, new, dynamic, dictionary entry. Pretty cool, eh?
Last lesson we covered the killer topic of Classes. As you can remember, classes are neat combinations of variables and functions in a nice, neat package. Programming lingo calls this feature encapsulation, but regardless of what it is called, it's a really cool feature for keeping things together so the code can be used in many instances in lots of places. Of course, you've got to ask, "how do I get my classes to many places, in many programs?". The answer is to put them into a module, to be imported into other programs.

## Module? What's a Module?

A module is a Python file that (generally) has only definitions of variables, functions, and classes. For example, a module might look like this:

### Code Example 1 - moduletest.py

As you see, a module looks pretty much like your normal Python program.
So what do we do with a module? We import bits of it (or all of it) into other programs.
To import all the variables, functions and classes from moduletest.py into another program you are writing, we use the import operator. For example, to import moduletest.py into your main program, you would have this:

### Code Example 2 - mainprogram.py

This assumes that the module is in the same directory as mainprogram.py, or is a default module that comes with python. You leave out the '.py' at the end of the file - it is ignored. You normally put all import statements at the beginning of the python file, but technically they can be anywhere. In order to use the items of the module in your main program, you use the following:

### Code Example 3 - mainprogram.py continued

As you see, the modules that you import act very much like the classes we looked at last lesson - anything inside them must be preceded with modulename for it to work.

## More About Modules

Wish you could get rid of the modulename part that you have to put before every item you use from a module? No? Never? Well, I'll teach it to you anyway.
One way to avoid this hassle is to import only the wanted objects from the module. To do this, you use the from operator. You use it in the form of from modulename import itemname. Here is an example:

### Code Example 4 - importing individual objects

What is the point of this? Well, maybe you could use it to make your code a little more readable. If we get into heaps of modules inside modules, it could also remove that extra layer of crypticness.
If you wanted to, you could import everything from a module in this way by using from modulename import *. Of course, this can be troublesome if there are objects in your program with the same name as some items in the module. With large modules, this can easily happen, and can cause many a headache. A better way to do this would be to import a module in the normal way (without the from operator) and then assign items to a local name:

### Code Example 5 - mainprogram.py continued

This way, you can remove some crypticness, AND have all of the items from a certain module.
Last lesson we learned how to load external code into our program. Without any introduction (like what I usually have), let's delve into file input and output with normal text files, and later the saving and restoring of instances of classes. (Wow, our lingo power has improved greatly!)

## Opening a File

To open a text file you use, well, the open function. Seems sensible. You pass certain parameters to open to tell it in which way the file should be opened - 'r' for read only, 'w' for writing only (if there is an old file, it will be written over), 'a' for appending (adding things on to the end of the file) and 'r+' for both reading and writing. But less talk, lets open a file for reading (you can do this in your python idle mode). Open a normal text file. We will then print out what we read inside the file:

### Code Example 1 - Opening a file

That was interesting. You'll notice a lot of '\n' symbols. These represent newlines (where you pressed enter to start a new line). The text is completely unformatted, but if you were to pass the output of openfile.read to print (by typing print openfile.read) it would be nicely formatted.

## Seek and You Shall Find

Did you try typing in print openfile.read? Did it fail? It likely did, and reason is because the 'cursor' has changed its place. Cursor? What cursor? Well, a cursor that you really cannot see, but still a cursor. This invisible cursor tells the read function (and many other I/O functions) where to start from. To set where the cursor is, you use the seek function. It is used in the form seek(offset, whence).
whence is optional, and determines where to seek from. If whence is 0, the bytes/letters are counted from the beginning. If it is 1, the bytes are counted from the current cursor position. If it is 2, then the bytes are counted from the end of the file. If nothing is put there, 0 is assumed.
offset describes how far from whence that the cursor moves. for example:
openfile.seek(45,0) would move the cursor to 45 bytes/letters after the beginning of the file. openfile.seek(10,1) would move the cursor to 10 bytes/letters after the current cursor position. openfile.seek(-77,2) would move the cursor to 77 bytes/letters before the end of the file (notice the - before the 77) Try it out now. Use openfile.seek to go to any spot in the file and then try typing print openfile.read. It will print from the spot you seeked to. But realise that openfile.read moves the cursor to the end of the file – you will have to seek again.

## Other I/O Functions

There are many other functions that help you with dealing with files. They have many uses that empower you to do more, and make the things you can do easier. Let's have a look at tell, readline, readlines, write and close.
tell returns where the cursor is in the file. It has no parameters, just type it in (like what the example below will show). This is infinitely useful, for knowing what you are referring to, where it is, and simple control of the cursor. To use it, type fileobjectname.tell - where fileobjectname is the name of the file object you created when you opened the file (in openfile = open('pathtofile', 'r') the file object name is openfile).
readline reads from where the cursor is till the end of the line. Remember that the end of the line isn't the edge of your screen - the line ends when you press enter to create a new line. This is useful for things like reading a log of events, or going through something progressively to process it. There are no parameters you have to pass to readline, though you can optionally tell it the maximum number of bytes/letters to read by putting a number in the brackets. Use it with fileobjectname.readline.
readlines is much like readline, however readlines reads all the lines from the cursor onwards, and returns a list, with each list element holding a line of code. Use it with fileobjectname.readlines. For example, if you had the text file:

### Code Example 2 - example text file

The returned list from readlines would be:
Table 1 - resulting list from readlines :
| Index | Value |
| 0 | 'Line 1' |
| 1 | '' |
| 2 | 'Line 3' |
| 3 | 'Line 4' |
| 4 | '' |
| 5 | 'Line 6' |
The write function, writes to the file. How did you guess? It writes from where the cursor is, and overwrites text in front of it - like in MS Word, where you press 'insert' and it writes over the top of old text. To utilise this most purposeful function, put a string between the brackets to write e.g. fileobjectname.write('this is a string').
close, you may figure, closes the file so that you can no longer read or write to it until you reopen in again. Simple enough. To use, you would write fileobjectname.close. Simple!
In Python IDLE mode, open up a test file (or create a new one...) and play around with these functions. You can do some simple (and very inconvenient) text editing.
Pickles, in Python, are objects saved to a file. An object in this case could be a variables, instance of a class, or a list, dictionary, or tuple. Other things can also be pickled, but with limits. The object can then be restored, or unpickled, later on. In other words, you are 'saving' your objects.
So how do we pickle? With the dump function, which is inside the pickle module - so at the beginning of your program you will have to write import pickle. Simple enough? Then open an empty file, and use pickle.dump to drop the object into that file. Let's try that:

### Code Example 3 - pickletest.py

First we open 'filename' for writing binary data(wb) - open('filename', 'wb')
Then we dump our list into binary file.
The code to do this is laid out like pickle.dump(object_to_pickle, file_object) where:
* object_to_pickle is the object you want to pickle (i.e. save it to file)
* file_object is the file object you want to write to (in this case, the file object is 'file')
After you close the file, open it in notepad and look at what you see. Along with some other gibblygook, you will see bits of the list we created.
Now to re-open, or unpickle, your file. to use this, we would use pickle.load:

### Code Example 4 - unpickletest.py

Nifty, eh?
Of course, the limitation above is that we can only put in one object to a file. We could get around this by putting lots of picklable objects in a list or dictionary, and then pickling that list or dictionary. This is the quickest and easiest way, but you can do some pretty advanced stuff if you have advanced knowledge of pickle.
Or we can just use multiple 'pickle.dump(list, file)' functions:
and multiple 'pickle.load(file)' functions:
We won't cover complex examples here.

## References

* ↑ http://stackoverflow.com/a/15463472/2450748
If you haven't seen them before, you're not trying hard enough. What are they? Errors. Exceptions. Problems. Know what I'm talking about? I got it with this program:

### Code Example 1 - buggy program

This is just an example of the menu program we made earlier. Appears perfectly fine to me. At least until when I first tried it. Run the program, and what happens?

## Bugs - Human Errors

The most common problems with your code are of your own doing. Sad, but true. What do we see when we try to run our crippled program?

### Code Example 2 - error message

Say what? What Python is trying to tell you (but struggling to find a good word for it) is that you can't join a string of letters and a number into one string of text. Let's go through the error message and have a look at how it tells us that:
* File "/home/steven/errortest.py", line 10, in -toplevel- tells us a couple of things. File "/home/steven/errortest.py" tells us which file the error occurred in. This is useful if you use lots of modules that refer to each other. line 10, in -toplevel- tells us that it is in line # 10 of the file, and in the top level (that is, no indentation).
* answer = menu(['A','B','C','D','E','F','H','I'],'Which letter is your favourite? ') duplicates the code where the error is.
* Since this line calls a function, the next two lines describe where in the function the error occurred.
* TypeError: unsupported operand type(s) for -: 'str' and 'int' tells you the error. In this case, it is a 'TypeError', where you tried to subtract incompatible variables.
There are multiple file and code listings for a single error, because the error occurred with the interaction of two lines of code (e.g. when using a function, the error occurred on the line where the function was called, AND the line in the function where things went wrong).
Now that we know what the problem is, how do we fix it. Well, the error message has isolated where the problem is, so we'll only concentrate on that bit of code.

### Code Example 3 - calling the menu function

This is a call to a function. The error occurred in the function in the following line

### Code Example 4 - Where it went wrong

raw_input always returns a string, hence our problem. Let's change it to input, which, when you type in a number, it returns a number:

### Code Example 5 - Fixing it

Bug fixed!

## Exceptions - Limitations of the Code

Okay, the program works when you do something normal. But what if you try something weird? Type in a letter (lets say, 'm') instead of a number? Whoops!

### Code Example 6 - Another error message

What is this telling us? There are two code listings - one in line 10, and the other in line 6. What this is telling us is that when we called the menu function in line 10, an error occurred in line 6 (where we take away 1). This makes sense if you know what the input function does - I did a bit of reading and testing, and realised that if you type in a letter or word, it will assume that you are mentioning a variable! so in line 6, we are trying to take 1 away from the variable 'm', which doesn't exist.
Have no clue on how to fix this? One of the best and easiest ways is to use the try and except operators.
Here is an example of try being used in a program:

### Code Example 7 - The try operator

This is an example of a really messy bit of code that I was trying to fix. First, the code under try: is run. If there is an error, the compiler jumps to the except section and prints world.errormsg. The program doesn't stop right there and crash, it runs the code under except: then continues on.
Let's try that where the error occurred in our code (line 6). The menu function now is:

### Code Example 8 - testing our fix

Try entering a letter when you're asked for a number and see what happens. Dang. We fixed one problem, but now it has caused another problem further down the track. This happens all the time. (Sometimes you end up going around in circles, because your code is an absolute mess). Let's have a look at the error:

### Code Example 9 - Yet another error message

What has happened this time is that the menu function has returned no value - it only printed an error message. When, at the end of the program, we try to print the returned value plus 1, what is the returned value? There is no returned value? So what is 1 + ... well, we have no clue what we are adding 1 to!
We could just return any old number, but that would be lying. What we really should to is rewrite the program to cope with this exception. With what? try and except!

### Code Example 10 - yet another solution

Problem solved again.

## Endless Errors

The approach that we used above is not recommended. Why? Because apart from the error that we know can happen, except: catches every other error too. What if this means we never see an error that could cause problems down the track? If except: catches every error under the sun, we have no hope of controlling what errors we deal with, and the other ones that we want to see, because so far we haven't dealt with them. We also have little hope of dealing with more than one type of error in the same block of code. What should one do, when all is hopeless? Here is an example of code with such a situation:

### Code Example 11 - The Problem We Face

Okay, you enter your two numbers and it works. Enter a letter, and it gives you a NameError. Lets rewrite the code to deal with a NameError only. We'll put the program in a loop, so it restarts if an error occurs (using continue, which starts the loop from the top again, and break, which leaves the loop):

### Code Example 12 - Dealing With NameError

Here, we restarted the loop if you typed in something wrong. In line 12 we assumed you wanted to quit the program if you didn't press 1, so we quit the program.
But there are still problems. If we leave something blank, or type in an unusual character like ! or ;, the program gives us a SyntaxError. Lets deal with this. When we are asking for the numbers to subtract, we will give a different error message. When we ask to press 1, we will again assume the user wants to quit.

### Code Example 13 - Now, dealing with SyntaxError

As you can see, you can have multiple except uses, each dealing with a different problem. You can also have one except to deal with multiple exceptions, by putting them inside parentheses and separating them with commas.
Now we have a program that is very difficult, to crash by an end user. As a final challenge, see if you can crash it. There is one way I have thought of - if you read the section on human error carefully, you might know what it is.