# Learning Python 3 with the Linkbot/Printable version

The current, editable version of this book is available in Wikibooks, the open-content textbooks collection, at
https://en.wikibooks.org/wiki/Learning_Python_3_with_the_Linkbot

# Authors

The original authors and contributors for the original text as of this writing are:
* Mike Challender
* Ryan Uebner
* David Ko (User:Davidko_barobo)
* Natalie Ryland
* Graham Ryland
* Aaron Cooper
* Dylan Besk

### Additional Contributors

* Josh Cogliati (User:Jrincayc), jjcogliati-jan2007 AT yahoo.com
* Mitchell Aikens, LGIT, WSIT, AAS (User:msaikens)
* Kiah Morante (User:greenmanwitch)
* Elizabeth Cogliati
* James A. Brown
* Joe Oppegaard
* Benjamin Hell (User:Siebengang)

# Installation and Setup
### Installing Python and the Linkbot Control Module (PyBarobo)

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 sufficient for the beginning programmer. As you get more into programming, you will probably switch to some other editor like emacs, vi or another editor.
The Python download page is: https://www.python.org/downloads/. The most recent version is Python 3.10.6 (as of 8th August 2022); Python 2.7 and older versions will not work with 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:

#### Ubuntu Linux Users

To install everything you need to run this curriculum, which includes Python 3, Python 3 setup tools, and the Barobo Python package, make sure you have an internet connection and run these commands in a terminal window:
You will also have to add your user account to the "dialout" group. You can do this by using the command:
The above command will add whatever user you are logged in as to the "dialout" group. If you wish to add a user account that is not the one that is logged in, replace "$USER" with the user name of the other account. You may have to log out and log back in for the change to take effect.
For other distributions of Linux, follow the instructions provided by either your distribution or on the Python website to get Python 3, NumPy, and PyBarobo installed.

#### Raspberry Pi (Raspbian) Users

Raspbian comes with Python 3 and numpy installed by default. To get the Raspberry Pi ready to control the Linkbot, make sure your Pi is connected to the internet and type the following commands:
You may have to log out and log back in again for the changes to take effect.

#### Mac users

Starting from Mac OS X (Tiger), Python ships by default with the operating system, but you will need to update to Python 3 until OS X starts including Python 3 (check the version by starting python3 in a command line terminal). Also IDLE (the Python editor) might be missing in the standard installation. If you want to (re-)install Python, get the MacOS installer from the Python download site.

#### Windows users

Download the appropriate Windows installer (the x86 MSI installer, if you do not have a 64-bit AMD or Intel chip). Even if you do have a 64-bit chip, I would still recommend downloading the 32-bit version because some of the Barobo Linkbot libraries are pre-built for 32-bit system by default. Start the installer by double-clicking it and follow the prompts. Be sure to include the optional package "pip", which can come in handy for installing additional Python modules and add-ons.
Once Python is installed and the path is configured, open a command prompt and type the following command:
See https://docs.python.org/3/using/windows.html#installing-python for more information.

##### Configuring your PATH environment variable

The PATH environment variable is a list of folders, separated by semicolons, in which Windows will look for a program whenever you try to execute one by typing its name at a Command Prompt. You can see the current value of your PATH by typing this command at a Command Prompt:
echo %PATH%
The easiest way to permanently change environment variables is to bring up the built-in environment variable editor in Windows. How you get to this editor is slightly different on different versions of Windows.
On Windows 8: Press the Windows key and type Control Panel to locate the Windows Control Panel. Once you've opened the Control Panel, select View by: Large Icons, then click on System. In the window that pops up, click the Advanced System Settings link, then click the Environment Variables... button.
On Windows 7 or Vista: Click the Start button in the lower-left corner of the screen, move your mouse over Computer, right-click, and select Properties from the pop-up menu. Click the Advanced System Settings link, then click the Environment Variables... button.
On Windows XP: Right-click the My Computer icon on your desktop and select Properties. Select the Advanced tab, then click the Environment Variables... button.
Once you've brought up the environment variable editor, you'll do the same thing regardless of which version of Windows you're running. Under System Variables in the bottom half of the editor, find a variable called PATH. If there is one, select it and click Edit.... Assuming your Python root is C:\Python34, add these two folders to your path (and make sure you get the semicolons right; there should be a semicolon between each folder in the list):
C:\Python34 C:\Python34\Scripts
Note: If you want to double-click and start your Python programs from a Windows folder and not have the console window disappear, you can add the following code to the bottom of each script:

# Intro
### First things first

The Advanced Python 3 lessons before you are geared toward furthering your knowledge and abilities with programming using Python. The tutorials are designed to allow you to interact with the Linkbot robots by programming them to move in very specific ways. By seeing the Linkbot respond to your programming commands via code that you write, your abilities to use Python coding will motivate you to learn even more. First, you will just type in the code that is displayed in the tutorial to see how the Linkbot responds. Then, you will make your own changes to that code to play around with the Linkbot's abilities. The worst thing that can happen is that the program won't work and nothing will happen with the robot, so feel free to play with the code. When you are expected to type in code, it will look like this:
The reason that it will be formatted this way is to make code you need to type easy to distinguish from other text. Additionally, the code will be in color with different parts in different colors to help you see the code's distinct parts. When you enter code, it will not necessarily be in color, but it won't matter as long as you type it the same way that it is written here.
If the computer prints something out it will be formatted like this:
(Note that printed text goes to your screen, and does not involve paper. Before computers had screens, the output of computer programs would be printed on paper.)
Please notice that these Advanced Python lessons are set up for Python 3, which means that most of the examples will not work in Python 2.7 and previous versions. Additionally, some of the extra lessons created by other programmers like you may not have been converted to Python 3. However, the differences between one version of Python and another are not really large, so if you learn how to code in one version, you should be able to read programs written for the other version without too much difficulty. At some point, you might want to look at the Non-Programmer's Tutorial for Python 2.6.
There will often be a mixture of the text you type (which is shown in bold) and the text the program prints on the screen, which would look like this:
These lessons will introduce you to the terminology or vocabulary of programming. For example, programming is also often called coding or hacking. By learning the special vocabulary of programming, you will be able to understand what programmers are talking about and sound like a programmer yourself.
Finally, it's very important for your success with these lessons that you have Python 3 software. If you don't already have the Python software, go to http://www.python.org/download/ and get the Python 3 version for your computer platform. Most likely if you are learning in a classroom, your teacher will already have done this for you beforehand. If not, download it, read the instructions, and install the program.

### Installing Python and the Linkbot Control Module (PyBarobo)

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 sufficient for the beginning programmer. As you get more into programming, you will probably switch to some other editor like emacs, vi or another editor.
The Python download page is: http://www.python.org/download. The most recent version is Python 3.4.2 (as of 18th October 2014); Python 2.7 and older versions will not work with 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:

#### Ubuntu Linux Users

To install everything you need to run this curriculum, which includes Python 3, Python 3 setup tools, and the Barobo Python package, make sure you have an internet connection and run these commands in a terminal window:
You will also have to add your user account to the "dialout" group. You can do this by using the command:
The above command will add whatever user you are logged in as to the "dialout" group. If you wish to add a user account that is not the one that is logged in, replace "$USER" with the user name of the other account. You may have to log out and log back in for the change to take effect.
For other distributions of Linux, follow the instructions provided by either your distribution or on the Python website to get Python 3, NumPy, and PyBarobo installed.

#### Raspberry Pi (Raspbian) Users

Raspbian comes with Python 3 and numpy installed by default. To get the Raspberry Pi ready to control the Linkbot, make sure your Pi is connected to the internet and type the following commands:
You may have to log out and log back in again for the changes to take effect.

#### Mac users

Starting from Mac OS X (Tiger), Python ships by default with the operating system, but you will need to update to Python 3 until OS X starts including Python 3 (check the version by starting python3 in a command line terminal). Also IDLE (the Python editor) might be missing in the standard installation. If you want to (re-)install Python, get the MacOS installer from the Python download site.

#### Windows users

Download the appropriate Windows installer (the x86 MSI installer, if you do not have a 64-bit AMD or Intel chip). Even if you do have a 64-bit chip, I would still recommend downloading the 32-bit version because some of the Barobo Linkbot libraries are pre-built for 32-bit system by default. Start the installer by double-clicking it and follow the prompts. Be sure to include the optional package "pip", which can come in handy for installing additional Python modules and add-ons.
Next, you will need to install a driver, which is available here: Installer. Follow the link, download the file and run it. Once Python is installed and the path is configured, open a windows command prompt and type the following command:
See https://docs.python.org/3/using/windows.html#installing-python for more information.

##### Configuring your PATH environment variable

The PATH environment variable is a list of folders, separated by semicolons, in which Windows will look for a program whenever you try to execute one by typing its name at a Command Prompt. You can see the current value of your PATH by typing this command at a Command Prompt:
echo %PATH%
The easiest way to permanently change environment variables is to bring up the built-in environment variable editor in Windows. How you get to this editor is slightly different on different versions of Windows.
On Windows 8: Press the Windows key and type Control Panel to locate the Windows Control Panel. Once you've opened the Control Panel, select View by: Large Icons, then click on System. In the window that pops up, click the Advanced System Settings link, then click the Environment Variables... button.
On Windows 7 or Vista: Click the Start button in the lower-left corner of the screen, move your mouse over Computer, right-click, and select Properties from the pop-up menu. Click the Advanced System Settings link, then click the Environment Variables... button.
On Windows XP: Right-click the My Computer icon on your desktop and select Properties. Select the Advanced tab, then click the Environment Variables... button.
Once you've brought up the environment variable editor, you'll do the same thing regardless of which version of Windows you're running. Under System Variables in the bottom half of the editor, find a variable called PATH. If there is one, select it and click Edit.... Assuming your Python root is C:\Python34, add these two folders to your path (and make sure you get the semicolons right; there should be a semicolon between each folder in the list):
C:\Python34 C:\Python34\Scripts
Note: If you want to double-click and start your Python programs from a Windows folder and not have the console window disappear, you can add the following code to the bottom of each script:

### Interactive Mode

Go into IDLE (also called the Python GUI). You should see a window that has some text like this:
The >>> is Python's way of telling you that you are in interactive mode. In interactive mode what you type is immediately run. Try typing 1+1 in. Python will respond with 2. Interactive mode allows you to test out and see what Python will do. If you ever feel you need to play with new Python statements, go into interactive mode and try them out.

### Creating and Running Programs

Go into IDLE if you are not already. In the menu at the top, select File then New Window. In the new window that appears, type the following:
Now save the program: select File from the menu, then Save. Save it as "hello.py" (you can save it in any folder you want). Now that it is saved it can be run. Just a Rookies note here, if you change a program, save it with a version notation like helloV1.py that way you won't change your original program that worked.
Next run the program by going to Run then Run Module (or if you have an older version of IDLE use Edit then Run script). This will output Hello, World! on the *Python Shell* window.
For a more in-depth introduction to IDLE, a longer tutorial with screenshots can be found at http://hkn.eecs.berkeley.edu/~dyoo/python/idle_intro/index.html

#### Program file names

It is very useful to stick to some rules regarding the file names of Python programs. Otherwise some things might go wrong unexpectedly. These don't matter as much for programs, but you can have weird problems if you don't follow them for module names (modules will be discussed later).
* Always save the program with the extension .py. Do not put another dot anywhere else in the file name.
* Only use standard characters for file names: letters, numbers, dash (-) and underscore (_).
* White space (" ") should not be used at all (use underscores instead).
* Do not use anything other than a letter (particularly no numbers!) at the beginning of a file name.
* Do not use "non-english" characters (such as ä, ö, ü, å or ß) in your file names—or, even better, do not use them at all when programming.

### Using Python from the command line

If you don't want to use Python from the command line, you don't have to, just use IDLE. To get into interactive mode just type python3 without any arguments. To run a program, create it with a text editor (Emacs has a good Python mode) and then run it with python3 program_name.
Additionally, to use Python within Vim, you may want to visit Python wiki page about VIM

#### Running Python Programs in *nix

If you are using Unix (such as Linux, Mac OS X, or BSD), if you make the program executable with chmod, and have as the first line:
you can run the python program with ./hello.py like any other command.

### Where to get help

At some point in your Python career you will probably get stuck and have no clue about how to solve the problem you are supposed to work on. This tutorial only covers the basics of Python programming, but there is a lot of further information available.

#### Python documentation

First of all, Python is very well documented. There might even be copies of these documents on your computer, which came with your Python installation:
* The official Python 3 Tutorial by Guido van Rossum is often a good starting point for general questions.
* For questions about standard modules (you will learn what this is later), the Python 3 Library Reference is the place to look at.
* If you really want to get to know something about the details of the language, the Python 3 Reference Manual is comprehensive but quite complex for beginners.

