How to reverse a number in Python

Reversing numbers in Python enables you to flip digits from left to right, transforming numbers like 12345 into 54321. This fundamental operation finds applications in algorithms, data processing, and mathematical computations.

This guide covers multiple techniques for number reversal, practical tips, and real-world use cases. All code examples were created with Claude, an AI assistant built by Anthropic.

Basic number reversal with string conversion

num = 12345
reversed_num = int(str(num)[::-1])
print(f"Original: {num}, Reversed: {reversed_num}")

Original: 12345, Reversed: 54321

The string conversion method leverages Python's string slicing capabilities to reverse numbers efficiently. Converting the integer to a string allows us to use the [::-1] slice operator, which creates a reversed copy of the sequence. This approach offers a clean, readable solution that works well for most numerical reversal needs.

While this technique requires type conversion between int and str, it provides several advantages:

• Simple implementation with minimal code
• Handles leading zeros naturally when converting back to integers
• Works consistently across different Python versions
• Maintains good performance for typical number sizes

String-based techniques

Building on the string conversion approach, Python offers several elegant techniques to reverse numbers—from methodically breaking down the steps to using built-in functions like reversed() and list comprehensions.

Breaking down string reversal steps

num = 7890
num_str = str(num)
reversed_str = num_str[::-1]
reversed_num = int(reversed_str)
print(reversed_num)

987

This step-by-step approach breaks down number reversal into distinct operations for clarity and learning. The process starts by converting the integer 7890 to a string using str(). Python's slice operator [::-1] then creates a reversed copy of that string.

• The str() function transforms the number into a sequence of characters we can manipulate
• The slice operator works from right to left, collecting each character in reverse order
• Converting back to an integer with int() removes any leading zeros automatically

This explicit method helps developers understand each transformation happening under the hood. It's particularly useful when debugging or when you need to modify specific steps in the reversal process.

Using the reversed() function

num = 12345
reversed_str = ''.join(reversed(str(num)))
reversed_num = int(reversed_str)
print(reversed_num)

54321

The reversed() function provides a memory-efficient way to reverse sequences in Python. When combined with join(), it creates a clean approach to number reversal that's both readable and performant.

• The reversed() function returns an iterator of characters in reverse order instead of creating a new string in memory
• The empty string '' acts as a delimiter when joining the reversed characters back together
• Converting the final string to an integer with int() produces the reversed number

This method shines when working with longer numbers since it conserves memory by processing one character at a time. It offers similar functionality to slice notation but with enhanced readability that clearly communicates the reversal intent.

Using list comprehension

num = 9876
num_str = str(num)
reversed_str = ''.join([num_str[i] for i in range(len(num_str)-1, -1, -1)])
reversed_num = int(reversed_str)
print(reversed_num)

6789

List comprehension offers a Pythonic way to reverse numbers by creating a new list of characters in reverse order. The range() function generates indices from the last character to the first, stepping backwards with -1. The comprehension builds a reversed sequence that join() combines into a string.

• The expression range(len(num_str)-1, -1, -1) creates a sequence starting from the last index, continuing until -1, moving backward one step at a time
• The comprehension [num_str[i] for i in range(...)] accesses each character using these reversed indices
• This approach gives you explicit control over the reversal process while maintaining readable, efficient code

While this method requires more code than slice notation, it demonstrates how to leverage Python's list comprehension for custom sequence manipulation. The technique proves particularly valuable when you need to apply additional transformations during the reversal process.

Mathematical approaches

Beyond string manipulation, Python enables number reversal through pure mathematical operations, recursive functions, and functional programming with reduce()—each offering unique advantages for specific use cases.

Using division and modulo operations

def reverse_number(num):
    reversed_num = 0
    while num > 0:
        digit = num % 10
        reversed_num = reversed_num * 10 + digit
        num = num // 10
    return reversed_num

print(reverse_number(12345))

54321

