>>> import numpy as np

>>> import pandas as pd

>>> df = pd.DataFrame({'key1':[4,5,3,np.nan,2],  # np.nan ：空值 

... 'key2':[1,2,np.nan,4,5],

... 'key3':[1,2,3,'j','k']}, #字符串

... index = ['a','b','c','d','e'])

>>> print(df)

   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

>>> print(df['key1'].dtype, df['key2'].dtype, df['key3'].dtype)

float64 float64 object  (object是python的对象)

>>> print(df.mean(),type(df.mean))  #.mean()计算均值（默认按列），只统计数字列 ，key3为object对象不统计。

　key1 3.5
　key2 3.0
　dtype: float64  <class 'pandas.core.series.Series'>

　>>>

>>> print('单独统计一列:',df['key2'].mean())  # .mean()计算均值  # 可以通过索引单独统计一列；

单独统计一列: 3.0

>>>

>>> m2 = df.mean(axis=1)  # 只统计数字列   #axis参数：默认为0，以列来计算， axis=1，以行来计算，这里就按照行来汇总了，也是只统计数字那行

>>> print(m2)

a    2.5

b    3.5

c    3.0

d    4.0

e    3.5

dtype: float64

>>>

　>>> print(df.mean(axis=1, skipna=False)) #以行来算；  skipna参数是是否忽略NaN，默认True忽略结果同上；False是有NaN的行，就直接显示NaN了不忽略它。
　a 2.5
　b 3.5
　c NaN
　d NaN
　e 3.5
　dtype: float64
>>>

>>> m3 = df.mean(skipna=False) #按列来算 >>> print(m3)

key1   NaN

key2   NaN

dtype: float64

>>>

>>> df = pd.DataFrame({'key1':np.arange(10),

...                   'key2':np.random.rand(10)*10})

>>> print(df)

    key1      key2

0     0  7.556713

1     1  8.650398

2     2  4.692490

3     3  0.275988

4     4  2.710686

5     5  5.130423

6     6  3.638846

7     7  2.989476

8     8  7.105496

9     9  0.907657

>>> print(df.count(),'→ count统计非Na值的数量\n')

key1    10

key2    10

dtype: int64 → count统计非Na值的数量

>>> print(df.min(),'→ min统计最小值\n',df['key2'].max(),'→ max统计最大值\n')

key1    0.000000

key2    0.275988

dtype: float64 → min统计最小值

 8.650397903041455 → max统计最大值

>>> print(df.quantile(q=0.75),'→ quantile统计分位数，参数q确定位置\n') #q=0.75，分位数就是总共数的3/4位置的那个数

key1    6.750000

key2    6.611727

Name: 0.75, dtype: float64 → quantile统计分位数，参数q确定位置

>>> print(df.sum(),'→ sum求和\n')

key1    45.000000

key2    43.658172

dtype: float64 → sum求和

>>> print(df.mean(),'→ mean求平均值\n')

key1    4.500000

key2    4.365817

dtype: float64 → mean求平均值

>>> print(df.median(),'→ median求算数中位数，50%分位数\n')

key1    4.500000

key2    4.165668

dtype: float64 → median求算数中位数，50%分位数

>>> print(df.std(),'\n',df.var(),'→ std,var分别求标准差，方差\n')

key1    3.027650

key2    2.800485

dtype: float64

 key1    9.166667

key2    7.842718

dtype: float64 → std,var分别求标准差，方差

>>> print(df.skew(),'→ skew样本的偏度\n')  #偏度和峰度是用来进行一致性检验的。

key1    0.000000

key2    0.094214

dtype: float64 → skew样本的偏度

>>> print(df.kurt(),'→ kurt样本的峰度\n')

key1   -1.200000

key2   -1.033864

dtype: float64 → kurt样本的峰度

>>>

>>> df['key1_s'] = df['key1'].cumsum() #样本的累计和，默认列。下面这4个赋值，给df添加了4个字段。

>>> df['key2_s'] = df['key2'].cumsum()

>>> print(df,'→ cumsum样本的累计和\n')

    key1    key2     key1_s   key2_s

0     0  7.556713         7.556713

1     1  8.650398         16.207111

2     2  4.692490        20.899601

3     3  0.275988         21.175589

4     4  2.710686      10  23.886275

5     5  5.130423       29.016698

6     6  3.638846       32.655544

7     7  2.989476        35.645019

8     8  7.105496       42.750515

9     9  0.907657       43.658172 → cumsum样本的累计和

>>> df['key1_p'] = df['key1'].cumprod() #样本的累计积，默认列

>>> df['key2_p'] = df['key2'].cumprod()

>>> print(df,'→ cumprod样本的累计积\n')

    key1   key2     key1_s     key2_s  key1_p        key2_p

0     0  7.556713       0   7.556713       0      7.556713

1     1  8.650398       1  16.207111       0     65.368572

2     2  4.692490       3  20.899601       0    306.741386

3     3  0.275988       6  21.175589       0     84.656944

4     4  2.710686      10  23.886275       0    229.478404

5     5  5.130423      15  29.016698       0   1177.321217

6     6  3.638846      21  32.655544       0   4284.090351

7     7  2.989476      28  35.645019       0  12807.184945

8     8  7.105496      36  42.750515       0  91001.397399

9     9  0.907657      45  43.658172       0  82598.051142 → cumprod样本的累计积

>>> print(df.cummax(),'\n',df.cummin(),'→ cummax,cummin分别求累计最大值，累计最小值\n') #累计最大值和最小值会直接填充之前的key1、key2

   key1      key2  key1_s     key2_s  key1_p        key2_p

0   0.0  7.556713     0.0   7.556713     0.0      7.556713

1   1.0  8.650398     1.0  16.207111     0.0     65.368572

2   2.0  8.650398     3.0  20.899601     0.0    306.741386

3   3.0  8.650398     6.0  21.175589     0.0    306.741386

4   4.0  8.650398    10.0  23.886275     0.0    306.741386

5   5.0  8.650398    15.0  29.016698     0.0   1177.321217

6   6.0  8.650398    21.0  32.655544     0.0   4284.090351

7   7.0  8.650398    28.0  35.645019     0.0  12807.184945

