'''
http://pandas.pydata.org/pandas-docs/stable/10min.html

    numpy的主要数据结构是ndarry
    pandas的主要数据结构是Series、DataFrame
'''


import pandas as pd
import numpy as np
import matplotlib.pyplot as plt  

df1 = pd.DataFrame(np.array(range(101,125)).reshape(6,4),
                   index=range(6),
                   columns=list('ABCD'))
print(df1)
#      A    B    C    D
# 0  101  102  103  104
# 1  105  106  107  108
# 2  109  110  111  112
# 3  113  114  115  116
# 4  117  118  119  120
# 5  121  122  123  124

df2 = pd.DataFrame({'custID':['C0001','C0002','C0004','C0004','C0004','C0003'],
                    'accountID':pd.Series(['6214C000101',
                                           '6214C000201',
                                           '6214C000401',
                                           '6214C000403',
                                           '6214C000402',
                                           '6214C000301'],index=range(6),dtype='str'),
                    'tradeDate':pd.Series(['2018-01-18 14:00:00',
                                           '2018-01-18 14:00:00',
                                           '2018-01-18 14:00:01',
                                           '2018-01-18 14:00:03',
                                           '2018-01-18 14:00:02',
                                           '2018-01-18 14:00:00'],index=range(6),dtype='str'),
                    'tradeAmt':pd.Series([100.0,
                                          100.0,
                                          101.0,
                                          103.0,
                                          102.0,
                                          100.0],index=range(6),dtype='float'),
                    'tradeDesc':'xxxxxx',
                    'mark':pd.Categorical(["row1","row2","row3","row4","row5","row6"])},
                   index=range(6))  #注意:表DateFrame与列Series的索引保持一致。DateFrame的真实index默认是从0开始的,这里设置的其实是index的标签,如果自定义了DateFrame的index(标签),假如某列是Series,那么Series的index也必须保持一致,否则会错位。
print(df2)
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx

print(df2.dtypes)
# accountID      object
# custID         object
# mark         category
# tradeAmt      float64
# tradeDate      object
# tradeDesc      object
# dtype: object

print(df2.index)
# RangeIndex(start=0, stop=6, step=1)

print(df2.columns)
# Index(['accountID', 'custID', 'mark', 'tradeAmt', 'tradeDate', 'tradeDesc'], dtype='object')

print(df2.values)
# [['6214C000101' 'C0001' 'row1' 100.0 '2018-01-18 14:00:00' 'xxxxxx']
#  ['6214C000201' 'C0002' 'row2' 100.0 '2018-01-18 14:00:00' 'xxxxxx']
#  ['6214C000401' 'C0004' 'row3' 101.0 '2018-01-18 14:00:01' 'xxxxxx']
#  ['6214C000403' 'C0004' 'row4' 103.0 '2018-01-18 14:00:03' 'xxxxxx']
#  ['6214C000402' 'C0004' 'row5' 102.0 '2018-01-18 14:00:02' 'xxxxxx']
#  ['6214C000301' 'C0003' 'row6' 100.0 '2018-01-18 14:00:00' 'xxxxxx']]

print(df2.head(2))
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx

print(df2.tail(2))
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx


print(df2.describe())  #统计,但仅限数值的列,非数值的列不会输出统计
#          tradeAmt
# count    6.000000
# mean   101.000000
# std      1.264911
# min    100.000000
# 25%    100.000000
# 50%    100.500000
# 75%    101.750000
# max    103.000000

print(df2.T)
#                              0                    1                    2  \
# accountID          6214C000101          6214C000201          6214C000401   
# custID                   C0001                C0002                C0004   
# mark                      row1                 row2                 row3   
# tradeAmt                   100                  100                  101   
# tradeDate  2018-01-18 14:00:00  2018-01-18 14:00:00  2018-01-18 14:00:01   
# tradeDesc               xxxxxx               xxxxxx               xxxxxx   
# 
#                              3                    4                    5  
# accountID          6214C000403          6214C000402          6214C000301  
# custID                   C0004                C0004                C0003  
# mark                      row4                 row5                 row6  
# tradeAmt                   103                  102                  100  
# tradeDate  2018-01-18 14:00:03  2018-01-18 14:00:02  2018-01-18 14:00:00  
# tradeDesc               xxxxxx               xxxxxx               xxxxxx  

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

