How to Convert Int to Binary in Python: 6 Methods Compared

Overview: Binary Representation in Python

Binary is a base-2 number system using only digits 0 and 1. Understanding how to convert between decimal (base-10) and binary is essential for:

• Low-level programming: Bitwise operations, flags, and hardware interaction
• Computer science fundamentals: Understanding how computers store data
• Algorithms: Bit manipulation problems and optimization
• Networking: IP addresses, subnets, and bit flags
• Cryptography: Binary operations are core to encryption

How Binary Works

Each position in binary represents a power of 2:

# Example: Convert decimal 5 to binary
# Position:  2^2  2^1  2^0    (powers of 2)
# Binary:     1    0    1
# Decimal:    4 +  0 +  1  = 5

# So decimal 5 = binary 101

# Another example: decimal 42
# Powers:  2^5  2^4  2^3  2^2  2^1  2^0
# Binary:   1    0    1    0    1    0
# Decimal: 32 +  0 +  8 +  0 +  2 +  0 = 42

# So decimal 42 = binary 101010

Why Convert to Binary?

Understanding binary is crucial for modern programming. Here are real-world use cases:

Method 1: bin() Function (Simplest & Most Readable)

The bin() function is Python’s built-in, easiest way to convert an integer to binary.

Syntax

binary_string = bin(integer)  # Returns string with '0b' prefix

Basic Examples

# Positive integers
print(bin(5))       # Output: '0b101'
print(bin(42))      # Output: '0b101010'
print(bin(255))     # Output: '0b11111111'

# Negative integers (two's complement)
print(bin(-5))      # Output: '-0b101'
print(bin(-42))     # Output: '-0b101010'

# Zero
print(bin(0))       # Output: '0b0'

# Large numbers
print(bin(1000000)) # Output: '0b11110100001001000000'

Removing the ‘0b’ Prefix

The '0b' prefix indicates binary, but you can remove it:

# Method 1: String slicing
binary = bin(42)[2:]
print(binary)       # Output: '101010'

# Method 2: replace() method
binary = bin(42).replace('0b', '')
print(binary)       # Output: '101010'

# Method 3: lstrip() method
binary = bin(42).lstrip('0b')
print(binary)       # Output: '101010'

Handling Negative Numbers

# bin() shows negative sign, not two's complement
num = -42
binary = bin(num)
print(binary)       # Output: '-0b101010'

# Get absolute value first if you want positive binary
binary = bin(abs(num))[2:]
print(binary)       # Output: '101010'

# For two's complement representation (8-bit example)
def two_complement_8bit(num):
    return bin(num & 0xFF)[2:].zfill(8)

print(two_complement_8bit(-42))  # Output: '11010110'

Advantages of bin()

• ✅ Simplest, most readable
• ✅ Built-in, no imports needed
• ✅ Works with any integer size
• ✅ Perfect for quick conversions
• ❌ Always includes ‘0b’ prefix (must remove if not wanted)
• ❌ Can’t control width/padding

Method 2: format() Function (Most Versatile)

The format() function provides more control over output formatting.

Syntax

# Basic: remove '0b' prefix
binary = format(integer, 'b')

# With padding: fixed-width binary with leading zeros
binary = format(integer, '08b')  # 8-bit binary with leading zeros

Basic Examples

# Simple binary (no prefix)
print(format(5, 'b'))       # Output: '101'
print(format(42, 'b'))      # Output: '101010'
print(format(255, 'b'))     # Output: '11111111'

# With fixed width (padded with zeros)
print(format(5, '08b'))     # Output: '00000101' (8-bit)
print(format(42, '16b'))    # Output: '0000000000101010' (16-bit)
print(format(255, '32b'))   # Output: '00000000000000000000000011111111' (32-bit)

Advanced Formatting

# Right-aligned (default)
print(format(42, '08b'))    # Output: '00101010'

# With separators (Python 3.6+)
print(format(255, '08b'))   # Output: '11111111'

# Dynamic width
num = 42
width = 8
print(format(num, f'0{width}b'))  # Output: '00101010'

