**π‘ Problem Formulation:** Converting angles from radians to degrees is a common requirement in various fields including mathematics, physics, and computer science. The task is to take an array of angles in radians, such as `[0, 1.5708, 3.14159]`

, and convert each element of the array into degrees, resulting in a new array like `[0, 90, 180]`

. The purpose of this article is to demonstrate five methods to perform this conversion efficiently in Python.

## Method 1: Using the math.degrees() Function

Python’s standard library provides the `math.degrees()`

function which converts a single angle from radians to degrees. To convert an array of radians, you can apply this function to each element using a loop or a list comprehension.

Here’s an example:

import math radian_array = [0, 1.5708, 3.14159] degree_array = [math.degrees(radian) for radian in radian_array] print(degree_array)

Output: `[0.0, 89.99984747309584, 179.9997549261917]`

Using a list comprehension along with the `math.degrees()`

function provides a straightforward and readable way to convert each radian value to degrees. This method is directly supported by the Python standard library and does not require any external modules.

## Method 2: Using numpy.deg2rad() Function

The NumPy library offers vectorized operations which can be highly efficient on large arrays. The `numpy.degrees()`

function converts each element of the input array from radians to degrees at once.

Here’s an example:

import numpy as np radian_array = np.array([0, 1.5708, 3.14159]) degree_array = np.degrees(radian_array) print(degree_array)

Output: `[ 0. 89.99984747 180. ]`

This snippet leverages NumPy’s array processing capabilities to perform the conversion. It’s an excellent approach for handling large datasets due to NumPy’s performance optimizations. NumPy must be installed separately as it does not come with the default Python library.

## Method 3: Using a Custom Conversion Function

For those who prefer to avoid external dependencies like NumPy or simply want to practice writing their own functions, creating a custom conversion function is a nice exercise. The rad-to-degree formula (degrees = radians * 180 / Ο) is easy to implement in a custom function.

Here’s an example:

def radians_to_degrees(radian_array): return [radian * 180 / math.pi for radian in radian_array] radian_array = [0, 1.5708, 3.14159] degree_array = radians_to_degrees(radian_array) print(degree_array)

Output: `[0.0, 89.99984747309584, 179.9997549261917]`

This code defines a function `radians_to_degrees()`

that applies the conversion formula using a list comprehension for the given array of radians. This custom function method works independently of any external library and is very clear and customizable.

## Method 4: Using map() with math.degrees()

The `map()`

function is a built-in feature in Python that applies a given function to each item of an iterable (like a list) and returns a map object. For radian-to-degree conversion, it can be paired with `math.degrees()`

.

Here’s an example:

import math radian_array = [0, 1.5708, 3.14159] degree_array = list(map(math.degrees, radian_array)) print(degree_array)

Output: `[0.0, 89.99984747309584, 179.9997549261917]`

The `map()`

function is used here to execute the `math.degrees()`

function on each element of the radian array, resulting in a map object that is then converted into a list. This is a very Pythonic approach and works well with the functional programming style.

## Bonus One-Liner Method 5: Using Lambda with map()

Combining a lambda function with `map()`

can provide a quick one-liner for the conversion. A lambda function allows you to define a simple function in a single expression without formally defining a function with `def`

.

Here’s an example:

radian_array = [0, 1.5708, 3.14159] degree_array = list(map(lambda r: r * 180 / math.pi, radian_array)) print(degree_array)

Output: `[0.0, 89.99984747309584, 179.9997549261917]`

In this snippet, a lambda function performs the radian to degree conversion for each element of the array. It offers a concise solution that can be handy for quick scripts or when embedding the conversion within other expressions.

## Summary/Discussion

**Method 1: Using math.degrees().**Strengths: Simple, readable, and part of the standard library. Weaknesses: May be slower for large datasets comparative to vectorized operations.**Method 2: Using numpy.deg2rad().**Strengths: Very efficient on large arrays due to NumPy’s optimized performance. Weaknesses: Requires installation of NumPy and may be overkill for small arrays.**Method 3: Custom Conversion Function.**Strengths: Does not depend on external libraries and is easily customizable. Weaknesses: May not be as concise or optimized as library functions.**Method 4: Using map() with math.degrees().**Strengths: Elegant functional programming approach, concise. Weaknesses: Creates a map object which needs to be explicitly cast to a list.**Bonus Method 5: Lambda with map().**Strengths: Extremely concise one-liner, good for quick conversions. Weaknesses: Lambda function might be less readable for complex operations.