print(df2.sort_values(by='tradeDate',ascending=False)) #排序  按指定列的值 降序
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx

print(df2.sort_values(by=['custID','tradeDate'],ascending=[True,False])) #联合排序
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx

print(df2.sort_index(axis=0,ascending=False)) #索引排序  按照行的索引
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx

print(df2.sort_index(axis=1,ascending=True)) #索引排序  按照列的索引(默认是按照列名生成的行索引)
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx

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

'''
    iloc按索引查找,loc按标签查找
    iat按索引查找,iat按标签查找
'''

print(df2['custID'])
# 0    C0001
# 1    C0002
# 2    C0004
# 3    C0004
# 4    C0004
# 5    C0003
# Name: custID, dtype: object

print(df2[0:4]) #切片 按行索引
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx

print(df2[1:4]) #切片 按行索引
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx

print(df2.loc[1,'accountID']) #按行列标签查找,不是按行列索引查找
# 6214C000201

print(df2.iloc[3]) #第4行
# accountID            6214C000403
# custID                     C0004
# mark                        row4
# tradeAmt                     103
# tradeDate    2018-01-18 14:00:03
# tradeDesc                 xxxxxx
# Name: 3, dtype: object

print(df2.iloc[3,4]) #第4行 第5列
# 2018-01-18 14:00:03

print(df2.iloc[3:4]) #第4至5行(不含第5行)
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx

print(df2.iloc[3:5,1:3]) #第4、5行,第2、3列(列索引如果没有自定义,是按列名排序自动生成的)
#   custID  mark
# 3  C0004  row4
# 4  C0004  row5
print(df2.iloc[[3,4],[1,2]]) #第4、5行,第2、3列
#   custID  mark
# 3  C0004  row4
# 4  C0004  row5

print(df2.iloc[3:5,:]) #第4、5行,所有列
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx

print(df2.iloc[:,1:3]) #所有行,第2、3列
#   custID  mark
# 0  C0001  row1
# 1  C0002  row2
# 2  C0004  row3
# 3  C0004  row4
# 4  C0004  row5
# 5  C0003  row6

print(df2[df2.tradeAmt > 101.0]) #筛选
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx

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

df3 = df2.copy()
df3["custID"] = ["NEW","NEW","NEW","NEW","NEW","NEW"] # 更新 整列
df3.loc[:,'tradeAmt'] = range(len(df3))  #更新  按行列标签查找
df3.at[range(7)[1],'accountID'] = '==========='  # 更新  按行列标签查找
df3.iat[0,0] = '+++++++++++' # 更新  按行列索引查找
# df3[df3.tradeDate == '2018-01-18 14:00:03'] = -df3 #找出符合条件的行,然后取反,如果所有字段都是数值的话是可以的
print(df3)
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  +++++++++++    NEW  row1         0  2018-01-18 14:00:00    xxxxxx
# 1  ===========    NEW  row2         1  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401    NEW  row3         2  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403    NEW  row4         3  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402    NEW  row5         4  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301    NEW  row6         5  2018-01-18 14:00:00    xxxxxx

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

df4 = df2.reindex(index=range(4), columns=['custID','accountID','tradeAmt']) #重新组合 抽取
df4.loc[0:1,'tradeAmt'] = 200  #如果该列存在,则更新
df4.loc[0:1,'newColumn'] = 1 #如果该列不存在,则新增列
print(df4)
#   custID    accountID  tradeAmt  newColumn
# 0  C0001  6214C000101     200.0        1.0
# 1  C0002  6214C000201     200.0        1.0
# 2  C0004  6214C000401     101.0        NaN
# 3  C0004  6214C000403     103.0        NaN

