Variables are references to Python objects. They are created by assignments, for example:

a = 1
diameter = 3.
height = 5.
cylinder = [diameter, height] # reference to a list

Variables take names that consist of any combination of capital and small letters, the underscore _, and digits. A variable name must not start with a digit. Note that variable names are case sensitive. A good naming of variables is an essential part of documenting your work, so we recommend that you use descriptive variable names.

Python has 33 reserved keywords, which cannot be used as variable names (see Table 2.1). Any attempt to use such a keyword as a variable name would raise a syntax error:

Table 2.1: Reserved Python keywords

As opposed to other programming languages, variables require no type declaration in Python. The type is automatically deduced:

x = 3 # integer (int)
y = 'sunny' # string (str)

You can create several variables with a multiple assignment statement:

a = b = c = 1 # a, b and c get the same value 1

Variables can also be altered after their definition:

a = 1 
a = a + 1 # a gets the value 2 
a = 3 * a # a gets the value 6

The last two statements can be written by combining the two operations with an assignment directly by using increment operators:

a += 1 # same as a = a + 1 
a *= 3 # same as a = 3 * a

At some point, you will have to work with numbers, so we start by considering different forms of numeric types in Python. In mathematics, we distinguish between natural numbers (ℕ), integers (ℤ), rational numbers (ℚ), real numbers (ℝ), and complex numbers (ℂ). These are infinite sets of numbers. Operations differ between these sets and may even not be defined. For example, the usual division of two numbers in ℤ might not result in an integer — it is not defined on ℤ.

In Python, like many other computer languages, we have numeric types:

• The numeric type, int, which is at least theoretically the entire ℤ
• The numeric type, float, which is a finite subset of ℝ
• The numeric type, complex, which is a finite subset of ℂ

Finite sets have a smallest and a largest number and there is a minimum spacing between two numbers; see Section 2.2.2, Floating-point numbers, for further details.

The simplest numeric type is the integer type int.

The statement k = 3 assigns the variable k to an integer.

Applying an operation such as +, -, or * to integers returns an integer. The division operator, //, returns an integer, while / returns a float:

6 // 2  # 3  an integer value
7 // 2  # 3
7 / 2   # 3.5  a float value

The set of integers in Python is unbounded; there is no largest integer. The limitation here is the computer's memory rather than any fixed value given by the language.

If you execute the statement a = 3.0 in Python, you create a floating-point number (Python type: float). These numbers form a finite subset of rational numbers, ℚ.

Alternatively, the constant could have been given in exponent notation as a = 30.0e-1 or simply a = 30.e-1. The symbol e separates the exponent from the mantissa, and the expression reads in mathematical notation as . The name floating-point number refers to the internal representation of these numbers and reflects the floating position of the decimal point when considering numbers over a wide range.

Applying elementary mathematical operations, such as +, -, *, and /, to two floating-point numbers, or to an integer and a floating-point number, returns a floating-point number.

Operations between floating-point numbers rarely return the exact result expected from rational number operations:

0.4 - 0.3 # returns 0.10000000000000003

This fact matters when comparing floating-point numbers:

0.4 - 0.3 == 0.1 # returns False

The reason for this becomes apparent when looking at the internal representation of floating-point numbers; see also Section 15.2.6, Float comparisons.

A floating-point number is represented by three quantities: the sign, the mantissa, and the exponent:

with  and .

is called the mantissa,  the basis, and e the exponent, with .  is called the mantissa length. The condition  makes the representation unique and saves, in the binary case (), one bit.

Two-floating point zeros,  and , exist, both represented by the mantissa .

On a typical Intel processor, . To represent a number in the float type, 64 bits are used, namely, 1 bit for the sign,  bits for the mantissa, and  bits for the exponent . The upper bound  for the exponent is consequently .

With this data, the smallest positive representable number is

, and the largest .

Note that floating-point numbers are not equally spaced in . There is, in particular, a gap at zero (see also [29]). The distance between and the first positive number is , while the distance between the first and the second is smaller by a factor . This effect, caused by the normalization , is visualized in Figure 2.1:

Figure 2.1: The floating-point gap at zero. Here 

This gap is filled equidistantly with subnormal floating-point numbers to which such a result is rounded. Subnormal floating-point numbers have the smallest possible exponent and do not follow the normalization convention, .

There are, in total,  floating-point numbers. Sometimes, a numerical algorithm computes floating-point numbers outside this range.

This generates number overflow or underflow. In NumPy, the special floating-point number inf is assigned to overflow results:

exp(1000.) # inf 
a = inf
3 - a # -inf
3 + a # inf

Working with inf may lead to mathematically undefined results. This is indicated in Python by assigning the result another special floating-point number, nan. This stands for not-a-number, that is, an undefined result of a mathematical operation. To demonstrate this, we continue the previous example:

a + a # inf
a - a # nan 
a / a # nan

There are special rules for operations with nan and inf. For instance, nan compared to anything (even to itself) always returns False:

x = nan 
x < 0 # False
x > 0 # False
x == x # False

See Exercise 4 for some surprising consequences of the fact that nan is never equal to itself.

