使用Python将excel文件中的数据提取到txt中

数据分析与建模，本次尝试使用C++进行处理，数据在excel中，遂考虑使用Python进行excel转txt操作，代码如下：

# -*- coding: UTF-8 -*-
import sys
import json
 
import pandas as pd
import numpy as np
 
filename=r'C:UserslenovoDesktop	hat.txt' 
raw_score = r'C:UserslenovoDesktopdata1.xlsx'
#读取excel保存成txt格式
excel_file = pd.read_excel(raw_score)
excel_file.to_csv(filename, sep=' ', index=False)

Python聚类分析代码：

import numpy as np
import matplotlib.pyplot as plt
 
# 加载数据
def loadDataSet(fileName):
    data = np.loadtxt(fileName,delimiter=' ')
    return data
 
# 欧氏距离计算
def distEclud(x,y):
    return np.sqrt(np.sum((x-y)**2))  # 计算欧氏距离
 
# 为给定数据集构建一个包含K个随机质心的集合
def randCent(dataSet,k):
    m,n = dataSet.shape
    centroids = np.zeros((k,n))
    for i in range(k):
        index = int(np.random.uniform(0,m)) #
        centroids[i,:] = dataSet[index,:]
    return centroids
 
# k均值聚类
def KMeans(dataSet,k):
 
    m = np.shape(dataSet)[0]  #行的数目
    # 第一列存样本属于哪一簇
    # 第二列存样本的到簇的中心点的误差
    clusterAssment = np.mat(np.zeros((m,2)))
    clusterChange = True
 
    # 第1步 初始化centroids
    centroids = randCent(dataSet,k)
    while clusterChange:
        clusterChange = False
 
        # 遍历所有的样本（行数）
        for i in range(m):
            minDist = 100000.0
            minIndex = -1
 
            # 遍历所有的质心
            #第2步 找出最近的质心
            for j in range(k):
                # 计算该样本到质心的欧式距离
                distance = distEclud(centroids[j,:],dataSet[i,:])
                if distance < minDist:
                    minDist = distance
                    minIndex = j
            # 第 3 步：更新每一行样本所属的簇
            if clusterAssment[i,0] != minIndex:
                clusterChange = True
                clusterAssment[i,:] = minIndex,minDist**2
        #第 4 步：更新质心
        for j in range(k):
            pointsInCluster = dataSet[np.nonzero(clusterAssment[:,0].A == j)[0]]  # 获取簇类所有的点
            centroids[j,:] = np.mean(pointsInCluster,axis=0)   # 对矩阵的行求均值
 
    print("Congratulations,cluster complete!")
    return centroids,clusterAssment
 
def showCluster(dataSet,k,centroids,clusterAssment):
    m,n = dataSet.shape
    if n != 2:
        print("数据不是二维的")
        return 1
 
    mark = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '<r', 'pr']
    if k > len(mark):
        print("k值太大了")
        return 1
 
    # 绘制所有的样本
    for i in range(m):
        markIndex = int(clusterAssment[i,0])
        plt.plot(dataSet[i,0],dataSet[i,1],mark[markIndex])
        plt.annotate(i+1,(dataSet[i,0],dataSet[i,1]))
 
    mark = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '<b', 'pb']
    # 绘制质心
    for i in range(k):
        print('质心：',str(centroids[i,0])+' '+str(centroids[i,1]))
        plt.plot(centroids[i,0],centroids[i,1],mark[i])
    plt.title('Clustering map of specialists')
    plt.show()