8   8.0  8.650398    36.0  42.750515     0.0  91001.397399

9   9.0  8.650398    45.0  43.658172     0.0  91001.397399

    key1      key2  key1_s    key2_s  key1_p    key2_p

0   0.0  7.556713     0.0  7.556713     0.0  7.556713

1   0.0  7.556713     0.0  7.556713     0.0  7.556713

2   0.0  4.692490     0.0  7.556713     0.0  7.556713

3   0.0  0.275988     0.0  7.556713     0.0  7.556713  #出现最小值了就一直累计那个最小值

4   0.0  0.275988     0.0  7.556713     0.0  7.556713

5   0.0  0.275988     0.0  7.556713     0.0  7.556713

6   0.0  0.275988     0.0  7.556713     0.0  7.556713

7   0.0  0.275988     0.0  7.556713     0.0  7.556713

8   0.0  0.275988     0.0  7.556713     0.0  7.556713

9   0.0  0.275988     0.0  7.556713     0.0  7.556713 → cummax,cummin分别求累计最大值，累计最小值

>>>

>>> s = pd.Series(list('asdvasdcfgg'))

>>> sq = s.unique() #得到一个只有唯一数值的数组，没有重复值了

>>> print(s)

0     a

1     s

2     d

3     v

4     a

5     s

6     d

7     c

8     f

9     g

10    g

dtype: object

>>> print(sq,type(sq))

['a' 's' 'd' 'v' 'c' 'f' 'g'] <class 'numpy.ndarray'>

>>> print(pd.Series(sq))  # 通过pd.Series重新变成新的Series

0    a

1    s

2    d

3    v

4    c

5    f

6    g

dtype: object

>>> sq.sort()

>>> print(sq)

['a' 'c' 'd' 'f' 'g' 's' 'v']

>>>

>>> sc = s.value_counts(sort = False)  # 也可以这样写：pd.value_counts(sc, sort = False)

>>> print(sc)  # 得到一个新的Series，计算出不同值出现的频率； # sort参数：排序，默认为True降序，False是不排序。

s    2

d    2

v    1

f    1

c    1

g    2

a    2

dtype: int64

>>>

>>> s = pd.Series(np.arange(10,15))

>>> df = pd.DataFrame({'key1':list('asdcbvasd'),

...                   'key2':np.arange(4,13)})

>>> print(s)

0    10

1    11

2    12

3    13

4    14

dtype: int32

>>> print(df)

  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

>>> print('-----')

-----

>>>

>>> print(s.isin([5,14]))

0    False

1    False

2    False

3    False

4     True

dtype: bool

>>> print(df.isin(['a','bc','',8]))

    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

>>>

>>> s = pd.Series(['A','b','C','bbhello','',np.nan,'hj'])

>>> df = pd.DataFrame({'key1':list('abcdef'),

...                   'key2':['hee','fv','w','hija','',np.nan]})

>>> print(s)

          A

          b

          C

    bbhello

        NaN

         hj

dtype: object

>>> print(df)

  key1  key2

    a   hee

    b    fv

    c     w

    d  hija

    e

    f   NaN

>>>

>>> print(s.str.count('b'))  # 直接通过.str调用字符串方法 # 可以对Series、Dataframe使用 # 自动过滤NaN值

    0.0

    1.0

    0.0

    2.0

    0.0

    NaN

    0.0

dtype: float64

>>> print(df['key2'].str.upper())

     HEE

      FV

       W

    HIJA

     NaN

Name: key2, dtype: object

>>>

>>> df.columns = df.columns.str.upper()  # df.columns是一个Index对象，也可使用.str

>>> print(df)

  KEY1  KEY2

    a   hee

    b    fv

    c     w

    d  hija

    e

    f   NaN

>>>

########字符串常用方法（一）
>>> s = pd.Series(['A','b','C','bbhello','',np.nan,'hj'])

>>> df = pd.DataFrame({'key1':list('abcdef'),

...                   'key2':['hee','fv','w','hija','',np.nan]})

>>> print(s)

0          A

1          b

2          C

3    bbhello

4        123

5        NaN

6         hj

dtype: object

>>> print(df)

  key1  key2

0    a   hee

1    b    fv

2    c     w

3    d  hija

4    e   123

5    f   NaN

>>>

>>> print(s.str.count('b'))

0    0.0

1    1.0

2    0.0

3    2.0

4    0.0

5    NaN

6    0.0

dtype: float64

>>> print(df['key2'].str.upper())

0     HEE

1      FV

2       W

3    HIJA

4     123

5     NaN

Name: key2, dtype: object

>>>

>>> df.columns = df.columns.str.upper()

>>> print(df)

  KEY1  KEY2

0    a   hee

1    b    fv

2    c     w

3    d  hija

4    e   123

5    f   NaN

>>>

>>>

>>>

>>>

>>>

>>> s = pd.Series(['A','b','bbhello','',np.nan])

>>> print(s.str.lower(),'→ lower小写\n')

0          a

1          b

2    bbhello

3        123

4        NaN

dtype: object → lower小写

>>> print(s.str.upper(),'→ lower大写\n')

0          A

1          B

2    BBHELLO

3        123

4        NaN

dtype: object → lower大写

>>> print(s.str.len(),'→ len字符长度\n')

0    1.0

1    1.0

2    7.0

3    3.0

4    NaN

dtype: float64 → len字符长度

>>> print(s.str.startswith('b'),'→ 判断起始是否为a\n')

0    False

1     True

2     True

3    False

4      NaN

dtype: object → 判断起始是否为a

>>> print(s.str.endswith(''),'→ 判断结束是否为3\n')

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)

0       jack

1      jill

2     jesse

3      frank

dtype: object

>>> print(df)

    Column A    Column B

0    1.134152    1.030622

1   -0.509581   -0.102576

2    1.033234   -1.170396

>>>

>>> print(s.str.strip())  # 去除字符串中的空格

0     jack

1     jill

2    jesse

3    frank

dtype: object

>>> print(s.str.lstrip())    # 去除字符串中的左空格

0      jack

1     jill

2    jesse

3     frank

dtype: object

>>> print(s.str.rstrip())  # 去除字符串中的右空格

0      jack

1      jill

