Python数据分析pandas类库常用方法总结（终结篇）

壹、pandas的核心是Series和DataFrame两大数据结构，其中，Series数据结构是用于存储一个序列的一维数组，而DataFrame数据结构则是用于存储复杂数据的二维数据结构

import pandas as  pd
import numpy as np
#创建一个Series   :pd.Series(序列,数组,Series ，字典{name:'zhangs',age:12,sex:'男'}   )
#通过一个序列 （列表创建）
li = [3,5,5,25,5,12,15,25]
se1 = pd.Series(li)
print(se1)

#通过一个np数组创创建一个Series
arr = np.array(['a','b','c','d'])
se2 = pd.Series(arr,index=[2,3,4,5])
arr[2] ='e'
print(arr)
print('se2:',se2)
#通过一个Series对象创建一个Series
se3 = pd.Series(se1)
print(se3)
#通过一个字典对象创建一个Series
dit ={'name':'zhangs','age':12,'sex':'男','num':101}
se3 = pd.Series(dit)
print(se3)
#1.2 查看Series 的和标签
print(se3.index)
print(se3.values)
print(se1.values)
print(se1[1])
print(se1[1:3])
print(se2[2:4])
print(se3[['name','age','num']])
print(se3['name':'sex'])
print(se1[se1>10])
#      4       3
se1 = se1 + se1[se1>10]
print(se1)

# 统计方法
l1 = [3,5,5,25,5,12,15,25]
s1 = pd.Series(l1)
a = s1.unique() #去重复
print(a)
b= s1.value_counts() #查看元素重复次数
print(b)
c =s1.isin([1,3,5,7,15]) #判断是否在列表元素中
print(c)
print(s1[c])

import pandas as pd
from pandas import Series,DataFrame
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

file = r'./train.csv'
# 1、加载数据
df = pd.read_csv(file)  #加载数据
df1 =df.head(10)  #加载前5行数据
#print(df1)
df.info()  #查看数据信息
#df.isnull() 方法可以判断哪个值是缺失值，如果缺失返回True，否则为False
print(df.isnull().sum())  #查看缺失值
# 2、处理缺失值
# 查看数据集中哪些变量存在缺失值
# 由此可见，Embarked/cabin/Age三个变量存在缺失值
# 处理过程如下：
# 2.1 处理变量Embarked的缺失值，由于该变量只存在2个缺失值，将Embarked最常见的水平值（众数）赋给缺失值。

# df.fillna(0) 用0填充所有空值
#df.mode(axis=1)#每列/行中出现最多的值
#df.iloc[0]#iloc用行编号选取行数据
print(df["Embarked"].mode())
print(df["Embarked"].mode().iloc[0])
df["Embarked"] = df["Embarked"].fillna(df["Embarked"].mode().iloc[0])
#print(df.isnull().sum())  查看缺失值
# 2.2 处理变量cabin的缺失值，该变量大部分缺失
# 但是是否缺失对于存活率有很大影响，不缺失的样本存活率远高于缺失样本：见下图
# 由该图可知，可将"变量cabin是否缺失"作为新的变量
#重新定义一列cabin_na 存是 True 或者是False
df["cabin_na"] = df["Cabin"].isnull()
print(df.head())
#df.groupby(‘客户分类’).sum()#客户分类后求和运算
#
print(df[["cabin_na","Survived"]])
#groupby 分组函数
#活着的人数
cabin_perc = df[["cabin_na","Survived"]].groupby(["cabin_na"],as_index=False).sum()
#所有人数
cabin_perc2 = df[["cabin_na","Survived"]].groupby(["cabin_na"],as_index=False).count()
#存活率
cabin_perc3 = df[["cabin_na","Survived"]].groupby(["cabin_na"],as_index=False).mean()
#print(df[["cabin_na","Survived"]].groupby(["cabin_na"],as_index=False).mean())
# cabin_perc = df[["cabin_na","Survived"]].groupby(["cabin_na"],as_index=False).mean()
print(cabin_perc)
print(cabin_perc2)
print(cabin_perc3)

fig, (axis1,axis2) = plt.subplots(1,2,figsize=(10,4))
sns.countplot(x="cabin_na", data=df, ax=axis1)#countplot
sns.barplot(x="cabin_na", y="Survived", data=cabin_perc3, ax=axis2)



# 2.3  处理变量Age的缺失值
# 首先尝试利用中位数填补Age的缺失值，发现填补后的数据分布与原数据分布相差较大
fig,(axis1,axis2) = plt.subplots(2,1,figsize=(13,8))
print(df["Age"].dropna())
df["Age"].dropna().hist(bins=70,ax=axis1)
#palplot是创建调色板  color_palette（颜色空间，设置几种颜色块）
c1, c2 = sns.color_palette("Set1", 2)

axis2.set_xlim([0,80])
sns.kdeplot(df.Age.dropna(), shade=True, color=c1,  ax=axis2)
print("---------------")
print(df.Age.fillna(df.Age.dropna().median()))
sns.kdeplot(df.Age.fillna(df.Age.dropna().median()), shade=True, color=c2, label="new", ax=axis2)

#sns.kdeplot() countplot() barplot()

average_age = df["Age"].mean() #平均年龄 29.69
std_age = df["Age"].std() #标准差14.526497332334042
count_nan_age = df["Age"].isnull().sum()
rand = np.random.randint(average_age - std_age,average_age + std_age,size=count_nan_age)
df["Age_Original"] = df["Age"]
df["Age"][np.isnan(df["Age"])] = rand
df["Age"] = df["Age"].astype(int)
# # 原始和填补缺失值的Age分布对比图如下，效果较好
fig,axis1 = plt.subplots(1,1,figsize=(13,4))
c1, c2 = sns.color_palette("Set1",2)
axis1.set_xlim([0,df["Age"].max()])
sns.kdeplot(df.Age_Original.dropna(),shade=True,color=c1,ax=axis1)
sns.kdeplot(df.Age,shade=True,color=c2,ax=axis1)
plt.show()

#读取mysql数据库的一个表，生成excl
from sqlalchemy import create_engine
import pandas as pd
engine = create_engine('mysql+pymysql://root:x5@localhost:3306/student?charset=gb2312')
#print(engine)
# 当前数据库下所有的表
#tables = pd.read_sql_query('show tables',con=engine)
#print(tables)
# 查询某一张表
#dftable = pd.read_sql_table('tstudent',con=engine)
#print(dftable)
# 将mysql 复杂查询 结果生成一个excl
dftable2 = pd.read_sql_query("select * from tstudent ",con=engine)
print(dftable2)
#将表格的数据生成excl
dftable2.to_excel('./tstudent.xls')

#通过读取excl 将读取的结果写入到数据库中
file = r'./train.csv'
df = pd.read_csv(file)
df.to_sql('train',con=engine,if_exists='replace')


#pd 处理JSON格式的数据

贰、分布分析

import numpy as np
import pandas as pd

df = pd.read_excel(r'./Employee_income.xls',
                   sheet_name='emp_income')
#年龄分布状况
age_bins = [20,30,40,50,60]
age_labels = ['20-30岁', '31-40岁', '41-50岁', '51-60岁']
df['年龄分层']=pd.cut(df.age, age_bins, labels=age_labels)
print(df)
#分组统计人数、平均月薪、最高月薪和最低月薪
aggResult = df.groupby('年龄分层')['salary'].agg({
    ('人数', np.size),
    ('平均月薪', np.mean),
    ('最高月薪', np.max),
    ('最低月薪', np.min),
})
print(aggResult)

叁、交叉分析交叉表

import pandas as pd
import numpy as np
df = pd.read_excel(r'./Employee_income.xls',
                   sheet_name='emp_income')
age_bins = [20,30,40,50,60]
age_labels = ['20-30岁', '31-40岁', '41-50岁', '51-60岁']
df['年龄分层']=pd.cut(df.age, age_bins, labels=age_labels)
# 按性别（sex）分组，统计各个分组中学历的频数
ctResult = pd.crosstab(df['年龄分层'], df['education'])
print(ctResult)

肆、相关分析

import pandas as pd

df = pd.read_excel(r'./Employee_income.xls',
                   sheet_name='emp_income')

#计算age和salary的相关系数
corrResult1 = df.age.corr(df.salary)
print('age和salary的相关系数',corrResult1)

#计算age和salary、subsidy的相关系数
corrResult2 = df.loc[:,['age', 'salary', 'subsidy']].corr()
print('age和salary、subsidy的相关系数\n',corrResult2)

# 返回一个相关系数矩阵
print('返回一个相关系数矩阵\n',df.corr())

伍、结构分析

import numpy as np
import pandas as pd

df = pd.read_excel(r'./Employee_income.xls',sheet_name='emp_income')
#年龄分布状况
age_bins = [20,30,40,50,60,70]
age_labels = ['20-29岁', '30-39岁', '40-49岁', '50-59岁','60-69岁']
df['年龄分层']=pd.cut(df.age, age_bins, right=False, labels=age_labels)

ptResult = df.pivot_table(
    values=['age'],
    index=['年龄分层'],
    columns=['education'],
    aggfunc=[np.size]
)
print(ptResult)

print(ptResult.div(ptResult.sum(axis=0), axis=1))
print(ptResult.div(ptResult.sum(axis=1), axis=0))
#div的第一个参数是除法的分母，意思是按行把数据除以该列的总和。即得到某一个年龄分层下，学历占比。

陆、决策树预测举例

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import tree
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
test = pd.read_csv(r'D:\期末上交资料\数据分析与挖掘\01 决策树课件数据源码\test.csv')
test.drop(["Name","Cabin","Ticket"],inplace =True, axis=1)
test = test.dropna()
test.loc[:,"Sex"] =(test["Sex"] == "male").astype("int")
tlables = test["Embarked"].unique().tolist()
test["Embarked"] = test["Embarked"].apply(lambda x: tlables.index(x))


clf = tree.DecisionTreeClassifier(random_state=30,
                                  max_depth=3)
clf = clf.fit(Xtrain,Ytrain) #用训练集数据训 模型
flag = clf.predict(test)
flag
test["Survived"] =flag
test.to_csv(r'D:\期末上交资料\数据分析与挖掘\01 决策树课件数据源码\res.csv')

柒、十字交叉验证求平均

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt


wine = load_wine()
rfc = RandomForestClassifier(random_state=30,n_estimators=25)
rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10)

clf = DecisionTreeClassifier(random_state=30)
clf_s = cross_val_score(clf,wine.data,wine.target,cv=10)
plt.plot(range(1,11),rfc_s,label="RandomForestClassifier")
plt.plot(range(1,11),clf_s,label="DecisionTreeClassifier")
plt.legend()
plt.show()

arr_rfc =[]
arr_clf =[]
for i in range(10):
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
    arr_rfc.append(rfc_s)
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,wine.data,wine.target,cv=10).mean()
    arr_clf.append(clf_s)

plt.plot(range(1,11),arr_rfc,label="RandomForestClassifier")
plt.plot(range(1,11),arr_clf,label="DecisionTreeClassifier")
plt.legend()
plt.show()

捌、用随机森林回归填补缺失值

运行单元|运行本单元及下方单元|调试单元
# In[3]:


import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston
from sklearn.impute import SimpleImputer#填补缺失值的类
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score

运行单元|运行本单元及下方单元|调试单元
# In[4]:


#用随机森林回归填补缺失值
#1.将load_boston数据集的数据认为加工成有一部分为null的数据 50%
#2.对50%null值进行处理，1）用0 填补 2）用均值填补 3)采用随机森林的算法进行填补   加原始数据集  有4个数据集，采用交叉验证将数据集打分
dataset = load_boston()
dataset#是一个字典

运行单元|运行本单元及下方单元|调试单元
# In[5]:


dataset.target#查看数据标签
dataset.data#数据的特征矩阵
dataset.data.shape#特征数据的结构   #506行  13列

运行单元|运行本单元及下方单元|调试单元
# In[6]:


#X_full 所有特征数据集，由普通的列 原始数据
#y_full 标签列组成的数据集
X_full, y_full = dataset.data, dataset.target
n_samples = X_full.shape[0]    #   =506  数据行数
n_features = X_full.shape[1]   #    =13  数据列数

运行单元|运行本单元及下方单元|调试单元
# In[ ]:




运行单元|运行本单元及下方单元|调试单元
# In[7]:


#1.将load_boston数据集的数据认为加工成有一部分为null的数据 50%
#首先确定我们希望放入的缺失数据的比例，在这里我们假设是50%，那总共就要有3289个数据缺失
rng = np.random.RandomState(0)#设置一个随机种子，方便观察
missing_rate = 0.5
n_missing_samples = int(np.floor(n_samples * n_features * missing_rate))#3289  #计算需要产生多少个null值

运行单元|运行本单元及下方单元|调试单元
# In[8]:


#np.floor向下取整，返回.0格式的浮点数
 
#所有数据要随机遍布在数据集的各行各列当中，而一个缺失的数据会需要一个行索引和一个列索引
#如果能够创造一个数组，包含3289个分布在0~506中间的行索引，和3289个分布在0~13之间的列索引，那我们就可以利用索引来为数据中的任意3289个位置赋空值
#然后我们用0，均值和随机森林来填写这些缺失值，然后查看回归的结果如何
#                                 13个特征列     3289个需要的null数
#rng.randint(0,10,5)
missing_features = rng.randint(0,n_features,n_missing_samples)#randint（下限，上限，n）指在下限和上限之间取出n个整数
len(missing_features)#3289
#                                 506行样本
missing_samples = rng.randint(0,n_samples,n_missing_samples)
len(missing_samples)#3289
 

运行单元|运行本单元及下方单元|调试单元
# In[54]:


#备份一个数据  X_missing将要搞破坏的数据
X_missing = X_full.copy()  # X_missing  普通列 （506，13）
y_missing = y_full.copy()  # y_missing  标签列
# missing_samples 0-506 ，missing_features：0-13
X_missing[missing_samples,missing_features] = np.nan
X_missing

运行单元|运行本单元及下方单元|调试单元
# In[55]:


X_missing = pd.DataFrame(X_missing)
#转换成DataFrame是为了后续方便各种操作，numpy对矩阵的运算速度快到拯救人生，但是在索引等功能上却不如pandas来得好用
X_missing.head()

运行单元|运行本单元及下方单元|调试单元
# In[56]:


#使用均值进行填补
from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')#实例化

X_missing_mean = imp_mean.fit_transform(X_missing)#特殊的接口fit_transform = 训练fit + 导出predict
#pd.DataFrame(X_missing_mean).isnull().sum()
# X_missing_mean 用均值的方式填补null的数据集
imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant",fill_value=0)#constant指的是常数
X_missing_0 = imp_0.fit_transform(X_missing)
#X_missing 有null值的所有特征列  
#X_missing_mean ：用均值代替null的所有特征列 
#X_missing_0：用0代替null的所有特征列
#X_full 代表的是原始特征列 506行13列的数据

运行单元|运行本单元及下方单元|调试单元
# In[57]:


pd.concat([pd.DataFrame(X_missing),pd.DataFrame(y_missing)],axis=1)

运行单元|运行本单元及下方单元|调试单元
# In[58]:


X_missing_reg = X_missing.copy()

#找出数据集中，缺失值从小到大排列的特征们的顺序，并且有了这些的索引
sortindex =np.argsort(X_missing_reg.isnull().sum()).values#np.argsort()返回的是从小到大排序的顺序所对应的索引
sortindex

运行单元|运行本单元及下方单元|调试单元
# In[59]:


for i in sortindex:
    
    #构建我们的新特征矩阵（没有被选中去填充的特征 + 原始的标签）和新标签（被选中去填充的特征）
    df = X_missing_reg
    fillc = df.iloc[:,i]#新标签
    df = pd.concat([df.iloc[:,df.columns != i],pd.DataFrame(y_full)],axis=1)#新特征矩阵
    
    #在新特征矩阵中，对含有缺失值的列，进行0的填补
    df_0 =SimpleImputer(missing_values=np.nan,strategy='constant',fill_value=0).fit_transform(df)
                        
    #找出我们的训练集和测试集
    Ytrain = fillc[fillc.notnull()]# Ytrain是被选中要填充的特征中（现在是我们的标签），存在的那些值：非空值
    Ytest = fillc[fillc.isnull()]#Ytest 是被选中要填充的特征中（现在是我们的标签），不存在的那些值：空值。注意我们需要的不是Ytest的值，需要的是Ytest所带的索引
    Xtrain = df_0[Ytrain.index,:]#在新特征矩阵上，被选出来的要填充的特征的非空值所对应的记录
    Xtest = df_0[Ytest.index,:]#在新特征矩阵上，被选出来的要填充的特征的空值所对应的记录
    
    #用随机森林回归来填补缺失值
    rfc = RandomForestRegressor(n_estimators=100)#实例化
    rfc = rfc.fit(Xtrain, Ytrain)#导入训练集进行训练
    Ypredict = rfc.predict(Xtest)#用predict接口将Xtest导入，得到我们的预测结果（回归结果），就是我们要用来填补空值的这些值
    
    #将填补好的特征返回到我们的原始的特征矩阵中
    X_missing_reg.loc[X_missing_reg.iloc[:,i].isnull(),i] = Ypredict

运行单元|运行本单元及下方单元|调试单元
# In[61]:


X_missing_reg