Pandas---4.运算

posted @ 2019-12-27 17:16 nxf_rabbit75 阅读(328) 评论(0) 编辑收藏举报

分类: Pandas

undefined

一、数值运算

1.当进行数值运算时，pandas会按照标签对齐元素：运算符会对标签相同的两个元素进行计算。对于DataFrame，对齐会同时发生在行和列上。

当某一方的标签不存在时，默认以NaN填充。缺失值会在运算过程中传播。（由于NaN是浮点数中的一个特殊值，因此结果的元素类型被转换为float64）
结果的索引是双方索引的并集。

2.除了支持加减乘除等运算符之外，pandas还提供了对应的函数： add/sub/mul/div/mod(other, axis='columns', level=None, fill_value=None):

other：一个DataFrame/Series或者一个array-like，或者一个标量值
axis：指定操作的轴。可以为0/1/'index'/'columns' 。其意义是：操作发生在哪个轴上。
fill_value：指定替换掉NaN的值。可以为None（不替换），或者一个浮点值。注意：如果发现两个NaN相加，则结果仍然还是NaN，而并不会是两个fill_value相加。
level：一个整数或者label，用于多级索引的运算。

全部运算操作函数为：

1 add,sub,mul,div,truediv,floordiv,mod,pow,radd,rsub,rmul,rdiv,rtruediv,
2 rfloordiv,rmod,rpow # 这些的参数为 other,axis,level,fill_value
3 lt,gt,le,ge,ne,eq# 这些的参数为 ohter,axis,level

对于DataFrame和Series的运算，默认会用DataFrame的每一行与Series运算。如果你希望使用DataFrame的每一列与Series运算，则必须使用二元操作函数，并且指定axis=0（表示操作匹配的轴）。

举例：

idx1 = pd.Index(['a','b','c','d'],name='idx1')
idx2 = pd.Index(['a','b','c','e'],name='idx2')
s1 = pd.Series([1,2,3,4],index=idx1,name='sr1')
s2 = pd.Series([2,4,6,np.NaN],index=idx2,name='sr2')
print(s1,s2,sep='\n-----------------------\n')
idx1
a    1
b    2
c    3
d    4
Name: sr1, dtype: int64
-----------------------
idx2
a    2.0
b    4.0
c    6.0
e    NaN
Name: sr2, dtype: float64
s1+s2 #直接相加，自动对齐相加
s1+s2 #直接相加，自动对齐相加
a    3.0
b    6.0
c    9.0
d    NaN
e    NaN
dtype: float64
 # fill_value
s1.add(s2,fill_value=-100) # fill_value
a     3.0
b     6.0
c     9.0
d   -96.0
e     NaN
dtype: float64
2
df1 = pd.DataFrame({'c1':[1,3,5,7],'c2':[2,4,6,8]},index=idx1)
df2 = pd.DataFrame({'c1':[11,13,15,17],'c3':[22,24,26,28]},index=idx2)
print(df1,df2,sep='\n----------------\n')
      c1  c2
idx1        
a      1   2
b      3   4
c      5   6
d      7   8
----------------
      c1  c3
idx2        
a     11  22
b     13  24
c     15  26
e     17  28
 # 直接相加,自动对齐相加
df1+df2 # 直接相加,自动对齐相加
c1  c2  c3
a   12.0    NaN NaN
b   16.0    NaN NaN
c   20.0    NaN NaN
d   NaN NaN NaN
e   NaN NaN NaN
 fill_value
df1.add(df2,fill_value=-100) # fill_value
c1  c2  c3
a   12.0    -98.0   -78.0
b   16.0    -96.0   -76.0
c   20.0    -94.0   -74.0
d   -93.0   -92.0   NaN
e   -83.0   NaN -72.0
df1 + df1.c1 # 广播
df1 + df1.c1 # 广播
a   b   c   c1  c2  d
idx1                        
a   NaN NaN NaN NaN NaN NaN
b   NaN NaN NaN NaN NaN NaN
c   NaN NaN NaN NaN NaN NaN
d   NaN NaN NaN NaN NaN NaN
df1 + [-10,-11] # 广播,默认在列上进行
c1  c2
idx1        
a   -9  -9
b   -7  -7
c   -5  -5
d   -3  -3
+ df1.c1 # 广播
df1 + df1.c1 # 广播
a   b   c   c1  c2  d
idx1                        
a   NaN NaN NaN NaN NaN NaN
b   NaN NaN NaN NaN NaN NaN
c   NaN NaN NaN NaN NaN NaN
d   NaN NaN NaN NaN NaN NaN
 # 在行上进行
