python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > pandas dataframe汇总和计算方法

pandas中的dataframe汇总和计算方法

作者:tsing_9521

这篇文章主要介绍了pandas中的dataframe汇总和计算方法,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

pandas dataframe汇总和计算方法

Dataframe汇总计算的主要方法有

在这里插入图片描述

在这里插入图片描述

Pandas 统计的一些常用方法 

1.frame.idxmax(): 列的最大值 输出每列最大值的索引

np.random.seed(38754)
data=np.random.randint(0,15,15).reshape(5,3)
frame=DataFrame(data,index=['a','b','c','d','e'],columns=['x','y','z'])
result=frame.idxmax()
print(result)
#输出:
x    b
y    a
z    e

2.frame.cumsum() :返回行或列的累加值的series,默认列累加

语法:

DataFrame.cumsum(axis=None, dtype=None, out=None, skipna=True, **kwargs)
np.random.seed(38754)
data=np.random.randint(0,15,15).reshape(5,3)
frame=DataFrame(data,index=['a','b','c','d','e'],columns=['x','y','z'])
result=frame.cumsum(axis=1)
print(frame)
print(result)
#输出:
    x   y   z
a   5  14   7
b  12  12   6
c   3   7   8
d  11  10   0
e   1  10  10
    x   y   z
a   5  19  26
b  12  24  30
c   3  10  18
d  11  21  21
e   1  11  21

3.frame.describe():描述列的一些值:

np.random.seed(38754)
data=np.random.randint(0,15,15).reshape(5,3)
frame=DataFrame(data,index=['a','b','c','d','e'],columns=['x','y','z'])
print(frame.describe())
#输出:
               x          y          z
count   5.000000   5.000000   5.000000 #每列非NAN数的个数
mean    6.400000  10.600000   6.200000 #每列平均值
std     4.878524   2.607681   3.768289 #标准差
min     1.000000   7.000000   0.000000
25%     3.000000  10.000000   6.000000 # 第一四分位数 (Q1),又称“较小四分位数”,等于该样本中所有数值由小到大排列后第25%的数字。
50%     5.000000  10.000000   7.000000 #中位数
75%    11.000000  12.000000   8.000000
max    12.000000  14.000000  10.000000

4.缺失数据处理:dataframe.dropna() ,默认删除所有存在na的行

语法:

DataFrame.dropna(axis=0, how=‘any', thresh=None, subset=None, inplace=False)

axis=0,默认对行作用,axis=1即对列作用

how=any/all:

#代码含义:对列作用,当整列都为NA值时才放弃列
np.random.seed(38754)
data=np.random.randint(0,15,15).reshape(5,3)
frame=DataFrame(data,index=['a','b','c','d','e'],columns=['x','y','z'])
#设置na值
frame.loc['a','x']=np.nan
frame.loc['b','y']=np.nan
frame.loc[0,0]=np.nan
print(frame)
print(frame.dropna(axis=1,how='all'))
#输出:
      x     y     z   0
a   NaN  14.0   7.0 NaN
b  12.0   NaN   6.0 NaN
c   3.0   7.0   8.0 NaN
d  11.0  10.0   0.0 NaN
e   1.0  10.0  10.0 NaN
0   NaN   NaN   NaN NaN
      x     y     z
a   NaN  14.0   7.0
b  12.0   NaN   6.0
c   3.0   7.0   8.0
d  11.0  10.0   0.0
e   1.0  10.0  10.0
0   NaN   NaN   NaN

5.填充缺失值:frame.fillna()

语法:

DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)

value: 变量, 字典, Series, or DataFrame

#字典填充:{‘a':1,‘b':2} a列填充1,b列填充2,字典填充只能按列填充
method=‘backfill', ‘bfill', ‘pad', ‘ffill', None (见实例)

limit: int 针对连续缺失值,指定填充数量

#实例
np.random.seed(38754)
data=np.random.randint(0,15,15).reshape(5,3)
frame=DataFrame(data,index=['a','b','c','d','e'],columns=['x','y','z'])
frame.loc['a','x']=np.nan
frame.loc['b','y']=np.nan
frame.loc[0,0]=np.nan
print(frame)
print(frame.fillna('new',))
print(frame.fillna('new',axis=0))
print('向前或向后填充',frame.fillna(method='ffill'))
print('对连续na值限制填充次数',frame.fillna('new',limit=3))
print('字典填充',frame.fillna(value={'x':11,'y':22,'z':33}))
#输出
#原始frame
      x     y     z   0
a   NaN  14.0   7.0 NaN
b  12.0   NaN   6.0 NaN
c   3.0   7.0   8.0 NaN
d  11.0  10.0   0.0 NaN
e   1.0  10.0  10.0 NaN
0   NaN   NaN   NaN NaN
#用new填充na
     x    y    z    0
a  new   14    7  new
b   12  new    6  new
c    3    7    8  new
d   11   10    0  new
e    1   10   10  new
0  new  new  new  new
向前或向后填充 #用前一行(axis=0)/前一列(axis=1)的数值填充na,如果前一行或前一列也是na,则不填充
    x     y     z   0
a   NaN  14.0   7.0 NaN
b  12.0  14.0   6.0 NaN
c   3.0   7.0   8.0 NaN
d  11.0  10.0   0.0 NaN
e   1.0  10.0  10.0 NaN
0   1.0  10.0  10.0 NaN
对连续na值限制填充次数     
	 x    y    z    0
a  new   14    7  new
b   12  new    6  new
c    3    7    8  new
d   11   10    0  NaN
e    1   10   10  NaN
0  new  new  new  NaN
字典填充 #只能填充列     
	x     y     z   0
