Integers, floats and arithmetic operators

Python has two number types for everyday work. An int is a whole number such as 42, -7 or 0, and it can be as large as your computer’s memory allows. A float is a number with a fractional part, such as 3.5 or 0.25, stored in binary with 53 bits of precision, which is roughly 16 significant decimal digits. (A third type, complex, for numbers such as 3+4j, is for maths and engineering; the later lesson on the math module comes back to it.) This lesson covers the operators that do arithmetic with both, and the few places where they behave differently from a pocket calculator.

Writing numbers

print(1_000_000)  # underscores make long numbers easier to read
print(0b1010, 0o17, 0xFF)  # binary, octal and hexadecimal literals
print(2e3, 1.5e-3)  # e notation always gives a float
print(type(2e3), type(2_000))

1000000
10 15 255
2000.0 0.0015
<class 'float'> <class 'int'>

• Underscores between digits are ignored, so 1_000_000 is easier to read than 1000000 and means the same (PEP 515, Python 3.6). Only single underscores between digits are allowed: 1__000 and 1000_ are syntax errors.
• 0b, 0o and 0x start binary, octal and hexadecimal numbers. A later lesson on number bases covers them.
• A decimal point or an e makes a float. 2e3 means 2 × 10³, and it is the float 2000.0, not the int 2000.
• A whole number other than zero cannot start with 0: 017 is a SyntaxError, and the message suggests the 0o prefix in case you meant octal. Phone numbers, PIN codes and other identifiers with leading zeros are text, not numbers; keep them as strings.

The arithmetic operators

• +, - and * add, subtract and multiply: 17 * 5 gives 85.
• / divides, and the result is always a float: 17 / 5 gives 3.4.
• // divides and then rounds down to a whole number (floor division): 17 // 5 gives 3.
• % gives the remainder that floor division leaves (modulo): 17 % 5 gives 2.
• ** raises to a power: 17 ** 2 gives 289.

