You've already seen the integer type, int. If you write an ordinary number in your program like 42, called a literal number, Python creates an int object for it:

>>> x = 42
>>> type(x)
<class 'int'>

You didn't have to construct the int explicitly, but you could if you want, like this:

>>> x = int(42)

You can also use the int constructor to convert other types, such as strings or other numerical types, to integers:

>>> x = int("17")
>>> y = int(4.8)
>>> print(x, y, x - y)
17 4 13

In the first line, Python converts a string representing a number to the number itself; you can't do math with "17" (a string), but you can with 17 (an integer). In the second line, Python converted the floating-point value 4.8 to the integer 4 by truncating it—chopping off the part after the decimal point to make it an integer.

When you convert a string to an int, Python assumes the number is represented in base 10. You can specify another base as the second argument. For instance, if you pass 16, the number is assumed to be hexadecimal:

gt;>> hex_number = "a1"
>>> print(int(hex_number, 16))
161

You can specify hexadecimal literals by prefixing the number with 0x. For example, hexadecimal 0xa1 is equivalent to decimal 161. Similarly, literals starting with just a 0 are assumed to be octal (base 8), so octal 0105 is equivalent to decimal 69. These conventions are used in many other programming languages, too.

What's the largest number Python can store in an int? Prior to Python 3.0, Python used at least 32 bits to represent integers, which meant that you could store numbers at least as large as 2³¹−1 and negative numbers as small as −2³¹. If you needed to store a larger number, Python provided the long type, which represented arbitrarily large integers.

For example, long before the search engine Google existed, mathematicians defined a googol, a one followed by 100 zeros. To represent this number in Python, you used to type out the hundred zeros, or you could have saved yourself the trouble by using the exponentiation operator, **:

>>> googol = 10 ** 100
>>> print(googol)
1000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000

The preceding was an example of a long integer. Starting in Python 3.0, the long type no longer exists; instead, int has been extended so that there is no limit to the size of an integer.

In Python, a floating-point number is represented by a float object. A floating-point number is only an approximation to a real number, so you may sometimes see results that look strange. For example:

>>> x = 1.1
>>> x
1.1000000000000001
>>> print(x)
1.1

What's going on here? You assigned to x the floating-point approximation to the number 1.1. The floating-point number that Python can represent that is closest to 1.1 is actually a tiny bit different, and Python is honest with you and shows this number when you ask for the full representation of x. When you print x, however, Python provides you with a "nice" depiction of the number, which doesn't show enough decimal places to illustrate the floating-point approximation.

As with integers, you can use the float constructor to covert strings to numbers (but only in base 10). For example:

>>> x = float("16.4")

Very large and very small floating-point numbers are represented with exponential notation, which separates out the power of ten. A googol as a floating-point number would be 1e+100, which means the number 1 times ten raised to the power 100. The U.S. national debt at the time this was written, according to the Treasury Department website, was:

>>> debt = 11322188570453.51

Python prefers exponential notation to print a number this large:

>>> print(debt)
1.13221885705e+13

You can also enter literals with exponential notation.

You can convert any Python number to a string using the str constructor. This produces the text that would be printed by the print statement, as a string object. For simple applications, this is adequate.

For better control of the output format, use Python's built-in string formatting operator, %.

Following are some details on formatting numbers. If you are familiar with the printf function in C, you already know much of the syntax for formatting numbers in Python.

To format an integer, use the %d conversion in the format string. For a floating-point number, use %f. If you use %d with a floating-point number or %f with an integer, Python will convert the number to the type indicated by the conversion. For example:

>>> print("%d" % 100)
100
>>> print("%d" % 101.6)
101

You probably didn't really notice, because it's so obvious, that Python formatted these integers in base 10. For some applications, you might prefer your output in hexadecimal. Use the %x conversion to produce this. If you use %#x, Python puts 0x before the output to make it look just like a hexadecimal literal value, like so:

>>> print("%#x" % 100)
0x64