# Group by 4 bits (nibble boundaries)
def format_binary_groups(num, width=16):
    binary = format(num, f'0{width}b')
    return ' '.join([binary[i:i+4] for i in range(0, len(binary), 4)])

print(format_binary_groups(255, 16))  # Output: '0000 0000 1111 1111'
print(format_binary_groups(65535, 16))  # Output: '1111 1111 1111 1111'

Handling Negative Numbers

# format() shows negative sign like bin()
print(format(-42, 'b'))     # Output: '-101010'

# For two's complement (with specified bit width)
def to_twos_complement(num, bits):
    if num >= 0:
        return format(num, f'0{bits}b')
    else:
        # Convert negative to two's complement
        return format((1 << bits) + num, f'0{bits}b')

print(to_twos_complement(42, 8))    # Output: '00101010'
print(to_twos_complement(-42, 8))   # Output: '11010110'
print(to_twos_complement(255, 16))  # Output: '0000000011111111'
print(to_twos_complement(-255, 16)) # Output: '1111111100000001'

Advantages of format()

• ✅ No '0b' prefix automatically
• ✅ Built-in padding with leading zeros
• ✅ Flexible width specification
• ✅ Works with any integer size
• ✅ Professional formatting options
• ❌ Slightly more complex syntax

Method 3: F-Strings (Modern Python 3.6+)

F-strings provide clean, readable formatting syntax (recommended for Python 3.6+).

Syntax

binary = f'{integer:b}'       # Simple binary
binary = f'{integer:08b}'    # 8-bit with padding

Examples

# Simple binary (no prefix)
num = 42
print(f'{num:b}')           # Output: '101010'
print(f'{255:b}')           # Output: '11111111'

# With fixed width
print(f'{5:08b}')           # Output: '00000101'
print(f'{42:16b}')          # Output: '0000000000101010'
print(f'{255:032b}')        # Output: '00000000000000000000000011111111'

# Dynamic width
width = 8
print(f'{42:{width}b}')     # Output: '  101010' (note: left-padded with spaces)
print(f'{42:0{width}b}')    # Output: '00101010' (zero-padded)

Complex F-String Examples

# Display multiple representations
num = 255
print(f'Decimal: {num}, Hex: {num:02x}, Binary: {num:08b}')
# Output: Decimal: 255, Hex: ff, Binary: 11111111

# With annotations
temperatures = [15, 20, 25]
for temp in temperatures:
    print(f'Temperature: {temp}°C, Binary: {temp:08b}')
# Output:
# Temperature: 15°C, Binary: 00001111
# Temperature: 20°C, Binary: 00010100
# Temperature: 25°C, Binary: 00011001

# In conditional statements
num = 42
if int(f'{num:b}'[0]) == 1:
    print("Most significant bit is 1")

Advantages of F-Strings

• ✅ Modern Python syntax (3.6+)
• ✅ Most readable for humans
• ✅ Fast performance
• ✅ No '0b' prefix automatically
• ✅ Flexible formatting
• ❌ Requires Python 3.6 or newer

Method 4: Bitwise Operations (Manual Control)

Manually construct binary using bitwise operations for deep understanding.

Bitwise Operators Reference

Manual Binary Construction

# Extract individual bits using right shift and AND
def get_binary_using_bitwise(num, bits=8):
    """Extract binary using bitwise operations."""
    binary = ''
    for i in range(bits - 1, -1, -1):
        # Check if bit at position i is set
        bit = (num >> i) & 1
        binary += str(bit)
    return binary

print(get_binary_using_bitwise(42, 8))   # Output: '00101010'
print(get_binary_using_bitwise(255, 8))  # Output: '11111111'
print(get_binary_using_bitwise(5, 8))    # Output: '00000101'

Building Binary String Digit by Digit

# Method 1: Division method (most intuitive)
def decimal_to_binary_division(num):
    """Convert decimal to binary using division by 2."""
    if num == 0:
        return '0'
    
    binary = ''
    while num > 0:
        binary = str(num % 2) + binary  # Prepend remainder
        num //= 2
    return binary

