pasdas模块基础学习

#pandas中的元素如果为空值，会返回NaN
'''pandas简介
pandas是python的一个数据分析包，最初由AQR Capital Management于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的一部分。Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。
Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。

官网：http://pandas.pydata.org/
参考文档：http://pandas.pydata.org/pandas-docs/stable/'''


'''pandas数据结构介绍
Series：一种类似于一维数组的对象，它是由一组数据（各种Numpy数据类型）
以及一组与之相关的数据标签（即索引）组成。仅由一组数据即可产生简单的
Series。

DataFrame：一个表格型的数据结构，含有一组有序的列，每列可以是不同的值
类型（数值、字符串、布尔值等），DataFrame既有行索引也有列索引，可以被
看做是由Series组成的字典。'''


'''Series
Series类型的创建
Series切片和索引
Series应用NumPy数组运算
Series类型的操作类似Python字典类型
Series缺失值检测
Series自动对齐
Series及其索引的name属性'''

'''Series类型的创建
• 通过一维数组创建Series
• Python字典，键值对中的“键”是索引，index从字典中进行选择操作
• 标量值，index表达Series类型的尺寸

• Python列表，index与列表元素个数一致
• 其他函数，range()函数等'''

#1.通过一维数组创建Series
#Series对象本质上是由两个数组构成，一个数组构成对象的索引（index），一个数组构成对象的值（values)'''

import numpy as np
import pandas as pd

#series测试
print('以下为对Series类型数据的测试：')
array = np.array([1,2,3,4])
series01 = pd.Series(array)#生成一个series对象，索引（index）为0，1，2，3
print('series01的索引：\n',series01.index)#查询series01的索引
print('series01的值：\n',series01.values)#查询series01的值
print('series01的数据类型：\n',series01.dtype)#查询series01的数据类型

series02 = pd.Series([34.5,56.78,45.67])#注意Series的第一个字母要大写
print('series02的索引和值：\n',series02)#查询series02的索引和值
series02.index = ['product1','product2','product3']#重新定义series02的索引
print('series02的新的索引和值：\n',series02)#查询series02新的索引和值

series03 = pd.Series([98,56,88,45],index=['语文','数学','英语','体育'])#产生一个自定义index的series
print('series03的索引和值：\n',series03)
print('series03的索引：\n',series03.index)
print('series03的值：\n',series03.values)

#2.用字典创建series
a_dict={'20071001':6789.98,'20071002':34556.89,'20071003':3748758.88}#建立一个字典
series04=pd.Series(a_dict)#用字典生成series，键作为index，值作为values
print('series04的索引和值：\n',series04)
print('series04的索引：\n',series04.index)

#3.用标量值创建series，index表达series类型数据的尺寸
s = pd.Series(25,index=['a','b','c','d'])
print('s的索引和值：\n',s)


'''Series切片和索引
切片：可以通过自定义索引的列表进行切片；可以通过自动索引进行切片，如果存在自定义索引，则一同被切片。

索引分为自动索引（序号）和自定义索引（index）。

索引：一个的时候直接传入序号或者index，多个的时候传入序号或者index的列表，也可以使用reindex()函数。'''

t=pd.Series(np.arange(10),index=list('ABCDEFGHIJ'))
print('自定义索引的series：t:\n',t)
t_cut1 = t[2:8]
print('对t进行从第2到第8个(左取右不取)元素的切片：\n',t_cut1)
t_cut2 = t[2:10:2]
print('对t进行从第2个到第10个（左取右不取）元素的切片：\n',t_cut2)
t_cut3 = t[[2,3,6]]
print('对t进行第2、3、6个元素的切片：\n',t_cut3)
t_cut4 = t[t>7]
print('对t中值大于7的元素进行切片：\n',t_cut4)
t_cut5 = t['F']
print('对t中自定义索引为F的元素进行切片：\n',t_cut5)
t_cut6 = t[['A','F','G']] # 将来可能报错
print('对t中自定义索引为啊A、F、G的元素进行切片：\n',t_cut6)
#如果上一条命令执行报错KeyError，可以用下面的语句代替:
t_cut7 = t.reindex(['A','F','G'])

'''Series应用NumPy数组运算
NumPy中运算和操作可用于Series类型。'''
print('series04的索引和值：\n',series04)
series04_cut1 = series04[series04>10000]
print('对series04中值大于10000的元素进行切片：\n',series04_cut1)
bool_result01 = series04>10000#对series04中的元素是否大于10000进行判断，返回一个值为bool值的series
bool_result02 = [series04>10000]#对series04中的元素是否大于10000进行判断，返回一个值为bool值的series,外面会套一层中括号
series04_divide = series04/100#对series04中元素的值作除法
print('将series04中的值除以100：\n',series04_divide)
exp_series01 = np.exp(series01)#对series01中的元素求e的幂

#series类型的操作类似python的字典类型
#支持通过自定义索引访问
#支持用 in 和 not in 查询数据是否在元素中
#可以使用.get()方法获得索引对应的值
b = pd.Series([9,8,7,6],index=list('abcd'))
'c' in b #返回True
8 in b #返回False
b.get('f',100)#'f'不在series中，返回100，并未将'f'添加到b中
b.get('c',100)#'c'在字典中，返回值7，并未将100赋值给'c'
b['c'] #返回b中索引为'c'的值
b['c'] = 100 #将100赋值给'c'
b['e'] = 100 #给b中新增元素，索引为'e',值为100

#series缺失值检测
#pandas中的isnull和notnull函数
score = pd.Series({'Tom':89,'John':88,'Merry':96,'Max':65})
new_index = ['Tom','Max','Joe','John','Merry']
scores = pd.Series(score,index=new_index)#索引Joe对应的值为NaN
#pandas中的isnull和notnull函数可用于Series缺失值检测
#isnull和notnull都返回一个布尔类型的Series
pd.isnull(scores)#检测scores里的值是否为空，是则返回True，最终返回一个值为bool值的series
pd.notnull(scores)#检测scores里的值是否不为空，为空则返回False，不为空返回True，最终返回一个值为bool值的series
scores[pd.isnull(scores)]#提取scores中值为NaN（空值）的元素，返回一个series
scores[pd.notnull(scores)]#提取scores中值为非空的元素，返回一个series

#series自动对齐
#不同series之间进行算数运算，会自动对齐不同索引的数据
product_num = pd.Series([23,45,67,89],index=['p3','p1','p2','p5'])
product_price_table = pd.Series([9.98,2.34,4.56,5.67,8.78],index=['p1','p2','p3','p4','p5'])
product_sum=product_num*product_price_table#索引对不上的数据的值返回为NaN

'''Series及其索引的name属性
Series对象本身及其索引都有一个name属性，可赋值设置。'''
product_num.name = 'ProductNums'
product_num.index.name = 'ProductType'



'''DataFrame
DataFrame对象既有行索引，又有列索引

行索引，表明不同行，横向索引，叫index，0轴，axis=0

列索引，表名不同列，纵向索引，叫columns，1轴，axis=1

DataFrame类型的创建
DataFrame的基本属性和整体情况查询
DataFrame索引'''

'''DataFrame类型的创建'''
#由二维np.array（数组）对象
#由一维ndarray、列表、字典、元组或Series构成的字典
#Series类型
#其他的DataFrame类型

#1.由二维ndarray对象创建DataFrame,也可以由矩阵(matrix对象)创建DataFrame
d1 = pd.DataFrame(np.arange(10).reshape(2,5))#由二维ndarray对象创建DaTaFrame
d2 = pd.DataFrame(np.mat([[1,2,3,4,5],[4,5,6,7,8]]))#由matrix对象创建DataFrame

#2由列表创建DataFrame
df01 = pd.DataFrame([['Tom','Merry','John'],[76,98,100]])
df02 = pd.DataFrame([['Tom',76],['Merry',98],['Merry',100]])#以上两个列表创建的DataFrame结果不同
arr = [['Tom',76],['Merry',98],['Merry',100]]
#自定义DataFrame的行索引和列索引
df03 = pd.DataFrame(arr,index=['one','two','three'],columns=['name','score'])

