NumPy Unit Vector

Normalize a nonzero NumPy vector by dividing it by its Euclidean norm: unit_vector = vector / np.linalg.norm(vector). For [3.0, 4.0], this gives [0.6, 0.8].

Define the Unit Vector

To turn a one-dimensional NumPy array into a unit vector, divide each component by the vector’s Euclidean norm:

u = v / ||v||

A unit vector has magnitude one. Dividing by the norm changes the vector’s length while preserving its direction. Positive scalar multiples of a vector produce the same normalized direction; multiplying by a negative scalar reverses the direction. This is useful when a calculation should depend on direction rather than the original magnitude.

Normalize with numpy.linalg.norm()

NumPy’s numpy.linalg.norm() calculates the Euclidean norm by default for a one-dimensional array. Run this example to create an array, divide it by its norm, and print the normalized components.

import numpy as np

vector = np.array([3.0, 4.0])
unit_vector = vector / np.linalg.norm(vector)
print(unit_vector)

[0.6 0.8]

For this input, the norm is 5, so each component is divided by 5. Use floating-point input when you want fractional components in the result. The result has the same one-dimensional shape as the input.

Calculate the Norm Manually

For a vector v with components v[i], the Euclidean norm is the square root of the sum of the squared components. In NumPy, that calculation is sqrt(sum(v ** 2)); dividing by it gives the same normalization formula. This version makes each mathematical step visible and can be useful when learning or adapting the calculation.

import numpy as np

vector = np.array([3.0, 4.0])
norm = np.sqrt(np.sum(vector ** 2))
unit_vector = vector / norm
print(unit_vector)

The manual formula shown here is for an ordinary one-dimensional real vector. For complex-valued arrays or other norm definitions, use the appropriate NumPy operation rather than assuming that squaring components gives the intended magnitude.

Handle Zero Vectors and Input Shape

A vector whose components are all zero has norm zero. Division by that norm is undefined, and the zero vector cannot be normalized into a unit vector because it has no direction. Choose an explicit policy for that input, such as raising a ValueError in a reusable function, or handling it before normalization in the calling code. Returning the original zero vector avoids division but does not make it a unit vector.

The examples above operate on one vector with shape (n,). If an array stores multiple vectors, its shape and the axis passed to a norm calculation determine what is normalized. For example, a two-dimensional array may store vectors as rows or columns; select the axis that represents each vector, then divide each row or column by its corresponding norm with broadcasting. Do not normalize an entire matrix as though it were one vector unless that is the intended mathematical operation.

Check the Result and Choose a Method

For a nonzero input, check that the normalized vector’s norm is approximately one, allowing for floating-point rounding. In code, use np.isclose(np.linalg.norm(unit_vector), 1.0) for the one-dimensional case. Exact equality is unsuitable for most floating-point calculations because rounded components may produce a norm extremely close to, rather than exactly, one.

Use numpy.linalg.norm() for the usual NumPy workflow: it states the intent clearly and supports selecting norm behavior for other tasks. Use the manual sum-of-squares formula when explaining the Euclidean calculation or when its steps are specifically needed. Both approaches require a nonzero norm, and neither makes the zero vector a unit vector. Keep the input shape and normalization axis explicit whenever working with more than one vector.