The float inf behaves much more as expected:

0 < inf     # True 
inf <= inf  # True 
inf == inf  # True 
-inf < inf  # True 
inf - inf   # nan 
exp(-inf)   # 0 
exp(1 / inf)  # 1

One way to check for nan and inf is to use the functions isnan and isinf. Often, you want to react directly when a variable gets the value nan or inf. This can be achieved by using the NumPy command seterr. The following command

seterr(all = 'raise')

would raise a FloatingPointError if a calculation were to return one of those values.

Underflow occurs when an operation results in a rational number that falls into the gap at zero; see Figure 2.1.

The machine epsilon, or rounding unit, is the largest number  such that .

Note that  on most of today's computers. The value that applies on the actual machine you are running your code on is accessible using the following command:

import sys 
sys.float_info.epsilon # 2.220446049250313e-16 

The variable sys.float_info contains more information on the internal representation of the float type on your machine.

The function float converts other types to a floating-point number, if possible. This function is especially useful when converting an appropriate string to a number:

a = float('1.356')

NumPy also provides other float types, known from other programming languages as double-precision and single-precision numbers, namely, float64 and float32:

a = pi            # returns 3.141592653589793 
a1 = float64(a)   # returns 3.141592653589793
a2 = float32(a)   # returns 3.1415927 
a - a1            # returns 0.0 
a - a2            # returns -8.7422780126189537e-08

The second last line demonstrates that a and a1 do not differ in accuracy. A difference in accuracy exists between a and its single-precision counterpart, a2.

The NumPy function finfo can be used to display information on these floating-point types:

f32 = finfo(float32) 
f32.precision   # 6 (decimal digits) 
f64 = finfo(float64) 
f64.precision   # 15 (decimal digits) 
f = finfo(float) 
f.precision     # 15 (decimal digits) 
f64.max         # 1.7976931348623157e+308 (largest number) 
f32.max         # 3.4028235e+38 (largest number) 
help(finfo)     # Check for more options

Complex numbers are an extension of the real numbers frequently used in many scientific and engineering fields.

Complex numbers consist of two floating-point numbers, the real part, , of the number, and its imaginary part, . In mathematics, a complex number is written as , where defined by is the imaginary unit. The conjugate complex counterpart of  is .

If the real part  is zero, the number is called an imaginary number.

In Python, imaginary numbers are characterized by suffixing a floating-point number with the letter j, for example, z = 5.2j. A complex number is formed by the sum of a real number and an imaginary number, for example, z = 3.5 + 5.2j.

While in mathematics the imaginary part is expressed as a product of a real number b with the imaginary unit , the Python way of expressing an imaginary number is not a product: j is just a suffix to indicate that the number is imaginary.

This is demonstrated by the following small experiment:

b = 5.2 
z = bj # returns a NameError 
z = b*j # returns a NameError
z = b*1j # is correct

The method conjugate returns the conjugate of z:

z = 3.2 + 5.2j 
z.conjugate() # returns (3.2-5.2j)

You may access the real and imaginary parts of a complex number  using the real and imag attributes. Those attributes are read-only; in other words, they cannot be changed:

z = 1j 
z.real # 0.0 
z.imag # 1.0 
z.imag = 2 # AttributeError: readonly attribute

It is not possible to convert a complex number to a real number:

z = 1 + 0j 
z == 1 # True 
float(z) # TypeError

Interestingly, the real and imag attributes as well as the conjugate method work just as well for complex arrays; see also Section 4.3.1, Array properties. We demonstrate this by computing the N^th roots of unity, which are , that is, the  solutions of the equation :

from matplotlib.pyplot import *
N = 10
# the following vector contains the Nth roots of unity: 
unity_roots = array([exp(1j*2*pi*k/N) for k in range(N)])
# access all the real or imaginary parts with real or imag:
axes(aspect='equal')
plot(unity_roots.real, unity_roots.imag, 'o')
allclose(unity_roots**N, 1) # True

The resulting figure shows the 10 roots of unity. In Figure 2.2, it is completed by a title and axes labels and shown together with the unit circle. (For more details on how to make plots, see Chapter 6: Plotting.)

It is, of course, possible to mix the previous methods, as illustrated by the following examples:

z = 3.2+5.2j 
(z + z.conjugate()) / 2. # returns (3.2+0j) 
((z + z.conjugate()) / 2.).real # returns 3.2 
(z - z.conjugate()) / 2. # returns 5.2j 
((z - z.conjugate()) / 2.).imag # returns 5.2 
sqrt(z * z.conjugate()) # returns (6.1057350089894991+0j)

Boolean is a data type named after George Boole (1815-1864). A Boolean variable can take only two values, True or False. The main use of this type is in logical expressions. Here are some examples:

a = True 
b = 30 > 45 # b gets the value False

Boolean expressions are often used in conjunction with if statements:

x= 5
if x > 0:
 print("positive")
else:
 print("nonpositive")

Boolean operations are performed using the keywords and, or, and not:

True and False # False
False or True # True
(30 > 45) or (27 < 30) # True
not True # False
not (3 > 4) # True

