python-数据描述与分析2（利用Pandas处理数据 缺失值的处理 数据库的使用）

2.利用Pandas处理数据
2.1 汇总计算
当我们知道如何加载数据后，接下来就是如何处理数据，虽然之前的赋值计算也是一种计算，但是如果Pandas的作用就停留在此，那我们也许只是看到了它的冰山一角，它首先比较吸引人的作用是汇总计算

（1）基本的数学统计计算
这里的基本计算指的是sum、mean等操作，主要是基于Series（也可能是来自DataFrame）进行统计计算。举例如下：

#统计计算 sum mean等
import numpy as np
import pandas as pd
df=pd.DataFrame(np.arange(16).reshape((4,4)),columns=["aa","bb","cc","dd"],index = ["a","b","c","d"])
df

#output
    aa    bb    cc    dd
a    0    1    2    3
b    4    5    6    7
c    8    9    10    11
d    12    13    14    15

df_data = df.reindex(["a","b","c","d","e"])
df_data

#output
    aa    bb    cc    dd
a    0.0    1.0    2.0    3.0
b    4.0    5.0    6.0    7.0
c    8.0    9.0    10.0    11.0
d    12.0    13.0    14.0    15.0
e    NaN    NaN    NaN    NaN

df_data.sum() #默认是通过列进行求和，即axis=0；默认NaN值也是忽略的

#output
aa    24.0
bb    28.0
cc    32.0
dd    36.0
dtype: float64

df_data.sum(axis=1) #默认是通过列进行求和

#output
a     6.0
b    22.0
c    38.0
d    54.0
e     0.0
dtype: float64

df_data.mean(axis=0,skipna=False)

#output
aa   NaN
bb   NaN
cc   NaN
dd   NaN
dtype: float64

## idxmax  idxmin 最大值，最小值的索引
print(df.idxmax())
print("________________________")
print(df.idxmin())

#output
aa    d
bb    d
cc    d
dd    d
dtype: object
________________________
aa    a
bb    a
cc    a
dd    a
dtype: object

##进行累计 cumsum
print(df.cumsum())

#output
aa  bb  cc  dd
a   0   1   2   3
b   4   6   8  10
c  12  15  18  21
d  24  28  32  36

#对于刚才提到的最大多数描述性统计可以使用describe
#对于这些统计量的含义可以查找“help”得到，此处不再赘述
df.describe()

#output
    aa    bb    cc    dd
count    4.000000    4.000000    4.000000    4.000000
mean    6.000000    7.000000    8.000000    9.000000
std    5.163978    5.163978    5.163978    5.163978
min    0.000000    1.000000    2.000000    3.000000
25%    3.000000    4.000000    5.000000    6.000000
50%    6.000000    7.000000    8.000000    9.000000
75%    9.000000    10.000000    11.000000    12.000000
max    12.000000    13.000000    14.000000    15.000000

#(2)唯一值、值的计数。成员资格的设定  采用几行代码，一个Output 进行演示
#是否是唯一值
obj = pd.Series(["a","a","b","b","b","c","c"])
print (obj)
print (obj.unique())

#output
0    a
1    a
2    b
3    b
4    b
5    c
6    c
dtype: object
['a' 'b' 'c']

#value_counts 是python 针对Series进行的顶级操作
print (pd.value_counts(obj.values,sort=False))

#output
a    2
b    3
c    2
dtype: int64

mark = obj.isin(["a"]) #是否存在a
print (mark)

#output
0     True
1     True
2    False
3    False
4    False
5    False
6    False
dtype: bool

obj[mark] #根据判定条件进行数据获取

#output
0    a
1    a
dtype: object

另外，实际应用中不只是这些统计函数在发挥作用，还有很多统计函数，比如计算数值之间的百分比（pct_change），或者是相关数据的系数与协方差等，这里就不讨论了，需要时可查看帮助文档来解决。