df1.add([-10,-11,-12,-13],axis=0) # 在行上进行
c1  c2
idx1        
a   -9  -8
b   -8  -7
c   -7  -6
d   -6  -5

二、排序

`1.sort_index()`

.sort_index()方法的作用是根据label排序（而不是对存放的数据排序）。

1 DataFrame/Series.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True)

参数：

axis：指定沿着那个轴排序。如果为0/'index'，则对沿着0轴，对行label排序；如果为1/'columns'，则沿着 1轴对列label排序。
level：一个整数、label、整数列表、label list或者None。对于多级索引，它指定在哪一级上排序。
ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。
inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象
kind：一个字符串，指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的
na_position：一个字符串，值为'first'/'last'，指示：将NaN排在最开始还是最末尾。
sort_remaining：一个布尔值。如果为True，则当多级索引排序中，指定level的索引排序完毕后，对剩下level的索引也排序。

举例：

import numpy as  np
import pandas as pd
 
idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([1,5,9,7],index=idx,name='sr1')
s
idx1
a    1
b    5
c    9
d    7
Name: sr1, dtype: int64
s.sort_index(ascending=False) # 对label排序,降序
idx1
d    7
c    9
b    5
a    1
Name: sr1, dtype: int64
idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,3,2,4],'c2':[11,14,13,12]},index=idx)
df
c1  c2
idx1        
a   1   11
b   3   14
c   2   13
d   4   12
df.sort_index(axis=0,ascending=False) # 对行label排序
c1  c2
idx1        
d   4   12
c   2   13
b   3   14
a   1   11
df.sort_index(axis=1,ascending=False) # 对行label排序
c2  c1
idx1        
a   11  1
b   14  3
c   13  2
d   12  4

2.sort_values()

.sort_values()方法的作用是根据元素值进行排序。

1 DataFrame/Series.sort_values(by, axis=0, ascending=True, inplace=False, 
2   kind='quicksort', na_position='last')
3 Series.sort_values(axis=0, ascending=True, inplace=False, 
4   kind='quicksort', na_position='last')

参数：

by：一个字符串或者字符串的列表，指定希望对那些label对应的列或者行的元素进行排序。对于DataFrame，必须指定该参数。而Series不能指定该参数。
1. 如果是一个字符串列表，则排在前面的label的优先级较高。它指定了用于比较的字段
axis：指定沿着那个轴排序。如果为0/'index'，则沿着0轴排序（此时by指定列label，根据该列的各元素大小，重排列各行）；如果为1/'columns'，则沿着 1轴排序（此时by指定行label，根据该行的各元素大小，重排列各列）。
ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。
inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象
kind:一个字符串，指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的
na_position：一个字符串，值为'first'/'last'，指示：将NaN排在最开始还是最末尾。

举例：

import numpy as  np
import pandas as pd
 
idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([1,5,9,7],index=idx,name='sr1')
s
 
idx1
a    1
b    5
c    9
d    7
Name: sr1, dtype: int64
 
 
s.sort_values(ascending=False) # 对value排序，降序
idx1
c    9
d    7
b    5
a    1
Name: sr1, dtype: int64
 
idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,3,2,4],'c2':[11,14,13,12]},index=idx)
df
c1  c2
idx1        
a   1   11
b   3   14
c   2   13
d   4   12
 
df.sort_values(by=['c1'],axis=0,ascending=False)
# 根据value对行排序,by指定了列label
c1  c2
idx1        
d   4   12
b   3   14
c   2   13
a   1   11
 
df.sort_values(by=['c2','c1'],axis=0,ascending=False)
# 根据value对行排序,by指定了列label,c2的优先级较高
c1  c2
idx1        
b   3   14
c   2   13
d   4   12
a   1   11

3.sortlevel()

1 DataFrame/Series.sortlevel(level=0, axis=0, ascending=True, inplace=False, sort_remaining=True)

根据单个level中的label对数据进行排列（稳定的）

