CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


In this lesson, you'll learn how to find the distance between two points using several different methods.

Distance Formula

Now that you've written these three distance formulas yourself, let's look at how to use them using Python's <a href="https://www.scipy.org/" target="_blank">SciPy</a> library:

- Euclidean Distance `.euclidean()`
- Manhattan Distance `.cityblock()`
- Hamming Distance `.hamming()`

There are a few noteworthy details to talk about:

First, the `scipy` implementation of Manhattan distance is called `cityblock()`. Remember, computing Manhattan distance is like asking how many blocks away you are from a point.

Second, the `scipy` implementation of Hamming distance will always return a number between `0` an `1`. Rather than summing the number of differences in dimensions, this implementation sums those differences and then divides by the total number of dimensions. For example, in your implementation, the Hamming distance between `[1, 2, 3]` and `[7, 2, -10]` would be `2`. In `scipy`'s version, it would be `2/3`.

SciPy Distances

**Manhattan Distance** is extremely similar to Euclidean distance. Rather than summing the squared difference between each dimension, we instead sum the absolute value of the difference between each dimension. It's called Manhattan distance because it's similar to how you might navigate when walking city blocks. If you've ever wondered "how many blocks will it take me to get from point A to point B", you've computed the Manhattan distance. 

The equation is shown below:

```tex
\mid a_1 - b_1 \mid + \mid a_2 - b_2 \mid + \ldots + \mid a_n - b_n \mid
```

Note that Manhattan distance will always be greater than or equal to Euclidean distance. Take a look at the image below visualizing Manhattan Distance:

<img src="https://content.codecademy.com/programs/machine-learning/distance-formula/manhattan.svg" alt="The Manhattan distance between two points."></img>

```tex
d = \mid a_1 - b_1 \mid + \mid a_2 - b_2 \mid
```



Manhattan Distance

**Hamming Distance** is another slightly different variation on the distance formula. Instead of finding the difference of each dimension, Hamming distance only cares about whether the dimensions are exactly equal. When finding the Hamming distance between two points, add one for every dimension that has different values.

Hamming distance is used in spell checking algorithms. For example, the Hamming distance between the word "there" and the typo "thete" is one. Each letter is a dimension, and each dimension has the same value except for one.




Hamming Distance

**Euclidean Distance** is the most commonly used distance formula. To find the Euclidean distance between two points, we first calculate the squared distance between each dimension. If we add up all of these squared differences and take the square root, we've computed the Euclidean distance. 

Let's take a look at the equation that represents what we just learned:

```tex
\sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\ldots+(a_n - b_n)^2}
```

The image below shows a visual of Euclidean distance being calculated:

<img src="https://content.codecademy.com/programs/machine-learning/distance-formula/euclidean.svg" alt="The Euclidean distance between two points."></img>

```tex
d = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2}
```

Euclidean Distance

In this lesson, you will learn three different ways to define the distance between two points:

1. Euclidean Distance
2. Manhattan Distance
3. Hamming Distance

Before diving into the distance formulas, it is first important to consider how to represent points in your code. 

In this exercise, we will use a list, where each item in the list represents a dimension of the point. For example, the point (5, 8) could be represented in Python like this:

```py
pt1 = [5, 8]
```

Points aren't limited to just two dimensions. For example, a five-dimensional point could be represented as `[4, 8, 15, 16, 23]`.

Ultimately, we want to find the distance between two points. We'll be writing functions that look like this:

```py
distance([1, 2, 3], [5, 8, 9])
```

Note that we can only find the difference between two points if they have the same number of dimensions!