5 Best Ways to Find the Distance Between Two Cities in Python

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

This example defines the haversine function to calculate the distance. It converts the latitude and longitude of each city from degrees to radians, applies the Haversine formula, and then returns the distance in kilometers between New York City and Los Angeles.

Method 3: Using Scipy’s distance functions

The Scipy library includes functions for calculating distances between sets of points. The scipy.spatial.distance.cdist function, for example, computes distance between each pair of the two collections of inputs.

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

This code uses Scipy’s cdist function to compute the Euclidean distance between New York City and Los Angeles. The result is then multiplied by 111, which roughly converts degrees to kilometers. It’s important to note that this is a rough estimation, as it does not account for the curvature of the Earth.

Method 4: Using Google Maps API

Google Maps API provides reliable distances between locations. By utilizing the Directions API, you can request the distance between two cities. This method requires an API key and internet access, and offers a more realistic estimate of travel distance by road.

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

This snippet makes an HTTP GET request to the Google Maps Directions API and retrieves the driving distance between New York City and Los Angeles. The response is parsed as JSON and the specific distance is extracted and printed.

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

This compact one-liner uses the same geodesic function from the geopy library to calculate the distance between New York City and Los Angeles in kilometers, demonstrating Python’s ability to achieve significant functionality in a single line of code.

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from geopy.distance import geodesic

# Define the two city coordinates
city1 = (40.7128, -74.0060) # New York City
city2 = (34.0522, -118.2437) # Los Angeles

# Calculate the distance in kilometers
distance = geodesic(city1, city2).kilometers

print(f"The distance between the cities is {distance} km")

The output of this code snippet:

The distance between the cities is 3935.4771 km

This code snippet uses the geodesic function to calculate the distance between New York City and Los Angeles. It first defines tuples with latitude and longitude for each city, then calculates the distance, and prints out the result in kilometers.

Method 2: Using haversine formula

The Haversine formula is a mathematical equation used for calculating the distance between two points on the sphere given their longitudes and latitudes. The formula is particularly useful in navigation for its simplicity and its suitability for quick calculations.

Here’s an example:

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from geopy.distance import geodesic

# Define the two city coordinates
city1 = (40.7128, -74.0060) # New York City
city2 = (34.0522, -118.2437) # Los Angeles

# Calculate the distance in kilometers
distance = geodesic(city1, city2).kilometers

print(f"The distance between the cities is {distance} km")

The output of this code snippet:

The distance between the cities is 3935.4771 km

Method 2: Using haversine formula

Here’s an example:

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from geopy.distance import geodesic

# Define the two city coordinates
city1 = (40.7128, -74.0060) # New York City
city2 = (34.0522, -118.2437) # Los Angeles

# Calculate the distance in kilometers
distance = geodesic(city1, city2).kilometers

print(f"The distance between the cities is {distance} km")

The output of this code snippet:

The distance between the cities is 3935.4771 km

Method 2: Using haversine formula

Here’s an example:

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from geopy.distance import geodesic

# Define the two city coordinates
city1 = (40.7128, -74.0060) # New York City
city2 = (34.0522, -118.2437) # Los Angeles

# Calculate the distance in kilometers
distance = geodesic(city1, city2).kilometers

print(f"The distance between the cities is {distance} km")

The output of this code snippet:

The distance between the cities is 3935.4771 km

Method 2: Using haversine formula

Here’s an example:

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

💡 Problem Formulation: You want to calculate the distance between two cities. For example, you have the names or coordinates of two cities, and you need a program to find the approximate distance in kilometers or miles. The output should be a numerical value representing the distance between these cities.

Method 1: Using geopy library

The geopy library in Python can be used to calculate geographical distances. It offers a simple interface to access various geocoding services and calculate distances using different algorithms. To find the distance between two cities, you can use the geodesic function from the geopy.distance module, which is based on the WGS84 ellipsoid.

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners

from geopy.distance import geodesic

# Define the two city coordinates
city1 = (40.7128, -74.0060) # New York City
city2 = (34.0522, -118.2437) # Los Angeles

# Calculate the distance in kilometers
distance = geodesic(city1, city2).kilometers

print(f"The distance between the cities is {distance} km")

The output of this code snippet:

The distance between the cities is 3935.4771 km

Method 2: Using haversine formula

Here’s an example:

from math import radians, cos, sin, asin, sqrt

def haversine(lon1, lat1, lon2, lat2):
    # Convert degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # Apply Haversine formula
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    
    # Radius of Earth in kilometers
    r = 6371
    
    return c * r

# New York City to Los Angeles coordinates
distance = haversine(-74.0060, 40.7128, -118.2437, 34.0522)

print(f"The distance between the cities is {distance:.2f} km")

The output of this code snippet:

The distance between the cities is 3940.06 km

Method 3: Using Scipy’s distance functions

Here’s an example:

import numpy as np
from scipy.spatial import distance

# Coordinates in the format (latitude, longitude)
coords = np.array([[40.7128, -74.0060],  # New York City
                   [34.0522, -118.2437]]) # Los Angeles

# Calculate the distance in kilometers (using Euclidean method, adjust accordingly)
dist_matrix = distance.cdist(coords, coords, 'euclidean')
distance_km = dist_matrix[0][1] * 111 # Conversion factor

print(f"The distance between the cities is {distance_km:.2f} km")

The output of this code snippet:

The distance between the cities is 3962.17 km

Method 4: Using Google Maps API

Here’s an example:

import requests
import json

# Google Maps API endpoint
endpoint = "https://maps.googleapis.com/maps/api/directions/json?"

# Your API key (replace with your actual API key)
api_key = "YOUR_API_KEY"

# Parameters for New York City to Los Angeles
origin = "New York City"
destination = "Los Angeles"

# Make a request to the API
response = requests.get(endpoint + f"origin={origin}&destination={destination}&key={api_key}")
directions = response.json()

# Extract distance from the response
distance = directions["routes"][0]["legs"][0]["distance"]["text"]

print(f"The driving distance between the cities is {distance}")

The output of this code snippet:

The driving distance between the cities is 2,775 mi

Bonus One-Liner Method 5: Using Python’s geodesic and tuple unpacking

A one-liner version utilizing the geodesic method from the geopy library combined with tuple unpacking for compact code.

Here’s an example:

from geopy.distance import geodesic

# One-liner to calculate the distance
distance = geodesic(('40.7128', '-74.0060'), ('34.0522', '-118.2437')).km

print(f"Distance: {distance} km")

The output of this code snippet:

Distance: 3935.4771 km

Summary/Discussion

Method 1: geopy library. Provides a straightforward and readable way to calculate distances. Requires an external library. Good for geographic calculations over longer distances.
Method 2: Haversine formula. A direct implementation of the formula that doesn’t rely on external libraries. More cumbersome than using geopy, but good for educational purposes or environments where installing external libraries is not possible.
Method 3: Scipy’s distance functions. Useful for multiple distance calculations and scientific computing. Requires the Scipy library, and the geographical distance calculation needs a conversion factor, hence less precise for geographical distances.
Method 4: Google Maps API. Provides accurate road distances and is maintained by Google, making it reliable. However, it requires an internet connection, an API key, and is subject to usage limits.
Bonus Method 5: Python’s geodesic one-liner. Offers a quick and clean approach for distance calculations, harnessing the power of Python for concise code. Still requires the geopy library and is less readable for beginners