axis：指定沿着那个轴排序。如果为0/'index'，则沿着0轴排序；如果为1/'columns'，则沿着 1轴排序
level：一个整数，指定多级索引的level
ascending：一个布尔值，如果为True，则升序排序；如果是False，则降序排序。
inplace：一个布尔值，如果为True，则原地修改。如果为False，则返回排好序的新对象
sort_remaining：一个布尔值。如果为True，则当多级索引排序中，指定level的索引排序完毕后，对剩下level的索引也排序。

举例：

import numpy as np
import pandas as pd
 
idx = pd.MultiIndex(levels=[['a','b'],['c','d','e']],labels=[[0,0,0,1,1,1],[0,1,2,0,1,2]],
                   name=['lv1','lv2'],tupleize_cols = True)
s = pd.Series([1,5,3,2,6,4],index=idx,name='s1')
df = pd.DataFrame({'col1':[1,5,3,2,6,4],'col2':[2,2,5,6,3,3]},index=idx)
print(s,df,sep='\n---------------------\n')
# lv1  lv2
a    c      1
     d      5
     e      3
b    c      2
     d      6
     e      4
Name: s1, dtype: int64
---------------------
         col1  col2
lv1 lv2            
a   c       1     2
    d       5     2
    e       3     5
b   c       2     6
    d       6     3
    e       4     3
 
print(s.sort_values(),# 按值排序
    s.sortlevel(level=0,ascending=False), # 根据label排序
    sep = '\n----------\n')
# lv1  lv2
a    c      1
b    c      2
a    e      3
b    e      4
a    d      5
b    d      6
Name: s1, dtype: int64
----------
lv1  lv2
b    e      4
     d      6
     c      2
a    e      3
     d      5
     c      1
Name: s1, dtype: int64
 
df.sortlevel(level=0,ascending=False)
# col1  col2
lv1 lv2     
b   e   4   3
d   6   3
c   2   6
a   e   3   5
d   5   2
c   1   2

4.rank()

.rank()方法的作用是在指定轴上计算各数值的排，其中相同数值的排名是相同的。

1 DataFrame/Series.rank(axis=0, method='average', numeric_only=None,
2  na_option='keep', ascending=True, pct=False)

参数：

axis：指定沿着那个轴排名。如果为0/'index'，则沿着行排名（对列排名）；如果为1/'columns'，则沿着列排名（对行排名）。
method：一个字符串，指定相同的一组数值的排名。假设数值 v一共有N个。现在轮到对v排序，设当前可用的排名为k。
1. 'average'：为各个等值平均分配排名，这N个数的排名都是 $\frac{\sum_{i=0}^{N-1}(K+i)}{N}=K+\frac{N-1}{2}$
2. 'min'：使用可用的最小的排名，这N个数的排名都是 k
3. 'max'：使用可用的最大的排名，这N各数的排名都是 k+N-1
4. 'first：根据元素数据中出现的顺序依次分配排名，即按照它们出现的顺序，其排名分别为 k,k+1,...k+N-1
5. 'dense：类似于 'min'，但是排名并不会跳跃。即比v大的下一个数值排名为k+1，而不是k+N
numeric_only :一个布尔值。如果为True，则只对float/int/bool数据排名。仅对DataFrame有效
na_option：一个字符串，指定对NaN的处理。可以为：
1. 'keep'：保留NaN在原位置
2. 'top':如果升序，则NaN安排最大的排名
3. 'bottom':如果升序，则NaN安排最小的排名
ascending：一个布尔值，如果为True，则升序排名；如果是False，则降序排名。
pct：一个布尔值。如果为True，则计算数据的百分位数，而不是排名。

举例：

idx = pd.Index(['a','b','c','d','e'],name='idx1')
s = pd.Series([3,1,3,5,np.NaN],index=idx,name="sr1")
s
#idx1
a    3.0
b    1.0
c    3.0
d    5.0
e    NaN
Name: sr1, dtype: float64
 
s.rank() # 3,3的排名分别为2,3，method="average"
#idx1
a    2.5
b    1.0
c    2.5
d    4.0
e    NaN
Name: sr1, dtype: float64
 
s.rank(method="min") 
#idx1
a    2.0
b    1.0
c    2.0
d    4.0
e    NaN
Name: sr1, dtype: float64
 
s.rank(method="max") 
#idx1
a    3.0
b    1.0
c    3.0
d    4.0
e    NaN
Name: sr1, dtype: float64
 