#3.由字典创建DataFrame，列索引默认为字典的键，只能自定义行索引，不能自定义列索引
data = {'apart':['1001','1002','1003','1001'],'profits':[567.87,987.87,873,498.87],'year':[2001,2001,2001,2000]}
df = pd.DataFrame(data)#行索引为默认索引，列索引为键名
df.index#查询df的行索引
df.columns#查询df的列索引
df.values#查询df的值
df1 = pd.DataFrame(data,index=['one','two','three','four'])#自定义DATaFrame的的行索引
df2 = pd.DataFrame(data,columns=['apa','pro','yea'])#无法自定义由字典创建的列索引（得到一个空的列索引为自定义列索引的DaaFrame）

'''DataFrame的基本属性和整体情况查询'''

'''DataFrame的基本属性'''
df.shape#df的行数、列数
df.dtypes#df每一列的数据类型
df.ndim#df的数据维度
df.index#行索引
df.columns#列索引
df.values#对象值，二维ndarray数组
'''DataFrame整体情况查询'''
df.head(3)#显示头部几行，默认5行
df.tail(3)#显示末尾几行，默认5行
df.info()#相关信息概览，行数、列数列索引、列非空值个数、列类型、内存占用
df.describe()#快速综合统计结果：计数，均值，标准差，最小值，四分位数，最大值

#DataFrame可以直接通过df['columns']获取列数据，但行数据的获取需要使用df.loc和df.iloc
'''DataFrame的索引         #DataFrame的行索引和列索引都从0开始计
df.loc 通过标签索引行数据
df.iloc 通过位置获取行数据
布尔索引'''

'''1.df.loc 通过标签索引行数据'''#DataFrame数据通过标签切片会取到冒号之后的数据
t=pd.DataFrame(np.arange(12).reshape(3,4),index=['A','B','C'],columns=['W','X','Y','Z'])
t.loc['A','W']#返回'A'行，'W'列的数据
t.loc['A',['W','Z']]#返回'A'行，'W'列和'Z'列的数据
t.loc[['A','C'],['W','Z']]#返回'A'行、'C'行，'W'列和'Z'列的数据；选择间隔的多行多列
t.loc['B':]#选择连续的多行，返回'B'行及其之后的数据
t.loc[:,'X':'Z']#选择连续的多列，返回'X'、'Y'、'Z'列的数据，注意会取到冒号后的数据

'''2.df.iloc 通过位置获取行数据'''#DataFrame数据通过位置切片取不到冒号之后的数据
t.iloc[1:3,[1,3]]#获取从第1行取到第2行(冒号之后的不取)，第1列和第3列的数据
t.iloc[1:3,1:3]#获取从第1行到第2行(冒号之后的不取)，第1列到第2列的数据(冒号之后的不取)
#通过赋值更改数据
t.loc['A','Y'] = 100#把‘A’行，‘Y’列的数据赋值为100
t.iloc[1:2,:2] = 200#把第1行、第0、1列的数据赋值为200

'''3. 布尔索引'''
t['X'] # 取某一列
t[t['X']>10] # 取列索引为'X'的列中值大于10的数据所在的行
t.loc[t['X']>10] # 取列索引为'X'的列中值大于10的数据所在的行（同上一行代码）
# 比如要查询df03中名字字符串长度大于3且分数大于98的人：
df03[(df03['name'].str.len()>3) & (df03['score']>98)]
df03[(len(str(df03['name']))>3) & (df03['score']>98)] # 这两行代码效果相同
'''注意两个问题：
    1. &表示且，|表示或
    2.字符串的方法'''
