【笔记】Pandas学习笔记

发表于 更新于 阅读次数：

前言

pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool,
built on top of the Python programming language.（官网）

下载依赖

1
pip3 install pandas
  • 通过openpyxl支持xlsx格式文件的读写
1
pip3 install openpyxl
  • 通过matplotlib支持图表绘制
1
pip3 install matplotlib

引入依赖

1
2
3
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Pandas维护的数据类型

  • Series：数据系列，用于保存和处理一维数据
    • 数据系列符合NumPy数据类型标准，可以使用NumPy直接处理
  • DataFrame：数据表，用于保存和处理二维数据
  • Index：索引，用于索引Series和DataFrame对象

创建Series对象

通过列表创建Series对象

1
series_object = pd.Series(data=[1, 2, 3])

自定义索引

1
series_object = pd.Series(data=[1, 2, 3], index=["index_1", "index_2", "index_3"])

通过字典创建Series对象

  • 字典中的key不要以数字开头
1
series_object = pd.Series(data={"index_1": 1, "index_2": 2, "index_3": 3})

Series对象的取值

直接取值

  • 返回数据值
1
series_object["index_1"]

花式索引

  • 返回数据系列对象
1
series_object[["index_1"]]

布尔索引

  • 返回数据系列对象
1
series_object[series_object > 0]

切片

  • 如果是下标索引
    • 获取[,)范围的数据组成新的数据系列
  • 如果是自定义索引
    • 获取[,]范围的数据组成新的数据系列
1
series_object[<index_start>:<index_end>]

Series对象的属性

获取索引对象

1
series_object.index

获取索引的值

1
series_object.index.values

获取索引的值

1
series_object.index.values

获取数据

1
series_object.values

获取元素个数

1
series_object.size

获取元素是否唯一

  • 如果有重复元素，则返回False
1
series_object.is_unique

获取是否有空值

1
series_object.hasnans

获取数据是否是单调递增

1
series_object.is_monotonic_increasing

获取数据是否是单调递减

1
series_object.is_monotonic_decreasing

Series对象的方法

求和

1
series_object.sum()

求平均数

1
series_object.mean()

求中位数

1
series_object.median()

求众数

1
series_object.mode()

求最大值

1
series_object.max()

求最小值

1
series_object.min()

求标准差

1
series_object.std()

求方差

1
series_object.var()

求4分位数

求1/4位数

1
q1 = series_object.quantile(0.25)

求3/4位数

1
q3 = series_object.quantile(0.75)

求四分位距离

1
iqr = q3 - q1

求所有描述性统计信息

1
new_series_object = series_object.describe()

删除指定位置的元素

1
series_object.drop(index=0)
1
series_object.drop(index=[1, 3])

对空值的相关操作

依次判断每个元素是否是NaN

  • 空值标记为True，非空标记为False
1
series_object.isnull()
1
series_object.isna()

依次判断每个元素是否不是NaN

  • 空值标记为False，非空标记为True
1
series_object.notnull()
1
series_object.notna()

删除NaN

1
series_object.dropna(inplace=True)
1
new_series_object = series_object.dropna()
通过布尔索引删除NaN
1
series_object[series_object.notnull()]

填充NaN

填充为指定值
1
series_object.fillna(0)
填充为就近的上一个值
1
series_object.fillna(method="ffill")
填充为就近的下一个值
1
series_object.fillna(method="bfill")
填充就近的上一个值或下一个值
1
series_object.fillna(method="ffill").fillna(method="bfill")

对重复值的相关操作

去重（Series）

遇到重复元素只保留第一项

inplace=True：在原对象上操作

1
series_object.drop_duplicates(inplace=True)
1
new_series_object = series_object.drop_duplicates()
遇到重复元素只保留最后一项
1
series_object.drop_duplicates(keep="last", inplace=True)
1
new_series_object = series_object.drop_duplicates(keep="last")
去除所有相同个数不唯一的元素
1
series_object.drop_duplicates(keep=False, inplace=True)
1
new_series_object = series_object.drop_duplicates(keep=False)
利用重复元素判断来去重
  • 将不重复的数据标记为True，并通过布尔索引摘取所有标记为True的元素
1
new_series_object = [~series_object.drop_duplicated()]

去重（ndarray）

1
ndarray_object = series_object.unique()

获取不重复元素的个数

1
series_object.nunique()

依次获取每种元素重复频率

  • 默认按照降序排序
1
series_object.value_counts()

