Quick answer: Call abs(value) for a real number’s distance from zero. For complex numbers it returns magnitude, and for custom classes Python calls __abs__(), so the result follows the type’s contract.
Python absolute value means the distance of a number from zero. The built-in abs() function returns that distance for integers, floats, complex numbers, and objects that define an absolute-value method.
The official Python documentation for abs() is the main reference. The numeric types documentation explains the related behavior for integers, floats, and complex numbers, while the math.fabs() reference covers the float-only helper.
Use abs() when the sign should not matter. Common cases include measuring error, comparing distance from a target, sorting numbers by closeness, and turning signed deltas into magnitudes for a report. The original number is not changed; abs() returns a new result.
The sign rule is simple for real numbers. A positive number stays positive, zero stays zero, and a negative number becomes positive. For complex numbers, abs() returns the magnitude, which is the geometric distance from the origin.
One important detail is type preservation. With integers, abs() returns an integer. With floats, it returns a float. With Decimal and Fraction, it keeps those types instead of forcing the result into a binary floating-point number.
Basic abs Usage
Pass one number to abs() and Python returns its non-negative magnitude.
numbers = [-12, -3.5, 0, 8, 14.25]
for number in numbers:
print(number, "=>", abs(number))
This is the everyday use case: remove the sign when only size matters. It works the same way in expressions, function calls, list comprehensions, and sort keys.
Do not use abs() when the sign carries meaning. A loss, refund, temperature drop, or direction change may need to remain negative so later logic can tell which side of zero it came from.
Measure Distance From A Target
Absolute value is useful when you care how far a reading is from the expected number, not whether it is above or below it.
target = 100
readings = [96, 101, 112, 87]
for reading in readings:
distance = abs(reading - target)
print(reading, distance)
The subtraction produces a signed difference. Wrapping that difference with abs() turns it into a plain distance.
This pattern appears in tests, sensor checks, game logic, and ranking systems. It is also useful before deciding whether two numbers are close enough for a tolerance rule.
Sort By Closeness
A sort key can call abs() to order numbers by closeness to a chosen target.
scores = [72, 91, 88, 103, 96]
target = 90
closest_first = sorted(scores, key=lambda score: abs(score - target))
print(closest_first)
Here, the list is not sorted from low to high. It is sorted by distance from 90. That makes 91 and 88 appear before scores that are farther away.
When two items have the same distance, Python’s stable sort keeps their earlier relative order. Add a second key if ties need a specific rule.
Use abs With Complex Numbers
For a complex number, abs() returns the magnitude. This is the same distance formula used for a right triangle.
point = 3 + 4j
magnitude = abs(point)
print(magnitude)
The result is 5.0 because the real part is 3 and the imaginary part is 4. That matches the square root of 3 ** 2 + 4 ** 2.
Complex magnitude is helpful in signal processing, geometry, and any code that represents two-dimensional coordinates as complex numbers.
Keep Exact Numeric Types
The built-in function respects standard-library numeric classes such as Decimal and Fraction.
from decimal import Decimal
from fractions import Fraction
amount = Decimal("-19.95")
ratio = Fraction(-2, 7)
print(abs(amount), type(abs(amount)).__name__)
print(abs(ratio), type(abs(ratio)).__name__)
This is one reason to prefer abs() over math.fabs() in general code. math.fabs() converts its result to float, which can lose exact decimal or rational representation.
Use math.fabs() only when a float result is clearly what you want. For most Python code, abs() is more flexible and easier to read.
Support Custom Objects
A class can define __abs__() when absolute value has a clear meaning for that object.
class BalanceChange:
def __init__(self, cents):
self.cents = cents
def __abs__(self):
return BalanceChange(abs(self.cents))
def __repr__(self):
return f"BalanceChange(cents={self.cents})"
change = BalanceChange(-250)
print(abs(change))
Only add __abs__() when callers can predict the result. If the operation needs business context, a named method is usually clearer.
The practical rule is short: use abs() for sign-free magnitude, use subtraction plus abs() for distance from a target, use it directly with complex numbers for magnitude, and avoid math.fabs() unless a float result is required.
When reviewing code, read abs(x) as “the magnitude of x.” That mental model makes it easier to spot mistakes where the sign should have been preserved for a later decision, audit trail, or user-facing message.
Also remember that absolute value is not rounding, clipping, or validation. It changes the sign of negative real numbers, but it does not limit a number to a range or make an invalid input acceptable. Keep those rules separate so code remains easy to test.
Use abs With Real Numbers
abs() accepts integers and floating-point values and returns a non-negative result for ordinary real inputs. It returns a new numeric value; it does not mutate the variable you pass. For Decimal or Fraction values, the result keeps the type’s arithmetic model.
values = [-12, 3.5, 0]
for value in values:
print(value, abs(value))Complex Values Return Magnitude
A complex number has real and imaginary components, so it has no ordinary left-or-right sign. abs(complex_value) returns its magnitude, equivalent to the distance from zero in the complex plane. This is a float even when the components are integers.
point = 3 + 4j
print(abs(point))
print((point.real ** 2 + point.imag ** 2) ** 0.5)Custom Objects Define The Meaning
Python delegates abs(object) to object.__abs__(). A domain type can use that hook for distance, norm, magnitude, or another clearly documented non-negative measure. Keep the return type predictable and make the unit or coordinate system part of the class documentation.
class Celsius:
def __init__(self, value):
self.value = value
def __abs__(self):
return abs(self.value)
print(abs(Celsius(-4)))Python’s abs() reference defines real and complex behavior, while the data model documents __abs__() for custom types.
For related numeric helpers, compare rounding values, finding a maximum, and NumPy square roots when the operation is more specific than magnitude.
Frequently Asked Questions
How do I find an absolute value in Python?
Call abs(value). It returns a non-negative magnitude for real numbers and the complex magnitude for complex values.
Does abs() work with negative numbers?
Yes. abs(-7) returns 7, and the original number is not modified.
What does abs() return for a complex number?
It returns the magnitude, calculated from the real and imaginary components, as a floating-point value.
Can a custom Python class support abs()?
Yes. Define __abs__() on the class to return the type-appropriate magnitude or distance.