5 Best Ways to Calculate the Hypotenuse of a Right Triangle in Python

Rate this post

πŸ’‘ Problem Formulation: In Python, given the lengths of the two legs a and b of a right triangle, the goal is to compute the length of the hypotenuse c. For example, if a = 3 and b = 4, the desired output is c = 5, based on the Pythagorean theorem.

Method 1: Using the math module

This method employs Python’s built-in math module which provides the sqrt function for square root calculation, an essential operation to find the hypotenuse in a right triangle using the Pythagorean theorem c = sqrt(a^2 + b^2).

Here’s an example:

import math

def calculate_hypotenuse(a, b):
    return math.sqrt(a**2 + b**2)

hypotenuse = calculate_hypotenuse(3, 4)



This code snippet defines a function calculate_hypotenuse that takes the legs a and b as arguments, squares them, sums them, and finally takes the square root of the sum to return the length of the hypotenuse.

Method 2: Using the power operator

Utilize Python’s power operator ** to calculate powers and square roots. To find a square root with the operator, raise a number to the power of 0.5.

Here’s an example:

def hypotenuse(a, b):
    return (a**2 + b**2)**0.5

print(hypotenuse(5, 12))



The function hypotenuse calculates the length of the hypotenuse by elevating the sum of squares of a and b to the power of 0.5, which is equivalent to taking the square root.

Method 3: Using the cmath module for complex numbers

For scenarios where one or both legs of the triangle might be complex numbers, Python’s cmath module provides tools to operate with complex numbers, including finding their magnitude using the abs function.

Here’s an example:

import cmath

def complex_hypotenuse(a, b):
    return abs(complex(a, b))

print(complex_hypotenuse(3, 4j))



This snippet defines a function that calculates the hypotenuse even when the legs are complex numbers by creating a complex number from the legs and using the abs function to get its magnitude, which serves as the hypotenuse.

Method 4: Using numpy for vectorized operations

For calculations involving arrays of triangle sides, numpy offers a highly performant vectorized approach. The numpy library is efficient for handling large datasets or computing the hypotenuses of many triangles simultaneously.

Here’s an example:

import numpy as np

legs = np.array([[3, 4], [5, 12]])
hypotenuses = np.sqrt(np.sum(legs**2, axis=1))


[ 5. 13.]

The code uses numpy to calculate the hypotenuses for an array of leg pairs. Squaring each element, summing them along an axis, and taking the square root, this snippet operates on the entire array at once, showcasing numpy‘s strength in array operations.

Bonus One-Liner Method 5: Using the hypot() function

The math.hypot() function provides a straightforward one-liner to directly compute the hypotenuse without manual squaring and square rooting, abstracting the Pythagorean theorem calculation.

Here’s an example:

from math import hypot

print(hypot(8, 15))



The hypot() function from the math module takes the two legs as arguments and returns the hypotenuse, offering a clean and concise built-in solution to the problem.


  • Method 1: Using the math module. Highly readable. Requires importing math.
  • Method 2: Using the power operator. No imports needed. Slightly less intuitive for those unfamiliar with math operations in Python.
  • Method 3: Using the cmath module for complex numbers. Allows for complex numbers. Overkill for simple use-cases.
  • Method 4: Using numpy for vectorized operations. Ideal for batch operations. Requires numpy installation.
  • Method 5: Using the hypot() function. Simplest and most elegant solution. Obscures the underlying computation mechanics.