【机器学习&深度学习】02 Pandas

1 介绍

pandas 是一个 Python Data Analysis Library（数据分析库），它是基于 NumPy 的一个开源 Python 库，它被广泛用于数据分析，以及数据清洗和准备等工作。数据科学家经常和表格形式的数据（比如**.csv、.tsv、.xlsx**）打交道。Pandas 可以使用类似 SQL 的方式非常方便地加载、处理、分析这些表格形式的数据。搭配 Matplotlib 和Seaborn 效果更好。

2 数据结构

Pandas主要有两个数据结构：Series和DataFrame

区别	Series	DataFrame
介绍	列、一维数组	表格、矩阵
参数	pandas.Series( data, index, dtype, name, copy)	pandas.DataFrame( data, index, columns, dtype, copy)
参数说明	数据,索引/行标签,数据类型,名字,拷贝数据	数据,索引/行标签,列标签,数据类型,拷贝数据

2.1 Pandas.DataFrame

DataFrame 的基础属性

• df.shape # 形状，行数列数
• df.dtypes # 列数据类型
• df.ndim # 数据维度
• df.index # 行索引
• df.columns # 列索引
• df.values # 对象值，二维ndarray数组

DataFrame 的整体情况查询

• df.head() # 显示头部几行
• df.tail() # 显示尾部几行
• df.info() # 相关信息概览：行数，列数，列索引，列非空值个数，列类型，内存占用
• df.describe() # 快速综合统计结果：计数，均值，标准差，最大值，四分位数，最小值
• df.T # 转置

2.2 索引

• 列索引和行索引

  直接看代码示例

  # 备注：以下代码在E:\AI安全\anaconda_code\1_2_2.py中
  # coding: utf-8
  
  
  import numpy as np
  import pandas as pd
  
  
  # 创建一个6行4列的矩阵df1
  def create_index1():
      df1 = pd.DataFrame(np.random.randn(6, 4), index=list("abcdef"), columns=list("ABCD"))
      return df1
  
  
  # 创建一个3行4列的矩阵df2
  def create_index2():
      df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=list("abc"), columns=list("WXYZ"))
      return df2
  
  
  a = create_index1()
  b = create_index2()
  # 输出两个矩阵
  print("输出矩阵a：")
  print(a)
  print("-"*50)
  print("输出矩阵b：")
  print(b)
  # 列索引读取列----------------------------------
  # 读取单列
  print("-"*50)
  print('输出矩阵a的A列（a["A"]）：')
  print(a["A"])
  print("-"*50)
  print("输出矩阵a的A列（a.A）：")
  print(a.A)
  # 读取多列
  print("-"*50)
  print('输出矩阵a的A和C列（a[["A", "C"]]）：')
  print(a[["A", "C"]])
  # 行索引读取行----------------------------------
  print("-"*50)
  print("使用切片读取多行：a[0:3]")
  print(a[0:3])
  print("-"*50)
  print('行索引读取：a["a":"c"]')
  print(a["a":"c"])
  # 指定读取行和列----------------------------------
  print("-"*50)
  print('读取指定行和列：a["a":"c"][["A", "D"]]')
  print(a["a":"c"][["A", "D"]])# 注意这里的行用冒号，列用逗号
  # 使用.loc的方式读取行列----------------------------------
  print("-"*50)
  print('读取ac行和WY列写法一：b.loc[["a", "c"], ["W", "Y"]]')
  print(b.loc[["a", "c"], ["W", "Y"]])
  print("-"*50)
  print('读取ac行和WY列写法二：b.loc[b.index[0:2], ["W", "Y"]]')
  print(b.loc[b.index[0:2], ["W", "Y"]])
  print("-"*50)
  print('读取ac行和WY列写法三：b.loc["a": "c", "W": "Y"]')
  print(b.loc["a": "c", "W": "Y"])
  # 使用.iloc的方式读取行列----------------------------------
  print("-"*50)
  print("读取前两行：b.iloc[0:2]")
  print(b.iloc[0:2])
  print("-"*50)
  print("读取前两行：b.iloc[0:2, :]")
  print(b.iloc[0:2, :])
  

• 布尔值索引

  # 备注：以下代码在E:\AI安全\anaconda_code\1_2_2.py中
  
  # ----------------------------------布尔值索引----------------------------------
  print("-"*50)
  print("判断矩阵a中的值是否大于0:a > 0")
  print(a > 0)
  print("-"*50)
  print("判断矩阵a中的A列的值是否大于2:a['A'] > 2")
  print(a['A'] > 2)
  print("-"*50)
  print('获取所有 A 列大于0的行：a[a["A"] > 0]')
  print(a[a["A"] > 0])
  print("-"*50)
  print("输出a中大于0小于5的数：a[(a > 0) & (a < 5)]")
  print(a[(a > 0) & (a < 5)])
  

2.3 层次化索引

• Series 层次化索引

  # 备注：以下代码在E:\AI安全\anaconda_code\1_2_3.py中
  # coding: utf-8
  
  # series层次化索引
  import pandas as pd
  
  
  def index():
      data = [16, 17, 18, 20, 19, 22]
      a = pd.Series(data, index=[["first", "first", "second", "second", "third", "third"], ["male", "female", "male", "female", "male", "female"]])
      return a
  
  
  s = index()
  print("-"*50)
  print("显示矩阵s：")
  print(s)
  # 显示层次化索引--------------------------
  print("-"*50)
  print("显示层次化索引:s.index")
  print(s.index)
  

• DataFrame 层次化索引

  # 备注：以上代码在E:\AI安全\anaconda_code\1_2_4.py中
  # coding: utf-8
  
  
  import pandas as pd
  import numpy as np
  
  
  def d():
      data = np.random.randint(10, 20, (6, 9))  # [10， 20)之间的随机整数
      index = [["first", "first", "second", "second", "third", "third"], ["male", "female", "male", "female", "male", "female"]]
      columns = [["Ch", "Ch", "Ch", "Ma", "Ma", "Ma", "En", "En", "En"], ["A", "B", "C", "A", "B", "C", "A", "B", "C"]]
      df = pd.DataFrame(data, index=index, columns=columns)
      return df
  
  
  a = d()
  print("创建数组----------")
  print(a)
  # ---------------显示层次索引---------------
  print("显示行")
  print(a.index)
  print("显示列")
  print(a.columns)
  

• 按层次统计数据
  
  

2.4 数据的合并

Pandas 包的 merge、join 方法可以完成数据的合并，merge 方法主要基于两个 DataFrame 的共同列进行合并，join 方法主要基于两个 DataFrame 的索引进行合并。

• Merge：对列进行操作

  pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

  参数说明：

  • left/right：左/右位置的 DataFrame。
  • how：数据合并的方式。left：基于左 DataFrame 列的数据合并；right：基于右DataFrame列的数据合并；outer：基于列的数据外合并（取并集）；inner：基于列的数据内合并（取交集）；默认为inner。
  • on：用来合并的列名，这个参数需要保证两个 DataFrame 有相同的列名。
  • left_on/right_on：左/右 DataFrame 合并的列名，也可为索引，数组和列表。
  • left_index/right_index：是否以 index 作为数据合并的列名，True 表示是。
  • sort：根据 DataFrame 合并的 keys 排序，默认是 True。
  • suffixes: 若有相同列且该列没有作为合并的列，可通过 suffixes 设置该列的后缀名，一般为元组和列表类型。

  # 备注：以下代码在E:\AI安全\anaconda_code\2_3_1.py中
  # 数据的合并
  # coding: utf-8
  
  
  import pandas as pd
  
  
  def create_df1():
      df1 = pd.DataFrame({'key': ['s', 's', 'w', 'x', 'x', 'n', 'f', 'c'], 'data1': range(8)})
      return df1
  def create_df2():
      df2 = pd.DataFrame({'key': ['w', 'w', 's', 's', 'x', 'f'], 'data2': range(6)})
      return df2
  
  
  a = create_df1()
  b = create_df2()
  print(a)
  print("-" * 50)  # 分割线
  print(b)
  print("-" * 50)  # 分割线
  print("将两个数组内连接合并：pd.merge(a,b)")
  print(pd.merge(a, b))
  print("-" * 50)  # 分割线
  print('将两个数组外连接合并：pd.merge(a, b, how="outer", on="key")')
  print(pd.merge(a, b, how="outer", on="key"))
  
  
  
  # 备注：以下代码在E:\AI安全\anaconda_code\2_3_2.py中
  # 基于多列的连接
  # coding: utf-8
  
  
  import pandas as pd
  
  
  def create_df1():
      df1 = pd.DataFrame({'key1': ['foo', 'foo', 'bar'], 'key2': ['one', 'two', 'one'],'val': [1, 2, 3]})
      return df1
  
  
  def create_df2():
      df2 = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'], 'key2': ['one', 'one', 'one', 'two'], 'val': [4, 5, 6, 7]})
      return df2
  
  
  a = create_df1()
  b = create_df2()
  print('-'*50)
  print(a)
  print('-'*50)
  print(b)
  print('-'*50)
  print('执行多列的右连接：pd.merge(a, b, on=["key1", "key2"], how="right")')
  print(pd.merge(a, b, on=["key1", "key2"], how="right"))
  print('-'*50)
  print('执行多列的右连接：pd.merge(a, b, on=["key1", "key2"], suffixes=["_left", "_right"])')
  print(pd.merge(a, b, on=["key1", "key2"], suffixes=["_left", "_right"]))
  

• join ：对行进行操作

  DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

  参数说明：

  • other：DataFrame，或者带有名字的 Series，或者 list，如果传递的是 Series，那么其 name 属性应当是一个集合，并且该集合将会作为结果 DataFrame 的列名。
  • on：列名称，或者列名称的 list/tuple，或者类似形状的数组连接的列，默认使用索引连接。
  • how： {‘left’, ‘right’, ‘outer’, ‘inner’} , 连接的方式，默认为左连接。
  • lsuffix：String 左 DataFrame 中重复列的后缀。
  • rsuffix：String 右 DataFrame 中重复列的后缀。
  • sort：按照字典顺序对结果在连接键上排序。如果为False，连接键的顺序取决于连接类型（关键字）。

  # 备注：以下代码在E:\AI安全\anaconda_code\2_3_3.py中
  # 基于多列的连接
  # coding: utf-8
  
  
  import pandas as pd
  import numpy as np
  
  
  def create_df1():
      df1 = pd.DataFrame(np.arange(8).reshape(2, 4), index=["one", "two"], columns=list("ABCD"))
      return df1
  
  
  def create_df2():
      df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=["one", "two", "three"], columns=list("WXYZ"))
      return df2
  
  
  a = create_df1()
  b = create_df2()
  print('-'*50)
  print(a)
  print('-'*50)
  print(b)
  print('-'*50)
  print('默认情况下合并：')
  print(a.join(b))
  print('-'*50)
  print('默认情况下合并：')
  print(b.join(a))
  # 若两个矩阵列名一样，执行join会报错：ValueError: columns overlap but no suffix specified: Index(['C', 'D'], dtype='object')
  

  注意：join不会像merge一样，merge会将重名的列明自动加上_x,_y加以区分，而join直接报错。

2.5 数据的分割与拆分

Grouping分组的过程分为：

• 拆分： 进行分组的根据
• 应用： 每个分组运行的计算规则
• 合并： 把每个分组的计算结果合并起来

Grouping分组主要利用的函数：

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=<no_default>, observed=False, dropna=True)

参数说明：

• by：接收list，string，mapping，generator，用于确定分组的依据，无默认。
• axis：接收int，表示操作的轴向，默认为0，对列进行操作。
• level：接收int或者索引名，代表标签所在级别。
• as_index：表示聚合后的聚合标签是否以DataFrame索引形式输出，默认为True。
• sort：表示是否对分组依据分组标签进行排序。
• group_keys：表示是否显示分组标签的名称。
• squeeze：表示是否在允许的情况下对返回数据进行降维。

注意：用groupby方法分组后的结果并不能直接查看，而是返回一个DataFrameGroupBy对象，被存在内存中，最后返回一个内存地址

查看结果的方法：

• count：计算分组中非NA值的数量
• sum：计算非NA值的和
• mean：计算非NA值的平均值
• median：计算非NA值的算术中位数
• std、var：无偏（分母为n-1）标准差和方差
• min、max：非NA值的最小值和最大值

# 备注：以下代码在E:\AI安全\anaconda_code\2_3_4.py中
# coding: utf-8


import pandas as  pd
import numpy as np


def create_df():
    data = {"lessons": ['Ch', 'En', 'Ch', 'En', 'Ch', 'Ma', 'En', 'Ma'],
            "grade": ['A', 'A', 'B', 'B', 'C', 'A', 'C', 'B'],
            "male": np.random.randint(10, 20, 8),  # [10, 20)的8个随机整数
            "female": np.random.randint(10, 20, 8)}
    df = pd.DataFrame(data)
    return df