s.rank(method="dense") 
# idx1
a    2.0
b    1.0
c    2.0
d    3.0
e    NaN
Name: sr1, dtype: float64
 
s.rank(pct=True) # 计算百分位 
# idx1
a    0.625
b    0.250
c    0.625
d    1.000
e      NaN
Name: sr1, dtype: float64
 
idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,3,3,4],'c2':[11,14,14,12]},index=idx)
df
# c1    c2
idx1        
a   1   11
b   3   14
c   3   14
d   4   12
 
df.rank(axis=0,method='min') # 沿着0轴排名(对列排名)
# c1    c2
idx1        
a   1.0 1.0
b   2.0 3.0
c   2.0 3.0
d   4.0 2.0
1
 
df.rank(axis=1,method='min') # 沿着1轴排名(对行排名)
#c1 c2
idx1        
a   1.0 2.0
b   1.0 2.0
c   1.0 2.0
d   1.0 2.0

三、统计

1.支持numpy的数组接口,直接使用ufunc函数

Series和DataFrame对象都支持Numpy的数组接口，因此可以直接使用Numpy提供的ufunc函数对它们进行运算。这些函数通常都有三个常用参数：

axis：指定运算沿着哪个轴进行
level：如果轴是多级索引MultiIndex，则根据level分组计算
skipna：运算是否自动跳过NaN

下面的方法使用如下的两个Series和DataFrame:

举例：

import numpy as np
import pandas as pd
idx1 = pd.Index(['a','b','c','d','e'],name='idx1')
idx2 = pd.Index(['a','b','c','d','e'],name='idx2')
s1 = pd.Series([1,3,5,7,9],index=idx1,name='sr1')
s2 = pd.Series([1,3,6,8,10],index=idx2,name='sr2')
df1 = pd.DataFrame({'c1':[1,3,5,7,9],'c2':[20,13,12,9,21]},index=idx1)
df2 = pd.DataFrame({'c1':[11,13,15,17,19],'c2':[20,13,12,9,21]},index=idx2)
print(s1,s2,df1,df2,sep="\n--------\n")
 
idx1
a    1
b    3
c    5
d    7
e    9
Name: sr1, dtype: int64
--------
idx2
a     1
b     3
c     6
d     8
e    10
Name: sr2, dtype: int64
--------
      c1  c2
idx1        
a      1  20
b      3  13
c      5  12
d      7   9
e      9  21
--------
      c1  c2
idx2        
a     11  20
b     13  13
c     15  12
d     17   9
e     19  21

2.数值运算类方法

数值运算类方法：（下面的DataFrame方法对于Series也适用）

DataFrame.abs()：计算绝对值（只对数值元素进行计算）
DataFrame.all([axis, bool_only, skipna, level])：返回指定轴上：是否所有元素都为True或者非零。bool_only为True则仅考虑布尔型的数据。
DataFrame.any([axis, bool_only, skipna, level]) ：返回指定轴上：是否存在某个元素都为True或者非零。bool_only为True则仅考虑布尔型的数据。
DataFrame.clip([lower, upper, axis]) ：将指定轴上的数据裁剪到[lower,upper]这个闭区间之内。超过upper的值裁剪成upper；小于lower的值裁剪成lower。
DataFrame.clip_lower(threshold[, axis])：返回一份拷贝，该拷贝是在指定轴上：向下裁剪到threshold
DataFrame.clip_upper(threshold[, axis])：返回一份拷贝，该拷贝是在指定轴上：向上裁剪到threshold
DataFrame.prod([axis, skipna, level, ...]) ：计算指定轴上的乘积
DataFrame.sum([axis, skipna, level, ...])：沿着指定轴，计算样本的和
DataFrame.cumsum([axis, skipna]) ：计算沿着axis轴的累积和。
DataFrame.cumprod([axis, skipna]) ：计算沿着axis轴的累积乘积。
DataFrame.count([axis, level, numeric_only])：计算沿着axis轴，level级索引的非NaN值的数量。如果numeric_only为True，则只考虑数值和布尔类型。（对于Series，只有level一个参数。）
DataFrame.round([decimals]) ：对元素指定小数点位数。decimals可以为一个整数（所有的元素都按照该小数点位数）、一个字典（根据列label指定）