print(df4.dropna(how='any'))  #过滤所有包含空值的行
#   custID    accountID  tradeAmt  newColumn
# 0  C0001  6214C000101     200.0        1.0
# 1  C0002  6214C000201     200.0        1.0

print(df4.fillna(value=999)) #填充空值
#   custID    accountID  tradeAmt  newColumn
# 0  C0001  6214C000101     200.0        1.0
# 1  C0002  6214C000201     200.0        1.0
# 2  C0004  6214C000401     101.0      999.0
# 3  C0004  6214C000403     103.0      999.0

print(pd.isnull(df4)) #判断空值
#   custID accountID tradeAmt newColumn
# 0  False     False    False     False
# 1  False     False    False     False
# 2  False     False    False      True
# 3  False     False    False      True

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

print(df2)
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx

print(df2.mean())
# tradeAmt    101.0
# dtype: float64



s = pd.Series([1,3,5,np.nan,6,8], index=range(6)).shift(2)  # 向后移动几行,前面置空
print(s)
# 0    NaN
# 1    1.0
# 2    3.0
# 3    5.0
# 4    NaN
# 5    6.0
# dtype: float64

print(df2.shift(2))
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0          NaN    NaN   NaN       NaN                  NaN       NaN
# 1          NaN    NaN   NaN       NaN                  NaN       NaN
# 2  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 3  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 4  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 5  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx

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

print(df2.apply(lambda x: max(x))) #列函数 lambda或者function都可以
# accountID            6214C000403
# custID                     C0004
# mark                        row6
# tradeAmt                     103
# tradeDate    2018-01-18 14:00:03
# tradeDesc                 xxxxxx
# dtype: object

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

print(df2["custID"].value_counts()) #类似 group by count 
# C0004    3
# C0001    1
# C0002    1
# C0003    1
# Name: custID, dtype: int64

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


print(df2["mark"].str.upper()) #大小写转换
# 0    ROW1
# 1    ROW2
# 2    ROW3
# 3    ROW4
# 4    ROW5
# 5    ROW6
# Name: mark, dtype: object

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

df5 = pd.DataFrame(np.random.randn(9,3))
print(df5)
#           0         1         2
# 0  1.303158 -0.125934 -0.205285
# 1  0.760388 -1.004298  1.143800
# 2  2.063722  0.229955  0.020368
# 3 -2.024974  0.307957 -0.579090
# 4 -1.571883  0.260561 -0.884209
# 5  2.465572 -1.001873  1.243028
# 6  0.025388 -0.372608  1.431214
# 7 -0.079416 -0.401075 -0.973337
# 8 -1.088755 -1.947188 -1.100827

pieces = [df5[:2],df5[5:6],df5[7:]]  #头、中间、尾,切几块拼起来
print(pieces)
# [          0         1         2
# 0  1.303158 -0.125934 -0.205285
# 1  0.760388 -1.004298  1.143800,           0         1         2
# 5  2.465572 -1.001873  1.243028,           0         1         2 #index重复打印了几次
# 7 -0.079416 -0.401075 -0.973337
# 8 -1.088755 -1.947188 -1.100827]

print(pd.concat(pieces)) #包含
#           0         1         2
# 0  1.303158 -0.125934 -0.205285
# 1  0.760388 -1.004298  1.143800
# 5  2.465572 -1.001873  1.243028
# 7 -0.079416 -0.401075 -0.973337
# 8 -1.088755 -1.947188 -1.100827

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

df_left = pd.DataFrame({'key':['001','002','007'],'val':['999','1','2']})
df_right = pd.DataFrame({'key':['001','002','009'],'key2':['001','002','009'],'val':['999','3','4']})

