• Pandas之DataFrame——Part 3


    '''
    【课程2.14】  数值计算和统计基础
    
    常用数学、统计方法
     
    '''
    # 基本参数:axis、skipna
    
    import numpy as np
    import pandas as pd
    
    df = pd.DataFrame({'key1':[4,5,3,np.nan,2],
                     'key2':[1,2,np.nan,4,5],
                     'key3':[1,2,3,'j','k']},
                     index = ['a','b','c','d','e'])
    print(df)
    print(df['key1'].dtype,df['key2'].dtype,df['key3'].dtype)
    print('-----')
    
    m1 = df.mean()
    print(m1,type(m1))
    print('单独统计一列:',df['key2'].mean())
    print('-----')
    # np.nan :空值
    # .mean()计算均值
    # 只统计数字列
    # 可以通过索引单独统计一列
    
    m2 = df.mean(axis=1)
    print(m2)
    print('-----')
    # axis参数:默认为0,以列来计算,axis=1,以行来计算,这里就按照行来汇总了
    
    m3 = df.mean(skipna=False)
    print(m3)
    print('-----')
    # skipna参数:是否忽略NaN,默认True,如False,有NaN的列统计结果仍未NaN

      输出:

       key1  key2 key3
    a   4.0   1.0    1
    b   5.0   2.0    2
    c   3.0   NaN    3
    d   NaN   4.0    j
    e   2.0   5.0    k
    float64 float64 object
    -----
    key1    3.5
    key2    3.0
    dtype: float64 <class 'pandas.core.series.Series'>
    单独统计一列: 3.0
    -----
    a    2.5
    b    3.5
    c    3.0
    d    4.0
    e    3.5
    dtype: float64
    -----
    key1   NaN
    key2   NaN
    dtype: float64
    -----
    # 主要数学计算方法,可用于Series和DataFrame(1)
    
    df = pd.DataFrame({'key1':np.arange(10),
                      'key2':np.random.rand(10)*10})
    print(df)
    print('-----')
    
    print(df.count(),'→ count统计非Na值的数量
    ')
    print(df.min(),'→ min统计最小值
    ',df['key2'].max(),'→ max统计最大值
    ')
    print(df.quantile(q=0.75),'→ quantile统计分位数,参数q确定位置
    ')
    print(df.sum(),'→ sum求和
    ')
    print(df.mean(),'→ mean求平均值
    ')
    print(df.median(),'→ median求算数中位数,50%分位数
    ')
    print(df.std(),'
    ',df.var(),'→ std,var分别求标准差,方差
    ')
    print(df.skew(),'→ skew样本的偏度
    ')
    print(df.kurt(),'→ kurt样本的峰度
    ')

      输出:

      key1      key2
    0     0  4.667989
    1     1  4.336625
    2     2  0.746852
    3     3  9.670919
    4     4  8.732045
    5     5  0.013751
    6     6  8.963752
    7     7  0.279303
    8     8  8.586821
    9     9  8.899657
    -----
    key1    10
    key2    10
    dtype: int64 → count统计非Na值的数量
    
    key1    0.000000
    key2    0.013751
    dtype: float64 → min统计最小值
     9.67091932107 → max统计最大值
    
    key1    6.750000
    key2    8.857754
    dtype: float64 → quantile统计分位数,参数q确定位置
    
    key1    45.000000
    key2    54.897714
    dtype: float64 → sum求和
    
    key1    4.500000
    key2    5.489771
    dtype: float64 → mean求平均值
    
    key1    4.500000
    key2    6.627405
    dtype: float64 → median求算数中位数,50%分位数
    
    key1    3.027650
    key2    3.984945
    dtype: float64 
     key1     9.166667
    key2    15.879783
    dtype: float64 → std,var分别求标准差,方差
    
    key1    0.000000
    key2   -0.430166
    dtype: float64 → skew样本的偏度
    
    key1   -1.200000
    key2   -1.800296
    dtype: float64 → kurt样本的峰度
    # 主要数学计算方法,可用于Series和DataFrame(2)
    
    df['key1_s'] = df['key1'].cumsum()
    df['key2_s'] = df['key2'].cumsum()
    print(df,'→ cumsum样本的累计和
    ')
    
    df['key1_p'] = df['key1'].cumprod()
    df['key2_p'] = df['key2'].cumprod()
    print(df,'→ cumprod样本的累计积
    ')
    
    print(df.cummax(),'
    ',df.cummin(),'→ cummax,cummin分别求累计最大值,累计最小值
    ')
    # 会填充key1,和key2的值

      输出:

      key1      key2  key1_s     key2_s
    0     0  4.667989       0   4.667989
    1     1  4.336625       1   9.004614
    2     2  0.746852       3   9.751466
    3     3  9.670919       6  19.422386
    4     4  8.732045      10  28.154431
    5     5  0.013751      15  28.168182
    6     6  8.963752      21  37.131934
    7     7  0.279303      28  37.411236
    8     8  8.586821      36  45.998057
    9     9  8.899657      45  54.897714 → cumsum样本的累计和
    
       key1      key2  key1_s     key2_s  key1_p       key2_p
    0     0  4.667989       0   4.667989       0     4.667989
    1     1  4.336625       1   9.004614       0    20.243318
    2     2  0.746852       3   9.751466       0    15.118767
    3     3  9.670919       6  19.422386       0   146.212377
    4     4  8.732045      10  28.154431       0  1276.733069
    5     5  0.013751      15  28.168182       0    17.556729
    6     6  8.963752      21  37.131934       0   157.374157
    7     7  0.279303      28  37.411236       0    43.955024
    8     8  8.586821      36  45.998057       0   377.433921
    9     9  8.899657      45  54.897714       0  3359.032396 → cumprod样本的累计积
    
       key1      key2  key1_s     key2_s  key1_p       key2_p
    0   0.0  4.667989     0.0   4.667989     0.0     4.667989
    1   1.0  4.667989     1.0   9.004614     0.0    20.243318
    2   2.0  4.667989     3.0   9.751466     0.0    20.243318
    3   3.0  9.670919     6.0  19.422386     0.0   146.212377
    4   4.0  9.670919    10.0  28.154431     0.0  1276.733069
    5   5.0  9.670919    15.0  28.168182     0.0  1276.733069
    6   6.0  9.670919    21.0  37.131934     0.0  1276.733069
    7   7.0  9.670919    28.0  37.411236     0.0  1276.733069
    8   8.0  9.670919    36.0  45.998057     0.0  1276.733069
    9   9.0  9.670919    45.0  54.897714     0.0  3359.032396 
        key1      key2  key1_s    key2_s  key1_p    key2_p
    0   0.0  4.667989     0.0  4.667989     0.0  4.667989
    1   0.0  4.336625     0.0  4.667989     0.0  4.667989
    2   0.0  0.746852     0.0  4.667989     0.0  4.667989
    3   0.0  0.746852     0.0  4.667989     0.0  4.667989
    4   0.0  0.746852     0.0  4.667989     0.0  4.667989
    5   0.0  0.013751     0.0  4.667989     0.0  4.667989
    6   0.0  0.013751     0.0  4.667989     0.0  4.667989
    7   0.0  0.013751     0.0  4.667989     0.0  4.667989
    8   0.0  0.013751     0.0  4.667989     0.0  4.667989
    9   0.0  0.013751     0.0  4.667989     0.0  4.667989 → cummax,cummin分别求累计最大值,累计最小值
    # 唯一值:.unique()
    
    s = pd.Series(list('asdvasdcfgg'))
    sq = s.unique()
    print(s)
    print(sq,type(sq))
    print(pd.Series(sq))
    # 得到一个唯一值数组
    # 通过pd.Series重新变成新的Series
    
    sq.sort()
    print(sq)
    # 重新排序

      输出:

    0     a
    1     s
    2     d
    3     v
    4     a
    5     s
    6     d
    7     c
    8     f
    9     g
    10    g
    dtype: object
    ['a' 's' 'd' 'v' 'c' 'f' 'g'] <class 'numpy.ndarray'>
    0    a
    1    s
    2    d
    3    v
    4    c
    5    f
    6    g
    dtype: object
    ['a' 'c' 'd' 'f' 'g' 's' 'v']
    # 值计数:.value_counts()
    
    sc = s.value_counts(sort = False)  # 也可以这样写:pd.value_counts(sc, sort = False)
    print(sc)
    # 得到一个新的Series,计算出不同值出现的频率
    # sort参数:排序,默认为True

      输出:

    s    2
    d    2
    v    1
    c    1
    a    2
    g    2
    f    1
    dtype: int64
    # 成员资格:.isin()
    
    s = pd.Series(np.arange(10,15))
    df = pd.DataFrame({'key1':list('asdcbvasd'),
                      'key2':np.arange(4,13)})
    print(s)
    print(df)
    print('-----')
    
    print(s.isin([5,14]))
    print(df.isin(['a','bc','10',8]))
    # 用[]表示
    # 得到一个布尔值的Series或者Dataframe

      输出:

    0    10
    1    11
    2    12
    3    13
    4    14
    dtype: int32
      key1  key2
    0    a     4
    1    s     5
    2    d     6
    3    c     7
    4    b     8
    5    v     9
    6    a    10
    7    s    11
    8    d    12
    -----
    0    False
    1    False
    2    False
    3    False
    4     True
    dtype: bool
        key1   key2
    0   True  False
    1  False  False
    2  False  False
    3  False  False
    4  False   True
    5  False  False
    6   True  False
    7  False  False
    8  False  False
    '''
    【课程2.15】  文本数据
    
    Pandas针对字符串配备的一套方法,使其易于对数组的每个元素进行操作
     
    '''
    # 通过str访问,且自动排除丢失/ NA值
    
    s = pd.Series(['A','b','C','bbhello','123',np.nan,'hj'])
    df = pd.DataFrame({'key1':list('abcdef'),
                      'key2':['hee','fv','w','hija','123',np.nan]})
    print(s)
    print(df)
    print('-----')
    
    print(s.str.count('b'))
    print(df['key2'].str.upper())
    print('-----')
    # 直接通过.str调用字符串方法
    # 可以对Series、Dataframe使用
    # 自动过滤NaN值
    
    df.columns = df.columns.str.upper()
    print(df)
    # df.columns是一个Index对象,也可使用.str

      输出:

    0          A
    1          b
    2          C
    3    bbhello
    4        123
    5        NaN
    6         hj
    dtype: object
      key1  key2
    0    a   hee
    1    b    fv
    2    c     w
    3    d  hija
    4    e   123
    5    f   NaN
    -----
    0    0.0
    1    1.0
    2    0.0
    3    2.0
    4    0.0
    5    NaN
    6    0.0
    dtype: float64
    0     HEE
    1      FV
    2       W
    3    HIJA
    4     123
    5     NaN
    Name: key2, dtype: object
    -----
      KEY1  KEY2
    0    a   hee
    1    b    fv
    2    c     w
    3    d  hija
    4    e   123
    5    f   NaN
    # 字符串常用方法(1) - lower,upper,len,startswith,endswith
    
    s = pd.Series(['A','b','bbhello','123',np.nan])
    
    print(s.str.lower(),'→ lower小写
    ')
    print(s.str.upper(),'→ upper大写
    ')
    print(s.str.len(),'→ len字符长度
    ')
    print(s.str.startswith('b'),'→ 判断起始是否为a
    ')
    print(s.str.endswith('3'),'→ 判断结束是否为3
    ')

      输出:

    0          a
    1          b
    2    bbhello
    3        123
    4        NaN
    dtype: object → lower小写
    
    0          A
    1          B
    2    BBHELLO
    3        123
    4        NaN
    dtype: object → upper大写
    
    0    1.0
    1    1.0
    2    7.0
    3    3.0
    4    NaN
    dtype: float64 → len字符长度
    
    0    False
    1     True
    2     True
    3    False
    4      NaN
    dtype: object → 判断起始是否为a
    
    0    False
    1    False
    2    False
    3     True
    4      NaN
    dtype: object → 判断结束是否为3
    # 字符串常用方法(2) - strip
    
    s = pd.Series([' jack', 'jill ', ' jesse ', 'frank'])
    df = pd.DataFrame(np.random.randn(3, 2), columns=[' Column A ', ' Column B '],
                      index=range(3))
    print(s)
    print(df)
    print('-----')
    
    print(s.str.strip())  # 去除字符串中的空格
    print(s.str.lstrip())  # 去除字符串中的左空格
    print(s.str.rstrip())  # 去除字符串中的右空格
    
    df.columns = df.columns.str.strip()
    print(df)
    # 这里去掉了columns的前后空格,但没有去掉中间空格

      输出:

    0       jack
    1      jill 
    2     jesse 
    3      frank
    dtype: object
        Column A    Column B 
    0    0.647766    0.094747
    1    0.342940   -0.660643
    2    1.183315   -0.143729
    -----
    0     jack
    1     jill
    2    jesse
    3    frank
    dtype: object
    0      jack
    1     jill 
    2    jesse 
    3     frank
    dtype: object
    0      jack
    1      jill
    2     jesse
    3     frank
    dtype: object
       Column A  Column B
    0  0.647766  0.094747
    1  0.342940 -0.660643
    2  1.183315 -0.143729
    # 字符串常用方法(3) - replace
    
    df = pd.DataFrame(np.random.randn(3, 2), columns=[' Column A ', ' Column B '],
                      index=range(3))
    df.columns = df.columns.str.replace(' ','-')
    print(df)
    # 替换
    
    df.columns = df.columns.str.replace('-','hehe',n=1)
    print(df)
    # n:替换个数

      输出:

       -Column-A-  -Column-B-
    0    1.855227   -0.519479
    1   -0.400376   -0.421383
    2   -0.293797   -0.432481
       heheColumn-A-  heheColumn-B-
    0       1.855227      -0.519479
    1      -0.400376      -0.421383
    2      -0.293797      -0.432481
    # 字符串常用方法(4) - split、rsplit
    
    s = pd.Series(['a,b,c','1,2,3',['a,,,c'],np.nan])
    print(s.str.split(','))
    print('-----')
    # 类似字符串的split
    
    print(s.str.split(',')[0])
    print('-----')
    # 直接索引得到一个list
    
    print(s.str.split(',').str[0])
    print(s.str.split(',').str.get(1))
    print('-----')
    # 可以使用get或[]符号访问拆分列表中的元素
    
    print(s.str.split(',', expand=True))
    print(s.str.split(',', expand=True, n = 1))
    print(s.str.rsplit(',', expand=True, n = 1))
    print('-----')
    # 可以使用expand可以轻松扩展此操作以返回DataFrame
    # n参数限制分割数
    # rsplit类似于split,反向工作,即从字符串的末尾到字符串的开头
    
    df = pd.DataFrame({'key1':['a,b,c','1,2,3',[':,., ']],
                      'key2':['a-b-c','1-2-3',[':-.- ']]})
    print(df['key2'].str.split('-'))
    # Dataframe使用split

      输出:

    0    [a, b, c]
    1    [1, 2, 3]
    2          NaN
    3          NaN
    dtype: object
    -----
    ['a', 'b', 'c']
    -----
    0      a
    1      1
    2    NaN
    3    NaN
    dtype: object
    0      b
    1      2
    2    NaN
    3    NaN
    dtype: object
    -----
         0     1     2
    0    a     b     c
    1    1     2     3
    2  NaN  None  None
    3  NaN  None  None
         0     1
    0    a   b,c
    1    1   2,3
    2  NaN  None
    3  NaN  None
         0     1
    0  a,b     c
    1  1,2     3
    2  NaN  None
    3  NaN  None
    -----
    0    [a, b, c]
    1    [1, 2, 3]
    2          NaN
    Name: key2, dtype: object
    # 字符串索引
    
    s = pd.Series(['A','b','C','bbhello','123',np.nan,'hj'])
    df = pd.DataFrame({'key1':list('abcdef'),
                      'key2':['hee','fv','w','hija','123',np.nan]})
    
    print(s.str[0])  # 取第一个字符串
    print(s.str[:2])  # 取前两个字符串
    print(df['key2'].str[0]) 
    # str之后和字符串本身索引方式相同

      输出:

    0      A
    1      b
    2      C
    3      b
    4      1
    5    NaN
    6      h
    dtype: object
    0      A
    1      b
    2      C
    3     bb
    4     12
    5    NaN
    6     hj
    dtype: object
    0      h
    1      f
    2      w
    3      h
    4      1
    5    NaN
    Name: key2, dtype: object
    '''
    【课程2.16】  合并 merge、join
    
    Pandas具有全功能的,高性能内存中连接操作,与SQL等关系数据库非常相似
    
    pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
             left_index=False, right_index=False, sort=True,
             suffixes=('_x', '_y'), copy=True, indicator=False)
     
    '''
    # merge合并 → 类似excel的vlookup
    
    df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                         'A': ['A0', 'A1', 'A2', 'A3'],
                         'B': ['B0', 'B1', 'B2', 'B3']})
    df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                          'C': ['C0', 'C1', 'C2', 'C3'],
                          'D': ['D0', 'D1', 'D2', 'D3']})
    df3 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                        'key2': ['K0', 'K1', 'K0', 'K1'],
                        'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3']})
    df4 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                        'key2': ['K0', 'K0', 'K0', 'K0'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
    print(pd.merge(df1, df2, on='key'))
    print('------')
    # left:第一个df
    # right:第二个df
    # on:参考键
    
    print(pd.merge(df3, df4, on=['key1','key2']))
    # 多个链接键

      输出:

       A   B key   C   D
    0  A0  B0  K0  C0  D0
    1  A1  B1  K1  C1  D1
    2  A2  B2  K2  C2  D2
    3  A3  B3  K3  C3  D3
    ------
        A   B key1 key2   C   D
    0  A0  B0   K0   K0  C0  D0
    1  A2  B2   K1   K0  C1  D1
    2  A2  B2   K1   K0  C2  D2
    # 参数how → 合并方式
    
    print(pd.merge(df3, df4,on=['key1','key2'], how = 'inner'))  
    print('------')
    # inner:默认,取交集
    
    print(pd.merge(df3, df4, on=['key1','key2'], how = 'outer'))  
    print('------')
    # outer:取并集,数据缺失范围NaN
    
    print(pd.merge(df3, df4, on=['key1','key2'], how = 'left'))  
    print('------')
    # left:按照df3为参考合并,数据缺失范围NaN
    
    print(pd.merge(df3, df4, on=['key1','key2'], how = 'right'))  
    # right:按照df4为参考合并,数据缺失范围NaN

      输出:

       A   B key1 key2   C   D
    0  A0  B0   K0   K0  C0  D0
    1  A2  B2   K1   K0  C1  D1
    2  A2  B2   K1   K0  C2  D2
    ------
         A    B key1 key2    C    D
    0   A0   B0   K0   K0   C0   D0
    1   A1   B1   K0   K1  NaN  NaN
    2   A2   B2   K1   K0   C1   D1
    3   A2   B2   K1   K0   C2   D2
    4   A3   B3   K2   K1  NaN  NaN
    5  NaN  NaN   K2   K0   C3   D3
    ------
        A   B key1 key2    C    D
    0  A0  B0   K0   K0   C0   D0
    1  A1  B1   K0   K1  NaN  NaN
    2  A2  B2   K1   K0   C1   D1
    3  A2  B2   K1   K0   C2   D2
    4  A3  B3   K2   K1  NaN  NaN
    ------
         A    B key1 key2   C   D
    0   A0   B0   K0   K0  C0  D0
    1   A2   B2   K1   K0  C1  D1
    2   A2   B2   K1   K0  C2  D2
    3  NaN  NaN   K2   K0  C3  D3
    # 参数 left_on, right_on, left_index, right_index → 当键不为一个列时,可以单独设置左键与右键
    
    df1 = pd.DataFrame({'lkey':list('bbacaab'),
                       'data1':range(7)})
    df2 = pd.DataFrame({'rkey':list('abd'),
                       'date2':range(3)})
    print(pd.merge(df1, df2, left_on='lkey', right_on='rkey'))
    print('------')
    # df1以‘lkey’为键,df2以‘rkey’为键
    
    df1 = pd.DataFrame({'key':list('abcdfeg'),
                       'data1':range(7)})
    df2 = pd.DataFrame({'date2':range(100,105)},
                      index = list('abcde'))
    print(pd.merge(df1, df2, left_on='key', right_index=True))
    # df1以‘key’为键,df2以index为键
    # left_index:为True时,第一个df以index为键,默认False
    # right_index:为True时,第二个df以index为键,默认False
    
    # 所以left_on, right_on, left_index, right_index可以相互组合:
    # left_on + right_on, left_on + right_index, left_index + right_on, left_index + right_index

      输出:

      data1 lkey  date2 rkey
    0      0    b      1    b
    1      1    b      1    b
    2      6    b      1    b
    3      2    a      0    a
    4      4    a      0    a
    5      5    a      0    a
    ------
       data1 key  date2
    0      0   a    100
    1      1   b    101
    2      2   c    102
    3      3   d    103
    5      5   e    104
    # 参数 sort
    
    df1 = pd.DataFrame({'key':list('bbacaab'),
                       'data1':[1,3,2,4,5,9,7]})
    df2 = pd.DataFrame({'key':list('abd'),
                       'date2':[11,2,33]})
    x1 = pd.merge(df1,df2, on = 'key', how = 'outer')
    x2 = pd.merge(df1,df2, on = 'key', sort=True, how = 'outer')
    print(x1)
    print(x2)
    print('------')
    # sort:按照字典顺序通过 连接键 对结果DataFrame进行排序。默认为False,设置为False会大幅提高性能
    
    print(x2.sort_values('data1'))
    # 也可直接用Dataframe的排序方法:sort_values,sort_index

      输出:

       data1 key  date2
    0    1.0   b    2.0
    1    3.0   b    2.0
    2    7.0   b    2.0
    3    2.0   a   11.0
    4    5.0   a   11.0
    5    9.0   a   11.0
    6    4.0   c    NaN
    7    NaN   d   33.0
       data1 key  date2
    0    2.0   a   11.0
    1    5.0   a   11.0
    2    9.0   a   11.0
    3    1.0   b    2.0
    4    3.0   b    2.0
    5    7.0   b    2.0
    6    4.0   c    NaN
    7    NaN   d   33.0
    ------
       data1 key  date2
    3    1.0   b    2.0
    0    2.0   a   11.0
    4    3.0   b    2.0
    6    4.0   c    NaN
    1    5.0   a   11.0
    5    7.0   b    2.0
    2    9.0   a   11.0
    7    NaN   d   33.0
    # pd.join() → 直接通过索引链接
    
    left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                         'B': ['B0', 'B1', 'B2']},
                        index=['K0', 'K1', 'K2'])
    right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                          'D': ['D0', 'D2', 'D3']},
                         index=['K0', 'K2', 'K3'])
    print(left)
    print(right)
    print(left.join(right))
    print(left.join(right, how='outer'))  
    print('-----')
    # 等价于:pd.merge(left, right, left_index=True, right_index=True, how='outer')
    
    df1 = pd.DataFrame({'key':list('bbacaab'),
                       'data1':[1,3,2,4,5,9,7]})
    df2 = pd.DataFrame({'key':list('abd'),
                       'date2':[11,2,33]})
    print(df1)
    print(df2)
    print(pd.merge(df1, df2, left_index=True, right_index=True, suffixes=('_1', '_2')))  
    print(df1.join(df2['date2']))
    print('-----')
    # suffixes=('_x', '_y')默认
    
    left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                         'B': ['B0', 'B1', 'B2', 'B3'],
                         'key': ['K0', 'K1', 'K0', 'K1']})
    right = pd.DataFrame({'C': ['C0', 'C1'],
                          'D': ['D0', 'D1']},
                         index=['K0', 'K1'])
    print(left)
    print(right)
    print(left.join(right, on = 'key'))
    # 等价于pd.merge(left, right, left_on='key', right_index=True, how='left', sort=False);
    # left的‘key’和right的index

      输出:

         A   B
    K0  A0  B0
    K1  A1  B1
    K2  A2  B2
         C   D
    K0  C0  D0
    K2  C2  D2
    K3  C3  D3
         A   B    C    D
    K0  A0  B0   C0   D0
    K1  A1  B1  NaN  NaN
    K2  A2  B2   C2   D2
          A    B    C    D
    K0   A0   B0   C0   D0
    K1   A1   B1  NaN  NaN
    K2   A2   B2   C2   D2
    K3  NaN  NaN   C3   D3
    -----
       data1 key
    0      1   b
    1      3   b
    2      2   a
    3      4   c
    4      5   a
    5      9   a
    6      7   b
       date2 key
    0     11   a
    1      2   b
    2     33   d
       data1 key_1  date2 key_2
    0      1     b     11     a
    1      3     b      2     b
    2      2     a     33     d
       data1 key  date2
    0      1   b   11.0
    1      3   b    2.0
    2      2   a   33.0
    3      4   c    NaN
    4      5   a    NaN
    5      9   a    NaN
    6      7   b    NaN
    -----
        A   B key
    0  A0  B0  K0
    1  A1  B1  K1
    2  A2  B2  K0
    3  A3  B3  K1
         C   D
    K0  C0  D0
    K1  C1  D1
        A   B key   C   D
    0  A0  B0  K0  C0  D0
    1  A1  B1  K1  C1  D1
    2  A2  B2  K0  C0  D0
    3  A3  B3  K1  C1  D1
    '''
    【课程2.17】  连接与修补 concat、combine_first
    
    连接 - 沿轴执行连接操作
    
    pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
              keys=None, levels=None, names=None, verify_integrity=False,
              copy=True)
     
    '''
    # 连接:concat
    
    s1 = pd.Series([1,2,3])
    s2 = pd.Series([2,3,4])
    s3 = pd.Series([1,2,3],index = ['a','c','h'])
    s4 = pd.Series([2,3,4],index = ['b','e','d'])
    print(pd.concat([s1,s2]))
    print(pd.concat([s3,s4]).sort_index())
    print('-----')
    # 默认axis=0,行+行
    
    print(pd.concat([s3,s4], axis=1))
    print('-----')
    # axis=1,列+列,成为一个Dataframe

      输出:

    0    1
    1    2
    2    3
    0    2
    1    3
    2    4
    dtype: int64
    a    1
    b    2
    c    2
    d    4
    e    3
    h    3
    dtype: int64
    -----
         0    1
    a  1.0  NaN
    b  NaN  2.0
    c  2.0  NaN
    d  NaN  4.0
    e  NaN  3.0
    h  3.0  NaN
    -----
    # 连接方式:join,join_axes
    
    s5 = pd.Series([1,2,3],index = ['a','b','c'])
    s6 = pd.Series([2,3,4],index = ['b','c','d'])
    print(pd.concat([s5,s6], axis= 1))
    print(pd.concat([s5,s6], axis= 1, join='inner'))
    print(pd.concat([s5,s6], axis= 1, join_axes=[['a','b','d']]))
    # join:{'inner''outer'},默认为“outer”。如何处理其他轴上的索引。outer为联合和inner为交集。
    # join_axes:指定联合的index

      输出:

         0    1
    a  1.0  NaN
    b  2.0  2.0
    c  3.0  3.0
    d  NaN  4.0
       0  1
    b  2  2
    c  3  3
         0    1
    a  1.0  NaN
    b  2.0  2.0
    d  NaN  4.0
    # 覆盖列名
    
    sre = pd.concat([s5,s6], keys = ['one','two'])
    print(sre,type(sre))
    print(sre.index)
    print('-----')
    # keys:序列,默认值无。使用传递的键作为最外层构建层次索引
    
    sre = pd.concat([s5,s6], axis=1, keys = ['one','two'])
    print(sre,type(sre))
    # axis = 1, 覆盖列名

      输出:

    one  a    1
         b    2
         c    3
    two  b    2
         c    3
         d    4
    dtype: int64 <class 'pandas.core.series.Series'>
    MultiIndex(levels=[['one', 'two'], ['a', 'b', 'c', 'd']],
               labels=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 1, 2, 3]])
    -----
       one  two
    a  1.0  NaN
    b  2.0  2.0
    c  3.0  3.0
    d  NaN  4.0 <class 'pandas.core.frame.DataFrame'>
    # 修补 pd.combine_first()
    
    df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],[np.nan, 7., np.nan]])
    df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],index=[1, 2])
    print(df1)
    print(df2)
    print(df1.combine_first(df2))
    print('-----')
    # 根据index,df1的空值被df2替代
    # 如果df2的index多于df1,则更新到df1上,比如index=['a',1]
    
    df1.update(df2)
    print(df1)
    # update,直接df2覆盖df1,相同index位置

      输出:

         0    1    2
    0  NaN  3.0  5.0
    1 -4.6  NaN  NaN
    2  NaN  7.0  NaN
          0    1    2
    1 -42.6  NaN -8.2
    2  -5.0  1.6  4.0
         0    1    2
    0  NaN  3.0  5.0
    1 -4.6  NaN -8.2
    2 -5.0  7.0  4.0
    -----
          0    1    2
    0   NaN  3.0  5.0
    1 -42.6  NaN -8.2
    2  -5.0  1.6  4.0
    '''
    【课程2.18】  去重及替换
    
    .duplicated / .replace
     
    '''
    # 去重 .duplicated
    
    s = pd.Series([1,1,1,1,2,2,2,3,4,5,5,5,5])
    print(s.duplicated())
    print(s[s.duplicated() == False])
    print('-----')
    # 判断是否重复
    # 通过布尔判断,得到不重复的值
    
    s_re = s.drop_duplicates()
    print(s_re)
    print('-----')
    # drop.duplicates移除重复
    # inplace参数:是否替换原值,默认False
    
    df = pd.DataFrame({'key1':['a','a',3,4,5],
                      'key2':['a','a','b','b','c']})
    print(df.duplicated())
    print(df['key2'].duplicated())
    # Dataframe中使用duplicated

      输出:

    0     False
    1      True
    2      True
    3      True
    4     False
    5      True
    6      True
    7     False
    8     False
    9     False
    10     True
    11     True
    12     True
    dtype: bool
    0    1
    4    2
    7    3
    8    4
    9    5
    dtype: int64
    -----
    0    1
    4    2
    7    3
    8    4
    9    5
    dtype: int64
    -----
    0    False
    1     True
    2    False
    3    False
    4    False
    dtype: bool
    0    False
    1     True
    2    False
    3     True
    4    False
    Name: key2, dtype: bool

      

    # 替换 .replace
    
    s = pd.Series(list('ascaazsd'))
    print(s.replace('a', np.nan))
    print(s.replace(['a','s'] ,np.nan))
    print(s.replace({'a':'hello world!','s':123}))
    # 可一次性替换一个值或多个值
    # 可传入列表或字典

      输出:

    0    NaN
    1      s
    2      c
    3    NaN
    4    NaN
    5      z
    6      s
    7      d
    dtype: object
    0    NaN
    1    NaN
    2      c
    3    NaN
    4    NaN
    5      z
    6    NaN
    7      d
    dtype: object
    0    hello world!
    1             123
    2               c
    3    hello world!
    4    hello world!
    5               z
    6             123
    7               d
    dtype: object
    '''
    【课程2.19】  数据分组
    
    分组统计 - groupby功能
    
    ① 根据某些条件将数据拆分成组
    ② 对每个组独立应用函数
    ③ 将结果合并到一个数据结构中
    
    Dataframe在行(axis=0)或列(axis=1)上进行分组,将一个函数应用到各个分组并产生一个新值,然后函数执行结果被合并到最终的结果对象中。
    
    df.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
     
    '''
    # 分组
    
    df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
                       'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                       'C' : np.random.randn(8),
                       'D' : np.random.randn(8)})
    print(df)
    print('------')
    
    print(df.groupby('A'), type(df.groupby('A')))
    print('------')
    # 直接分组得到一个groupby对象,是一个中间数据,没有进行计算
    
    a = df.groupby('A').mean()
    b = df.groupby(['A','B']).mean()
    c = df.groupby(['A'])['D'].mean()  # 以A分组,算D的平均值
    print(a,type(a),'
    ',a.columns)
    print(b,type(b),'
    ',b.columns)
    print(c,type(c))
    # 通过分组后的计算,得到一个新的dataframe
    # 默认axis = 0,以行来分组
    # 可单个或多个([])列分组

      输出:

         A      B         C         D
    0  foo    one  0.891765 -1.121156
    1  bar    one -1.272769  1.188977
    2  foo    two  0.198131  0.543673
    3  bar  three -0.827655 -1.608699
    4  foo    two -1.114089 -0.696145
    5  bar    two -0.345336  0.718507
    6  foo    one -0.207091 -0.922269
    7  foo  three -0.431760 -0.123696
    ------
    <pandas.core.groupby.DataFrameGroupBy object at 0x0000000004B65E10> <class 'pandas.core.groupby.DataFrameGroupBy'>
    ------
                C         D
    A                      
    bar -0.815253  0.099595
    foo -0.132609 -0.463918 <class 'pandas.core.frame.DataFrame'> 
     Index(['C', 'D'], dtype='object')
                      C         D
    A   B                        
    bar one   -1.272769  1.188977
        three -0.827655 -1.608699
        two   -0.345336  0.718507
    foo one    0.342337 -1.021713
        three -0.431760 -0.123696
        two   -0.457979 -0.076236 <class 'pandas.core.frame.DataFrame'> 
     Index(['C', 'D'], dtype='object')
    A
    bar    0.099595
    foo   -0.463918
    Name: D, dtype: float64 <class 'pandas.core.series.Series'>
    # 分组 - 可迭代对象
    
    df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 4, 3, 2]})
    print(df)
    print(df.groupby('X'), type(df.groupby('X')))
    print('-----')
    
    print(list(df.groupby('X')), '→ 可迭代对象,直接生成list
    ')
    print(list(df.groupby('X'))[0], '→ 以元祖形式显示
    ')
    for n,g in df.groupby('X'):
        print(n)
        print(g)
        print('###')
    print('-----')
    # n是组名,g是分组后的Dataframe
    
    print(df.groupby(['X']).get_group('A'),'
    ')
    print(df.groupby(['X']).get_group('B'),'
    ')
    print('-----')
    # .get_group()提取分组后的组
    
    grouped = df.groupby(['X'])
    print(grouped.groups)
    print(grouped.groups['A'])  # 也可写:df.groupby('X').groups['A']
    print('-----')
    # .groups:将分组后的groups转为dict
    # 可以字典索引方法来查看groups里的元素
    
    sz = grouped.size()
    print(sz,type(sz))
    print('-----')
    # .size():查看分组后的长度
    
    df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
                       'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                       'C' : np.random.randn(8),
                       'D' : np.random.randn(8)})
    grouped = df.groupby(['A','B']).groups
    print(df)
    print(grouped)
    print(grouped[('foo', 'three')])
    # 按照两个列进行分组

      输出:

      X  Y
    0  A  1
    1  B  4
    2  A  3
    3  B  2
    <pandas.core.groupby.DataFrameGroupBy object at 0x00000000091B6F28> <class 'pandas.core.groupby.DataFrameGroupBy'>
    -----
    [('A',    X  Y
    0  A  1
    2  A  3), ('B',    X  Y
    1  B  4
    3  B  2)] → 可迭代对象,直接生成list
    
    ('A',    X  Y
    0  A  1
    2  A  3) → 以元祖形式显示
    
    A
       X  Y
    0  A  1
    2  A  3
    ###
    B
       X  Y
    1  B  4
    3  B  2
    ###
    -----
       X  Y
    0  A  1
    2  A  3 
    
       X  Y
    1  B  4
    3  B  2 
    
    -----
    {'B': [1, 3], 'A': [0, 2]}
    [0, 2]
    -----
    X
    A    2
    B    2
    dtype: int64 <class 'pandas.core.series.Series'>
    -----
         A      B         C         D
    0  foo    one -0.668695  0.247781
    1  bar    one -0.125374  2.259134
    2  foo    two -0.112052  1.618603
    3  bar  three -0.098986  0.150488
    4  foo    two  0.912286 -1.260029
    5  bar    two  1.096757 -0.571223
    6  foo    one -0.090907 -1.671482
    7  foo  three  0.088176 -0.292702
    {('bar', 'two'): [5], ('foo', 'two'): [2, 4], ('bar', 'one'): [1], ('foo', 'three'): [7], ('bar', 'three'): [3], ('foo', 'one'): [0, 6]}
    [7]
    # 其他轴上的分组
    
    df = pd.DataFrame({'data1':np.random.rand(2),
                      'data2':np.random.rand(2),
                      'key1':['a','b'],
                      'key2':['one','two']})
    print(df)
    print(df.dtypes)
    print('-----')
    for n,p in df.groupby(df.dtypes, axis=1):
        print(n)
        print(p)
        print('##')
    # 按照值类型分列

      输出:

          data1     data2 key1 key2
    0  0.454580  0.692637    a  one
    1  0.496928  0.214309    b  two
    data1    float64
    data2    float64
    key1      object
    key2      object
    dtype: object
    -----
    float64
          data1     data2
    0  0.454580  0.692637
    1  0.496928  0.214309
    ##
    object
      key1 key2
    0    a  one
    1    b  two
    ##
    # 通过字典或者Series分组
    
    df = pd.DataFrame(np.arange(16).reshape(4,4),
                      columns = ['a','b','c','d'])
    print(df)
    print('-----')
    
    mapping = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
    by_column = df.groupby(mapping, axis = 1)
    print(by_column.sum())
    print('-----')
    # mapping中,a、b列对应的为one,c、d列对应的为two,以字典来分组
    
    s = pd.Series(mapping)
    print(s,'
    ')
    print(s.groupby(s).count())
    # s中,index中a、b对应的为one,c、d对应的为two,以Series来分组

      输出:

        a   b   c   d
    0   0   1   2   3
    1   4   5   6   7
    2   8   9  10  11
    3  12  13  14  15
    -----
       one  two
    0    1    5
    1    9   13
    2   17   21
    3   25   29
    -----
    a      one
    b      one
    c      two
    d      two
    e    three
    dtype: object 
    
    one      2
    three    1
    two      2
    dtype: int64
    # 通过函数分组
    
    df = pd.DataFrame(np.arange(16).reshape(4,4),
                      columns = ['a','b','c','d'],
                     index = ['abc','bcd','aa','b'])
    print(df,'
    ')
    print(df.groupby(len).sum())
    # 按照字母长度分组

      输出:

         a   b   c   d
    abc   0   1   2   3
    bcd   4   5   6   7
    aa    8   9  10  11
    b    12  13  14  15 
    
        a   b   c   d
    1  12  13  14  15
    2   8   9  10  11
    3   4   6   8  10
    # 分组计算函数方法
    
    s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
    grouped = s.groupby(level=0)  # 唯一索引用.groupby(level=0),将同一个index的分为一组
    print(grouped)
    print(grouped.first(),'→ first:非NaN的第一个值
    ')
    print(grouped.last(),'→ last:非NaN的最后一个值
    ')
    print(grouped.sum(),'→ sum:非NaN的和
    ')
    print(grouped.mean(),'→ mean:非NaN的平均值
    ')
    print(grouped.median(),'→ median:非NaN的算术中位数
    ')
    print(grouped.count(),'→ count:非NaN的值
    ')
    print(grouped.min(),'→ min、max:非NaN的最小值、最大值
    ')
    print(grouped.std(),'→ std,var:非NaN的标准差和方差
    ')
    print(grouped.prod(),'→ prod:非NaN的积
    ')

      输出:

    <pandas.core.groupby.SeriesGroupBy object at 0x00000000091992B0>
    1    1
    2    2
    3    3
    dtype: int64 → first:非NaN的第一个值
    
    1    10
    2    20
    3    30
    dtype: int64 → last:非NaN的最后一个值
    
    1    11
    2    22
    3    33
    dtype: int64 → sum:非NaN的和
    
    1     5.5
    2    11.0
    3    16.5
    dtype: float64 → mean:非NaN的平均值
    
    1     5.5
    2    11.0
    3    16.5
    dtype: float64 → median:非NaN的算术中位数
    
    1    2
    2    2
    3    2
    dtype: int64 → count:非NaN的值
    
    1    1
    2    2
    3    3
    dtype: int64 → min、max:非NaN的最小值、最大值
    
    1     6.363961
    2    12.727922
    3    19.091883
    dtype: float64 → std,var:非NaN的标准差和方差
    
    1    10
    2    40
    3    90
    dtype: int64 → prod:非NaN的积
    # 多函数计算:agg()
    
    df = pd.DataFrame({'a':[1,1,2,2],
                      'b':np.random.rand(4),
                      'c':np.random.rand(4),
                      'd':np.random.rand(4),})
    print(df)
    print(df.groupby('a').agg(['mean',np.sum]))
    print(df.groupby('a')['b'].agg({'result1':np.mean,
                                   'result2':np.sum}))
    # 函数写法可以用str,或者np.方法
    # 可以通过list,dict传入,当用dict时,key名为columns

      输出:

       a         b         c         d
    0  1  0.357911  0.318324  0.627797
    1  1  0.964829  0.500017  0.570063
    2  2  0.116608  0.194164  0.049509
    3  2  0.933123  0.542615  0.718640
              b                   c                   d         
           mean       sum      mean       sum      mean      sum
    a                                                           
    1  0.661370  1.322739  0.409171  0.818341  0.598930  1.19786
    2  0.524865  1.049730  0.368390  0.736780  0.384075  0.76815
        result2   result1
    a                    
    1  1.322739  0.661370
    2  1.049730  0.524865
    '''
    【课程2.20】  分组转换及一般性“拆分-应用-合并”
    
    transform / apply
     
    '''
    # 数据分组转换,transform
    
    df = pd.DataFrame({'data1':np.random.rand(5),
                      'data2':np.random.rand(5),
                      'key1':list('aabba'),
                      'key2':['one','two','one','two','one']})
    k_mean = df.groupby('key1').mean()
    print(df)
    print(k_mean)
    print(pd.merge(df,k_mean,left_on='key1',right_index=True).add_prefix('mean_'))  # .add_prefix('mean_'):添加前缀
    print('-----')
    # 通过分组、合并,得到一个包含均值的Dataframe
    
    print(df.groupby('key2').mean()) # 按照key2分组求均值
    print(df.groupby('key2').transform(np.mean))
    # data1、data2每个位置元素取对应分组列的均值
    # 字符串不能进行计算

      输出:

         data1     data2 key1 key2
    0  0.003727  0.390301    a  one
    1  0.744777  0.130300    a  two
    2  0.887207  0.679309    b  one
    3  0.448585  0.169208    b  two
    4  0.448045  0.993775    a  one
             data1     data2
    key1                    
    a     0.398850  0.504792
    b     0.667896  0.424258
       mean_data1_x  mean_data2_x mean_key1 mean_key2  mean_data1_y  mean_data2_y
    0      0.003727      0.390301         a       one      0.398850      0.504792
    1      0.744777      0.130300         a       two      0.398850      0.504792
    4      0.448045      0.993775         a       one      0.398850      0.504792
    2      0.887207      0.679309         b       one      0.667896      0.424258
    3      0.448585      0.169208         b       two      0.667896      0.424258
    -----
             data1     data2
    key2                    
    one   0.446326  0.687795
    two   0.596681  0.149754
          data1     data2
    0  0.446326  0.687795
    1  0.596681  0.149754
    2  0.446326  0.687795
    3  0.596681  0.149754
    4  0.446326  0.687795
    # 一般化Groupby方法:apply
    
    df = pd.DataFrame({'data1':np.random.rand(5),
                      'data2':np.random.rand(5),
                      'key1':list('aabba'),
                      'key2':['one','two','one','two','one']})
    
    print(df.groupby('key1').apply(lambda x: x.describe()))
    # apply直接运行其中的函数
    # 这里为匿名函数,直接描述分组后的统计量
    
    def f_df1(d,n):
        return(d.sort_index()[:n])
    def f_df2(d,k1):
        return(d[k1])
    print(df.groupby('key1').apply(f_df1,2),'
    ')
    print(df.groupby('key1').apply(f_df2,'data2'))
    print(type(df.groupby('key1').apply(f_df2,'data2')))
    # f_df1函数:返回排序后的前n行数据
    # f_df2函数:返回分组后表的k1列,结果为Series,层次化索引
    # 直接运行f_df函数
    # 参数直接写在后面,也可以为.apply(f_df,n = 2))

      输出:

                   data1     data2
    key1                          
    a    count  3.000000  3.000000
         mean   0.561754  0.233470
         std    0.313439  0.337209
         min    0.325604  0.026906
         25%    0.383953  0.038906
         50%    0.442303  0.050906
         75%    0.679829  0.336753
         max    0.917355  0.622599
    b    count  2.000000  2.000000
         mean   0.881906  0.547206
         std    0.079357  0.254051
         min    0.825791  0.367564
         25%    0.853849  0.457385
         50%    0.881906  0.547206
         75%    0.909963  0.637026
         max    0.938020  0.726847
               data1     data2 key1 key2
    key1                                
    a    0  0.325604  0.050906    a  one
         1  0.917355  0.622599    a  two
    b    2  0.825791  0.726847    b  one
         3  0.938020  0.367564    b  two 
    
    key1   
    a     0    0.050906
          1    0.622599
          4    0.026906
    b     2    0.726847
          3    0.367564
    Name: data2, dtype: float64
    <class 'pandas.core.series.Series'>
    '''
    【课程2.21】  透视表及交叉表
    
    类似excel数据透视 - pivot table / crosstab
     
    '''
    # 透视表:pivot_table
    # pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
    
    date = ['2017-5-1','2017-5-2','2017-5-3']*3
    rng = pd.to_datetime(date)
    df = pd.DataFrame({'date':rng,
                       'key':list('abcdabcda'),
                      'values':np.random.rand(9)*10})
    print(df)
    print('-----')
    
    print(pd.pivot_table(df, values = 'values', index = 'date', columns = 'key', aggfunc=np.sum))  # 也可以写 aggfunc='sum'
    print('-----')
    # data:DataFrame对象
    # values:要聚合的列或列的列表
    # index:数据透视表的index,从原数据的列中筛选
    # columns:数据透视表的columns,从原数据的列中筛选
    # aggfunc:用于聚合的函数,默认为numpy.mean,支持numpy计算方法
    
    print(pd.pivot_table(df, values = 'values', index = ['date','key'], aggfunc=len))
    print('-----')
    # 这里就分别以date、key共同做数据透视,值为values:统计不同(date,key)情况下values的平均值
    # aggfunc=len(或者count):计数

      输出:

            date key    values
    0 2017-05-01   a  5.886424
    1 2017-05-02   b  9.906472
    2 2017-05-03   c  8.617297
    3 2017-05-01   d  8.972318
    4 2017-05-02   a  7.990905
    5 2017-05-03   b  8.131856
    6 2017-05-01   c  2.823731
    7 2017-05-02   d  2.394605
    8 2017-05-03   a  0.667917
    -----
    key                a         b         c         d
    date                                              
    2017-05-01  5.886424       NaN  2.823731  8.972318
    2017-05-02  7.990905  9.906472       NaN  2.394605
    2017-05-03  0.667917  8.131856  8.617297       NaN
    -----
    date        key
    2017-05-01  a      1.0
                c      1.0
                d      1.0
    2017-05-02  a      1.0
                b      1.0
                d      1.0
    2017-05-03  a      1.0
                b      1.0
                c      1.0
    Name: values, dtype: float64
    -----
    # 交叉表:crosstab
    # 默认情况下,crosstab计算因子的频率表,比如用于str的数据透视分析
    # pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)
    
    df = pd.DataFrame({'A': [1, 2, 2, 2, 2],
                       'B': [3, 3, 4, 4, 4],
                       'C': [1, 1, np.nan, 1, 1]})
    print(df)
    print('-----')
    
    print(pd.crosstab(df['A'],df['B']))
    print('-----')
    # 如果crosstab只接收两个Series,它将提供一个频率表。
    # 用A的唯一值,统计B唯一值的出现次数
    
    print(pd.crosstab(df['A'],df['B'],normalize=True))
    print('-----')
    # normalize:默认False,将所有值除以值的总和进行归一化 → 为True时候显示百分比
    
    print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum))
    print('-----')
    # values:可选,根据因子聚合的值数组
    # aggfunc:可选,如果未传递values数组,则计算频率表,如果传递数组,则按照指定计算
    # 这里相当于以A和B界定分组,计算出每组中第三个系列C的值
    
    print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum, margins=True))
    print('-----')
    # margins:布尔值,默认值False,添加行/列边距(小计)

      输出:

       A  B    C
    0  1  3  1.0
    1  2  3  1.0
    2  2  4  NaN
    3  2  4  1.0
    4  2  4  1.0
    -----
    B  3  4
    A      
    1  1  0
    2  1  3
    -----
    B    3    4
    A          
    1  0.2  0.0
    2  0.2  0.6
    -----
    B    3    4
    A          
    1  1.0  NaN
    2  1.0  2.0
    -----
    B      3    4  All
    A                 
    1    1.0  NaN  1.0
    2    1.0  2.0  3.0
    All  2.0  2.0  4.0
    -----
    '''
    【课程2.22】  数据读取
    
    核心:read_table, read_csv, read_excel
     
    '''
    # 读取普通分隔数据:read_table
    # 可以读取txt,csv
    
    import os
    os.chdir('C:/Users/Hjx/Desktop/')
    
    data1 = pd.read_table('data1.txt', delimiter=',',header = 0, index_col=1)
    print(data1)
    # delimiter:用于拆分的字符,也可以用sep:sep = ','
    # header:用做列名的序号,默认为0(第一行)
    # index_col:指定某列为行索引,否则自动索引0, 1, .....
    
    # read_table主要用于读取简单的数据,txt/csv

      输出:

         va1  va3  va4
    va2               
    2      1    3    4
    3      2    4    5
    4      3    5    6
    5      4    6    7
    # 读取csv数据:read_csv
    # 先熟悉一下excel怎么导出csv
    
    data2 = pd.read_csv('data2.csv',engine = 'python')
    print(data2.head())
    # engine:使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。
    # encoding:指定字符集类型,即编码,通常指定为'utf-8'
    
    # 大多数情况先将excel导出csv,再读取

      输出:

       省级政区代码 省级政区名称  地市级政区代码 地市级政区名称    年份 党委书记姓名  出生年份  出生月份  籍贯省份代码 籍贯省份名称  
    0  130000    河北省   130100    石家庄市  2000    陈来立   NaN   NaN     NaN    NaN   
    1  130000    河北省   130100    石家庄市  2001    吴振华   NaN   NaN     NaN    NaN   
    2  130000    河北省   130100    石家庄市  2002    吴振华   NaN   NaN     NaN    NaN   
    3  130000    河北省   130100    石家庄市  2003    吴振华   NaN   NaN     NaN    NaN   
    4  130000    河北省   130100    石家庄市  2004    吴振华   NaN   NaN     NaN    NaN   
    
       ...    民族  教育 是否是党校教育(是=1,否=0) 专业:人文 专业:社科  专业:理工  专业:农科  专业:医科  入党年份  工作年份  
    0  ...   NaN  硕士              1.0   NaN   NaN    NaN    NaN    NaN   NaN   NaN  
    1  ...   NaN  本科              0.0   0.0   0.0    1.0    0.0    0.0   NaN   NaN  
    2  ...   NaN  本科              0.0   0.0   0.0    1.0    0.0    0.0   NaN   NaN  
    3  ...   NaN  本科              0.0   0.0   0.0    1.0    0.0    0.0   NaN   NaN  
    4  ...   NaN  本科              0.0   0.0   0.0    1.0    0.0    0.0   NaN   NaN  
    
    [5 rows x 23 columns]
    # 读取excel数据:read_excel
    
    data3 = pd.read_excel('地市级党委书记数据库(2000-10).xlsx',sheetname='中国人民共和国地市级党委书记数据库(2000-10)',header=0)
    print(data3)
    # io :文件路径。
    # sheetname:返回多表使用sheetname=[0,1],若sheetname=None是返回全表 → ① int/string 返回的是dataframe ②而none和list返回的是dict
    # header:指定列名行,默认0,即取第一行
    # index_col:指定列为索引列,也可以使用u”strings”

      输出:

          省级政区代码    省级政区名称  地市级政区代码   地市级政区名称    年份 党委书记姓名  出生年份  出生月份  籍贯省份代码  
    0     130000       河北省   130100      石家庄市  2000    陈来立   NaN   NaN     NaN   
    1     130000       河北省   130100      石家庄市  2001    吴振华   NaN   NaN     NaN   
    2     130000       河北省   130100      石家庄市  2002    吴振华   NaN   NaN     NaN   
    3     130000       河北省   130100      石家庄市  2003    吴振华   NaN   NaN     NaN   
    4     130000       河北省   130100      石家庄市  2004    吴振华   NaN   NaN     NaN   
    5     130000       河北省   130100      石家庄市  2005    吴振华   NaN   NaN     NaN   
    6     130000       河北省   130100      石家庄市  2006    吴振华   NaN   NaN     NaN   
    7     130000       河北省   130100      石家庄市  2007    吴显国   NaN   NaN     NaN   
    8     130000       河北省   130100      石家庄市  2008    吴显国   NaN   NaN     NaN   
    9     130000       河北省   130100      石家庄市  2009     车俊   NaN   NaN     NaN   
    10    130000       河北省   130100      石家庄市  2010    孙瑞彬   NaN   NaN     NaN   
    11    130000       河北省   130200       唐山市  2000    白润璋   NaN   NaN     NaN 
  • 相关阅读:
    解决SSH窗口关闭,linux上的应用也关闭
    Spring 自定义配置类bean
    java 图片文字识别 ocr
    解决Oracle在Linux下Listener起不来,error 111错误
    java 切图 判断图片是否是纯色/彩色图片
    java 二维码编码解码
    字符串整体大小写转换,首字母大小写
    oracle 解锁表的一个小问题
    mysql-如何完全删除主从同步
    oracle RAC ONLINE INTERMEDIATE shdb1 Stuck Archiver
  • 原文地址:https://www.cnblogs.com/654321cc/p/9351806.html
Copyright © 2020-2023  润新知