python数据分析所需要了解的操作。

import pandas as pd

data_forest_fires = pd.read_csv("data/forestfires.csv", encoding='gbk')

data1 = pd.read_excel("data/original_data.xls", sheet_name="原始数据")
data2 = pd.read_excel("data/original_data.xls", sheet_name="属性规约")

data_mtcars = pd.read_csv("data/mtcars.csv")

# data1.to_csv("data/original_data.csv")
# data2.to_csv("data/originalTo_data.csv")

# ----------------------------------------------------------------------
# test

# 查看几行几列
# print(data1.shape)

# 查看维度
# print(data1.ndim)

# 查看列名
# print(data1.columns)

# 查看索引名
# print(data1.index)

# 查看每列的数据类型
# print(data1.info())

# 查看统计特征
# print(data1.describe())
'''
count：非空值的数目
mean：数值型数据的均值
std：数值型数据的标准差
min：数值型数据的最小值
25%：数值型数据的下四分位数
50%：数值型数据的中位数
75%：数值型数据的上四分位数
max：数值型数据的最大值
'''

# ----------查看数据-----------
# 直接查看数据
# print(data1[1:5]["加热中"])
# 通过索引和列名来查看数据
# print(data1.loc[1:5]["加热中"])
# 通过第几行，第几列来查看数据
# print(data1.iloc[1:5, 5])

# ----------修改数据-----------

# ----------增加数据-----------
# 新增一列
# data1['new'] = 'new'
# 新增一行
# data1.loc['new', :] = 'new'

# ----------删除数据-----------
# 删除列
# data1.drop('new', axis=1, inplace=True)
# 删除行
# data1.drop('new', axis=0, inplace=True)

# ----------替代数据-----------
# data1.iloc[1, :] = data1.iloc[0, :]

# ---------转换数据类型--------
# 转换时间
data1["发生时间"] = pd.to_datetime(data1["发生时间"], format='%Y%m%d%H%M%S')
print(data1["发生时间"])

import pandas as pd
import numpy as np
from scipy.interpolate import interp1d
from scipy.interpolate import lagrange
from scipy.interpolate import spline
from sklearn.cluster import KMeans

data_forest_fires = pd.read_csv("data/forestfires.csv", encoding='gbk')
data1 = pd.read_excel("data/original_data.xls", sheet_name="原始数据")
data2 = pd.read_excel("data/original_data.xls", sheet_name="属性规约")
data_mtcars = pd.read_csv("data/mtcars.csv")

# 转换时间
data1["发生时间"] = pd.to_datetime(data1["发生时间"], format='%Y%m%d%H%M%S')
# data1.info()
# print(data1.head())
# data1.loc[1, "发生时间"].day

# 新增一列日期
data1["日期"] = [i.day for i in data1["发生时间"]]
# print(data1.head())

# 新增一列第几周
data1["第几周"] = [i.weekofyear for i in data1["发生时间"]]
# print(data1.head())

# 新增一列一周第几天
data1["星期几"] = [i.weekday for i in data1["发生时间"]]

# data1.to_csv("data/original_data_day.csv")

# 查看时间最大值
# print(data1['发生时间'].max())

# --------------------------------------分组聚合---------------------------------------
# ---分组---
group_day = data1.groupby("日期")
group_day_water = data1.groupby(["日期", "有无水流"])
# 查看分组个数
# print(group_day.size())
# print(group_day_water.size())

# ---聚合---

# agg              函数或包含了字段名和函数的字典
# 对不同的列进行不同的聚合操作
# print(group_day.agg({'发生时间': max, '水流量': sum}))
# 上述过程中使用的函数均为系统math库所带的函数，若需要使用pandas的函数则需要做如下操作
group_day.agg({'发生时间': lambda x: x.max(), '水流量': lambda x: x.sum()})

# apply            只能对所有列执行同一种操作
group_day.apply(lambda x: x.max())

# transform         常用来组内标准化,transform操作时的对象不再是每一组，而是每一个元素
# print(group_day['热水器编号'].transform(lambda x: x.astype(str)+'China').head())
# 组内标准化
group_day['水流量'].transform(lambda x: (x.mean()-x.min())/(x.max()-x.min())).head()