#### Python user community

There are a lot of other Python users out there, and usually they are nice and willing to help you. Before you ask the Python user community a question, everyone will appreciate it if you do a web search for a solution to your problem before contacting the community. This very active user community is organized mostly through mailing lists and a newsgroup:
* The tutor mailing list is for people who want to ask questions regarding how to learn computer programming with the Python language.
* The python-help mailing list is python.org's help desk. You can ask a group of knowledgeable volunteers questions about all your Python problems.
* The Python newsgroup comp.lang.python (Google groups archive) is the place for general Python discussions, questions, and the central meeting point of the community.
* Python wiki has a list of local user groups, you can join the group mailing list and ask questions. You can also participate in the user group meetings.

# Hello, World
### What you should know

Once you've completed this chapter, you will know how to edit programs in a Python Editor, IDLE 3, or some other text editor, save them, and run them.

### Printing

Since the beginning of programming tutorials, "Hello World!" has been the first foray into creating something on the screen, here is how to do it with Python:
If you are using the command line to run this program, then type it in a text editor, save it as hello.py and run it with python3.0 hello.py
Otherwise go into your Python Editor, create a new file (Ctrl + N for IDLE), and create the program as in section Creating and Running Programs.
When this program is run here's what it prints:
Remember, whenever you see code as an example, it's a good idea for you to type it in and run it. Learning by doing can be a powerful tool! It is worth the time it takes.
Here is a modified 'Hello World' using the Linkbot to say hello. Comments are added to help you understand what the code is doing step by step.
Feel free to chance the frequency of the buzzer to change the tone, and the duration of time.sleep to see what that does to the greeting.
Now here is are a few more program:
When you run this program it prints out:
When the computer runs this program it first sees the line (like one sentence of code):
so the computer prints:
Then the computer goes down to the next line and sees:
So the computer prints to the screen:
The computer keeps looking at each line, follows the command and then goes on to the next line. The computer keeps running commands until it reaches the end of the program.

#### Controlling a Linkbot LED Color

Linkbots are equipped with a multi-color LED, which is basically just a light that can change colors. Lets try a simple program to control the LED color on a Linkbot. To get started, follow these steps:
* Turn on your Linkbot by holding down the power button until the Linkbot flashes a bright red light.
* After about 5 seconds, the Linkbot will beep and show a blue light. Your Linkbot is now on!
* Take a Micro-USB cable and connect the Linkbot to your computer.
* Open your text editor and try the following code:https://en.wikibooks.org/wiki/Learning_Python_3_with_the_Barobo_Linkbot
When you run this program, you should notice that your Linkbot turned green! In the code that you wrote, there were three numbers: 0, 255, and 0. These three numbers determine the brightness of the red, green, and blue LEDs inside the linkbot, where 0 denotes the lowest brightness setting and 255 the maximum setting. If you want to try making your Linkbot a brilliant purple color, try setting the color numbers to "255, 0, 255". This tells the Linkbot to turn on its red and blue LED's to their maximum brightness. When the red light blends with the blue light, it appears purple!

#### Terminology

Now is probably a good time to give you a bit of an explanation of what is happening - and a little bit of programming terminology.
What we were doing above was using a function called print. The function's name - print - is followed by parentheses containing zero or more arguments. So in this example
there is one argument, which is "Hello, World!". Note that this argument is a group of characters enclosed in double quotes (""). This is commonly referred to as a string of characters, or string, for short. Another example of a string is "Jack and Jill went up a hill". The combination of a function and parentheses with the arguments is a function call.
A function and its arguments are one type of statement that python has, so
is an example of a statement. Basically, you can think of a statement as a single line in a program.
That's probably more than enough terminology for now.

### Expressions

Here is another program:
And here is the output when the program is run:
As you can see, Python can turn your thousand-dollar computer into a five-dollar calculator.
In this example, the print function is followed by two arguments, with each of the arguments separated by a comma. So with the first line of the program
The first argument is the string "2 + 2 is" and the second argument is the mathematical expression 2 + 2, which is commonly referred to as an expression.
What is important to note is that a string is printed as is (without the enclosing double quotes), but an expression is evaluated, or converted to its actual value.
Python has seven basic operations for numbers:
| Operation | Symbol | Example |
| Power (exponentiation) | ** | 5 ** 2 == 25 |
| Multiplication | * | 2 * 3 == 6 |
| Division | / | 14 / 3 == 4.666666666666667 |
| Integer Division | // | 14 // 3 == 4 |
| Remainder (modulo) | % | 14 % 3 == 2 |
| Addition | + | 1 + 2 == 3 |
| Subtraction | - | 4 - 3 == 1 |
Notice that there are two ways to do division, one that returns the repeating decimal, and the other that can get the remainder and the whole number.
The order of operations is the same as in math:
* parentheses
* exponents **
* multiplication *, division /, integer division //, and remainder %
* addition + and subtraction -
So use parentheses to structure your formulas when needed.

### Talking to humans (and other intelligent beings)

Often in programming you are doing something complicated and may not in the future remember what you did. When this happens the program should probably be commented. A comment is a note to you and other programmers explaining what is happening. For example:
Which outputs
Notice that the comment starts with a hash: #. Comments are used to communicate with others who read the program and your future self to make clear what is complicated.
Note that any text can follow a comment, and that when the program is run, the text after the # through to the end of that line is ignored. The # does not have to be at the beginning of a new line:

### Examples

Each chapter (eventually) will contain examples of the programming features introduced in the chapter. You should at least look over them and see if you understand them. If you don't, you may want to type them in and see what happens. Mess around with them, change them and see what happens.
Denmark.py
Output:
School.py
Output:

### Exercises

* Write a program that prints your full name and your birthday as separate strings.
* Write a program that shows the use of all 7 math functions.
1. Write a program that prints your full name and your birthday as separate strings.
2. Write a program that shows the use of all 7 math functions.

#### Footnotes

* ↑ Here is a great list of the famous "Hello, world!" program in many programming languages. Just so that you know how simple Python can be...

# Who Goes There?
### Input and Variables

You are now ready to create a more complicated program. Type the following into your Python Editor:
Run your program to ensure that it displays the following:
Note: After running the code by pressing F5 on your keyboard, the Python Shell will only give the output:
Enter your name in the Python Shell and press enter for the remainder of the output.
Your program will look different because of the input statement. Notice that, when running the program, you must type your name and press 'Enter'. The program responds by displaying text that includes your name. This is an example of input. The program reaches a certain point, and then waits for the user to type more data for the program to include.
The user's data that the program includes is stored as a variable. In the previous program user_input is a variable. A variable is like a box that can store a piece of data. This program demonstrates the use of variables:
(Helpful blurb, Aaron, "This may not make a lot of sense right now, but refer back to it as you read the paragraph about variables.")
And here is the output:
Variables store data, such as a number, a word, a phrase, or anything you choose to make it. The variables in the above program are a, b23, first_name, b, and c. The two basic types of variables are numbers and strings. Numbers are simply a mathematical, numerical number, such as 7 or 89 or -3.14. In the above example, a, b, and even c are number variables. c is considered a number variable because the result is a number. Strings are a sequence of letters, numbers and other characters. In this example b23 and first_name are variables that store strings. Barobo, Linkbot, a + b is, first_name is, and The Linkbot was created by are the strings in this program. The characters are surrounded by " or '. The other types of symbols used in the program are variables representing numbers. Remember that variables are used to store a value, they do not use punctuation marks (" and '). If you want to use an actual value, you must use those punctuation marks. See the next example.
Both lines of code look the same at first glance, but they are different. In the first one, Python checks if the value stored in the variable value1 is the same as the value stored in the variable Pim. In the second one, Python checks if the string (the actual letters P,i, and m) are the same as in value2 (More explanation about strings and about the == come later).

### Assignment

In review, there are boxes called variables, and data goes into those boxes. Recall the previous examples. The computer sees a line such as first_name = "Linkbot", and it reads it as "put the string Linkbot into the box, or variable, first_name". Then the computer sees the statement c = a + b, and it reads it as "put the sum of a + b or 123.4 + 432 which equals 555.4 into c". The right hand side of the statement a + b is evaluated, meaning that the two terms are equal, and the result is stored in the variable on the left hand side c. In other words, one side of the statement is assigned to the other side. This process is called assignment.
One single equal sign in coding makes the line of code a grammatical statement. For example, apple = banana reads "apple is banana." By writing the code in this way, apple is assigned to banana, and they are now considered equal by the program.You are basically telling the program that the two terms are equal, even if that is not in actuality the case.
Two equal signs together makes the line of code into a question that the computer will answer. For example, apple == banana reads "is apple equal to banana?" This answer would be "no," of course, unless you have previously and incorrectly assigned apple to banana.
(Helpful blurb, Aaron, "Be careful how many = you use because it can change your program entirely!")
Here is another example of variable usage:
Here is the output:
Even if the same variable appears on both sides of the equals sign (e.g., spam = spam), the computer still reads it as, "First find out the data to store, and then find out where the data goes."
Try another program:
The output should be:
Notice that number was created with float(input) while text was created with input. input returns a string while the function float returns a number from a string. int returns an integer, that is a number with no decimal point. When you want the user to type in a decimal use float(input), if you want the user to type in an integer use int(input), but if you want the user to type in a string use input.
The second half of the program uses the type function which identifies a variable's type. Numbers are of type int or float, which are short for integer and floating point (mostly used for decimal numbers), respectively. Text strings are of type str, short for string. Integers and floats can be worked on by mathematical functions, strings cannot. Notice how when python multiplies a number by an integer the expected thing happens. However when a string is multiplied by an integer the result is that multiple copies of the string are produced (i.e., text * 2 = HelloHello).
Operations with strings do different things than operations with numbers. As well, some operations only work with numbers (both integers and floating point numbers) and will give an error if a string is used. Here are some interactive mode examples to show that some more.
Here is the list of some string operations:
| Operation | Symbol | Example |
| Repetition | * | "i" * 5 == "iiiii" |
| Concatenation | + | "Hello, " + "World!" == "Hello, World!" |

### Moving a Linkbot's Motor

Each Linkbot has two joints that it can move to do a variety of tasks. Sometimes, there might be wheels attached to the joints so that the Linkbot can drive around like a two-wheeled car. Or, the joints might be attached to a gripper, which would allow a Linkbot to pick up objects.
Each joint on a Linkbot has a number printed into the plastic. Looking at the Linkbot directly from a "top down" view, joint 1 is on the left side, joint 2 faces you, and joint 3 is on the right hand side. The Linkbot-L only has joints 1 and 2 and the Linkbot-I only has joints 1 and 3. Lets learn how to move a joint on a Linkbot!
moveMotor.py
When you run this example, you should notice joint 1 move. If you typed "90" for the input, you should see the joint rotate counter-clockwise 90 degrees. If you typed "-90", you should see the joint move 90 degrees in the clockwise direction. When you run this program, be careful about entering very large numbers or else you might have to wait a while for the joint to stop moving.

### Examples

Rate_times.py
Sample runs:
Area.py
Sample runs:
Temperature.py
Sample runs:

### Exercises

Write a program that gets 2 string variables and 2 number variables from the user, concatenates (joins them together with no spaces) and displays the strings, then multiplies the two numbers on a new line.
Write a program that gets 2 string variables and 2 number variables from the user, concatenates (joins them together with no spaces) and displays the strings, then multiplies the two numbers on a new line.
Write a program that gets 2 number variables from the user; each one an angle in degrees. After the program gets the two numbers, it makes the Linkbot rotate joint 1 by the amount in the first number, and then joint 3 (or 2, if you have a Linkbot-L) by the second number.

# Count to 10

Lesson Information

### While loops