依次判断每个元素是否重复

1
series_object.duplicated()

排序相关的操作

给索引排序

升序
1
series_object.sort_index()
1
series_object.sort_index(ascending=True)
降序
1
series_object.sort_index(ascending=False)

给值排序

升序
1
series_object.sort_values()
1
series_object.sort_values(ascending=True)
降序
1
series_object.sort_values(ascending=False)

求最大的几个值

1
series_object.nlargest(<num>)

求最小的几个值

1
series_object.nsmallest(<num>)

格式化数据为指定字符串

1
series_object.map("{:.2f}".format(x))

自动排除NaN

1
series_object.map("{:.2f}".format(x), na_action="ignore")

替换指定值

  • 没有提及的值会赋值为NaN
1
series_object.replace({"替换前的值": "替换后的值", "替换前的值": "替换后的值"})

执行回调函数

1
2
3
4
def func(x):
    return x ** 0.5 * 10

new_series_object = series_object.map(func)
使用lambda函数作为回调函数
1
new_series_object = series_object.map(lambda x: x ** 0.5 * 10)
1
new_series_object = series_object.apply(lambda x: x ** 0.5 * 10)

分组聚合

level=0：定义分组的维度

分组求和

1
new_series_object = series_object.groupby(level=0).sum()

Series对象利用封装的Matplotlib绘制图表

修改Matplotlib的字体和解决中文显示的问题

1
2
3
sns.set_theme()
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams["axes.unicode_minus"] = False

修改图表分辨率

<width>：宽，单位英寸
<height>：高，单位英寸

1
series_object.plot(kind="bar", figsize(<width>, <height>))

输出为矢量图

1
%config InlineBackground.figure_format = "svg"
1
series_object.plot(kind="bar")

绘制折线图

1
data_frame.plot(kind="line")

绘制柱状图

color=['red', '#000000']：定义颜色
y="<column_name>"：根据指定单列数据绘制图表
y=["<column_name_1>", "<column_name_2>"]：根据指定多列数据绘制图表

1
series_object.plot(kind="bar")

绘制饼图

autopct="%.2f%%"：自动显示百分比
shadow=True：添加阴影
pctdistance=1.3：百分比距离圆心的位置
wedgeprops={"width": 0.3}：形状改为环状饼图

"width": 0.3：定义环的宽度
edgecolor="white"：定义分割线颜色

1
series_object.plot(kind="pie")

创建DataFrame对象

通过构造器创建

index=[1, 2, 3]：定义行名
columns=["A", "B", "C"]：定义列名

二维列表

1
2
3
arr = [[], [], []]

data_frame_object = pd.DataFrame(arr)

二维数组

1
2
3
4
arr = [[], [], []]

ndarray_object = np.array(arr)
data_frame_object = pd.DataFrame(ndarray_object)

字典

1
2
3
4
5
6
7
dict_object = {
  "1": [1, 2, 3],
  "2": [1, 2, 3],
  "3": [1, 2, 3],
}

data_frame_object = pd.DataFrame(dict_object)

读取CSV文件

  • .tsv文件是以制表符分割的数据的.csv文件

index_col="<column_name>"：将指定列作为索引列
usecols=["<column_name_1>", "<column_name_2>"]：只获取指定列
nrows=<num>：只获取前几行的数据
skiprows=<num>：跳过前几行数据
delimiter=","、sep=","：指定CSV文件的分隔符
quotechar="\""：指定包裹数据的字符，在获取数据后会自动去除
encoding="utf-8"：指定文件编码格式

1
data_frame_object = pd.read_csv("<file>")

使用迭代器读取数据

  • 大文件不一次性加载数据到内存

iterator=True：使用迭代器读取数据
chunksize=<num>：指定迭代器每次读取的数据数

1
2
data_frame_iterator = pd.read_csv("<file>", iterator=True, chunksize=<num>)
iterator = next(data_frame_iterator)

读取Excel文件

读取xls文件需要下载依赖

1
pip3 install xlrd xlwt

读取xlsx文件需要下载依赖

1
pip3 install openpyxl

读取Excel文件

index_col=0：指定索引列，如果不指定则会额外生成一组有序数列作为索引列
sheet_name="<sheet_name>"：指定读取的工作簿名称
header=0：指定表头的索引
nrows=<num>：只获取前几行的数据
skiprows=<num>：跳过前几行数据
na_values=None：指定被视为空值的值

1
data_frame_object = pd.read_excel("<file>")

