Integer Data Type in Python

Python integers are the most frequently used numeric type in the language, and they work differently from integers in many other programming languages. In languages like C, Java, or JavaScript, integers have a fixed size, typically 32 or 64 bits, and calculations that exceed that size either wrap around to negative numbers or produce incorrect results silently. Python takes a different approach: integers can grow to any size your computer's memory can support, and you never need to think about overflow or underflow. This design choice makes Python an unusually friendly language for beginners because you can focus on the logic of your program without worrying about numeric boundaries.

If you have read the overview of Python data types and understand how Python variables work, you are ready to explore integers in depth. Integers represent whole numbers without fractional parts, both positive and negative, and they are the default type Python chooses when you write a number without a decimal point.

Creating integers and integer literals

The most common way to create an integer is to write a number directly in your code. Python recognizes decimal integers by default, but it also supports three other literal formats that are useful in different programming domains. A plain number like 42 or -7 creates a decimal integer. For binary numbers, prefix the digits with 0b or 0B, which is useful when working with bit flags, hardware registers, or low-level data formats. Binary 0b1010 equals decimal 10. For octal, use the 0o prefix, which appears less often in modern code but still surfaces in file permissions on Unix systems. For hexadecimal, use the 0x prefix, which is common when working with colors, memory addresses, or binary protocols. Hexadecimal 0xFF equals decimal 255.

Here is how all four formats look in practice, along with the built-in functions that convert an integer back to each string representation:

python

decimal = 255
binary  = 0b11111111     # 255 in binary
octal   = 0o377          # 255 in octal
hex_val = 0xFF           # 255 in hexadecimal
 
print(bin(255))   # 0b11111111
print(oct(255))   # 0o377
print(hex(255))   # 0xff

The int constructor converts other types to integers when the conversion is meaningful. Passing a string of digits returns the corresponding integer, and you can optionally specify a base for strings that use a different representation. Passing a float truncates toward zero, discarding the fractional part rather than rounding. This is a common source of surprise: int(3.9) returns 3, not 4.

Arithmetic with integers

Python supports the standard arithmetic operators you would expect, and they behave intuitively on integers. Addition, subtraction, and multiplication work exactly as they do in ordinary math. Exponentiation uses two asterisks rather than a caret symbol, so 2 raised to the 10th power equals 1024. The modulus operator returns the remainder after division, and it is frequently used to check whether a number is even or odd, to wrap values around a fixed range, or to extract digits from a number.

Division is the one area where Python behaves differently from what beginners sometimes expect. The single slash always returns a float, even when both operands are integers and the division is mathematically exact. Writing 10 divided by 5 returns 2.0, not 2. The double slash performs floor division, which divides and then floors toward negative infinity to produce an integer result. This means 10 floor-divided by 3 returns 3, and -10 floor-divided by 3 returns -4 because floor division always rounds down, never toward zero. The difference between floor division and truncation only matters for negative numbers, but it is worth knowing about before it surprises you.

Integer methods and attributes

Python integers are objects with methods and attributes, though you call them less often than string or list methods. The bit_length method returns the number of bits needed to represent the integer in binary, excluding the sign bit. This is useful when you need to know how much space a number occupies in a binary format or when sizing bit fields in protocols.

The as_integer_ratio method returns a pair of integers whose ratio equals the integer, which is simply the integer itself divided by 1. This method exists on integers for consistency with floats, which use it to express their value as an exact fraction.

Python also has a small-integer caching optimization worth knowing about. The interpreter pre-creates integer objects for values from -5 to 256 because these numbers appear so frequently in loops, indexing, and comparisons. When you assign two variables to the same small number, both variables point to the same cached integer object rather than two separate ones. This is why the is operator returns True for small integers but may return False for larger ones that are not cached. The caching behavior is an implementation detail of CPython and should never be relied on for program logic; always use double-equals for value comparisons.

Working with large integers

Python's unlimited precision integers mean you can calculate factorials, powers, and Fibonacci numbers to thousands of digits without any special library or configuration. The tradeoff is performance: operations on very large integers are slower than operations on small ones because the computer must process more bits. For everyday programming, this tradeoff is invisible because the numbers you work with are well within the range where Python's integer arithmetic is fast enough.

If you need to read or display very large numbers, Python 3 supports underscores in integer literals as visual separators. Writing 1_000_000 instead of 1000000 makes large numbers easier to read at a glance without affecting the value. The underscores can appear between any digits and are purely for human readability. This feature is also available for floats in Python, which the next article in this series covers in detail alongside floating-point precision and the pitfalls of binary representation of decimal values.