2.2 缺失值的处理
（1）缺失值的概念
缺失值是在数据处理中在所难免的问题，pandas对缺失值的处理目的是简化对缺失值处理的工作。缺失值在pandas中使用的是浮点数（numpy.nan:Not a Number），具体代码如下：

import numpy as np
import pandas as pd
data = pd.Series([11,22,33,np.nan,55])   #定义NaN 值通过numpy.nan
data

#output
0    11.0
1    22.0
2    33.0
3     NaN
4    55.0
dtype: float64

data.isnull()  #判定是否为空NaN

#output
0    False
1    False
2    False
3     True
4    False
dtype: bool

#python中对于None 也认为是NaN
data[2]=None
data

#output
0    11.0
1    22.0
2     NaN
3     NaN
4    55.0
dtype: float64

#(2)过滤缺失值 对于缺失值的过滤主要通过dropna进行，如下所示：
data.dropna()  #过滤NaN值 #接着上面定义的data进行操作

#output
0    11.0
1    22.0
4    55.0
dtype: float64

#当然dropna太过暴力——他会过滤所有的NaN值，这样往往不是一般正常需要的处理结果
#我们通过dropna的属性进行限定
df = pd.DataFrame(np.arange(16).reshape((4,4)),columns=["aa","bb","cc","dd"],index=["a","b","c","d"])
df

#output
    aa    bb    cc    dd
a    0    1    2    3
b    4    5    6    7
c    8    9    10    11
d    12    13    14    15

#制造NaN值
df.loc[:1,:]=np.nan
print (df)

#output
 aa    bb    cc    dd
a   NaN   NaN   NaN   NaN
b   4.0   5.0   6.0   7.0
c   8.0   9.0  10.0  11.0
d  12.0  13.0  14.0  15.0

print (df.dropna(axis=1,how="all"))  #0行1列
#output 并没有发生变化，因为过滤的是列，要求一列全都是NaN值

#output
aa    bb    cc    dd
a   NaN   NaN   NaN   NaN
b   4.0   5.0   6.0   7.0
c   8.0   9.0  10.0  11.0
d  12.0  13.0  14.0  15.0

df.dropna(axis=0,how="all")  #0行1列

#output
    aa    bb    cc    dd
b    4.0    5.0    6.0    7.0
c    8.0    9.0    10.0    11.0
d    12.0    13.0    14.0    15.0

（3）填充缺失值
因为数据处理的要求，可能并不需要将所有的数据进行过滤，此时需要对数据进行必要的填充（比如0.0）；还可以用线性插值进行必要的填充，而在这个数据处理中需要用到的方式如下所示：

df=pd.DataFrame(np.arange(16).reshape((4,4)),columns=["aa","bb","cc","dd"],index = ["a","b","c","d"])
df
df.loc[:1,:] = np.nan
print (df)

#output
 aa    bb    cc    dd
a   NaN   NaN   NaN   NaN
b   4.0   5.0   6.0   7.0
c   8.0   9.0  10.0  11.0
d  12.0  13.0  14.0  15.0

print (df.fillna(0.0)) #fillna 默认会返回新的对象

#output
 aa    bb    cc    dd
a   0.0   0.0   0.0   0.0
b   4.0   5.0   6.0   7.0
c   8.0   9.0  10.0  11.0
d  12.0  13.0  14.0  15.0

#也可以像dropna 操作一样进行必要的限定而不是所有的值都进行填充
#print df.fillna({1:0.5,2:5.5)  #测试失败
#当需要在旧的对象上进行更改，而不是经过过滤返回一个新的对象时

df.fillna(0.5,inplace = True)
df

#output
aa    bb    cc    dd
a    0.5    0.5    0.5    0.5
b    4.0    5.0    6.0    7.0
c    8.0    9.0    10.0    11.0
d    12.0    13.0    14.0    15.0

#也可以选择一些线性插值进行填充
df.loc[:1,:] = np.nan
df.fillna(method ="bfill")  #后向寻值填充