读取数据库

下载依赖

  • pymysql是纯Python库
1
pip3 install pymysql
  • mysqlclient不是纯Python库
1
pip3 install mysqlclient
  • MySQL 8.x 需要安装cryptography库
1
pip3 install cryptography
  • ORM需要安装sqlalchemy库
1
pip3 install sqlalchemy

建立连接

pymysql方式建立连接
1
conn = pymysql.connect(host="127.0.0.1", port=3306, user="<username>", password="<password>", database="<database_name>", charset="utf8mb4")
sqlalchemy方式建立连接
pymysql
1
conn = create_engine("mysql+pymysql://<username>:<password>@127.0.0.1:3306/<database_name>?charset=utf8mb4")
mysqlclient
1
conn = create_engine("mysql://<username>:<password>@127.0.0.1:3306/<database_name>?charset=utf8mb4")

读取数据库数据

index_col="<column_name>"：将指定列作为索引列

1
data_frame_object = pd.read_sql("SELECT * FROM <table_name>", conn)

通过DataFrame对象对数据表的读写

获取前几行的数据

1
data_frame_object.head(<num>)

获取后几行的数据

1
data_frame_object.tail(<num>)

获取指定列

取一个列

  • 得到Series对象
1
new_series_object = data_frame_object["<column_name>"]

取多个列

  • 得到DataFrame对象
1
new_data_frame_object = data_frame_object[["<column_name_1>", "<column_name_2>"]]

取指定行

取一个行

1
data_frame_object.loc[<column_name>]

取多个行

1
data_frame_object.loc[[<column_name>, <column_name>]]
取连续的多行
根据列名
  • 获取范围为[,]
1
data_frame_object.loc[[<column_name>:<column_name>]]
根据筛选
  • 获取范围为[, )
1
data_frame_object.iloc[<index_start>:<index_end>]

取单元格

1
data_frame_object.at[<row_name>, <column_name>]
1
data_frame_object.iat[<row_index>, <row_index>]

修改单元格的值

1
data_frame_object.at[<row_name>, <column_name>] = <value>
1
data_frame_object.iat[<row_index>, <row_index>] = <value>

末尾追加新列

新列赋值为相同值

1
data_frame_object["<new_column_name>"] = <new_value>

新列赋值为不同值

  • 新值的数组长度必须与表数据的行数相同
1
data_frame_object["<new_column_name>"] = [<new_value_1>, <new_value_2>]

末尾追加新行

为每一个是列都赋值

  • 新值的数组长度要必须与表结构的列数相同
1
data_frame_object[<index_max>+1] = [<value_1>, <value_2>]

只为指定列赋值

1
data_frame_object[<index_max>+1] = {"<column_name>": <value>}

DataFrame对象的方法

获取数据表相关信息

1
data_frame_object.info()

合并表

merge

  • 行和列都拼接
如果外联表字段名相同

how="<type>"：连接方式

inner：内连接，交集
outer：外连接，并集
left：左外连接
right：右外连接

on="<field_name>"：连接字段
suffixes=("_x", "_y")：定义如果出现重复的列的字段后缀

1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

data_frame_object_1.merge(data_frame_object_2, how="<type>", on="<field_name>")
如果外联表字段名不相同

left_on="<field_name>"：定义左表连接字段
right_on="<field_name>"：定义右表连接字段

1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

data_frame_object_1.merge(data_frame_object_2, how="<type>", left_on="<field_name>", right_on="<field_name>")
直接根据外联表索引列作为关联
1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

data_frame_object_1.merge(data_frame_object_2, how="<type>", left_on="<field_name>", right_index=True)

concat

  • 指定行拼接还是列拼接

ignore_index=True：忽略索引列的拼接，让索引延续

1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

pd.concat([data_frame_object_1, data_frame_object_2], axis=0, join="outer", ignore_index=True)

join

  • 只拼接列
  • 必须指定左表后缀或者右表后缀，也可以都指定，但是不能不指定
1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

data_frame_object_1.join(data_frame_object_2, lsuffix='_left', rsuffix='_ritht')

append

  • 只拼接行

ignore_index=True：忽略索引列的拼接，让索引延续

1
2
3
4
data_frame_object_1 = data_frame_object = pd.DataFrame([[], [], []])
data_frame_object_2 = data_frame_object = pd.DataFrame([[], [], []])

data_frame_object_1.append(data_frame_object_2, ignore_index=True)

修改列名