a = create_df()
print(a)
print('-'*50)
print("对课程lessons进行分组：a.groupby(by='lessons')")
print("并没有输出结果，而是输出内存地址")
print(a.groupby(by='lessons'))
print('-'*50)
group1 = a.groupby(by='grade')
print("输出各等级的男女生人数：")
print(group1.sum())
print('-'*50)
group2 = a.groupby(by="lessons")
print("输出每个课程的人数：")
print(group2.count())
print('-' * 50)
print("返回每个分组的元素个数")
print(group2.size())
print('-' * 50)
print("分组统计之后如果只查看男生的情况")
print(a.groupby(by=[a["lessons"], a["grade"]]).sum()["male"])

# 备注：以下代码在E:\AI安全\anaconda_code\2_3_5.py中
# 题目：现有三家公司 A B C，公司个别员工的薪资和年龄已经给出，求出 A B C 三家公司各公司员工的薪水和年龄的平均值。结果返回 DataFrame 类型。

# coding: utf-8


import pandas as  pd
import numpy as np


def create_df():
    data = {"company": ['A', 'A', 'A', 'A', 'C', 'A', 'C', 'B', 'B', 'B'],
            "saraly": [48, 58, 34, 23, 77, 67, 87, 23, 11, 10],
            "age": [48, 58, 20, 20, 77, 67, 87, 23, 50, 10]}
    df = pd.DataFrame(data)
    return df


a = create_df()
print(a)
print(a[["saraly", "age"]].groupby(by=a["company"]).mean())

3 文件读写

pandas 文件读写重点放在读取 csv 和 txt 文件上。

如果文件每一行的多 个元素是用逗号隔开的，则这种格式叫作 csv。

其他由空格或制表符分隔的列表数据通常存储在各种类型的文本文件中（扩展名一般 为 .txt )。

相关函数：

• head(n) 方法用于读取前面的 n 行，如果不填参数 n ，默认返回 5 行。

• tail(n) 方法用于读取尾部的 n 行，如果不填参数 n ，默认返回 5 行，空行各个字段的值返回 NaN。

• info() 方法返回表格的一些基本信息：

3.1 读写数据

（1）read_csv函数：读取csv数据

