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

好的，让我来回答这个问题。

首先，我们需要随机生成聚类的对象。为了简化问题，我们假设每个对象是一个二维向量（x，y），其中x和y都是浮点数。我们可以使用Python的random模块来生成随机对象。这里我们生成20个对象：

import random

objects = [(random.uniform(0, 1), random.uniform(0, 1)) for i in range(20)]

接下来，我们需要计算对象之间的距离。我们可以使用欧几里得距离公式来计算两个向量之间的距离：

def euclidean_distance(a, b):
    return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

我们可以使用一个距离矩阵来存储所有对象之间的距离。距离矩阵是一个二维数组，其中第i行第j列的元素表示第i个对象和第j个对象之间的距离。为了方便起见，我们可以将距离矩阵的对角线上的元素都初始化为正无穷大，因为任何对象和它自己之间的距离都是0，而我们不希望这些元素被误认为是最小距离。

import math

distance_matrix = [[math.inf] * 20 for i in range(20)]
for i in range(20):
    for j in range(i+1, 20):
        distance_matrix[i][j] = euclidean_distance(objects[i], objects[j])
        distance_matrix[j][i] = distance_matrix[i][j]

现在我们已经有了距离矩阵，我们可以开始实现凝聚层次聚类算法。我们将实现三种不同的距离计算方法：单链法、全链法和组平均法。在每个方法中，我们将使用一个列表来存储聚类。初始时，每个对象都被认为是一个独立的聚类。我们将使用一个字典来存储每个聚类的标签，其中键是聚类的对象，值是聚类的标签。

clusters = [[i] for i in range(20)]
labels = {i: i for i in range(20)}

现在，我们可以开始实现单链法。在单链法中，我们将聚类之间的最小距离定义为两个聚类中距离最近的两个对象之间的距离。我们将重复以下步骤，直到只剩下一个聚类：

1. 在距离矩阵中找到最小的距离值d。
2. 找到距离矩阵中最小距离值对应的两个聚类c1和c2。
3. 将聚类c1和c2合并为一个新聚类。
4. 更新距离矩阵，将新聚类与其他聚类之间的距离重新计算。
5. 更新聚类标签字典。

while len(clusters) > 1:
    # find the minimum distance
    min_distance = math.inf
    for i in range(len(clusters)):
        for j in range(i+1, len(clusters)):
            distance = min(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in clusters[j])
            if distance < min_distance:
                min_distance = distance
                min_i, min_j = i, j
    # merge the two clusters
    new_cluster = clusters[min_i] + clusters[min_j]
    clusters = clusters[:min_i] + clusters[min_i+1:min_j] + clusters[min_j+1:] + [new_cluster]
    # update the distance matrix
    for i in range(len(clusters)-1):
        distance = min(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in new_cluster)
        distance_matrix[i][-1] = distance
        distance_matrix[-1][i] = distance
    distance_matrix.append([math.inf] * len(clusters))
    # update the label dictionary
    for c in new_cluster:
        labels[c] = len(clusters) - 1

现在，我们可以对全链法进行类似的实现。在全链法中，我们将聚类之间的最小距离定义为两个聚类中距离最远的两个对象之间的距离。

while len(clusters) > 1:
    # find the minimum distance
    max_distance = -math.inf
    for i in range(len(clusters)):
        for j in range(i+1, len(clusters)):
            distance = max(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in clusters[j])
            if distance > max_distance:
                max_distance = distance
                max_i, max_j = i, j
    # merge the two clusters
    new_cluster = clusters[max_i] + clusters[max_j]
    clusters = clusters[:max_i] + clusters[max_i+1:max_j] + clusters[max_j+1:] + [new_cluster]
    # update the distance matrix
    for i in range(len(clusters)-1):
        distance = max(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in new_cluster)
        distance_matrix[i][-1] = distance
        distance_matrix[-1][i] = distance
    distance_matrix.append([math.inf] * len(clusters))
    # update the label dictionary
    for c in new_cluster:
        labels[c] = len(clusters) - 1

最后，我们可以对组平均法进行类似的实现。在组平均法中，我们将聚类之间的最小距离定义为两个聚类中所有对象之间距离的平均值。

while len(clusters) > 1:
    # find the minimum distance
    min_distance = math.inf
    for i in range(len(clusters)):
        for j in range(i+1, len(clusters)):
            distance = sum(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in clusters[j]) / (len(clusters[i]) * len(clusters[j]))
            if distance < min_distance:
                min_distance = distance
                min_i, min_j = i, j
    # merge the two clusters
    new_cluster = clusters[min_i] + clusters[min_j]
    clusters = clusters[:min_i] + clusters[min_i+1:min_j] + clusters[min_j+1:] + [new_cluster]
    # update the distance matrix
    for i in range(len(clusters)-1):
        distance = sum(distance_matrix[c1][c2] for c1 in clusters[i] for c2 in new_cluster) / (len(clusters[i]) * len(new_cluster))
        distance_matrix[i][-1] = distance
        distance_matrix[-1][i] = distance
    distance_matrix.append([math.inf] * len(clusters))
    # update the label dictionary
    for c in new_cluster:
        labels[c] = len(clusters) - 1

现在，我们已经完成了凝聚层次聚类算法的实现，并且得到了分类结果、聚类过程中得到的最短距离值以及距离矩阵。完整代码如下：