Number Conversion

Numbers are the fundamental building blocks of programming. Whether you’re displaying scores in a game, calculating values in a finance app, or manipulating raw data, understanding how to convert numbers between different formats is vital. In Python, number conversion allows you to switch between the familiar decimal system and other bases like binary, octal, and hexadecimal. These conversions are not only academically interesting but essential for working with low-level data, debugging, and understanding how computers represent information.

In this lesson, we’ll explore how to convert numbers between various bases using Python. You’ll learn how to:

• Convert decimal numbers to binary, octal, and hexadecimal formats.
• Convert strings representing numbers in other bases back to integers.
• Understand the built-in Python functions that simplify number conversion.

By the end of this lesson, you’ll be confident in handling number conversions in your programs, empowering you to work effectively with different numeric representations.

The Basics: Number Systems You Should Know

Before diving into Python code, let’s quickly recap the common number systems:

• Decimal (Base 10): The number system we use daily, digits 0-9.
• Binary (Base 2): Uses only digits 0 and 1. Computers use binary internally.
• Octal (Base 8): Uses digits 0-7. Less common, but sometimes used in computing.
• Hexadecimal (Base 16): Uses digits 0-9 and letters A-F (or a-f). Common in programming for compact binary representation.

Converting Decimal to Other Number Systems

Python provides simple built-in functions to convert decimal integers to binary, octal, and hexadecimal strings.

• bin(): Converts an integer to a binary string prefixed with 0b.
• oct(): Converts an integer to an octal string prefixed with 0o.
• hex(): Converts an integer to a hexadecimal string prefixed with 0x.

number = 255

binary_repr = bin(number)
octal_repr = oct(number)
hex_repr = hex(number)

print(f"Decimal: {number}")
print(f"Binary: {binary_repr}")   # Output: 0b11111111
print(f"Octal: {octal_repr}")     # Output: 0o377
print(f"Hexadecimal: {hex_repr}") # Output: 0xff

Notice that the output strings include prefixes (0b, 0o, 0x) that indicate the base. This is useful when reading output, but sometimes you may want just the digits, which we’ll cover shortly.

Converting Strings in Other Bases Back to Integers

Often you receive numbers as strings representing binary, octal, or hexadecimal values. To perform calculations, you need to convert them back into integers. Python’s int() function is very flexible and can accept a second argument specifying the base of the input string.

binary_str = "11111111"
octal_str = "377"
hex_str = "ff"

# Convert back to decimal integers
decimal_from_bin = int(binary_str, 2)
decimal_from_oct = int(octal_str, 8)
decimal_from_hex = int(hex_str, 16)

print(f"Binary '{binary_str}' to decimal: {decimal_from_bin}")
print(f"Octal '{octal_str}' to decimal: {decimal_from_oct}")
print(f"Hex '{hex_str}' to decimal: {decimal_from_hex}")

The int() function’s base parameter accepts values between 2 and 36, allowing conversions from many number systems.

int('0xff', 0)  # returns 255

Removing Prefixes When Converting Back to Strings

Sometimes, you want to convert numbers to binary, octal, or hex without the prefixes (0b, 0o, 0x). This is especially useful for formatting output or embedding numbers in strings.

Python strings have formatting options to remove those prefixes:

• Use string slicing to remove first two characters (the prefix).
• Or use the format() function with format specifiers 'b', 'o', and 'x'.

number = 255

# Using slicing to remove prefixes
binary_str = bin(number)[2:]
octal_str = oct(number)[2:]
hex_str = hex(number)[2:]

print(f"Binary without prefix: {binary_str}")
print(f"Octal without prefix: {octal_str}")
print(f"Hex without prefix: {hex_str}")

# Using format()
binary_fmt = format(number, 'b')
octal_fmt = format(number, 'o')
hex_fmt = format(number, 'x')

print(f"Binary (format): {binary_fmt}")
print(f"Octal (format): {octal_fmt}")
print(f"Hex (format): {hex_fmt}")

Using format() is often preferred because it is clearer and avoids potential errors if the prefix length changes in the future.

Working With Uppercase Hexadecimal

By default, hexadecimal digits from format() and hex() are lowercase. Sometimes you might want uppercase letters (A-F). You can achieve this easily:

• Use the format specifier 'X' instead of 'x'.
• Or use the string method .upper() on the output.

number = 255

hex_upper_1 = format(number, 'X')
hex_upper_2 = hex(number)[2:].upper()

print(f"Uppercase hex (format): {hex_upper_1}")
print(f"Uppercase hex (upper method): {hex_upper_2}")

Summary of Python Number Conversion Functions

Practical Example: Parsing User Input in Different Bases

Imagine you are building a calculator that accepts numbers in various formats. You want to allow the user to enter binary, octal, decimal, or hexadecimal numbers, and then convert them all to a decimal integer for calculation.

Here’s a simple approach:

def parse_number(user_input):
    user_input = user_input.strip().lower()
    
    if user_input.startswith('0b'):
        return int(user_input, 2)
    elif user_input.startswith('0o'):
        return int(user_input, 8)
    elif user_input.startswith('0x'):
        return int(user_input, 16)
    else:
        # Assume decimal if no prefix
        return int(user_input, 10)

# Examples:
print(parse_number("0b1010"))  # binary 10 decimal
print(parse_number("0o12"))    # octal 10 decimal
print(parse_number("10"))      # decimal 10 decimal
print(parse_number("0xA"))     # hex 10 decimal

This function lets your program be flexible and user-friendly by accepting multiple numeric formats.

Advanced: Using int() with Base 0

Python’s int() function can automatically detect the base if you pass 0 as the second argument. This means you can parse strings with prefixes without specifying the exact base manually.

print(int("0b1010", 0))  # 10 decimal
print(int("0o12", 0))    # 10 decimal
print(int("10", 0))      # 10 decimal (no prefix, decimal)
print(int("0xA", 0))     # 10 decimal

This can simplify your parsing logic significantly.

Summary and Best Practices

Number conversion in Python is straightforward thanks to built-in functions and flexible parsing options. Here are some best practices to keep in mind:

• Use bin(), oct(), and hex() for quick conversions from integers to strings with prefixes.
• Use format() for cleaner strings without prefixes or for formatting output.
• Use int(string, base) to convert strings in any base back to integers.
• Use base 0 in int() to auto-detect the base from prefixes when parsing mixed input.
• Always validate or handle exceptions when converting user input to avoid runtime errors.