Ordinarily the computer starts with the first line and then goes down from there. Control structures change the order that statements are executed or decide if a certain statement will be run. Here's the source for a program that uses the while control structure:
And here is the extremely exciting output:
(And you thought it couldn't get any worse after turning your computer into a five-dollar calculator?)
So what does the program do? First it sees the line a = 0 and sets a to zero. Then it sees while a < 10: and so the computer checks to see if a < 10. The first time the computer sees this statement, a is zero, so it is less than 10. In other words, as long as a is less than ten, the computer will run the tabbed in statements. This eventually makes a equal to ten (by adding one to a again and again) and the while a < 10 is not true any longer. Reaching that point, the program will stop running the indented lines.
Always remember to put a colon ":" at the end of the while statement line!
Here is another example of the use of while:
Notice how print 'Total Sum =', s is only run at the end. The while statement only affects the lines that are indented with whitespace. The != means does not equal so while a != 0: means as long as a is not zero run the tabbed statements that follow.
Note that a is a floating point number, and not all floating point numbers can be accurately represented, so using != on them can sometimes not work. Try typing in 1.1 in interactive mode.

#### Infinite loops or Never Ending Loop

Now that we have while loops, it is possible to have programs that run forever. An easy way to do this is to write a program like this:
The "==" operator is used to test equality of the expressions on the two sides of the operator, just as "<" was used for "less than" before (you will get a complete list of all comparison operators in the next chapter).
This program will output Help, I'm stuck in a loop. until the heat death of the universe or you stop it, because 1 will forever be equal to 1. The way to stop it is to hit the Control (or Ctrl) button and C (the letter) at the same time. This will kill the program. (Note: sometimes you will have to hit enter after the Control-C.) On some systems, nothing will stop it, short of killing the process--so avoid!

### Examples
#### Fibonacci sequence

Fibonacci-method1.py
Output:
Note that the output is on a single line because of the extra argument end=" " in the print arguments.
Fibonacci-method2.py
Output:

#### Enter password

Password.py
Sample run:

#### A Linkbot Musical Example

The Linkbot has a small buzzer on board that can play one note at a time. We can control the frequency of the buzzer on the Linkbot to generate different tones. The equation $\mathrm {pianokeyFrequency} =2^{((\mathrm {key} -49)/12)}*440$ shows how to calculate the frequency of a key on a piano. There are 88 keys on a real piano, but lets see if we can make our robot play from the 34th key all the way up to the 73rd key.
In Python, to calculate the "power" of a number, we can use the ** operator. For instance, $2^{3}$ can be calculated in Python using 2**3.

### Exercises

Write a program that asks the user for a Login Name and password. Then when they type "lock", they need to type in their name and password to unlock the program.
Write a program that asks the user for a Login Name and password. Then when they type "lock", they need to type in their name and password to unlock the program.
If you would like the program to run continuously, just add a while 1 == 1: loop around the whole thing. You will have to indent the rest of the program when you add this at the top of the code, but don't worry, you don't have to do it manually for each line! Just highlight everything you want to indent and click on "Indent" under "Format" in the top bar of the python window.
Another way of doing this could be:
Notice the or in while (nameguess != name) or (passwordguess != password), which we haven't yet introduced. You can probably figure out how it works.
Modify the Linkbot Buzzer program to play every third key on the piano from the 34th key up to the 74th key.

# Decisions
### If statement

As always I believe I should start each chapter with a warm-up typing exercise, so here is a short program to compute the absolute value of an integer:
Here is the output from the two times that I ran this program:
So what does the computer do when it sees this piece of code? First it prompts the user for a number with the statement "n = int(input("Number? "))". Next it reads the line "if n < 0:". If n is less than zero Python runs the line "print("The absolute value of", n, "is", -n)". Otherwise it runs the line "print("The absolute value of", n, "is", n)".
More formally Python looks at whether the expression n < 0 is true or false. An if statement is followed by an indented block of statements that are run when the expression is true. Optionally after the if statement is an else statement and another indented block of statements. This second block of statements is run if the expression is false.
There are a number of different tests that an expression can have. Here is a table of all of them:
| operator | function |
| < | less than |
| <= | less than or equal to |
| > | greater than |
| >= | greater than or equal to |
| == | equal |
| != | not equal |
Another feature of the if command is the elif statement. It stands for else if and means if the original if statement is false but the elif part is true, then do the elif part. And if neither the if or elif expressions are true, then do what's in the else block. Here's an example:
and the output:
Notice how the elif a <= 3 is only tested when the if statement fails to be true. There can be more than one elif expression, allowing multiple tests to be done in a single if statement.

### Moving a Linkbot's Motors

In the previous chapter, Who Goes There?, we saw that you can move a linkbot's motor with the moveJoint function. It is typically used like:
where the first argument is the motor you want to move and the second argument is the angle in degrees you want to move it. The above code will move motor "1" in the positive direction by 180 degrees.
What if you want to move more than one motor at a time? The linkbot also has a move function that does just that. It looks something like this:
The move function expects three numbers inside the parentheses. The first number is the angle to move motor 1, the second number is the angle to move motor 2, and the third number is the angle to move motor 3. If your Linkbot only has two motors, the value for the face that does not have a motor is ignored. For example, if I have a Linkbot-I and I ran the above sample code, the "180" is ignored because motor 2 is not a movable motor. Instead, the Linkbot will move motor 1 forward 90 degrees and motor 3 forward 270 degrees.
When the move function is executed, the Linkbot will move any/all of its motors simultaneously.

#### command_linkbot.py

In this example, we'd like to create a program that we can use to move our Linkbot around. This demo will use the python break command. In the previous chapter, we saw that Python can get stuck in "infinite loops". The break command can be used to exit loops even if the loop condition is still true.
Lets start with just moving the Linkbot forward and backward first. To run this demo, you'll need a Linkbot-I and two wheels. A caster is also recommended but optional.
A Note on Strings
You might have noticed that towards the end of the program, there is a line that reads print('I\'m sorry. I don\'t understand that command.') with funny backslashes in the code. When you run the program though, it doesn't print those backslashes. These backslashes actually serve an important purpose.
When Python encounters either a single quote ' or double quote " , it knows that what follows will be a string that is terminated by the same type of quotation mark that started it. But, what if we want to include some quotation marks as part of the string? Consider the following piece of code:
When Python sees the first Quotation mark at "Hello th..., it says "Ok, this is going to be a string and as soon as I see another quotation mark, that will be the end of the string". Soon, Python sees another quotation mark at ...says "woof! and thinks "I've found the end of the string!", but this is not the end of our string! We wanted Python to go all the way to the end at ...bored." . How do we tell Python that the quotation marks around "woof!" are special, and that our string doesn't actually end there?
The answer is backslashes. If there is a backslash preceding a quotation mark, that is a special indicator to Python to include that quotation mark as part of the string, rather than terminating the string. Therefore, the fixed code should be:
In this example, the single quote in he's is automatically included as part of the string because the string started with a double-quotation mark, and thus Python is looking for a double-quotation mark to terminate the string.
Sample runs:

### Examples

equality.py
And the output
high_low.py
Sample run:
even.py
Sample runs:
average1.py
Sample runs:
average2.py
Sample runs:

### Exercises

Write a program that asks the user their name, if they enter your name say "That is a nice name", if they enter "John Cleese" or "Michael Palin", tell them how you feel about them ;), otherwise tell them "You have a nice name."
Modify the higher or lower program from this section to keep track of how many times the user has entered the wrong number. If it is more than 3 times, print "That must have been complicated." at the end, otherwise print "Good job!"
Write a program that asks for two numbers. If the sum of the numbers is greater than 100, print "That is a big number."
Modify the Linkbot program presented earlier to include the commands "turnright", "turnleft", and "beep". Make the "turnright" command turn the robot to the right, "turnleft" turn the robot to the left, and "beep" beep the robot buzzer for 1 second.

# Linkbot Multitasking
### "Non-blocking" Linkbot Functions

Lets take an inventory of all of the functions that we've used so far to control various aspects of the Linkbot.
| Function Name | Function Description |
| setLEDColor(r, g, b) | Changes the LED color based on red, green, and blue intensities. |
| setBuzzerFrequency(Hz) | Makes the Linkbot buzzer play a frequency in Hertz. |
| moveJoint(jointNum, degrees) | Makes a single motor move. |
| move(degrees, degrees, degrees) | Makes multiple motors move simultaneously |
Using these functions, we can move our robot around, change the robot's LED color, and make the robot beep or play simple melodies. However, using only these functions, it is not possible to make a robot play a tune and change its LED colors while the robot is moving. For example, lets say we want to make our robot beep 2 times _while_ our robot is moving. We can try something like this:
Lets reason our way through each major point of this program.
* First, we turn on the buzzer on the Linkbot. It starts buzzing
* Pause the program for 0.25 seconds
* Turn off the Linkbot's buzzer.
* Pause the program for another 0.25 seconds. The end result of steps 1-4 is that the Linkbot buzzes its buzzer for 0.25 seconds. The next four lines do the same exact thing.
* At this point, the Linkbot has buzzed twice, and now the move function makes the Linkbot roll forward.
This is almost what we want to do, except we want the robot to beep twice while the robot is moving; not before it starts moving. Lets try again:
This program is almost exactly the same as the program before except we relocated the move function to the beginning of the program. Will this program make the robot beep twice as the robot is moving?
* First, we call the move function which moves the robot's motors. The robot begins moving. However, the program stays at item 1 until the move function is completed. After the robot finishes moving, the program continues.
* Here, the robot turns the buzzer on similar to the previous example. Using setBuzzerFrequency and time.sleep, it makes the buzzer beep twice.

### The moveNB Function

As we can see, we have failed yet again to make the robot beep twice while moving. In order to make the robot do these things simultaneously, we must use a similar but new type of function: Non-blocking functions. Lets take a look at an example:
* Here, instead of using the move function, we use the moveNB function.
The "NB" in the function name stands for "non-blocking". Both functions move the motors on the Linkbot, but there is one important difference: The NB version of the function "returns" immediately. What this means is Python continues on to the next line of code immediately without waiting for the movement to finish first. In other words, the moveNB function does not "block" Python from continuing on immediately after the function is called.
* Now, the Linkbot begins playing its buzzer while the Linkbot is still moving. We've accomplished our task! This program will move the robot and beep twice while the robot is moving.

### The moveWait Function

Now lets try one more example. Lets say we want to make the robot move its wheels 180 degrees to roll forward while beeping twice, and then change the LED color to green after the movement is done. To accomplish this, we introduce the moveWait function. Lets take a look and see how it works:
* As before, this line tells the robot to begin moving motors 1 and 3. Since we used the "NB" version of the function, Python continues directly on to the next line of code even though the robot is still moving.
* The next several lines of code beep the robot twice, similar to before.
* Here, we call a function called moveWait. This function blocks until all motor movements on the robot are finished. In effect, Python will wait at # 3 until the motors are done moving.
* Here, we set the LED color to green.
If we had omitted moveWait at # 3, the LED color would've been set whether the motors were still moving or not. By using the moveWait function, we force Python to wait for the motors to stop moving before setting the LED color.

### Other Non-Blocking Functions

Almost all Linkbot movement commands have a non-blocking version with the "NB" suffix. The ones that do not have a non-blocking version are the ones that move a Linkbot's motor continuously forever. We haven't explored any of them yet, but they are out there. These functions do not have non-blocking versions because they would block forever.
All of the functions that begin with the prefix "set", such as setBuzzerFrequency and setLEDColor, can be considered non-blocking because of how fast the buzzer and LED colors are set. For instance, if you run the following snippet of code:
The Linkbot would appear to start buzzing and change the LED color to green simultaneously. Technically, the robot is actually doing one before the other, but the two things happen so fast (typically within 5 milliseconds of each other) that it is practically simultaneous.

# Debugging
### What is debugging?

    "As soon as we started programming, we found to our surprise that it wasn't as easy to get programs right as we had thought. Debugging had to be discovered. I can remember the exact instant when I realized that a large part of my life from then on was going to be spent in finding mistakes in my own programs." — Maurice Wilkes discovers debugging, 1949
By now if you have been messing around with the programs you have probably found that sometimes the program does something you didn't want it to do. This is fairly common. Debugging is the process of figuring out what the computer is doing and then getting it to do what you want it to do. This can be tricky. It surprisingly common to spend weeks tracking down and fixing a bug that was caused by someone putting an x where a y should have been.
This chapter will be more abstract than previous chapters.

### What should the program do?

The first thing to do (this sounds obvious) is to figure out what the program should be doing if it is running correctly. Come up with some test cases and see what happens.
For instance, lets try to write a program that rolls a Linkbot-I with two wheels forward one rotation while making the LED green, and then rolls the Linkbot backward with the LED red. Here's a first try at this program:
At first glance, the above program may appear to be correct. When you actually try it though, you'll see that the robot never turns its LED green, and it never moves forward. It immediately changes its LED red and moves backward. What happened to the two lines that are supposed to make the robot roll forward and turn the LED green?
One easy and powerful method of debugging problems like this is to use the print function to track the progress of the program while it's running. Lets try adding some print statements to our original program and see if we can track down the problem:
When you run this program, pay attention not only to what it's printing, but also how and when it's printing. When you run the program, the output you should get is:
However, you'll notice that all of those statements print immediately; there is no delay between the commands that tell the robot to move forward and the commands that tell it to move backward. That should immediately give us an indication for what is wrong: the program should wait until the robot is finished moving forward before moving backward and turning red. You'll notice that we used non-blocking movement functions in our program so that we can move and change the LED color at the same time. However, we also know that Python doesn't stop and wait at non-blocking and "set" functions. From the previous chapter, we also have a function that makes Python wait until a non-blocking motion is completed called moveWait. Lets try fixing our broken program:
A moveWait statement has been added in-between the two steps. This forces Python to wait until the robot is done moving forward before telling it to move backward and set the LED color to red.
Without the moveWait statement, Python will go through all of those statements so fast that the robot rolling forward and green LED won't be noticeable to human eyes and ears. Only the last commands, rolling backward and the red LED, "stay" on the robot and are observable, making it seem like Python was skipping the moving forward and green LED altogether.

