计算空间任意两个坐标点之间距离的Python程序脚本
两个坐标点之间的距离公式编程
两个坐标点之间的距离公式编程
在计算机编程中，经常需要计算两个坐标点之间的距离。
这个问题在许多领域都有应用，比如地理信息系统（GIS）、导航、游戏开发等。
本文将介绍两个坐标点之间的距离公式，并以程序代码实现。
在二维平面上，我们可以用两个数值来表示一个坐标点，通常用(x, y)表示。
假设有两个坐标点A(x1, y1)和B(x2, y2)，我们要计算它们之间的距离。
这个问题可以通过欧几里得距离公式来解决。
欧几里得距离公式
欧几里得距离也称为直线距离，是空间中两个点之间的最短距离。
对于平面上的两个点A(x1, y1)和B(x2, y2)，欧几里得距离可以用以下公式计算：
distance = sqrt((x2 - x1)^2 + (y2 - y1)^2)
其中，^表示乘方运算，sqrt()表示开方运算。
编程实现
以下是使用Python编程语言实现欧几里得距离公式的代码：
```python import math
def calculate_distance(x1, y1, x2, y2): distance = math.sqrt((x2 - x1)2 + (y2 -
y1)2) return distance
例子：计算坐标点A(1, 2)和B(4, 6)之间的距离
x1, y1 = 1, 2 x2, y2 = 4, 6 distance = calculate_distance(x1, y1, x2, y2) print(。
用坐标怎么计算出距离和距离
用坐标怎么计算出距离和距离在几何学中，计算两点之间的距离是一项常见的任务。
当给定两个点的坐标时，我们可以使用数学公式来计算它们之间的距离。
距离指的是点与点之间的间隔，而方位角是指从一个点指向另一个点的方向。
计算距离假设你有两个点A(x1, y1)和B(x2, y2)，我们可以使用以下公式来计算这两个点之间的距离：$distance = \\sqrt{(x2 - x1)^2 + (y2 - y1)^2}$这个公式基于勾股定理，也称为欧几里得距离。
我们可以通过将坐标代入此公式来找到点A和点B之间的距离。
例如，假设A的坐标是(3, 4)，B的坐标是(7, 8)。
我们可以将这些值代入公式：$distance = \\sqrt{(7 - 3)^2 + (8 - 4)^2}$$distance = \\sqrt{16 + 16}$$distance = \\sqrt{32}$$distance \\approx 5.66$因此，点A和点B之间的距离约为5.66。
计算方位角方位角是指从一个点指向另一个点的方向。
为了计算方位角，我们可以使用以下公式：$angle = \\arctan\\left(\\frac{y2 - y1}{x2 - x1}\\right)$这个公式计算的是从点A指向点B的角度，以弧度为单位。
我们可以通过将坐标代入该公式来找到点A指向点B的方位角。
继续以上面的例子，我们假设A的坐标是(3, 4)，B的坐标是(7, 8)。
我们可以将这些值代入公式：$angle = \\arctan\\left(\\frac{8 - 4}{7 - 3}\\right)$$angle = \\arctan\\left(\\frac{4}{4}\\right)$$angle = \\arctan\\left(1\\right)$$angle \\approx 45°$因此，点A指向点B的方位角约为45°。
已知两个坐标点求距离
已知两个坐标点求距离两个坐标点之间的距离是计算两点直线距离的长度。
在二维平面上，我们可以通过使用勾股定理来计算这个距离。
该定理表明，对于平面上的任意两点，我们可以通过计算它们的坐标差值，并应用勾股定理公式来求解它们之间的距离。
假设有两个坐标点A和B，它们的坐标分别为A(x1, y1)和B(x2, y2)。
我们可以使用以下公式来计算这两个点之间的距离：距离= √((x2 - x1)² + (y2 - y1)²)这个公式涉及到两个步骤。
首先，我们计算x坐标的差值，并将其平方；接下来，我们计算y坐标的差值，并将其平方。
然后将这两个平方值相加，并将其平方根。
最后的结果就是我们所求的两个坐标点之间的距离。
举个例子，假设我们有两个坐标点A(3, 4)和B(7, 9)。
我们可以使用上述公式计算这两点之间的距离：距离= √((7 - 3)² + (9 - 4)²) = √(4² + 5²) = √(16 + 25) = √41 ≈ 6.403所以点A和点B之间的距离约为6.403个单位。
在实际应用中，这个距离公式常常用于计算两个物体之间的距离、两个地点之间的距离等。
它是计算几何中的基础概念之一。
需要注意的是，这个距离公式适用于二维平面上的点，如果是在三维空间或更高维空间上的坐标点，则需要使用相应的距离公式来计算。
值得一提的是，在计算机编程领域，我们可以借助编程语言提供的函数或库来计算两个坐标点之间的距离。
不同的编程语言可能提供不同的函数接口，但基本原理是相同的，即计算两点之间的距离。
总结：已知两个坐标点，我们可以通过应用勾股定理来计算它们之间的距离。
这个距离公式适用于二维平面上的点，计算两点之间的x和y坐标差值的平方和，然后将其平方根得到最终的距离。
这个公式在计算几何和计算机编程中被广泛应用。
无论是测量物体之间的距离还是计算两个地点之间的距离，这个距离公式都能提供准确的结果。
拓扑学小实验
拓扑学小实验拓扑学是现代数学的一个重要分支，研究的是空间上图形的形状与度量，以及它们之间的变形关系。
在实际应用中，拓扑学涉及到数据管理、机器学习、计算机辅助设计等领域。
本文将介绍一项基于代码实现的拓扑学小实验，让我们一步步感受拓扑学的奥秘。
一、准备工作首先需要安装Python编程环境，并安装拓扑学相关的第三方库：Numpy、Scipy、matplotlib等。
安装完成后，可以打开编辑器准备进行代码编写。
二、导入数据在拓扑学实验中，需要导入的是一个二维平面上的数据集，可以使用Python中的random库生成一些随机的数据点。
首先，定义一个函数用于生成坐标系范围内的随机数，这里以[-1, 1]之间的坐标为例：```pythonimport randomdef generate_points(num):points = []for i in range(num):x = 2 * random.random() - 1y = 2 * random.random() - 1points.append((x, y))return points```生成随机数据点后，可以使用matplotlib库绘制可视化图形，代码如下：```pythonimport matplotlib.pyplot as pltpoints = generate_points(50) # 生成50个随机数据点x = [p[0] for p in points]y = [p[1] for p in points]plt.scatter(x, y)plt.show()```运行程序后，我们能看到一组随机的散点图，代表二维平面上的一些数据点。
三、创建关联矩阵接下来，需要计算数据点之间的关系矩阵。
将所有数据点两两之间的距离计算出来，并将其保存在矩阵中。
这里使用SciPy库中的spatial.distance_matrix函数，代码如下：```pythonfrom scipy.spatial import distance_matrixdist_matrix = distance_matrix(points, points)```这段代码将返回一个50x50的矩阵，其中每个元素是两个对应数据点之间的欧几里得距离。
二个坐标点之间的距离怎么算出来的
二个坐标点之间的距离怎么算出来的在数学和计算中，计算两个坐标点之间的距离是非常常见且有很多应用的问题。
这个问题可以被应用在地理测量、导航系统、图像处理等领域中。
在本文中，我们将讨论两个坐标点之间的距离是如何计算的。
直线距离的计算首先，我们来看最常见和简单的情况，即计算两个坐标点之间的直线距离。
直线距离也被称为欧几里得距离或直角三角形的斜边长度，可以通过勾股定理计算得出。
假设我们有两个坐标点A和B，分别表示为A(x1, y1)和B(x2, y2)。
直线距离可以通过以下公式计算：距离= √((x2 - x1)^2 + (y2 - y1)^2)其中，^ 表示乘方运算，√ 表示开方运算。
这个公式通过计算两个坐标点在水平和垂直方向的差距，然后使用勾股定理计算直线距离。
实际例子让我们通过一个实际例子来说明直线距离的计算。
假设我们有两个坐标点A(3, 4)和B(7, 1)。
我们可以使用上面的公式来计算这两个点之间的距离：距离= √((7 - 3)^2 + (1 - 4)^2)= √(4^2 + (-3)^2)= √(16 + 9)= √25= 5因此，点A和点B之间的距离为5个单位长度。
曼哈顿距离的计算除了直线距离，还有一种常见的距离计算方式称为曼哈顿距离。
曼哈顿距离也被称为城市街区距离，它是在一个网格上移动的最短距离。
曼哈顿距离可以通过以下公式计算：距离 = |x2 - x1| + |y2 - y1|其中，| | 表示取绝对值的运算。
这个公式计算了两个坐标点在水平和垂直方向的差距，并将它们相加得到最终的距离。
实际例子继续以前面的例子来计算曼哈顿距离。
我们有两个坐标点A(3, 4)和B(7, 1)，我们可以使用曼哈顿距离公式来计算它们之间的距离：距离 = |7 - 3| + |1 - 4|= |4| + |-3|= 4 + 3= 7因此，点A和点B之间的曼哈顿距离为7个单位长度。
总结通过本文，我们了解了如何计算两个坐标点之间的距离。
坐标与距离的换算
package com.logistics.util;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.math.BigDecimal;import .URL;import .URLEncoder;import java.util.HashMap;import java.util.Map;import ng.StringUtils;public class LatitudeUtil {public static final String KEY_1 = "ChwEVlrmoje34iED20piImPc";/*** 根据地址查坐标* @param address 地址,格式:深圳市罗湖区火车站** @return*/// @param key 申请ak（即获取密钥），若无百度账号则首先需要注册百度账号。
public static Map<String,String> getGeocoderLatitude(String address){BufferedReader in = null;// if(CommonUtil.NotEmpty(key)){// return null;// }try {address = URLEncoder.encode(address, "UTF-8");URL tirc = new URL("/geocoder?address="+ address +"&output=json&key="+ KEY_1);in = new BufferedReader(new InputStreamReader(tirc.openStream(),"UTF-8"));String res;StringBuilder sb = new StringBuilder("");while((res = in.readLine())!=null){sb.append(res.trim());}String str = sb.toString();Map<String,String> map = new HashMap<String,String>();if(StringUtils.isNotEmpty(str)){int lngStart = str.indexOf("lng\":");int lngEnd = str.indexOf(",\"lat");int latEnd = str.indexOf("},\"precise");if(lngStart > 0 && lngEnd > 0 && latEnd > 0){String lng = str.substring(lngStart+5, lngEnd);String lat = str.substring(lngEnd+7, latEnd);map.put("lng", lng);map.put("lat", lat);return map;}}}catch (Exception e) {e.printStackTrace();}finally{try {in.close();} catch (IOException e) {e.printStackTrace();}}return null;}/*** 计算地球上任意两点(经纬度)距离** @param lon1* 第一点经度* @param lat1* 第一点纬度* @param lon2* 第二点经度* @param lat2* 第二点纬度* @return 返回距离单位：千米*/public static double getDistatce(double lon1, double lat1, double lon2, double lat2) { double R = 6371;double distance = 0.0;double dLat = (lat2 - lat1) * Math.PI / 180;double dLon = (lon2 - lon1) * Math.PI / 180;double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)+ Math.cos(lat1 * Math.PI / 180)* Math.cos(lat2 * Math.PI / 180) * Math.sin(dLon / 2)* Math.sin(dLon / 2);distance = (2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))) * R;return distance;}/*** 计算地球上任意两点(经纬度)距离** @param long1* 第一点经度* @param lat1* 第一点纬度* @param long2* 第二点经度* @param lat2* 第二点纬度* @return 返回距离单位：米*/public static double Distance(double long1, double lat1, double long2,double lat2) {double a, b, R;R = 6378137; // 地球半径lat1 = lat1 * Math.PI / 180.0;lat2 = lat2 * Math.PI / 180.0;a = lat1 - lat2;b = (long1 - long2) * Math.PI / 180.0;double d;double sa2, sb2;sa2 = Math.sin(a / 2.0);sb2 = Math.sin(b / 2.0);d = 2* R* Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(lat1)* Math.cos(lat2) * sb2 * sb2));return d;}/*** 查找一定范围内的经纬度值* 传入值：经度纬度查找半径(m)* 返回值：最小经度、纬度，最大经度、纬度113.957541,22.549392 朗峰大厦*/public static Map<String, Double> getAround(Double lon,Double lat,Double raidus) {Double PI = 3.14159265; // 圆周率Double EARTH_RADIUS = 6378137d; // 地球半径Double RAD = Math.PI / 180.0; // 弧度Double longitude = lon; //经度Double latitude = lat; //纬度Double degree = (24901*1609)/360.0;Double raidusMile = raidus; //距离Double dpmLat = 1/degree;Double radiusLat = dpmLat*raidusMile;Double minLat = latitude - radiusLat; //最小纬度Double maxLat = latitude + radiusLat; //最大纬度Double mpdLng = degree*Math.cos(latitude * (PI/180));Double dpmLng = 1 / mpdLng;Double radiusLng = dpmLng*raidusMile;Double minLng = longitude - radiusLng; //最小经度Double maxLng = longitude + radiusLng; //最大经度Map<String, Double> m = new HashMap<String, Double>();m.put("minLng", minLng); //最小经度m.put("minLat", minLat); //最小纬度m.put("maxLng", maxLng); //最大经度m.put("maxLat", maxLat); //最大纬度System.err.println("最小经度:"+minLng);System.err.println("最小纬度:"+minLat);System.err.println("最大经度:"+maxLng);System.err.println("最大纬度:"+maxLat);return m;}public static void main(String args[]){Map<String, String> json = LatitudeUtil.getGeocoderLatitude("深圳罗湖火车站"); // Map<String, String> json = LatitudeUtil.getGeocoderLatitude("tl");System.out.println("lng : "+json.get("lng"));System.out.println("lat : "+json.get("lat"));double d1 = getDistatce(113.993941, 22.596919, 114.156395, 22.581934);double d2 = Distance(113.993941, 22.596919, 114.156395, 22.581934);System.out.println("d1 -> " + d1 + ", d2 -> " + d2);double f = 111.234;BigDecimal bg = new BigDecimal(f);double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();System.out.println(f1);}}。
测地线计算 python程序
测地线计算 python程序测地线是指在地球上连接两个点时，所采用的最短路径，它是球面上的一条曲线。
在地理学、地图学、导航学等领域中，测地线具有重要的应用价值。
本文将介绍如何使用Python编程计算测地线。
我们需要导入Python的geopy库，它是一个用于处理地理信息的库。
可以通过以下命令安装geopy库：```pip install geopy```安装好geopy库后，我们就可以开始编写计算测地线的Python程序了。
我们需要确定两个点的经纬度坐标。
假设我们要计算从纽约（纬度：40.7128，经度：-74.0060）到伦敦（纬度：51.5074，经度：-0.1278）之间的测地线。
```pythonfrom geopy.distance import geodesic# 纽约的经纬度坐标new_york = (40.7128, -74.0060)# 伦敦的经纬度坐标london = (51.5074, -0.1278)# 计算测地线距离distance = geodesic(new_york, london).milesprint("从纽约到伦敦的测地线距离为：", distance, "英里")```在这段代码中，我们首先导入了geopy库的geodesic函数，它用于计算两个点之间的测地线距离。
然后，我们定义了纽约和伦敦的经纬度坐标，并使用geodesic函数计算了它们之间的测地线距离。
最后，我们将结果打印出来。
运行这段代码，我们可以得到从纽约到伦敦的测地线距离为3455.868973656787英里。
除了计算测地线距离，geopy库还提供了其他一些功能，比如计算两个点之间的切比雪夫距离、哈曼顿距离等。
我们可以根据具体的需求选择合适的函数进行计算。
除了geopy库，Python还有其他一些用于处理地理信息的库，比如geopandas、pyproj等。
坐标点的距离如何计算
坐标点的距离如何计算在地图定位、导航、地理信息系统等领域中，计算两个坐标点之间的距离是一项基本的任务。
无论是计算两个地理位置之间的直线距离，还是计算驾车路径上的实际距离，都离不开坐标点距离的计算。
本文将介绍几种常用的计算坐标点距离的方法。
1. 平面坐标系在平面坐标系中，我们可以使用两点之间的欧几里得距离来计算点的距离。
欧几里得距离是两点间的直线距离，用勾股定理来计算。
设两点的坐标分别为(x1, y1)和(x2, y2)，则它们之间的距离d可以通过以下公式计算：d = \\sqrt{(x2 - x1)^2 + (y2 - y1)^2}这个公式是通过计算两点在x轴和y轴上的距离差的平方和，再开平方根得到的。
这种方式适用于平面上的二维点的距离计算。
2. 球面坐标系在地理信息系统中，常常需要计算两个地理位置之间的距离。
由于地球是一个近似于椭球的三维物体，所以球面距离计算需要考虑地球的曲率。
常用的球面距离计算方法有以下两种：2.1 大圆距离大圆距离是计算地球上两个点之间最短路径的方法。
这种距离计算方式需要使用经纬度坐标。
设两点的经纬度分别为(lat1, lon1)和(lat2, lon2)，则它们之间的大圆距离d可以通过以下公式计算：d = R * arccos(sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(l on2 - lon1))这里R是地球的半径，取平均半径约为6371公里。
这种方法使用了球面三角关系，通过计算两点的纬度和经度之差的余弦值，再使用反余弦函数计算出最终的距离。
2.2 Haversine公式Haversine公式是大圆距离的一种近似计算方法，用于计算球面上两点之间的距离。
设两点的经纬度分别为(lat1, lon1)和(lat2, lon2)，则它们之间的Haversine距离d可以通过以下公式计算：a = sin^2((lat2 - lat1) / 2) + cos(lat1) * cos(lat2) * sin^2((lon2 - lon1) / 2)c = 2 * atan2(sqrt(a), sqrt(1 - a))d = R * c其中，a是一个中间变量，c是两点之间的角距离，d是最终的距离。
欧氏距离 python
欧氏距离什么是欧氏距离？欧氏距离是用于计算样本之间相似性或距离的一种常用方法。
它是从欧几里得空间中两点之间的直线距离概念推广而来。
在机器学习和数据挖掘的领域，欧氏距离经常被用作聚类、分类、相似性度量等任务中的基本工具。
计算欧氏距离的公式欧氏距离的计算公式可以简单地表示为：其中和是两个样本点，、和是样本点在不同维度上的特征值。
该公式计算的是两个样本点之间的直线距离。
欧氏距离的应用1. 聚类分析在聚类分析中，欧氏距离被广泛应用于计算样本之间的相似性。
通过计算样本点之间的欧氏距离，可以将相似的样本点归为同一类别。
聚类分析可以帮助我们发现数据集中的潜在模式和结构。
2. 特征选择欧氏距离也可以用于特征选择。
在特征选择过程中，我们可以计算每个特征与目标变量之间的欧氏距离，以确定特征与目标变量之间的相关性。
通过选择与目标变量具有较小欧氏距离的特征，可以提高机器学习模型的准确性和效率。
3. 图像处理在图像处理领域，欧氏距离被用于计算图像之间的相似性。
通过将图像表示为特征向量，可以使用欧氏距离来计算不同图像之间的相似性程度。
这在图像搜索、图像分类和人脸识别等任务中得到广泛应用。
4. 异常检测欧氏距离可以用于检测数据中的异常点。
通过计算样本点与数据集中其他样本点的欧氏距离，我们可以找到与其他样本点相差较远的异常点。
这对于检测系统故障、欺诈行为和异常行为非常有用。
欧氏距离的局限性尽管欧氏距离在许多应用中表现良好，但它也存在一些局限性：1. 敏感性欧氏距离对异常值和噪声非常敏感。
如果数据集中存在离群点或噪声点，欧氏距离可能会导致错误的相似性度量。
这可能会对聚类分析和异常检测等任务产生不良影响。
2. 维度灾难在高维空间中，样本点之间的欧氏距离会变得越来越接近。
这被称为维度灾难问题。
维度灾难会导致欧氏距离无法准确地度量样本点之间的差异性，从而影响了聚类和分类等任务的表现。
3. 特征权重问题在计算欧氏距离时，所有特征被视为等权重。
计算两坐标点之间的距离公式
计算两坐标点之间的距离公式在地理学、数学和计算机科学中，计算两个坐标点之间的距离是一项常见的任务。
无论是用于导航应用程序、地图服务还是其他领域，计算坐标点之间的距离是处理空间数据的基本操作之一。
1. Euclidean距离欧几里得距离是最常见的计算两个坐标点之间距离的方法。
它是通过计算两个坐标点之间的直线距离来衡量的，即我们所熟悉的直线距离。
假设我们有两个点A（x1, y1）和B（x2, y2）。
我们可以使用欧几里得距离公式来计算它们之间的直线距离：distance = sqrt((x2 - x1)^2 + (y2 - y1)^2)其中，sqrt代表平方根。
2. 曼哈顿距离曼哈顿距离是另一种常见的计算两个坐标点之间距离的方法。
它是通过计算两个点在各个坐标轴上的距离之和来衡量的。
假设我们有两个点A（x1, y1）和B（x2, y2）。
我们可以使用曼哈顿距离公式来计算它们之间的距离：distance = |x2 - x1| + |y2 - y1|其中，|x|代表x的绝对值。
3. 海伦公式海伦公式（也称为三角形的面积公式）可以用于计算任意两个坐标点之间的距离。
这个公式是基于三角形的边长和周长之间的关系建立的。
假设我们有两个点A（x1, y1）和B（x2, y2）。
我们可以使用海伦公式来计算它们之间的距离：首先，我们需要计算两个点之间的直线距离，即使用欧几里得距离公式计算：side1 = sqrt((x2 - x1)^2 + (y2 - y1)^2)然后，我们可以使用以下公式计算距离：distance = 2 * arcsin(sqrt(sin^2((y2 - y1) / 2) + cos(y1) * cos(y2) * sin^2((x2 - x1) / 2))) * radius_of_earth其中，arcsin代表反正弦函数，sin和cos代表正弦和余弦函数。
需注意，我们将距离乘以地球的半径以获得长度单位，例如千米或英里，具体取决于所使用的地球半径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#coding:UTF-8
"""
Python implementation of Haversine formula
Copyright (C) <2009> Bartek Górny <bartek@.pl>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY W ARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see </licenses/>.
"""
import math
def recalculate_coordinate(val, _as=None):
"""
Accepts a coordinate as a tuple (degree, minutes, seconds)
You can give only one of them (e.g. only minutes as a floating point number) and it will be duly recalculated into degrees, minutes and seconds.
Return value can be specified as 'deg', 'min' or 'sec'; default return value is
a proper coordinate tuple.
"""
deg, min, sec = val
# pass outstanding values from right to left
min = (min or 0) + int(sec) / 60
sec = sec % 60
deg = (deg or 0) + int(min) / 60
min = min % 60
# pass decimal part from left to right
dfrac, dint = math.modf(deg)
min = min + dfrac * 60
deg = dint
mfrac, mint = math.modf(min)
sec = sec + mfrac * 60
min = mint
if _as:
sec = sec + min * 60 + deg * 3600
if _as == 'sec': return sec
if _as == 'min': return sec / 60
if _as == 'deg': return sec / 3600
return deg, min, sec
def points2distance(start, end):
"""
Calculate distance (in kilometers) between two points given as (long, latt) pairs
based on Haversine formula (/wiki/Haversine_formula).
Implementation inspired by JavaScript implementation from
/scripts/latlong.html
Accepts coordinates as tuples (deg, min, sec), but coordinates can be given
in any form - e.g. can specify only minutes:
(0, 3133.9333, 0)
is interpreted as
(52.0, 13.0, 55.998000000008687)
which, not accidentally, is the lattitude of Warsaw, Poland.
"""
start_long = math.radians(recalculate_coordinate(start[0], 'deg'))
start_latt = math.radians(recalculate_coordinate(start[1], 'deg'))
end_long = math.radians(recalculate_coordinate(end[0], 'deg'))
end_latt = math.radians(recalculate_coordinate(end[1], 'deg'))
d_latt = end_latt - start_latt
d_long = end_long - start_long
a = math.sin(d_latt/2)**2 + math.cos(start_latt) * math.cos(end_latt) * math.sin(d_long/2)**2 c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
return 6371 * c
if __name__ == '__main__':
warsaw = ((21, 0, 30), (52, 13, 56))
cracow = ((19, 56, 18), (50, 3, 41))
print points2distance(warsaw, cracow)。