When I started my programming journey at Stanford’s computer science program, one of the first algorithmic challenges I encountered was reversing numbers. In this article, I’ll walk you through multiple methods to reverse a number in Python, from the most simple approaches to more advanced techniques with examples.
Reverse a Number in Python
Let us learn various to reverse a number in Python.
Read How to Write a Variable to a File in Python?
Method 1: String Conversion Approach
The most simple way to reverse a number in Python is to convert it to a string, reverse the string, and convert it back to an integer:
def reverse_number_string_method(number):
"""
Reverse a number using string conversion.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
if number < 0:
return -int(str(-number)[::-1])
# Convert to string, reverse, and convert back to integer
return int(str(number)[::-1])
# Example
original_number = 12345
reversed_number = reverse_number_string_method(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")Output:
Original: 12345, Reversed: 54321You can see the output in the screenshot below.
I’ve used this method extensively in my data transformation scripts at a fintech startup in New York, where readability was prioritized over absolute performance.
Check out How to Write a List to a File in Python?
Method 2: Mathematical Approach
If you prefer a purely mathematical solution without string conversions, this approach uses modulo and division operations:
def reverse_number_math_method(number):
"""
Reverse a number using mathematical operations.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
is_negative = number < 0
number = abs(number)
reversed_num = 0
while number > 0:
# Extract the last digit
digit = number % 10
# Add the digit to the reversed number
reversed_num = reversed_num * 10 + digit
# Remove the last digit from the original number
number //= 10
return -reversed_num if is_negative else reversed_num
# Example
original_number = 7890
reversed_number = reverse_number_math_method(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")Output:
Original: 7890, Reversed: 987You can see the output in the screenshot below.
When I was teaching algorithm design at a coding boot camp in Boston, I always emphasized this approach.
Read How to Download and Extract ZIP Files from a URL Using Python?
Method 3: Use Recursion
For those who appreciate elegant, recursive solutions:
def reverse_number_recursive(number, reversed_num=0):
"""
Reverse a number using recursion.
Args:
number: The number to reverse
reversed_num: The partially built reversed number (used in recursion)
Returns:
The reversed number
"""
# Base case: number is fully processed
if number == 0:
return reversed_num
# Extract last digit and add to reversed number
last_digit = number % 10
reversed_num = reversed_num * 10 + last_digit
# Recursive call with the remaining digits
return reverse_number_recursive(number // 10, reversed_num)
# Example with handling negative numbers
def reverse_with_sign(number):
if number < 0:
return -reverse_number_recursive(-number)
return reverse_number_recursive(number)
# Test
original_number = 42195
reversed_number = reverse_with_sign(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")Output:
Original: 42195, Reversed: 59124You can see the output in the screenshot below.
While working on a project for a Chicago-based insurance company, I found this recursive approach particularly useful when integrating with a larger recursive algorithm.
Check out Python Create File
Method 4: Use List Comprehension and join()
For a more Pythonic solution using list comprehension:
def reverse_number_list_comprehension(number):
"""
Reverse a number using list comprehension.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
is_negative = number < 0
number_str = str(abs(number))
# Use list comprehension to create a reversed string
reversed_str = ''.join([number_str[i] for i in range(len(number_str)-1, -1, -1)])
return -int(reversed_str) if is_negative else int(reversed_str)
# Example
original_number = 8675309
reversed_number = reverse_number_list_comprehension(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")
# Output: Original: 8675309, Reversed: 9035768I’ve found this approach particularly elegant when teaching Python list comprehensions to my team members at a San Francisco startup.
Check out Python Get File Extension
Method 5: Use the Reversed() Function
Python’s built-in reversed() function offers another clean solution:
def reverse_number_reversed_function(number):
"""
Reverse a number using the built-in reversed() function.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
is_negative = number < 0
number_str = str(abs(number))
# Use the reversed() function
reversed_str = ''.join(reversed(number_str))
return -int(reversed_str) if is_negative else int(reversed_str)
# Example
original_number = 1234567
reversed_number = reverse_number_reversed_function(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")
# Output: Original: 1234567, Reversed: 7654321During code reviews at my previous position at a tech company in Austin, I often recommended this approach for its readability and use of Python’s built-in functions.
Read Python Get Filename From Path
Method 6: Use reduce() Function
For fans of functional programming, here’s an approach using reduce():
from functools import reduce
def reverse_number_functional(number):
"""
Reverse a number using functional programming.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
is_negative = number < 0
number = abs(number)
# Convert to string for digit extraction
digits = [int(d) for d in str(number)]
# Use reduce to build the reversed number
reversed_num = reduce(lambda acc, digit: acc * 10 + digit, digits[::-1], 0)
return -reversed_num if is_negative else reversed_num
# Example
original_number = 987654
reversed_number = reverse_number_functional(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")
# Output: Original: 987654, Reversed: 456789I implemented this approach in a data analytics project at a Los Angeles media company where we were heavily using functional programming patterns throughout the codebase.
Check out Python File methods
Method 7: One-Liner Using Extended Slice Syntax
If you prefer concise code, here’s a one-liner solution:
# One-liner function
reverse_number = lambda n: -int(str(abs(n))[::-1]) if n < 0 else int(str(n)[::-1])
# Examples
print(f"12345 reversed: {reverse_number(12345)}") # Output: 54321
print(f"-9876 reversed: {reverse_number(-9876)}") # Output: -6789While teaching a Python workshop in Washington D.C., I used this one-liner to demonstrate the power and expressiveness of Python’s lambda functions and slicing operations.
Read Python file Does Not Exist Exception
Method 8: Use Generators for Memory Efficiency
For extremely large numbers where memory efficiency matters:
def reverse_number_generator(number):
"""
Reverse a number using a generator for memory efficiency.
Args:
number: The number to reverse
Returns:
The reversed number
"""
# Handle negative numbers
is_negative = number < 0
number = abs(number)
# Create a generator that yields digits in reverse order
def reversed_digits(n):
while n > 0:
yield n % 10
n //= 10
# Build the reversed number using the generator
result = 0
for digit in reversed_digits(number):
result = result * 10 + digit
return -result if is_negative else result
# Example
original_number = 1234567890
reversed_number = reverse_number_generator(original_number)
print(f"Original: {original_number}, Reversed: {reversed_number}")
# Output: Original: 1234567890, Reversed: 987654321I’ve used this generator-based approach when working with large numerical datasets at a Denver-based research institute where memory optimization was critical.
Check out How to Import a Class from a File in Python
Conclusion
In this tutorial, I explained how to reverse a number in Python. I discussed some methods such as the string conversion approach, mathematical approach, recursion, list comprehension and join(), the reversed() function, reduce() function, one-loner using extended slice syntax, and using generators for memory.
You may read:
- How to Copy File and Rename in Python
- How to Check If a File Exists and Create It If Not in Python?
- How to Get the File Size in MB using Python?
Bijay Kumar is an experienced Python and AI professional who enjoys helping developers learn modern technologies through practical tutorials and examples. His expertise includes Python development, Machine Learning, Artificial Intelligence, automation, and data analysis using libraries like Pandas, NumPy, TensorFlow, Matplotlib, SciPy, and Scikit-Learn. At PythonGuides.com, he shares in-depth guides designed for both beginners and experienced developers. More about us.