2     jesse

3     frank

dtype: object

>>> df.columns = df.columns.str.strip()  # 这里去掉了columns的前后空格，但没有去掉中间空格

>>> print(df)

   Column A  Column B

0  1.134152  1.030622

1 -0.509581 -0.102576

2  1.033234 -1.170396

>>>

>>>

>>># 字符串常用方法（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)

   -Column-A-  -Column-B-

0   -0.721763    0.899423

1    1.129852    0.893515

2   -1.715414   -1.465260

>>>

>>> df.columns = df.columns.str.replace('-','hehe',n=1)

>>> print(df)

   heheColumn-A-  heheColumn-B-

0      -0.721763       0.899423

1       1.129852       0.893515

2      -1.715414      -1.465260

>>>

>>>

>>># 字符串常用方法（4） - split、rsplit

>>> s = pd.Series(['a,b,c','1,2,3',['a,,,c'],np.nan])

>>> print(s.str.split(','))    # 类似字符串的split

0    [a, b, c]

1    [1, 2, 3]

2          NaN

3          NaN

dtype: object

>>> print(s.str.split(',')[0])  ## 直接索引得到一个list

['a', 'b', 'c']

>>>

>>> print(s.str.split(',').str[0])

0      a

1      1

2    NaN

3    NaN

dtype: object

>>> print(s.str.split(',').str.get(1))  # 可以使用get或[]符号访问拆分列表中的元素

0      b

1      2

2    NaN

3    NaN

dtype: object

>>>

>>> print(s.str.split(',',expand=True)) # 可以使用expand可以轻松扩展此操作以返回DataFrame；expand默认为False 

     0    1    2

0    a    b    c

1    1    2    3

2  NaN  NaN  NaN

3  NaN  NaN  NaN

>>> print(s.str.split(',',expand=True,n=1)) # n参数限制分割数  

     0    1

0    a  b,c

1    1  2,3

2  NaN  NaN

3  NaN  NaN

>>> print(s.str.rsplit(',',expand=True,n=1)) # rsplit类似于split，反向工作，即从字符串的末尾到字符串的开头

     0    1

0  a,b    c

1  1,2    3

2  NaN  NaN

3  NaN  NaN

>>>

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

Name: key2, dtype: object

>>>

>>> s = pd.Series(['A','b','C','bbhello','',np.nan,'hj'])

>>> df = pd.DataFrame({'key1':list('abcdef'),

...                   'key2':['hee','fv','w','hija','',np.nan]})

>>> print(s)

0          A

1          b

2          C

3    bbhello

4        123

5        NaN

6         hj

dtype: object

>>> print(df)

  key1  key2

0    a   hee

1    b    fv

2    c     w

3    d  hija

4    e   123

5    f   NaN

>>> print(s.str[0])  # 取第一个字符串

0      A

1      b

2      C

3      b

4      1

5    NaN

6      h

dtype: object

>>> print(s.str[:2]) # 取前两个字符串

0      A

1      b

2      C

3     bb

4     12

5    NaN

6     hj

dtype: object

>>> print(df['key2'].str[0])  # str之后和字符串本身索引方式相同

0      h

1      f

2      w

3      h

4      1

5    NaN

Name: key2, dtype: object

>>>

>>> 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(df1)

  key   A   B

0  K0  A0  B0

1  K1  A1  B1

2  K2  A2  B2

3  K3  A3  B3

>>> print(df2)

  key   C   D

0  K0  C0  D0

1  K1  C1  D1

2  K2  C2  D2

3  K3  C3  D3

>>>

>>> print(pd.merge(df1, df2, on='key'))  　　# left：第一个df; #right：第二个df  #on：参考键；

  key   A   B   C   D

0  K0  A0  B0  C0  D0

1  K1  A1  B1  C1  D1

2  K2  A2  B2  C2  D2

3  K3  A3  B3  C3  D3

>>> print(df3)

  key1 key2   A   B

0   K0   K0  A0  B0

1   K0   K1  A1  B1

2   K1   K0  A2  B2

3   K2   K1  A3  B3

>>> print(df4)

  key1 key2   C   D

0   K0   K0  C0  D0

1   K1   K0  C1  D1

2   K1   K0  C2  D2

3   K2   K0  C3  D3

>>> print(pd.merge(df3, df4, on=['key1','key2']))  # 多个链接键，on是以什么作为参考，必须是基于一个参数的；多个键的连接-值必须是一样的

  key1 key2   A   B   C   D                        #key1=k0,key2=k0看看有没有 -->有, 再看key1=k0，key2=k1有没有 -->没有......

0   K0   K0  A0  B0  C0  D0

1   K1   K0  A2  B2  C1  D1

2   K1   K0  A2  B2  C2  D2

>>>

　>>> pd.merge(df3,df4,on=['key1']) #on以key1为参考值
　　key1 key2_x A B key2_y C D
　0 K0  K0 　  A0 B0  K0  C0 D0  
　1 K0  K1 　  A1 B1  K0  C0 D0  #值可以重复
　2 K1  K0 　  A2 B2  K0  C1 D1
　3 K1  K0 　  A2 B2  K0  C2 D2
　4 K2  K1 　  A3 B3  K0  C3 D3

>>> print(pd.merge(df3,df4,on=['key1','key2'],how='inner'))  #inner：默认，取交集 ，可不写

  key1 key2   A   B   C   D

0   K0   K0  A0  B0  C0  D0

1   K1   K0  A2  B2  C1  D1

2   K1   K0  A2  B2  C2  D2

>>> print(pd.merge(df3,df4,on=['key1','key2'],how='outer'))  # outer：取并集，全部都包含上了；数据缺失范围用NaN填充

  key1 key2    A    B    C    D

0   K0   K0   A0   B0   C0   D0

1   K0   K1   A1   B1  NaN  NaN

2   K1   K0   A2   B2   C1   D1

3   K1   K0   A2   B2   C2   D2

4   K2   K1   A3   B3  NaN  NaN

5   K2   K0  NaN  NaN   C3   D3

>>> print(pd.merge(df3,df4,on=['key1','key2'],how='left')) # left：按照df3为参考合并，数据缺失范围NaN

  key1 key2   A   B    C    D