举例：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

import numpy as np
import pandas as pd
idx1 = pd.Index(['a','b','c','d','e'],name='idx1')
idx2 = pd.Index(['a','b','c','d','e'],name='idx2')
s1 = pd.Series([1,3,5,7,9],index=idx1,name='sr1')
s2 = pd.Series([1,3,6,8,10],index=idx2,name='sr2')
df1 = pd.DataFrame({'c1':[1,3,5,7,9],'c2':[20,13,12,9,21]},index=idx1)
df2 = pd.DataFrame({'c1':[11,13,15,17,19],'c2':[20,13,12,9,21]},index=idx2)
print(s1,s2,df1,df2,sep="\n--------\n")
 
# idx1
a    1
b    3
c    5
d    7
e    9
Name: sr1, dtype: int64
--------
idx2
a     1
b     3
c     6
d     8
e    10
Name: sr2, dtype: int64
--------
      c1  c2
idx1        
a      1  20
b      3  13
c      5  12
d      7   9
e      9  21
--------
      c1  c2
idx2        
a     11  20
b     13  13
c     15  12
d     17   9
e     19  21
 
print(df1.all(axis=0),df1.all(axis=1),sep='\n-----\n')
# c1    True
c2    True
dtype: bool
-----
idx1
a    True
b    True
c    True
d    True
e    True
dtype: bool
 
print(df1.clip(2,8,axis=0),df1.clip(2,8,axis=1),sep='\n-----\n')
#  c1  c2
idx1        
a      2   8
b      3   8
c      5   8
d      7   8
e      8   8
-----
      c1  c2
idx1        
a      2   8
b      3   8
c      5   8
d      7   8
e      8   8
 
print(df1.prod(axis=0),df1.prod(axis=1),sep='\n-----\n')
# c1       945
c2    589680
dtype: int64
-----
idx1
a     20
b     39
c     60
d     63
e    189
dtype: int64
 
print(df1.sum(axis=0),df1.sum(axis=1),sep='\n-----\n')
# c1    25
c2    75
dtype: int64
-----
idx1
a    21
b    16
c    17
d    16
e    30
dtype: int64
 
print(df1.cumsum(axis=0),df1.cumsum(axis=1),sep='\n-----\n')
#  c1  c2
idx1        
a      1  20
b      4  33
c      9  45
d     16  54
e     25  75
-----
      c1  c2
idx1        
a      1  21
b      3  16
c      5  17
d      7  16
e      9  30
 
print(df1.count(axis=0),df1.count(axis=1),sep='\n-----\n')
# c1    5
c2    5
dtype: int64
-----
idx1
a    2
b    2
c    2
d    2
e    2
dtype: int64

3.最大最小

最大最小：（下面的DataFrame方法对于Series也适用）

DataFrame.max([axis, skipna, level, ...])：沿着指定轴，计算最大值
DataFrame.min([axis, skipna, level, ...])：沿着指定轴，计算最小值
Series.argmax([axis, skipna, ...])：计算最大值的索引位置（一个整数值）

pandas 0.20 以后，它返回的不再是索引位置，而是索引 label，等价于 idxmax
Series.argmin([axis, skipna, ...])：计算最小值的索引位置（一个整数值）

pandas 0.20 以后，它返回的不再是索引位置，而是索引 label，等价于 idxmin
Series.idxmax([axis, skipna, ...])：计算最大值的索引label
Series.idxmin([axis, skipna, ...])：计算最小值的索引label
DataFrame.cummax([axis, skipna]) ：计算沿着axis轴的累积最大值。
DataFrame.cummin([axis, skipna]) ：计算沿着axis轴的累积最最小值。
DataFrame.quantile([q, axis, numeric_only, ...])：计算指定轴上样本的百分位数。q为一个浮点数或者一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位
DataFrame.rank([axis, method, numeric_only, ...])：计算指定轴上的排名。
DataFrame.pct_change([periods, fill_method, ...])：计算百分比变化。periods为相隔多少个周期。它计算的是：(s[i+periods]-s[i])/s[i]，注意结果并没有乘以 100。
Series.nlargest( *args,**kwargs)：计算最大的N个数。参数为：
1. n：最大的多少个数
2. keep：遇到重复值时怎么处理。可以为：'first'/'last'。
Series.nsmallest( *args,**kwargs)：计算最小的N个数。参数同上。

