The Interactive Interpreter

When you start up Python, you get a prompt similar to the following:

Python 3.5.0 (default, Dec 5 2015, 15:03:35)
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.1.76)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

The exact appearance of the interpreter and its error messages will depend on which version you are using. This might not seem very interesting, but believe me, it is. This is your gateway to hackerdom—your first step in taking control of your computer. In more pragmatic terms, it’s an interactive Python interpreter. Just to see if it’s working, try the following:

>>> print("Hello, world!")

When you press the Enter key, the following output appears:

Hello, world!
>>>

If you are familiar with other computer languages, you may be used to terminating every line with a semicolon. There is no need to do so in Python. A line is a line, more or less. You may add a semicolon if you like, but it won’t have any effect (unless more code follows on the same line), and it is not a common thing to do.

So what happened here? The >>> thingy is the prompt. You can write something in this space, like print "Hello, world!". If you press Enter, the Python interpreter prints out the string “Hello, world!” and you get a new prompt below that.

What if you write something completely different? Try it out:

>>> The Spanish Inquisition
SyntaxError: invalid syntax
>>>

Obviously, the interpreter didn’t understand that.² (If you are running an interpreter other than IDLE, such as the command-line version for Linux, the error message will be slightly different.) The interpreter also indicates what’s wrong: it will emphasize the word Spanish by giving it a red background (or, in the command-line version, by using a caret, ^).

If you feel like it, play around with the interpreter some more. For some guidance, try entering the command help() at the prompt and pressing Enter . You can press F1 for help about IDLE. Otherwise, let’s press on. After all, the interpreter isn’t much fun when you don’t know what to tell it.

Algo . . . What?

Before we start programming in earnest, I’ll try to give you an idea of what computer programming is. Simply put, it’s telling a computer what to do. Computers can do a lot of things, but they aren’t very good at thinking for themselves. They really need to be spoon-fed the details. You need to feed the computer an algorithm in some language it understands. Algorithmis just a fancy word for a procedure or recipe—a detailed description of how to do something. Consider the following:

SPAM with SPAM, SPAM, Eggs, and SPAM:  First, take some SPAM.
Then add some SPAM, SPAM, and eggs.
If a particularly spicy SPAM is desired, add some SPAM.
Cook until done -- Check every 10 minutes.

Not the fanciest of recipes, but its structure can be quite illuminating. It consists of a series of instructions to be followed in order. Some of the instructions may be done directly (“take some SPAM”), while some require some deliberation (“If a particularly spicy SPAM is desired”), and others must be repeated several times (“Check every 10 minutes.”)

Recipes and algorithms consist of ingredients (objects, things) and instructions (statements). In this example, SPAM and eggs are the ingredients, while the instructions consist of adding SPAM, cooking for a given length of time, and so on. Let’s start with some reasonably simple Python ingredients and see what you can do with them.

Numbers and Expressions

The interactive Python interpreter can be used as a powerful calculator. Try the following:

>>> 2 + 2

This should give you the answer 4. That wasn’t too hard. Well, what about this:

>>> 53672 + 235253
288925

Still not impressed? Admittedly, this is pretty standard stuff. (I’ll assume that you’ve used a calculator enough to know the difference between 1 + 2 * 3 and (1 + 2) * 3.) All the usual arithmetic operators work as expected. Division produces decimal numbers, called floats (or floating-point numbers).

>>> 1 / 2
0.5
>>> 1 / 1
1.0

If you’d rather discard the fractional part and do integer division, you can use a double slash.

>>> 1 // 2
0
>>> 1 // 1
1
>>> 5.0 // 2.4
2.0

In older versions of Python , ordinary division on integers used to work like this double slash. If you’re using Python 2.x, you can get proper division by adding the following statement to the beginning of your program (writing full programs is described later) or simply executing it in the interactive interpreter:

>>> from __future__ import division

Another alternative, if you’re running an old Python from the command line, is to supply the command-line switch -Qnew. There is a more thorough explanation of the __future__ stuff in the section “Back to the __future__” later in this chapter.

Now you’ve seen the basic arithmetic operators (addition, subtraction, multiplication, and division), but I’ve left out a close relative of integer division.

>>> 1 % 2
1

This is the remainder (modulus) operator. x % y gives the remainder of x divided by y. In other words, it’s the part that’s left over when you use integer division. That is, x % y is the same as x - ((x // y) * y).

>>> 10 // 3
3
>>> 10 % 3
1
>>> 9 // 3
3
>>> 9 % 3
0
>>> 2.75 % 0.5
0.25

Here 10 // 3 is 3 because the result is rounded down. But 3 × 3 is 9, so you get a remainder of 1. When you divide 9 by 3, the result is exactly 3, with no rounding. Therefore, the remainder is 0. This may be useful if you want to check something “every 10 minutes” as in the recipe earlier in the chapter. You can simply check whether minute % 10 is 0. (For a description on how to do this, see the sidebar “Sneak Peek: The if Statement” later in this chapter.) As you can see from the final example, the remainder operator works just fine with floats as well. It even works with negative numbers, and this can be a little confusing.

>>> 10 % 3
1
>>> 10 % -3
-2
>>> -10 % 3
2
>>> -10 % -3
-1

Looking at these examples, it might not be immediately obvious how it works. It’s probably easier to understand if you look at the companion operation of integer division.

>>> 10 // 3
3
>>> 10 // -3
-4
>>> -10 // 3
-4
>>> -10 // -3
3

Given how the division works, it’s not that hard to understand what the remainder must be. The important thing to understand about integer division is that it is rounded down, which for negative numbers is away from zero. That means -10 // 3 is rounded down to -4, not up to -3.

The last operator we’ll look at is the exponentiation (or power) operator.

>>> 2 ** 3
8
>>> -3 ** 2
-9
>>> (-3) ** 2
9

Note that the exponentiation operator binds tighter than the negation (unary minus), so -3**2 is in fact the same as -(3**2). If you want to calculate (-3)**2, you must say so explicitly.

>>> 0xAF
175
>>> 010
8
>>> 0b1011010010
722

Variables

Another concept that might be familiar to you is variables. If algebra is but a distant memory, don’t worry: variables in Python are easy to understand. A variable is a name that represents (or refers to) some value. For example, you might want the name x to represent 3. To make it so, simply execute the following:

>>> x = 3

This is called an assignment. We assign the value 3 to the variable x. Another way of putting this is to say that we bind the variable x to the value (or object) 3. After you’ve assigned a value to a variable, you can use the variable in expressions.

>>> x * 2
6

Unlike some other languages, you can’t use a variable before you bind it to something. There is no “default value.”

Statements

Until now we’ve been working (almost) exclusively with expressions, the ingredients of the recipe. But what about statements—the instructions?

In fact, I’ve cheated. I’ve introduced two types of statements already: the print statement and assignments. What’s the difference between a statement and an expression? You could think of it like this: an expression is something, while a statement does something. For example, 2 * 2 is 4, whereas print(2 * 2) prints 4. The two behave quite similarly, so the difference between them might not be all that clear.

>>> 2 * 2
4
>>> print(2 * 2)
4

As long as you execute this in the interactive interpreter , there’s no difference, but that is only because the interpreter always prints out the values of all expressions (using the same representation as repr—see the section “String Representations, str and repr” later in this chapter). That is not true of Python in general. Later in this chapter, you’ll see how to make programs that run without this interactive prompt; simply putting an expression such as 2 * 2 in your program won’t do anything interesting.⁴ Putting print(2 * 2) in there, however, will still print out 4.

The difference between statements and expressions is more obvious when dealing with assignments. Because they are not expressions, they have no values that can be printed out by the interactive interpreter.

>>> x = 3
>>>

You simply get a new prompt immediately. Something has changed, however. We now have a new variable x, which is now bound to the value 3. To some extent, this is a defining quality of statements in general: they change things. For example, assignments change variables, and print statements change how your screen looks.

Assignments are probably the most important type of statement in any programming language, although it may be difficult to grasp their importance right now. Variables may just seem like temporary “storage” (like the pots and pans of a cooking recipe), but the real power of variables is that you don’t need to know what values they hold in order to manipulate them.⁵

For example, you know that x * y evaluates to the product of x and y, even though you may have no knowledge of what x and y are. So, you may write programs that use variables in various ways without knowing the values they will eventually hold (or refer to) when the program is run.

Getting Input from the User

You’ve seen that you can write programs with variables without knowing their values. Of course, the interpreter must know the values eventually. So how can it be that we don’t? The interpreter knows only what we tell it, right? Not necessarily.

You may have written a program, and someone else may use it. You cannot predict what values users will supply to the program. Let’s take a look at the useful function input. (I’ll have more to say about functions in a minute.)

>>> input("The meaning of life: ")
The meaning of life: 42
'42'

What happens here is that the first line (input(...)) is executed in the interactive interpreter. It prints out the string "The meaning of life: " as a new prompt. I type 42 and press Enter. The resulting value of input is that very number (as a piece of text, or string), which is automatically printed out in the last line. Converting the strings to integers using int, we can construct a slightly more interesting example:

>>> x = input("x: ")
x: 34
>>> y = input("y: ")
y: 42
>>> print(int(x) * int(y))
1428

Here, the statements at the Python prompts (>>>) could be part of a finished program, and the values entered (34 and 42) would be supplied by some user. Your program would then print out the value 1428, which is the product of the two. And you didn’t have to know these values when you wrote the program, right?

>>> if 1 == 2: print('One equals two')
...
>>> if 1 == 1: print('One equals one')
...
One equals one
>>>

if time % 60 == 0: print('On the hour!')

Functions

In the “Numbers and Expressions” section, I used the exponentiation operator (**) to calculate powers. The fact is that you can use a function instead, called pow.

>>> 2 ** 3
8
>>> pow(2, 3)
8

A function is like a little program that you can use to perform a specific action. Python has a lot of functions that can do many wonderful things. In fact, you can make your own functions, too (more about that later); therefore, we often refer to standard functions such as pow as built-in functions.

Using a function as I did in the preceding example is called calling the function. You supply it with arguments (in this case, 2 and 3), and it returns a value to you. Because it returns a value, a function call is simply another type of expression, like the arithmetic expressions discussed earlier in this chapter.⁶ In fact, you can combine function calls and operators to create more complicated expressions (like I did with int, earlier).

>>> 10 + pow(2, 3 * 5) / 3.0
10932.666666666666

Several built-in functions can be used in numeric expressions like this. For example, abs gives the absolute value of a number, and round rounds floating-point numbers to the nearest integer.

>>> abs(-10)
10
>>> 2 // 3
0
>>> round(2 / 3)
1.0

Notice the difference between the two last expressions . Integer division always rounds down, whereas round rounds to the nearest integer, with ties rounded toward the even number. But what if you want to round a given number down? For example, you might know that a person is 32.9 years old, but you would like to round that down to 32 because she isn’t really 33 yet. Python has a function for this (called floor)—it just isn’t available directly. As is the case with many useful functions, it is found in a module.

Modules

You may think of modules as extensions that can be imported into Python to expand its capabilities. You import modules with a special command called (naturally enough) import. The function mentioned in the previous section, floor, is in a module called math.

>>> import math
>>> math.floor(32.9)
32

Notice how this works: we import a module with import and then use the functions from that module by writing module.function. For this operation in particular, you could actually just convert the number into an integer, like I did earlier, with the results from input.

>>> int(32.9)
32

The math module has several other useful functions, though. For example, the opposite of floor is ceil (short for “ceiling”), which finds the smallest integral value larger than or equal to the given number.

>>> math.ceil(32.3)
33
>>> math.ceil(32)
32

If you are sure that you won’t import more than one function with a given name (from different modules), you might not want to write the module name each time you call the function. Then you can use a variant of the import command.

>>> from math import sqrt
>>> sqrt(9)
3.0

After using the from module import function, you can use the function without its module prefix.

>>> from math import sqrt
>>> sqrt(-1)
Traceback (most recent call last):    ...
ValueError: math domain error

>>> sqrt(-1)
nan

>>> import cmath
>>> cmath.sqrt(-1)
1j

>>> (1 + 3j) * (9 + 4j)
(-3 + 31j)

Saving and Executing Your Programs

The interactive interpreter is one of Python’s great strengths. It makes it possible to test solutions and to experiment with the language in real time. If you want to know how something works, just try it! However, everything you write in the interactive interpreter is lost when you quit. What you really want to do is write programs that both you and other people can run. In this section, you learn how to do just that.

First of all, you need a text editor, preferably one intended for programming. (If you use something like Microsoft Word, which I really don’t really recommend, be sure to save your code as plain text.) If you are already using IDLE , you’re in luck. With IDLE, you can simply create a new editor window with File › New File. Another window appears, without an interactive prompt. Whew! Start by entering the following:

print("Hello, world!")

Now select File › Save to save your program (which is, in fact, a plain text file). Be sure to put it somewhere where you can find it later, and give your file any reasonable name, such as hello.py. (The .py ending is significant.)

Got that? Don’t close the window with your program in it. If you did, just open it again (File › Open). Now you can run it with Run › Run Module. (If you aren’t using IDLE, see the next section about running your programs from the command prompt.)

What happens? Hello, world! is printed in the interpreter window, which is exactly what we wanted. The interpreter prompt may be gone (depending on the version you’re using), but you can get it back by pressing Enter (in the interpreter window).

Let’s extend our script to the following:

name = input("What is your name? ")
print("Hello, " + name  + "!")

If you run this (remember to save it first), you should see the following prompt in the interpreter window:

What is your name?

Enter your name (for example, Gumby) and press Enter. You should get something like this:

Hello, Gumby!

from turtle import *

forward(100)
left(120)
forward(100)
left(120)
forward(100)

C:>python hello.py

$ python hello.py

#!/usr/bin/env python

$ chmod a+x hello.py

$ hello.py

input("Press <enter>")

What is your name? Gumby
Hello, Gumby!
Press <enter>

# Print the circumference of the circle:
print(2 * pi * radius)

# Get the user's name:
user_name = input("What is your name?")

Strings

Now what was all that "Hello, " + name + "!" stuff about? The first program in this chapter was simply

print("Hello, world!")

It is customary to begin with a program like this in programming tutorials. The problem is that I haven’t really explained how it works yet. You know the basics of the print statement (I’ll have more to say about that later), but what is "Hello, world!"? It’s called a string (as in “a string of characters”). Strings are found in almost every useful, real-world Python program and have many uses. Their main use is to represent bits of text, such as the exclamation “Hello, world!”

>>> "Hello, world!"
'Hello, world!'

>>> 'Hello, world!'
'Hello, world!'

>>> "Let's go!"
"Let's go!"
>>> '"Hello, world!" she said'
'"Hello, world!" she said'

>>> 'Let's go!'
SyntaxError: invalid syntax

>>> 'Let's go!'
"Let's go!"

>>> ""Hello, world!" she said"
'"Hello, world!" she said'

>>> "Let's say " '"Hello, world!"'
'Let's say "Hello, world!"'

>>> x = "Hello, "
>>> y = "world!"
>>> x y
SyntaxError: invalid syntax

>>> "Hello, " + "world!"
'Hello, world!'
>>> x = "Hello, "
>>> y = "world!"
>>> x + y
'Hello, world!'

>>> "Hello, world!"
'Hello, world!'
>>> print("Hello, world!")
Hello, world!

>>> "Hello,
world!"
'Hello,
world!'
>>> print("Hello,
world!")
Hello,
world!

>>> print(repr("Hello,
world!"))
'Hello,
world!'
>>> print(str("Hello,
world!"))
Hello,
world!

print('''This is a very long string.  It continues here.
And it's not over yet.  "Hello, world!"
Still here.''')

print("Hello,  world!")

>>> 1 + 2 + 
    4 + 5
12
>>> print 
    ('Hello, world')
Hello, world

>>> print('Hello,
world!')
Hello,
world!

>>> path = 'C:
owhere'
>>> path
'C:
owhere'

>>> print(path)
C:
owhere

>>> print('C:\nowhere')
C:
owhere

path = 'C:\Program Files\fnord\foo\bar\baz\frozz\bozz'

>>> print(r'C:
owhere')
C:
owhere
>>> print(r'C:Program Filesfnordfooarazfrozzozz')
C:Program Filesfnordfooarazfrozzozz

>>> print(r'Let's go!')
Let's go!

>>> print(r"This is illegal")
SyntaxError: EOL while scanning string literal

>>> print(r'C:Program Filesfooar' '')
C:Program Filesfooar

>>> b'Hello, world!'
b'Hello, world!'

>>> "Hello, world!".encode("ASCII")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-8")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-32")
b'xffxfex00x00Hx00x00x00ex00x00x00lx00x00x00lx00x00x00ox00x00x00,x00x00x00 x00x00x00wx00x00x00ox00x00x00rx00x00x00lx00x00x00dx00x00x00!x00x00x00'

>>> len("How long is this?".encode("UTF-8"))
17
>>> len("How long is this?".encode("UTF-32"))
72

>>> "Hællå, wørld!".encode("ASCII")
Traceback (most recent call last):
  ...
UnicodeEncodeError: 'ascii' codec can't encode character 'xe6' in position 1: ordinal not in range(128)

>>> "Hællå, wørld!".encode("ASCII", "ignore")
b'Hll, wrld!'
>>> "Hællå, wørld!".encode("ASCII", "replace")
b'H?ll?, w?rld!'
>>> "Hællå, wørld!".encode("ASCII", "backslashreplace")
b'H\xe6ll\xe5, w\xf8rld!'
>>> "Hællå, wørld!".encode("ASCII", "xmlcharrefreplace")
b'Hællå, wørld!'

>>> "Hællå, wørld!".encode()
b'Hxc3xa6llxc3xa5, wxc3xb8rld!'

>>> b'Hxc3xa6llxc3xa5, wxc3xb8rld!'.decode()
'Hællå, wørld!'

>>> bytes("Hællå, wørld!", encoding="utf-8")
b'Hxc3xa6llxc3xa5, wxc3xb8rld!'
>>> str(b'Hxc3xa6llxc3xa5, wxc3xb8rld!', encoding="utf-8")
'Hællå, wørld!'

# -*- coding: encoding name -*-

>>> x = bytearray(b"Hello!")
>>> x[1] = ord(b"u")
>>> x
bytearray(b'Hullo!')

A Quick Summary

This chapter covered quite a bit of material. Let’s take a look at what you’ve learned before moving on.

• Algorithms: An algorithm is a recipe telling you exactly how to perform a task. When you program a computer, you are essentially describing an algorithm in a language the computer can understand, such as Python. Such a machine-friendly description is called a program, and it mainly consists of expressions and statements.

• Expressions: An expression is a part of a computer program that represents a value. For example, 2 + 2 is an expression, representing the value 4. Simple expressions are built from literal values (such as 2 or "Hello") by using operators (such as + or %) and functions (such as pow). More complicated expressions can be created by combining simpler expressions (e.g., (2 + 2) * (3 - 1)). Expressions may also contain variables.

• Variables: A variable is a name that represents a value. New values may be assigned to variables through assignments such as x = 2. An assignment is a kind of statement.

• Statements: A statement is an instruction that tells the computer to do something. That may involve changing variables (through assignments), printing things to the screen (such as print("Hello, world!")), importing modules, or doing a host of other stuff.

• Functions: Functions in Python work just like functions in mathematics: they may take some arguments, and they return a result. (They may actually do lots of interesting stuff before returning, as you will find out when you learn to write your own functions in Chapter 6.)

• Modules: Modules are extensions that can be imported into Python to extend its capabilities. For example, several useful mathematical functions are available in the math module.

• Programs: You have looked at the practicalities of writing, saving, and running Python programs.

• Strings: Strings are really simple—they are just pieces of text, with characters represented as Unicode code points. And yet there is a lot to know about them. In this chapter, you’ve seen many ways to write them, and in Chapter 3 you learn many ways of using them.