Last modified April 11, 2025
This comprehensive guide explores Python's abs function, which
returns the absolute value of a number. We'll cover numeric types, custom
objects, and practical examples of calculating magnitudes and distances.
The abs function returns the absolute value of a number. For
real numbers, it removes any negative sign. For complex numbers, it returns
the magnitude.
Key characteristics: works with integers, floats, complex numbers, and any
object implementing __abs__. It always returns a non-negative
value (float for complex numbers).
Here's simple usage with different numeric types showing how abs
handles positive, negative, and complex numbers.
# With integers print(abs(10)) # 10 print(abs(-10)) # 10 # With floats print(abs(3.14)) # 3.14 print(abs(-3.14)) # 3.14 # With complex numbers print(abs(3 + 4j)) # 5.0 (sqrt(32 + 42))
This example shows abs with different numeric types. For real
numbers, it simply removes the negative sign. For complex numbers, it calculates
the magnitude using the Pythagorean theorem.
The complex number example returns 5.0 because √(32 + 42) = 5. The result is always a float for complex numbers.
Absolute values are commonly used in distance calculations between points. This example shows a practical application in 1D and 2D space.
def distance_1d(a, b): return abs(a - b) def distance_2d(p1, p2): return abs(complex(p2[0] - p1[0], p2[1] - p1[1])) print(distance_1d(5, 9)) # 4 print(distance_1d(9, 5)) # 4 print(distance_2d((1,2), (4,6))) # 5.0
The 1D distance calculates absolute difference between two numbers. The 2D version uses complex numbers to compute Euclidean distance between points.
This demonstrates how abs can simplify distance calculations by
automatically handling directionality (order of points doesn't matter).
You can make custom objects work with abs by implementing the
__abs__ special method. This example creates a Vector class.
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __abs__(self):
return (self.x**2 + self.y**2)**0.5
def __repr__(self):
return f"Vector({self.x}, {self.y})"
v = Vector(3, 4)
print(abs(v)) # 5.0
The Vector class implements __abs__ to return its magnitude.
When we call abs on a Vector instance, Python uses this method.
This pattern is common in mathematical classes where the concept of magnitude or length applies (vectors, complex numbers, etc.).
The abs function raises TypeError when used with
unsupported types. This example shows proper error handling.
try:
print(abs("hello"))
except TypeError as e:
print(f"Error: {e}") # bad operand type for abs(): 'str'
class NoAbs:
pass
try:
print(abs(NoAbs()))
except TypeError as e:
print(f"Error: {e}") # bad operand type for abs(): 'NoAbs'
These examples demonstrate abs's behavior with unsupported types.
Strings and objects without __abs__ raise TypeError.
To make a class work with abs, implement __abs__
as shown in the previous example.
This example compares abs performance with alternative methods
for getting absolute values.
import timeit
import math
def test_abs():
return abs(-3.14)
def test_math_fabs():
return math.fabs(-3.14)
def test_conditional():
return -3.14 if -3.14 < 0 else 3.14
print("abs():", timeit.timeit(test_abs, number=1000000))
print("math.fabs():", timeit.timeit(test_math_fabs, number=1000000))
print("Conditional:", timeit.timeit(test_conditional, number=1000000))
This benchmarks different absolute value methods. abs is generally
fastest for built-in types. math.fabs is specialized for floats.
The conditional approach is slower and less readable, demonstrating why
abs is preferred in most cases.
abs over manual conditionalsMy name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.
List all Python tutorials.