### General Tips

* This may sound obvious, but the first thing to ensure is that you know what the program is supposed to do.
* Check to make sure the program flow is correct by using print statements.
* Check to make sure variable values are correct using print statements.
* For complex programs that might use loops and variables, try "stepping" through the program, line by line, keeping track of variable values and program outputs using pen and paper.
* If you have a long program that does many calculations on a variable and the value of the variable is wrong at the end of the program, try using the "binary-search" method to find the bug: Use a print statement to check the value of the variable in the middle of the program. If the value is correct, you know the bug is somewhere in the second half of your program. Put another print statement in the middle of the second half of the program and check its value. Repeat until you've found the incorrect line of code that is incorrectly setting the variable's value. This technique is highly useful for finding where a bug might be occurring, and it is useful for many types of bugs.

# Defining Functions
### Creating Functions

To start off this chapter I am going to give you an example of what you could do but shouldn't (so don't type it in):
with the output being:
The program seems a little repetitive. Programmers hate to repeat things -- that's what computers are for, after all! (Note also that finding the absolute value changed the value of the variable, which is why it is printing out 23, and not -23 in the output.) Fortunately Python allows you to create functions to remove duplication. Here is the rewritten example:
with the output being:
The key feature of this program is the def statement. def (short for define) starts a function definition. def is followed by the name of the function absolute_value. Next comes a '(' followed by the parameter n (n is passed from the program into the function when the function is called). The statements after the ':' are executed when the function is used. The statements continue until either the indented statements end or a return is encountered. The return statement returns a value back to the place where the function was called. We already have encountered a function in our very first program, the print function. Now we can make new functions.
Notice how the values of a and b are not changed. Functions can be used to repeat tasks that don't return values. Here are some examples:
with output being:
That example shows some more stuff that you can do with functions. Notice that you can use no arguments or two or more. Notice also when a function doesn't need to send back a value, a return is optional.

### Variables in functions

When eliminating repeated code, you often have variables in the repeated code. In Python, these are dealt with in a special way. So far all variables we have seen are global variables. Functions have a special type of variable called local variables. These variables only exist while the function is running. When a local variable has the same name as another variable (such as a global variable), the local variable hides the other. Sound confusing? Well, these next examples (which are a bit contrived) should help clear things up.
When run, we will receive an output of:
Variable assignments inside a function do not override global variables, they exist only inside the function. Even though a was assigned a new value inside the function, this newly assigned value was only relevant to print_func, when the function finishes running, and the a's values is printed again, we see the originally assigned values.
Here is another more complex example.
In this example the variables a_var, b_var, and d_var are all local variables when they are inside the function a_func. After the statement return b_var + 10 is run, they all cease to exist. The variable a_var is automatically a local variable since it is a parameter name. The variables b_var and d_var are local variables since they appear on the left of an equals sign in the function in the statements b_var = 100 + a_var and d_var = 2 * a_var .
Inside of the function a_var has no value assigned to it. When the function is called with c_var = a_func(b_var), 15 is assigned to a_var since at that point in time b_var is 15, making the call to the function a_func(15). This ends up setting a_var to 15 when it is inside of a_func.
As you can see, once the function finishes running, the local variables a_var and b_var that had hidden the global variables of the same name are gone. Then the statement print("a_var = ", a_var) prints the value 10 rather than the value 15 since the local variable that hid the global variable is gone.
Another thing to notice is the NameError that happens at the end. This appears since the variable d_var no longer exists since a_func finished. All the local variables are deleted when the function exits. If you want to get something from a function, then you will have to use return something.
One last thing to notice is that the value of e_var remains unchanged inside a_func since it is not a parameter and it never appears on the left of an equals sign inside of the function a_func. When a global variable is accessed inside a function it is the global variable from the outside.
Functions allow local variables that exist only inside the function and can hide other variables that are outside the function.

### Linkbots in Functions : Making the Linkbot Move a Certain Distance

We've seen now that we can pass numbers and variables to a function in the function parameters. It turns out that you can pass just about anything into a function, including Linkbot objects. In the Chapter "Decisions", we wrote some code that could move a two-wheels linkbot around. In the code, we specified the angle to rotate the wheels, but it would be much cooler if we could tell the Linkbot to move some distance on the ground. When you're writing new functions, it's common to prototype how the function might be used before actually writing it, so lets try that now. We want our function to be used something like this:
Now that we're satisfied with how we want to use our function, now we have to worry about how to actually write it so that it does what we want it to do. First, let us catalog what we know and what we have. So far we know about 2 functions that we can use to move motors on the Linkbot: moveJoint and move. Of the two, we have found that move is probably better for driving two-wheeled Linkbots. However, the move function takes angles as arguments. That leaves the question: How do we turn a distance into an angle?
It turns out there is an equation that you can use to figure out how many degrees a wheel has to turn to travel a certain distance. The equation is: $\mathrm {degrees} ={\frac {360}{2\pi r}}*\mathrm {distance}$
If you would like to see a derivation where that equation comes from, click on the "derivation" link below.
To solve this question, we can consider how wheels roll on a surface. Let us consider a wheel rolling on a surface that doesn't slip on the surface because it will make our calculations easier. Let us consider the "circumference" of a wheel. If you took a string and wrapped it all the way around a circle, the length of that string is the "circumference". The circumference of a circle with radius "r" is
$\mathrm {circumference} =2\pi r$
The following figure illustrates a blue wheel with a green string wrapped around it. As the wheel rolls, the string unrolls off of the wheel.
As we can see from the figure, if the wheel rolls one full revolution, it travels one circumference of distance. Knowing that one revolution is 360 degrees, we can write a ratio:
${\frac {360}{2\pi r}}={\frac {\mathrm {degrees} }{\mathrm {distance} }}$
So if we want to travel a distance "distance", we can do
$\mathrm {degrees} ={\frac {360}{2\pi r}}*\mathrm {distance}$
Using this equation, if we know the wheel radius and we know what distance we want to travel, we can calculate the degrees to turn the wheel! Now we can write our function.
Now, we can include that equation in our function. This allows us to re-use the function for any distance and we don't have to type in the equation over and over again.
The program shown above uses the driveDistance function to drive a robot forward 10 inches and then backward 5 inches. You might wondering why we went through all the trouble of defining a function, which took four lines of code, when we could accomplish the same task without functions.
* Consider if the task was much more complex than just two movements. If you have to drive the robot forwards and backwards more than 4 times, you are actually saving time and code by using a function.
* Writing repeated code via copy/paste can be very hard to debug. Imagine if you copy and pasted the equation 20 times for 20 robot movements, and then you found a bug in the copy-pasted code. You would have to correct the bug in each one of the 20 pasted code blocks. If you had written a function with a bug in it, you would only have to fix the equation inside the function.
* If you are writing code for someone else to use, it would make sense to encapsulate your code in a function. Imagine if you are working with a team of people and your job is to write a function that moves the robot forward and backward, another person's job is to write a function that turns the robot, and a third person has to write a function that changes the LED color. You could then take all three functions and put them into a single program and have a robot that accurately drives a certain distance, turns, and changes LED color.

### Examples

temperature2.py
Sample Run:
area2.py
Sample Run:

### Exercises

Rewrite the area2.py program from the Examples above to have a separate function for the area of a square, the area of a rectangle, and the area of a circle (3.14 * radius**2). This program should include a menu interface.

# Advanced Functions Example

Some people find this section useful, and some find it confusing. If you find it confusing you can skip it. Now we will do a walk through for the following program:
Basically this program creates a positive integer multiplication function (that is far slower than the built in multiplication function) and then demonstrates this function with a use of the function. This program demonstrates the use of recursion, that is a form of iteration (repetition) in which there is a function that repeatedly calls itself until an exit condition is satisfied. It uses repeated additions to give the same result as mutiplication: e.g. 3 + 3 (addition) gives the same result as 3 * 2 (multiplication).

## Question: What is the first thing the program does?

    Answer: The first thing done is the function mult is defined with the lines:
    This creates a function that takes two parameters and returns a value when it is done. Later this function can be run.

## What happens next?

    The next line after the function, print("3 * 2 = ", mult(3, 2)) is run.

## And what does this do?

    It prints 3 * 2 = and the return value of mult(3, 2)

## And what does mult(3, 2) return?

    We need to do a walkthrough of the mult function to find out.

## What happens next?

    The variable a gets the value 3 assigned to it and the variable b gets the value 2 assigned to it.

## And then?

    The line if b == 0: is run. Since b has the value 2 this is false so the line return 0 is skipped.

## And what then?

    The line rest = mult(a, b - 1) is run. This line sets the local variable rest to the value of mult(a, b - 1). The value of a is 3 and the value of b is 2 so the function call is mult(3,1)

## So what is the value of mult(3, 1) ?

    We will need to run the function mult with the parameters 3 and 1.

## So what happens next?

    The local variables in the new run of the function are set so that a has the value 3 and b has the value 1. Since these are local values these do not affect the previous values of a and b.

## And then?

    Since b has the value 1 the if statement is false, so the next line becomes rest = mult(a, b - 1).

## What does this line do?

    This line will assign the value of mult(3, 0) to rest.

## So what is that value?

    We will have to run the function one more time to find that out. This time a has the value 3 and b has the value 0.

## So what happens next?

    The first line in the function to run is if b == 0:. b has the value 0 so the next line to run is return 0

## And what does the line return 0 do?

    This line returns the value 0 out of the function.

## So?

    So now we know that mult(3, 0) has the value 0. Now we know what the line rest = mult(a, b - 1) did since we have run the function mult with the parameters 3 and 0. We have finished running mult(3, 0) and are now back to running mult(3, 1). The variable rest gets assigned the value 0.

## What line is run next?

    The line value = a + rest is run next. In this run of the function, a = 3 and rest = 0 so now value = 3.

## What happens next?

    The line return value is run. This returns 3 from the function. This also exits from the run of the function mult(3, 1). After return is called, we go back to running mult(3, 2).

## Where were we in mult(3, 2)?

    We had the variables a = 3 and b = 2 and were examining the line rest = mult(a, b - 1).

## So what happens now?

    The variable rest get 3 assigned to it. The next line value = a + rest sets value to 3 + 3 or 6.

## So now what happens?

    The next line runs, this returns 6 from the function. We are now back to running the line print("3 * 2 = ", mult(3, 2)) which can now print out the 6.

## What is happening overall?

    Basically we used two facts to calculate the multiple of the two numbers. The first is that any number times 0 is 0 (x * 0 = 0). The second is that a number times another number is equal to the first number plus the first number times one less than the second number (x * y = x + x * (y - 1)). So what happens is 3 * 2 is first converted into 3 + 3 * 1. Then 3 * 1 is converted into 3 + 3 * 0. Then we know that any number times 0 is 0 so 3 * 0 is 0. Then we can calculate that 3 + 3 * 0 is 3 + 0 which is 3. Now we know what 3 * 1 is so we can calculate that 3 + 3 * 1 is 3 + 3 which is 6.
This is how the whole thing works:

#### Recursion

Programming constructs solving a problem by solving a smaller version of the same problem are called recursive. In the examples in this chapter, recursion is realized by defining a function calling itself. This facilitates implementing solutions to programming tasks as it may be sufficient to consider the next step of a problem instead of the whole problem at once. It is also useful as it allows to express some mathematical concepts with straightforward, easy to read code.
Any problem that can be solved with recursion could be re-implemented with loops. Using the latter usually results in better performance. However equivalent implementations using loops are usually harder to get done correctly.
Probably the most intuitive definition of recursion is:

##### Recursion

    If you still don't get it, see recursion.
Try walking through the factorial example if the multiplication example did not make sense.

### Examples

factorial.py
Output:
countdown.py
Output:

# 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. These are called containers because they can contain more than one object. 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 in interactive mode 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. To get help on all the functions a list provides for you, type help(list) in the interactive Python interpreter.
The line # Next we will loop through the list is a just a reminder to the programmer (also called a comment). Python ignores everything that is written after a # on the current line. 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.
A much better way to do the above is:
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 |
| another_list.sort | sorts another_list. Note that the list must be all numbers or all strings to be sorted. |
| 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 an 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). Please note that get_questions is essentially a list because even though it's technically a function, returning a list of lists is the only thing it does.
Sample Output:
LinkbotMelody.py
We can also create our own lists of items and use for loops to loop through them. Lets try making a list of keyboard keys to play in order to play a simple tune. We'll write this program using the knowledge that middle-C is the 40th key on our keyboard. When you run this program, it should play the beginning of a very familiar tune. Can you guess what it is?