举例：

print(df1,df2,sep='\n---------\n')
      c1  c2
idx1        
a      1   2
b      3   5
c      5   7
d      7   9
e      9  11
---------
      c1  c2
idx2        
a     11  20
b     13  13
c     15  12
d     17   9
e     19  21
 
print(df1.max(axis=0),df1.max(axis=1),sep="\n----------\n")
c1     9
c2    11
dtype: int64
----------
idx1
a     2
b     5
c     7
d     9
e    11
dtype: int64
 
print(s1.max(),s1.argmax(),s1.idxmax(),sep=",")
9,e,e
 
print(df1.cummin(axis=0),df1.cummin(axis=1),sep="\n----------\n")
      c1  c2
idx1        
a      1   2
b      1   2
c      1   2
d      1   2
e      1   2
----------
      c1  c2
idx1        
a      1   1
b      3   3
c      5   5
d      7   7
e      9   9
 
print(df1.quantile(0.5,axis=0),df1.quantile(0.5,axis=1),sep="\n----------\n")
c1    5.0
c2    7.0
Name: 0.5, dtype: float64
----------
idx1
a     1.5
b     4.0
c     6.0
d     8.0
e    10.0
Name: 0.5, dtype: float64
 
print(df1.pct_change(1,axis=0),df1.pct_change(1,axis=1),sep="\n----------\n")
            c1        c2
idx1                    
a          NaN       NaN
b     2.000000  1.500000
c     0.666667  0.400000
d     0.400000  0.285714
e     0.285714  0.222222
----------
      c1        c2
idx1              
a    NaN  1.000000
b    NaN  0.666667
c    NaN  0.400000
d    NaN  0.285714
e    NaN  0.222222
 
print(s1.nlargest(2),s1.nsmallest(2),sep='\n----------\n')
idx1
e    9
d    7
Name: sr1, dtype: int64
----------
idx1
a    1
b    3
Name: sr1, dtype: int64

4.统计类方法

统计类方法：（下面的DataFrame方法对于Series也适用）

DataFrame.mean([axis, skipna, level, ...])：沿着指定轴，计算平均值
DataFrame.median([axis, skipna, level, ...])：沿着指定轴，计算位于中间大小的数
DataFrame.var([axis, skipna, level, ddof, ...])：沿着指定轴，计算样本的方差
DataFrame.std([axis, skipna, level, ddof, ...])：沿着指定轴，计算样本的标准差
DataFrame.mad([axis, skipna, level])：沿着指定轴，根据平均值计算平均绝对离差
DataFrame.diff([periods, axis])：沿着指定轴的一阶差分。periods为间隔。
DataFrame.skew([axis, skipna, level, ...])：沿着指定轴计算样本的偏度（二阶矩）
DataFrame.kurt([axis, skipna, level, ...])：沿着指定轴，计算样本的峰度（四阶矩）
1. 对随机变量X， $E(X^K),K=1,2,...$
DataFrame.describe([percentiles, include, ...])：获取顺序统计量以及其他的统计结果。
1. percentiles：一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位
2. include,exclude：指定包含/不包含哪些列（通过dtype来指定）。可以为None/'all'，或者一个dtype列表
DataFrame.corr([method, min_periods])：计算任意两个列之间的非NAN的、按照索引对齐的值的相关系数。method为相关系数的类型，可以为：
1. 'pearson'：标准的相关系数
2. 'kendall'：Kendall Tau相关系数
3. 'spearman'：Spearman rank相关系数
而min_periods：一个整数。它指定为了生成一个有效的相关系数，每一对列数据的最短长度。
DataFrame.corrwith(other[, axis, drop]) ：计算两个DataFrame的行-行、列-列的相关系数。
1. axis：如果为0/'index'则沿着0轴，则计算列-列之间的相关系数。如果为1/'columns'，则沿着1轴，计算行-行之间的相关系数
2. drop：一个布尔值。如果为True，则如果某行/列都是NaN，则抛弃该行/列。如果为False，则返回全部。
DataFrame.cov([min_periods])：计算任意两列之间的协方差。min_periods指定为了生成一个有效的协方差，每一对列数据的最短长度。
1. 对于Series，其调用为：Series.cov(other,[min_periods])

举例：

