ZetCode

Python __abs__ Method

Last modified April 8, 2025

This comprehensive guide explores Python's __abs__ method, the special method that implements the built-in abs() function. We'll cover basic usage, mathematical operations, custom number types, and practical examples.

Basic Definitions

The __abs__ method is a special method in Python that defines how the abs() function behaves when called on an object. It returns the absolute value of a number.

Key characteristics: it takes no arguments (except self), must return a value, and is automatically invoked by the abs() built-in function. It's part of Python's operator overloading protocol for numeric types.

Basic __abs__ Implementation

Here's a simple implementation showing how __abs__ works with a custom number class. This demonstrates the basic syntax and behavior.

basic_abs.py 
class MyNumber:
    def __init__(self, value):
        self.value = value
    
    def __abs__(self):
        return abs(self.value)

num = MyNumber(-5)
print(abs(num))  # Output: 5

This example shows a minimal __abs__ implementation. The method simply returns the absolute value of the instance's value attribute using Python's built-in abs().

When abs(num) is called, Python automatically invokes num.__abs__(). This allows custom objects to work with Python's built-in functions.

Implementing Absolute Value for Complex Numbers

The __abs__ method can implement more complex mathematical operations, like calculating the magnitude of a complex number or vector.

complex_abs.py 
class ComplexNumber:
    def __init__(self, real, imaginary):
        self.real = real
        self.imaginary = imaginary
    
    def __abs__(self):
        return (self.real**2 + self.imaginary**2) ** 0.5
    
    def __repr__(self):
        return f"{self.real} + {self.imaginary}i"

c = ComplexNumber(3, 4)
print(abs(c))  # Output: 5.0 (sqrt(3² + 4²))

This implementation calculates the magnitude (absolute value) of a complex number using the Pythagorean theorem. The result is the distance from the origin in the complex plane.

The __abs__ method here demonstrates how to compute a derived value rather than simply returning an attribute. This pattern is common in mathematical classes.

Absolute Value for Custom Vector Class

The __abs__ method can represent different concepts like vector magnitude in physics or mathematics applications.

vector_abs.py 
class Vector:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    
    def __abs__(self):
        return (self.x**2 + self.y**2 + self.z**2) ** 0.5
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y}, {self.z})"

v = Vector(1, 2, 2)
print(abs(v))  # Output: 3.0 (sqrt(1 + 4 + 4))

This Vector class implements __abs__ to return the Euclidean norm (magnitude) of the vector. The calculation extends the Pythagorean theorem to three dimensions.

This example shows how __abs__ can represent domain-specific concepts of "absolute value" or "magnitude" beyond simple numeric absolute values.

Absolute Value with Unit Conversion

__abs__ can incorporate unit conversions or other transformations when computing absolute values, useful in scientific computing.

temperature_abs.py 
class Temperature:
    def __init__(self, kelvin):
        self.kelvin = kelvin
    
    def __abs__(self):
        return Temperature(abs(self.kelvin))
    
    def to_celsius(self):
        return self.kelvin - 273.15
    
    def __repr__(self):
        return f"{self.kelvin}K ({self.to_celsius():.1f}°C)"

temp = Temperature(-50)
abs_temp = abs(temp)
print(abs_temp)  # Output: 50K (-223.1°C)

This Temperature class implements __abs__ to return a new Temperature instance with the absolute value in Kelvin. The method preserves the unit while computing the absolute value.

The example demonstrates how __abs__ can return a new object rather than a primitive value, maintaining the class type through the operation.

Absolute Value with Caching

For expensive absolute value calculations, __abs__ can implement caching to optimize performance when called repeatedly.

cached_abs.py 
class BigMatrix:
    def __init__(self, data):
        self.data = data
        self._abs_cache = None
    
    def __abs__(self):
        if self._abs_cache is None:
            print("Calculating absolute value...")
            # Simulate expensive calculation
            self._abs_cache = sum(sum(abs(x) for x in row) for row in self.data)
        return self._abs_cache

matrix = BigMatrix([[1, -2], [-3, 4]])
print(abs(matrix))  # Calculates and caches
print(abs(matrix))  # Uses cached value

This example shows a __abs__ implementation with caching. The first call performs the calculation and stores the result, while subsequent calls return the cached value.

This pattern is useful when the absolute value calculation is computationally expensive and the object is immutable (or the relevant attributes don't change).

Best Practices

Source References

Author

My 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.