Similarly, %o (that's the letter "o," not a zero) produces output in octal, and %#o produces octal output preceded by a 0.

For integers, you can specify the width (number of digits) of the output by placing a number after the % in the format string. If the number starts with 0, the output will be left-padded with zeros; otherwise, it will be padded with spaces. In the examples that follow, the output is surrounded with parentheses so you can see exactly what Python generates for the %d conversions:

>>> print("z is (%6d)" % 175)
z is (   175)
>>> print("z is (%06d)" % 175)
z is (000175)

When you format floating-point numbers, you can specify the total width of the output, and/or the number of digits displayed after the decimal place. If you want the output to have total width w and to display p decimal places, use the conversion %w.pf in the format string. The total width includes the decimal point and digits after the decimal point. Unlike converting a float to an integer value, Python rounds to the nearest digit in last decimal place:

>>> x = 20.0 / 3
>>> print("(%6.2f)" % x)
(  6.67)

If you omit the number before the decimal point, Python uses as much room as necessary to print the integer part and the decimal places you asked for:

>>> print("(%.4f)" % x)
(6.6667)

You can demand as many digits as you want, but remember that a float carries a limited precision and, therefore, contains information for only 16 digits or so. Python will add zero digits to fill out the rest:

>>> two_thirds = 2.0 / 3
>>> print("%.40f" % two_thirds)
0.6666666666666666300000000000000000000000

The number you see may be slightly different, because architectures handle the details of floating-point computations differently.

If you omit the number after the decimal point (or specify zero decimal places), Python doesn't show any decimal places and omits the decimal point, too:

>>> print("(%4.f)" % x)
(   7)

For example, the following function formats the ratio of its arguments, num and den, as a percentage, showing one digit after the decimal point:

>>> def as_percent(num, den):
...     if den == 0:
...         ratio = 0
...     else:
...         ratio = float(num) / den
...     return "%5.1f%%" % (100 * ratio)
...
>>> print("ratio = " + as_percent(6839, 13895))
ratio =  49.2%

One nice thing about this function is that it confirms that the denominator is not zero, to avoid division-by-zero errors. Moreover, look closely at the format string. The first % goes with the f as part of the floating-point conversion. The %% at the end is converted to a single % in the output: Because the percent symbol is used to indicate a conversion, Python requires you to use two of them in a format string if you want one in your output.

You don't have to hard-code the width or number of decimal places in the format string. If you use an asterisk instead of a number in the conversion, Python takes the value from an extra integer argument in the argument tuple (positioned before the number that's being formatted). Using this feature, you can write a function that formats U.S. dollars. Its arguments are an amount of money and the number of digits to use for the dollars part, not including the two digits for cents:

>>> def format_dollars(dollars, places):
...     return "$%*.2f" % (places + 3, dollars)
...
>>> print(format_dollars(499.98, 5))
$  499.98

In the format string, you use * instead of the total width in the floating-point conversion. Python looks at the argument tuple and uses the first value as the total width of the conversion. In this case, you specify three more than the desired number of digits for dollars, to leave room for the decimal point and the two digits for cents.

Even more options are available for controlling the output of numbers with the string formatting operator. Consult the Python documentation for details, under the section on sequence types (because strings are sequences) in the Python Library Reference.

What about characters? C and C++ programmers are used to manipulating characters as numbers, because C's char type is just another integer numeric type. Python doesn't work like this, though. In Python, a character is just a string of length one, and cannot be used as a number.

Occasionally, you might need to convert between characters and their numeric values. Python provides the built-in function ord to convert a single character to its numeric code and the function asc to convert back from a numeric code to a character. The numeric code must be between 0 and 255.

If you are a Usenet regular, you are probably familiar with the rot13 cipher. It's not particularly secure; all it does is rotate letters of the alphabet 13 positions forward, wrapping around from "z" to "a." Using chr and ord functions, it's not hard to implement in Python:

def rot13_character(character):
    # Look up codes for ends of the alphabet.
    a = ord('a')
    z = ord('z')
    A = ord('A')
    Z = ord('Z')

    code = ord(character)
    # Rotate lower-case characters.
    if a <= code <= z:
        code = a + (code - a + 13) % 26
    # Rotate upper-case characters.
    elif A <= code <= Z:
        code = A + (code - A + 13) % 26
    # Leave other characters alone.
    else:
        pass
    return chr(code)

