# python – Getting distance between two points based on latitude/longitude

## python – Getting distance between two points based on latitude/longitude

**Update: 04/2018:** Vincenty distance is deprecated since GeoPy version 1.13 – you should use `geopy.distance.distance()`

instead!

The answers above are based on the Haversine formula, which assumes the earth is a sphere, which results in errors of up to about 0.5% (according to `help(geopy.distance)`

). Vincenty distance uses more accurate ellipsoidal models such as WGS-84, and is implemented in geopy. For example,

```
import geopy.distance
coords_1 = (52.2296756, 21.0122287)
coords_2 = (52.406374, 16.9251681)
print geopy.distance.vincenty(coords_1, coords_2).km
```

will print the distance of `279.352901604`

kilometers using the default ellipsoid WGS-84. (You can also choose `.miles`

or one of several other distance units).

**Edit:** Just as a note, if you just need a quick and easy way of finding the distance between two points, I strongly recommend using the approach described in Kurts answer below instead of re-implementing Haversine — see his post for rationale.

This answer focuses just on answering the specific bug OP ran into.

Its because in Python, all the trig functions use radians, not degrees.

You can either convert the numbers manually to radians, or use the `radians`

function from the math module:

```
from math import sin, cos, sqrt, atan2, radians
# approximate radius of earth in km
R = 6373.0
lat1 = radians(52.2296756)
lon1 = radians(21.0122287)
lat2 = radians(52.406374)
lon2 = radians(16.9251681)
dlon = lon2 - lon1
dlat = lat2 - lat1
a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
distance = R * c
print(Result:, distance)
print(Should be:, 278.546, km)
```

The distance is now returning the correct value of `278.545589351`

km.

#### python – Getting distance between two points based on latitude/longitude

For people (like me) coming here via search engine and just looking for a solution which works out of the box, I recommend installing `mpu`

. Install it via `pip install mpu --user`

and use it like this to get the haversine distance:

```
import mpu
# Point one
lat1 = 52.2296756
lon1 = 21.0122287
# Point two
lat2 = 52.406374
lon2 = 16.9251681
# What you were looking for
dist = mpu.haversine_distance((lat1, lon1), (lat2, lon2))
print(dist) # gives 278.45817507541943.
```

An alternative package is `gpxpy`

.

If you dont want dependencies, you can use:

```
import math
def distance(origin, destination):
Calculate the Haversine distance.
Parameters
----------
origin : tuple of float
(lat, long)
destination : tuple of float
(lat, long)
Returns
-------
distance_in_km : float
Examples
--------
>>> origin = (48.1372, 11.5756) # Munich
>>> destination = (52.5186, 13.4083) # Berlin
>>> round(distance(origin, destination), 1)
504.2
lat1, lon1 = origin
lat2, lon2 = destination
radius = 6371 # km
dlat = math.radians(lat2 - lat1)
dlon = math.radians(lon2 - lon1)
a = (math.sin(dlat / 2) * math.sin(dlat / 2) +
math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *
math.sin(dlon / 2) * math.sin(dlon / 2))
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
d = radius * c
return d
if __name__ == __main__:
import doctest
doctest.testmod()
```

The other alternative package is `haversine`

```
from haversine import haversine, Unit
lyon = (45.7597, 4.8422) # (lat, lon)
paris = (48.8567, 2.3508)
haversine(lyon, paris)
>> 392.2172595594006 # in kilometers
haversine(lyon, paris, unit=Unit.MILES)
>> 243.71201856934454 # in miles
# you can also use the string abbreviation for units:
haversine(lyon, paris, unit=mi)
>> 243.71201856934454 # in miles
haversine(lyon, paris, unit=Unit.NAUTICAL_MILES)
>> 211.78037755311516 # in nautical miles
```

They claim to have performance optimization for distances between all points in two vectors

```
from haversine import haversine_vector, Unit
lyon = (45.7597, 4.8422) # (lat, lon)
paris = (48.8567, 2.3508)
new_york = (40.7033962, -74.2351462)
haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS)
>> array([ 392.21725956, 6163.43638211])
```