0   K0   K0  A0  B0   C0   D0

1   K0   K1  A1  B1  NaN  NaN

2   K1   K0  A2  B2   C1   D1

3   K1   K0  A2  B2   C2   D2

4   K2   K1  A3  B3  NaN  NaN

>>> print(pd.merge(df3,df4,on=['key1','key2'],how='right')) # right：按照df4为参考合并，数据缺失范围NaN

  key1 key2    A    B   C   D

0   K0   K0   A0   B0  C0  D0

1   K1   K0   A2   B2  C1  D1

2   K1   K0   A2   B2  C2  D2

3   K2   K0  NaN  NaN  C3  D3

>>>

>>> df1 = pd.DataFrame({'lkey':list('bbacaab'),

...                    'data1':range(7)})

>>> df2 = pd.DataFrame({'rkey':list('abd'), #lkey，rkey他们两个的名字不一样。 left_on是左边的的DataFrame用这个键，右边的DataFrame用那个键

...                    'date2':range(3)})   #只是个指向问题，相同就用on就可以了

>>> print(df1)

  lkey  data1

0    b      0

1    b      1

2    a      2

3    c      3

4    a      4

5    a      5

6    b      6

>>> print(df2)

  rkey  date2

0    a      0

1    b      1

2    d      2

>>>

>>> print(pd.merge(df1,df2,left_on='lkey',right_on='rkey')) # df1以‘lkey’为键，df2以‘rkey’为键； df1里边所有与df2相同的。

  lkey  data1 rkey  date2                                  #两个key键不一样时，一个是lkey、一个是rkey---> left_on是左边的df1用lkey作为键，righ_on是右边的df2用rkey作为键。

0    b      0    b      1

1    b      1    b      1

2    b      6    b      1

3    a      2    a      0

4    a      4    a      0

5    a      5    a      0

>>> df1 = pd.DataFrame({'key':list('abcdfeg'),    # df1以‘key’为键，df2以index为键  

...                    'data1':range(7)})

>>> df2 = pd.DataFrame({'date2':range(100,105)},

...                   index = list('abcde'))

>>> print(df1)

  key  data1

0   a      0

1   b      1

2   c      2

3   d      3

4   f      4

5   e      5

6   g      6

>>> print(df2)

   date2

a    100

b    101

c    102

d    103

e    104

>>> print(pd.merge(df1, df2, left_on='key', right_index=True))#left_index：为True时，第一个df以index为键，默认False; right_index：为True时，第二个df以index为键，默认False

  key  data1  date2

0   a      0    100

1   b      1    101

2   c      2    102

3   d      3    103

5   e      5    104

>>>

>>> 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(pd.merge(df1,df2,on='key',how='outer'))

  key  data1  date2

0   b    1.0    2.0

1   b    3.0    2.0

2   b    7.0    2.0

3   a    2.0   11.0

4   a    5.0   11.0

5   a    9.0   11.0

6   c    4.0    NaN

7   d    NaN   33.0

>>> print(pd.merge(df1,df2,on='key',sort=True,how='outer')) # sort：按照字典顺序通过 连接键 对结果DataFrame进行排序。默认为False，设置为False会大幅提高性能

  key  data1  date2

0   a    2.0   11.0

1   a    5.0   11.0

2   a    9.0   11.0

3   b    1.0    2.0

4   b    3.0    2.0

5   b    7.0    2.0

6   c    4.0    NaN

7   d    NaN   33.0

>>> x2 = pd.merge(df1,df2,on='key',sort=True,how='outer')

>>> print(x2.sort_values('data1')) #sort_values('指定某列排序')   # 也可直接用Dataframe的排序方法：sort_values，sort_index

  key  data1  date2

3   b    1.0    2.0

0   a    2.0   11.0

4   b    3.0    2.0

6   c    4.0    NaN

1   a    5.0   11.0

5   b    7.0    2.0

2   a    9.0   11.0

7   d    NaN   33.0

>>>

　>>> x2.sort_index()
　　　key data1 date2
　0   a   2.0  11.0
　1   a   5.0  11.0
　2   a   9.0  11.0
　3   b   1.0  2.0
　4   b   3.0  2.0
　5   b   7.0  2.0
　6   c   4.0  NaN
　7   d   NaN  33.0

>>> 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)

     A   B

K0  A0  B0

K1  A1  B1

K2  A2  B2

>>> print(right)

     C   D

K0  C0  D0

K2  C2  D2

K3  C3  D3

>>> print(left.join(right)) #它不是how='inner',而是默认how='left'

     A   B    C    D

K0  A0  B0   C0   D0

K1  A1  B1  NaN  NaN

K2  A2  B2   C2   D2

>>> print(left.join(right,how='outer'))  # 等价于：pd.merge(left, right, left_index=True, right_index=True, how='outer')

      A    B    C    D

K0   A0   B0   C0   D0

K1   A1   B1  NaN  NaN

K2   A2   B2   C2   D2

K3  NaN  NaN   C3   D3

>>>

>>> 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)

  key  data1

0   b      1

1   b      3

2   a      2

3   c      4

4   a      5

5   a      9

6   b      7

>>> print(df2)

  key  date2

0   a     11

1   b      2

2   d     33

>>> print(pd.merge(df1,df2,left_index=True,right_index=True,suffixes=('_1','_2'))) #为了区分两个相同的key，合并之后就给它区分了

  key_1  data1 key_2  date2                                                        #不加，就是默认为key_x , key_y 即suffixes=('_x','_y')默认哦

0     b      1     a     11

1     b      3     b      2

2     a      2     d     33

>>> print(df1.join(df2['date2']))

  key  data1  date2

0   b      1   11.0

1   b      3    2.0

2   a      2   33.0

3   c      4    NaN

4   a      5    NaN

5   a      9    NaN

6   b      7    NaN

>>>

>>> 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)

    A   B key

0  A0  B0  K0

1  A1  B1  K1

2  A2  B2  K0

3  A3  B3  K1

>>> print(right)

     C   D

K0  C0  D0

K1  C1  D1

>>> 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 key   C   D     #这里是left的key，不是right的；left按key，right按index。

0  A0  B0  K0  C0  D0

1  A1  B1  K1  C1  D1