def rot13(plaintext):
    # Loop over letters in the text.
    ciphertext = ""
    for character in plaintext:
        ciphertext += rot13_character(character)
    return ciphertext

The program is composed of two functions. The first, rot13_character, applies rot13 to a single character. If it's an uppercase or lowercase letter, it is rotated 13 places; otherwise, it is left alone. (In case you are not familiar with the remainder operator, %, it is described in the next section.) The main function, rot13, takes the message to be coded (the "plaintext") and creates the encoded message (the "ciphertext") by rotating each letter.

Type the preceding code into a module file named rot13.py. In Python, import the module and try it out:

>>> import rot13
>>> message = rot13.rot13("This is a TOP-SECRET encoded message.")
>>> print(message)
Guvf vf n GBC-FRPERG rapbqrq zrffntr.

rot13 has the nice property that it is its own inverse: To decode a rot13-encoded message, you just apply rot13 to it again:

>>> print(rot13.rot13(message))
This is a TOP-SECRET encoded message.

Python provides the normal arithmetic operators + (addition), - (subtraction), * (multiplication), and / (division) for numerical types. You can mix numerical types when using these operators; Python automatically chooses the more flexible type for the result:

>>> i = 10
>>> f = 6.54
>>> print(i + f)
16.54

When adding an integer, i, and a floating-point number f, Python chose a float for the result.

These operators all have special forms for updating the values of variables, written by adding an equals sign right after the operator. Instead of writing

>>> total = total + 6
>>> coefficient = coefficient / 2

you can simply write:

>>> total += 6
>>> coefficient /= 2

and so forth.

When dividing two integers, Python always uses an integer type for the result, unless the result is fractional, as is the case in the following example:

>>> print 10 / 3
3.33333333333

The exponentiation operator ** is used previously in examples. It, too, works for integer and floating-point values. The function that follows uses it to compute compounded interest. The function returns the amount of money you would have if you put starting_balance in a bank account with APR annual_rate and waited for years:

>>> def compound(starting_balance, annual_rate, years):
...     return starting_balance * ((1 + annual_rate) ** years)
...

Ten grand in the bank at 4 percent APR for a century yields:

>>> print(compound(10000, 0.04, 100))
505049.481843

That's half a million bucks. Start saving now.

Also useful is the remainder operator %. It's like floor division, but instead of returning the quotient, it returns the remainder. Using it, you can format a number of months into whole years and remaining months:

