Numbers in Python

Integers

An integer is a whole number with no decimal places. For example, 1 is an integer, but 1.0 isn’t. The name for the integer data type is int, which you can see with type():

>>> type(1)
<class 'int'>

You can create an integer by typing the desired number. For instance, the following assigns the integer 25 to the variable num:

>>> num = 25

When you create an integer like this, the value 25 is called an integer literal because the integer is literally typed into the code.

You may already be familiar with how to convert a string containing an integer to a number using int(), which is especially useful when working with user input. For example, the following converts the string "25" to the integer 25:

>>> int("25")
25

int("25") is not an integer literal because the integer value is created from a string.

When you write large numbers by hand, you typically group digits into groups of three separated by a comma or a decimal point. The number 1,000,000 is a lot easier to read than 1000000.

In Python, you can’t use commas to group digits in integer literals, but you can use underscores (_). Both of the following are valid ways to represent the number one million as an integer literal:

>>> 1000000
1000000

>>> 1_000_000
1000000

There’s no limit to how large an integer can be, which might be surprising considering that computers have a finite amount of memory. Try typing the largest number you can think of into IDLE’s interactive window. Python can handle it with no problem!

Floating-Point Numbers

A floating-point number, or float for short, is a number with a decimal place. 1.0 is a floating-point number, as is -2.75. The name of the floating-point data type is float:

>>> type(1.0)
<class 'float'>

Like integers, floats can be created from floating-point literals or by converting a string to a float with float():

>>> float("1.25")
1.25

There are three ways to represent a floating-point literal. Each of the following creates a floating-point literal with a value of one million:

>>> 1000000.0
1000000.0

>>> 1_000_000.0
1000000.0

>>> 1e6
1000000.0

The first two ways are similar to the two techniques for creating integer literals. The third approach uses E notation to create a float literal.

To write a float literal in E notation, type a number followed by the letter e and then another number. Python takes the number to the left of the e and multiplies it by 10 raised to the power of the number after the e. So 1e6 is equivalent to 1×10⁶.

Python also uses E notation to display large floating-point numbers:

>>> 200000000000000000.0
2e+17

The float 200000000000000000.0 gets displayed as 2e+17. The + sign indicates that the exponent 17 is a positive number. You can also use negative numbers as the exponent:

>>> 1e-4
0.0001

The literal 1e-4 is interpreted as 10 raised to the power -4, which is 1/10000, or 0.0001.

Unlike integers, floats do have a maximum size. The maximum floating-point number depends on your system, but something like 2e400 ought to be well beyond most machines’ capabilities. 2e400 is 2×10⁴⁰⁰, which is far more than the total number of atoms in the universe!

When you reach the maximum floating-point number, Python returns a special float value, inf:

>>> 2e400
inf

inf stands for infinity, and it just means that the number you’ve tried to create is beyond the maximum floating-point value allowed on your computer. The type of inf is still float:

>>> n = 2e400
>>> n
inf
>>> type(n)
<class 'float'>

Python also uses -inf, which stands for negative infinity and represents a negative floating-point number that is beyond the minimum floating-point number allowed on your computer:

>>> -2e400
-inf

You probably won’t come across inf and -inf very often as a programmer unless you regularly work with extremely large numbers.

Check Your Understanding

Expand the block below to check your understanding:

You can expand the block below to see a solution:

num1 = 25000000

num2 = 25_000_000

print(num1)
print(num2)

25000000
25000000

When you’re ready, you can move on to the next section.

Addition

Addition is performed with the + operator:

>>> 1 + 2
3

The two numbers on either side of the + operator are called operands. In the above example, both operands are integers, but operands don’t need to be the same type.

You can add an int to a float with no problem:

>>> 1.0 + 2
3.0

Notice that the result of 1.0 + 2 is 3.0, which is a float. Anytime a float is added to a number, the result is another float. Adding two integers together always results in an int.

Subtraction

To subtract two numbers, just put a - operator between them:

>>> 1 - 1
0

>>> 5.0 - 3
2.0

Just like adding two integers, subtracting two integers always results in an int. Whenever one of the operands is a float, the result is also a float.

The - operator is also used to denote negative numbers:

>>> -3
-3

You can subtract a negative number from another number, but as you can see below, this can sometimes look confusing:

>>> 1 - -3
4

>>> 1 --3
4

>>> 1- -3
4

>>> 1--3
4

Of the four examples above, the first is the most PEP 8 compliant. That said, you can surround -3 with parentheses to make it even clearer that the second - is modifying 3:

>>> 1 - (-3)
4

Using parentheses is a good idea because it makes your code more explicit. Computers execute code, but humans read code. Anything you can do to make your code easier to read and understand is a good thing.

Multiplication

To multiply two numbers, use the * operator:

>>> 3 * 3
9

>>> 2 * 8.0
16.0