2  A2  B2  K0  C0  D0

3  A3  B3  K1  C1  D1

>>>

>>> left.join(right) 
　 　A　B key C   D
　0 A0 B0 K0 NaN NaN
　1 A1 B1 K1 NaN NaN
　2 A2 B2 K0 NaN NaN
　3 A3 B3 K1 NaN NaN
>>>

>>> 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(s1)

0    1

1    2

2    3

dtype: int64

>>> print(s2)

0    2

1    3

2    4

dtype: int64

>>> print(s3)

a    1

c    2

h    3

dtype: int64

>>> print(s4)

b    2

e    3

d    4

dtype: int64

>>> print(pd.concat([s1,s2])) #行与行的拼接呗

0    1

1    2

2    3

0    2

1    3

2    4

dtype: int64

>>> print(pd.concat([s3,s4]).sort_index()) # 默认axis=0，行 拼 行

a    1

b    2

c    2

d    4

e    3

h    3

dtype: int64

>>>

>>> print(pd.concat([s3,s4], axis=1)) # axis=1,列+列，成为一个Dataframe

     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

>>>

>>> s5 = pd.Series([1,2,3],index = ['a','b','c'])

>>> s6 = pd.Series([2,3,4],index = ['b','c','d'])

>>> print(s5)

a    1

b    2

c    3

dtype: int64

>>> print(pd.concat([s5,s6],axis=1))

     0    1

a  1.0  NaN

b  2.0  2.0

c  3.0  3.0

d  NaN  4.0

>>> print(pd.concat([s5,s6],axis=1,join='inner')) # join：{'inner'，'outer'}，默认为“outer”并集。如何处理其他轴上的索引。  outer为联合，inner为交集。

   0  1                            #就是把NaN的值行给去掉啊，保留都有值的行

b  2  2

c  3  3

>>> print(pd.concat([s5,s6],axis=1,join_axes=[['a','b','d']])) # join_axes：指定联合的index，只显示a b d轴

     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))　　# keys：序列，默认值无。使用传递的键作为最外层构建层次索引

one  a    1

     b    2

     c    3

two  b    2

     c    3

     d    4

dtype: int64 <class 'pandas.core.series.Series'>

>>> print(sre.index)

MultiIndex(levels=[['one', 'two'], ['a', 'b', 'c', 'd']],

           labels=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 1, 2, 3]])

>>> sre = pd.concat([s5,s6], axis=1, keys = ['one','two'])   # axis = 1, 覆盖列名

>>> print(sre,type(sre))

   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'>

>>>

>>> 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)

     0    1    2

0  NaN  3.0  5.0

1 -4.6  NaN  NaN

2  NaN  7.0  NaN

>>> print(df2)

      0    1    2

1 -42.6  NaN -8.2

2  -5.0  1.6  4.0

>>> print(df1.combine_first(df2))  # 根据index，df1的空值被df2替代； # 如果df2的index多于df1，则更新到df1上，比如index=['a',1]

     0    1    2

0  NaN  3.0  5.0

1 -4.6  NaN -8.2

2 -5.0  7.0  4.0

>>>

　>>> df1.update(df2)  # update，直接df2覆盖df1，相同index位置
　>>> print(df1)
　0 1 2
　0 NaN 3.0 5.0
　1 -42.6 NaN -8.2
　2 -5.0 1.6 4.0
　>>>

>>> s = pd.Series([1,1,1,1,2,2,2,3,4,5,5,5,5])

>>> print(s)

0     1

1     1

2     1

3     1

4     2

5     2

6     2

7     3

8     4

9     5

10    5

11    5

12    5

dtype: int64

>>> print(s.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

>>> print(s[s.duplicated() == False]) # 通过布尔判断，得到不重复的值

0    1

4    2

7    3

8    4

9    5

dtype: int64

>>>

>>> s_re = s.drop_duplicates()  # drop.duplicates移除重复

>>> print(s_re)                 # inplace参数：是否替换原值，默认False

0    1

4    2

7    3

8    4

9    5

dtype: int64

>>>

>>> df = pd.DataFrame({'key1':['a','a',3,4,5],

...                   'key2':['a','a','b','b','c']})

>>> print(df.duplicated())

0    False

1     True

2    False

3    False

4    False

dtype: bool

>>> print(df['key2'].duplicated())  # Dataframe中使用duplicated

0    False

1     True

2    False

3     True

4    False

Name: key2, dtype: bool

>>> s = pd.Series(list('ascaazsd'))

>>> print(s.replace('a', np.nan))  # 可一次性替换一个值或多个值

0    NaN

1      s

2      c

3    NaN

4    NaN

5      z

6      s

7      d

dtype: object

>>> print(s.replace(['a','s'] ,np.nan))

0    NaN

1    NaN

2      c

3    NaN

4    NaN

5      z

6    NaN

7      d

dtype: object

>>> print(s.replace({'a':'hello world!','s':123})) # 可传入列表或字典

0    hello world!

1             123

2               c

3    hello world!

4    hello world!

5               z

6             123

7               d

dtype: object

>>>

>>> 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)

     A      B         C         D

0  foo    one -0.362058 -1.232524

1  bar    one  1.038853 -1.261056

2  foo    two  1.240874  0.120504

3  bar  three  0.579106 -0.695712

4  foo    two -0.107265  0.149843

5  bar    two -0.015046 -1.024002

6  foo    one  1.907054 -2.116334

7  foo  three -0.826077 -0.959509

>>>

>>> print(df.groupby('A'),type(df.groupby('A')))   # 直接分组得到一个groupby对象，是一个中间数据，没有进行计算

<pandas.core.groupby.groupby.DataFrameGroupBy object at 0x000000000B2EA748> <class 'pandas.core.groupby.groupby.DataFrameGroupBy'>

>>>

>>> a = df.groupby('A').mean()>>> print(a,type(a),'\n',a.columns)

            C         D

A

bar  0.534304 -0.993590

foo  0.370506 -0.807604 <class 'pandas.core.frame.DataFrame'>

 Index(['C', 'D'], dtype='object')

>>> b = df.groupby(['A','B']).mean()

>>> print(b,type(b),'\n',b.columns)

                  C         D