>>> def format_months(months):
...   print("%d years, %d months" % (months // 12, months % 12))
...
>>> format_months(100)
8 years, 4 months

A few very common mathematical functions are available as built-in functions. The simplest is abs, which returns the absolute value of a number. The number that abs returns is the same type as the number you pass it:

>>> print(abs(−6.5))
6.5

Also useful are min and max, which return the smallest or largest of several values. You can call them either with several numeric arguments or with a single argument that is a sequence (such as a list or tuple) of numbers. The values needn't all be the same type:

>>> print(min(6, 7, 2, 8, 5))
2
>>> print(max([0, 43.5, 19, 5, −6]))
43.5

The round function rounds a floating-point value to a specified number of digits. This is similar to the behavior you saw before in the %f conversions, except the result is not a string but rather another floating-point number with which you can perform further computations. Specify the number to round, and the number of decimal places you want to keep:

>>> print(round(1234.56789, 2))
1234.57

You can even specify a negative number of decimal places, which rounds to that multiple of 10:

>>> print(round(1234.56789, −2))
1200.0

Lastly, the sum function adds numbers in a sequence. Together with range, you can compute the sum of the first 100 positive integers:

>>> print(sum(range(1, 101)))
5050

Suppose in your Python programming class you got a 96 percent and 90 percent on the two homework assignments, a perfect score on the final project, and an 88 percent on the final exam. What's your average for the class? Of course, you would write a Python function to compute it. The function uses sum and computes the mean, or average, value of a sequence of numbers:

>>> def mean(numbers):
...     if numbers:
...         return float(sum(numbers)) / len(numbers)
...     else:
...         raise ValueError("no numbers specified")
...
>>> print(mean([96, 90, 100, 88]))
93.5

It's a good idea to make sure that the sequence of numbers isn't empty, to avoid dividing by zero. In this case, the function raises an exception if the sequence is empty.

The math module contains the standard transcendental functions listed here. All these functions take float arguments and return float values:

A few other useful math functions are included:

The math package also contains the constants pi and e.

Here's some sample code that uses the math module. It will give you flashbacks to your freshman physics class. It's a function that computes the time of flight and range of a projectile launched into the air (such as a cannonball), neglecting friction. Examine it at least long enough to understand how the Python code works. Pay attention to how sin, cos, and pi are imported from math, which saves you from having to refer to them as math.sin and so on. It's a handy technique for commonly used functions. Note also how carefully the units used in the arguments and results are documented. Many failed rocket launches attest to the importance of this practice.

from math import sin, cos, pi

def trajectory(velocity, angle):
    """Compute time of flight and range of a projectile.

    For a projectile with initial 'velocity' in meters/sec launched at
    'angle' from horizontal in degrees, returns time of flight in sec
    and range in meters, neglecting friction."""

    # Gravitational acceleration in meters/sec^2.
    g = 9.8
    # Convert 'angle' to radians.
    angle = angle * pi / 180
    # Compute horizontal and vertical components of velocity.
    v_h = velocity * cos(angle)
    v_v = velocity * sin(angle)
    # Compute the time of flight and range.
    tof = 2 * v_v / g
    range = tof * v_h
    return tof, range

Suppose you throw a ball into the air at 40 m/sec (about 90 mph) at a 45° angle. How long will it stay in the air, and how far away will it land? Save the preceding code into a file named ballistic.py, and then call the function like this:

>>> from ballistic import trajectory
>>> tof, range = trajectory(40, 45)
>>> print("time of flight: %.1f sec, range: %.0f meters" % (tof, range))
time of flight: 5.8 sec, range: 163 meters

The Python standard library has just the ticket: a module array for one-dimensional arrays of numbers. The array type in this module stores numbers all together in memory as one object subject to the constraint that all of them must be of the same type. The numerical types supported by array are not the same as Python's numeric types. (In fact, they correspond to the numerical types in the C language.) An array can store numbers equivalent to Python's int and float, as well as integers of other sizes, and floating-point numbers of other precisions. (An array can store long values, but not arbitrarily large ones, and cannot store complex values at all.)

When you create an array, you have to specify the numerical type to store in the array. The type is specified by a single character. To store numbers as Python int objects, use "l"; for float use "d". (Other options are available; see the documentation for the array module for a list of them.) If you don't specify anything else, you'll get an empty array:

>>> import array
>>> a = array.array("l")
>>> print(a)
array('l')

Generally, you can use an array object just as you would an ordinary list. You can insert, append, or delete elements, and the indexing syntax is the same. (Note that in versions of Python earlier than 2.4, an array object is somewhat more limited than a list object.) For example:

>>> a.append(15)
>>> a.extend([20, 17, 0])
>>> print(a)
array('l', [15, 20, 17, 0])
>>> a[1] = 42
>>> print(a)
array('l', [15, 42, 17, 0])
>>> del a[2]
>>> print(a)
array('l', [15, 42, 0])

You can also convert a list or tuple to an array object by passing it to the constructor:

>>> t = (5.6, 3.2, −1.0, 0.7)
>>> a = array.array("d", t)
>>> print(a)
array('d', [5.5999999999999996, 3.2000000000000002, −1.0, 0.69999999999999996])

Here again you see the approximate nature of floating-point values.

In fact, because an array object behaves very much like a list, you can pass it to the same stddev function you wrote previously, and it works just fine:

>>> print(stddev(a))
2.50137462208

If you ever need to convert back to an ordinary tuple or list, just pass the array to the tuple or list constructor:

>>> back_again = tuple(a)
>>> print(back_again)
(5.5999999999999996, 3.2000000000000002, −1.0, 0.69999999999999996)

Compared to lists, array objects have the following advantages and disadvantages: