【Python基础训练营】5. Python之Pandas(python版的excel)

目录

1. Pandas简介
2. 两种数据结构（Series和DataFrame数据结构）
3. 相关操作

1. Pandas简介

1. Pandas是基于NumPy的一个开源Python库，它被广泛用于快速分析数据，以及数据清洗和准备等工作。
2. Pandas中有两类非常重要的数据结构，就是序列Series和数据框DataFramne。
3. Series类似于NumPy中的__一维数组__，可以使用一维数组的可用函数和方法，而且还可以通过索引标签的方式。
4. 获取数据，具有索引的自动对齐功能。
5. DataFrame类似于numpy的__二维数组__，同样可以使用numpy数组的函数和方法，还具有一些其它灵活的使用。

2. Series和DataFrame数据结构

• pd.Series()：
  • 通过一维数组创建序列；
  • 通过字典的方式创建序列；
  • 通过DataFrame中的某一行或者某一列创建序列。
• pd.DataFrame():
  • 通过二维数组创建；
  • 通过字典方式创建；
  • 通过数据框创建。

  2.1 通过索引值或索引标签获取数据

  2.1.1 建立带有索引的数组

import pandas as pd
import numpy as np
s5=pd.Series(np.array([1,2,3,4,5,6]))#对数组自动生成索引

In：

#如果不给序列一个指定索引值，序列会自动生成一个从0开始的自增索引
print(s5)

Out：

1    2
2    3
3    4
4    5
5    6
dtype: int32

In：

#通过index属性获取序列的索引值
print(s5.index)

Out：

RangeIndex(start=0, stop=6, step=1)

In：

#为index重新赋值,数量要对应
s5.index=['a','b','c','d','e','f']
print(s5)

Out：

a    1
b    2
c    3
d    4
e    5
f    6
dtype: int32

2.1.2 使用索引的数组

#序列有了索引，就可以通过索引获取数据
print(s5[3])#索引第4个数，输出为4
print(s5['e'])#索引为e的值，输出为5

In：

print(s5[[1,2,4]])#索引第2,3,5个数，注意两个[]

Out：

b    2
c    3
e    5
dtype: int32

In：

#索引第0-3个数
print(s5[:4])

Out：

a    1
b    2
c    3
d    4
dtype: int32

In：

#索引c到结尾
print(s5['c':])

Out：

c    3
d    4
e    5
f    6
dtype: int32

In：

#从索引b到e
print(s5['b':'e'])

Out：

b    2
c    3
d    4
e    5
dtype: int32

2.2 自动化对齐

In：

s6=pd.Series(np.array([10,15,20,30,55,80]),index=['a','b','c','d','e','f'])
print('序列6\n',s6)
s7=pd.Series(np.array([12,11,13,15,14,16]),index=['a','c','g','b','d','f'])
print('序列7\n',s7)
#s6中不存在g索引，s7中不存在e索引，所以数据运算会产生两个缺失值NaN。
print(s6+s7)

Out：

a    22.0
b    30.0
c    31.0
d    44.0
e     NaN
f    96.0
g     NaN

In：

#可以注意到这里的算术运算自动实现了两个序列的自动对齐
#对于数据框的对齐，不仅是行索引的自动对齐，也会是对列索引进行自动对齐，数据框相当于二维数组的推广。
print(s6/s7)

Out：

a    0.833333
b    1.000000
c    1.818182
d    2.142857
e         NaN
f    5.000000
g         NaN

3. 相关操作

3.1 查询数据

• 查询数据，我们需要使用索引有针对的选取原数据中的子集，指定行，指定列等。
• 无论数据框还是序列，最左侧始终有一个非原始数据对象，这个就是接下来要介绍的数据索引。
• 通过索引获取目标数据，对数据进行一系列的操作。
  • 通过index属性获取序列的索引值
  • 更改index
  • 通过索引获取数据
  • 自动化对齐

#通过布尔索引有针对的选取原数据的子集，指定行，指定列等。
（windows下地址）
test_data=pd.read_csv("F:/day 4/day4_pandas/test_set.csv")
#head()表示查看前5行数据
print(test_data.head())
#字符串特征转化为模型可以识别的数字特征,从数字0开始
test_data['job'],jnum=pd.factorize(test_data['job'])
test_data['job']=test_data['job']+1#把从数字0变成从1开始

test_data['marital'],jnum=pd.factorize(test_data['marital'])
test_data['marital']=test_data['marital']+1

test_data['education'],jnum=pd.factorize(test_data['education'])
test_data['education']=test_data['education']+1

test_data['default'],jnum=pd.factorize(test_data['default'])
test_data['default']=test_data['default']+1

test_data['housing'],jnum=pd.factorize(test_data['housing'])
test_data['housing']=test_data['housing']+1

test_data['loan'],jnum=pd.factorize(test_data['loan'])
test_data['loan']=test_data['loan']+1

test_data['contact'],jnum=pd.factorize(test_data['contact'])
test_data['contact']=test_data['contact']+1

test_data['month'],jnum=pd.factorize(test_data['month'])
test_data['month']=test_data['month']+1

test_data['poutcome'],jnum=pd.factorize(test_data['poutcome'])
test_data['poutcome']=test_data['poutcome']+1

print(test_data.head())#查询数据的前5行
print(test_data.tail())#查询数据的末5行
print(test_data.iloc[[0,2,4,5,7]])#查询数据的指定行
print(test_data[['age','job','marital']].head())#查询数据的指定列

 Out：（上面最后一行输出）

   age  job  marital
0   51    1        1
1   32    2        1
2   60    3        1
3   32    4        2
4   41    1        1

In：

print(test_data.loc[[0,2,4,5,7],['age','job','martial']])#查询指定行指定列

 Out：

   age  job  martial
0   51    1      NaN
2   60    3      NaN
4   41    1      NaN
5   26    5      NaN
7   31    4      NaN

3.2 通过布尔索引实现数据子集查询

In：

#查询年龄为51的信息
print(test_data[test_data['age']==51].head())

 Out：

        ID  age  job  marital  ...  campaign  pdays  previous  poutcome
0    25318   51    1        1  ...         3     -1         0         1
95   25413   51    2        1  ...         1    180         6         4
350  25668   51    5        1  ...         2     -1         0         1
408  25726   51    8        1  ...         2     -1         0         1
573  25891   51   10        1  ...         2     -1         0         1
'''

【说明】多个条件的查询，需要在&或者\的两段的条件括起来

In：

#查询工作为5以上，年龄在51的人员信息
print(test_data[(test_data['age']==51)&(test_data['job']>=5)].head())

Out：

        ID  age  job  marital  ...  campaign  pdays  previous  poutcome
350  25668   51    5        1  ...         2     -1         0         1
408  25726   51    8        1  ...         2     -1         0         1
573  25891   51   10        1  ...         2     -1         0         1
610  25928   51    8        1  ...         5     -1         0         1
618  25936   51    5        3  ...         4     -1         0         1

In：

#查询工作为5以上，年龄在51的人员的housing,loan,contact和poutcome
print(test_data[(test_data['age']==51)&(test_data['job']>=5)][['education','housing','loan','contact','poutcome']].head())

Out：

     education  housing  loan  contact  poutcome
350          4        1     2        2         1
408          1        2     1        3         1
573          3        1     2        2         1
610          3        1     1        2         1
618          4        1     2        2         1

补充：

#输出处理过数据的csv文件
test_data.t o_csv("F:/day 4/day4_pandas/test_set_processing.csv")

3.3 统计分析

Pandas为我们提供了很多描述性统计分析的指标函数，包括，总和，均值，最小值，最大值等。

• Series和DataFrame
• 总和（df.shape:维度）
• 均值（ df.info：数据表的基本信息（维度，列名称，数据格- 式，所占空间等））
• 最大最小值（ df.dtypes：每一列数据的格式）
• 众数 （ df.columns:查看列名称）
• …

3.3.1 Series和DataFrame

In：

#构造随机数组a
a=np.random.normal(size=10)
d1=pd.Series(2*a+3)
print(d1)

Out：

0    5.805875
1    3.572778
2    6.134968
3   -0.374326
4    4.835445
5    2.751821
6    2.439271
7    0.329361
8    5.286590
9    2.032464

In：

d2=np.random.f(2,4,size=10)#随机浮点数，size表示个数
d3=np.random.randint(1,100,size=10)#随机取值范围[1, 100)，size表示个数
print(d2)#[0.10483054 0.03396298 2.81558747 1.45152955 0.77410974 0.75929649 0.1302249  0.35372686 1.29485497 7.79373261]
print(d3)#[34 69 77 20 31 85 48 78 47 49]
print(d1.count())#非空元素的计算，10
print(d1.min())#最小值，-0.3743261868298351
print(d1.max())#最大值，6.134967720218656
print(d1.idxmin())#最小值位置（索引号），3
print(d1.idxmax())#最大值位置（索引号），2
print(d1.quantile())#10%分数位，3.1622995602439827
print(d1.sum())#求和
print(d1.mean())#求均值
print(d1.median())#求中位数
print(d1.mode())#求众数
print(d1.var())#方差
print(d1.std())#标准差
print(d1.mad())#平均绝对偏差
print(d1.skew())#偏度
print(d1.kurt())#峰度
print(d1.describe())#一次性输出多个描述性统计指标

Out：（d1.describe()的输出）

'''
count    10.000000
mean      3.697869
std       1.807103
min       1.235592
25%       2.638097
50%       3.370503
75%       4.825244
max       7.080197
'''

In：

#自定义一个函数，将这些统计面熟指标全部汇总到一起
def stats(x):
  return pd.Series([x.count(),x.min(),x.idxmin(),x.quantile(.25),x.median(),x.quantile(.75),
                    x.mean(),x.max(),x.idxmax(),x.mad(),x.var(),x.std(),x.skew(),x.kurt()],
                   index=['Count','Min','Which_Min','Q1','Median','Q3','Mean','Max','Which_Max','Mad',
                   'Var','Std','Skew','Kurt'])
print(stats(d1))

Out：

Count        10.000000
Min          -2.204165
Which_Min     1.000000
Q1            0.924661
Median        2.370822
Q3            4.713006
Mean          2.361523
Max           5.749974
Which_Max     8.000000
Mad           2.196318
Var           7.377872
Std           2.716224
Skew         -0.361785
Kurt         -0.976224

In：

#当实际工作中我们需要处理的是一系列的数值型数据框，可以使用apply函数将这个stats函数应用到数据框中的每一列
df=pd.DataFrame(np.array([d1,d2,d3]).T,columns=['x1','x2','x3'])
print(df.head())

Out：

         x1         x2    x3
0  4.124788   5.826232  56.0
1  1.483892  10.581340  10.0
2  5.473072   0.132211  99.0
3  1.588564   0.063255  47.0
4  2.731951   0.729150  12.0

In：

print(df.apply(stats))

Out：

                  x1         x2          x3
Count      10.000000  10.000000   10.000000
Min        -0.319289   0.019682   20.000000
Which_Min   3.000000   6.000000    3.000000
Q1          2.031417   0.199343   43.250000
Median      2.119055   0.627383   55.500000
Q3          2.906481   2.206590   63.000000
Mean        2.749894   1.310031   55.200000
Max         6.979073   3.797169   94.000000
Which_Max   7.000000   1.000000    9.000000
Mad         1.446468   1.208230   17.600000
Var         4.168743   1.964631  550.177778
Std         2.041750   1.401653   23.455869
Skew        1.024424   0.812573    0.239583
Kurt        1.432761  -0.902670   -0.372235

以上很简单的创建了数值型数据的统计性描述，但对于离散型数据就不能使用该方法了。

In：

#我们在统计离散变量的观测数、唯一值个数、众数水平及个数，只需要使用describe方法就可以实现这样的统计了。
train_data=pd.read_csv("F:/day 4/day4_pandas/train_set.csv")
#test_data.drop(['ID'],inplace=True,axis=1)
print(train_data.head())

Out：

   ID  age         job   marital  ... pdays previous  poutcome  y
0   1   43  management   married  ...    -1        0   unknown  0
1   2   42  technician  divorced  ...   251        2     other  0
2   3   47      admin.   married  ...    -1        0   unknown  0
3   4   28  management    single  ...    -1        0   unknown  0
4   5   42  technician  divorced  ...    -1        0   unknown  0

In：

print(train_data['job'].describe())

Out：

count           25317
unique             12
top       blue-collar
freq             5456
Name: job, dtype: object

In：

print(test_data['job'].describe())

Out：

count    10852.000000
mean         5.593255
std          2.727318
min          1.000000
25%          3.000000
50%          6.000000
75%          8.000000
max         12.000000

In：

#除了以上简单的面熟新统计之外，还提供了连续变量的相关系数（corr）和协方差（cov）的求解
print(df)

Out：

        x1        x2    x3
0  5.236092  0.716670   8.0
1  1.377705  0.780115  37.0
2  2.798303  0.841277  59.0
3  5.771967  2.592392  89.0
4  0.784508  2.648356  65.0
5  3.412906  1.227642  96.0
6  6.119422  1.855159   8.0
7  0.878728  0.300718  97.0
8  3.725962  0.263673  77.0
9  4.439775  0.227011  81.0

In：

print(df.corr())#相关系数的计算方法可以电泳pearson方法、kendall方法、或者spearman方法，默认使用的是pearson方法

Out：

         x1        x2        x3
x1  1.000000  0.576035 -0.049064
x2  0.576035  1.000000 -0.215028
x3 -0.049064 -0.215028  1.000000 

In：

print(df.corr('spearman'))

Out：

         x1        x2        x3
x1  1.000000 -0.684848  0.090909
x2 -0.684848  1.000000 -0.490909
x3  0.090909 -0.490909  1.000000 

In：

print(df.corr('pearson'))

Out：

          x1        x2        x3
x1  1.000000  0.187580 -0.367241
x2  0.187580  1.000000 -0.148664
x3 -0.367241 -0.148664  1.000000

In：

print(df.corr('kendall'))

Out：

          x1        x2        x3
x1  1.000000 -0.219867 -0.603293
x2 -0.219867  1.000000 -0.219813
x3 -0.603293 -0.219813  1.000000

In：

#如果只关注某一个变量与其变量的相关系数的话，可以使用corrwith,如下方只关注x1与其余变量的相关系数
print(df.corrwith(df['x1']))

Out：

x1    1.000000
x2    0.420441
x3   -0.173017

In：

#数值型变量间的协方差矩阵
print(df.cov())

Out：

           x1        x2          x3
x1   4.273094  0.560952   11.356736
x2   0.560952  0.639441    5.745619
x3  11.356736  5.745619  861.955556

3.4 实现Sql操作

pandas实现对数据的增删改查。

• 【增】
  • 通过contact函数实现增加行
  • 通过colimns增加列
• 【删】
  • del:删除整个数据框
  • drop：删除指定行，列
• 【列】
  • 结合索引和复制的方式
• 【查】
  • groupby():聚合分组
  • sort_values():排序
  • merge():多表链接

In：

dict={'Name':['LiuShunxiang','Zhangshan'],
    'Sex':['M','F'],
    'Age':[27,23],
    'Height':[165.7,167.2],
    'Weight':[61,63]}
print(dict)#输出字典
student1=pd.DataFrame(dict)#字典转换为数据框形式
print(student1)

dict={'Name':['Liu','Zhang'],
      'Sex':['M','F'],
      'Age':[27,23],
      'Height':[165.7,167.2],
      'Weight':[61,63]}
student2=pd.DataFrame(dict)
print(student2)

Out：

           Name Sex  Age  Height  Weight
0  LiuShunxiang   M   27   165.7      61
1     Zhangshan   F   23   167.2      63

In：

#将student2中的数据新增到student1中，可以通过concat函数实现
student3=pd.concat([student1,student2],ignore_index='True')#concat函数对index无视
print(student3)

Out：

           Name Sex  Age  Height  weight
0  LiuShunxiang   M   27   165.7      61
1     Zhangshan   F   23   167.2      63
2           Liu   M   27   165.7      61
3         Zhang   F   23   167.2      63

In：

#添加新列--增加的新列没有赋值，就会出现NAN的形式
print(pd.DataFrame(student2,columns=['Age','Height','Name','Sex','Weight','Score']))

Out：

   Age  Height   Name Sex  Weight  Score
0   27   165.7    Liu   M     NaN    NaN
1   23   167.2  Zhang   F     NaN    NaN

In：

#删：删除表、观测行或变量列
#删除整个数据框
del student2
#print(student2)
#NameError: name 'student2' is not defined
#删除指定行
print(student3.drop([0]))

Out：

   Age  Height   Name Sex  Weight  Score
0   27   165.7    Liu   M     NaN    NaN
1   23   167.2  Zhang   F     NaN    NaN

In：

#删除25岁以下的学生
print(student3[student3['Age']<25])

Out：

        Name Sex  Age  Height  Weight
1  Zhangshan   F   23   167.2      63
3      Zhang   F   23   167.2      63

In：

#删除指定的列
print(student3.drop(['Height','Weight'],axis=1))

Out：

  Age          Name Sex  weight
0   27  LiuShunxiang   M    61.0
1   23     Zhangshan   F    63.0
2   27           Liu   M     NaN
3   23         Zhang   F     NaN

In：

#不论删除行还是列，都可以通过drop方法实现，只需要设定好删除的轴即可，即调整drop方法中的axis参数。
#默认参数为0，即删除行观测数据，如果需要删除列变量，则需要设置为1
#改：修改原始记录的值
#如果发现表中的数据错了，如何更改原来得值呢？尝试结合布尔索引和赋值的方法
print(student3)

Out：

  Age  Height          Name Sex  Weight  
0   27   165.7  LiuShunxiang   M     NaN    
1   23   167.2     Zhangshan   F     NaN    
2   27   165.7           Liu   M    61.0     
3   23   167.2         Zhang   F    63.0  

In：

#假设需要修改liu学生的身高为173
student3.loc[student3['Name']=='Liu','Height']=173
print(student3)

Out：

   Age  Height          Name Sex  Weight 
0   27   165.7  LiuShunxiang   M     NaN    
1   23   167.2     Zhangshan   F     NaN    
2   27   173.0           Liu   M    61.0    
3   23   167.2         Zhang   F    63.0 

In：

#查：类似上边的数据查询部分
#聚合：groupby()
print(student3.groupby('Sex').mean())

Out：

     Age  Height  Weight
Sex                     
F     23  167.20      63
M     27  169.35      61

In：

print(student3.groupby(['Sex','Age']).mean())

Out：

Sex Age                
F   23   167.20      63
M   27   169.35      61

In：

#对每个分组计算多个统计量
print(student3.drop('Age',axis=1).groupby('Sex').agg([np.mean,np.median]))

Out：

     Height         Weight       
      mean  median   mean median
Sex                              
F    167.20  167.20     63     63
M    169.35  169.35     61     61

In：

#排序：sort_values
series=pd.Series(np.array(np.random.randint(1,20,10)))
print(series)

Out：

0    17
1    11
2    13
3     5
4    19
5     4
6    11
7    18
8     2
9    15

In：

print(series.sort_values())#默认按值升序排列

Out：

9     2
0     5
7     5
2     6
5     8
1    14
4    14
3    16
6    17
8    19

In：

print(series.sort_values(ascending=False))#按降序排列

Out：

9    18
4    17
7    13
1     7
5     5
3     5
0     5
8     1
6     1
2     1

In：

#数据框中按值排列
print(student3.sort_values(by=['Sex','Age']))#默认升序排列，先按照Sex，再按Age来排序

Out：

           Name Sex  Age  Height  Weight
1     Zhangshan   F   23   167.2      63
3         Zhang   F   23   167.2      63
0  LiuShunxiang   M   27   165.7      61
2           Liu   M   27   173.0      61

In：

#多表链接-merge
dict2={'Name':['Alfred','Alice','Barbara','Carol','Henry','Jeffrey','Judy','Philip','Robert','William'],
     'Score':[88,76,89,67,79,90,92,86,73,77]}#字典
score=pd.DataFrame(dict2)
print(score)

Out：

      Name  Score
0   Alfred     88
1    Alice     76
2  Barbara     89
3    Carol     67
4    Henry     79
5  Jeffrey     90
6     Judy     92
7   Philip     86
8   Robert     73
9  William     77

In：

student3['Name']=['Alfred','Alice','Barbara','Carol']#更改数据框中’Name‘的名字
print(student3)

Out：

      Name Sex  Age  Height  Weight
0   Alfred   M   27   165.7      61
1    Alice   F   23   167.2      63
2  Barbara   M   27   173.0      61
3    Carol   F   23   167.2      63

In：

#把学生表和成绩表做一个关联(数据融合)
stu_score1=pd.merge(student3,score,on='Name')#默认请款改下是实现的是两个表之间的内连接，即返回两张表中共同部分的数据
print(stu_score1)

Out：

      Name Sex  Age  Height  Weight  Score
0   Alfred   M   27   165.7      61     88
1    Alice   F   23   167.2      63     76
2  Barbara   M   27   173.0      61     89
3    Carol   F   23   167.2      63     67

In：

stu_score1=pd.merge(student3,score,on='Name',how='inner')#使用how参数设置连接的方式，left为左连接，right为右连接，outer为外连接。
print(stu_score1)

Out：

      Name Sex  Age  Height  Weight  Score
0   Alfred   M   27   165.7      61     88
1    Alice   F   23   167.2      63     76
2  Barbara   M   27   173.0      61     89
3    Carol   F   23   167.2      63     67

In：

stu_score2=pd.merge(student3,score,on='Name',how='left')
print(stu_score2)#保留student3表中的所有信息，同时将score表的的信息与之配对，能配多少配多少，对于没有配上的Name,将会显示成绩为Nan

Out：

      Name Sex  Age  Height  Weight  Score
0   Alfred   M   27   165.7      61     88
1    Alice   F   23   167.2      63     76
2  Barbara   M   27   173.0      61     89
3    Carol   F   23   167.2      63     67

In：

stu_score2=pd.merge(student3,score,on='Name',how='right')
print(stu_score2)#保留student3表中的所有信息，同时将score表的的信息与之配对，能配多少配多少，对于没有配上的Name,将会显示成绩为Nan

Out：

     Name  Sex   Age  Height  Weight  Score
0   Alfred    M  27.0   165.7    61.0     88
1    Alice    F  23.0   167.2    63.0     76
2  Barbara    M  27.0   173.0    61.0     89
3    Carol    F  23.0   167.2    63.0     67
4    Henry  NaN   NaN     NaN     NaN     79
5  Jeffrey  NaN   NaN     NaN     NaN     90
6     Judy  NaN   NaN     NaN     NaN     92
7   Philip  NaN   NaN     NaN     NaN     86
8   Robert  NaN   NaN     NaN     NaN     73
9  William  NaN   NaN     NaN     NaN     77 

In：

stu_score2=pd.merge(student3,score,on='Name',how='outer')
print(stu_score2)#保留student3表中的所有信息，同时将score表的的信息与之配对，能配多少配多少，对于没有配上的Name,将会显示成绩为Nan

Out：

      Name  Sex   Age  Height  Weight  Score
0   Alfred    M  27.0   165.7    61.0     88
1    Alice    F  23.0   167.2    63.0     76
2  Barbara    M  27.0   173.0    61.0     89
3    Carol    F  23.0   167.2    63.0     67
4    Henry  NaN   NaN     NaN     NaN     79
5  Jeffrey  NaN   NaN     NaN     NaN     90
6     Judy  NaN   NaN     NaN     NaN     92
7   Philip  NaN   NaN     NaN     NaN     86
8   Robert  NaN   NaN     NaN     NaN     73
9  William  NaN   NaN     NaN     NaN     77

3.5 缺失值处理

• 删除法
  • 当数据中某个变量大部分值都是缺失时，可以考虑删除该变量；
  • 当缺失值随机分布的，且缺失的数量并不是很多时，可以删除这些缺失的观测；
  • 主要通过dropna完成，接下来就先学习一下dropna的用法。

In：

print(train_data.head())

Out：

ID  age         job   marital  ... pdays previous  poutcome  y
0   1   43  management   married  ...    -1        0   unknown  0
1   2   42  technician  divorced  ...   251        2     other  0
2   3   47      admin.   married  ...    -1        0   unknown  0
3   4   28  management    single  ...    -1        0   unknown  0
4   5   42  technician  divorced  ...    -1        0   unknown  0

In：

offline_data=pd.read_csv("F:/day 4/day4_pandas/ccf_offline_stage1_train.csv")
print(offline_data)

Out：

   User_id  Merchant_id  Coupon_id  ... Distance  Date_received        Date
0  1439408         2632        NaN  ...      0.0            NaN  20160217.0
1  1439408         4663    11002.0  ...      1.0     20160528.0         NaN
2  1439408         2632     8591.0  ...      0.0     20160217.0         NaN
3  1439408         2632     1078.0  ...      0.0     20160319.0         NaN
4  1439408         2632     8591.0  ...      0.0     20160613.0         NaN

In：

s=offline_data['Coupon_id']
#print(np.size(s))#1754884
#print(pd.isnull(s))#查看包含多少个缺失值，显示bool的列表
s=s.dropna(axis=0)#直接删除缺失值,要采用赋值的形式，默认情况下，dropna会删除任何含有缺失值的行
print(s)#1053282

#构造数据框试试
df=pd.DataFrame([[1,1,2],[3,5,np.nan],[13,21,34],[55,np.nan,10],[np.nan,np.nan,np.nan],[np.nan,1,2]],columns=['x1','x2','x3'])
print(df)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
1   3.0   5.0   NaN
2  13.0  21.0  34.0
3  55.0   NaN  10.0
4   NaN   NaN   NaN
5   NaN   1.0   2.0

In：

df1=df.dropna()
print(df1)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
2  13.0  21.0  34.0

In：

df2=df.dropna(how='all')#只删除所有行为缺失值的观测(第4行)
print(df2)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
1   3.0   5.0   NaN
2  13.0  21.0  34.0
3  55.0   NaN  10.0
5   NaN   1.0   2.0

In：

df3=df.dropna(how='any')#删除所有行为缺失值的观测
print(df3)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
2  13.0  21.0  34.0

In：

df=pd.DataFrame([[1,1,2,np.nan],[3,5,np.nan,np.nan],[13,21,34,np.nan],
               [55,np.nan,10,np.nan],[np.nan,np.nan,np.nan,np.nan],
               [np.nan,1,2,np.nan]],columns=['x1','x2','x3','x4'])
print(df)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
1   3.0   5.0   NaN NaN
2  13.0  21.0  34.0 NaN
3  55.0   NaN  10.0 NaN
4   NaN   NaN   NaN NaN
5   NaN   1.0   2.0 NaN

In：

df1=df.dropna(how='all',axis=1)#删除全为nan的那些列
print(df1)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
1   3.0   5.0   NaN
2  13.0  21.0  34.0
3  55.0   NaN  10.0
4   NaN   NaN   NaN
5   NaN   1.0   2.0

In：

df2=df.dropna(thresh=3)#在行方向上至少有3个非NAN的项保留
print(df2)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
2  13.0  21.0  34.0 NaN

In：

df3=df.dropna(thresh=1)
print(df3)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
1   3.0   5.0   NaN NaN
2  13.0  21.0  34.0 NaN
3  55.0   NaN  10.0 NaN
5   NaN   1.0   2.0 NaN

In：

df4=df.dropna(thresh=3,axis=1)#在列方向上至少保留有3个非NAN的项
print(df4)

Out：

     x1    x2    x3
0   1.0   1.0   2.0
1   3.0   5.0   NaN
2  13.0  21.0  34.0
3  55.0   NaN  10.0
4   NaN   NaN   NaN
5   NaN   1.0   2.0

• 替补法：
  • 对于连续变量，如果变量的分布近似或就是正态分布的话，可以用均值替代那些缺失值；
  • 如果变量是有偏的，可以使用中位数来代替那些缺失值；
  • 对于离散型变量，一般使用众数去途欢那些存在缺失的预测；
  • 主要通过fillna完成。
• fillna函数的参数：
  • value：用于填充缺失值的标量或者字典对象
  • method：插值方式，如果函数调用时，未指定其他参数的话默认fill
  • axis：待填充的轴默认值axis=0
  • inplace：修改调用这对象而不产生副本
  • limit：(对于前向和后向填充)可以连续填充的最大数量

In：

#使用一个常量来填充缺失值，可以使用fillna函数实现简单的填补工作
df5=df.fillna(0)#用0填补所有缺失值
print(df5)

Out：

     x1    x2    x3   x4
0   1.0   1.0   2.0  0.0
1   3.0   5.0   0.0  0.0
2  13.0  21.0  34.0  0.0
3  55.0   0.0  10.0  0.0
4   0.0   0.0   0.0  0.0
5   0.0   1.0   2.0  0.0

In：

#采用前项填充或者后项填充
df6=df.fillna(method='ffill')#用前一个观测值填充
print(df6)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
1   3.0   5.0   2.0 NaN
2  13.0  21.0  34.0 NaN
3  55.0  21.0  10.0 NaN
4  55.0  21.0  10.0 NaN
5  55.0   1.0   2.0 NaN

In：

df7=df.fillna(method='bfill')#用后一个观测值填充,这样会导致最后边的无法填充Nan
print(df7)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
1   3.0   5.0  34.0 NaN
2  13.0  21.0  34.0 NaN
3  55.0   1.0  10.0 NaN
4   NaN   1.0   2.0 NaN
5   NaN   1.0   2.0 NaN

In：

#使用常量填充不同的列
df8=df.fillna({'x1':1,'x2':2,'x3':3,'x4':5})
print(df8)

Out：

     x1    x2    x3   x4
0   1.0   1.0   2.0  5.0
1   3.0   5.0   3.0  5.0
2  13.0  21.0  34.0  5.0
3  55.0   2.0  10.0  5.0
4   1.0   2.0   3.0  5.0
5   1.0   1.0   2.0  5.0

In：

#使用均值或者中位数填充各自的列
x1_median=df['x1'].median()
x2_mean=df['x2'].mean()
x3_mean=df['x3'].mean()
print(x1_median,x2_mean,x3_mean)#8.0 7.0 12.0
df9=df.fillna({'x1':x1_median,'x2':x2_mean,'x3':x3_mean})
print(df9)

Out：

     x1    x2    x3  x4
0   1.0   1.0   2.0 NaN
1   3.0   5.0  12.0 NaN
2  13.0  21.0  34.0 NaN
3  55.0   7.0  10.0 NaN
4   8.0   7.0  12.0 NaN
5   8.0   1.0   2.0 NaN
#使用填充法时，相对于常数填充或者前向、后项填充，使用各列众数，均值或中位数填充要更加合理些，这也是工作中常用的一个快捷手段。

7、实现excel的数据透视表功能

pivot_table(data,values=None,index=None,aggfunc=‘mean’,fill_value=None,margins=False,dropna=True,margins_name=‘All’)

• data:需要进行数据透视表操作的数据框
• values：指定需要聚合的字段
• index:指定某些原始变量作为行索引
• columns:指定那些离散的分组变量
• aggfunc:指定相应的聚合函数
• fill_values:使用一个常数替代缺失值，默认不替换
• margins:是否进行行或列的汇总，默认不汇总
• dropna:默认所有观测为缺失的列
• margins_name:默认行汇总或列汇总的名称为’all‘

In：

print(test_data.head())

Out：

ID  age  job  marital  ...  campaign  pdays  previous  poutcome
0  25318   51    1        1  ...         3     -1         0         1
1  25319   32    2        1  ...         2     -1         0         1
2  25320   60    3        1  ...         3     -1         0         1
3  25321   32    4        2  ...         4    105         5         2
4  25322   41    1        1  ...         4     -1         0         1

In：

#marital作为分组变量，balance作为数值变量做统计汇总
fd=pd.pivot_table(test_data,values=['balance'],columns=['marital'])
print(fd)

Out：

marital            1            2            3
balance  1455.797641  1313.231841  1251.767347

In：

#marital作为1个分组变量，balance,housing作为两个数值变量做统计汇总
fd1=pd.pivot_table(test_data,values=['balance','housing'],columns=['marital'])
print(fd1)

Out：

marital            1            2            3
balance  1455.797641  1313.231841  1251.767347
housing     1.555051     1.529353     1.549388 

In：

#martial,job作为2个分组变量，balance作为1个数值变量做统计汇总
fd2=pd.pivot_table(test_data,values=['balance','housing'],columns=['marital','job'])
print(fd2)

Out：

 marital  job
balance  1        1      1228.493671
                 2      1785.391272
                 3      2353.951501
                 4       845.000000
                 5      1243.956701
                 6       977.805556
                 7      1364.432602
                 8      1243.585938
                 9      1579.081081
                 10     1952.578544
                 11     1270.040984
                 12     1749.975000
        2        1      1355.333333
                 2      1501.268148
                 3      1890.900000
                 4      1205.809322
                 5      1438.189147
                 6       878.873606
                 7      1236.768448
                 8      1047.812500
                 9      1716.306931
                 10     1367.694737
                 11     2158.580000
                 12      814.833333
        3        1      1166.673913
                 2      1801.176471
                 3      1454.990196
                 4      2946.000000
                 5       962.784141
                 6       940.809917
                           ...     
housing  1        7         1.601881
                 8         1.725361
                 9         1.459459
                 10        1.475096
                 11        1.573770
                 12        1.000000
        2        1         1.393939
                 2         1.482963
                 3         1.300000
                 4         1.241525
                 5         1.533333
                 6         1.676580
                 7         1.587786
                 8         1.708333
                 9         1.257426
                 10        1.452632
                 11        1.540000
                 12        1.055556
        3        1         1.239130
                 2         1.533088
                 3         1.235294
                 4         1.000000
                 5         1.550661
                 6         1.628099
                 7         1.657609
                 8         1.705521
                 9         1.513514
                 10        1.457143
                 11        1.571429
                 12        1.500000

In：

#很显然，这样的结果并不像excel中预期的那样，该如何变成列联表的形式呢？很简单，只需要将结果进行非堆叠操作即可。
fd3=pd.pivot_table(test_data,values=['balance','housing'],columns=['marital','job']).unstack()
print(fd3)

Out：

job                       1            2   ...           11           12
       marital                            ...                          
balance 1        1228.493671  1785.391272  ...  1270.040984  1749.975000
       2        1355.333333  1501.268148  ...  2158.580000   814.833333
       3        1166.673913  1801.176471  ...  1379.485714  2940.500000
housing 1           1.295359     1.474112  ...     1.573770     1.000000
       2           1.393939     1.482963  ...     1.540000     1.055556
       3           1.239130     1.533088  ...     1.571429     1.500000
#这样看起来舒服点。

In：

#使用多个聚合函数
fd4=pd.pivot_table(test_data,values=['balance','housing'],columns=['marital'],aggfunc=[np.mean,np.median,np.std])
print(fd4)

Out：

               mean               ...          std             
marital            1            2  ...            2            3
balance  1455.797641  1313.231841  ...  2888.859422  3352.982857
housing     1.555051     1.529353  ...     0.499220     0.497758

8、多层索引

接下来讲一个Pandas中的重要功能，那就是多层索引。

• 在数据框中使用多层索引，可以将整个数据集控制在二维表结构中，这对于数据重塑和基于分组的操作（如数据透视表的生成）比较有帮助
• 在数据透视表中往往存在多层索引 序列的多层索引类似于excel中的如下形式。

In：

#Series的多层索引
s=pd.Series([1,2,3,4],index=[['小张','小张','老王','老王'],['期末','期末','期中','期末']])
print(s)

Out：

小张  期末    1
   期末    2
老王  期中    3
   期末    4

In：

print(s[['小张']])

Out：

小张  期末    1
   期末    2

In：

print(s[:,'期末'])

Out：

小张    1
小张    2
老王    4

In：

#将多层次索引的序列转换为数据框的形式
#s1=s.unstack()
#print(s1)
#以上是对序列的多层次索引，接下来对数据框的多层次索引，多层索引的形式类似excel的如下形式。
#构造一个类似的高维数据框
df=pd.DataFrame(np.random.randint(10,50,20).reshape(5,4),index=[['A','A','A','B','B'],[1,2,3,1,2]],columns=[['x','x','x','y'],['x1','x2','x3','y']])
print(df)

Out：

      x           y
    x1  x2  x3   y
A 1  17  29  45  45
 2  42  15  46  31
 3  28  38  18  12
B 1  12  17  43  35
 2  48  28  17  33

In：

#通过外层索引取出大块数据
print(df['x'])

Out：

     x1  x2  x3
A 1  19  14  44
 2  46  36  31
 3  35  34  38
B 1  42  22  46
 2  45  21  14

In：

print(df.loc[['A'],:])

Out：

     x           y
    x1  x2  x3   y
A 1  33  18  17  13
 2  13  31  33  44
 3  30  18  28  23

In：

#在数据框中使用多层索引，可以将整个数据集控制在二维结构中，这对于数据重塑和基于分组的操作（如数据透视表的生成）比较有帮助。
#以test_data二维数据框为例，构造一个多层索引数据集
df1=pd.pivot_table(test_data,index=['marital','loan'])
print(df1)

Out：

                        ID        age  ...  poutcome  previous
marital loan                           ...                    
1       1     30742.940724  43.724844  ...  1.287596  0.535309
       2     30756.275742  42.596859  ...  1.218150  0.445899
2       1     30742.904599  33.679970  ...  1.331813  0.646142
       2     30734.937500  33.416667  ...  1.195312  0.455729
3       1     30732.382937  46.012897  ...  1.286706  0.523810
       2     30764.129032  44.847926  ...  1.253456  0.414747

以上pandas模块的基本学习就完成了，大家若想更深一步的学习，可以参考《Pandas的官方文档》，本篇主要参考《Pandas数据分析之Pandas学习》