python如何求任意两个对象的欧几里得距离和曼哈顿距离

在Python中，我们可以使用内置的`math`模块计算两个向量的欧几里得距离，以及`numpy`库计算曼哈顿距离。以下是两种距离的计算方法：

**1. 欧几里得距离 (Euclidean Distance)**
欧几里得距离是基于每个维度上数值的平方差的平方根。如果你有两个列表表示二维坐标点 `p1 = [x1, y1]` 和 `p2 = [x2, y2]`，你可以这样做：

import math

def euclidean_distance(p1, p2):
    return math.sqrt(sum((a - b) ** 2 for a, b in zip(p1, p2)))

# 示例
p1 = [1, 2]
p2 = [4, 6]
distance_euclidean = euclidean_distance(p1, p2)

**2. 曼哈顿距离 (Manhattan Distance or Taxicab Distance)**
曼哈顿距离是沿着网格线的直线距离，对于每个维度的值直接取绝对值然后相加。同样使用两个点 `p1` 和 `p2` 计算：

def manhattan_distance(p1, p2):
    return sum(abs(a - b) for a, b in zip(p1, p2))

# 示例
distance_manhattan = manhattan_distance(p1, p2)

相关问题

闵可夫斯基距离python

闵可夫斯基距离（Minkowski Distance）是一种计算两个向量之间的距离的方法，它可以用来度量任意维度空间中的距离。在Python中，可以使用SciPy库中的spatial.distance.minkowski()函数来计算闵可夫斯基距离。该函数的语法如下：

scipy.spatial.distance.minkowski(u, v, p)

其中，`u`和`v`是待计算距离的两个向量，`p`是距离的阶数。当`p=1`时，计算的是曼哈顿距离（Manhattan Distance）；当`p=2`时，计算的是欧几里得距离（Euclidean Distance）。当`p`取其他值时，计算的是闵可夫斯基距离。

下面是一个示例代码：

from scipy.spatial.distance import minkowski

u = [1, 2, 3]
v = [4, 5, 6]
p = 3

dist = minkowski(u, v, p)
print(dist)

输出结果为：

5.196152422706632

其中，`u`和`v`分别为向量`[1, 2, 3]`和`[4, 5, 6]`，`p`为3，计算出的闵可夫斯基距离为5.196。

python凝聚层次聚类算法实现（非聚类库函数调用），要求算法输入：随机生成聚类的>=20个对象；算法输出：分类结果，聚类过程中得到的最短距离值以及距离矩阵。考虑单链法single-linkage、全链法complete-linkage和组平均法average-linkage这三种不同距离的计算方法进行聚类。

好的，这是一个比较复杂的问题，需要分步骤来回答。首先，我们需要了解一下凝聚层次聚类算法的基本原理。

凝聚层次聚类算法是一种自下而上的聚类方法，它的基本思想是从每个数据点开始，逐步将相似的数据点合并成一个簇，直到所有数据点都被合并成为一个簇或者达到指定的簇的个数。其中，相似度的计算方法可以采用不同的距离度量方式，如欧几里得距离、曼哈顿距离、余弦相似度等。在本次问题中，我们需要实现三种不同距离度量方式的凝聚层次聚类算法，分别是单链法、全链法和组平均法。

下面，我将分步骤介绍如何实现这个算法。首先是数据的生成。我们可以使用numpy库来生成随机数据，代码如下：

import numpy as np

np.random.seed(0)
X = np.random.rand(20, 5)  # 生成20个5维随机向量

接下来，我们需要计算两两数据点之间的距离，并构建距离矩阵。这里我们可以使用scipy库中的distance函数来计算距离。代码如下：

from scipy.spatial.distance import pdist, squareform

distances = pdist(X, metric='euclidean')  # 计算欧几里得距离
distance_matrix = squareform(distances)  # 将距离向量转换为距离矩阵

接下来是凝聚层次聚类的核心代码。我们可以使用一个列表来存储每个数据点的簇标记，初始时每个数据点都是一个簇，簇标记为数据点的下标。然后，我们可以使用一个字典来存储每个簇的距离，初始时每个簇的距离为无穷大。在聚类过程中，我们需要不断地找到距离最小的两个簇进行合并，直到达到指定的簇的个数。每次合并簇时，我们需要更新每个簇的距离，并将被合并的簇的标记更新为合并后的簇的标记。最后，我们可以返回聚类结果、最短距离值以及距离矩阵。代码如下：

def agglomerative_clustering(X, n_clusters, linkage='single'):
    n_samples = X.shape[0]
    labels = np.arange(n_samples)  # 初始时每个数据点都是一个簇，簇标记为数据点的下标
    distances = {i: {j: distance_matrix[i, j] for j in range(i + 1, n_samples)} for i in range(n_samples)}
    # 初始时每个簇的距离为无穷大
    cluster_distances = {i: float('inf') for i in range(n_samples)}

    def update_distances(i, j, k):
        # 更新簇k与其他簇的距离
        for l in range(n_samples):
            if l not in (i, j, k):
                if linkage == 'single':
                    d = min(distances[i][l], distances[j][l])
                elif linkage == 'complete':
                    d = max(distances[i][l], distances[j][l])
                elif linkage == 'average':
                    d = (distances[i][l] + distances[j][l]) / 2
                distances[k][l] = d
        # 删除簇i和簇j
        del distances[i], distances[j]
        # 更新簇距离
        for l in distances:
            if l != k:
                if linkage == 'single':
                    cluster_distances[l] = min(cluster_distances[l], distances[k][l])
                elif linkage == 'complete':
                    cluster_distances[l] = max(cluster_distances[l], distances[k][l])
                elif linkage == 'average':
                    cluster_distances[l] = (cluster_distances[l] + distances[k][l]) / 2

    for n_clusters in range(n_samples, n_clusters, -1):
        # 找到距离最小的两个簇进行合并
        i, j = min(((i, j) for i in distances for j in distances[i]), key=lambda x: distances[x[0]][x[1]])
        k = n_samples - n_clusters
        # 更新簇标记
        labels[labels == i] = k
        labels[labels == j] = k
        # 更新距离矩阵
        distances[k] = {l: distances[i][l] for l in distances[i]}
        distances[k].update({l: distances[j][l] for l in distances[j]})
        update_distances(i, j, k)

    return labels, cluster_distances, distance_matrix

最后，我们可以使用上面的代码来分别实现单链法、全链法和组平均法的聚类。代码如下：

labels_single, distances_single, distance_matrix_single = agglomerative_clustering(X, 5, linkage='single')
labels_complete, distances_complete, distance_matrix_complete = agglomerative_clustering(X, 5, linkage='complete')
labels_average, distances_average, distance_matrix_average = agglomerative_clustering(X, 5, linkage='average')

其中，n_clusters参数指定最终要聚成的簇的个数。这里我们聚成了5个簇。最后，我们可以输出聚类结果、最短距离值以及距离矩阵。代码如下：

print('Single linkage:')
print('Labels:', labels_single)
print('Distances:', distances_single)
print('Distance matrix:\n', distance_matrix_single)

print('Complete linkage:')
print('Labels:', labels_complete)
print('Distances:', distances_complete)
print('Distance matrix:\n', distance_matrix_complete)

print('Average linkage:')
print('Labels:', labels_average)
print('Distances:', distances_average)
print('Distance matrix:\n', distance_matrix_average)

注意，这里的距离矩阵是一个对称矩阵，因此只需要输出其中的一半就可以了。

希望我的回答能够帮助你解决问题。如果还有任何疑问，欢迎继续追问！