The operators follow some precedence rules (see also Section 1.3.5, Boolean expressions) which would make the parentheses in the third and in the last line obsolete. Nevertheless, it is a good practice to use them in any case to increase the readability of your code.

Note, the and operator is implicitly chained in the following Boolean expressions:

a < b < c     # same as: a < b and b < c 
a < b <= c    # same as: a < b and b <= c (less or equal)
a == b == c   # same as: a == b and b == c

Most Python objects may be converted to Booleans; this is called Boolean casting. The built-in function bool performs that conversion. Note that most objects are cast to True, except 0, the empty tuple, the empty list, the empty string, or the empty array. These are all cast to False.

It is not possible to cast arrays into Booleans unless they contain no or only one element; this is explained further in Section 5.2.1, Boolean arrays. The previous table (see Table 2.2: Casting rules for Booleans) contains summarized rules for Boolean casting.

We demonstrate this by means of some usage examples:

bool([]) # False 
bool(0) # False 
bool(' ') # True 
bool('') # False 
bool('hello') # True 
bool(1.2) # True 
bool(array([1])) # True 
bool(array([1,2])) # Exception raised!

Using an if statement with a non-Boolean type will cast it to a Boolean. In other words, the following two statements are always equivalent:

if a:
 ...
if bool(a): # exactly the same as above
 ...

A typical example is testing whether a list is empty:

# L is a list
if L:
    print("list not empty")
else:
    print("list is empty")

An empty list, or tuple, will return False.

You can also use a variable in the if statement, for example, an integer:

# n is an integer
if n % 2:         # the modulo operator
    print("n is odd")
else:
    print("n is even")

Note that we used % for the modulo operation, which returns the remainder of an integer division. In this case, it returns 0 or 1 as the remainder after modulo 2.

In this last example, the values 0 or 1 are cast to bool; see also Section 2.3.4, Booleans and integers.

The Boolean operators or, and, and not will also implicitly convert some of their arguments to a Boolean.

Note that the operators and and or do not necessarily produce Boolean values. This can be explained by the fact that the expression x and y is equivalent to:

def and_as_function(x,y):
    if not x:
        return x
    else:
        return y

Correspondingly, the expression x or y is equivalent to:

def or_as_function(x,y):
    if x:
        return x
    else:
        return y

Interestingly, this means that when executing the statement True or x, the variable x need not even be defined! The same holds for False and x.

Note that, unlike their counterparts in mathematical logic, these operators are no longer commutative in Python. Indeed, the following expressions are not equivalent:

1 or 'a' # produces 1 
'a' or 1 # produces 'a'

In fact, Booleans and integers are the same. The only difference is in the string representations of 0 and 1, which, in the case of Booleans, is False and True, respectively. This allows constructions such as this:

def print_ispositive(x):
    possibilities = ['nonpositive or zero', 'positive']
    return f"x is {possibilities[x>0]}"

The last line in this example uses string formatting, which is explained in Section 2.4.3, String formatting.

We note for readers already familiar with the concept of subclasses that the type bool is a subclass of the type int (see Chapter 8: Classes). Indeed, all four inquiries – isinstance(True, bool), isinstance(False, bool), isinstance(True, int), and isinstance(False, int) return the value True (see Section 3.7, Checking the type of a variable).

Even rarely used statements such as True+13 are correct.

The type string is a type used for text:

name = 'Johan Carlsson'
child = "Åsa is Johan Carlsson's daughter"
book = """Aunt Julia 
       and the Scriptwriter"""

A string is enclosed either by single or double quotes. If a string contains several lines, it has to be enclosed by three double quotes """ or three single quotes '''.

Strings can be indexed with simple indexes or slices (see  Chapter 3: Container Types, for a comprehensive explanation on slices):

book[-1] # returns 'r' 
book[-12:] # returns 'Scriptwriter'

Strings are immutable; that is, items cannot be altered. They share this property with tuples. The command book[1] = 'a' returns:

TypeError: 'str' object does not support item assignment

The string '\n' is used to insert a line break and '\t' inserts a horizontal tabulator (TAB) into the string to align several lines:

print('Temperature\t20\tC\nPressure\t5\tPa')

These strings are examples of escape sequences. Escape sequences always start with a backslash, \. A multiline string automatically includes escape sequences:

a=""" 
A multi-line 
example""" 
a # returns '\nA multi-line \nexample'

A special escape sequence is "\\", which represents the backslash symbol in text:

latexfontsize="\\tiny"
print(latexfontsize) # prints \tiny

The same can be achieved by using a raw string instead:

latexfs=r"\tiny" # returns "\tiny"
latexfontsize == latexfs # returns True

Note that in raw strings, the backslash remains in the string and is used to escape some special characters:

print(r"\"") # returns \"
print(r"\\") # returns \
print(r"\") # returns an error (why?)

A raw string is a convenient tool to construct strings in a readable manner. The result is the same:

r"\"" == '\\"'
r"She: \"I am my dad's girl\"" == 'She: \\"I am my dad\'s girl\\"'