### 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".

# For Loops

And here is the new typing exercise for this chapter:
and the ever-present output:
The output looks awfully familiar but the program code looks different. The first line uses the range function. The range function uses two arguments like this range(start, finish). start is the first number that is produced. finish is one larger than the last number. Note that this program could have been done in a shorter way:
The range function returns an iterable. This can be converted into a list with the list function.
Here are some examples to show what happens with the range command:
The next line for count in onetoten: uses the for control structure. A for control structure looks like for variable in list:. list is gone through starting with the first element of the list and going to the last. As for goes through each element in a list it puts each into variable. That allows variable to be used in each successive time the for loop is run through. Here is another example (you don't have to type this) to demonstrate:
The output is:
Notice how the for loop goes through and sets item to each element in the list. So, what is for good for? The first use is to go through all the elements of a list and do something with each of them. Here's a quick way to add up all the elements:
with the output simply being:
The sum is: 20
Or you could write a program to find out if there are any duplicates in a list like this program does:
and for good measure:
Okay, so how does it work? Here is a special debugging version to help you understand (you don't need to type this in):
with the output being:
The reason I put so many print statements in the code was so that you can see what is happening in each line. (By the way, if you can't figure out why a program is not working, try putting in lots of print statements in places where you want to know what is happening.) First the program starts with a boring old list. Next the program sorts the list. This is so that any duplicates get put next to each other. The program then initializes a prev(ious) variable. Next the first element of the list is deleted so that the first item is not incorrectly thought to be a duplicate. Next a for loop is gone into. Each item of the list is checked to see if it is the same as the previous. If it is a duplicate was found. The value of prev is then changed so that the next time the for loop is run through prev is the previous item to the current. Sure enough, the 7 is found to be a duplicate. (Notice how \t is used to print a tab.)
The other way to use for loops is to do something a certain number of times. Here is some code to print out the first 9 numbers of the Fibonacci series:
with the surprising output:
Everything that can be done with for loops can also be done with while loops but for loops give an easy way to go through all the elements in a list or to do something a certain number of times.

### A Linkbot Example

In this example the Linkbot will play changing tones a fixed number of times while the duration remains constant. The Linkbot can also change tone and duration a fixed number of times. Here we are using a for loop running with in a fixed range of values.
setBuzzerFrequency.py
When you run this example play around with the loop range and time values to create interesting sounds.

# Boolean Expressions

Here is a little example of boolean expressions (you don't have to type it in):
With the output being:
What is going on? The program consists of a bunch of funny looking print statements. Each print statement prints a number and an expression. The number is to help keep track of which statement I am dealing with. Notice how each expression ends up being either False or True. In Python false can also be written as 0 and true as 1.
The lines:
print out a True and a False respectively just as expected since the first is true and the second is false. The third print, print(3, a == 6 and b == 7), is a little different. The operator and means if both the statement before and the statement after are true then the whole expression is true otherwise the whole expression is false. The next line, print(4, a == 7 and b == 7), shows how if part of an and expression is false, the whole thing is false. The behavior of and can be summarized as follows:
| expression | result |
| true and true | true |
| true and false | false |
| false and true | false |
| false and false | false |
Notice that if the first expression is false Python does not check the second expression since it knows the whole expression is false. Try running False and print("Hi") and compare this to running True and print("Hi") The technical term for this is short-circuit evaluation
The next line, print(5, not a == 7 and b == 7), uses the not operator. not just gives the opposite of the expression. (The expression could be rewritten as print(5, a != 7 and b == 7)). Here is the table:
| expression | result |
| not true | false |
| not false | true |
The two following lines, print(6, a == 7 or b == 7) and print(7, a == 7 or b == 6), use the or operator. The or operator returns true if the first expression is true, or if the second expression is true or both are true. If neither are true it returns false. Here's the table:
| expression | result |
| true or true | true |
| true or false | true |
| false or true | true |
| false or false | false |
Notice that if the first expression is true Python doesn't check the second expression since it knows the whole expression is true. This works since or is true if at least one half of the expression is true. The first part is true so the second part could be either false or true, but the whole expression is still true.
The next two lines, print(8, not (a == 7 and b == 6)) and print(9, not a == 7 and b == 6), show that parentheses can be used to group expressions and force one part to be evaluated first. Notice that the parentheses changed the expression from false to true. This occurred since the parentheses forced the not to apply to the whole expression instead of just the a == 7 portion.
Here is an example of using a boolean expression:
And here is the output:
This program works by continuing to check for match while count < len(copy) and copy[count] is not equal to prev. When either count is greater than the last index of copy or a match has been found the and is no longer true so the loop exits. The if simply checks to make sure that the while exited because a match was found.
The other "trick" of and is used in this example. If you look at the table for and notice that the third entry is "false and false". If count >= len(copy) (in other words count < len(copy) is false) then copy[count] is never looked at. This is because Python knows that if the first is false then they can't both be true. This is known as a short circuit and is useful if the second half of the and will cause an error if something is wrong. I used the first expression (count < len(copy)) to check and see if count was a valid index for copy. (If you don't believe me remove the matches "Jill" and "Life", check that it still works and then reverse the order of count < len(copy) and copy[count] != prev to copy[count] != prev and count < len(copy).)
Boolean expressions can be used when you need to check two or more different things at once.

### A note on Boolean Operators

A common mistake for people new to programming is a misunderstanding of the way that boolean operators works, which stems from the way the python interpreter reads these expressions. For example, after initially learning about "and " and "or" statements, one might assume that the expression x == ('a' or 'b') would check to see if the variable x was equivalent to one of the strings 'a' or 'b'. This is not so. To see what I'm talking about, start an interactive session with the interpreter and enter the following expressions:
And this will be the unintuitive result:
At this point, the and and or operators seem to be broken. It doesn't make sense that, for the first two expressions, 'a' is equivalent to 'a' or 'b' while 'b' is not. Furthermore, it doesn't make any sense that 'b' is equivalent to 'a' and 'b'. After examining what the interpreter does with boolean operators, these results do in fact exactly what you are asking of them, it's just not the same as what you think you are asking.
When the Python interpreter looks at an or expression, it takes the first statement and checks to see if it is true. If the first statement is true, then Python returns that object's value without checking the second statement. This is because for an or expression, the whole thing is true if one of the values is true; the program does not need to bother with the second statement. On the other hand, if the first value is evaluated as false Python checks the second half and returns that value. That second half determines the truth value of the whole expression since the first half was false. This "laziness" on the part of the interpreter is called "short circuiting" and is a common way of evaluating boolean expressions in many programming languages.
Similarly, for an and expression, Python uses a short circuit technique to speed truth value evaluation. If the first statement is false then the whole thing must be false, so it returns that value. Otherwise if the first value is true it checks the second and returns that value.
One thing to note at this point is that the boolean expression returns a value indicating True or False, but that Python considers a number of different things to have a truth value assigned to them. To check the truth value of any given object x, you can use the fuction bool(x) to see its truth value. Below is a table with examples of the truth values of various objects:
| True | False |
| True | False |
| 1 | 0 |
| Numbers other than zero | The string 'None' |
| Nonempty strings | Empty strings |
| Nonempty lists | Empty lists |
| Nonempty dictionaries | Empty dictionaries |
Now it is possible to understand the perplexing results we were getting when we tested those boolean expressions before. Let's take a look at what the interpreter "sees" as it goes through that code:
First case:
Second case:
Third case:
Fourth case:
So Python was really doing its job when it gave those apparently bogus results. As mentioned previously, the important thing is to recognize what value your boolean expression will return when it is evaluated, because it isn't always obvious.
Going back to those initial expressions, this is how you would write them out so they behaved in a way that you want:
When these comparisons are evaluated they return truth values in terms of True or False, not strings, so we get the proper results.

### Using the Linkbot's Accelerometer

An accelerometer is a device which can be used to detect the acceleration of an object, or the force of gravity. For instance, when you are sitting in a car and the driver steps on the gas pedal, you can feel a force pushing you back into your seat. Or, as you are sitting in your chair right now, you can feel Earth's gravity pulling you down, towards the center of the earth. The Linkbot can also feel these forces acting on it using its accelerometer, and you can get the accelerometer values from the Linkbot.
Lets take a look at the Linkbot's getAccelerometerData function.
Output
This small program connects to a Linkbot, gets its accelerometer data, and prints it out. The number you get may be different than the ones shown, depending on the orientation and acceleration of your Linkbot when you ran the program.
Notice that the value isn't a single value, but is actually a list of 3 values. Each one of these values is the force (in G's) that the Linkbot is currently experiencing on a particular axis direction, corresponding to the x, y, and z axes of the Linkbot.
We can calculate the total magnitude of force that the Linkbot is experiencing through this equation:
$\mathrm {TotalMagnitude} ={\sqrt {x^{2}+y^{2}+z^{2}}}$
Lets write a Python function that calculates the magnitude of acceleration given a list of three acceleration values:
Output:
Note that the units of these numbers is in earth-gravitational units, usually called "G's". When the above output was produced, the code was executed on a Linkbot that was sitting still on a desk. Because the Linkbot is only being pulled on by Earth's gravity, we expect its magnitude to be very close to 1. If the Linkbot were weightless, floating in space, or in freefall, we can expect the magnitude to be close to zero.
Lets try tilting our Linkbot on a diagonal and running it again. We should expect the three numbers in the list to change, but the total magnitude should still be very close to 1.
Output:
As we can see, the accelMag function that we wrote can display the total magnitude of acceleration acting on the Linkbot regardless of direction. That means we can use it to detect free-fall or high acceleration events, like if the Linkbot is dropped, or bumps into something.
Now, lets try to write a program that makes the Linkbot beep if it detects that it is in freefall. Notice, though, that the values reported by the accelerometer have some "noise". Noise is tiny amounts of error that are picked up at random by robotic sensors. What this means is that the magnitude reported by the Linkbot will almost never exactly zero or exactly 1, even if the Linkbot is in free-fall or sitting still on your desk. What this means is when we write our program, we don't want to check to see if the acceleration magnitude is zero. Instead, we want to check to see if it is below a certain threshold; say, 0.2 G's.
Notice that we've now added an infinite loop to the program. The loop repeatedly checks the accelerometer magnitude at "# 1". If the magnitude is less than 0.2, it beeps the buzzer for 1 second at "# 2".

### Examples

password1.py
Sample runs

### Exercises

Write a program that has a user guess your name, but they only get 3 chances to do so until the program quits.
Write a Linkbot program that beeps if the acceleration exceeds 2 G's. This typically happens if the robot is bumped, or when the robot is shaken vigorously.

# Dictionaries

This chapter is about dictionaries. Dictionaries have keys and values. The keys are used to find the values. Here is an example of a dictionary in use:
And here is my output:
This program is similar to the name list earlier in the chapter on lists. Here's how the program works. First the function print_menu is defined. print_menu just prints a menu that is later used twice in the program. Next comes the funny looking line numbers =. All that this line does is to tell Python that numbers is a dictionary. The next few lines just make the menu work. The lines
go through the dictionary and print all the information. The function numbers.keys returns a list that is then used by the for loop. The list returned by keys is not in any particular order so if you want it in alphabetic order it must be sorted. Similar to lists the statement numbers[x] is used to access a specific member of the dictionary. Of course in this case x is a string. Next the line numbers[name] = phone adds a name and phone number to the dictionary. If name had already been in the dictionary phone would replace whatever was there before. Next the lines
see if a name is in the dictionary and remove it if it is. The operator name in numbers returns true if name is in numbers but otherwise returns false. The line del numbers[name] removes the key name and the value associated with that key. The lines
check to see if the dictionary has a certain key and if it does prints out the number associated with it. Lastly if the menu choice is invalid it reprints the menu for your viewing pleasure.
A recap: Dictionaries have keys and values. Keys can be strings or numbers. Keys point to values. Values can be any type of variable (including lists or even dictionaries (those dictionaries or lists of course can contain dictionaries or lists themselves (scary right? :-) ))). Here is an example of using a list in a dictionary:
and here is a sample output:
Heres how the program works. Basically the variable students is a dictionary with the keys being the name of the students and the values being their grades. The first two lines just create two lists. The next line students = {'#Max': max_points} creates a new dictionary with the key {#Max} and the value is set to be [25, 25, 50, 25, 100] (since that's what max_points was when the assignment is made) (I use the key #Max since # is sorted ahead of any alphabetic characters). Next print_menu is defined. Next the print_all_grades function is defined in the lines:
Notice how first the keys are gotten out of the students dictionary with the keys function in the line keys = list(students.keys). keys is an iterable, and it is converted to list so all the functions for lists can be used on it. Next the keys are sorted in the line keys.sort. for is used to go through all the keys. The grades are stored as a list inside the dictionary so the assignment grades = students[x] gives grades the list that is stored at the key x. The function print_grades just prints a list and is defined a few lines later.
The later lines of the program implement the various options of the menu. The line students[name] = [0] * len(max_points) adds a student to the key of their name. The notation [0] * len(max_points) just creates a list of 0's that is the same length as the max_points list.
The remove student entry just deletes a student similar to the telephone book example. The record grades choice is a little more complex. The grades are retrieved in the line grades = students[name] gets a reference to the grades of the student name. A grade is then recorded in the line grades[which] = grade. You may notice that grades is never put back into the students dictionary (as in no students[name] = grades). The reason for the missing statement is that grades is actually another name for students[name] and so changing grades changes student[name].
Dictionaries provide an easy way to link keys to values. This can be used to easily keep track of data that is attached to various keys.

## Using a Dictionary to Store Musical Notes

Up to this point, our Linkbot programs have been playing musical notes on the Linkbot either by specifying a specific frequency to play, such as myLinkbot.setBuzzerFrequency(440) , or using an equation to calculate the frequency based on a keyboard key number. Wouldn't it be nice if we could just tell the Linkbot to play notes like "Do-Re-Mi", or "A-B-C"?
Perhaps we can use a dictionary to accomplish this task. We can use a dictionary that uses the strings "Do", "Re", "Mi", etc. as keys, and their actual frequencies as values. To find the actual values, we can use an equation or simply look them up online. A quick search shows these frequencies:
| Note Name | Note Frequency |
| Do | 261.63 |
| Re | 293.66 |
| Mi | 329.63 |
| Fa | 349.23 |
| Sol | 392.00 |
| La | 440 |
| Ti | 493.88 |
Now we can create and use a dictionary to play notes.
* Here, we define a helper function that helps us play notes. The function takes a linkbot object and a string note value such as "Do" as input arguments and plays that note on the linkbot for 0.5 seconds.
* This is where we create the dictionary that relates note names to note frequencies.
* This list defines the notes in a simple song we want to play.
* This loop takes each note in the list of notes that we constructed earlier and plays it using our playNote function.

# Using Modules

Here's this chapter's typing exercise (name it cal.py (import actually looks for a file named calendar.py and reads it in. If the file is named calendar.py and it sees a "import calendar" it tries to read in itself which works poorly at best.)):
And here is part of the output I got:
(I skipped some of the output, but I think you get the idea.) So what does the program do? The first line import calendar uses a new command import. The command import loads a module (in this case the calendar module). To see the commands available in the standard modules either look in the library reference for python (if you downloaded it) or go to http://docs.python.org/library/. If you look at the documentation for the calendar module, it lists a function called prcal that prints a calendar for a year. The line calendar.prcal(year) uses this function. In summary to use a module import it and then use module_name.function for functions in the module. Another way to write the program is:
This version imports a specific function from a module. Here is another program that uses the Python Library (name it something like clock.py) (press Ctrl and the 'c' key at the same time to terminate the program):
With some output being:
The output is infinite of course so I canceled it (or the output at least continues until Ctrl+C is pressed). The program just does a infinite loop (True is always true, so while True: goes forever) and each time checks to see if the time has changed and prints it if it has. Notice how multiple names after the import statement are used in the line from time import time, ctime.
The Python Library contains many useful functions. These functions give your programs more abilities and many of them can simplify programming in Python.
The following Barobo Linkbot program demonstrates multiple modules that are used to create some fun examples of playing with the Linkbot functionality. Comments have been added to the program to explain what the link is doing as you read. Once again the while True: puts the program in an infinite loop that can be exited when Ctrl+C is pressed.
Check out the range of colors and intensity the Linkbot is capable of generating with its built in RGB LED.

### Exercises

Rewrite the high_low.py program from section Decisions to use an random integer between 0 and 99 instead of the hard-coded 78. Use the Python documentation to find an appropriate module and function to do this.
Rewrite the high_low.py program from section Decisions to use an random integer between 0 and 99 instead of the hard-coded 78. Use the Python documentation to find an appropriate module and function to do this.

# More on Lists

We have already seen lists and how they can be used. Now that you have some more background I will go into more detail about lists. First we will look at more ways to get at the elements in a list and then we will talk about copying them.
Here are some examples of using indexing to access a single element of a list:
All those examples should look familiar to you. If you want the first item in the list just look at index 0. The second item is index 1 and so on through the list. However what if you want the last item in the list? One way could be to use the len function like some_numbers[len(some_numbers) - 1]. This way works since the len function always returns the last index plus one. The second from the last would then be some_numbers[len(some_numbers) - 2]. There is an easier way to do this. In Python the last item is always index -1. The second to the last is index -2 and so on. Here are some more examples:
Thus any item in the list can be indexed in two ways: from the front and from the back.
Another useful way to get into parts of lists is using slicing. Here is another example to give you an idea what they can be used for:
Slicing is used to return part of a list. The slicing operator is in the form things[first_index:last_index]. Slicing cuts the list before the first_index and before the last_index and returns the parts in between. You can use both types of indexing:
Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:
Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
with the output being:
The get_bold function takes in a list that is broken into words and tokens. The tokens that it looks for are <B> which starts the bold text and </B> which ends bold text. The function get_bold goes through and searches for the start and end tokens.
The next feature of lists is copying them. If you try something simple like:
This probably looks surprising since a modification to b resulted in a being changed as well. What happened is that the statement b = a makes b a reference to a. This means that b can be thought of as another name for a. Hence any modification to b changes a as well. However some assignments don't create two names for one list:
In this case b is not a reference to a since the expression a * 2 creates a new list. Then the statement b = a * 2 gives b a reference to a * 2 rather than a reference to a. All assignment operations create a reference. When you pass a list as an argument to a function you create a reference as well. Most of the time you don't have to worry about creating references rather than copies. However when you need to make modifications to one list without changing another name of the list you have to make sure that you have actually created a copy.
There are several ways to make a copy of a list. The simplest that works most of the time is the slice operator since it always makes a new list even if it is a slice of a whole list:
Taking the slice [:] creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the deepcopy function of the copy module:
First of all notice that a is a list of lists. Then notice that when b[0][1] = 10 is run both a and b are changed, but c is not. This happens because the inner arrays are still references when the slice operator is used. However with deepcopy c was fully copied.
So, should I worry about references every time I use a function or =? The good news is that you only have to worry about references when using dictionaries and lists. Numbers and strings create references when assigned but every operation on numbers and strings that modifies them creates a new copy so you can never modify them unexpectedly. You do have to think about references when you are modifying a list or a dictionary.
By now you are probably wondering why are references used at all? The basic reason is speed. It is much faster to make a reference to a thousand element list than to copy all the elements. The other reason is that it allows you to have a function to modify the inputted list or dictionary. Just remember about references if you ever have some weird problem with data being changed when it shouldn't be.

# Revenge of the Strings

And now presenting a cool trick that can be done with strings:
And the output is:
What these programs demonstrate is that strings are similar to lists in several ways. The shout function shows that for loops can be used with strings just as they can be used with lists. The middle procedure shows that that strings can also use the len function and array indexes and slices. Most list features work on strings as well.
The next feature demonstrates some string specific features:
with the output being:
This works because the computer represents the characters of a string as numbers from 0 to 1,114,111. For example 'A' is 65, 'B' is 66 and א is 1488. The values are the unicode value. Python has a function called ord (short for ordinal) that returns a character as a number. There is also a corresponding function called chr that converts a number into a character. With this in mind the program should start to be clear. The first detail is the line: if 'a' <= character <= 'z': which checks to see if a letter is lower case. If it is then the next lines are used. First it is converted into a location so that a = 0, b = 1, c = 2 and so on with the line: location = ord(character) - ord('a'). Next the new value is found with new_ascii = location + ord('A'). This value is converted back to a character that is now upper case. Note that if you really need the upper case of a letter, you should use u=var.upper which will work with other languages as well.
Now for some interactive typing exercise:
If you haven't guessed already the function repr can convert an integer to a string and the function int can convert a string to an integer. The function float can convert a string to a float. The repr function returns a printable representation of something. Here are some examples of this:
The int function tries to convert a string (or a float) into an integer. There is also a similar function called float that will convert a integer or a string into a float. Another function that Python has is the eval function. The eval function takes a string and returns data of the type that python thinks it found. For example:
If you use the eval function you should check that it returns the type that you expect.
One useful string function is the split method. Here's an example:
Notice how split converts a string into a list of strings. The string is split by whitespace by default or by the optional argument (in this case a comma). You can also add another argument that tells split how many times the separator will be used to split the text. For example:

### Slicing strings (and lists)

Strings can be cut into pieces — in the same way as it was shown for lists in the previous chapter — by using the slicing "operator". The slicing operator works in the same way as before: text[first_index:last_index] (in very rare cases there can be another colon and a third argument, as in the example shown below).
In order not to get confused by the index numbers, it is easiest to see them as clipping places, possibilities to cut a string into parts. Here is an example, which shows the clipping places (in yellow) and their index numbers (red and blue) for a simple text string:
| | | 0 | | 1 | | 2 | | ... | | -2 | | -1 | | | |
| text = | " | | S | | T | | R | | I | | N | | G | | " |
Note that the red indexes are counted from the beginning of the string and the blue ones from the end of the string backwards. (Note that there is no blue -0, which could seem to be logical at the end of the string. Because -0 == 0, -0 means "beginning of the string" as well.) Now we are ready to use the indexes for slicing operations:
| text[1:4] | → | "TRI" |
| text[:5] | → | "STRIN" |
| text[:-1] | → | "STRIN" |
| text[-4:] | → | "RING" |
| text[2] | → | "R" |
| text[:] | → | "STRING" |
| text[::-1] | → | "GNIRTS" |
text[1:4] gives us all of the text string between clipping places 1 and 4, "TRI". If you omit one of the [first_index:last_index] arguments, you get the beginning or end of the string as default: text[:5] gives "STRIN". For both first_index and last_index we can use both the red and the blue numbering schema: text[:-1] gives the same as text[:5], because the index -1 is at the same place as 5 in this case. If we do not use an argument containing a colon, the number is treated in a different way: text[2] gives us one character following the second clipping point, "R". The special slicing operation text[:] means "from the beginning to the end" and produces a copy of the entire string (or list, as shown in the previous chapter).
Last but not least, the slicing operation can have a second colon and a third argument, which is interpreted as the "step size": text[::-1] is text from beginning to the end, with a step size of -1. -1 means "every character, but in the other direction". "STRING" backwards is "GNIRTS" (test a step length of 2, if you have not got the point here).
All these slicing operations work with lists as well. In that sense strings are just a special case of lists, where the list elements are single characters. Just remember the concept of clipping places, and the indexes for slicing things will get a lot less confusing.

### Examples

The output is:

# File IO
### File I/O

Here is a simple example of file I/O (input/output):
The output and the contents of the file test.txt are:
Notice that it wrote a file called test.txt in the directory that you ran the program from. The \n in the string tells Python to put a newline where it is.
A overview of file I/O is:
* Get a file object with the open function
* Read or write to the file object (depending on how it was opened)
* If you did not use with to open the file, you'd have to close it manually
The first step is to get a file object. The way to do this is to use the open function. The format is file_object = open(filename, mode) where file_object is the variable to put the file object, filename is a string with the filename, and mode is "rt" to read a file as text or "wt" to write a file as text (and a few others we will skip here). Next the file objects functions can be called. The two most common functions are read and write. The write function adds a string to the end of the file. The read function reads the next thing in the file and returns it as a string. If no argument is given it will return the whole file (as done in the example).
Now here is a new version of the phone numbers program that we made earlier:
Notice that it now includes saving and loading files. Here is some output of my running it twice:
The new portions of this program are:
First we will look at the save portion of the program. First it creates a file object with the command open(filename, "wt"). Next it goes through and creates a line for each of the phone numbers with the command out_file.write(x + "," + numbers[x] + "\n"). This writes out a line that contains the name, a comma, the number and follows it by a newline.
The loading portion is a little more complicated. It starts by getting a file object. Then it uses a while True: loop to keep looping until a break statement is encountered. Next it gets a line with the line in_line = in_file.readline. The readline function will return an empty string when the end of the file is reached. The if statement checks for this and breaks out of the while loop when that happens. Of course if the readline function did not return the newline at the end of the line there would be no way to tell if an empty string was an empty line or the end of the file so the newline is left in what readline returns. Hence we have to get rid of the newline. The line in_line = in_line[:-1] does this for us by dropping the last character. Next the line name, number = in_line.split(",") splits the line at the comma into a name and a number. This is then added to the numbers dictionary.

### Advanced use of .txt files

You might be saying to yourself, "Well I know how to read and write to a textfile, but what if I want to print the file without opening out another program?"
There are a few different ways to accomplish this. The easiest way does open another program, but everything is taken care of in the Python code, and doesn't require the user to specify a file to be printed. This method involves invoking the subprocess of another program.
Remember the file we wrote output to in the above program? Let's use that file. Keep in mind, in order to prevent some errors, this program uses concepts from the Next chapter. Please feel free to revisit this example after the next chapter.
The subprocess.call takes three arguments. The first argument in the context of this example, should be the name of the program which you would like to invoke the printing subprocess from. The second argument should be the specific subprocess within that program. For simplicity, just understand that in this program, '/p' is the subprocess used to access your printer through the specified application. The last argument should be the name of the file you want to send to the printing subprocess. In this case, it is the same file used earlier in this chapter.

### Storing and loading music saved in a text file

This section will demonstrate how we can store simple melodies in a file. We can then write a program that reads the file and plays the melody on a Linkbot.

#### A little music theory

To fully understand the sample program, we will need a little knowledge about music theory. If you don't care about music theory and you just want to get the Linkbot to play music, you can skip to the next section.
What is music? Music is a series of notes played in a certain order. Sometimes, more than one note is played together. Each note is played for a certain duration. Notes themselves are vibrations in the air that we can hear. Each note has a certain frequency of vibration; when the frequency changes, the perceived pitch of the note changes too.
Each note has a name. If you know it's name, you can find it on a piano keyboard, and vice versa. You may have heard the term "Middle-C", or the phrase "Do-Re-Mi". These are both ways to refer to notes. If you are familiar with a piano keyboard, you will know that the "C" note appears more than once on the keyboard. When you play the C notes, you'll notice that they don't sound the same, but they are all called "C". It turns out that there are 12 tones that repeat over and over again. Starting at C, they are:
* C
* C# (Db)
* D
* D# (Eb)
* E
* F
* F# (Gb)
* G
* G# (Ab)
* A
* A# (Bb)
* B
The "#" symbol is pronounced "sharp", so C# is pronounced "See-Sharp". The "sharp" indicates that the tone is one step higher than the normal note. For instance, "A#" is one step higher than "A". You might also be familiar with another symbol that looks like a lowercase b. That symbol is pronounced "flat", so "Bb" is pronounced "B-flat". It has the opposite meaning of sharp, indicating that the note is one step lower than the un-flatted note. This means that the note "G#" is actually the same note as "Ab". For now, we will only use sharps to avoid confusion. On a piano keyboard, all of the sharp/flat notes are the black keys and the rest of the notes are the white keys.
On a piano keyboard, these notes repeat over and over again, so we must devise a way to specifically refer which A or B or C we are referring to. To do this, we introduce the concept of an octave number. The lowest note a piano can play is called "A0", where 0 is the octave number. Going from left to right on a piano keyboard, the octave number increases every time you encounter the C note. Thus, the first several white keys on a piano keyboard from left to right are:
* A0
* B0
* C1
* D1
* E1
* F1
* G1
* A1
* B1
* C2
* etc...
Now, we have a way to specify exactly what key on a keyboard we are referring to using a string such as "F#5".
We also have an equation where we can calculate the frequency of a note depending on how many steps away it is from our "A0" note. The equation is:
$\mathrm {frequency} =27.5*2^{\mathrm {steps} /12}$
For instance, G0 is -2 steps away from A0, and B0 is 2 steps away from A0. For notes in the same octave, we can simply count the number of black and white keys to find the distance away from A, but how about different octaves? For instance, how many keys away is A0 from B4?
First, lets consider how many notes away A4 is from A0. When we count the keys, each octave is 12 notes. Since A4 is 4 octave away from 0 (4-0 = 4), A4 is 4*12=48 keys away from A0.
How about A0 and B4? A0 is 2 keys away from B0, and B0 is 4*12 keys away from B4, so in total, A0 is 2+4*12 = 50 keys away from B4. Now, we can write an equation to figure out exactly how many keys away any note is from A0. Lets use the variable $n$ for the note name we want, and $v$ for the octave of the note. Then,
$\mathrm {offset} (n,v)=n-\mathrm { A0)+12*v$

#### Reading and playing a melody from a file

First, let us write a function that takes a string describing a note such as "A4" and gives us a frequency for that note. Here is our strategy:
* We receive a string describing the note. The first character is the letter name of the note. We calculate the offset of that letter name from the "A" note. For instance, "B" would have an offset of +2 and "E" would have an offset of -5. We find these offsets simply by counting the keys on a keyboard.
* The next character in the string might be a "#" sharp or a "b" flat. If it is sharp, increase the offset by one. If it is flat, decrease it by one. If it is neither, don't do anything.
* The final character is the octave number. We multiply this number by 12 and add it to our offset.
* The result is the number of keys away the note is away from A0. We can now use the equation $f=27.5*2^{\mathrm {offset} /12}$ to find the frequency based on the key offset from A0.
Next, lets talk about our file format. Since the Linkbot can only play one note at a time, the file should specify single notes for the Linkbot to play. Also, the file should specify how many seconds to play each note. We choose to have our file such that each line contains a note name such as "C4" or "Bb3", along with a note duration in seconds.
Here is a file that we have created for you:
fur_elise.txt
Go ahead and copy-paste the text into a file called "fur_elise.txt". Lets write our function and program that will read this file and play a tune.
* note[0].upper takes the first character and uppercases it. We want to uppercase anything that comes in just in case the user used a lowercase note name, like "e4". Since we wrote our dictionary with uppercase note names, we need to make sure the incoming note names are upper-case too so that it can be matched with the ones in our dictionary.
* The "-1" index means the last item of a list. Since all of the items in our list are strings, we need to convert it to an integer with int.
* This loop goes through every single line in the music file, line by line. Each time, it stores the text of the line in the line variable.
* The split function splits lines of text based on whitespace. For instance, "Hello there".split becomes the list ["Hello", "there"] . Since each line in our text file has 2 "words", the first part (the note name) is stored into our variable data[0], and the second part (the note duration) is stored into data[1].

### Exercises

Now modify the grades program from section Dictionaries so that is uses file I/O to keep a record of the students.
Now modify the grades program from section Dictionaries so that is uses file I/O to keep a record of the students.
Write a program that reads a text file containing motor angles, such as
Each triplet of numbers represents three motor angles. Write a program that moves the Linkbot's joints to those positions with the moveTo function for each line in the data file.

# Dealing with the imperfect
### closing files with with

We use the "with" statement to open and close files.
If some sort of error happens anywhere in this code (one of the files is inaccessible, the parse function chokes on corrupt data, etc.) the "with" statements guarantee that all the files will eventually be properly closed. Closing a file just means that the file is "cleaned up" and "released" by our program so that it can be used in another program.

### catching errors with try

So you now have the perfect program, it runs flawlessly, except for one detail, it will crash on invalid user input. Have no fear, for Python has a special control structure for you. It's called try and it tries to do something. Here is an example of a program with a problem:
Notice how when you enter @#& it outputs something like:
As you can see the int function is unhappy with the number @#& (as well it should be). The last line shows what the problem is; Python found a ValueError. How can our program deal with this? What we do is first: put the place where errors may occur in a try block, and second: tell Python how we want ValueErrors handled. The following program does this:
Now when we run the new program and give it @#& it tells us "That was not a number." and continues with what it was doing before.
When your program keeps having some error that you know how to handle, put code in a try block, and put the way to handle the error in the except block.

### Generating Errors: Controlling a Linkbot's Speed

We've seen in previous examples that we can write a function that makes a wheeled robot travel a certain distance. We can also control the rotational velocity of the motors with the setJointSpeed function. The setJointSpeed function expects a rotational speed with units of degrees/sec, but it would be nice if we could have a function where we could set the robot speed using inches/sec. The math equation to convert $v$ inches/sec to $\omega$ degrees/sec is
$\omega \mathrm {(deg/sec)} ={\frac {v\mathrm {(inches/sec)} }{r\mathrm {(inches)} }}*{\frac {180\mathrm {(degrees)} }{\pi \mathrm {(radians)} }}$
where $r$ is the wheel radius. Lets expand our example from the Learning Python 3 with the Linkbot/Defining Functions section:
This example is all well and good. We define a new function setSpeed that sets the speed of a Linkbot wheeled vehicle and we use it to set the speed to 2.5 inches per second.
What if the programmer tries to set the speed to 1,000 inches/second? Or 1,000,000 inches/second? Although it would be cool to see a Linkbot compete with a Formula One race car, there are physical limitations that prevent the Linkbot's motors from moving more than 200 degrees/second. If the speed is too high, we should set an error the user can see and possibly deal with. This is called "raising an exception". The code to raise an exception looks like this:
When an exception is raised, the function immediately returns with the exception. These raised exceptions can be caught by try/except blocks. If the exception occurred outside of a try/except block, the entire program will quit and display the error message of the exception. In the setSpeed function, this means that if the raise is executed, the two setJointSpeed statements will be skipped.
When I run the new program and I try to set the speed to 1000 inches a second, I get this output:
Now you can use try/catch blocks to deal with possible errors. Lets try writing a program that tries to set the speed to 10 inches per second again, except every time it encounters an exception, in reduces the requested speed by 1 inch/second and tries again.
The output is
Lets step through this program together to make sure we fully understand what is happening.
* # 1 : When we first get to this line, we create a new variable called requestedSpeed and set its value to "10".
* # 2 : Enter an infinite loop
* # 3 : Try to set the speed. requestedSpeed is currently 10, which is too high. The setSpeed function raises an exception. Since we are in a try/except block, we immediately go to the except block since an exception was thrown. Proceed to # 5
* # 5 : Decrease requestedSpeed by one. requestedSpeed is now 9. This is the end of our while loop, which means that Python goes back to the beginning of the loop.
* # 3 : We end up at # 3 again, except requestedSpeed is now 9. Still too high, exception is thrown.
* # 5 : Again, we decrease requestedSpeed to 8.
* # 3 : Still too high...
* # 5 : Reduce to 7...
* # 3 : Still too high...
* # 5 : Reduce to 6.
* # 3 : Now it succeeds. Since it succeeded, no exception was raised. Continue to # 4
* # 4 : This break statement pops us out of the loop. Proceed to # 6 and the rest of the program.

### Exercises

Update at least the phone numbers program (in section Dictionaries) so it doesn't crash if a user doesn't enter any data at the menu.

# Recursion
## Recursion

In Python, a recursive function is a function which calls itself.

### Introduction to recursion

So far, in Python, we have seen functions which call other functions. However, it is possible for a function to call itself. Lets look at a simple example.
If you were to run this program in IDLE, it would run forever. The only way to stop the loop would be to interrupt the execution by pressing Ctrl + C on your keyboard. This is an example of an infinite recursion. (Some users have reported a glitch in the current IDLE system causing the exception raised by Ctrl + C to start looping as well. If this happens, press Ctrl + F6, and the IDLE shell should restart.)
It is arguable that recursion is just another way to accomplish the same thing as a while loop. In some cases, this is absolutely correct. Though, there are other uses for Recursion that are very valid, where while loops or for loops may not be optimal.
Recursion can be controlled, just like loops. Lets look at an example of a controlled loop.
The above uses arguments/parameters to control the number of recursions. Simply use what you already know about functions and follow the flow of the program. It is simple to figure out. If you are having trouble, please refer back to Non-Programmer's Tutorial for Python 3/Advanced Functions Example.

## Practical Applications of Recursion

Often, recursion is studied at an advanced computer science level. Recursion is usually used to solve complex problems, that can be broken down into smaller, identical problems. Recursion isn't required to solve a problem. Problems that can be solved with recursion, most likely can be solved with loops. Also, a loop may be more efficient than a recursive function. Recursive functions require more memory, and resources than loops, making them less efficient in a lot of cases. This usage requirement is sometimes referred to as overhead. You might be thinking, "Well why bother with recursion. I'll just use a loop. I already know how to loop and this is a lot more work." This thought is understandable, but not entirely ideal. When solving complex problems, a recursive function is sometimes easier, faster, and simpler to build and code.
Think of these two "rules":
* If I can solve the problem now, without recursion, the function simply returns a value.
* If I cannot solve the problem now without recursion, the function reduces the problem to something smaller and similar, and calls itself to solve the problem.
Let's apply this using a common mathematical concept, factorials. If you are unfamiliar with factorials in mathematics, please refer to the following reading. Factorials
The factorial of a number n, is denoted as n!.
Here are some basic rules of factorials.
If n = 0 then n! = 1 If n > 0 then n! = 1 x 2 x 3 x ... x n
For example, let's look at the factorial of the number 9.
9! = 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9
Let's look at a program which calculates the factorial of any number entered by the user, by method of recursion.
Recursion is also useful in an advanced topic called generators. To generate the series 1,2,1,3,1,2,1,4,1,2... we would need this code:
to get the next element you would call next(i)

# Intro to Object Oriented Programming in Python 3
## Object Oriented Programming

    Up until now, the programming you have been doing has been procedural. However, a lot of programs today are Object Oriented. Knowing both types, and knowing the difference, is very important. Many important languages in computer science such as C++ and Java, often use OOP methods.
    Beginners, and non-programmers often find the concept of OOP confusing, and complicated. This is normal. Don't be put off if you struggle or do not understand. There are plenty of other resources you can use to help overcome any issues you may have, if this chapter does not help you.
    This chapter will be broken up into different lessons. Each lesson will explain OOP in a different way, just to make sure OOP is covered as thoroughly as possible, because IT IS VERY IMPORTANT. Before the lessons, there is an introduction which explains key concepts, terms, and other important areas of OOP, required to understand each lesson.

## Introduction

Think of a procedure as a function. A function has a specific purpose. That purpose may be gathering input, performing mathematical calculations, displaying data, or manipulating data to, from, or in, a file. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems. For example, you have designed a program which stores information about a product in variables. When a customer requests information on a product, these variables are passed to different functions for different purposes. Later on, as more data is stored on these products, you decide to store the information in a list or dictionary. In order for your program to function, you must now edit each function that accepted variables, to now accept and manipulate a list or dictionary. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal. Procedural programming is centered on procedures or functions. But, OOP is centered on creating Objects. Remember how a procedural program has separated data and code? Remember how that huge program was hundreds of files and would take FOREVER to edit? Well, think of an object as a sort of "combination" of those files and data into one "being". In a technical sense, an Object is an entity which contains data, AND procedures (code, functions, etc.).
Data inside an object is called a data attribute.
Functions, or procedures inside the object are called methods.
Think of data attributes as variables.
Think of methods as functions or procedures.
Let's look at a simple, everyday example. The light and light switch in your bedroom. The data attributes would be as follows.
* light_on (True or False)
* switch_position (Up or Down)
* electricity_flow (True or False)
The methods would be as follows.
* move_switch
* change_electricity_flow
The data attributes may or may not be visible. For example, you cannot directly see the electricity flowing to the light. You only know there is electricity, because the light is on. However, you can see the position of the switch (switch_position), and you can see if the light is on or off (light_on). Some methods are private. This means that you cannot directly change them. For example, unless you cut the wires in your light fixture (please don't do that, and for the sake of this example, assume that you don't know the wires exist), you cannot change the flow of electricity directly. You also cannot directly change if the light is on or off (and no, you can't unscrew the bulb! work with me here!). However, you can indirectly change these attributes by using the methods in the object. If you don't pay your bill, the change_electricity_flow method will change the value of the electricity_flow attribute to FALSE. If you flip the switch, the move_switch method changes the value of the light_on attribute.
By now you're probably thinking, "What does this have to do with Python?" or, "I understand, but how do I code an Object?" Well, we are almost to that point! One more concept must be explained before we can dive into code.
In Python, an object's data attributes and methods are specified by a class. Think of a class as a blueprint to an object. For example, your home - the object that you live in - you can also call it your pad, bungalow, crib, or whatever, was built based on a set of blueprints; these blueprints would be considered the class used to design your home, pad, crib, ahem, you get the idea.
Again, a class tells us how to make an object. In technical terms, and this is important here, a class defines the data attributes and methods inside an object.
To create a class, we code a class definition. A class definition is a group of statements which define an object's data attributes and methods.
Lesson One
Below is a Procedural program that performs simple math on a single number, entered by a user.
If we were to enter a value of "5", the output would be as shown below.
If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.
Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program. To create a class, we use the class keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class is capitalized. If I wanted to create a class named dirtysocks, the code would be:
The Class is shown first. The program which uses the class is second.
The program which uses the class above, is below.
After looking at that program, you are probably a bit lost. That's OK. Lets start off by dissecting the class. The class is named "Numchange" There are three methods to this class:
* __init__
* addfive
* multiply
These three methods each have a similar code.
Notice how each method has a parameter named "self". this parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.
Lets look at the first method.
Most Classes in python have an __init__ which executes automatically when an instance of a class is created in memory.(When we reference a class, an instance (or object)of that class is created). This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. Under the __init__ method, we set the value of the number method to 0 initially. We reference the object attribute using dot notation.
The self.__number = 0 line simply means ""the value of the attribute "number", in the object, is 0"".
Let's look at the next method.
This method is named "addfive. It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.
Let's look at the third method.
This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.
Notice how the name of each method begins with two underscores? Let's explain that. Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.
Lets look at the program which uses the class we just dissected.
Notice the first line of non comment code.
This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.
The next line:
This line creates an instance of the Numchange class, stored in the module named "oopexample", and stores the instance in the variable named "maths". The syntax is: modulename.Classname Next we define the main function. Then, we get a number from the user.
The next line added = maths.addfive(num) sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".
The next line multip = maths.multiply(added) sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".
The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

## Object Oriented Inheritance: Extending the Linkbot Class

Throughout all of our code examples, you've been seeing these lines of code over and over again:
If you guessed that the myLinkbot variable is actually a Python object, you are correct! The getLinkbot function returns an object of the Linkbot class, which is defined inside of the barobo package. An extremely powerful and important concept that object-oriented languages use is a concept called "inheritance". Sometimes, a programmer may want to create a new object that is very similar to or related to objects that have already been written.
For instance, the Linkbot class contains a variety of functions that move the motors, beeps the buzzer, etc. However, it would be nice if I could write my own object for controlling a Linkbot-I that has 2 wheels and a caster attached. I could call the new object "LinkbotCar", and it could have member functions that make it drive forward, drive backward, turn, etc. At the same time, I still want the LinkbotCar class to do everything that the original Linkbot class did, such as changing LED colors and beeping the buzzer. Furthermore, it would be nice if the programmer didn't have to re-implement all of those methods that already exist inside the Linkbot class.
The solution to this situation is to write our LinkbotCar class such that it "extends", "inherits from", or "derives from" (all of these terms are more-or-less interchangeable) the original Linkbot class. Lets start by a quick example. Here is a program that creates a new LinkbotCar class based on the original Linkbot class, makes a new function called driveForwardDistance which drives the wheeled robot forward a certain distance, and then beeps the buzzer for half a second.
* This line begins the process of making a new class called "LinkbotCar" based on the existing class "barobo.Linkbot".
* Here, we define a new function called "driveForwardDistance" for the LinkbotCar class. The first argument for member functions represents the object itself. Although you can name this first variable whatever you want, all Python programmers use the name "self" by convention. The second argument is the number of inches we want the robot to travel.
* This is the line that actually makes the Linkbot move. Notice that we use the move function on the self variable here.
* Here, we gain control of the Linkbot through the dongle. Notice that the format of this function call is slightly different from what we've seen before. Not only is the requested Linkbot ID 'ABCD' specified, we also specify that we want a "LinkbotCar" object instead of a vanilla "Linkbot" object. Vanilla "Linkbot" objects do not have the new driveForwardDistance member function that we just defined.
* At this line, we actually use our new function that we defined above. This makes the robot represented by the variable myLinkbotCar drive forward 5 inches.
* Next, we make the Linkbot beep its buzzer. Notice that setBuzzerFrequency was originally a function inside the barobo.Linkbot class. Because our object inherits from the original barobo.Linkbot class, we can also call any member function that is in the barobo.Linkbot class.
While this style of programming may seem cumbersome at first, there are many reasons to motivate this type of organization. For instance,
* Why don't we just hard-code all of the Linkbot movements with move and moveJoint functions? This might be feasible for smaller programs, but imagine if you had to write a program where a wheeled Linkbot had to travel through a complex maze. If we need the Linkbot to accurately turn and travel more than 10 times, it is probably worth the time to write a function or class to make it easier on ourselves. In the long run, we would probably save time by writing the derived class.
* Why is writing a class better than writing helper functions? One of the main benefits of writing a class is that someone else (or you) can inherit from your new class too. Lets say for instance you wrote a LinkbotCar class that moves the Linkbot like a car and your buddy wrote a class called LinkbotMelody that could make the Linkbot play complex songs using the buzzer. You could take the two classes and inherit from both of them to create a new class that can drive the Linkbot like a car and play melodies!

## Exercises

Continue extending the LinkbotCar class by adding functions turnLeft and turnRight.

# Intro to Imported Libraries and other Functions
## Intro to Imported Libraries and other Functions

    In this chapter, we will cover some functions from various imported libraries that are commonly asked about, or used in Python. This chapter is not required to fully understand basics of Python. This chapter is meant to show further capability of Python, which can be utilized with what you already know about the language.

### math

    The math library has many functions that are useful for programs that need to perform mathematical operations, that cannot be accomplished using the built in operators.
    This section assumes you have math training up to and including Trigonometry.
The following list, shows all the functions in the math library:
* math.ceil
* math.copysign
* math.fabs
* math.factorial
* math.floor
* math.fmod (Not the most ideal for its purpose. Will not be explained.)
* math.frexp (Outside the scope of this tutorial. Will not be explained.)
* math.fsum
* math.isfinite
* math.isinf
* math.isnan
* math.ldexp
* math.modf (Outside the realm of this tutorial. Will not be explained.)
* math.trunc (Outside the realm of this tutorial. Will not be explained.)
* math.exp
* math.expm1
* math.log
* math.log1p
* math.log10
* math.pow
* math.sqrt
* math.acos
* math.asin
* math.atan
* math.atan2
* math.cos
* math.hypot
* math.sin
* math.tan
* math.degrees
* math.radians
* math.acosh
* math.asinh
* math.atanh
* math.cosh
* math.sinh
* math.tanh
* math.erf
* math.erfc
* math.gamma
* math.lgamma
* math.pi
* math.e
    Of course we wont cover every one of these functions. But we will cover a good chunk of them.
Lets start off by covering the two constants in the math library. math.pi is the mathematical constant "π", to available precision on your computer. math.e is the mathematical constant "e", to available precision on your computer. Here is an example of both constants when entered in interactive mode in the Python shell.
These constants can be stored in a variable just like any other number. Below is an example of such, and shows simple operations on those variables.
Now, lets look at the functions. Lets start at the top of the list, and work our way down. Some of the functions will be skipped. At this point in the tutorial, you should be able to look at each of these examples to follow, and easily figure out what the example does. A simple sentence or two about what the function does will be provided.
Below is an example of every math module function, and how it is used. (Excluding functions noted above as not to be explained)

# The End

So here we are at the end, or maybe the beginning. This tutorial is on Wikibooks, so feel free to make improvements to it. If you want to learn more about Python, The Python Tutorial by Guido van Rossum has more topics that you can learn about. If you have been following this tutorial, you should be able to understand a fair amount of it. The Python Programming wikibook can be worth looking at, too. Here are few other books which cover Python 3:
* A Byte of Python by Swaroop C H
* Hands-on Python Tutorial by Dr. Andrew N. Harrington
* Subject:Python programming language lists other Wikibooks related to Python.
Hopefully this book covers everything you have needed to get started programming. Thanks to everyone who has sent me emails about it. I enjoyed reading them, even when I have not always been the best replier.
Happy programming, may it change your life and the world.

# FAQ
## How do I make a GUI in Python?

    You can use either TKinter at http://www.python.org/topics/tkinter/ or PyQT4 at http://www.riverbankcomputing.co.uk/ or PyGobject at http://live.gnome.org/PyGObject For really simple graphics, you can use the turtle graphics mode import turtle

## How do I make a game in Python?

    The best method is probably to use PyGame at http://pygame.org/

## How do I make an executable from a Python program?

    Short answer: Python is an interepreted language so that is impossible. Long answer is that something similar to an executable can be created by taking the Python interpreter and the file and joining them together and distributing that. For more on that problem see http://www.python.org/doc/faq/programming/#how-can-i-create-a-stand-alone-binary-from-a-python-script

## (IFAQ) Why do you use first person in this tutorial?

    Once upon a time in a different millennia, (1999 to be exact), an earlier version was written entirely by Josh Cogliati, and it was up on his webpage http://www.honors.montana.edu/~jjc/easytut and it was good. Then the server rupert, like all good things than have a beginning came to an end, and Josh moved it to Wikibooks, but the first person writing stuck. If someone really wants to change it, I will not revert it, but I don't see much point.

## My question is not answered.

    Ask on the discussion page or add it to this FAQ, or email one of the Authors.
For other FAQs, you may want to see the Python 2.6 version of this page Non-Programmer's Tutorial for Python 2.6/FAQ, or the Python FAQ.
* ↑ "The 'with' statement"
* ↑ 'The Python "with" Statement by Example'