print(df1.mean(axis=0),df1.mean(axis=1),sep="\n--------------\n")
#c1    5.0
c2    6.8
dtype: float64
--------------
idx1
a     1.5
b     4.0
c     6.0
d     8.0
e    10.0
dtype: float64
 
print(df1.var(axis=0),df1.var(axis=1),sep="\n--------------\n")
#c1    10.0
c2    12.2
dtype: float64
--------------
idx1
a    0.5
b    2.0
c    2.0
d    2.0
e    2.0
dtype: float64
 
print(df1.mad(axis=0),df1.mad(axis=1),sep="\n--------------\n")
#c1    2.40
c2    2.64
dtype: float64
--------------
idx1
a    0.5
b    1.0
c    1.0
d    1.0
e    1.0
dtype: float64
 
print(df1.skew(axis=0),df1.skew(axis=1),sep="\n--------------\n")
#c1    0.000000
c2   -0.309766
dtype: float64
--------------
idx1
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
dtype: float64
 
df1.kurt(axis=0)
c1   -1.200000
c2   -0.643644
dtype: float64
 
df1.describe([0.2,0.5])
c1  c2
count   5.000000    5.00000
mean    5.000000    6.80000
std 3.162278    3.49285
min 1.000000    2.00000
20% 2.600000    4.40000
50% 5.000000    7.00000
max 9.000000    11.00000
 
df1.corr()
#c1 c2
c1  1.000000    0.995893
c2  0.995893    1.000000
 
print(df1.corrwith(df2,axis=0),df1.corrwith(df2,axis=1),sep='\n-----------\n')
#c1    1.000000
c2   -0.122839
dtype: float64
-----------
a    1.0
b    NaN
c   -1.0
d   -1.0
e    1.0
dtype: float64
 
df1.cov()
#c1 c2
c1  10.0    11.0
c2  11.0    12.2

5.唯一值、值计数、成员资格

Series.unique()：返回Series中唯一值组成的一维ndarray
Series.value_counts(normalize=False, sort=True, ascending=False,bins=None, dropna=True)：对Series中的数进行计数。如果normalize为True，则返回频率而不是频数。sort为True则结果根据出现的值排序，排序方式由ascending指定。
1. bins是一个整数或者None。如果它为整数，则使用半开半闭区间来统计，它给出了该区间的数量。
Series.isin(values)：返回一个布尔数组，给出Series中各值是否位于values中。

DataFrame也有此方法。

举例：

s2
#idx2
a     1
b     3
c     6
d     8
e    10
Name: sr2, dtype: int64
 
s2.unique()
#array([ 1,  3,  6,  8, 10], dtype=int64)
 
s2.value_counts()
#6     1
3     1
10    1
1     1
8     1
Name: sr2, dtype: int64
 
s2.isin([1,2,3,4,5,6])
#idx2
a     True
b     True
c     True
d    False
e    False
Name: sr2, dtype: bool
​

6.多级索引

对于多级索引，可以通过level参数来指定在某个轴上的操作索引级别。如果level=None，则不考虑索引的多级。

idx3 = pd.MultiIndex.from_tuples([('a','c'),('a','d'),('a','e'),
                                  ('b','c'),('b','d'),('b','e')],names=['lv0','lv1'])
s3 = pd.Series([1,3,5,7,9,11],index=idx3)
s3
# lv0  lv1
a    c       1
     d       3
     e       5
b    c       7
     d       9
     e      11
dtype: int64
 
print(s3.sum(level=0),s3.sum(level=1),s3.sum(level=None),sep='\n----------\n')
# lv0
a     9
b    27
dtype: int64
----------
lv1
c     8
d    12
e    16
dtype: int64
----------
36

posted @ 2019-12-27 17:16 nxf_rabbit75 阅读(328) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现

历史上的今天：
2018-12-27 去掉python的警告

2025年3月

日

一

二

三

四

五

六

Pandas---4.运算

一、数值运算

二、排序

`1.sort_index()`

2.sort_values()

3.sortlevel()

4.rank()

三、统计

1.支持numpy的数组接口,直接使用ufunc函数

2.数值运算类方法

3.最大最小

4.统计类方法

5.唯一值、值计数、成员资格

6.多级索引

搜索

最新随笔

随笔分类 (511)

阅读排行榜

推荐排行榜