Defining the Absolute Value

The absolute value lets you determine thesize ormagnitude of an object, such as a number or avector, regardless of its direction.Real numbers can have one of two directions when you ignore zero: they can be either positive or negative. On the other hand,complex numbers and vectors can have many more directions.

Consider a temperature measurement as an example. If the thermometer reads -12°C, then you can say it’s twelve degrees Celsius below freezing. Notice how you decomposed the temperature in the last sentence into a magnitude, twelve, and a sign. The phrasebelow freezing means the same as below zero degrees Celsius. The temperature’s size or absolute value is identical to the absolute value of the much warmer +12°C.

Using mathematical notation, you can define the absolute value of 𝑥 as apiecewise function, which behaves differently depending on the range of input values. A common symbol for absolute value consists of two vertical lines:

This function returns values greater than or equal to zero without alteration. On the other hand, values smaller than zero have their sign flipped from a minus to a plus. Algebraically, this is equivalent to taking the square root of a number squared:

When you square a real number, you always get a positive result, even if the number that you started with was negative. For example, the square of -12 and the square of 12 have the same value, equal to 144. Later, when you compute the square root of 144, you’ll only get 12 without the minus sign.

Geometrically, you can think of an absolute value as thedistance from the origin, which is zero on anumber line in the case of the temperature reading from before:

To calculate this distance, you can subtract the origin from the temperature reading (-12°C - 0°C = -12°C) or the other way around (0°C - (-12°C) = +12°C), and then drop the sign of the result. Subtracting zero doesn’t make much difference here, but the reference point may sometimes be shifted. That’s the case for vectors bound to a fixed point in space, which becomes their origin.

Vectors, just like numbers, convey information about thedirection and themagnitude of a physical quantity, but in more than one dimension. For example, you can express thevelocity of a falling snowflake as a three-dimensional vector:

This vector indicates the snowflake’s current position relative to the origin of the coordinate system. It also shows the snowflake’s direction and pace of motion through the space. The longer the vector, the greater the magnitude of the snowflake’s speed. As long as the coordinates of the vector’s initial and terminal points are expressed in meters, calculating its length will get you the snowflake’sspeed measured in meters per unit of time.

>>>A=[1,2,3]>>>B=[3,2,1]>>>bound_vector=[A,B]>>>bound_vector[[1, 2, 3], [3, 2, 1]]>>>free_vector=[b-afora,binzip(A,B)]>>>free_vector[2, 0, -2]

Thelength of a vector, also known as its magnitude, is the distance between its initial and terminal points, 𝐴 and 𝐵, which you can calculate using theEuclidean norm:

This formula calculates the length of the 𝑛-dimensional vector 𝐴𝐵, by summing the squares of the differences between the coordinates of points 𝐴 and 𝐵 in each dimension indexed by 𝑖. For a free vector, the initial point, 𝐴, becomes the origin of the coordinate system—or zero—which simplifies the formula, as you only need to square the coordinates of your vector.

Recall the algebraic definition of an absolute value. For numbers, it was the square root of a number squared. Now, when you add more dimensions to the equation, you end up with the formula for the Euclidean norm, shown above. So, the absolute value of a vector is equivalent to its length!

All right. Now that you know when absolute values might be useful, it’s time to implement them in Python!

Implementing the Absolute Value Function in Python

To implement the absolute value function in Python, you can take one of the earlier mathematical definitions and translate it into code. For instance, the piecewise function may look like this:

defabsolute_value(x):ifx>=0:returnxelse:return-x

You use aconditional statement to check whether the given number denoted with the letterx is greater than or equal to zero. If so, then you return the same number. Otherwise, you flip the number’s sign. Because there are only two possible outcomes here, you can rewrite the above function using aconditional expression that comfortably fits on a single line:

defabsolute_value(x):returnxifx>=0else-x

It’s exactly the same behavior as before, only implemented in a slightly more compact way. Conditional expressions are useful when you don’t have a lot of logic that goes into the two alternative branches in your code.

defabsolute_value(x):returnmax(x,-x)