print(df_left)
#    key  val
# 0  001  999
# 1  002    1
# 2  007    2
print(df_right)
#    key key2  val
# 0  001  001  999
# 1  002  002    3
# 2  009  009    4
print( pd.merge(df_left, df_right,how='inner', on='key') ) #内关联
#    key val_x key2 val_y
# 0  001   999  001   999
# 1  002     1  002     3
print( pd.merge(df_left, df_right, how='inner', left_on='key',right_on='key2') ) #内关联 不同字段
#   key_x val_x key_y key2 val_y
# 0   001   999   001  001   999
# 1   002     1   002  002     3
print( pd.merge(df_left, df_right,how='inner', on=['key','val']) ) #内关联 多字段
#    key  val key2
# 0  001  999  001
print( pd.merge(df_left, df_right, how='left', on='key') ) #左外关联
#    key val_x key2 val_y
# 0  001   999  001   999
# 1  002     1  002     3
# 2  007     2  NaN   NaN
print( pd.merge(df_left, df_right, how='right', on='key') ) #右外关联
#    key val_x key2 val_y
# 0  001   999  001   999
# 1  002     1  002     3
# 2  009   NaN  009     4

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

print(df2.append(df2[:3],ignore_index=True)) #对原表做行切片,再追加到原表,追加的时候忽略切片的索引标签,索引自动重新编排标签
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx
# 6  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx  (这行是追加的)
# 7  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx  (这行是追加的)
# 8  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx  (这行是追加的)

print(df2.append(df2[:3],ignore_index=False))  #追加之后,保留切片的索引标签,发现了吗,索引标签是允许重复的
#      accountID custID  mark  tradeAmt            tradeDate tradeDesc
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx
# 3  6214C000403  C0004  row4     103.0  2018-01-18 14:00:03    xxxxxx
# 4  6214C000402  C0004  row5     102.0  2018-01-18 14:00:02    xxxxxx
# 5  6214C000301  C0003  row6     100.0  2018-01-18 14:00:00    xxxxxx
# 0  6214C000101  C0001  row1     100.0  2018-01-18 14:00:00    xxxxxx  (这行是追加的)
# 1  6214C000201  C0002  row2     100.0  2018-01-18 14:00:00    xxxxxx  (这行是追加的)
# 2  6214C000401  C0004  row3     101.0  2018-01-18 14:00:01    xxxxxx  (这行是追加的)

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

tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',   #zip()函数,将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表
                      'foo', 'foo', 'qux', 'qux'], 
                     ['one', 'two', 'one', 'two',
                      'one', 'two', 'one', 'two']])) 
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second']) # 多索引标签MultiIndex

df6 = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
print(df6)
#                      A         B
# first second                    
# bar   one    -0.101234 -0.956210
#       two    -0.480354  1.308950
# baz   one     0.943706  0.976480
#       two    -0.788852 -1.556547
# foo   one     0.997527 -0.337391
#       two    -0.191448 -0.083129
# qux   one    -0.919527 -0.414051
#       two    -0.579727  1.595290

stacked = df6.stack()   # 把“行列表结构”变成“堆栈结构”(姑且这样称呼它),把列标签追加到行标签之后
print(stacked) 
# first  second   
# bar    one     A   -0.101234
#                B   -0.956210
#        two     A   -0.480354
#                B    1.308950
# baz    one     A    0.943706
#                B    0.976480
#        two     A   -0.788852
#                B   -1.556547
# foo    one     A    0.997527
#                B   -0.337391
#        two     A   -0.191448
#                B   -0.083129
# qux    one     A   -0.919527
#                B   -0.414051
#        two     A   -0.579727
#                B    1.595290

print(stacked["bar"]["one"]["A"]) # “堆栈结构”的好处是,你可以这样访问数据,可以想象“堆栈结构”其实就是多层数组
# dtype: float64
# -0.101233870095