# --------------------------------------数据清洗---------------------------------------

# data_training_Master = pd.read_csv("Training_Master.csv", encoding='gbk')
df1 = pd.DataFrame({'一班': [90, 80, 66, 75, 99, 55, 76, 78, 98, None, 90],
                   '二班': [75, 98, 100, None, 77, 45, None, 66, 56, 80, 57],
                   '三班': [45, 89, 77, 67, 65, 100, None, 75, 64, 88, 99]})

print(df1)
# -------------数据删除-------------
# dropna()
'''
axis：表示轴向。默认为0，表示删除所有含有空值的行。
how：表示删除的方式。默认为any。为any的时候，表示只要存在缺失值就删除。为all的时候，表示全部是缺失值才能删除。
subset：表示删除的主键，默认为全部。注意，使用任意主键均需要将其放入list中。且主键和axis对应。
inplace：表示是否对原数据进行操作。默认为False，不对原数据操作。
'''
df1.dropna(axis=0, how='any')
# 判断缺失值
df1.notna()

# -------------定值替换法-------------
'''
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
value：表示传入的定值。可为某一个值，dict,Series,DataFrame。无默认
method：此参数存在，则不传入value。表示使用前一个非空值或后一个非空值进行缺失值填补。无默认。
axis：表示轴向。
inplace：表示是否对原数据进行操作。默认为False，不对原数据操作。
limit：表示插补多少次。默认全量插补。
'''
# df1.fillna(-999)
# df1.fillna({'一班':-60,'二班':-70,'三班':-80})

# -------------插补法-------------
df1.fillna(method='ffill')

# -------------插值法-------------
# 用inteerpolate包
# 默认linear
df1.interpolate()
# 线性插值
linear = df1['一班'][df1['一班'].notnull()]
LinearInsValue1 = interp1d(linear.index, linear.values, kind='linear')
LinearInsValue1(df1['一班'][df1['一班'].isnull()].index)
# 拉格朗日插值,使用非空索引为因变量，对应的元素为自变量，创建了一个拉格朗日拟合公式
LargeInsValue1 = lagrange(linear.index, linear.values)
LargeInsValue1(df1['一班'][df1['一班'].isnull()].index)
# 样条插值
spline(linear.index, linear.values,
       xnew=df1['一班'][df1['一班'].isnull()].index)

# -------------数据校验-------------

# 判断是否为缺失值（空值）
df1.isnull()
# 统计出每一列的缺失值数目
df1.isnull().sum()
# 每一列缺失比例
df1.isnull().sum()/df1.shape[0]
# 使用describe方法查看数据的完整性,统计出了非空值的数目
print(df1.describe().iloc[0, :])

# 特征值检验，相似度
'''
特征重复检验
针对数值型的特征（列）
特征重复检验需要用到相似度的概念
pearson相似度
spearman相似度
kendall相似度
使用的pandas方法为 DataFrame.corr(method = 'pearson')
method：表示求取相似度的方法，可取pearson，kendall，spearman。默认为pearson
'''
# 对分类型数据要去空格！！！
asso = df1.corr()
print(asso)
# 自定义一个输入相似度矩阵，输出应剔除的列名的自定义函数

def drop_features(assoMat,assoRate = 1.0):
    '''
    此函数用于求取相似度大于assoRate的两列中的一个，主要目的用于去除数值型特征的重复
    assoMat：相似度矩阵，无默认
    assoRate：相似度，默认为1
    '''
    delCol = []
    length = len(assoMat)
    for i in range(length):
        for j in range(i+1, length):
            if asso.iloc[i, j] >= assoRate:
                delCol.append(assoMat.columns[j])
    return(delCol)
drop_features(asso)

# -------------样本重复检验-------------
df2 = pd.DataFrame({'一班': [90, 80, 66, 90, 99, 55, 76, 90, 98, None, 90],
                   '二班': [75, 98, 100, 75, 77, 45, None, 75, 56, 80, 57],
                   '三班': [45, 89, 77, 45, 65, 100, None, 45, 64, 88, 99],
                   '四班': [75, 98, 100, 75, 77, 45, None, 75, 56, 80, 57]})