The algebraic definition of an absolute value is also pretty straightforward to implement in Python:

frommathimportsqrtdefabsolute_value(x):returnsqrt(pow(x,2))

First, you import thesquare root function from themath module and then call it on the given number raised to the power of two. Thepower function is built right into Python, so you don’t have to import it. Alternatively, you can avoid theimport statement altogether by leveraging Python’sexponentiation operator (**), which can simulate the square root function:

defabsolute_value(x):return(x**2)**0.5

This is sort of a mathematical trick because using a fractional exponent is equivalent to computing the𝑛th root of a number. In this case, you take a squared number to the power of one-half (0.5) or one over two (½), which is the same as calculating the square root. Note that both Python implementations based on the algebraic definition suffer from a slight deficiency:

>>>defabsolute_value(x):...return(x**2)**0.5>>>absolute_value(-12)12.0>>>type(12.0)<class 'float'>

You always end up with afloating-point number, even if you started with aninteger. So, if you’d like to preserve the original data type of a number, then you might prefer the piecewise-based implementation instead.

As long as you stay within integers and floating-point numbers, you can also write a somewhat silly implementation of the absolute value function by leveraging the textual representation of numbers in Python:

defabsolute_value(x):returnfloat(str(x).lstrip("-"))

You convert the function’s argument,x, to aPython string using the built-instr() function. This lets you strip the leading minus sign, if there is one, with an empty string. Then, you convert the result to a floating-point number withfloat(). Note this implementation always converts integers to floats.

Implementing the absolute value function from scratch in Python is a worthwhile learning exercise. However, in real-life applications, you should take advantage of the built-inabs() function that comes with Python. You’ll find out why in the next section.

Using the Built-inabs() Function With Numbers

The last function that you implemented above was probably the least efficient one because of the data conversions and the string operations, which are usually slower than direct number manipulation. But in truth, all of your hand-made implementations of an absolute value pale in comparison to theabs() function that’s built into the language. That’s becauseabs() is compiled to blazing-fastmachine code, while your pure-Python code isn’t.

You should always preferabs() over your custom functions. It runs much more quickly, an advantage that can really add up when you have a lot of data to process. Additionally, it’s much more versatile, as you’re about to find out.

>>>abs(-12)12>>>abs(-12.0)12.0

Complex Numbers

You can think of acomplex number as a pair consisting of two floating-point values, commonly known as thereal part and theimaginary part. One way to define a complex number in Python is by calling the built-incomplex() function:

Python

>>>z=complex(3,2)

It accepts two arguments. The first one represents the real part, while the second one represents the imaginary part. At any point, you can access the complex number’s.real and.imag attributes to get those parts back:

Python

>>>z.real3.0>>>z.imag2.0

Both of them are read-only and are always expressed as floating-point values. Also, the absolute value of a complex number returned byabs() happens to be a floating-point number:

Python

>>>abs(z)3.605551275463989

This might surprise you until you find out that complex numbers have a visual representation that resembles two-dimensional vectors fixed at the coordinate system’s origin:

You already know the formula to calculate the length of such a vector, which in this case agrees with the number returned byabs(). Note that the absolute value of a complex number is more commonly referred to as themagnitude,modulus, orradius of a complex number.

While integers, floating-point numbers, and complex numbers are the only numeric types supported natively by Python, you’ll find two additional numeric types in its standard library. They, too, can interoperate with theabs() function.

>>>fromfractionsimportFraction>>>abs(Fraction("1/3"))Fraction(1, 3)>>>abs(Fraction("-3/4"))Fraction(3, 4)

>>>fromdecimalimportDecimal>>>abs(Decimal("0.3333333333333333"))Decimal('0.3333333333333333')>>>abs(Decimal("-0.75"))Decimal('0.75')

Callingabs() on Other Python Objects

Say you want to compute the absolute values of average daily temperature readings over some period. Unfortunately, as soon as you try callingabs() on a Python list with those numbers, you get an error:

>>>temperature_readings=[1,-5,1,-4,-1,-8,0,-7,3,-5,2]>>>abs(temperature_readings)Traceback (most recent call last):  File"<stdin>", line1, in<module>TypeError:bad operand type for abs(): 'list'

