python pandas 基础工具

 

DataFrame索引选项

2.在算数方法中填充值

ser=DataFrame(np.arange(9).reshape(3,3),columns=list('abc'))
ser1=DataFrame(np.arange(12).reshape(3,4),columns=list('abcd'))
ser.loc[1,'a']=np.nan#根据标签索引找到索引为1行，columns为a列的值，设置为空


p=ser.add(ser1,fill_value=0)#若某值为空，则用0填充

3.Series和DataFrame的算术⽅法

表5-5列出了Series和DataFrame的算术⽅法。它们每个都有⼀
个副本，以字⺟r开头，它会翻转参数。因此这两个语句是等价
的：

In [172]: 1 / df1
Out[172]:
a b c d
0 inf 1.000000 0.500000 0.333333
1 0.250000 0.200000 0.166667 0.142857
2 0.125000 0.111111 0.100000 0.090909
In [173]: df1.rdiv(1)
Out[173]:
a b c d
0 inf 1.000000 0.500000 0.333333
1 0.250000 0.200000 0.166667 0.142857
2 0.125000 0.111111 0.100000 0.090909

ser=DataFrame(np.arange(9).reshape(3,3),columns=list('abc'))
ser1=DataFrame(np.arange(12).reshape(3,4),columns=list('abcd'))
ser.loc[1,'a']=np.nan
p=ser.pow(2,fill_value=0)#每个位置都乘方
p=ser.rpow(2,fill_value=0)#每个位置等于2的该位置的数次方

 汇总和计算描述统计

 

In [230]: df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
.....: [np.nan, np.nan], [0.75, -1.3]],
.....: index=['a', 'b', 'c', 'd'],
.....: columns=['one', 'two'])
In [231]: df
Out[231]:
one two
a 1.40 NaN
b 7.10 -4.5
c NaN NaN
d 0.75 -1.3
1.
调⽤DataFrame的sum⽅法将会返回⼀个含有列的和的Series：
In [232]: df.sum()
Out[232]:
one 9.25
two -5.80
dtype: float64

2.
传⼊axis='columns'或axis=1将会按⾏进⾏求和运算：
In [233]: df.sum(axis=1)
Out[233]:
a 1.40
b 2.60
c NaN
d -0.55


3.NA值会⾃动被排除，除⾮整个切⽚（这⾥指的是⾏或列）都是
NA。通过skipna选项可以禁⽤该功能：
In [234]: df.mean(axis='columns', skipna=False)
Out[234]:
a NaN
b 1.300
c NaN
d -0.275
dtype: float64

 

In [243]: returns.tail()
Out[243]:
AAPL GOOG IBM MSFT
Date
2016-10-17 -0.000680 0.001837 0.002072 -0.003483
2016-10-18 -0.000681 0.019616 -0.026168 0.007690
2016-10-19 -0.002979 0.007846 0.003583 -0.002255
2016-10-20 -0.000512 -0.005652 0.001719 -0.004867
2016-10-21 -0.003930 0.003011 -0.012474 0.042096

Series的corr⽅法⽤于计算两个Series中重叠的、⾮NA的、按索
引对⻬的值的相关系数。与此类似，cov⽤于计算协⽅差：

In [244]: returns['MSFT'].corr(returns['IBM'])
Out[244]: 0.49976361144151144
In [245]: returns['MSFT'].cov(returns['IBM'])
Out[245]: 8.8706554797035462e-05

另⼀⽅⾯，DataFrame的corr和cov⽅法将以DataFrame的形式
分别返回完整的相关系数或协⽅差矩阵：
In [247]: returns.corr()
Out[247]:
AAPL GOOG IBM MSFT
AAPL 1.000000 0.407919 0.386817 0.389695
GOOG 0.407919 1.000000 0.405099 0.465919
IBM 0.386817 0.405099 1.000000 0.499764
MSFT 0.389695 0.465919 0.499764 1.000000
In [248]: returns.cov()
Out[248]:
AAPL GOOG IBM MSFT
AAPL 0.000277 0.000107 0.000078 0.000095
GOOG 0.000107 0.000251 0.000078 0.000108
IBM 0.000078 0.000078 0.000146 0.000089
MSFT 0.000095 0.000108 0.000089 0.000215