1
data_frame_object.rename(columns={"<old_column_name>": "<new_column_name>"}, inplace=True)
1
new_data_frame_object = data_frame_object.rename(columns={"<old_column_name>": "<new_column_name>"})

删除指定列

1
data_frame_object.drop(columns=["<column_name>"], inplace=True)
1
new_data_frame_object = data_frame_object.drop(columns=["<column_name>"])

定义索引列

1
new_data_frame_object = data_frame_object.set_index("<column_name>")

对空值的相关操作

判断空值

1
data_frame_object.isnull()
1
data_frame_object.notnull()

删除包含空值的行

1
data_frame_object.dropna()

删除包含空值的列

axis=1：指定维度

1
data_frame_object.dropna(axis=1)

填充整个表的所有空值

1
data_frame_object.fillna("<value>")

填充指定列的空值

1
data_frame_object["<column_name>"].fillna("<value>")
写入到数据表
1
data_frame_object["<column_name>"] = data_frame_object["<column_name>"].fillna("<value>")

对重复值的相关操作

根据指定列判断是否是重复的行

根据单个列判断
1
data_frame_object.duplicated("<column_name>")
根据多个列组合判断
1
data_frame_object.duplicated(["<column_name_1>", "<column_name_2>"])

去除被视为重复的行

不保留
  • 只要是被视为重复的行就都删除
1
data_frame_object.drop_duplicates("<column_name>", keep=False)
保留首行
1
data_frame_object.drop_duplicates("<column_name>")
1
data_frame_object.drop_duplicates("<column_name>", keep="first")
保留尾行
1
data_frame_object.drop_duplicates("<column_name>", keep="last")

替换

替换单个数据

1
new_data_frame_object = data_frame_object.replace("<old_value>", "<new_value>")

替换多个数据

1
new_data_frame_object = data_frame_object.replace(["<old_value_1>", "<old_value_2>"], ["<new_value_1>", "<new_value_2>"])

通过正则表达式替换

1
new_data_frame_object = data_frame_object.replace(r"<regex_pattern>", "<new_value>", regex=True)

对日期类型的相关操作

将字符串类型数据转换为日期类型

1
data_frame_object["<column_name>"] = pd.to_datetime(data_frame_object["<column_name>"])

获取日期的属性

1
data_frame_object["<column_name>"].dt.<attribute>

对字符串的相关操作

1
data_frame_object["<column_name>"].str.<attribute>

抽取

利用正则表达式作为抽取内容
  • 可以通过正则表达式的匹配组，抽取为多个列
1
data_frame_object["<column_name>"].str.extract(r"<regex_pattern>")

拆分

利用正则表达式作为分割符

expand=True：是否展开为多个列

True：展开为多个列，将数据拆分为每个列的数据
False：不展开，返回一个Series对象，每个数据是一个列表，将数据拆分为列表中的每个数据

1
data_frame_object["<column_name>"].str.split(r"<regex_pattern>", regex=True, expand=True)

筛选

利用Python语法进行筛选

1
data_frame_object.query("'<str>' in <column_name>")
1
data_frame_object.query("<column_name> == '<str_1>' or <column_name> == '<str_2>'")

利用布尔索引进行筛选

1
data_frame_object[data_frame_object.str.contains("<str_1>") | data_frame_object.str.contains("<str_2>")]

在每一个元素上执行回调函数

1
2
3
4
def func:
    pass

data_frame_object["<column_name>"].applymap(func)

转换每一个字符串元素为整型

1
data_frame_object["<column_name>"].applymap(int)

转换每一个字符串元素为浮点型

1
data_frame_object["<column_name>"].applymap(float)

调整列顺序

  • 重新定义列顺序

利用reindex函数调整列顺序

1
new_data_frame_object = data_frame_object.reindex(columns=["<column_name_1>", "<column_name_2>"])

利用reindex函数调整行顺序

1
new_data_frame_object = data_frame_object.reindex(index=["<index_name_1>", "<index_name_2>"])

利用花式索引调整列顺序

1
data_frame_object[["<column_name_1>", "<column_name_2>"]]

切割数据（分箱）

根据数值范围切割数据

right=True：定义区间

True：缺省值，左开右闭
False：左闭右开

1
pd.cut(data_frame_object["<column_name>"], bins=[0, 50, 100])
为每一段定义标签
1
pd.cut(data_frame_object["<column_name>"], bins=[0, 50, 100], labels=["low", "high"])

根据次数平均分割