A   B

bar one    1.038853 -1.261056

    three  0.579106 -0.695712

    two   -0.015046 -1.024002

foo one    0.772498 -1.674429

    three -0.826077 -0.959509

    two    0.566804  0.135173 <class 'pandas.core.frame.DataFrame'>

 Index(['C', 'D'], dtype='object')

>>> c = df.groupby(['A'])['D'].mean() #以A分组，算D的平均值。

>>> print(c,type(c))

A

bar   -0.993590

foo   -0.807604

Name: D, dtype: float64 <class 'pandas.core.series.Series'>

>>>

>>> df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 4, 3, 2]})

>>> print(df)

   X  Y

0  A  1

1  B  4

2  A  3

3  B  2

>>> print(df.groupby('X'), type(df.groupby('X')))

<pandas.core.groupby.groupby.DataFrameGroupBy object at 0x000000000B2D2E48> <class 'pandas.core.groupby.groupby.DataFrameGroupBy'>

>>> print(list(df.groupby('X')), '→ 可迭代对象，直接生成list\n')

[('A',    X  Y  #'A'后边就是一个dataframe

0  A  1

2  A  3), ('B',    X  Y

1  B  4

3  B  2)] → 可迭代对象，直接生成list

>>> print(list(df.groupby('X'))[0], '→ 以元祖形式显示\n')

('A',    X  Y

0  A  1

2  A  3) → 以元祖形式显示

>>>for n,g in df.groupby('X'):   # n是组名，g是分组后的Dataframe

...    print(n)

...    print('###')

...    print(g)

A

   X  Y

0  A  1

2  A  3

###

B

   X  Y

1  B  4

3  B  2

>>> print(df.groupby(['X']).get_group('A'),'\n')

   X  Y

0  A  1

2  A  3

>>> print(df.groupby(['X']).get_group('B'),'\n')   # .get_group()提取分组后的组

   X  Y

1  B  4

3  B  2

>>> grouped = df.groupby(['X'])>>> print(grouped.groups)          # .groups：将分组后的groups转为dict

{'A': Int64Index([0, 2], dtype='int64'), 'B': Int64Index([1, 3], dtype='int64')}

>>> print(grouped.groups['A'])   # 也可写：df.groupby('X').groups['A']             # 可以字典索引方法来查看groups里的元素

Int64Index([0, 2], dtype='int64')

>>>

>>> sz = grouped.size()    # .size()：查看分组后的长度

>>> print(sz,type(sz))

X

A    2

B    2

dtype: int64 <class 'pandas.core.series.Series'>

>>>

>>> 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)})

>>> df

     A      B         C         D

0  foo    one -0.742833 -0.459537

1  bar    one  1.584006  0.834005

2  foo    two -0.021436  0.711519

3  bar  three  0.104556  0.693898

4  foo    two  0.358998  1.870570

5  bar    two  1.626876  0.526132

6  foo    one  0.716151 -0.414307

7  foo  three -2.315347 -0.258841

>>> df.groupby(['A','B']).groups   #按照两个列进行分组，转化为字典；

{('bar', 'one'): Int64Index([1], dtype='int64'), ('bar', 'three'): Int64Index([3], dtype='int64'), ('bar', 'two'): Int64Index([5], dtype='int64'), ('foo', 'one'): Int64Index([0, 6], dtype='int64'), ('

foo', 'three'): Int64Index([7], dtype='int64'), ('foo', 'two'): Int64Index([2, 4], dtype='int64')}

>>> df.groupby(['A','B']).groups[('foo','three')] #查看它的结构；

Int64Index([7], dtype='int64')

>>> df.groupby(['A','B']).get_group(('foo','three')) #查看它的分组

     A      B         C         D

7  foo  three -2.315347 -0.258841

>>> df.groupby(['A','B']).get_group(('foo','one'))

     A    B         C         D

0  foo  one -0.742833 -0.459537

6  foo  one  0.716151 -0.414307

>>>

>>> df = pd.DataFrame({'data1':np.random.rand(2),

...                   'data2':np.random.rand(2),

...                   'key1':['a','b'],

...                   'key2':['one','two']})

>>> print(df)

      data1     data2 key1 key2

0  0.168619  0.824735    a  one

1  0.094004  0.268596    b  two

>>> print(df.dtypes) #会直接得到一个Series

data1    float64

data2    float64

key1      object

key2      object

dtype: object

df = pd.DataFrame({'data1':np.random.rand(2),

                  'data2':np.random.rand(2),

                  'key1':['a','b'],

                  'key2':['one','two']})

>>>for n,p in df.groupby(df.dtypes, axis=1):  # 按照值类型分列  #按照列进行分组（没有对值进行聚合），按照数值的字段类型（浮点型、字符串）

...    print(n)

...    print(p)

...    print('##')

float64

      data1     data2

0  0.204654  0.104438

1  0.749022  0.392701

##

object

  key1 key2

0    a  one

1    b  two

##

>>> df = pd.DataFrame(np.arange(16).reshape(4,4),

...                   columns = ['a','b','c','d'])

>>> df

    a   b   c   d

0   0   1   2   3

1   4   5   6   7

2   8   9  10  11

3  12  13  14  15

>>> mapping = {'a':'one','b':'one','c':'two','d':'two'}  #mapping字典中，a , b 列对应为one； c ,d 列对应two ；

>>> df.groupby(mapping, axis = 1)               ##以字典来进行分组；

<pandas.core.groupby.groupby.DataFrameGroupBy object at 0x000000000299CB70>

>>> print(df.groupby(mapping, axis=1).groups['one']) #################特别注意它的结构，a b为它的index，#############

Index(['a', 'b'], dtype='object')

>>> print(df.groupby(mapping,axis=1).get_group('one')) #查看它的组

    a   b

0   0   1

1   4   5

2   8   9

3  12  13

>>> df.groupby(mapping, axis = 1).sum()  #axis=1是按照行进行计算的

   one  two

0    1    5

1    9   13

2   17   21

3   25   29

>>>

>>> s = pd.Series(mapping) # s中，index中a、b对应的为one，c、d对应的为two，以Series来分组

>>> print(s,'\n')

a      one

b      one

c      two

d      two

dtype: object

>>> print(s.groupby(s).count())

one      2

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,'\n')

      a   b   c   d

abc   0   1   2   3

bcd   4   5   6   7

aa    8   9  10  11

b    12  13  14  15

>>> print(df.groupby(len).sum()) # 按照index的字母长度分组；

    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)