dataSet = loadDataSet(r'C:UserslenovoDesktop
ormal.txt')
k = 3
centroids,clusterAssment = KMeans(dataSet,k)
 
showCluster(dataSet,k,centroids,clusterAssment)

聚类结果：

话说，c++建模也还可，就是需要自己编写相关指标的算法，但是也挺有意

代码如下：

/*
*language:c++
*version:11
*encoding:GBK
*made by Luo Wenshui
*last modified:2020/5/10
*data file:input.txt
*/
#include<iostream>
#include<map> 
#include<math.h>
#include<string.h>
#include<algorithm> 
#include<cstdio>
using namespace std;
inline int read(){
    int ans=0,w=1;
    char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch))ans=(ans<<3)+(ans<<1)+ch-'0',ch=getchar();
    return ans*w;
}
int n,m,t;
const int maxn=1200;
const int maxm=50; 
struct node{//每一件参赛作品 
    double final_score;
    double raw_score[4];
    int score_givener[4];
    double std_score[4];
    int rank;//该作品在所有参赛作品中的排序 
}a[maxn];
struct specialist{ 
    double raw_score[100];
    double std_score[100];
    int num_of_work[100];//每次评阅的作品编号 
    int count;//表示专家批阅的项目数量；
    double std;//该专家打分的标准差
    double mean;//该专家打分的均值 
    int rank[maxn];//该专家对相应编号作品的打分在该专家所有分数中的排名
    double delta0i,delta1i;
    double P0i,P1i;//定义为P0i=1-delta0i,P1i=1-delta1i
    double P0T,P1T;//专家多次比赛获得的平均可行度水平，本论文中不涉及 
    int kide;//专家在聚类之后所属的类别 
}E[maxm];
struct work{//对所有作品确定排名的排序类 
    int index;
    double score;
}w[maxn]; 
double R[maxm][maxm];//相似度矩阵 
double total_mean;//所有专家打分的均值
double total_std;//所有专家打分的标准差 
int kide[100]={3,2,3,3,3,2,3,3,3,1,3,2,2,1,3,3,3,2,3,2,1,3,2,3,2,1,2,3,2,1,3,2,3,3,3,3,2,1,3,3,3,2,2,3,1};//专家类别表，由聚类分析得出 
double get_std(specialist& s)//获取每个专家打分的标准差 
{
    double mean=0.0;
    for(int i = 1; i <= s.count; i ++ )//计算均值 
    {
        mean+=s.raw_score[i];
    }
    mean/=s.count; 
    double ans = 0.0;
    for(int i = 1; i <= s.count; i ++ )
    {
        ans+=(s.raw_score[i]-mean)*(s.raw_score[i]-mean);
    }
    return sqrt(ans/s.count); 
}
double get_mean(specialist& s)//获取s打分的均值 
{
    double ans = 0.0;
    for(int i = 1; i <= s.count; i ++ )
    {
        ans += s.raw_score[i];
    }
    return ans/s.count;
}
int get_rank(double score,specialist& s)//获取某一得分在专家所有打分中的排名 
{
    int rank = 0;
    for(int i = 0; i <= s.count; i ++ )
    {
        if(s.raw_score[i] < score)rank++;
    }
    return rank;
}
double get_delta0i(specialist& Ei)//获取专家E[i]的delta0i 
{
    double ans = 0.0;
    for(int j = 1; j <= Ei.count; j ++ )
    {
        double final_score = a[Ei.num_of_work[j]].final_score;//专家Ei在评阅的作品j的总评得分 
        ans += fabs(Ei.raw_score[j]-final_score)/final_score;
    }
    return ans/(double)Ei.count;
}
double get_delta1i(specialist& Ei)//获取专家E[i]的delta1i 
{
    double ans = 0.0;
    int count = Ei.count;
    for(int j = 1; j <= Ei.count; j ++ )
    {
        double rank = a[Ei.num_of_work[j]].rank;//Ei评阅的第j件作品的总评排序 
        ans += fabs((double)Ei.rank[j]-rank)/(double)(count-1); 
    }
    return ans/count;
} 
void get_R()//计算定义的相似度矩阵 
{
    double M = -1e10;
    for(int i = 1; i <= 45; i ++ )
    {
        for(int j = 1; j <= 45; j ++ )
        {
            double P0i = E[i].P0i;
            double P0j = E[j].P0i;
            double P1i = E[i].P1i;
            double P1j = E[j].P1i;
            double tmp = P0i*P0j+P1i*P1j;
            M = max(M,tmp);    
            if(i == j)R[i][j]=1;
            else
            {
                R[i][j]=tmp;
            }
        }
    }
    for(int i = 1; i <= 45; i ++ )
    {
        for( int j = 1; j <= 45; j ++ )
        {
            if(i==j)continue;
            R[i][j] = R[i][j]/M;//映射到(0,1)区间 
        }
     } 
}
double  get_total_mean()//获得总体均值 
{
    double ans = 0.0;
    for(int i = 1; i <= 1046; i ++ )
    {
        ans += a[i].final_score;
    } 
    return ans/1046;
}
double get_total_std()//获得总体方差 
{
    double ans = 0.0;
    int count = 0;
    for(int i = 1; i <= 45;i ++ )
    {
        count += E[i].count;
        for(int j = 1; j <= E[i].count; j ++ )
        {
            int num = E[i].num_of_work[j];
            ans += pow(a[num].final_score-E[i].raw_score[j],2);
        }
     }
     return  sqrt(ans/count);
}
void display();//展示专家信息
void display_R();//展示相关系数矩阵 
void display_P();//打印可信度表 
struct test{ 
    int index;
}; 

