Numerical types

Python has several different numerical types built in that allow you to represent integer, floating point, and complex numbers using the following types:

There are a range of ways to define a numerical value in Python. Typically, this can be done by typing the standard representation of a number as shown in the following example:

a = 42
type(a)
b = 0.009
type(b)
c = 10000000000
type(c)
d = 100L
type(d)

Following is the output of this code:

As the output shows, each numerical value is assigned a different type in Python:

Since we have mentioned the maximum numerical precision of a particular system, we will quickly look at how we can actually find out what the value of this is. Python provides this value in the sys module (which is used to retrieve information about the host system).

import sys
sys.maxint

This returns the maximum value that can be held as an int, as shown in the following screenshot; anything larger will use the long type instead:

Integer types can also be defined using hexadecimal and binary notation using the 0x and 0b prefixes, as shown in the following example:

e = 0xFF
e
type(e)
f = 0b11111111
f
type(f)

As the following screenshot shows, both numbers evaluate to an integer with the value 255:

Using this format for integer types will become more useful later when we start interacting with the GPIO expansion header on the Raspberry Pi.

Floating point and complex numbers also have their own syntax, based on the standard scientific syntax for their notation.

g = 2.75e-3
g
type(g)
h = (5+3j)
h
type(h)

This creates a floating point and complex number respectively, as shown in the following output:

It is also possible to create numerical types explicitly using the type name as a function, as shown in the following example. Doing this also allows you to convert between different numerical types and create numerical types by parsing strings.

a = int(4)
a
type(a)
b = int("4")
b
type(b)
c = long(4)
c
type(c)
d = int(5.9864)
d
type(d)
e = float(9)
e
type(e)
f = complex(3, 8)
f
type(f)
g = int("one")

The output from this previous example is shown in the following screenshot. Note that for the last variable (g), an exception was raised as there was no way to convert the string to an int type (we will cover exceptions in more detail later on in the chapter).

Operations on numerical types

If you have ever used any other programming language then the numerical operators you will find in Python will not be greatly different. The main operators are listed as follows:

It is worth noting that with the exception of complex numbers, which do not work for integer division, module, and the divmod() operations, you can use any combination of numerical types with these functions.

Following is an example of these operations:

a = 49
b = 5
c = 6.5
d = 3e-9
e = 100L
a + b
a - b
a / b
a // b
a % b
c / d
e / a
div, rem = divmod(a, b)
div
rem

The output of this preceding code is shown next. You may wish to use the type() functions here to check the return type of each of the operations.

One thing to note here is that despite the fact that 49/5 is actually 9.8, when we execute 49/5 in Python, the result will be 9. Because both operands are of type int only integer division was performed and hence the return value will effectively be the floored value (that is, the value with the decimal part subtracted) of the actual result.

It is also possible to perform certain operations directly on the left hand side value of the operation. In this case, the value held by the left hand side is modified and no value is returned. This is supported by the following operations:

The following example demonstrates this format for the operators. Note that here you need to print out the output in order to see that the value is being changed.

a = 45
b = 5
a += b
a
a -= b
a
a *= b
a
a /= b
a

The output of this is shown in the following screenshot:

String manipulation

The next topic we will look at is string storage and manipulation. As with numerical types, strings can be assigned using a literal (a value written exactly as it should be interpreted) as the right hand operand of the assignment operator =. You can also take a majority of any other type and convert it to a string using the str() function as shown in the following example:

a = "Hello, world!"
a
type(a)
b = complex(3, 6)
b
type(b)
c = str(b)
c
type(c)

The output of this is shown in the following screenshot:

String formatting

Python supports both the conventional style string formatting using the % identifier syntax (for example, %.5d is an integer with up to 5 leading zeros) which can be found in a lot of other programming languages, and Python's own (more powerful) string formatting mini-language.

Here we will only look at the conventional style formatting as it is usually good enough for the majority of uses and is much simpler to understand. The details for the Python formatting language can be found online at docs.python.org/2/library/string.html#string-formatting.

The conventional string formatting is done in Python using the syntax in the following example:

"%s is %d years old" % ("Alice", 23)

This returns the string "Alice is 23 years old", as shown in the following output:

There are several additional formatting options that can be used here to control how the string is formatted. The complete documentation can be found online at docs.python.org/2/library/stdtypes.html#string-formatting-operations.

A format string is made up of several sections as follows:

%[(name)][flags][minimum width][.precision][length]type

• name: This allows you to optionally specify the name of the key that is used to take the value from
• flags: This is used to control the type of conversion performed
• minimum width: This is used to pad out the value so that the string is a certain number of characters long
• precision: This is used to specify the precision of the numerical types
• length: This allows you to modify the length of the numerical types
• type: This is the character representing the data type of the parameter

Following is a list of the most common data types:

• s: String
• i: Integer number
• f: Floating point number

String templates

String templates are very similar to string formatting. However, they use customized $ marked substitutions that rely less on the type of the variable being used for the substitution.

Templates are available via the Template class in the string module.

The following is a simple example of how templates can be used to format multiple strings:

from string import Template
hello_template = Template("Hello $name, welcome to Python!")
hello_template.substitue(name="Alice")
hello_template.substitue(name="Marisa")
hello_template.substitue(name="Reimu")

This example gives the following output on the interactive terminal:

It is worth noting that the type of the parameter passed to the substitute function is not really that important as it will be converted to a string in order to be substituted into the template string. The following is an example of this:

from string import Template
t = Template("The number is $number")
t.substitute(number="one")
t.substitute(number=42)
t.substitute(number=100L)
t.substitute(number=4e-3)
t.substitute(number=(3+6j))

In the following screenshot, you will see that the output of each substitution simply gives whatever the standard string representation of each number is:

So far, we have just been using keyword arguments (by passing an argument to the substitute function by name) to provide the substitutions to the template. However, it is also possible to provide a dictionary containing the values (we will be covering dictionaries in more detail in the next chapter), as in the following example:

from string import Template
t = Template("$person_a says $something to $person_b")
info = {"person_a": "Marisa", "something": "hello", "person_b": "Alice"}
t. substitute(info)

This is equivalent to providing the values as parameters to substitute and will provide the following output:

One issue with using substitute to perform the replacement is that an exception is raised if one of the substitution parameters is missing. Depending on the application, this may or may not be the desired behavior, but for cases where the call should not fail, there is the safe_substitute function which will never raise an exception. This is shown with the following example:

from string import Template
t = Template("$person_a says hello to $person_b")
t.substitute(person_a="Mima")
t.safe_substitute(person_a="Mima")

As shown in the following output, the first substitution fails as the person_b parameter is missing. However, when safe_substitute is used instead, the substitution completes but skips replacing the template parameter in the template string with anything.