<pandas.core.groupby.groupby.SeriesGroupBy object at 0x000000000B2D2B38>

>>> print(grouped.first(),'→ first：非NaN的第一个值\n')

1    1

2    2

3    3

dtype: int64 → first：非NaN的第一个值

>>> print(grouped.last(),'→ last：非NaN的最后一个值\n')

1    10

2    20

3    30

dtype: int64 → last：非NaN的最后一个值

>>> print(grouped.sum(),'→ sum：非NaN的和\n')

1    11

2    22

3    33

dtype: int64 → sum：非NaN的和

>>> print(grouped.mean(),'→ mean：非NaN的平均值\n')

1     5.5

2    11.0

3    16.5

dtype: float64 → mean：非NaN的平均值

>>> print(grouped.median(),'→ median：非NaN的算术中位数\n')

1     5.5

2    11.0

3    16.5

dtype: float64 → median：非NaN的算术中位数

>>> print(grouped.count(),'→ count：非NaN的值\n')

1    2

2    2

3    2

dtype: int64 → count：非NaN的值

>>> print(grouped.min(),'→ min、max：非NaN的最小值、最大值\n')

1    1

2    2

3    3

dtype: int64 → min、max：非NaN的最小值、最大值

>>> print(grouped.std(),'→ std，var：非NaN的标准差和方差\n')

1     6.363961

2    12.727922

3    19.091883

dtype: float64 → std，var：非NaN的标准差和方差

>>> print(grouped.prod(),'→ prod：非NaN的积\n')

1    10

2    40

3    90

dtype: int64 → prod：非NaN的积

>>>

>>> 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)

   a         b         c         d

0  1  0.296927  0.088159  0.144423

1  1  0.658442  0.172187  0.716124

2  2  0.978164  0.292865  0.421377

3  2  0.288031  0.874687  0.779844

>>> print(df.groupby('a').agg(['mean',np.sum])) #以a进行分组，想求出它的均值和sum 

          b                   c                   d

       mean       sum      mean       sum      mean       sum

a

1  0.477684  0.955369  0.130173  0.260346  0.430273  0.860547

2  0.633097  1.266195  0.583776  1.167551  0.600611  1.201221

>>> print(df.groupby('a')['b'].agg({'result1':np.mean,  #把b单独提取出来，结果以字典的形式显示。 

...                                'result2':np.sum}))

    result1   result2

a

1  0.477684  0.955369

2  0.633097  1.266195

>>>

# 函数写法可以用str，或者np.方法

# 可以通过list，dict传入，当用dict时，key名为columns

>>> 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)

      data1     data2 key1 key2

0  0.965986  0.086595    a  one

1  0.981811  0.143423    a  two

2  0.750037  0.331594    b  one

3  0.433544  0.594493    b  two

4  0.801283  0.022557    a  one

>>> print(k_mean)

        data1     data2

key1

a     0.91636  0.084192

b     0.59179  0.463044

>>> print(pd.merge(df,k_mean,left_on='key1',right_index=True).add_prefix('mean_')) # .add_prefix('mean_')：添加前缀     # 通过分组、合并，得到一个包含均值的Dataframe

   mean_data1_x  mean_data2_x mean_key1 mean_key2  mean_data1_y  mean_data2_y

0      0.965986      0.086595         a       one       0.91636      0.084192

1      0.981811      0.143423         a       two       0.91636      0.084192

4      0.801283      0.022557         a       one       0.91636      0.084192

2      0.750037      0.331594         b       one       0.59179      0.463044

3      0.433544      0.594493         b       two       0.59179      0.463044

>>>

>>> print(df.groupby('key2').mean())  # 按照key2分组求均值

         data1     data2

key2

one   0.839102  0.146916

two   0.707678  0.368958

>>> print(df.groupby('key2').transform(np.mean))

      data1     data2

0  0.839102  0.146916

1  0.707678  0.368958

2  0.839102  0.146916

3  0.707678  0.368958

4  0.839102  0.146916

>>>

 data1、data2每个位置元素取对应分组列的均值

# 字符串不能进行计算

>>> 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直接运行其中的函数 # 这里为匿名函数，直接描述分组后的统计量 

               data1     data2                 # describe()就是计算统计量。

key1

a    count  3.000000  3.000000

     mean   0.544703  0.643239

     std    0.423421  0.373472

     min    0.093693  0.217797

     25%    0.350207  0.506341

     50%    0.606721  0.794885

     75%    0.770208  0.855961

     max    0.933696  0.917036

b    count  2.000000  2.000000

     mean   0.560306  0.296463

     std    0.081378  0.365345

     min    0.502763  0.038125

     25%    0.531534  0.167294

     50%    0.560306  0.296463

     75%    0.589077  0.425632

     max    0.617848  0.554801

>>>

def f_df1(d,n):

    return(d.sort_index()[:n]) # 参数n就是返回几个；

def f_df2(d,k1):

    return(d[k1])

print(df.groupby('key1').apply(f_df1,2),'\n') #第一个参数d就是dataframe

           data1     data2 key1 key2

key1

a    0  0.913408  0.369516    a  one

     1  0.742166  0.340193    a  two

b    2  0.975362  0.863833    b  one

     3  0.087291  0.420579    b  two

print(df.groupby('key1').apply(f_df2,'data2')) #按照key1分组之后按照data2做了个索引；

key1

a     0    0.233298

      1    0.024352

      4    0.828523

b     2    0.340762

      3    0.745267

Name: data2, dtype: float64

print(type(df.groupby('key1').apply(f_df2,'data2')))

<class 'pandas.core.series.Series'>

# f_df1函数：返回排序后的前n行数据

# f_df2函数：返回分组后表的k1列，结果为Series，层次化索引

# 直接运行f_df函数

# 参数直接写在后面，也可以为.apply(f_df,n = 2))

>>> 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)

        date key    values

0 2017-05-01   a  9.990137