#output
aa    bb    cc    dd
a    4.0    5.0    6.0    7.0
b    4.0    5.0    6.0    7.0
c    8.0    9.0    10.0    11.0
d    12.0    13.0    14.0    15.0

df.fillna(df.mean())   #使用平均值进行填充

#output
    aa    bb    cc    dd
a    8.0    9.0    10.0    11.0
b    4.0    5.0    6.0    7.0
c    8.0    9.0    10.0    11.0
d    12.0    13.0    14.0    15.0

另外，在处理缺失值时除了以上介绍的简单操作之外，更多的时候需要根据数据挖掘需要或者程序运行方面灵活地进行缺失值处理，程序是人为设定的规则，但针对这些规则进行优化组合，将会带来新的效果

3.数据库的使用
关于数据库的使用，虽然各大厂商都在追捧NOSQL,但是目前使用最多的还是关系型数据库（MySQL、SQLServer、PostgreSql等）。总体而言，数据库的选择取决于其性能、数据完整性及应用程序的需求等。
在这里我们使用python内置的sqlite3驱动器，操作过程如下所示：

#sql MySql
import sqlite3 as sql  #首先我们需要导入sqlite3包
#现在我们使用的是python内置的数据库

#创建数据库表（table）
query = "create table test(a varchar(20),b varchar(20),c real,d integer);"
con = sql.connect(":memory:")
#可以看出它是内置数据库而且此处又使用memory
#因此它的处理是放在内存进行处理的内置操作
con.execute(query)
con.commit()

#对刚才创建的test表写入数据
#insert data
data = [("UCAS","NSLCAS",0.5,1),
("UCAS","NSLCAS",0.5,2),
("UCAS","NSLCAS",0.5,3),
("UCAS","NSLCAS",0.5,4)]
stmt="insert into test values(?,?,?,?)"
con.executemany(stmt,data)  #多行方式写入，如果单行模式用con.execute
con.commit

#查找数据
#select data
sql_str="select*from test"
cursor=con.execute(sql_str)
rows=cursor.fetchall()
rows

#output
[('UCAS', 'NSLCAS', 0.5, 1),
 ('UCAS', 'NSLCAS', 0.5, 2),
 ('UCAS', 'NSLCAS', 0.5, 3),
 ('UCAS', 'NSLCAS', 0.5, 4)]

#说明：查找的数据是我们刚才写入的数据  关键的地方才正式开始：通过获取的数据rows生成DataFrame（这里是建立数据库中数据同pandas数据对象DataFrame之间关系的关键）
import pandas as pd
column =list(zip(*cursor.description))[0]  #获取列名
df = pd.DataFrame(rows,columns = column)
df
#书本上写的是：column = zip(*cursor.description)[0]

#错误：'zip' object is not subscriptable
#解决办法：使用list包装zip对象
#代码：column =list(zip(*cursor.description))[0]
#注意[0]是在list的括号()外

#output
a    b    c    d
0    UCAS    NSLCAS    0.5    1
1    UCAS    NSLCAS    0.5    2
2    UCAS    NSLCAS    0.5    3
3    UCAS    NSLCAS    0.5    4

优化：之前的操作看似简单流畅，但是针对具体应用来看不是很理想，原因在于我们需要对数据库的每次操作进行代码的重写，这样既耗时又耗力，庆幸的是pandas提供了一组方法帮我们解决类似难题。

#pandas 针对该种繁琐的操作提供了更加优化的方式进行数据访问
import pandas.io.sql as pdsql  #需要导入这个库
pdsql.read_sql_query("select * from test",con)   #当然con都是同样的

#output
a    b    c    d
0    UCAS    NSLCAS    0.5    1
1    UCAS    NSLCAS    0.5    2
2    UCAS    NSLCAS    0.5    3
3    UCAS    NSLCAS    0.5    4

另外，也就是说read_sql_query(查询语句，连接)返回的就是我们需要的数据格式DataFrame，仅用此句代码搞定。当然这里只是抛砖引玉，当真正需要同数据库进行数据交互时，查询相关文档时最好的方式.