# print(df2)
'''
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)
subset：表示以这几个特征为基础，对整体样本进行去重。默认为使用所有特征
keep：表示保留第几个重复的样本。只允许填入first（保留第一个）,last(保留最后一个)，False(只要存在重复均不保留)。默认为first
inplace：表示是否在原DataFrame上进行操作,会改变原数据。默认为False
'''
# 剔除重复行
# df2.drop_duplicates()
# 计算样本重复率
# 计算样本重复率
# (df2.shape[0] - df2.drop_duplicates().shape[0])/df2.shape[0]

# -------------异常值处理-------------
# 3σ原则检测异常值
# 定义3σ法则识别异常值函数
def outRange(Ser1):
    '''
    Ser1：表示传入DataFrame的某一列。
    '''
    boolInd = (Ser1.mean()-3*Ser1.std() > Ser1) | (Ser1.mean()+3*Ser1.std() < Ser1)
    index = np.arange(Ser1.shape[0])[boolInd]       # range to array
    outrange = Ser1.iloc[index]
    return outrange
df = pd.read_csv('./data/detail.csv', encoding='gbk')
print(outRange(df['counts']).head())

# 箱线图检测异常值
def boxOutRange(Ser):
    '''
    Ser：进行异常值分析的DataFrame的某一列
    '''
    Low = Ser.quantile(0.25)-1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
    Up = Ser.quantile(0.75)+1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
    index = (Ser < Low) | (Ser > Up)
    Outlier = Ser.loc[index]
    return(Outlier)
# print(boxOutRange(df['counts']))

# --------------------------------------数据合并---------------------------------------

df1 = pd.DataFrame({'一班':[90,80,66,75,99,55,76,78,98,None,90],
                   '二班':[75,98,100,None,77,45,None,66,56,80,57],
                   '三班':[45,89,77,67,65,100,None,75,64,88,99]})
df2 = pd.DataFrame({'一班':[90,80,66,75,99,55,76,78,98,None,90],
                  '二班':[75,98,100,None,77,45,None,66,56,80,57],
                  '三班':[45,89,77,67,65,100,None,75,64,88,99]})

# append 直接在末尾追加，注意特征数目相同，并且数据类型相同
# print(df1.append(df2))

# concat
# print(pd.concat([df1, df2], axis=1))

# 主键合并
'''
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, suffixes=('_x', '_y'))
left：表示进行合并的左边的DataFrame。无默认。
right：表示进行合并的右边的DataFrame。无默认。
how：表示合并的方法。默认为'inner'。可取'left'(左连接),'right'（右连接）,'inner'（内连接）,'outer'（外连接）。
on：表示合并的主键。默认为空。
left_on：表示左边的合并主键。默认为空。
right_on：表示右边的合并主键。默认为空。
suffixes：表示列名相同的时候的后缀。默认为('_x', '_y')
'''
# 合并数据
# print(pd.merge(df1, df2, on='一班'))               # 因为90出现两次，在进行合并时，合并了4次
# print(pd.merge(df1, df2, left_on='一班', right_on='二班', suffixes=('_1', '_2')))
# 重叠合并
# DataFrame.combine_first(other) 重叠合并，当两者皆有以前者为准，为空时，则使用后者的补上。
df1['一班'].combine_first(df1['二班'])

# --------------------------------------数据变换---------------------------------------

df = pd.DataFrame({'性别': ['男', '女', '男'],
                  '学历': ['本科', '硕士', '本科'],
                  '民族': ['汉族', '仫佬族', '维吾尔族']})

# -------------哑变量处理/独热编码-------------
'''
pd.get_dummies(data, prefix=None, prefixsep='', dummy_na=False, columns=None, sparse=False, drop_first=False)
data：进行哑变量处理的数据，无默认，不可省略
prefix：前缀字符串
prefixsep：连接字符串，默认为''
dummy_na：表示是否将缺失值单独作为一类，默认为False，表示不将缺失值单独作为一类。
columns：表示进行哑变量处理的列，仅接收list，默认所有的类别型的列。
drop_first：表示是否剔除第一种类型，默认为False，表示不剔除。
'''
print(pd.get_dummies(df, prefix_sep='_'))
print(pd.get_dummies(df, prefix_sep='_', columns=['学历']))
print(pd.get_dummies(df, prefix_sep=':', drop_first=True))

