使用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:\Users\lenovo\Desktop\that.txt' 
raw_score = r'C:\Users\lenovo\Desktop\data1.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:\Users\lenovo\Desktop\normal.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;
    }
}