k-means python代码

### 回答1：
下面是一个简单的使用Python实现的K-Means算法的代码：

import numpy as np
import matplotlib.pyplot as plt

# 生成随机数据
np.random.seed(0)
X = np.random.randn(100, 2)

# 初始化聚类中心
k = 3
centers = X[:k, :]

# 迭代更新聚类中心
while True:
    # 计算每个样本与聚类中心的距离
    distances = np.sqrt(((X - centers[:, np.newaxis]) ** 2).sum(axis=2))
    
    # 分配样本到最近的聚类中心
    labels = distances.argmin(axis=0)
    
    # 更新聚类中心
    new_centers = np.array([X[labels == i].mean(axis=0) for i in range(k)])
    
    # 判断是否收敛
    if np.all(centers == new_centers):
        break
    centers = new_centers

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.scatter(centers[:, 0], centers[:, 1], marker='*', s=200, c='r')
plt.show()

上述代码中，我们首先生成了一个二维的随机数据集X，然后初始化了三个聚类中心，接着进行了迭代更新聚类中心的过程，直到聚类中心不再变化为止。最后，我们用matplotlib库将聚类结果可视化出来。

### 回答2：
k-means是一种基本的聚类算法，它的目标是将数据集划分为k个簇，使得每个数据点与所属簇中的均值最接近。以下是一个简单的使用Python实现k-means算法的代码：

import numpy as np

def kmeans(data, k, max_iters=100):
    # 随机选择k个初始质心
    centers = data[np.random.choice(range(len(data)), k, replace=False)]
    
    for _ in range(max_iters):
        # 计算每个数据点与质心的距离
        distances = np.sqrt(((data - centers[:, np.newaxis])**2).sum(axis=2))
        
        # 将数据点分配到最近的质心
        labels = np.argmin(distances, axis=0)
        
        # 更新质心位置为所属簇的均值
        new_centers = np.array([data[labels == i].mean(axis=0) for i in range(k)])
        
        # 如果质心位置没有变化，则停止迭代
        if np.all(centers == new_centers):
            break
            
        centers = new_centers
    
    return labels, centers

# 测试代码
data = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])
k = 2
labels, centers = kmeans(data, k)

print("数据点所属簇的标签：", labels)
print("质心坐标：", centers)

上述代码中，将数据集表示为一个二维numpy数组。在算法开始时，通过随机选择k个数据点作为初始质心。然后，通过多次迭代计算每个数据点与质心的距离，将数据点分配到最近的质心所属的簇，然后更新质心的位置为所属簇的均值。重复这个过程直到质心位置不再发生变化或达到最大迭代次数。

最后，打印每个数据点所属的簇的标签以及最终的质心坐标。

### 回答3：
k-means是一种常用的聚类算法，其思想是根据样本之间的相似度进行聚类，将样本划分为K个不重叠的簇。下面是一个用Python实现k-means算法的例子：

import numpy as np
import random

def k_means(data, k, max_iters):
    centroids = random.sample(list(data), k)  # 随机选择k个初始质心
    for _ in range(max_iters):
        clusters = [[] for _ in range(k)]  # 存储每个簇的样本
        for point in data:
            distances = [np.linalg.norm(point - centroid) for centroid in centroids]  # 计算样本与每个质心的距离
            cluster_idx = np.argmin(distances)  # 找到距离最近的质心索引
            clusters[cluster_idx].append(point)  # 将样本添加到对应的簇中
        
        new_centroids = []
        for cluster in clusters:
            if cluster:
                new_centroid = np.mean(cluster, axis=0)  # 计算簇中样本的均值作为新的质心
                new_centroids.append(new_centroid)
            else:
                new_centroids.append(random.choice(list(data)))  # 若某个簇为空，则随机选择一个样本作为新的质心
        
        if np.all(centroids == new_centroids):
            break  # 若质心不再更新，则停止迭代
        centroids = new_centroids

    return centroids, clusters

# 测试代码
data = np.array([[1, 2], [1, 4], [3, 4], [5, 7], [3, 2], [8, 1]])
k = 2
max_iters = 10
centroids, clusters = k_means(data, k, max_iters)
for i, cluster in enumerate(clusters):
    print('Cluster {}:'.format(i))
    print(cluster)

上述代码中，`data`是一个包含样本的numpy数组，`k`是簇的数量，`max_iters`是最大迭代次数。代码首先在样本中随机选择`k`个作为初始质心，然后进行迭代，直到质心不再更新或达到最大迭代次数为止。对于每个迭代周期，代码计算每个样本与质心的距离，将样本分配到距离最近的簇中，然后重新计算每个簇的质心。最后，返回最终的质心和簇的分配结果。

测试代码中，我们给定了一个简单的二维数据集，将其分为两个簇，然后输出每个簇的样本。