zoukankan      html  css  js  c++  java
  • Pandas---4.运算

    一、数值运算

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

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

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

    1. other:一个DataFrame/Series或者一个array-like,或者一个标量值
    2. axis:指定操作的轴。可以为0/1/'index'/'columns' 。其意义是:操作发生在哪个轴上。
    3. fill_value:指定替换掉NaN的值。可以为None(不替换),或者一个浮点值。注意:如果发现两个NaN相加,则结果仍然还是NaN,而并不会是两个fill_value相加。
    4. 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 

    对于DataFrameSeries的运算,默认会用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='
    -----------------------
    ')
    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='
    ----------------
    ')
          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)

    参数:

    1. axis:指定沿着那个轴排序。如果为0/'index',则对沿着0轴,对行label排序;如果为1/'columns',则沿着 1轴对列label排序。
    2. level:一个整数、label、整数列表、label list或者None。对于多级索引,它指定在哪一级上排序。
    3. ascending:一个布尔值,如果为True,则升序排序;如果是False,则降序排序。
    4. inplace:一个布尔值,如果为True,则原地修改。如果为False,则返回排好序的新对象
    5. kind:一个字符串,指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的
    6. na_position:一个字符串,值为'first'/'last',指示:将NaN排在最开始还是最末尾。
    7. 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')

    参数:

    1. by:一个字符串或者字符串的列表,指定希望对那些label对应的列或者行的元素进行排序。对于DataFrame,必须指定该参数。而Series不能指定该参数。

      1. 如果是一个字符串列表,则排在前面的label的优先级较高。它指定了用于比较的字段

    2. axis:指定沿着那个轴排序。如果为0/'index',则沿着0轴排序(此时by指定列label,根据该列的各元素大小,重排列各行);如果为1/'columns',则沿着 1轴排序(此时by指定行label,根据该行的各元素大小,重排列各列)。

    3. ascending:一个布尔值,如果为True,则升序排序;如果是False,则降序排序。

    4. inplace:一个布尔值,如果为True,则原地修改。如果为False,则返回排好序的新对象

    5. kind:一个字符串,指定排序算法。可以为'quicksort'/'mergesort'/'heapsort'。注意只有归并排序是稳定排序的

    6. 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='
    ---------------------
    ')
    # 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 = '
    ----------
    ')
    # 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)

     参数:

    1. axis:指定沿着那个轴排名。如果为0/'index',则沿着行排名(对列排名);如果为1/'columns',则沿着列排名(对行排名)。

    2. 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

    3. numeric_only :一个布尔值。如果为True,则只对float/int/bool数据排名。仅对DataFrame有效

    4. na_option:一个字符串,指定对NaN的处理。可以为:

      1. 'keep':保留NaN在原位置
      2. 'top':如果升序,则NaN安排最大的排名
      3. 'bottom':如果升序,则NaN安排最小的排名
    5. ascending:一个布尔值,如果为True,则升序排名;如果是False,则降序排名。

    6. 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函数

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

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

    下面的方法使用如下的两个SeriesDataFrame

    举例:

    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="
    --------
    ")
    
    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也适用)

    1. DataFrame.abs():计算绝对值(只对数值元素进行计算)

    2. DataFrame.all([axis, bool_only, skipna, level]):返回指定轴上:是否所有元素都为True或者非零。bool_onlyTrue则仅考虑布尔型的数据。

    3. DataFrame.any([axis, bool_only, skipna, level]) :返回指定轴上:是否存在某个元素都为True或者非零。bool_onlyTrue则仅考虑布尔型的数据。

    4. DataFrame.clip([lower, upper, axis]) :将指定轴上的数据裁剪到[lower,upper]这个闭区间之内。超过upper的值裁剪成upper;小于lower的值裁剪成lower

    5. DataFrame.clip_lower(threshold[, axis]):返回一份拷贝,该拷贝是在指定轴上:向下裁剪到threshold

    6. DataFrame.clip_upper(threshold[, axis]):返回一份拷贝,该拷贝是在指定轴上:向上裁剪到threshold

    7. DataFrame.prod([axis, skipna, level, ...]) :计算指定轴上的乘积

    8. DataFrame.sum([axis, skipna, level, ...]):沿着指定轴,计算样本的和

    9. DataFrame.cumsum([axis, skipna]) :计算沿着axis轴的累积和。

    10. DataFrame.cumprod([axis, skipna]) :计算沿着axis轴的累积乘积。

    11. DataFrame.count([axis, level, numeric_only]):计算沿着axis轴,level级索引的非NaN值的数量。如果numeric_onlyTrue,则只考虑数值和布尔类型。(对于Series,只有level一个参数。)

    12. DataFrame.round([decimals]) :对元素指定小数点位数。decimals可以为一个整数(所有的元素都按照该小数点位数)、一个字典(根据列label指定) 

    举例:

    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="
    --------
    ")
    
    # 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='
    -----
    ')
    # 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='
    -----
    ')
    #  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='
    -----
    ')
    # 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='
    -----
    ')
    # 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='
    -----
    ')
    #  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='
    -----
    ')
    # c1    5
    c2    5
    dtype: int64
    -----
    idx1
    a    2
    b    2
    c    2
    d    2
    e    2
    dtype: int64
    

     

    3.最大最小

    最大最小:(下面的DataFrame方法对于Series也适用)

    1. DataFrame.max([axis, skipna, level, ...]): 沿着指定轴,计算最大值

    2. DataFrame.min([axis, skipna, level, ...]): 沿着指定轴,计算最小值

    3. Series.argmax([axis, skipna, ...]): 计算最大值的索引位置(一个整数值)

      pandas 0.20 以后,它返回的不再是索引位置,而是索引 label,等价于 idxmax

    4. Series.argmin([axis, skipna, ...]): 计算最小值的索引位置(一个整数值)

      pandas 0.20 以后,它返回的不再是索引位置,而是索引 label,等价于 idxmin

    5. Series.idxmax([axis, skipna, ...]): 计算最大值的索引label

    6. Series.idxmin([axis, skipna, ...]): 计算最小值的索引label

    7. DataFrame.cummax([axis, skipna]) :计算沿着axis轴的累积最大值。

    8. DataFrame.cummin([axis, skipna]) :计算沿着axis轴的累积最最小值。

    9. DataFrame.quantile([q, axis, numeric_only, ...]):计算指定轴上样本的百分位数。q为一个浮点数或者一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位

    10. DataFrame.rank([axis, method, numeric_only, ...]):计算指定轴上的排名。

    11. DataFrame.pct_change([periods, fill_method, ...]):计算百分比变化。periods为相隔多少个周期。它计算的是:(s[i+periods]-s[i])/s[i],注意结果并没有乘以 100。

    12. Series.nlargest( *args,**kwargs):计算最大的N个数。参数为:

      1. n:最大的多少个数
      2. keep:遇到重复值时怎么处理。可以为:'first'/'last'
    13. Series.nsmallest( *args,**kwargs):计算最小的N个数。参数同上。

    举例:

    print(df1,df2,sep='
    ---------
    ')
          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="
    ----------
    ")
    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="
    ----------
    ")
          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="
    ----------
    ")
    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="
    ----------
    ")
                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='
    ----------
    ')
    idx1
    e    9
    d    7
    Name: sr1, dtype: int64
    ----------
    idx1
    a    1
    b    3
    Name: sr1, dtype: int64
    

     

    4.统计类方法

    统计类方法:(下面的DataFrame方法对于Series也适用)

    1. DataFrame.mean([axis, skipna, level, ...]):沿着指定轴,计算平均值

    2. DataFrame.median([axis, skipna, level, ...]):沿着指定轴,计算位于中间大小的数

    3. DataFrame.var([axis, skipna, level, ddof, ...]):沿着指定轴,计算样本的方差

    4. DataFrame.std([axis, skipna, level, ddof, ...]):沿着指定轴,计算样本的标准差

    5. DataFrame.mad([axis, skipna, level]):沿着指定轴,根据平均值计算平均绝对离差

    6. DataFrame.diff([periods, axis]):沿着指定轴的一阶差分。periods为间隔。

    7. DataFrame.skew([axis, skipna, level, ...]):沿着指定轴计算样本的偏度(二阶矩)

    8. DataFrame.kurt([axis, skipna, level, ...]):沿着指定轴,计算样本的峰度(四阶矩)

      1. 对随机变量X,$E(X^K),K=1,2,...$若存在,则称它为$X$的$k$阶原点矩,简称$k$阶矩。若$Eleft[(X-E(X))^{k} ight], k=1,2, cdots$存在,则称它为X的k阶中心矩。
    9. DataFrame.describe([percentiles, include, ...]):获取顺序统计量以及其他的统计结果。

      1. percentiles:一个array-like。每个元素都是 0~1之间。如 0.5代表 50%分位
      2. include,exclude:指定包含/不包含哪些列(通过dtype来指定)。可以为None/'all',或者一个dtype列表
    10. DataFrame.corr([method, min_periods]):计算任意两个列之间的非NAN的、按照索引对齐的值的相关系数。method为相关系数的类型,可以为:

      1. 'pearson':标准的相关系数
      2. 'kendall'Kendall Tau相关系数
      3. 'spearman'Spearman rank相关系数

      min_periods:一个整数。它指定为了生成一个有效的相关系数,每一对列数据的最短长度。

    11. DataFrame.corrwith(other[, axis, drop]) :计算两个DataFrame的行-行、列-列的相关系数。

      1. axis:如果为0/'index'则沿着0轴,则计算列-列之间的相关系数。如果为1/'columns',则沿着1轴,计算行-行之间的相关系数
      2. drop:一个布尔值。如果为True,则如果某行/列都是NaN,则抛弃该行/列。如果为False,则返回全部。
    12. DataFrame.cov([min_periods]):计算任意两列之间的协方差。min_periods指定为了生成一个有效的协方差,每一对列数据的最短长度。

      1. 对于Series,其调用为:Series.cov(other,[min_periods])

    举例:

    print(df1.mean(axis=0),df1.mean(axis=1),sep="
    --------------
    ")
    #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="
    --------------
    ")
    #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="
    --------------
    ")
    #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="
    --------------
    ")
    #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='
    -----------
    ')
    #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.唯一值、值计数、成员资格

    1. Series.unique()返回Series中唯一值组成的一维ndarray

    2. Series.value_counts(normalize=False, sort=True, ascending=False,bins=None, dropna=True)Series中的数进行计数。如果normalizeTrue,则返回频率而不是频数。sortTrue则结果根据出现的值排序,排序方式由ascending指定。

      1. bins是一个整数或者None。如果它为整数,则使用半开半闭区间来统计,它给出了该区间的数量。
    3. 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='
    ----------
    ')
    # lv0
    a     9
    b    27
    dtype: int64
    ----------
    lv1
    c     8
    d    12
    e    16
    dtype: int64
    ----------
    36
    

  • 相关阅读:
    js中的原生Ajax和JQuery中的Ajax
    this的用法
    static的特性
    时政20180807
    java compiler没有1.8怎么办
    Description Resource Path Location Type Java compiler level does not match the version of the installed Java project facet Unknown Faceted Project Problem (Java Version Mismatch)
    分词器
    [数算]有一个工程甲、乙、丙单独做,分别要48天、72天、96天完成
    一点感想
    解析Excel文件 Apache POI框架使用
  • 原文地址:https://www.cnblogs.com/nxf-rabbit75/p/12108436.html
Copyright © 2011-2022 走看看