bool cmp(work& a1,work& a2){return a1.score<a2.score;}//按照得分进行升序排序 
int main()
{
    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);
    std::ios::sync_with_stdio(false);
    int number,number_of_work;
    double tmp;
    int x;
    double tmp1,tmp2; 
    for(int i = 1;i <= 1046;i ++)//获取1046条数据 
    {
        cin>>tmp;
        number = (int)tmp;
        cin>>a[number].final_score;
        w[i].index = i;
        w[i].score = a[number].final_score;
    //获取三个专家的信息 
        for(int j = 1; j <= 3; j ++ )
        {
            cin>>tmp;
            number = (int)tmp;
            cin>>tmp1>>tmp2;
             
            int count = ++E[number].count;
            E[number].raw_score[count]=tmp1;
            E[number].std_score[count]=tmp2;
            E[number].num_of_work[count]=i;//评阅的作品编号 
            
            a[i].raw_score[j] = tmp1;
            a[i].score_givener[j] = number;
            a[i].std_score[j] = tmp2;
        }
    }
    
    for(int i = 1; i <= 45; i ++ )
    {
        E[i].std = get_std(E[i]);
        E[i].mean = get_mean(E[i]);
        for(int j = 1; j <= E[i].count; j ++ )//计算在E[i]所打的分中作品Aj的排名 
        {
            E[i].rank[j] = get_rank(E[i].raw_score[j],E[i]);
        }
    }
    sort(w+1,w+1046+1,cmp);//对作品final_score进行升序排序
    for(int i = 1; i <=1046; i ++ )
    {
        a[w[i].index].rank=i;//得到每件作品的排名 
    } 
    
    for(int i = 1; i <= 45; i ++ )//获取每位专家的分值偏差和排序偏差与可信度 
    {
        E[i].delta0i = get_delta0i(E[i]);
        E[i].delta1i = get_delta1i(E[i]); 
        E[i].P0i = 1 - E[i].delta0i;
        E[i].P1i = 1 - E[i].delta1i;
    }
//    cout<<get_total_mean()<<" "<<get_total_std()<<endl;
//    display();//通过display 函数可以展示每一个专家的详细信息 
//    get_R();//计算相关矩阵 
//    display_R();
//    
//    display_P();
}
void display()
{
    cout<<"四元组（a,b,c,d) => 该专家第a次批阅了作品b，给了c分，该作品的标准分是d"<<endl;
    for(int j = 1; j <= 45; j ++ )
    {
        cout<<"第"<<j<<"个专家："<<endl;
        cout<<"总体："<<E[j].count<<endl; 
        for(int i = 1; i <= E[j].count; i ++ )
        {
            cout<<"("<<i<<","<<E[j].num_of_work[i]<<","<<E[j].raw_score[j]<<","<<E[j].std_score[i]<<")"<<endl;
            cout<<"该作品在该专家所以给分中的排名："<<E[1].rank[i]<<endl;
        } 
        cout<<"标准差:"<<E[j].std<<endl;
        cout<<"delta0i = "<<E[j].delta0i<<endl;
        cout<<"delta1i = "<<E[j].delta1i<<endl;
        
        cout<<"P0i = "<<E[j].P0i<<endl;
        cout<<"P1i = "<<E[j].P1i<<endl; 
        cout<<"#########################################################"<<endl; 
    }
}
void display_R()
{
    cout<<" ";
    for(int i = 1;i <= 45; i ++ )
    {
        cout<<"("<<i<<")"<<"  ";
    }
    cout<<endl;
    for(int i = 1; i <= 45; i ++ )
    {
        cout<<"("<<i<<")"<<" ";
        for(int j = 1; j <= 45; j ++ )
        {
            cout<<R[i][j]<<" ";
        }
        cout<<endl;
    }
}
void display_P() 
{
    cout<<"可信度矩阵"<<endl; 
    for(int i = 1; i <= 45; i ++ )
    {
        cout<<E[i].P0i<<" "<<E[i].P1i<<endl;
    }
}