''' 方法(字符串的方法)
    cat                          实现元素级的字符串连接操作，可指定分隔符
    contains                     返回表示各字符串是否含有指定模式的bool型数组
    count                        模式的出现次数
    endswith、startswith         相当于对各个元素执行x.endswith(pattern)或x.startswith(pattern)
    findall                      计算个字符串的模式列表
    get                          获取各元素的第i个字符
    join                         根据指定的分隔符将series中各元素的字符串连接起来
    len                          计算各字符串的长度
    lower、upper                 转换大小写，相当于对各个元素执行x.lower()或x.upper
    match                        根据指定的正则表达式对指定的元素进行re.match
    pad                          在字符串的左边、右边或左右两边添加空白符
    center                       相当于pad(side='both')
    repeat                       重复值。例如x.str.repeat(3)相当于对各个字符串执行x*3
    replace                      用指定字符串替换找到的模式
    slice                        对series中的各个字符串进行子串截取
    split                        根据分隔符或正则表达式对字符串进行拆分
    strip、rstrip、lstrip        去除空白符，包括换行符。相当于对各个元素执行x.strip()、x.rstrip、x.lstrip
    '''



'''层次化索引
在某个方向上拥有多个（两个及两个以上）索引级别
通过层次化索引，pandas能够以低维度形式处理高维度数据
通过层次化索引，可以按层级统计数据'''

'''series层次化索引'''
# 建立一个有两个索引级别的series
data = pd.Series([988.44,95859,3949.44,32445.44,234.45],index=[['2001','2001','2001','2002','2002'],['苹果','香蕉','西瓜','苹果','西瓜']])
#设置data的索引的name
data.index.names=['年份','水果类别']

'''DataFrame层次化索引'''
# 通过字典建立一个列索引为‘production’、‘year’、‘fruit’和‘profits’的DataFrame
df = pd.DataFrame({'production':[988.44,95859,3949.44,32445.44,234.45],'year':['2001','2001','2001','2002','2002'],'fruit':['苹果','香蕉','西瓜','苹果','西瓜'],'profits':[2334.44,44556,6677,7788,3345]})
#将‘year’和‘fruit’列设置为DataFrame的行索引(index)
df.set_index(['year','fruit']) # 'year'和'fruit'字符串作为返回的DataFrame的index索引的name属性的值，建立层次化索引
# 将‘year’和‘fruit’列设置为DataFrame的行索引(index),并将返回结果赋值给new_df
new_df = df.set_index(['year','fruit'])

'''按层级统计数据'''
# levels：每个等级上轴标签的唯一值 
# labels：以整数来表示每个level上标签的位置 
# names：index level的名称
new_df.index # 返回new_df这个DataFrame的两个(可以是任意多个)index索引(MultiIndex)
new_df.index.levels # 返回new_df的index索引的levels
new_df.index.labels # 返回new_df的index索引的labels
new_df.index.names # 返回new_df的index索引的names

# 计算某个层级的统计结果
new_df.sum(level='year') # 按'year'索引求和
new_df.sum(level='fruit') # 按'fruit'索引求和



'''数据的合并
join:默认情况下是把行索引相同的数据连接到一起。
merge:把数据按照一定的方式合并到一起。'''
# 准备数据
t1=pd.DataFrame(np.full((3,4),1),index=list('ABC'))
t2=pd.DataFrame(np.full((2,5),0),index=list('AB'),columns=list('VWXYZ'))
# 将t2中和t1行索引相同的行连接
t1.join(t2)

# 准备数据
df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],
                    'group': ['Accounting', 'Engineering', 'Engineering','Hr']})
df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],
                     'hire_date': [2004, 2008, 2012, 2014]})
# 一对一合并,将df1和df2中相对应的元素合并
df3 = pd.merge(df1,df2)

df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'Hr'],
                    'supervisor': ['Carly', 'Guido', 'Steve']})
# 多对一合并，指在需要连接的两个列(两个列的列索引相同)中，有一列的值有重复(行数可以相等也可以不等)
pd.merge(df3,df4)

df5 = pd.DataFrame({'group': ['Accounting', 'Accounting', 'Engineering', 'Engineering', 'Hr']  , 
                    'skills': ['math', 'spreadsheets', 'coding', 'spreadsheets', 'organization']})
# 多对多合并，指在需要连接的两个列(两个列的列索引相同)中，两列的值都有重复(行数可以相等也可以不等)
pd.merge(df1,df5)