This mathematical approach extracts and rebuilds digits without converting to strings. The reverse_number function processes each digit through a loop using two key operations: modulo and integer division.

• The modulo operator % extracts the rightmost digit by finding the remainder when divided by 10
• Integer division // removes the rightmost digit by dividing the number by 10
• Each extracted digit gets added to reversed_num after multiplying by 10 to shift existing digits left

For example, when reversing 12345, the function first extracts 5, then 4, then 3, and so on. It builds the reversed number by gradually constructing 5, then 54, then 543, until reaching the final result 54321.

Using recursion

def reverse_recursive(num, reversed_num=0):
    if num == 0:
        return reversed_num
    return reverse_recursive(num // 10, reversed_num * 10 + num % 10)

print(reverse_recursive(12345))

54321

The recursive approach elegantly breaks down number reversal into smaller, identical steps. Each recursive call processes one digit and builds the reversed result through the accumulator parameter reversed_num.

• The base case if num == 0 returns the final reversed number when no digits remain
• The recursive step uses num // 10 to remove the rightmost digit and continue processing
• The expression reversed_num * 10 + num % 10 builds the reversed number one digit at a time

For example, reversing 12345 creates a chain of recursive calls. Each call extracts a digit and positions it correctly in the final number through multiplication and addition. This technique showcases the power of recursion for breaking complex operations into simple, repeatable steps.

Using functional programming with reduce()

from functools import reduce

def reverse_functional(num):
    return reduce(lambda acc, digit: acc * 10 + int(digit), str(num)[::-1], 0)

print(reverse_functional(12345))

54321

The reduce() function transforms a sequence into a single value by applying an operation repeatedly. In this case, it builds the reversed number digit by digit using a lambda function that multiplies the accumulator by 10 and adds each new digit.

• The lambda acc, digit function takes two parameters: acc stores the running total. digit represents each character from the reversed string
• The str(num)[::-1] creates a reversed string of digits that reduce() processes from left to right
• The final parameter 0 provides the initial value for the accumulator

For example, when reversing 12345, reduce() processes the reversed string "54321". It starts with 0, then computes 5, then 50+4=54, then 540+3=543, continuing until it reaches 54321.

Checking if a number is a palindrome using str() comparison

The str() function enables a straightforward palindrome check by comparing a number with its reversed version—a technique that works efficiently for both small and large integers.

def is_palindrome(num):
    return str(num) == str(num)[::-1]

test_numbers = [121, 12321, 12345, 98789]
for num in test_numbers:
    print(f"{num} is{' ' if is_palindrome(num) else ' not '}a palindrome")

The is_palindrome function efficiently determines if a number reads the same forwards and backwards. It converts the input number to a string and compares it with its reversed version using the slice operator [::-1]. The function returns True if both strings match, indicating a palindrome.

A loop processes a list of test numbers, using Python's ternary operator in an f-string to generate clear output messages. The expression ' ' if is_palindrome(num) else ' not ' elegantly adds or omits the word "not" based on the palindrome check result.

• Numbers like 121 and 12321 will return True
• Numbers like 12345 will return False
• The solution handles numbers of any length

Creating a simple number encoding scheme with [::-1] reversal

Number reversal combined with basic arithmetic operations creates a straightforward encoding scheme that transforms account IDs and other sensitive numbers into less recognizable forms while maintaining reversibility.

def encode_number(num, salt=7):
    reversed_num = int(str(num)[::-1])
    encoded = reversed_num * salt + salt
    return encoded

account_id = 12345
encoded_id = encode_number(account_id)
print(f"Original ID: {account_id}, Encoded: {encoded_id}")

The encode_number function implements a basic number transformation technique using two key operations. First, it reverses the input number using string conversion and the [::-1] slice operator. Then it applies a mathematical formula using a salt value (defaulting to 7) to further obscure the number.

• The function takes a number and an optional salt parameter
• It multiplies the reversed number by the salt value
• Finally, it adds the salt value to create the encoded result

This approach creates a simple yet effective way to transform numbers while preserving the ability to decode them later. The salt value adds an extra layer of complexity to the transformation process.

Common errors and challenges

Python's number reversal operations can encounter several edge cases that require special handling—from preserving zeros to managing negative values effectively.

Handling leading zeros in reversed numbers

Leading zeros pose a unique challenge when reversing numbers in Python. The int() function automatically removes leading zeros, which can produce unexpected results when you need to preserve the original number of digits.

num = 1020
reversed_num = int(str(num)[::-1])
print(f"Original: {num}, Reversed: {reversed_num}")

When reversing 1020, the output becomes 201 instead of 0201. This happens because Python's int() function drops leading zeros during the conversion process. The following code demonstrates a solution to preserve these zeros.

num = 1020
reversed_str = str(num)[::-1]
print(f"Original: {num}, Reversed as string: {reversed_str}, As number: {int(reversed_str)}")

The solution stores the reversed number as a string using reversed_str = str(num)[::-1] before converting it to an integer. This preserves leading zeros in the string representation while still allowing numeric operations with the integer version.

• Watch for this issue when working with phone numbers, ZIP codes, or any data where leading zeros carry meaning
• The string format maintains the exact digit count and position information
• Use string comparison instead of numeric comparison when exact digit matching matters

This approach gives you flexibility to handle both string and numeric representations based on your specific needs. The integer conversion remains available when you need to perform calculations.

Handling negative numbers with abs() function

Negative numbers require special handling during reversal operations. The str() method includes the minus sign when converting negative integers to strings. This creates unexpected behavior when using slice operations directly. The code below demonstrates this common pitfall.

num = -12345
reversed_num = int(str(num)[::-1])
print(f"Original: {num}, Reversed: {reversed_num}")

The code incorrectly places the negative sign at the end of the reversed number, producing an invalid result. The direct string reversal fails to handle the minus symbol appropriately. The following implementation demonstrates the proper approach for negative numbers.

num = -12345
abs_num = abs(num)
reversed_abs = int(str(abs_num)[::-1])
reversed_num = -reversed_abs if num < 0 else reversed_abs
print(f"Original: {num}, Reversed: {reversed_num}")

The solution handles negative numbers by first using abs() to remove the minus sign. After reversing the absolute value, it reapplies the negative sign only if the original number was negative. This approach ensures proper placement of the minus sign in the final result.

• Watch for this issue when processing financial data or mathematical calculations that involve negative numbers
• The ternary operator -reversed_abs if num < 0 else reversed_abs provides an elegant way to conditionally restore the sign
• This pattern works consistently across different Python versions and number ranges

Preserving trailing zeros when using int() conversion

Trailing zeros at the end of numbers present a distinct challenge when performing number reversal operations. The int() function automatically drops these zeros during conversion, potentially altering the expected output. The code below demonstrates this common issue that developers encounter when working with numbers that end in zero.

num = 12300
reversed_num = int(str(num)[::-1])
print(f"Original: {num}, Reversed: {reversed_num}")

When reversing 12300, the code produces 321 instead of 00321. The int() function strips away the zeros that should appear at the start of the reversed number. Let's examine a solution that preserves these important digits.

num = 12300
reversed_str = str(num)[::-1]
print(f"Original: {num}, Reversed as string: {reversed_str}, As number: {int(reversed_str)}")

The solution stores the reversed number in a string variable reversed_str before converting it to an integer. This approach preserves all zeros in the string representation while still allowing numeric operations with the integer version.

• Watch for this issue when working with formatted numbers like product codes or serial numbers
• The string format maintains exact digit positions and counts
• Use string comparison instead of numeric comparison when precise digit matching matters

This pattern gives you flexibility to handle both string and numeric representations based on your specific needs. The integer conversion remains available when you need to perform calculations with the reversed number.