1
pd.qcut(data_frame_object["<column_name>"], 2)

根据比例切割

1
pd.qcut(data_frame_object["<column_name>"], bins=[0, 0.5, 1])

将名义变量列转换为虚拟变量矩阵

  • 名义变量：没有等级的高低
1
pd.get_dummies(data_frame_object["<column_name>"])

将定序变量列转换为值

  • 定序变量：有等级的高低
1
2
3
4
5
def convert(arg):
    results = {"key_1": 1, "key_2": 2, "key_3": 3}
    return results.get(arg, 0)

data_frame_object["<column_name>"].apply(convert)

排序

  • 如果需要取最大的前几行数据或最小的前几行数据，可以使用nlargest和nsmallest函数，而不要先排序再取值，避免性能开销

根据单列排序

ascending=True：顺序

True：缺省值，升序
False：降序

1
data_frame_object.sort_values(by="<column_name>", ascending=True)

根据多列排序

1
data_frame_object.sort_values(by=["<column_name_1>", "<column_name_2>"], ascending=[True, False])

获取最大的前几行的数据

1
data_frame_object.nlargest(<num>, "<column_name>")

获取最小的前几行的数据

1
data_frame_object.nsmallest(<num>, "<column_name>")

分组聚合

先分组再求和

  • 根据<column_name_1>分组，根据<column_name_2>求和
1
new_data_frame_object = data_frame_object.groupby("<column_name_1>")["<column_name_2>"].sum()
仍然返回DataFrame
1
new_data_frame_object = data_frame_object.groupby("<column_name_1>")[["<column_name_2>"]].sum()
根据多个列分组
  • 先根据<column_name_1>分组，再根据<column_name_2>分组，最后根据<column_name_3>求和
  • 返回具有多级索引的DataFrame对象
1
new_data_frame_object = data_frame_object.groupby(["<column_name_1>", "<column_name_2>"])[["<column_name_3>"]].sum()
根据指定级索引进行分组
1
new_data_frame_object = data_frame_object.groupby(level=<level_num>)["<column_name>"].sum()

分组后求多个聚合

1
new_data_frame_object = data_frame_object.groupby("<column_name_1>")["<column_name_2>"].agg(["sum", "max", "min", "count"])
1
new_data_frame_object = data_frame_object.groupby("<column_name_1>")["<column_name_2>"].agg([np.sum, np.amax, np.amin])

得到指定组

1
new_data_frame_object = data_frame_object.groupby("<column_name_1>").get_group("<index_name>")

透视

旋转行为列作为透视表

index="<column_name_1>"：将指定列作为新表的索引
columns="<column_name_2>"：将指定列作为新表的列
values="<column_name_3>"：将指定列作为新表的值

1
new_data_frame_object = data_frame_object.pivot(index="<column_name_1>", columns="<column_name_2>", values="<column_name_3>")

直接生成透视表

aggfunc="avg"、aggfunc=np.avg：指定单个聚合函数

np.avg：缺省值，求平均数
np.sum：求和
np.max：求最大值
np.min：求最小值
aggfunc=["avg", "sum"]、aggfunc=[np.avg, np.sum]：指定多个聚合函数
fill_value=0：填充NaN值为0
margins=True：添加汇总列
margins_name="<column_name>"：指定汇总列名

1
new_data_frame_object = data_frame_object.pivot_table(index="<column_name_1>", columns="<column_name_2>", values="<column_name_3>")
1
new_data_frame_object = pd.pivot_table(data_frame_object, index="<column_name_1>", columns="<column_name_2>", values="<column_name_3>")

堆叠和反堆叠

反堆叠

  • 将具有多级索引的DataFrame转换为只有一级索引的DataFrame
1
new_data_frame_object = data_frame_object.unstack()
将指定级索引作为列
1
new_data_frame_object = data_frame_object.unstack(level=<level_num>)

堆叠

  • 重置为多级索引
1
new_data_frame_object = data_frame_object.reset_index()

重新指定索引顺序

1
new_data_frame_object = data_frame_object.reorder_levels(["<column_name_1>", "<column_name_2>"])

交换索引级别

1
new_data_frame_object = data_frame_object.swaplevel(<level_num_1>, <level_num_2>)

随机抽样

指定抽样个数

1
new_data_frame_object = data_frame_object.sample(n=<num>)

指定抽样比例

1
new_data_frame_object = data_frame_object.sample(frac=0.5)

按照时间抽样

method="ffill"：填充空值