'''分割和组合
一个经典分割 - 应用 - 组合操作示例，其中“apply”的是一个求和函数。

1.分割步骤将 DataFrame 按照指定的键分割成若干组。
2.应用步骤对每个组应用函数，通常是累计、转换或过滤函数。
3.组合步骤将每一组的结果合并成一个输出数组。'''
df = pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C'],
                   'data': range(6)})#, columns=['key', 'data'])
# 将df中的数据按列分割(把'key'这一列的值相同的行分割成若干(本例中为3)组，数据类型为pandas.core.groupby.generic.DataFrameGroupBy)
df.groupby('key')
# 将df中的数据按'key'这一列的值相同的行分割成若干组之后对每一组求和,返回一个index的name为'key'，columns为'data'的DataFrame
df.groupby('key').sum()

# DataFrameGroupBy对象常用的函数：
'''函数名	          说明
 .count()	    统计非nan值的数量
 .sum()	        非nan值的和
 .mean()	    非nan值的平均数
 .median()	    非nan值的中位数
 .std()、.var()	无偏（n-1）标准差和方差
 .min() .max()	非nan值的最小值和最大值'''



'''pandas之读写数据'''

# 读取数据的函数
'''   函数名	                         说明
    read_csv()	      从文件、url，文件型对象中加载带分隔符的数据，默认为' , '。
    read_table()	  从文件、url，文件型对象中加载带分隔符的数据，默认为'\t'。
    read_excel()	  从 Excel 文件读入数据
    read_hdf()	      使用 HDF5 文件读写数据
    read_sql()	      从 SQL 数据库的査询结果载入数据
    read_pickle()	  读入 Pickle 序列化之后的数据'''
# 其中read_csv和read_table是常用的，下面就介绍一下read_csv或read_table如何读取数据。
# csv文件的默认编码方式是gbk，pandas读入数据时默认编码方式是utf-8，所以在读取数据时要设置encoding='utf-8',写入数据时要设置encoding='gbk'
# 1.read_csv()或read_table()从文本文件读入数据
# 例:df=pd.read_csv(r'C:\Users\Administrator\Desktop\测量计算\examples\ex1.csv')
'''---------------------------------------------------------------------------
OSError                                   Traceback (most recent call last)
'''''''（报错细节不展示）'''
'''pandas\_libs\parsers.pyx in pandas._libs.parsers.TextReader._setup_parser_source()
OSError: Initializing from file failed'''
# pandas.read_csv() 报错 OSError: Initializing from file failed，一般由两种情况引起：一种是函数参数为路径而非文件名称，另一种是函数参数带有中文。
'''对于第一种情况很简单，原因就是没有把文件名称放到路径的后面，把文件名称添加到路径后面就可以了。。
第二种情况，即使路径、文件名都完整，还是报错的原因是这个参数中有中文，发现调用pandas的read_csv()方法时，
默认使用 C engine作为parser engine，而当文件名中含有中文的时候，用C engine在部分情况下就会出错。
所以在调用read_csv()方法时指定engine为Python就可以解决问题了。'''
# 例:df=pd.read_csv(r'C:\Users\Administrator\Desktop\测量计算\examples\ex1.csv',engine='python')
# 例:df=pd.read_table(r'C:\Users\Administrator\Desktop\测量计算\examples\ex1.csv',sep=',',engine='python')，，，sep=','意思是‘逗号分隔符’
# 在读取csv文件时默认第一行为表头（columns），若不想使其为表头，可设置header=None
df=pd.read_csv(r'D:\Anaconda\programm_my\little_programm\收件人邮箱.csv',header=None,encoding='utf-8')

# 2.to_csv写入数据
df.to_csv(r'D:\Anaconda\programm_my\little_programm\ex001.csv',encoding='gbk')



'''缺失数据的处理'''
data = [[None,1.0,2.0,3.0,4.0,None],
        [6.0,7.0,8.0,9.0,0.0,11.0],
        [12.0,13.0,14.0,15.0,16.0,17.0],
        [18.0,19.0,None,21.0,22.0,23.0]]