That’s becauseabs() doesn’t know how to process a list of numbers. To work around this, you could use a list comprehension or callPython’smap() function, like so:

>>>[abs(x)forxintemperature_readings][1, 5, 1, 4, 1, 8, 0, 7, 3, 5, 2]>>>list(map(abs,temperature_readings))[1, 5, 1, 4, 1, 8, 0, 7, 3, 5, 2]

Both implementations do the job but require an additional step, which may not always be desirable. If you want to cut that extra step, then you may look into external libraries that change the behavior ofabs() for your convenience. That’s what you’ll explore below.

>>>importnumpyasnp>>>temperature_readings=np.array([1,-5,1,-4,-1,-8,0,-7,3,-5,2])>>>abs(temperature_readings)array([1, 5, 1, 4, 1, 8, 0, 7, 3, 5, 2])

>>>list(abs(temperature_readings))[1, 5, 1, 4, 1, 8, 0, 7, 3, 5, 2]

>>>lowest_temperatures={..."Reykjav\xedk":[-3,-2,-2,1,4,7,9,8,6,2,-1,-2],..."Rovaniemi":[-16,-14,-10,-3,3,8,12,9,5,-1,-6,-11],..."Valetta":[9,9,10,12,15,19,21,22,20,17,14,11],...}

>>>importcalendar>>>importpandasaspd>>>df=pd.DataFrame(lowest_temperatures,index=calendar.month_abbr[1:])>>>df     Reykjavík  Rovaniemi  ValettaJan         -3        -16        9Feb         -2        -14        9Mar         -2        -10       10Apr          1         -3       12May          4          3       15Jun          7          8       19Jul          9         12       21Aug          8          9       22Sep          6          5       20Oct          2         -1       17Nov         -1         -6       14Dec         -2        -11       11

>>>df["Rovaniemi"]Jan   -16Feb   -14Mar   -10Apr    -3May     3Jun     8Jul    12Aug     9Sep     5Oct    -1Nov    -6Dec   -11Name: Rovaniemi, dtype: int64>>>type(df["Rovaniemi"])<class 'pandas.core.series.Series'>

>>>abs(df)     Reykjavík  Rovaniemi  ValettaJan          3         16        9Feb          2         14        9Mar          2         10       10Apr          1          3       12May          4          3       15Jun          7          8       19Jul          9         12       21Aug          8          9       22Sep          6          5       20Oct          2          1       17Nov          1          6       14Dec          2         11       11>>>abs(df["Rovaniemi"])Jan    16Feb    14Mar    10Apr     3May     3Jun     8Jul    12Aug     9Sep     5Oct     1Nov     6Dec    11Name: Rovaniemi, dtype: int64

>>>importmath>>>classVector:...def__init__(self,*coordinates):...self.coordinates=coordinates......def__abs__(self):...origin=[0]*len(self.coordinates)...returnmath.dist(origin,self.coordinates)

>>>snowflake_velocity=Vector(0.42,1.5,0.87)>>>abs(snowflake_velocity)1.7841804841439108

>>>importmath>>>classVector:...def__init__(self,*coordinates):...self.coordinates=coordinates......def__abs__(self):...returnmath.hypot(*self.coordinates)>>>snowflake_velocity=Vector(0.42,1.5,0.87)>>>abs(snowflake_velocity)1.7841804841439108

Conclusion

Implementing formulas for an absolute value in Python is a breeze. However, Python already comes with the versatileabs() function, which lets you calculate the absolute value of various types of numbers, including integers, floating-point numbers, complex numbers, and more. You can also useabs() on instances of custom classes and third-party library objects.

In this tutorial, you learned how to:

• Implement theabsolute value function from scratch
• Use thebuilt-inabs() function in Python
• Calculate the absolute values ofnumbers
• Callabs() onNumPy arrays andpandas series
• Customize thebehavior ofabs() on objects

With this knowledge, you’re equipped with an efficient tool to calculate absolute values in Python.