每周抽样一天
1
new_data_frame_object = data_frame_object.asfreq("W")
每月抽样一天
  • 抽出每月最后一天作为样本
1
new_data_frame_object = data_frame_object.asfreq("M")
每隔10天取一次样本
1
new_data_frame_object = data_frame_object.asfreq("10D")
将10天的数据作为一个组
1
new_data_frame_object = data_frame_object.resample("10D").sum()

插值

  • 只能在数值型数据进行插值
  • 根据算法自动补齐空值

线性插值

1
new_data_frame_object = data_frame_object.interpolate()
1
new_data_frame_object = data_frame_object.interpolate(method="linear")

多项式插值

  • 2阶多项式插值
1
new_data_frame_object = data_frame_object.interpolate(method="polynomial", order=2)

就近填充

1
new_data_frame_object = data_frame_object.interpolate(method="pad")

复合值展开

  • 自动展开数组为多个数据

炸开单个列

1
new_data_frame_object = data_frame_object.explode("<column_name>")

炸开多个列

  • 多个列的复合值内的元素个数需要匹配，才可以同时炸开多个列
1
new_data_frame_object = data_frame_object.explode(["<column_name_1>", "<column_name_2>"])

环比

手动计算环比

  • 将数据向后移动1位
1
data_frame_object["<column_name_2>"] = data_frame_object["<column_name_1>"].shift(1)
  • 计算环比
1
(data_frame_object["<column_name_2>"] - data_frame_object["<column_name_1>"]) / data_frame_object["<column_name_1>"] * 100

直接计算环比

1
data_frame_object["<column_name_2>"] = data_frame_object["<column_name_1>"].pct_change()
格式化数据
1
data_frame_object["<column_name_2>"] = data_frame_object["<column_name_2>"].pct_change().applymap(lambda x: "0" if np.isnan(x) else f"{x * 100:.2f}%")

窗口计算

1
data_frame_object["<column_name>"] = data_frame_object["<column_name>"].rolling(<num>).mean()

协方差和相关系数

获取协方差

1
data_frame_object.cov()

获取相关系数

  • 如果相关系数是大于零，说明两个数是正相关

  • 如果相关系数是小于零，说明两个数是负相关

  • 如果相关系数是等于零或接近零，说明两个数没有相关

  • 如果相关系数的绝对值在[0.6,1]，说明两个数是强相关

  • 如果相关系数的绝对值在[0.1,0.6)，说明两个数是弱相关

  • 如果相关系数的绝对值在[0,0.1)，说明两个数没有相关

皮尔逊相关系数
  • 适用于连续值，且为正态总体
  • 数据要成对出现
计算所有数据的相关系数矩阵
1
data_frame_object.corr()
1
data_frame_object.corr("pearson")
计算指定两列的相关系数
1
np.corrcoef(data_frame_object["<column_name_1>"], data_frame_object["<column_name_2>"])
斯皮尔曼相关系数
  • 适用于等级之间的相关系数计算
1
data_frame_object.corr("spearman")

修改背景色

设置为渐变色

Reds：从白色到红色的渐变色
ReYlBu：从红色到黄色到蓝色的渐变色

1
data_frame_object.style.background_gradient("Reds")

保存为Excel文件

1
data_frame_object.to_excel("<file_name>.xlsx")

Index索引类型

多级索引

创建多级索引MultiIndex

1
multi_index_object = pd.MultiIndex.from_product(([1, 2], [3, 4]), names=["<column_name_1>", "<column_name_2>"])

日期索引

创建日期索引DatetimeIndex

手动分段

periods=12：分段数

1
datetime_index_object = pd.date_range("2020-01-01", "2020-12-01", periods=12)
以周分段
  • 以一周的开始作为得到的时间
    • 国外一周的开始为周日
1
datetime_index_object = pd.date_range("2020-01-01", "2020-12-01", freq="W")
偏移量
1
datetime_index_object = pd.date_range("2020-01-01", "2020-12-01", freq="W") + pd.DateOffset(days=1)

设置日期的时区

1
datetime_index_object = datetime_index_object.tz_localize("Asia/Shanghai")

转换日期的时区

1
datetime_index_object = datetime_index_object.tz_convert("Asia/Shanghai")

完成

参考文献

哔哩哔哩——千锋教育
哔哩哔哩——骆昊jackfrued
CSDN——一个甜甜的大橙子
CSDN——weixin_46115371
CSDN——夏日麦香