a  11.0  14.0   7.0 NaN
b  12.0  22.0   6.0 NaN
c   3.0   7.0   8.0 NaN
d  11.0  10.0   0.0 NaN
e   1.0  10.0  10.0 NaN
0  11.0  22.0  33.0 NaN

6.dataframe.head(n) :查看前n行数据(默认是前5行)

7.dataframe.tail(n) :查看后n行数据(默认是前5行)

pandas入门—汇总和计算描述统计

pandas对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计,用于从Series中提取单个值(如sum或mean)或从DataFrame的行或列中提取一个Series。

跟对应的NumPy数组方法相比,它们都是基于没有缺失数据的假设而构建的,如

In [1]: 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 [2]: df
Out[2]: 
    one  two
a  1.40  NaN
b  7.10 -4.5
c   NaN  NaN
d  0.75 -1.3

调用DataFrame的sum方法将会返回一个含有列的和的Series

In [3]: df.sum()
Out[3]: 
one    9.25
two   -5.80

传入axis='columns’或axis=1将会按行进行求和运算,如

In [4]: df.sum(axis=1)
Out[4]:
a    1.40
b    2.60
c     NaN
d   -0.55

NA值会自动被排除,除非整个切片(这里指的是行或列)都是NA。通过skipna选项可以禁用该功能:

In [5]: df.mean(axis='columns', skipna=False)
Out[5]: 
a      NaN
b    1.300
c      NaN
d   -0.275

有些方法(如idxmin和idxmax)返回的是间接统计(比如达到最小值或最大值的索引)

In [6]: df.idxmax()
Out[6]: 
one    b
two    d

另一些方法则是累计型的,如

In [7]: df.cumsum()
Out[7]: 
    one  two
a  1.40  NaN
b  8.50 -4.5
c   NaN  NaN
d  9.25 -5.8

还有一种方法,它既不是约简型也不是累计型。describe就是一个例子,它用于一次性产生多个汇总统计

In [8]: df.describe()
Out[8]: 
            one       two
count  3.000000  2.000000
mean   3.083333 -2.900000
std    3.493685  2.262742
min    0.750000 -4.500000
25%    1.075000 -3.700000
50%    1.400000 -2.900000
75%    4.250000 -2.100000
max    7.100000 -1.300000

对于非数值型数据,describe会产生另外一种汇总统计

In [9]: obj = pd.Series(['a', 'a', 'b', 'c'] * 4)
In [10]: obj.describe()
Out[10]: 
count     16
unique     3
top        a
freq       8

相关系数与协方差

有些汇总统计(如相关系数和协方差)是通过参数对计算出来的

pandas-datareader包(可以用conda或pip安装)

pip install pandas-datareader
import pandas_datareader.data as web
all_data = {ticker: web.get_data_yahoo(ticker)
            for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOG']}
price = pd.DataFrame({ticker: data['Adj Close']
                     for ticker, data in all_data.items()})
volume = pd.DataFrame({ticker: data['Volume']
                      for ticker, data in all_data.items()})

计算价格的百分数变化

In [11]: returns = price.pct_change()
In [12]: returns.tail()
Out[12]: 
                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 [13]: returns['MSFT'].corr(returns['IBM'])
Out[13]: 0.49976361144151144
In [14]: returns['MSFT'].cov(returns['IBM'])
Out[14]: 8.8706554797035462e-05

另一方面,DataFrame的corr和cov方法将以DataFrame的形式分别返回完整的相关系数或协方差矩阵

In [15]: returns.corr()
Out[15]: 
          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 [16]: returns.cov()
Out[16]: 
          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 [17]: returns.corrwith(returns.IBM)
Out[17]: 
AAPL    0.386817
GOOG    0.405099
IBM     1.000000
MSFT    0.499764

传入一个DataFrame则会计算按列名配对的相关系数。这里,我计算百分比变化与成交量的相关系数

In [18]: returns.corrwith(volume)
Out[18]: 
AAPL   -0.075565
GOOG   -0.007067
IBM    -0.204849
MSFT   -0.092950

传入axis='columns’即可按行进行计算。无论如何,在计算相关系数之前,所有的数据项都会按标签对齐

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

还有一类方法可以从一维Series的值中抽取信息,如

In [19]: obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])

第一个函数是unique,它可以得到Series中的唯一值数组

In [20]: uniques = obj.unique()
In [21]: uniques
Out[21]: array(['c', 'a', 'd', 'b'], dtype=object)

返回的唯一值是未排序的,如果需要的话,可以对结果再次进行排序(uniques.sort())。相似的,value_counts用于计算一个Series中各值出现的频率

In [22]: obj.value_counts()
Out[22]: 
c    3
a    3
b    2
d    1

为了便于查看,结果Series是按值频率降序排列的。value_counts还是一个顶级pandas方法,可用于任何数组或序列,如

In [23]: pd.value_counts(obj.values, sort=False)
Out[23]: 
a    3
b    2
c    3
d    1

isin用于判断矢量化集合的成员资格,可用于过滤Series中或DataFrame列中数据的子集

In [24]: obj
Out[24]: 
0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
In [25]: mask = obj.isin(['b', 'c'])
In [26]: mask
Out[26]: 
0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool
In [27]: obj[mask]
Out[27]: 
0    c
5    b
6    b
7    c
8    c

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

In [28]: to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a'])
In [29]: unique_vals = pd.Series(['c', 'b', 'a'])
In [30]: pd.Index(unique_vals).get_indexer(to_match)
Out[30]: array([0, 2, 1, 1, 0, 2])

另一个例子,如

In [31]: data
Out[31]: 
   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 [32]: result = data.apply(pd.value_counts).fillna(0)
In [33]: result
Out[33]: 
   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

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文