def k_means_clustering(points: list[tuple[float, float]], k: int, initial_centroids: list[tuple[float, float]], max_iterations: int) -> list[tuple[float, float]]:
    import numpy as np
    my_list=[0]*len(points)
    my_list[1]
    if k==1:
        points=np.array(points)
        initial_centroids=[tuple(np.mean(points,axis=0))]
        final_centroids=initial_centroids
        return final_centroids
        
    for _ in range(max_iterations):
        for index, items in enumerate(points):
            my_list1=[0]*len(initial_centroids)
            for indx2, cen in enumerate(initial_centroids):
                my_list1[indx2]=np.sqrt(np.sum((np.array(items)-np.array(cen))**2))
                # print(my_list1[indx2])
            max_val=999999
            centroid=9
            for index3, value in enumerate(my_list1):
                if value<max_val:
                    centroid=index3
                    max_val=value
            # print(centroid)
            my_list[index]=centroid
        my_list

        points_array=np.array(points)

        if k==1:
            cluster0=points_array[np.array(my_list)==0]
            initial_centroids=[tuple(np.mean(cluster0,axis=0))]

        elif k==2:
            cluster0=points_array[np.array(my_list)==0]
            cluster1=points_array[np.array(my_list)==1]
            initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0))]
        elif k==3:
            cluster0=points_array[np.array(my_list)==0]
            cluster1=points_array[np.array(my_list)==1]
            cluster2=points_array[np.array(my_list)==2]
            initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0)),tuple(np.mean(cluster2,axis=0))]
        elif k==4:
            cluster0=points_array[np.array(my_list)==0]
            cluster1=points_array[np.array(my_list)==1]
            cluster2=points_array[np.array(my_list)==2]
            cluster3=points_array[np.array(my_list)==3]
            initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0)),tuple(np.mean(cluster2,axis=0)),tuple(np.mean(cluster3,axis=0))]

        initial_centroids
        final_centroids=initial_centroids
    return final_centroids
def standerd_data_z_score(points):
    points = np.array(points, dtype=float)
    mean=np.mean(points,dtype=float)
    std=np.std(points,dtype=float)
    scaled=(points-mean)/std
    return scaled, mean, std
# print(k_means_clustering([(1, 1), (2, 2), (3, 3), (4, 4)], 1, [(0,0)], 10))
# print(k_means_clustering([(0, 0), (1, 0), (0, 1), (1, 1), (5, 5), (6, 5), (5, 6), (6, 6),(0, 5), (1, 5), (0, 6), (1, 6), (5, 0), (6, 0), (5, 1), (6, 1)], 4, [(0, 0), (0, 5), (5, 0), (5, 5)], 10))
points = [
    (5.1, 2.3, 12),
    (4.9, 2.5, 10),
    (6.2, 3.0, 15),
    (1.5, 0.8, 5),
    (1.2, 0.6, 3)
]

import numpy as np
scaled, mean, std=standerd_data_z_score(points)
centr=[(6.2,3,15),(1.35,0.7,4),(5,2.4,11)]

centr=np.array(centr,dtype=float)
centr=(centr-mean)/std
finally_centroid=k_means_clustering(scaled, 3, centr, 100)

# # max_iterations = 10

# points = [(1, 1), (2, 2), (3, 3), (4, 4)]
# k=1
# initial_centroids=  [(0,0)]
# max_iterations=10

# points[0][0]

# my_list=[0]*len(points)
# my_list[1]
# i=int(0)
# for _ in range(max_iterations):
#     for index, items in enumerate(points):
#         my_list1=[0]*len(initial_centroids)
#         for indx2, cen in enumerate(initial_centroids):
#             my_list1[indx2]=np.sqrt(np.sum((np.array(items)-np.array(cen))**2))
#             # print(my_list1[indx2])
#         max_val=999999
#         centroid=9
#         for index3, value in enumerate(my_list1):
#             if value<max_val:
#                 centroid=index3
#                 max_val=value
#         # print(centroid)
#         my_list[index]=centroid
#     my_list

#     points_array=np.array(points)
#     if k==1:
#         cluster0=points_array[np.array(my_list)==0]
#         initial_centroids=[tuple(np.mean(cluster0,axis=0))]

#     elif k==2:
#         cluster0=points_array[np.array(my_list)==0]
#         cluster1=points_array[np.array(my_list)==1]
#         initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0))]
#     elif k==3:
#         cluster0=points_array[np.array(my_list)==0]
#         cluster1=points_array[np.array(my_list)==1]
#         cluster2=points_array[np.array(my_list)==2]
#         initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0)),tuple(np.mean(cluster2,axis=0))]

#     # cluster1
#     # initial_centroids=[tuple(np.mean(cluster0,axis=0)),tuple(np.mean(cluster1,axis=0))]
#     # initial_centroids
        
# initial_centroids		
scaled
finally_centroid
level_data=[0]*5

for index, value in enumerate(scaled):
    lis=[0]*3
    for index2, centroids in enumerate(finally_centroid):
        dis1=np.sqrt(np.sum(value-centroids)**2)
        lis[index2]=dis1
    smallest_val=min(lis)
    level_data[index]=lis.index(smallest_val)
scaled
level_data
# dis1=np.sqrt(np.array(value)-np.array(centroids)**2)

finally_centroid = np.array(finally_centroid)
import matplotlib.pyplot as plt
plt.scatter(scaled[:, 0], scaled[:, 1], c=level_data, cmap='viridis')  
plt.scatter(finally_centroid[:, 0], finally_centroid[:, 1], marker='*', s=200, c='red')  
plt.xlabel('Annual Spending ($1000s)')  
plt.ylabel('Avg Order Value ($100s)')  
plt.title('Customer Segmentation with k-Means')  
plt.legend