unstacked = stacked.unstack() # 还原回去,把“堆栈结构”变成“行列表结构”,把行标签变成列
print(unstacked)
#                      A         B
# first second                    
# bar   one    -0.101234 -0.956210
#       two    -0.480354  1.308950
# baz   one     0.943706  0.976480
#       two    -0.788852 -1.556547
# foo   one     0.997527 -0.337391
#       two    -0.191448 -0.083129
# qux   one    -0.919527 -0.414051
#       two    -0.579727  1.595290

unstacked_unstacked_0 = unstacked.unstack(0) #还能继续吧行标签变成列标签
print(unstacked_unstacked_0)
#                A                                      B                      
# first        bar       baz       foo       qux      bar       baz       foo        qux 
# second                                                                                 
# one    -0.101234  0.943706  0.997527 -0.919527 -0.95621  0.976480 -0.337391  -0.414051 
# two    -0.480354 -0.788852 -0.191448 -0.579727  1.30895 -1.556547 -0.083129   1.595290 

unstacked_unstacked_1 = unstacked.unstack(1) #还能继续吧行标签变成列标签  把第2个标签变成列标签
print(unstacked_unstacked_1)
#                A                   B          
# second       one       two       one       two
# first                                         
# bar    -0.101234 -0.480354 -0.956210  1.308950
# baz     0.943706 -0.788852  0.976480 -1.556547
# foo     0.997527 -0.191448 -0.337391 -0.083129
# qux    -0.919527 -0.579727 -0.414051  1.595290


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

df7 = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,
                   'B' : ['A', 'B', 'C'] * 4,
                   'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
                   'D' : np.random.randn(12),
                   'E' : np.random.randn(12)})

print(df7)
#         A  B    C         D         E
# 0     one  A  foo -0.516297 -0.860641
# 1     one  B  foo -1.560483 -1.647366
# 2     two  C  foo  1.124756  0.329971
# 3   three  A  bar -0.312954  0.040263
# 4     one  B  bar -1.355079  0.358829
# 5     one  C  bar  0.749617  0.978513
# 6     two  A  foo -2.173830  0.434789
# 7   three  B  foo -1.070213  0.641253
# 8     one  C  foo -0.515032  0.127273
# 9     one  A  bar -1.408970  0.025128
# 10    two  B  bar -0.390044  0.060392
# 11  three  C  bar  0.067667  0.676595

print( pd.pivot_table(df7, values='D', index=['A', 'B'], columns=['C'])  ) #透视表
# C             bar       foo
# A     B                    
# one   A -1.408970 -0.516297
#       B -1.355079 -1.560483
#       C  0.749617 -0.515032
# three A -0.312954       NaN
#       B       NaN -1.070213
#       C  0.067667       NaN
# two   A       NaN -2.173830
#       B -0.390044       NaN
#       C       NaN  1.124756

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


rng = pd.date_range('1/1/2012', periods=10, freq='min') #看结果,是个时间索引DatetimeIndex
print(rng)
# DatetimeIndex(['2012-01-01 00:00:00', '2012-01-01 00:01:00',
#                '2012-01-01 00:02:00', '2012-01-01 00:03:00',
#                '2012-01-01 00:04:00', '2012-01-01 00:05:00',
#                '2012-01-01 00:06:00', '2012-01-01 00:07:00',
#                '2012-01-01 00:08:00', '2012-01-01 00:09:00'],
#               dtype='datetime64[ns]', freq='T')

ts = pd.Series(range(10), index=rng)  # 时间序列数据
print(ts)
# 2012-01-01 00:00:00    0
# 2012-01-01 00:01:00    1
# 2012-01-01 00:02:00    2
# 2012-01-01 00:03:00    3
# 2012-01-01 00:04:00    4
# 2012-01-01 00:05:00    5
# 2012-01-01 00:06:00    6
# 2012-01-01 00:07:00    7
# 2012-01-01 00:08:00    8
# 2012-01-01 00:09:00    9
# Freq: T, dtype: int32

print( ts.resample('5Min').sum() ) #resample()是对时间序列数据进行重新采样的便捷方法
# 2012-01-01 00:00:00    10
# 2012-01-01 00:05:00    35
# Freq: 5T, dtype: int32