data_df = pd.DataFrame(data)
# data_df取值如下所示：
'''      0     1     2     3     4     5
   0   NaN   1.0   2.0   3.0   4.0   NaN
   1   6.0   7.0   8.0   9.0   0.0  11.0
   2  12.0  13.0  14.0  15.0  16.0  17.0
   3  18.0  19.0   NaN  21.0  22.0  23.0'''
# 数据缺失通常有两种情况：
# 一种就是空，None等，在pandas是NaN(和np.nan一样)。
# 另一种是我们让其为0，上面的(1,4)数据。
'''    方法	               说明
    .dropna()	根据标签的值中是否存在缺失数据对轴标签进行过滤（删除），可通过阈值调节对缺失值的容忍度
    .fillna()	用指定值或插值方法填充缺失数据
    .isnull()	返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值NA
    .notnull()	isnull的否定式'''
'''在pandas中数据缺失处理方法：'''
# 判断数据是否为NaN：pd.isnull(df),pd.notnull(df)
# 处理方式1：删除NaN所在的行列dropna (axis=0, how='any', inplace=False)括号中的三个为默认参数
# inplace = True时直接在原数据上进行修改，inplace = False时返回一个修改后的数据，原数据不变
# 处理方式2：填充数据，t.fillna(t.mean()),t.fiallna(t.median()),t.fillna(0)
# 处理为0的数据：t[t==0]=np.nan
#注意：当然并不是每次为0的数据都需要处理；计算平均值等情况，nan是不参与计算的，但是0会。

df=pd.DataFrame([['Tom',np.nan,None,'M'],
                 ['Merty',34,None,np.nan],
                 ['John',23,np.nan,'M'],
                 ['Joe',18,None,'F'],
                 [None,None,None,None]],
                columns=['name','age','salary','gender'])
df.isnull() # 判断df中的值是否为NaN，返回一个值为bool值的DataFrame
df.notnull() # 判断df中的值是否不为NaN，返回一个值不为bool值的DataFrame
df.dropna() # 默认丢失只要含有缺失值的行与df.dropna(axis=0,how='any')效果相同
df.dropna(how='all') # 丢失全部为缺失值的行
df.dropna(axis=1,how='all') # 丢失全部为缺失值的列

series = pd.Series([1,2,3,4,np.NaN,5])
series.dropna() # 返回一个去掉series中值为NaN的行的新series，不改变原series的值

# 准备数据
df = pd.DataFrame(np.random.randn(7,3))
df.iloc[:4,1] = np.nan
df.iloc[:2,2] = np.nan

df.fillna(df.mean()) #取df（各列）的平均值填充，返回一个DataFrame
df[1].fillna(df[1].median()) # 取1这一列的中位数填充该列,返回一个name为该列索引的series



''' 数据特征分析
    排序
    基本统计函数
    累计统计函数
    相关性分析'''
    
''' 1.排序'''

'''   索引排序'''#默认axis = 0
#    .sort_index()方法在指定轴上（***）根据索引进行排序，默认升序
#    .sort_index(axis=0, ascending=True),括号中的参数为.sort_index(()的默认参数
#    注意：若按照键值排序中出现NaN，无论升序或者降序排列，统一放到排序末尾。
# 准备数据
b = pd.DataFrame(np.arange(20).reshape(4,5),index=list('cadb'))
# 按行索引上升排序
b.sort_index() # 返回一个排过序的DataFrame
# 按行索引下降排序
b.sort_index(ascending=False) #返回一个排过序的DataFrame
# 按列索引下降排序
c=b.sort_index(axis=1,ascending=False) # 返回一个排过序的DaTaFrame
# 按行索引上升排序
c = c.sort_index() # 返回一个排过序的DataFrame，并将其重新赋值给c

'''键值排序'''
#.sort_values()方法在指定轴上根据数值进行排序，默认升序
#Series.sort_values(axis=0, ascending=True)
#DataFrame.sort_values(by, axis=0, ascending=True)
#by : axis轴上的某个索引（与axis轴平行的索引，如axis=0时by为列索引）或索引列表
b #准备数据b
c = b.sort_values(2,ascending=False) # 按照索引2的一列中的值进行降序排列,将返回的DataFrame赋值给c
c = c.sort_values('a',axis=1,ascending=False) # 按照索引a的一行中的值进行降序排列，并将返回值重新赋值给c