## 证据权重函数

def total_response(data, label):
    value_count = data[label].value_counts()
    return value_count

def woe(data, feature, label, label_value):
    '''
    data：传入需要做woe的特征和标签两列数据
    feature：特征名
    label：标签名
    label_value:接收字典，key为1，0，表示为响应和未响应，value为对应的值
    '''
    import pandas as pd
    import numpy as np
    idx = pd.IndexSlice

    data['woe'] = 1
    groups = data.groupby([label, feature]).count().sort_index()

    ## 使用上述函数
    value_counts = total_response(data, label)

    resp_col = label_value[1]
    not_resp_col = label_value[0]
    resp = groups.loc[idx[resp_col, :]] / value_counts[resp_col]
    not_resp = groups.loc[idx[not_resp_col, :]] / value_counts[not_resp_col]
    Woe = np.log(resp / not_resp).fillna(0)
    return Woe

# -------------连续型数据离散化-------------
lsh = pd.DataFrame({'年龄':[18,16,15,17,19,28,80,55,36,43,12,23],
                  '身高':[180,160,150,170,170,153,165,155,162,170,120,185]})

# -------------等宽离散化-------------
pd.cut(lsh['年龄'], bins=5)
# pd.cut(lsh['年龄'],bins=5,labels = ['青少年','而立','不惑','耳顺','耄耋'])

# -------------等频离散化-------------
# 自定义等频法离散化函数
def SameRateCut(data,k):
    import numpy as np
    w = data.quantile(np.arange(0, 1+1.0/k, 1.0/k))
    data = pd.cut(data,w, include_lowest=True)
    return data
print(SameRateCut(lsh['身高'],5))

# -------------聚类离散化-------------
# def KmeanCut(data,k):
#     kmodel=KMeans(n_clusters=k, n_jobs=4)   ##建立模型，n_jobs是并行数
#     kmodel.fit(data.reshape((len(data), 1)))    ##训练模型
#     c=pd.DataFrame(kmodel.cluster_centers_).sort_values(0)   ##输出聚类中心并排序
#     w=pd.rolling_mean(c, 2).iloc[1:]    ##相邻两项求中点，作为边界点
#     w=[0]+list(w[0])+[data.max()]    ##把首末边界点加上
#     data=pd.cut(data,w)
#     return data
# print(KmeanCut(lsh['年龄'],5))

# --------------------------------------透视表和交叉表---------------------------------------
df = pd.DataFrame({'性别': ['男', '女', '男'],
                  '学历': ['本科', '硕士', '本科'],
                  '民族': ['汉族', '仫佬族', '维吾尔族']})

'''
log_info1 = pd.pivot_table(data_training_LogInfo[['Idx', 'LogInfo1', 'Listinginfo1']], index='Idx',
                           values='Listinginfo1', columns='LogInfo1',
                           aggfunc='count', fill_value=0).reset_index()
# index = 索引行
# values = 想要探究的值
# columns = 列，类似index吧
# aggfunc 聚合函数
'''

print(df1)

# sklearn 学习

# 读取数据集
from sklearn.datasets import load_iris
iris = load_iris()

# print(iris)

# print(iris.keys())

data = iris['data']                            # 数据内容
target = iris['target']                        # 属于花的种类
target_names = iris['target_names']            # 种类名
DESR = iris['DESCR']                           # 描述
feature_names = iris['feature_names']          # 列名

# print(target)
# ---------------------------分类模型构建 (离散)--------------------------------
'''
模块                     函数                     算法名称
linear_model               LogisticRegression         逻辑斯蒂回归
svm                            SVC                            支持向量机
neighbors                  KNeighborsClassifier       K最近邻分类
naive_bayes                    GaussianNB                 高斯朴素贝叶斯
tree                       DecisionTreeClassifier     分类决策树
ensemble                   RandomForestClassifier     随机森林分类
ensemble                   GradientBoostingClassifier 梯度提升分类树
'''