pd.read_csv(filepath,encoding,sep,header,names,usecols,index_col,skiprows,nrows……）

• filepath： 文件存储路径，可以用r""进行非转义限定，路径最好是纯英文（文件名也是），不然会经常碰到编码不对的问题，最方便是直接将文件存储在pandas默认的路径下，则直接输入文件名即可
• encoding: pandas默认编码是utf-8，如果是csv，且数据中有中文时，则要指定encoding=‘gbk’
• sep: 指定分割符形式，CSV默认逗号分割，可以忽略这个参数，如果是其它分割方式，则要填写
• header: 指定第一行是否是列名，通常有三种用法，忽略或header=0(表示数据第一行为列名），header=None（表明数据没有列名），常与names搭配使用
• names: 指定列名，通常用一个字符串列表表示，当header=0时，用names可以替换掉第数据中的第一行作为列名，如果header=None，用names可以增加一行作为列名，如果没有header参数时，用names会增加一行作为列名，原数据的第一行仍然保留
• usecols: 一个字符串列表，可以指定读取的列名
• index_col: 一个字符串列表，指定哪几列作为索引
• skiprows: 跳过多少行再读取数据，通常是数据不太干净，需要去除掉表头才会用到
• nrows: 仅读取多少行，后面的处理也都仅限于读取的这些行

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_1.py中
# csv文件读取
import pandas as pd

df = pd.read_csv('2_4_1.csv')

print(df.to_string())
# 使用head()方法读取文件前五行
print(df.head())
# 使用tail()方法读取文件后五行
print(df.tail())
# 返回表格的基本信息
print(df.info())

（2）read_table函数：读取txt数据

pd.read_table(filepath,encoding,sep,header,names,usecols,index_col,skiprows,nrows……）

参数月read_csv一致

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_2.py中
# txt文件读取
import pandas as pd

df = pd.read_table("2_4_2.txt", sep=",", names=list("abcde"))
print(df)

（3）to_csv方法：把数据写入 CSV 文件中并生成

DataFrame.to_csv(path_or_buf, sep, na_rep, float_format, columns, header, index...)  

• path_or_buf: 字符串或文件句柄，默认无文件路径或对象，如果没有提供，结果将返回为字符串。
• sep: 默认字符 **‘ ，’**输出文件的字段分隔符。
• na_rep : 默认为 ‘’ 浮点数格式字符串。
• float_format : 默认为 None, 浮点数格式字符串
• columns : 顺序，可选列写入.
• header : 字符串或布尔列表，默认为true,写出列名。如果给定字符串列表，则假定为列名的别名。
• index : 布尔值，默认为Ture, 写入行名称（索引）

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_2.py中
# txt文件读取
import pandas as pd

df = pd.read_table("2_4_2.txt", sep=",", names=list("abcde"))
print(df)
df.to_csv("2_4_3.csv")

3.2 缺失值数据处理/数据清洗

（1）删除缺失值

适用环境：

在遇到某列数据（标签或指标等）大量丢失时，常用的方法是将该含有过多空值的行/列删除

DataFrame.dropna函数介绍：

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数说明：

• axis: axis=0 表示 index 行, axis=1 表示 columns 列，默认为0
• how: “all” 表示这一行或列中的元素全部缺失，才删除这一行或列，“any” 表示这一行或列中只要有元素缺失，就删除这一行或列
• thresh: axis 中至少有 thresh 个非缺失值，否则删除。
• subset: 在某些列的子集中选择出现了缺失值的列删除，不在子集中的含有缺失值得列或行不会删除。
• inplace: 刷选过缺失值得新数据是存为副本还是直接在原数据上进行修改。默认是 False，即创建新的对象进行修改，原对象不变，和深复制和浅复制有些类似。

（2）填充缺失值

适应环境：

有时如果样本过少，不适合删除缺失值，常用的方法时将均值、中位值等填充进缺失值

DataFrame.fillna函数介绍：

DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)

参数说明：

• value: 需要用什么值去填充缺失值
• axis: 确定填充维度，从行开始或是从列开始
• method: ffill: 用缺失值前面的一个值代替缺失值，如果 axis =1，那么就是横向的前面的值替换后面的缺失值，如果 axis=0，那么则是上面的值替换下面的缺失值。backfill/bfill，缺失值后面的一个值代替前面的缺失值。注意这个参数不能与value同时出现
• limit: 确定填充的个数，如果 limit=2，则只填充两个缺失值。

（3）判断缺失值

• DataFrame.isna()： 判断是否 Nan，一般是数值字段的 null

• DataFrame.isnull()：主要是判断字符型是否有值， 可以判断所有的空值，但是 python 的数值字段比如 int float 为空的时候默认是 Nan

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_4.py中
# 缺失值数据处理
import pandas as pd
import numpy as np


def create_df1():
    df1 = pd.DataFrame(np.random.randn(4, 5), index=["one", "two", "three", "four"], columns=list("ABCDE"))
    # 设置缺失值
    df1.iloc[0, 2] = np.nan
    df1.iloc[[1, 3], 4] = np.nan
    return df1


def create_df2():
    df2 = pd.DataFrame(np.random.randn(4, 5), index=["one", "two", "three", "four"], columns=list("ABCDE"))
    # 设置缺失值
    df2.iloc[0, 2] = np.nan
    df2.iloc[[1, 3], 4] = np.nan
    return df2


def create_df3():
    df3 = pd.DataFrame(np.random.randn(4, 5), index=["one", "two", "three", "four"], columns=list("ABCDE"))
    # 设置缺失值
    df3.iloc[0, 2] = np.nan
    df3.iloc[[1, 3], 4] = np.nan
    return df3


a = create_df1()
b = create_df2()
c = create_df3()
print('-'*50)
# 缺失矩阵
print(a)
print('-'*50)
print("丢弃所有缺失数据的行得到新的数据：a.dropna(how='any')")
print(a.dropna(how='any'))
print('-'*50)
print("以每行均值填充数据：b.fillna(value=b.mean())")
print(b.fillna(value=b.mean()))
print('-'*50)
print("判断是否有null")
print(pd.isna(c))
print('-'*50)
print("查找缺失值的位置")
print(pd.isnull(c))

4 数据特征分析

4.1 排序

sort_index方法：在指定轴上根据索引进行排序，默认为零轴，升序

.sort_index(axis=0,ascending=True)

参数说明：

• axis: 指定要排序的轴。
• ascending : 指递增排序。

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_5.py中
# 按照索引排序
import pandas as pd
import numpy as np


def create_df1():
    df1 = pd.DataFrame(np.arange(20).reshape(4, 5), index=list("cabd"))
    return df1


a = create_df1()
print('-' * 50)
print(a)
print('-' * 50)
print("规定索引按照降序排序:a.sort_index(ascending=False)")
print(a.sort_index(ascending=False))

sort_values 方法：在指定轴上根据数值进行排序，默认为零轴，升序

Series.sort_values(axis=0, ascending=True)
DataFrame.sort_values(by, axis=0, ascending=True)

参数说明：

• by: axis ：如果axis=0，那么by=“列名”； 如果axis=1，那么by=“行名”；
• ascending ：True时递增排序，False时递减排序。

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_6.py中
# 按照数据排序
import pandas as pd
import numpy as np


def create_df1():
    df1 = pd.DataFrame(np.arange(20).reshape(4, 5), index=list("abcd"))
    return df1


a = create_df1()
print('-'*50)
print(a)
print('-'*50)
print("默认在0轴上，指定对索引为2的那一列按照降序排序")
print(a.sort_values(2, ascending=False))
print('-'*50)
print("指定在1轴上，对索引为‘c’的那一行进行降序排序")
print(a.sort_values('a', axis=1, ascending=False))

4.2 基本统计数据

适用于 Series 和 DataFrame 类型：

方法	说明
.sum()	计算数据的总和，按0轴计算，下同
.count()	非Nan值的数量
.mean() .median()	计算数据的算数平均值、算数中位数
.var() .std()	计算数据的方差、标准差
.min() .max()	计算数据的最小值、最大值

适用于 Series 类型的方法：

方法	说明
.argmin() .argmax()	计算数据最大值、最小值所在位置的索引（返回自动索引）
.idxmin() .idxmax()	计算数据最大值、最小值所在位置的索引（返回自定义索引）

适用于 Series 和 DataFrame 类型：

方法	说明
.describe()	针对0轴（各列）的统计汇总

4.3 累计统计数据

适用于 Series 和 DataFrame 类型：

方法	说明
.cumsum()	依次给出前1、2、…、n个数的和
.cumprod()	依次给出前1、2、…、n个数的积
.cummax()	依次给出前1、2、…、n个数的最大值
.cummin()	依次给出前1、2、…、n个数的最小值

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_7.py中
# 基本数据统计
import pandas as pd
import numpy as np


def create_df1():
    df1 = pd.DataFrame(np.arange(20).reshape(4, 5), index=list("cabd"))
    return df1


a = create_df1()
print('-'*50)
print(a)
print('-'*50)
print('在0轴上的均值')
print(a.mean(axis=0))
print('-'*50)
print("计算前几个数的和")
print(a.cumsum())
print('-'*50)
print("计算前几个数的积")
print(a.cumprod())
print('-'*50)
print("计算前几个数的最小值")
print(a.cummin())
print('-'*50)
print("计算前几个数的最大值")
print(a.cummax())

适用于 Series 和 DataFrame 类型，滚动计算（窗口计算）：

方法	说明
.rolling(w).sum()	依次计算相邻w个元素的和
.rolling(w).mean()	依次计算相邻w个元素的算数平均值
.rolling(w).var()	依次计算相邻w个元素的方差
.rolling(w).std()	依次计算相邻w个元素的标准差
.rolling(w).min() .max()	依次计算相邻w个元素的最小值和最大值

import pandas as pd
import numpy as np
b = pd.DataFrame(np.arange(20).reshape(4, 5), index=list("abcd"))
print(b)
print("-" * 50)
print('每一行元素都和他的上一行元素相加。（第一行的上一行为NaN，相加还为NaN）')
print(b.rolling(2).sum())
print("-" * 50)
print('    依次计算相邻w个元素的算数平均值')
print(b.rolling(2).mean())
print("-" * 50)
print('    依次计算相邻w个元素的方差')
print(b.rolling(2).var())
print("-" * 50)
print('    依次计算相邻w个元素的标准差')
print(b.rolling(2).std())
print("-" * 50)
print('    依次计算相邻w个元素的最小值')
print(b.rolling(2).min())
print("-" * 50)
print('    依次计算相邻w个元素的最大值')
print(b.rolling(2).max())
print("-" * 50)

4.4 相关性分析

什么是相关性呢，现有两个事物，表示为X和Y：

• X增大，Y增大，两个变量正相关
• X增大，Y减小，两个变量负相关
• X增大，Y无视，两个变量不变

在统计学上的度量标准为：协方差

• 协方差>0, X和Y正相关
• 协方差<0, X和Y负相关
• 协方差=0, X和Y独立

相关分析函数

适用于 Series 和 DataFrame

方法	说明
.cov()	计算协方差矩阵
.corr()	计算相关系数矩阵，Pearson、Spearman、Kendall等系数

# 备注：以下代码在E:\AI安全\anaconda_code\2_4_9.py中
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(3, 4))
print(df)
print("-" * 50)
print("计算协方差矩阵:")
print(df.cov())
print("-" * 50)
print("计算相关系数矩阵")
print(df.corr())