''' 2.基本统计函数'''

'''适用于Series和DataFrame类型
     方法	                   说明
    .sum()	            计算数据的总和，按0轴计算(按列计算,若要按行计算，则.sum(1))，下同
    .count()	        非NaN值的数量
    .mean() .median()	计算数据的算术平均值、算术中位数
    .var() .std()	    计算数据的方差、标准差
    .min() .max()	    计算数据的最小值、最大值
    .prod()             求各元素的乘积(默认求取各列的积，若要求各行的积，需.prod(1))
    .describe()	        针对0轴（各列）的统计汇总'''

''' 适用于Series类型
            方法	                      说明
    .argmin() .argmax()	计算数据最大值、最小值所在位置的索引位置（自动索引）
    .idxmin() .idxmax()	计算数据最大值、最小值所在位置的索引（自定义索引）'''
# 例：
a=pd.Series([9,8,7,6],index=list('abcd'))
a.describe()
a.describe()['std'] # 相当于a.std()
a.describe()['min'] # 相当于a.min()

b.describe() # 针对b中0轴（各列）的统计汇总，返回一个DataFrame
type(b.describe()) # 穿b.describe()的数据类型（结果为DataFrame）
b.describe().loc['max'] # 相当于b.max(),取每一列中的最大值
b.describe()[2] #取统计汇总中的2列

''' 3.累计统计函数'''
''' 适用于Series和DataFrame类型，累计计算
       方法	            说明
    .cumsum()	依次给出前1、2、…、n个数的和
    .cumprod()	依次给出前1、2、…、n个数的积
    .cummax()	依次给出前1、2、…、n个数的最大值
    .cummin()	依次给出前1、2、…、n个数的最小值'''
b #准备数据b
b.cumsum() #按列累计求各行的和
b.cumsum(1) # 按行累计求各行的和
b.cumprod() # 按列累计求各行的积
b.cummax() # 按列累计求各行的最大值
b.cummin() # 按列累计求各行的最小值
''' 适用于Series和DataFrame类型，滚动计算（窗口计算）
           方法	                       说明
    .rolling(w).sum()	        依次计算相邻w个元素的和(默认按列计算)
    .rolling(w).mean()	        依次计算相邻w个元素的算术平均值
    .rolling(w).var()	        依次计算相邻w个元素的方差
    .rolling(w).std()	        依次计算相邻w个元素的标准差
    .rolling(w).min() .max()	依次计算相邻w个元素的最小值和最大值'''
b # 准备数据b
b.rolling(2).sum() # 依次计算相邻2个元素(本元素与上一个元素)的和
b.rolling(3).sum() # 依次计算相邻3个元素(本元素与上两个元素)的和

''' 4.相关性分析'''
''' 相关分析函数适用于Series和DataFrame类型
      方法	    说明
    .cov()	  计算协方差矩阵
    .corr()	  计算相关系数矩阵, Pearson、Spearman、Kendall等系数'''
hprice = pd.Series([3.04,22.93,11.22,22.55,12.33],index=['2010','2011','2012','2013','2014'])
m2 = pd.Series([8.18,6.93,9.12,7.55,6.63],index=['2010','2011','2012','2013','2014'])
hprice.cov(m2) # 计算hprice和m2的协方差
hprice.corr(m2) # 计算hprice和m2的相关系数（默认为pearson相关系数）
hprice.corr(m2,method='spearman') # 计算hprice和m2的spearman相关系数

d1 = pd.DataFrame([[1,2,3,4],
                   [4,5,6,7],
                   [6,7,8,9],
                   [1,4,7,9]])
d1.index = ['a','b','c','d']
d1.columns = ['f','g','h','j']
d1.loc['c'].corr(d1.loc['b']) # 计算d1中'c'行和'b'行的pearson相关系数