a, b = 17, 5
print(a + b, a - b, a * b)
print(a / b)  # true division: always a float
print(a // b)  # floor division
print(a % b)  # the remainder
print(a ** 2)  # a power

print(10 / 2)  # a float, even when the division is exact
print(3 * 1.5, 2 + 0.0)  # an int and a float give a float
print(2 ** 0.5, 2 ** -1)  # fractional and negative powers give floats
print(2 ^ 3)  # careful: ^ is not a power in Python

22 12 85
3.4
3
2
289
5.0
4.5 2.0
1.4142135623730951 0.5
1

Three rules explain every result above:

1. / always gives a float, even when the division comes out exact: 10 / 2 is 5.0. Use // when you need a whole number.
2. An int and a float give a float. Python converts the int first, so 3 * 1.5 is 4.5 and 2 + 0.0 is 2.0. Two ints give an int with +, -, *, //, % and **, except that a negative power gives a float: 2 ** -1 is 0.5.
3. ** is the power operator. ^ also exists, but it is the bitwise “exclusive or” of the two numbers’ bits, so 2 ^ 3 is 1, not 8. Spreadsheet formulas write powers with ^, which makes this an easy mistake.

A common mistake: / where a whole number is needed

A list position must be an int. A float from / is not one, even when it happens to be 2.0:

names = ["Asha", "Ben", "Chen", "Dev", "Esi"]
middle = len(names) / 2
print(middle)
print(names[middle])

2.5

Traceback (most recent call last):
  File "middle_item.py", line 4, in <module>
    print(names[middle])
          ~~~~~^^^^^^^^
TypeError: list indices must be integers or slices, not float

len(names) // 2 gives 2, and names[2] is "Chen". When the length is even, // picks the second of the two middle positions; decide whether that is what you want.

Floor division and the remainder with negative numbers

a // b does the division and then rounds down, towards minus infinity. For positive numbers that simply drops the fraction, but for a negative result it is one less than you might expect: -7 / 2 is -3.5, so -7 // 2 is -4. Many languages, Java among them, round integer division towards zero instead and would give -3.

a % b is whatever floor division leaves over, so the two are tied together by one rule that always holds for ints: a == b * (a // b) + a % b. A consequence is that the remainder has the same sign as b, the number you divide by, or is 0:

print(" a   b  a // b  a % b  check")
for a in (7, -7):
    for b in (2, -2):
        check = b * (a // b) + a % b  # always gives a back
        print(f"{a:2}  {b:2}  {a // b:6}  {a % b:5}  {check:5}")

print(divmod(-7, 2))  # both results at once: (a // b, a % b)

 a   b  a // b  a % b  check
 7   2       3      1      7
 7  -2      -4     -1      7
-7   2      -4      1     -7
-7  -2       3     -1     -7
(-4, 1)

Read the rows as predictions you can check. The check column works out b * (a // b) + a % b, and it gives back a every time. divmod(a, b) returns both results at once, as the pair (a // b, a % b).

Why rounding down is useful

With a positive divisor, % never returns a negative number, so it is ideal for anything that wraps around, such as days of the week. And divmod(), which gives the quotient and the remainder together, is the natural tool for splitting an amount into units:

days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
today = 0  # Monday
print("In 10 days:", days[(today + 10) % 7])
print("3 days ago:", days[(today - 3) % 7])  # -3 % 7 is 4, never negative

total = 7384  # seconds
minutes, seconds = divmod(total, 60)
hours, minutes = divmod(minutes, 60)
print(hours, "h", minutes, "min", seconds, "s")

In 10 days: Thu
3 days ago: Fri
2 h 3 min 4 s

Three days before Monday (position 0) is position -3 % 7, which is 4, Friday, with no special case for going back past the start of the week. Python’s programming FAQ gives the same reason for the design: when the divisor is positive, a remainder that is never negative is almost always the one you want.

amount = 1_00_000  # one lakh, grouped the Indian way
print(amount)
print(f"{amount:,}")  # the , option groups digits in threes

rupees, paise = divmod(12_345, 100)  # 12,345 paise
print(rupees, "rupees and", paise, "paise")

100000
100,000
123 rupees and 45 paise

Integers have no size limit

In many languages an integer has a fixed size, such as 64 bits, and a calculation that goes past the limit overflows. Python’s ints grow as needed, so adding, subtracting, multiplying, floor-dividing and raising them to powers that are not negative is always exact:

import sys

print(2 ** 100)
print(len(str(2 ** 1000)), "digits in 2 ** 1000")
print(sys.maxsize)  # the largest size a list or a string can have, not the largest int
print(sys.maxsize + 1)  # no overflow: an int simply grows

1267650600228229401496703205376
302 digits in 2 ** 1000
9223372036854775807
9223372036854775808

sys.maxsize is not the largest int. It is the largest value of Py_ssize_t, the C type CPython uses for the size of a list or a string and for positions in it (PEP 353), and adding 1 to it works like any other addition.

1267650600228229401496703205376
302 digits in 2 ** 1000
2147483647
2147483648

The digit limit for converting to text

Python lets you compute with ints of any size, but turning one into decimal digits, with str(), print() or an f-string, or reading digits with int(), takes time that grows faster than the number of digits. A program that accepts a number from a user could be stalled by one with millions of digits, so CPython refuses conversions of more than 4,300 decimal digits by default:

import sys

big = 10 ** 5000  # computing with a huge int is fine
print(big.bit_length(), "bits")

try:  # try and except catch the error so that the program can go on
    text = str(big)  # turning it into decimal text is limited
except ValueError as error:
    print("ValueError:", error)

print(len(hex(big)), "characters in hexadecimal")  # no limit for hex
sys.set_int_max_str_digits(6000)  # raise the limit, for this program only
print(len(str(big)), "decimal digits")

16610 bits
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
4155 characters in hexadecimal
5001 decimal digits

The try and except lines (the module on errors explains them) catch the ValueError so that the program can go on. Hexadecimal and binary conversions are not limited, and sys.set_int_max_str_digits() raises the limit for the rest of the program, as the last two lines show; 0 would remove it. Raise it only in programs that never convert numbers that come from outside, such as a web form or an uploaded file.

Rounding

print(round(2.5), round(3.5), round(-2.5))  # a tie goes to the even neighbour
print(round(2.567, 2), round(1234, -2))  # to 2 decimal places; to the nearest hundred
print(int(3.99), int(-3.99))  # int() drops the fraction
print(-7 // 2, int(-7 / 2))  # floor division and dropping the fraction differ

2 4 -2
2.57 1200
3 -3
-4 -3

• round(x) returns the nearest int, and a tie goes to the even neighbour: round(2.5) is 2, round(3.5) is 4 and round(-2.5) is -2. Over many values, about half of the ties go up and half go down, so a total of rounded numbers does not drift upwards the way it does when every .5 is rounded up.
• round(x, n) rounds to n decimal places, and a negative n rounds to tens, hundreds and so on: round(1234, -2) is 1200.
• int(x) drops the fractional part, so it rounds towards zero: int(-3.99) is -3. Compare -7 // 2, which is -4, with int(-7 / 2), which is -3.

Rounding a float to a number of decimal places, as in round(2.675, 2), holds one more surprise, which the next lesson explains.

Key takeaways

• int holds whole numbers of any size; float holds fractions in binary, with roughly 16 significant digits.
• / always returns a float; // rounds down to a whole number and % gives the remainder; ** is the power operator, and ^ is not.
• Floor division rounds towards minus infinity, so -7 // 2 == -4, and for ints a == b * (a // b) + a % b always holds; the remainder takes the sign of the divisor.
• Mixing an int and a float gives a float; a list position must be an int.
• CPython refuses int and string conversions longer than 4,300 decimal digits unless you raise the limit.
• round() sends ties to the even neighbour, and int() rounds towards zero.