In a Python transcript, >>> is the Python shell prompt. A >>> marks a line of input from you, the user, while lines without a >>> are generated by Python. Thus it is easy to distinguish at a glance what is from Python and what is from you.

A shell transcript is a snapshot of the command shell showing a series of user inputs and Python replies. We’ll be using them frequently; they’re a great way to learn Python by seeing real examples in action.

Python also has an integer division operator, //. It works like /, except that it always returns an integer. For example, 7 // 3 evaluates to the integer 2; the digits after the decimal are simply chopped off (// does no rounding!).

Table 2.1 summarizes Python’s basic arithmetic operators. They are grouped from lowest precedence to highest precedence. For example, when Python evaluates the expression 1 + 2 * 3, it does * before + because * has higher precedence (so it evaluates to 7—not 9!). Operators at the same level of precedence are evaluated in the order they are written. You can use round brackets, (), to change the order of evaluation—so, for example, (1 + 2) * 3 evaluates to 9. In other words, Python arithmetic follows the same evaluation rules as regular arithmetic.

Unlike most other programming languages, Python puts no limit on the size of an integer. You can do calculations involving numbers with dozens (or hundreds, or thousands) of digits:

>>> 27 ** 100
1368914790585883759913260273820883159664
6369562533743647148019007836899717749907
6593800206155688941388250484440597994042
813512732765695774566001

Very large or small floats are often written in scientific notation:

>>> 8.8 ** -5.4
7.939507629591553e-06

The e-06 means to multiply the preceding number by 10⁻⁶. You can use scientific notation directly if you like:

>>> 2.3e02
230.0

Python is quite forgiving about the use of decimal points:

>>> 3.
3.0
>>> 3.0
3.0

You can write numbers like 0.5 with or without the leading 0:

>>> .5
0.5
>>> 0.5
0.5

Unlike integers, floating point numbers have minimum and maximum values that, if exceeded, will cause overflow errors. An overflow error means you’ve tried to calculate a number that Python cannot represent as a float, because it is either too big or too small (Figure 2.3). Overflow errors can be silent errors, meaning that Python may just do the calculation incorrectly without telling you that anything bad has happened. Generally speaking, it is up to you, the programmer, to avoid overflow errors.

>>> 500.0 ** 10000
Traceback (most recent call last):
    File "<pyshell#38>", line 1, in <module>
       500.0 ** 10000
OverflowError: (34, 'Result too large')

Precision (that is, accuracy) is a fundamental difficulty with floats on all computers. Numbers are represented in binary (base 2) in a computer, and it turns out that not all floating point numbers can be represented precisely in binary. Even the simplest examples can have problems:

>>> 1 / 3
0.33333333333333331

This should have an infinite number of 3s after the decimal, but there are only (!) 17 digits here. Plus, the last digit is wrong (the 1 should be a 3).

These small errors are not usually a problem: 17 digits after the decimal is enough for most programs. However, little errors have a nasty habit of becoming big errors when you are doing lots of calculations. If you are, say, computing the stresses on a newly designed bridge, it is necessary to take these floating point approximations into account to ensure that they don’t balloon into significant errors.

Python has built-in support for complex numbers—that is, numbers that involve the square root of −1. In Python, 1j denotes the square root of −1:

>>> 1j
1j
>>> 1j * 1j
(-1+0j)

Complex numbers are useful in certain engineering and scientific calculations; we won’t be using them again in this book.

We say that these functions return a value. That means they evaluate to either an integer or a floating point number, depending on the function.

You can use these functions anywhere that you can use a number. Python automatically evaluates the function and replaces it with its return value.

To use the math module, or any existing Python module, you must first import it:

>>> import math

You can now access any math function by putting math. in front of it:

>>> math.sqrt(5)
2.2360679774997898
>>> math.sqrt(2) * math.tan(22)
0.012518132023611912

An alternative way of importing a module is this:

>>> from math import *

Now you can call all the math module functions without first appending math.:

>>> log(25 + 5)
3.4011973816621555
>>> sqrt(4) * sqrt(10 * 10)
20.0

Python lets you indicate string literals in three main ways:

To determine the number of characters in a string, use the len(s) function:

>>> len('pear')
4
>>> len('up, up, and away')
16
>>> len("moose")
5
>>> len("")
0

The last example uses the empty string, usually denoted by '' or "". The empty string has zero characters in it.

Since len evaluates to (that is, returns) an integer, we can use len anywhere that an integer is allowed—for example:

>>> 5 + len('cat') * len('dog')
14

Once you’ve imported a module, you can list all of its functions using the dir(m) function:

>>> import math
>>> dir(math)
['__doc__', '__name__', '__package__', 'acos',
'acosh', 'asin', 'asinh', 'atan',
'atan2', 'atanh', 'ceil',
'copysign', 'cos', 'cosh', 'degrees',
'e', 'exp', 'fabs', 'factorial',
'floor', 'fmod', 'frexp', 'hypot',
'isinf', 'isnan', 'ldexp', 'log',
'log10', 'log1p', 'modf', 'pi', 'pow',
'radians', 'sin', 'sinh', 'sqrt', 'sum',
'tan', 'tanh', 'trunc']

This gives you a quick overview of the functions in a module, and many Python programmers use dir(m) all the time.

For now, you can ignore the names beginning with a double underscore __; they are used only in more advanced Python programming.

Another useful trick is to print a function’s documentation string (doc string for short):

>>> print(math.tanh.__doc__)
tanh(x)
Return the hyperbolic tangent of x.

Most built-in Python functions, along with most functions in Python’s standard modules (such as math), have short doc strings you can access in this way.

As another example, here’s the doc string for the built-in function bin:

>>> print(bin.__doc__)
bin(number) -> string
Return the binary representation of an integer or long integer.
>>> bin(25)
'0b11001'

To convert the number 3 to a float, use the float(x) function:

>>> float(3)
3.0

Converting a string to a float is similar:

>>> float('3.2')
3.2000000000000002
>>> float('3')
3.0

The str(n) function converts any number to a corresponding string:

>>> str(85)
'85'
>>> str(-9.78)
'-9.78'

>>> 25 * 8.5
212.5

This is a little tricky because you must decide how to handle any digits after the decimal in your float. The int(x) function simply chops off extra digits, while round(x) does the usual kind of rounding off:

>>> int(8.64)
8
>>> round(8.64)
9
>>> round(8.5)
8

This is easily done with the int(s) and float(s) functions:

>>> int('5')
5
>>> float('5.1')
5.0999999999999996

Variable names must follow a few basic rules (see Table 2.3 for some examples):

It’s essential to understand that assignment statements don’t make a copy of the value they point to. All they do is label, and relabel, existing values. Thus, no matter how big or complex the object a variable points to, assignment statements are always exceedingly efficient.

An important feature of Python numbers and strings is that they are immutable—that is, they cannot be changed in any way, ever. Whenever it seems that you are modifying a number or string, Python is in fact making a modified copy (Figure 2.9).

>>> s = 'apple'
>>> s + 's'
'apples'
>>> s
'apple'
>>> 5 = 1
SyntaxError: can't assign to literal (<pyshell#3>, line 1)

A useful trick you can do with multiple assignment is to swap the values of two variables:

>>> a, b = 5, 9
>>> a, b
(5, 9)
>>> a, b = b, a
>>> a, b
(9, 5)

The statement a, b = b, a is said to assign values to a and b in parallel. Without using multiple assignment, the standard way to swap variables is like this:

>>> a, b = 5, 9
>>> temp = a
>>> a = b
>>> b = temp
>>> a, b
(9, 5)

Multiple assignment doesn’t do anything you can’t already do with regular assignment. It is just a convenient shorthand that we will sometimes be using.