利⽤DataFrame的corrwith⽅法，你可以计算其列或⾏跟另⼀个
Series或DataFrame之间的相关系数。传⼊⼀个Series将会返回
⼀个相关系数值Series（针对各列进⾏计算）：
In [249]: returns.corrwith(returns.IBM)
Out[249]:
AAPL 0.386817
GOOG 0.405099
IBM 1.000000
MSFT 0.499764
dtype: float64

传⼊⼀个DataFrame则会计算按列名配对的相关系数。这⾥，我
计算百分⽐变化与成交量的相关系数：
In [250]: returns.corrwith(volume)
Out[250]:
AAPL -0.075565
GOOG -0.007067
IBM -0.204849
MSFT -0.092950
dtype: float64
传⼊axis='columns'即可按⾏进⾏计算。⽆论如何，在计算相关
系数之前，所有的数据项都会按标签对⻬。

唯⼀值、值计数以及成员资格

还有⼀类⽅法可以从⼀维Series的值中抽取信息。看下⾯的例
⼦：
In [251]: obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b'])
第⼀个函数是unique，它可以得到Series中的唯⼀值数组：
In [252]: uniques = obj.unique()
In [253]: uniques
Out[253]: array(['c', 'a', 'd', 'b'], dtype=object)

返回的唯⼀值是未排序的，如果需要的话，可以对结果再次进⾏
排序（uniques.sort()）。相似的，value_counts⽤于计算⼀个
Series中各值出现的频率：
In [254]: obj.value_counts()
Out[254]:
c 3
a 3
b 2
d 1
dtype: int64


为了便于查看，结果Series是按值频率降序排列的。
value_counts还是⼀个顶级pandas⽅法，可⽤于任何数组或序
列：
In [255]: pd.value_counts(obj.values, sort=False)
Out[255]:
a 3
b 2
c 3
d 1
dtype: int64


isin⽤于判断⽮量化集合的成员资格，可⽤于过滤Series中或
DataFrame列中数据的⼦集：


In [256]: obj
Out[256]:
0 c
1 a
2 d
3 a
4 a
5 b
6 b
7 c
8 c
dtype: object
In [257]: mask = obj.isin(['b', 'c'])
In [258]: mask
Out[258]:
0 True
1 False
2 False
3 False
4 False
5 True
6 True
7 True
8 True
dtype: bool
In [259]: obj[mask]
Out[259]:
0 c
5 b
6 b
7 c
8 c
dtype: object

与isin类似的是Index.get_indexer⽅法，它可以给你⼀个索引数
组，从可能包含重复值的数组到另⼀个不同值的数组：

即返回to_match中的元素再unique_vals中的索引
In [260]: to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a'])
In [261]: unique_vals = pd.Series(['c', 'b', 'a'])
In [262]: pd.Index(unique_vals).get_indexer(to_match)
Out[262]: array([0, 2, 1, 1, 0, 2])

 

In [264]: data
Out[264]:
Qu1 Qu2 Qu3
0 1 2 1
1 3 3 5
2 4 1 2
3 3 2 4
4 4 3 4

将pandas.value_counts传给该DataFrame的apply函数，就会出
现：
In [265]: result = data.apply(pd.value_counts).fillna(0)
In [266]: result
Out[266]:
Qu1 Qu2 Qu3
1 1.0 1.0 1.0
2 0.0 2.0 1.0
3 2.0 2.0 0.0
4 2.0 0.0 2.0
5 0.0 0.0 1.0
相当于统计每个索引数在每一列中的个数
这⾥，结果中的⾏标签是所有列的唯⼀值。这些值是每个列中这
些值的相应计数。

 

 得到DataFrame中多个相关列的⼀张柱状图。

 

In [264]: dataOut[264]:Qu1 Qu2 Qu30 1 2 11 3 3 52 4 1 23 3 2 44 4 3 4

 

categories分类对象方法应用