ts_utc = ts.tz_localize('UTC') #改变时区标准 UTC世界时 GMT格里尼治时
print( ts_utc )
# 2012-01-01 00:00:00+00:00    0
# 2012-01-01 00:01:00+00:00    1
# 2012-01-01 00:02:00+00:00    2
# 2012-01-01 00:03:00+00:00    3
# 2012-01-01 00:04:00+00:00    4
# 2012-01-01 00:05:00+00:00    5
# 2012-01-01 00:06:00+00:00    6
# 2012-01-01 00:07:00+00:00    7
# 2012-01-01 00:08:00+00:00    8
# 2012-01-01 00:09:00+00:00    9
# Freq: T, dtype: int32

print( ts_utc.tz_convert('US/Eastern') ) #时区转换
# 2011-12-31 19:00:00-05:00    0
# 2011-12-31 19:01:00-05:00    1
# 2011-12-31 19:02:00-05:00    2
# 2011-12-31 19:03:00-05:00    3
# 2011-12-31 19:04:00-05:00    4
# 2011-12-31 19:05:00-05:00    5
# 2011-12-31 19:06:00-05:00    6
# 2011-12-31 19:07:00-05:00    7
# 2011-12-31 19:08:00-05:00    8
# 2011-12-31 19:09:00-05:00    9
# Freq: T, dtype: int32


print( ts.to_period() ) #时间序列显示格式,只显示到你定义的单位 
# 2012-01-01 00:00    0
# 2012-01-01 00:01    1
# 2012-01-01 00:02    2
# 2012-01-01 00:03    3
# 2012-01-01 00:04    4
# 2012-01-01 00:05    5
# 2012-01-01 00:06    6
# 2012-01-01 00:07    7
# 2012-01-01 00:08    8
# 2012-01-01 00:09    9
# Freq: T, dtype: int32

print( ts.to_period().to_timestamp() ) #时间序列显示格式,标准时间格式
# 2012-01-01 00:00:00    0
# 2012-01-01 00:01:00    1
# 2012-01-01 00:02:00    2
# 2012-01-01 00:03:00    3
# 2012-01-01 00:04:00    4
# 2012-01-01 00:05:00    5
# 2012-01-01 00:06:00    6
# 2012-01-01 00:07:00    7
# 2012-01-01 00:08:00    8
# 2012-01-01 00:09:00    9
# Freq: T, dtype: int32

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

df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e']})
df["grade"] = df["raw_grade"].astype("category") #创建新的列,支持category类型数据(category是一种类别标签)

print( df["grade"] )
# 0    a
# 1    b
# 2    b
# 3    a
# 4    a
# 5    e
# Name: grade, dtype: category

df["grade"].cat.categories = ["very good", "good", "very bad"]
df["grade"] = df["grade"].cat.set_categories(["very bad", "bad", "medium", "good", "very good"]) #重新定义类别,覆盖原来的类别
print( df["grade"] )
# 0    very good
# 1         good
# 2         good
# 3    very good
# 4    very good
# 5     very bad
# Name: grade, dtype: category
# Categories (5, object): [very bad, bad, medium, good, very good]

print( df.groupby("grade").size() ) #按类别统计
# grade
# very bad     1
# bad          0
# medium       0
# good         2
# very good    3
# dtype: int64


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

ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000)) #1000日的时间序列+随机数

ts = ts.cumsum() #累加统计

print(ts)
ts.plot() #有的环境到这步就显式了
plt.show() #有的要导入matplotlib.pyplot模块,这样开启图像显示
#图像是一条曲线,X轴:1000日,y轴:每日的累加统计结果

df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,columns=['A', 'B', 'C', 'D']) #时间序列的索引标签,4列的表
df = df.cumsum() #每列的累加统计
df.plot()
plt.show()
#图像是4条曲线,X轴:1000日,y轴:每日的累加统计结果