# -------------------------------回归模型构建（连续）--------------------------------
'''
模块                     函数                     算法名称
linear_model               LinearRegression           线性回归
svm                            SVR                            支持向量机回归
neighbors                  KNeighborsRegressor            最近邻回归
tree                       DecisionTreeRegressor      回归决策树
ensemble                   RandomForestRegressor      随机森林回归
ensemble                   GradientBoostingRegressor  梯度提升回归树
'''

# -------------------------------KMeans 算法--------------------------------
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3, random_state=123).fit(data)
print(kmeans.labels_)

# 对数据要进行标准化， 因为要进行计算时，特征x与y应该对等，若差别太大，会削弱其中一个特征的作用
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 标准差标准化，x-均值/标准差
scale = StandardScaler().fit(data)               # 训练规则
X = scale.transform(data)                        # 应用规则
kmeans = KMeans(n_clusters=3, random_state=123).fit(X)
# print(kmeans.labels_)

# 离差标准化， x-min/max-min
scale = MinMaxScaler().fit(data)                 # 训练规则
X = scale.transform(data)                        # 应用规则
kmeans = KMeans(n_clusters=3, random_state=123).fit(X)
# print(kmeans.labels_)

# 检验kmeans的优劣度,silhoutte_scorce和c
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt
silhouettteScore = []
for i in range(2, 15):
    kmeans = KMeans(n_clusters=i, random_state=123).fit(X)                      # 构建并训练模型
    score = silhouette_score(X, kmeans.labels_)
    silhouettteScore.append(score)
plt.figure(figsize=(10, 6))
plt.plot(range(2, 15), silhouettteScore, linewidth=1.5, linestyle="-")
plt.show()

# -------------------------------KNN分类算法(不适合用高维)--------------------------------
# 数据集划分
'''
一般在日常工作中将数据集拆分为训练集（train_set）和测试集（test_set）
训练集：一般用于训练模型，需要尽可能保证训练的数据具有代表性。
测试集：用于测试模型，检测模型的性能（包括了运行时间，模型的效果等）
trian_test_split(*arrays,train_size,test_size,ramdom_state)
*arrays：表示需要进行划分的数据，可以为多个。
train_size：训练集所占总数据的比例，0-1的浮点数。无默认
test_size：测试集所占总数据的比例，和train_size相加为1，在填写了train_size的情况下可以省略
random_state：设置随机种子，保证后续每次划分的结果相同
'''
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X = data['data']
y = data['target']
names = data['feature_names']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# 标准化
from sklearn.preprocessing import StandardScaler
Standard = StandardScaler().fit(X_train)             # 训练产生标准化的规则,因为数据集分为训练与测试，测试相当于后来的。

Xtrain = Standard.transform(X_train)                 # 将规则应用于训练集
Xtest = Standard.transform(X_test)                   # 将规则应用于测试集
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier().fit(Xtrain, y_train)
y_pred = knn.predict(Xtest)

# 分类算法评价常用函数,只适用于2分类。要么是要么否
'''
方法名称               最佳值                sklearn函数
Precision（精确率）     1.0                    metrics.precision_score
Recall（召回率）        1.0                    metrics.recall_score
F1值                    1.0                    metrics.f1_score
Cohen’s Kappa系数        1.0                    metrics.cohen_kappa_score
ROC曲线                  最靠近y轴          metrics. roc_curve
AUC(ROC的积分)          1.0                 metrics.auc
'''
from sklearn.metrics import precision_score, recall_score, f1_score, cohen_kappa_score, roc_curve
# print(precision_score(y_test, y_pred))
# print(recall_score(y_test, y_pred))
# print(f1_score(y_test, y_pred))
# print(cohen_kappa_score(y_test, y_pred))
# print(roc_curve(y_test, y_pred))

# 输出上述的常用判定函数值
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

# 绘制roc曲线
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = 'SimHei'  # 改字体
# 求出ROC曲线的x轴和Y轴
fpr, tpr, thresholds = roc_curve(y_test, y_pred)
plt.figure(figsize=(10, 6))
plt.xlim(0, 1)                              # 设定x轴的范围
plt.ylim(0.0, 1.1)                          # 设定y轴的范围
plt.xlabel('假正率')
plt.ylabel('真正率')
plt.plot(fpr, tpr, linewidth=2, linestyle="-", color='red')
plt.show()