print(decimal_to_binary_division(42))    # Output: '101010'
print(decimal_to_binary_division(255))   # Output: '11111111'
print(decimal_to_binary_division(0))     # Output: '0'

Advantages of Bitwise Operations

• ✅ Educational - understand how conversion works
• ✅ Maximum control over each bit
• ✅ Useful for bit manipulation problems
• ❌ Slower than built-in functions
• ❌ More code to write
• ❌ Harder to read for non-specialists

Method 5: Recursive Algorithm

Elegant recursive approach for educational purposes.

# Recursive binary conversion
def binary_recursive(num):
    """Convert to binary recursively."""
    if num == 0:
        return '0'
    elif num == 1:
        return '1'
    else:
        return binary_recursive(num // 2) + str(num % 2)

print(binary_recursive(42))     # Output: '101010'
print(binary_recursive(255))    # Output: '11111111'
print(binary_recursive(7))      # Output: '111'

# With padding
def binary_recursive_padded(num, bits=8):
    """Recursive with zero padding."""
    return binary_recursive(num).zfill(bits)

print(binary_recursive_padded(42, 8))   # Output: '00101010'
print(binary_recursive_padded(5, 16))   # Output: '0000000000000101'

How It Works

# Trace example: binary_recursive(5)
# Call stack:
# binary_recursive(5)
#   → binary_recursive(2) + '1'
#     → binary_recursive(1) + '0'
#       → '1' (base case)
#     → '1' + '0' = '10'
#   → '10' + '1' = '101'
# Result: '101'

Advantages of Recursion

• ✅ Elegant and concise
• ✅ Educational value
• ❌ Slower than iteration
• ❌ Risk of stack overflow for very large numbers
• ❌ Not practical for production use

Method 6: NumPy (Large Arrays)

For converting many integers at once, NumPy is efficient.

import numpy as np

# Convert single integer to binary string
num = np.uint8(42)
binary = bin(num)[2:].zfill(8)
print(binary)  # Output: '00101010'

# Convert array of integers to binary
numbers = np.array([5, 42, 255, 0], dtype=np.uint8)
binary_array = np.array([bin(n)[2:].zfill(8) for n in numbers])
print(binary_array)
# Output: ['00000101' '00101010' '11111111' '00000000']

# More efficient: use format for multiple values
numbers = [5, 42, 255, 1000]
binary_list = [format(n, '016b') for n in numbers]
print(binary_list)
# Output: ['0000000000000101', '0000000000101010', '0000000011111111', '0000001111101000']

# Using NumPy's unpackbits (for bit array operations)
data = np.array([42], dtype=np.uint8)
bits = np.unpackbits(data)
print(bits)  # Output: [0 0 1 0 1 0 1 0]
print(''.join(bits.astype(str)))  # Output: '00101010'

Performance with Large Arrays

import numpy as np
import time

# Generate 1 million random integers
numbers = np.random.randint(0, 256, 1000000, dtype=np.uint8)

# Method 1: List comprehension with format
start = time.time()
binary_list = [format(n, '08b') for n in numbers]
time1 = time.time() - start

# Method 2: NumPy vectorized
start = time.time()
binary_array = np.array([format(n, '08b') for n in numbers])
time2 = time.time() - start

print(f"List comprehension: {time1:.4f}s")
print(f"NumPy approach: {time2:.4f}s")

Advantages of NumPy

• ✅ Fast for converting many numbers
• ✅ Efficient bit array operations
• ✅ unpackbits for per-bit access
• ❌ Requires NumPy installation
• ❌ Overkill for single conversions

Performance Comparison & Benchmarks

Benchmark Setup

import timeit

# Compare methods for single conversion
setup = "num = 42"

methods = {
    "bin()":                "bin(num)[2:]",
    "format()":             "format(num, 'b')",
    "f-string":             "f'{num:b}'",
    "bitwise loop":         "bin(num)[2:]",  # Simplified
    "recursive":            "binary_recursive(num)",
}

for name, code in methods.items():
    time = timeit.timeit(code, setup=setup, number=100000)
    print(f"{name:20} {time:.4f}s")

Benchmark Results

Key Insights

• ✅ Use f-strings for best performance (Python 3.6+)
• ✅ Use format() when you need padding control
• ✅ Use bin() for simplicity and compatibility
• ❌ Avoid bitwise loops unless for educational purposes
• ❌ Avoid recursion for production code

Real-World Examples

Example 1: File Permissions

# Unix file permissions (rwxrwxrwx)
def show_file_permissions(octal_value):
    """Display file permissions from octal value."""
    # 755 = 7 (owner), 5 (group), 5 (others)
    owner = (octal_value >> 6) & 7
    group = (octal_value >> 3) & 7
    others = octal_value & 7
    
    def bin_to_permissions(bits):
        r = 'r' if bits & 4 else '-'
        w = 'w' if bits & 2 else '-'
        x = 'x' if bits & 1 else '-'
        return r + w + x
    
    return f'{bin_to_permissions(owner)}{bin_to_permissions(group)}{bin_to_permissions(others)}'

print(show_file_permissions(0o755))  # Output: 'rwxr-xr-x'
print(show_file_permissions(0o644))  # Output: 'rw-r--r--'
print(show_file_permissions(0o700))  # Output: 'rwx------'

Example 2: Network Subnetting

# Convert IP address to binary for subnetting
def ip_to_binary(ip_string):
    """Convert IP address to binary representation."""
    parts = ip_string.split('.')
    binary = ''
    for part in parts:
        binary += format(int(part), '08b')
    return binary

def show_ip_binary(ip_string):
    """Display IP address in binary with dots."""
    binary = ip_to_binary(ip_string)
    octets = [binary[i:i+8] for i in range(0, 32, 8)]
    return '.'.join(octets)

print(show_ip_binary('192.168.1.1'))    # Output: '11000000.10101000.00000001.00000001'
print(show_ip_binary('10.0.0.1'))       # Output: '00001010.00000000.00000000.00000001'
print(show_ip_binary('255.255.255.0'))  # Output: '11111111.11111111.11111111.00000000'

Example 3: Bit Flags (Permissions System)

# Using bits to represent features/permissions
class User:
    READ = 1      # 2^0 = 1
    WRITE = 2     # 2^1 = 2
    DELETE = 4    # 2^2 = 4
    ADMIN = 8     # 2^3 = 8
    
    def __init__(self, name, permissions=0):
        self.name = name
        self.permissions = permissions
    
    def grant(self, permission):
        self.permissions |= permission
    
    def revoke(self, permission):
        self.permissions &= ~permission
    
    def has_permission(self, permission):
        return (self.permissions & permission) != 0
    
    def show_permissions(self):
        perms = []
        if self.has_permission(self.READ): perms.append('READ')
        if self.has_permission(self.WRITE): perms.append('WRITE')
        if self.has_permission(self.DELETE): perms.append('DELETE')
        if self.has_permission(self.ADMIN): perms.append('ADMIN')
        return perms

# Usage
user = User('Alice')
user.grant(User.READ | User.WRITE)  # Grant READ and WRITE

print(f"Permissions: {user.show_permissions()}")
print(f"Binary: {format(user.permissions, '04b')}")

user.grant(User.DELETE)
print(f"After DELETE: {user.show_permissions()}")
print(f"Binary: {format(user.permissions, '04b')}")

Example 4: Binary Search (LeetCode Style)

# Problem: Find single number appearing once
# (all others appear twice)
def find_single_number(nums):
    """Find number appearing once using XOR."""
    result = 0
    for num in nums:
        result ^= num  # XOR cancels out duplicates
    return result

# Example
numbers = [1, 1, 2, 2, 3, 3, 4, 5, 5]
single = find_single_number(numbers)
print(f"Single number: {single}")
print(f"Binary: {format(single, '08b')}")

# Trace: 
# 1 ^ 1 = 0
# 0 ^ 2 = 2
# 2 ^ 2 = 0
# 0 ^ 3 = 3
# 3 ^ 3 = 0
# 0 ^ 4 = 4
# 4 ^ 5 = 1
# 1 ^ 5 = 4
# Result: 4

Best Practices & Common Mistakes

Best Practice 1: Choose the Right Method

# ✅ GOOD: Use format() with padding
def get_byte_value(num):
    return format(num, '08b')

print(get_byte_value(42))  # '00101010'

# ❌ AVOID: Manual padding with zeros
def get_byte_value_bad(num):
    return ('0' * 8 + bin(num)[2:])[-8:]  # Confusing!

Best Practice 2: Handle Edge Cases

# ✅ GOOD: Handle zero and negative numbers
def safe_to_binary(num, bits=8):
    if num < 0:
        raise ValueError("Only non-negative integers supported")
    if num >= (1 << bits):
        raise ValueError(f"Number too large for {bits} bits")
    return format(num, f'0{bits}b')

print(safe_to_binary(42, 8))     # '00101010'
print(safe_to_binary(0, 8))      # '00000000'
try:
    print(safe_to_binary(-1, 8))
except ValueError as e:
    print(f"Error: {e}")

Best Practice 3: Document Expected Output

# ✅ GOOD: Clear documentation
def convert_to_binary(num: int, width: int = 8) -> str:
    """
    Convert decimal to binary with zero padding.
    
    Args:
        num: Non-negative integer to convert
        width: Bit width for padding (default: 8)
    
    Returns:
        Binary string with leading zeros (e.g., '00101010')
    
    Examples:
        >>> convert_to_binary(42)
        '00101010'
        >>> convert_to_binary(5, 16)
        '0000000000000101'
    """
    if num < 0:
        raise ValueError("num must be non-negative")
    return format(num, f'0{width}b')

Common Mistake 1: Forgetting the '0b' Prefix

# ❌ WRONG: Including prefix in comparisons
binary = bin(42)
if binary == '101010':  # This will fail!
    print("Found")  # Won't execute
else:
    print("Not found")  # Executes

# ✅ RIGHT: Remove prefix first
binary = bin(42)[2:]
if binary == '101010':
    print("Found")  # Executes correctly

Common Mistake 2: Integer Overflow Assumptions

# ❌ WRONG: Assuming 32-bit limit (JavaScript problem)
large_num = 2**40
print(format(large_num, '08b'))  # Works fine in Python!

# ✅ RIGHT: Python handles arbitrary precision
print(f"Large number: {large_num}")
print(f"Binary: {format(large_num, 'b')}")
print(f"Length: {len(format(large_num, 'b'))} bits")

Common Mistake 3: Forgetting Padding in Comparisons

# ❌ WRONG: Binary strings without padding
nums = [1, 5, 10, 15]
binary_strings = [bin(n)[2:] for n in nums]
print(binary_strings)  # ['1', '101', '1010', '1111'] - inconsistent!

# ✅ RIGHT: Use consistent padding
binary_strings = [format(n, '04b') for n in nums]
print(binary_strings)  # ['0001', '0101', '1010', '1111'] - consistent!

Security Checklist

Binary Conversion Best Practices
✓ Use f-strings or format() for modern code
✓ Handle negative numbers explicitly
✓ Use fixed-width padding for consistency
✓ Test edge cases (0, max value, overflow)
✓ Document expected bit width
✓ Validate input ranges
✓ Consider performance for bulk conversions
✓ Use type hints for clarity
            

Summary: Mastering Binary Conversion in Python

You now understand six methods for converting integers to binary:

• bin(): Simplest, but includes '0b' prefix
• format(): Most versatile with padding control
• F-strings: Fastest and most modern (Python 3.6+)
• Bitwise operations: Educational, maximum control
• Recursion: Elegant but slow
• NumPy: Efficient for large arrays

Quick Decision Tree:

• Need simple binary? → bin(num)[2:]
• Need padded binary? → format(num, '08b')
• Modern code? → f'{num:08b}'
• Understanding bits? → Bitwise operations
• Many numbers? → List comprehension or NumPy

Start with the simplest method that meets your needs, then optimize if necessary.