1 2017-05-02   b  0.888088

2 2017-05-03   c  9.568805

3 2017-05-01   d  3.617859

4 2017-05-02   a  6.341511

5 2017-05-03   b  5.447269

6 2017-05-01   c  7.827543

7 2017-05-02   d  9.753436

8 2017-05-03   a  6.048343

>>> print(pd.pivot_table(df, values = 'values', index = 'date', columns = 'key', aggfunc=np.sum))  # 也可以写 aggfunc='sum'

key                a         b         c         d

date

2017-05-01  9.990137       NaN  7.827543  3.617859

2017-05-02  6.341511  0.888088       NaN  9.753436

2017-05-03  6.048343  5.447269  9.568805       NaN

>>> # data：DataFrame对象

... # values：要聚合的列或列的列表。  就是df里边的数据，分组的结果聚合哪些数据；

... # index：是做完数据透视表之后的index，从原数据的列中筛选。  要以哪个值作为参考，数据透视表后的那个index就是分组的那个index，拿哪个字段作为分组；

... # columns：数据透视表的columns，从原数据的列中筛选

... # aggfunc：用于聚合的函数，默认为numpy.mean，支持numpy计算方法

...

>>> print(pd.pivot_table(df, values = 'values', index = ['date','key'], aggfunc=len))

                values

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

>>> # 这里就分别以date、key共同做数据透视，值为values：统计不同（date，key）情况下values的平均值

... # aggfunc=len(或者count)：计数

>>> df = pd.DataFrame({'A': [1, 2, 2, 2, 2],

...                    'B': [3, 3, 4, 4, 4],

...                    'C': [1, 1, np.nan, 1, 1]})

>>> print(df)

   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

>>> print(pd.crosstab(df['A'],df['B'])) # 如果crosstab只接收两个Series，它将提供一个频率表。  #用A的唯一值，统计B唯一值的出现次数

B  3  4            #当A值为1，B值为3时，有1个； A为2，B为3时有1个； A为2，B为4时有3个。

A

1  1  0

2  1  3

>>> print(pd.crosstab(df['A'],df['B'],normalize=True)) # normalize：默认False，将所有值除以值的总和进行归一化 → 为True时候显示百分比

B    3    4         #就是说当A为1，B为3时，有1个，1/(1+1+0+3)=0.2 这样一个百分比。

A

1  0.2  0.0

2  0.2  0.6

>>> print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum)) # values：可选，根据因子聚合的值数组 # aggfunc：可选，如果未传递values数组，则计算频率表，如果传递数组，则按照指定计算  # 这里相当于以A和B界定分组，计算出每组中第三个系列C的值

B    3    4         #就是说当A=1，B=3时，求C列的和为1 。

A

1  1.0  NaN

2  1.0  2.0

>>> print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum, margins=True)) # margins：布尔值，默认值False，给你加个行/列边距（小计），为了好看点

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

>>>

C:\Users\Administrator>pip install xlrd

Collecting xlrd #先安装下这个模块

  Downloading https://files.pythonhosted.org/packages/07/e6/e95c4eec6221bfd8528bcc4ea252a850bf

    100% |████████████████████████████████| 112kB 171kB/s

Installing collected packages: xlrd

Successfully installed xlrd-1.1.0

import os

os.chdir(r'C:\Users\Administrator\Desktop')

data1 = pd.read_table('data1.txt', delimiter=',',header = 0, index_col=1) # delimiter：用于拆分的字符，也可以用sep：sep = ','#header：用做列名的序号，默认为0（第一行） # index_col：指定某列为行索引，否则自动索引0, 1, .....

print(data1)                                   header=0就是把首行第一行作为columns  #index_col=0就是把第一列当做索引,不写它或None就是默认的自动添加；

     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('地市级党委书记数据库（2000-10）.csv',engine = 'python',encoding='utf-8') # engine：使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。

# encoding：指定字符集类型，即编码，通常指定为'utf-8'

# 大多数情况先将excel导出csv，再读取

print(data2.head()) # read_table主要用于读取简单的数据，txt/csv

 省级政区代码 省级政区名称  地市级政区代码 地市级政区名称    年份 ...  专业：理工  专业：农科  专业：医科  入党年份 工作年份

0  130000    河北省   130100    石家庄市  2000 ...    NaN    NaN    NaN   NaN  NaN

1  130000    河北省   130100    石家庄市  2001 ...    1.0    0.0    0.0   NaN  NaN

2  130000    河北省   130100    石家庄市  2002 ...    1.0    0.0    0.0   NaN  NaN

3  130000    河北省   130100    石家庄市  2003 ...    1.0    0.0    0.0   NaN  NaN

4  130000    河北省   130100    石家庄市  2004 ...    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)

# io ：文件路径。                        sheetname就是你的excel文件里边可能有多个文件，你可以写文件名也可以写 0就是第一个文件，1第二个文件；None是给你读取成个字典，把excel里边两个表都读出来；list就是 [0,1]

# sheetname：返回多表使用sheetname=[0,1],若sheetname=None是返回全表 → ① int/string 返回的是dataframe ②而none和list返回的是dict

# header：指定列名行，默认0，即取第一行

# index_col：指定列为索引列，也可以使用u”strings”

print(data3)

      省级政区代码    省级政区名称  地市级政区代码   地市级政区名称  ...   专业：农科 专业：医科  入党年份  工作年份

0     130000       河北省   130100      石家庄市  ...     NaN   NaN   NaN   NaN

1     130000       河北省   130100      石家庄市  ...     0.0   0.0   NaN   NaN

2     130000       河北省   130100      石家庄市  ...     0.0   0.0   NaN   NaN

3     130000       河北省   130100      石家庄市  ...     0.0   0.0   NaN   NaN

4     130000       河北省   130100      石家庄市  ...     0.0   0.0   NaN   NaN

5     130000       河北省   130100      石家庄市  ...     0.0   0.0   NaN   NaN

...

3661  650000  新疆维吾尔自治区   654300     阿勒泰地区  ...     NaN   NaN   NaN   NaN

3662  650000  新疆维吾尔自治区   654300     阿勒泰地区  ...     NaN   NaN   NaN   NaN

[3663 rows x 23 columns]