The type of number you get from multiplication follows the same rules as addition and subtraction. Multiplying two integers results in an int, and multiplying a number with a float results in a float.

Division

The / operator is used to divide two numbers:

>>> 9 / 3
3.0

>>> 5.0 / 2
2.5

Unlike addition, subtraction, and multiplication, division with the / operator always returns a float. If you want to make sure that you get an integer after dividing two numbers, you can use int() to convert the result:

>>> int(9 / 3)
3

Keep in mind that int() discards any fractional part of the number:

>>> int(5.0 / 2)
2

5.0 / 2 returns the floating-point number 2.5, and int(2.5) returns the integer 2 with the .5 removed.

Integer Division

If writing int(5.0 / 2) seems a little long winded to you, Python provides a second division operator called the integer division operator (//), also known as the floor division operator:

>>> 9 // 3
3

>>> 5.0 // 2
2.0

>>> -3 // 2
-2

The // operator first divides the number on the left by the number on the right and then rounds down to an integer. This might not give the value you expect when one of the numbers is negative.

For example, -3 // 2 returns -2. First, -3 is divided by 2 to get -1.5. Then -1.5 is rounded down to -2. On the other hand, 3 // 2 returns 1 because both numbers are positive.

The above example also illustrates that // returns a floating-point number when one of the operands is a float. This is why 9 // 3 returns the integer 3, and 5.0 // 2 returns the float 2.0.

Let’s see what happens when you try to divide a number by 0:

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Python gives you a ZeroDivisionError, letting you know that you just tried to break a fundamental rule of the universe.

Exponents

You can raise a number to a power using the ** operator:

>>> 2 ** 2
4

>>> 2 ** 3
8

>>> 2 ** 4
16

Exponents don’t have to be integers. They can also be floats:

>>> 3 ** 1.5
5.196152422706632

>>> 9 ** 0.5
3.0

Raising a number to the power of 0.5 is the same as taking the square root, but notice that even though the square root of 9 is an integer, Python returns the float 3.0.

For positive operands, the ** operator returns an int if both operands are integers and a float if any one of the operands is a floating-point number.

You can also raise numbers to negative powers:

>>> 2 ** -1
0.5

>>> 2 ** -2
0.25

Raising a number to a negative power is the same as dividing 1 by the number raised to the positive power. So, 2 ** -1 is the same as 1 / (2 ** 1), which is the same as 1 / 2, or 0.5. Similarly, 2 ** -2 is the same as 1 / (2 ** 2), which is the same as 1 / 4, or 0.25.

The Modulus Operator

The % operator, or the modulus, returns the remainder of dividing the left operand by the right operand:

>>> 5 % 3
2

>>> 20 % 7
6

>>> 16 % 8
0

3 divides 5 once with a remainder of 2, so 5 % 3 is 2. Similarly, 7 divides 20 twice with a remainder of 6. In the last example, 16 is divisible by 8, so 16 % 8 is 0. Anytime the number to the left of % is divisible by the number to the right, the result is 0.

One of the most common uses of % is to determine whether one number is divisible by another. For example, a number n is even if and only if n % 2 is 0. What do you think 1 % 0 returns? Let’s try it out:

>>> 1 % 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

This makes sense because 1 % 0 gives the remainder of dividing 1 by 0. But you can’t divide 1 by 0, so Python raises a ZeroDivisionError.

Things get a little tricky when you use the % operator with negative numbers:

>>> 5 % -3
-1

>>> -5 % 3
1

>>> -5 % -3
-2

Although potentially shocking at first glance, these results are the product of a well-defined behavior in Python. To calculate the remainder r of dividing a number x by a number y, Python uses the equation r = x - (y * (x // y)).

For example, to find 5 % -3, Python first finds (5 // -3). Since 5 / -3 is about -1.67, that means 5 // -3 is -2. Now Python multiplies that by -3 to get 6. Finally, Python subtracts 6 from 5 to get -1.

Arithmetic Expressions

You can combine operators to form complex expressions. An expression is a combination of numbers, operators, and parentheses that Python can compute, or evaluate, to return a value.

Here are some examples of arithmetic expressions:

>>> 2*3 - 1
5

>>> 4/2 + 2**3
10.0

>>> -1 + (-3*2 + 4)
-3

The rules for evaluating expressions are the same as in everyday arithmetic. In school, you probably learned these rules under the name order of operations.

The *, /, //, and % operators all have equal precedence, or priority, in an expression, and each of these has a higher precedence than the + and - operators. This is why 2*3 - 1 returns 5 and not 4. 2*3 is evaluated first, because * has higher precedence than the - operator.

You may notice that the expressions in the previous example do not follow the rule for putting a space on either side of all of the operators. PEP 8 says the following about whitespace in complex expressions:

If operators with different priorities are used, consider adding whitespace around the operators with the lowest priority(ies). Use your own judgment; however, never use more than one space, and always have the same amount of whitespace on both sides of a binary operator. (Source)

Another good practice is to use parentheses to indicate the order in which operations should be performed, even if the parentheses aren’t necessary. For instance, (2 * 3) - 1 is potentially clearer than 2*3 - 1.

Round Numbers With round()

You can use round() to round a number to the nearest integer:

>>> round(2.3)
2

>>> round(2.7)
3

round() has some unexpected behavior when the number ends in .5:

>>> round(2.5)
2

>>> round(3.5)
4

2.5 is rounded down to 2, and 3.5 is rounded up to 4. Most people expect a number that ends in .5 to be rounded up, so let’s take a closer look at what’s going on here.

Python 3 rounds numbers according to a strategy called rounding ties to even. A tie is any number whose last digit is five. 2.5 and 3.1415 are ties, but 1.37 is not.

When you round ties to even, you first look at the digit one decimal place to the left of the last digit in the tie. If that digit is even, then you round down. If the digit is odd, then you round up. That’s why 2.5 rounds down to 2 and 3.5 rounds up to 4.

You can round a number to a given number of decimal places by passing a second argument to round():

>>> round(3.14159, 3)
3.142

>>> round(2.71828, 2)
2.72

The number 3.14159 is rounded to three decimal places to get 3.142, and the number 2.71828 is rounded to two decimal places to get 2.72.

The second argument of round() must be an integer. If it isn’t, then Python raises a TypeError:

>>> round(2.65, 1.4)
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    round(2.65, 1.4)
TypeError: 'float' object cannot be interpreted as an integer

Sometimes round() doesn’t get the answer quite right:

>>> # Expected value: 2.68
>>> round(2.675, 2)
2.67

2.675 is a tie because it lies exactly halfway between the numbers 2.67 and 2.68. Since Python rounds ties to the nearest even number, you would expect round(2.675, 2) to return 2.68, but it returns 2.67 instead. This error is the result of a floating-point representation error, not a bug in round().

Dealing with floating-point numbers can be frustrating, but this frustration isn’t specific to Python. All languages that implement the IEEE floating-point standard have the same issues, including C/C++, Java, and JavaScript.

In most cases, though, the little errors encountered with floating-point numbers are negligible, and the results of round() are perfectly useful.

Find the Absolute Value With abs()

The absolute value of a number n is just n if n is positive and -n if n is negative. For example, the absolute value of 3 is 3, while the absolute value of -5 is 5.

To get the absolute value of a number in Python, you use abs():

>>> abs(3)
3

>>> abs(-5.0)
5.0

abs() always returns a positive number of the same type as its argument. That is, the absolute value of an integer is always a positive integer, and the absolute value of a float is always a positive float.

Raise to a Power With pow()

Earlier, you learned how to raise a number to a power using the ** operator. You can also use pow() to achieve the same result.

pow() takes two arguments. The first argument is the base, or the number to be raised to a power, and the second argument is the exponent, or the power to which the number is to be raised.

For example, the following uses pow() to raise 2 to the exponent 3:

>>> pow(2, 3)
8

Just like with **, the exponent in pow() can be negative:

>>> pow(2, -2)
0.25

So, what’s the difference between ** and pow()?

The pow() function accepts an optional third argument that computes the first number raised to the power of the second number, then takes the modulo with respect to the third number. In other words, pow(x, y, z) is equivalent to (x ** y) % z.

Here’s an example in which x = 2, y = 3, and z = 2:

>>> pow(2, 3, 2)
0

First, 2 is raised to the power 3 to get 8. Then 8 % 2 is calculated, which is 0 because 2 divides 8 with no remainder.

Check if a Float Is Integral

You may be familiar with string methods like .lower(), .upper(), and .find(). Integers and floating-point numbers also have methods.

Number methods aren’t used very often, but there is one that can be useful. Floating-point numbers have an .is_integer() method that returns True if the number is integral—meaning it has no fractional part—and otherwise returns False:

>>> num = 2.5
>>> num.is_integer()
False

>>> num = 2.0
>>> num.is_integer()
True

One use for .is_integer() is for validating user input. For example, if you were writing an online ordering app for a pizzeria, then you would want to check that the quantity of pizzas the customer inputs is a whole number.

The round(), abs(), and pow() functions are built-in functions, meaning you don’t have to import anything in order to use them. But these three functions barely scratch the surface of all of the functions available for working with numbers in Python.

For even more math fun, check out The Python math Module: Everything You Need to Know!

Check Your Understanding

Expand the block below to check your understanding:

Enter a number: 5.432
5.432 rounded to 2 decimal places is 5.43

You can expand the block below to see a solution:

user_input = input("Enter a number: ")

num = float(user_input)

rounded_num = round(num, 2)

print(f"{num} rounded to 2 decimal places is {rounded_num}")

When you’re ready, you can move on to the next section.