. 引言

Web数据提取，通常被称为Web Scraping或Web Crawling，是指从网页中自动提取信息的过程。这项技术在市场研究、数据分析、信息聚合等多个领域都有广泛的应用。Python社区提供了丰富的工具和库来支持这一技术，其中BeautifulSoup和htmltab是两个非常有用的库。

2. BeautifulSoup简介

BeautifulSoup是一个用于解析HTML和XML文档的Python库。它能够将复杂的HTML文档转换成易于使用的Python对象，从而可以方便地提取网页中的各种数据。BeautifulSoup的主要特点包括：

• 易于使用：提供了简单直观的API来查找、修改和操作解析树中的元素。
• 强大的搜索功能：支持多种搜索方法，如通过标签名、类名、ID等快速定位元素。
• 灵活的解析器支持：可以与Python标准库中的HTML解析器或第三方解析器如lxml配合使用。

3. htmltab库介绍

htmltab是一个专门用于从HTML中提取表格数据的Python库。它提供了一种简单的方式来识别和解析网页中的表格，并将它们转换为Python的列表或Pandas的DataFrame。htmltab的主要特点包括：

• 表格识别：能够自动识别网页中的表格，并支持通过CSS选择器进行更精确的定位。
• 数据转换：支持将提取的表格数据转换为多种格式，包括列表、字典和Pandas的DataFrame。
• 易用性：提供了简洁的API，使得表格数据的提取变得简单直观。

4. BeautifulSoup与htmltab的结合使用

结合使用BeautifulSoup和htmltab可以大大提高Web数据提取的效率和灵活性。以下是一个简单的示例，展示如何使用这两个库来提取Reddit子论坛中的表格数据。

4.1 准备工作

首先，确保已经安装了所需的库。如果尚未安装，可以通过pip安装：

4.2 示例代码

5. 代码解析

在上述示例中，我们首先设置了代理服务器，这对于绕过某些网站的IP封锁非常有用。然后，我们定义了一个函数get_reddit_content，它接受一个Reddit子论坛的名称作为参数，并返回该子论坛中的表格数据。 函数内部，我们使用requests.Session来发送GET请求，并设置了代理。然后，使用BeautifulSoup解析HTML内容，并利用htmltab库来提取表格数据。最后，我们检查响应状态码，如果请求成功，就打印出表格数据。

6. 结论

通过结合使用BeautifulSoup和htmltab，我们可以高效地从Web页面中提取所需的数据。这种方法不仅适用于Reddit，还可以扩展到其他任何包含表格数据的网站。然而，需要注意的是，Web数据提取应当遵守目标网站的robots.txt文件规定，尊重版权和隐私政策。

者：George Seif

编译：ronghuaiyang

导读

虽然Pandas的功能非常强大，但是对于大数据集来说，确实是很慢的。

虽然 panda 是 Python 中用于数据处理的库，但它并不是真正为了速度而构建的。了解一下新的库 Modin，Modin 是为了分布式 panda 的计算来加速你的数据准备而开发的。

Pandas是处理 Python 数据的首选库。它易于使用，并且在处理不同类型和大小的数据时非常灵活。它有大量的函数，使得操纵数据变得轻而易举。

但是有一个缺点：对于较大的数据集来说，panda“慢”。

默认情况下，panda 使用单个 CPU 内核作为单个进程执行其函数。这对于较小的数据集工作得很好，因为你可能不会注意到速度上的差异。但是，随着数据集越来越大，计算量越来越大，如果只使用单个 cpu 核，速度会受到很大的影响。它在数据集上同一时间只能计算一次，但该数据集可以有数百万甚至数十亿行。

然而，大多数用于数据科学的现代机器都有至少 2 个 CPU 核。这意味着，以 2 个 CPU 核为例，在使用 pandas 时，50%或更多的计算机处理能力在默认情况下不会执行任何操作。当你使用 4 核(现代 Intel i5)或 6 核(现代 Intel i7)时，情况会变得更糟。pandas 的设计初衷并不是为了有效利用这种计算能力。

Modin是一个新的库，通过在系统所有可用的 CPU 核上自动分配计算来加速 pandas。有了它，对于任何尺寸的 pandas 数据数据集，Modin 声称能够以 CPU 内核的数量得到近乎线性的加速。

让我们看看它是如何工作的，并通过一些代码示例进行说明。

Modin 如何用 Pandas 并行计算

给定 pandas 中的 DataFrame ，我们的目标是以尽可能快的方式对其执行某种计算或处理。可以用*.mean()取每一列的平均值，用groupby对数据进行分组，用drop_duplicates()*删除所有重复项，或者使用其他任何内置的 pandas 函数。

在前一节中，我们提到了 pandas 如何只使用一个 CPU 核进行处理。自然，这是一个很大的瓶颈，特别是对于较大的 DataFrames，计算时就会表现出资源的缺乏。

理论上，并行计算就像在每个可用的 CPU 核上的不同数据点上应用计算一样简单。对于一个 pandas 的 DataFrame，一个基本的想法是将 DataFrame 分成几个部分，每个部分的数量与你拥有的 CPU 内核的数量一样多，并让每个 CPU 核在一部分上运行计算。最后，我们可以聚合结果，这是一个计算上很 cheap 的操作。

多核系统如何更快地处理数据。对于单核进程(左)，所有10个任务都放在一个节点上。对于双核进程(右图)，每个节点承担5个任务，从而使处理速度加倍。

这正是 Modin 所做的。它将 DataFrame 分割成不同的部分，这样每个部分都可以发送到不同的 CPU 核。Modin 在行和列之间划分 DataFrame。这使得 Modin 的并行处理可扩展到任何形状的 DataFrame。

想象一下，如果给你一个列多行少的 DataFrame。有些库只执行跨行分区，在这种情况下效率很低，因为我们的列比行多。但是对于 Modin 来说，由于分区是跨两个维度进行的，所以并行处理对于所有形状的数据流都是有效的，不管它们是更宽的(很多列)、更长的(很多行)，还是两者都有。

panda的DataFrame(左)存储为一个块，只发送到一个CPU核。Modin的DataFrame(右)跨行和列进行分区，每个分区可以发送到不同的CPU核上，直到用光系统中的所有CPU核。

上面的图是一个简单的例子。Modin 实际上使用了一个“分区管理器”，它可以根据操作的类型改变分区的大小和形状。例如，可能有一个操作需要整个行或整个列。在这种情况下，“分区管理器”将以它能找到的最优方式执行分区和分配到 CPU 核上。它是非常灵活的。

为了在执行并行处理时完成大量繁重的工作，Modin 可以使用 Dask 或 Ray。它们都是使用 Python api 的并行计算库，你可以选择一个或另一个在运行时与 Modin 一起使用。Ray 目前是最安全的一个，因为它更稳定 —— Dask 后端是实验性的。

已经有足够的理论了。让我们来看看代码和速度基准测试！

Modin 速度基准测试

安装 Modin 的最简单的方法是通过 pip。下面的命令安装 Modin、Ray 和所有相关的依赖项：

pip install modin[ray]

对于我们下面的例子和 benchmarks，我们使用了 Kaggle 的 CS:GO Competitive Matchmaking Data。CSV 的每一行都包含了 CS:GO 比赛中的一轮数据。

现在，我们尝试使用最大的 CSV 文件(有几个)，esea_master_dmg_demo .part1.csv，它有 1.2GB。有了这样的体量，我们应该能够看到 pandas 有多慢，以及 Modin 是如何帮助我们加速的。对于测试，我使用一个 i7-8700k CPU，它有 6 个物理内核和 12 个线程。

我们要做的第一个测试是使用 read_csv()读取数据。Pandas 和 Modin 的代码是完全一样的。

### Read in the data with Pandas
import pandas as pd

s = time.time()
df = pd.read_csv("esea_master_dmg_demos.part1.csv")
e = time.time()
print("Pandas Loading Time = {}".format(e-s))

### Read in the data with Modin
import modin.pandas as pd

s = time.time()
df = pd.read_csv("esea_master_dmg_demos.part1.csv")
e = time.time()
print("Modin Loading Time = {}".format(e-s))

为了测量速度，我导入了time模块，并在read_csv()之前和之后放置了一个time()。panda 将数据从 CSV 加载到内存需要 8.38 秒，而 Modin 需要 3.22 秒。这是 2.6 倍的加速。对于只修改 import 语句来说，这不算太寒酸！

让我们在 DataFrame 上做一些更复杂的处理。连接多个 DataFrames 是 panda 中的一个常见操作 — 我们可能有几个或多个包含数据的 CSV 文件，然后必须一次读取一个并连接它们。我们可以使用 panda 和 Modin 中的*pd.concat()*函数轻松做到这一点。

我们希望 Modin 能够很好地处理这种操作，因为它要处理大量的数据。代码如下所示。

import pandas as pd
df = pd.read_csv("esea_master_dmg_demos.part1.csv")

s = time.time()
df = pd.concat([df for _ in range(5)])
e = time.time()
print("Pandas Concat Time = {}".format(e-s))

import modin.pandas as pd
df = pd.read_csv("esea_master_dmg_demos.part1.csv")

s = time.time()
df = pd.concat([df for _ in range(5)])
e = time.time()
print("Modin Concat Time = {}".format(e-s))

在上面的代码中，我们将 DataFrame 与自身连接了 5 次。pandas 在 3.56 秒内完成了连接操作，而 Modin 在 0.041 秒内完成，速度提高了 86.83 倍！看起来，即使我们只有 6 个 CPU 核心，DataFrame 的分区也有助于提高速度。

用于 DataFrame 清洗的 panda 函数是*.fillna()*函数。此函数查找 DataFrame 中的所有 NaN 值，并将它们替换为你选择的值。panda 必须遍历每一行和每一列来查找 NaN 值并替换它们。这是一个应用 Modin 的绝佳机会，因为我们要多次重复一个非常简单的操作。

import pandas as pd
df = pd.read_csv("esea_master_dmg_demos.part1.csv")

s = time.time()
df = df.fillna(value=0)
e = time.time()
print("Pandas Concat Time = {}".format(e-s))

import modin.pandas as pd
df = pd.read_csv("esea_master_dmg_demos.part1.csv")

s = time.time()
df = df.fillna(value=0)
e = time.time()
print("Modin Concat Time = {}".format(e-s))

这次，Pandas 运行*.fillna()*用了 1.8 秒，而 Modin 用了 0.21 秒，8.57 倍的加速！

警告！

Modin 总是这么快吗？

并不是这样。

在有些情况下，panda 实际上比 Modin 更快，即使在这个有 5,992,097(近 600 万)行的大数据集上也是如此。下表显示了我进行的一些实验中 panda 与 Modin 的运行时间。

正如你所看到的，在某些操作中，Modin 要快得多，通常是读取数据并查找值。其他操作，如执行统计计算，在 pandas 中要快得多。

使用 Modin 的实用技巧

Modin 仍然是一个相当新的库，并在不断地发展和扩大。因此，并不是所有的 pandas 功能都被完全加速了。如果你在 Modin 中尝试使用一个还没有被加速的函数，它将默认为 panda，因此不会有任何代码错误或错误。

默认情况下，Modin 将使用计算机上所有可用的 CPU 内核。在某些情况下，你可能希望限制 Modin 可以使用的 CPU 内核的数量，特别是如果你希望在其他地方使用这种计算能力。我们可以通过 Ray 中的初始化设置来限制 Modin 可以访问的 CPU 内核的数量，因为 Modin 在后端使用它。

import ray
ray.init(num_cpus=4)
import modin.pandas as pd

在处理大数据时，数据集的大小超过系统上的内存(RAM)的情况并不少见。Modin 有一个特殊的标志，我们可以设置为“true”，这将使其进入“out of core”模式。这意味着 Modin 将使用你的磁盘作为你的内存溢出存储，允许你处理比你的 RAM 大得多的数据集。我们可以设置以下环境变量来启用此功能：

export MODIN_OUT_OF_CORE=true

总结

这就是使用 Modin 加速 panda 函数的指南。只需修改 import 语句就可以很容易地做到这一点。希望你发现 Modin 至少在一些情况下对加速 panda有用。

英文原文：https://www.kdnuggets.com/2019/11/speed-up-pandas-4x.html

读：Pandas 是一个强大的分析结构化数据的工具集，它的使用基础是 Numpy（提供高性能的矩阵运算），用于数据挖掘和数据分析，同时也提供数据清洗功能。

本文收集了 Python 数据分析库 Pandas 及相关工具的日常使用方法，备查，持续更新中。

作者：李庆辉

来源：华章科技

缩写说明：

• df：任意的 Pandas DataFrame 对象
• s：任意的 Pandas Series 对象
• 注：有些属性方法 df 和 s 都可以使用

推荐资源：

• pandas 在线教程
• https://www.gairuo.com/p/pandas-tutorial
• 书籍 《深入浅出Pandas：利用Python进行数据处理与分析》

01 环境搭建

# https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/
# https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/
# https://docs.conda.io/en/latest/miniconda.html
# excel 处理相关包 xlrd / openpyxl / xlsxwriter
# 解析网页包 requests / lxml / html5lib / BeautifulSoup4
# 计算包：scipy
pip install jupyter pandas matplotlib
# 国外网络慢，可指定国内源快速下载安装
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

Conda 多 Python 版本环境：

# 创建新环境，<环境名称>, python 版本
conda create -n py39 python=3.9
# 删除环境
conda remove -n py39 --all
# 进入、激活环境
conda activate py39
# 退出环境
conda deactivate
# 查看所有虚拟环境及当前环境
conda info -e

02 Jupyter Notebook 快捷键

启动 Jupyter Notebook：jupyter notebook

快捷键及功能：

• <tab>：代码提示
• Shift+ Enter：执行本行并定位到新增的行
• Shift+Tab(1-3次)：查看函数方法说明
• D, D：双击 D 删除本行
• A / B：向上 / 下增加一行
• M / Y：Markdown / 代码模式

03 导入库包

import pandas as pd # 最新为 1.4.1 版本 (2022-02-12)
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

04 导入数据

# 从 CSV 文件导入数据
pd.read_csv('file.csv', name=['列名','列名2'])
# 从限定分隔符的文本文件导入数据
pd.read_table(filename, header=0)
# Excel 导入，指定 sheet 和表头
pd.read_excel('file.xlsx', sheet_name=' 表1', header=0)
# 从 SQL 表/库导入数据
pd.read_sql(query, connection_object)
# 从 JSON 格式的字符串导入数据
pd.read_json(json_string)
# 解析 URL、字符串或者 HTML 文件，抽取其中的 tables 表格
pd.read_html(url)
# 从你的粘贴板获取内容，并传给 read_table()
pd.read_clipboard()
# 从字典对象导入数据，Key 是列名，Value是数据
pd.DataFrame(dict)
# 导入字符串
from io import StringIO
pd.read_csv(StringIO(web_data.text))

05 导出输出数据

# 导出数据到CSV文件
df.to_csv('filename.csv')
# 导出数据到Excel文件
df.to_excel('filename.xlsx', index=True)
# 导出数据到 SQL 表
df.to_sql(table_name, connection_object)
# 以Json格式导出数据到文本文件
df.to_json(filename)
# 其他
df.to_html() # 显示 HTML 代码
df.to_markdown() # 显示 markdown 代码
df.to_string() # 显示格式化字符
df.to_latex(index=False) # LaTeX tabular, longtable
df.to_dict('split') # 字典, 格式 list/series/records/index
df.to_clipboard(sep=',', index=False) # 存入系统剪贴板

# 将两个表格输出到一个excel文件里面,导出到多个 sheet
writer=pd.ExcelWriter('new.xlsx')
df_1.to_excel(writer,sheet_name='第一个', index=False)
df_2.to_excel(writer,sheet_name='第二个', index=False)
writer.save() # 必须运行writer.save()，不然不能输出到本地

# 写法2
with pd.ExcelWriter('new.xlsx') as writer:
df1.to_excel(writer, sheet_name='第一个')
df2.to_excel(writer, sheet_name='第二个')
# 用 xlsxwriter 导出支持合并单元格、颜色、图表等定制功能
# https://xlsxwriter.readthedocs.io/working_with_pandas.html

06 创建测试对象

# 创建20行5列的随机数组成的 DataFrame 对象
pd.DataFrame(np.random.rand(20,5))
# 从可迭代对象 my_list 创建一个 Series 对象
pd.Series(my_list)
# 增加一个日期索引
df.index = pd.date_range('1900/1/30', periods=df.shape[0])
# 创建随机数据集
df = pd.util.testing.makeDataFrame()
# 创建随机日期索引数据集
df = pd.util.testing.makePeriodFrame()
df = pd.util.testing.makeTimeDataFrame()
# 创建随机混合类型数据集
df = pd.util.testing.makeMixedDataFrame()

07 查看、检查、统计、属性

df.head(n) # 查看 DataFrame 对象的前n行
df.tail(n) # 查看 DataFrame 对象的最后n行
df.sample(n) # 查看 n 个样本，随机
df.shape # 查看行数和列数
df.info() # 查看索引、数据类型和内存信息
df.describe() # 查看数值型列的汇总统计
df.dtypes # 查看各字段类型
df.axes # 显示数据行和列名
df.mean() # 返回所有列的均值
df.mean(1) # 返回所有行的均值，下同
df.corr() # 返回列与列之间的相关系数
df.count() # 返回每一列中的非空值的个数
df.max() # 返回每一列的最大值
df.min() # 返回每一列的最小值
df.median() # 返回每一列的中位数
df.std() # 返回每一列的标准差
df.var() # 方差
s.mode() # 众数
s.prod() # 连乘
s.cumprod() # 累积连乘,累乘
df.cumsum(axis=0) # 累积连加,累加
s.nunique() # 去重数量，不同值的量
df.idxmax() # 每列最大的值的索引名
df.idxmin() # 最小
df.columns # 显示所有列名
df.team.unique() # 显示列中的不重复值
# 查看 Series 对象的唯一值和计数, 计数占比: normalize=True
s.value_counts(dropna=False)
# 查看 DataFrame 对象中每一列的唯一值和计数
df.apply(pd.Series.value_counts)
df.duplicated() # 重复行
df.drop_duplicates() # 删除重复行
# set_option、reset_option、describe_option 设置显示要求
pd.get_option()
# 设置行列最大显示数量，None 为不限制
pd.options.display.max_rows = None
pd.options.display.max_columns = None
df.col.argmin() # 最大值[最小值 .argmax()] 所在位置的自动索引
df.col.idxmin() # 最大值[最小值 .idxmax()] 所在位置的定义索引
# 累计统计
ds.cumsum() # 前边所有值之和
ds.cumprod() # 前边所有值之积
ds.cummax() # 前边所有值的最大值
ds.cummin() # 前边所有值的最小值
# 窗口计算(滚动计算)
ds.rolling(x).sum() #依次计算相邻x个元素的和
ds.rolling(x).mean() #依次计算相邻x个元素的算术平均
ds.rolling(x).var() #依次计算相邻x个元素的方差
ds.rolling(x).std() #依次计算相邻x个元素的标准差
ds.rolling(x).min() #依次计算相邻x个元素的最小值
ds.rolling(x).max() #依次计算相邻x个元素的最大值

08 数据清理

df.columns = ['a','b','c'] # 重命名列名
df.columns = df.columns.str.replace(' ', '_') # 列名空格换下划线
df.loc[df.AAA >= 5, ['BBB', 'CCC']] = 555 # 替换数据
df['pf'] = df.site_id.map({2: '小程序', 7:'M 站'}) # 将枚举换成名称
pd.isnull() # 检查DataFrame对象中的空值，并返回一个 Boolean 数组
pd.notnull() # 检查DataFrame对象中的非空值，并返回一个 Boolean 数组
df.drop(['name'], axis=1) # 删除列
df.drop([0, 10], axis=0) # 删除行
del df['name'] # 删除列
df.dropna() # 删除所有包含空值的行
df.dropna(axis=1) # 删除所有包含空值的列
df.dropna(axis=1,thresh=n) # 删除所有小于 n 个非空值的行
df.fillna(x) # 用x替换DataFrame对象中所有的空值
df.fillna(value={'prov':'未知'}) # 指定列的空值替换为指定内容
s.astype(float) # 将Series中的数据类型更改为 float 类型
df.index.astype('datetime64[ns]') # 转化为时间格式
s.replace(1, 'one') # 用 ‘one’ 代替所有等于 1 的值
s.replace([1, 3],['one','three']) # 用'one'代替 1，用 'three' 代替 3
df.rename(columns=lambda x: x + 1) # 批量更改列名
df.rename(columns={'old_name': 'new_name'}) # 选择性更改列名
df.set_index('column_one') # 更改索引列
df.rename(index=lambda x: x + 1) # 批量重命名索引
# 重新命名表头名称
df.columns = ['UID', '当前待打款金额', '认证姓名']
df['是否设置提现账号'] = df['状态'] # 复制一列
df.loc[:, ::-1] # 列顺序反转
df.loc[::-1] # 行顺序反转, 下方为重新定义索引
df.loc[::-1].reset_index(drop=True)

09 数据处理：Filter、Sort

# 保留小数位，四舍六入五成双
df.round(2) # 全部
df.round({'A': 1, 'C': 2}) # 指定列
df['Name'] = df.Name # 取列名的两个方法
df[df.index == 'Jude'] # 按索引查询要用 .index
df[df[col] > 0.5] # 选择col列的值大于0.5的行
# 多条件查询
df[(df['team'] == 'A') &
( df['Q1'] > 80) &
df.utype.isin(['老客', '老访客'])]
# 筛选为空的内容
df[df.order.isnull()]
# 类似 SQL where in
df[df.team.isin('A','B')]
df[(df.team=='B') & (df.Q1 == 17)]
df[~(df['team'] == 'A') | ( df['Q1'] > 80)] # 非，或
df[df.Name.str.contains('张')] # 包含字符
df.sort_values(col1) # 按照列col1排序数据，默认升序排列
df.col1.sort_values() # 同上, -> s
df.sort_values(col2, ascending=False) # 按照列 col1 降序排列数据
# 先按列col1升序排列，后按col2降序排列数据
df.sort_values([col1,col2], ascending=[True,False])
df2 = pd.get_dummies(df, prefix='t_') # 将枚举的那些列带枚举转到列上
s.set_index().plot()
# 多索引处理
dd.set_index(['utype', 'site_id', 'p_day'], inplace=True)
dd.sort_index(inplace=True) # 按索引排序
dd.loc['新访客', 2, '2019-06-22'].plot.barh() # loc 中按顺序指定索引内容
# 前100行, 不能指定行，如：df[100]
df[:100]
# 只取指定行
df1 = df.loc[0:, ['设计师ID', '姓名']]
# 将ages平分成5个区间并指定 labels
ages = np.array([1,5,10,40,36,12,58,62,77,89,100,18,20,25,30,32])
pd.cut(ages, [0,5,20,30,50,100],
labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])

daily_index.difference(df_work_day.index) # 取出差别
# 格式化
df.index.name # 索引的名称 str
df.columns.tolist()
df.values.tolist()
df.总人口.values.tolist()
data.apply(np.mean) # 对 DataFrame 中的每一列应用函数 np.mean
data.apply(np.max,axis=1) # 对 DataFrame 中的每一行应用函数 np.max
df.insert(1, 'three', 12, allow_duplicates=False) # 插入列 (位置、列名、[值])
df.pop('class') # 删除列
# 增加一行
df.append(pd.DataFrame({'one':2,
'two':3,
'three': 4.4},
index=['f']),
sort=True)
# 指定新列
iris.assign(sepal_ratio=iris['SepalWidth'] / iris['SepalLength']).head()
df.assign(rate=lambda df: df.orders/df.uv)
# shift 函数是对数据进行平移动的操作
df['增幅'] = df['国内生产总值'] - df['国内生产总值'].shift(-1)
df.tshift(1) # 时间移动，按周期
# 和上相同，diff 函数是用来将数据进行移动之后与原数据差
# 异数据，等于 df.shift()-df
df['增幅'] = df['国内生产总值'].diff(-1)
# 留存数据，因为最大一般为数据池
df.apply(lambda x: x/x.max(), axis=1)

# 取 best 列中值为列名的值写到 name 行上
df['value'] = df.lookup(df['name'], df['best'])

s.where(s > 1, 10) # 满足条件下数据替换（10，空为 NaN）
s.mask(s > 0) # 留下满足条件的，其他的默认为 NaN
# 所有值加 1 (加减乘除等)
df + 1 / df.add(1)
# 管道方法，链式调用函数，f(df)=df.pipe(f)
def gb(df, by):
result = df.copy()
result = result.groupby(by).sum()
return result 
# 调用
df.pipe(gb, by='team')
# 窗口计算 '2s' 为两秒
df.rolling(2).sum()
# 在窗口结果基础上的窗口计算
df.expanding(2).sum()
# 超出（大于、小于）的值替换成对应值
df.clip(-4, 6)
# AB 两列想加增加 C 列
df['C'] = df.eval('A+B')
# 和上相同效果
df.eval('C = A + B', inplace=True)
# 数列的变化百分比
s.pct_change(periods=2)
# 分位数, 可实现时间的中间点
df.quantile(.5)
# 排名 average, min,max,first，dense, 默认 average
s.rank()
# 数据爆炸，将本列的类列表数据和其他列的数据展开铺开
df.explode('A')
# 枚举更新
status = {0:'未执行', 1:'执行中', 2:'执行完毕', 3:'执行异常'}
df['taskStatus'] = df['taskStatus'].apply(status.get)
df.assign(金额=0) # 新增字段
df.loc[('bar', 'two'), 'A'] # 多索引查询
df.query('i0 == "b" & i1 == "b"') # 多索引查询方法 2
# 取多索引中指定级别的所有不重复值
df.index.get_level_values(2).unique()
# 去掉为零小数，12.00 -> 12
df.astype('str').applymap(lambda x: x.replace('.00', ''))
# 插入数据，在第三列加入「两倍」列
df.insert(3, '两倍', df['值']*2)
# 枚举转换
df['gender'] = df.gender.map({'male':'男', 'female':'女'})
# 增加本行之和列
df['Col_sum'] = df.apply(lambda x: x.sum(), axis=1)
# 对指定行进行加和
col_list= list(df)[2:] # 取请假范围日期
df['总天数'] = df[col_list].sum(axis=1) # 计算总请假天数
# 对列求和，汇总
df.loc['col_sum'] = df.apply(lambda x: x.sum())
# 按指定的列表顺序显示
df.reindex(order_list)
# 按指定的多列排序
df.reindex(['col_1', 'col_5'], axis="columns")

10 数据选取

df[col] # 根据列名，并以Series的形式返回列
df[[col1, col2]] # 以DataFrame形式返回多列
df.loc[df['team'] == 'B',['name']] # 按条件查询，只显示name 列
s.iloc[0] # 按位置选取数据
s.loc['index_one'] # 按索引选取数据
df.loc[0,'A':'B'] # A到 B 字段的第一行 
df.loc[2018:1990, '第一产业增加值':'第三产业增加值']
df.loc[0,['A','B']] # d.loc[位置切片, 字段]
df.iloc[0,:] # 返回第一行, iloc 只能是数字
df.iloc[0,0] # 返回第一列的第一个元素
dc.query('site_id > 8 and utype=="老客"').head() # 可以 and or / & |
# 迭代器及使用
for idx,row in df.iterrows(): row['id']
# 迭代器对每个元素进行处理
df.loc[i,'链接'] = f'http://www.gairuo.com/p/{slug}.html'
for i in df.Name:print(i) # 迭代一个列
# 按列迭代，[列名, 列中的数据序列 S（索引名 值)]
for label, content in df.items():print(label, content)
# 按行迭代，迭代出整行包括索引的类似列表的内容，可row[2]取
for row in df.itertuples():print(row)
df.at[2018, '总人口'] # 按行列索引名取一个指定的单个元素
df.iat[1, 2] # 索引和列的编号取单个元素
s.nlargest(5).nsmallest(2) # 最大和最小的前几个值
df.nlargest(3, ['population', 'GDP'])
df.take([0, 3]) # 指定多个行列位置的内容
# 按行列截取掉部分内容，支持日期索引标签
ds.truncate(before=2, after=4)
# 将 dataframe 转成 series
df.iloc[:,0]
float(str(val).rstrip('%')) # 百分数转数字
df.reset_index(inplace=True) # 取消索引

11 数据处理 GroupBy 透视

df.groupby(col) # 返回一个按列col进行分组的Groupby对象
df.groupby([col1,col2]) # 返回一个按多列进行分组的Groupby对象
df.groupby(col1)[col2] # 返回按列col1进行分组后，列col2的均值
# 创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表
df.pivot_table(index=col1,
values=[col2,col3],
aggfunc=max,
as_index=False)
# 同上
df.pivot_table(index=['site_id', 'utype'],
values=['uv_all', 'regist_num'],
aggfunc=['max', 'mean'])
df.groupby(col1).agg(np.mean) # 返回按列col1分组的所有列的均值
# 按列将其他列转行
pd.melt(df, id_vars=["day"], var_name='city', value_name='temperature')
# 交叉表是用于统计分组频率的特殊透视表
pd.crosstab(df.Nationality,df.Handedness)
# groupby 后排序，分组 agg 内的元素取固定个数
(
df[(df.p_day >= '20190101')]
.groupby(['p_day', 'name'])
.agg({'uv':sum})
.sort_values(['p_day','uv'], ascending=[False, False])
.groupby(level=0).head(5) # 每天取5个页面
.unstack()
.plot()
)
# 合并查询经第一个看（max, min, last, size:数量）
df.groupby('结算类型').first()
# 合并明细并分组统计加总（'max', `mean`, `median`,
# `prod`, `sum`, `std`,`var`, 'nunique'）,'nunique'为去重的列表
df1 = df.groupby(by='设计师ID').agg({'结算金额':sum})
df.groupby(by=df.pf).ip.nunique() # groupby distinct, 分组+去重数
df.groupby(by=df.pf).ip.value_counts() # groupby 分组+去重的值及数量
df.groupby('name').agg(['sum', 'median', 'count'])

12 数据合并

# 合并拼接行
# 将df2中的行添加到df1的尾部
df1.append(df2)
# 指定列合并成一个新表新列
ndf = (df['提名1']
.append(df['提名2'], ignore_index=True)
.append(df['提名3'], ignore_index=True))
ndf = pd.DataFrame(ndf, columns=(['姓名']))
# 将df2中的列添加到df1的尾部
df.concat([df1, df2], axis=1)

# 合并文件的各行
df1 = pd.read_csv('111.csv', sep='\t')
df2 = pd.read_csv('222.csv', sep='\t')
excel_list = [df1, df2]
# result = pd.concat(excel_list).fillna('')[:].astype('str')
result = pd.concat(excel_list)[]
result.to_excel('333.xlsx', index=False)

# 合并指定目录下所有的 excel (csv) 文件
import glob
files = glob.glob("data/cs/*.xls")
dflist = []
for i in files:
dflist.append(pd.read_excel(i, usecols=['ID', '时间', '名称']))

df = pd.concat(dflist)

# 合并增加列
# 对df1的列和df2的列执行SQL形式的join
df1.join(df2,on=col1,how='inner')
# 用 key 合并两个表
df_all = pd.merge(df_sku, df_spu, 
how='left',
left_on=df_sku['product_id'],
right_on=df_spu['p.product_id'])

13 时间处理 时间序列

# 时间索引
df.index = pd.DatetimeIndex(df.index)
# 时间只保留日期
df['date'] = df['time'].dt.date
# 将指定字段格式化为时间类型
df["date"] = pd.to_datetime(df['时间'])
# 转化为北京时间
df['time'] = df['time'].dt.tz_convert('Asia/Shanghai')
# 转为指定格式，可能会失去秒以后的精度
df['time'] = df['time'].dt.strftime("%Y-%m-%d %H:%M:%S")
dc.index = pd.to_datetime(dc.index, format='%Y%m%d', errors='ignore')
# 时间，参与运算
pd.DateOffset(days=2)
# 当前时间
pd.Timestamp.now()
pd.to_datetime('today')
# 判断时间是否当天
pd.datetime.today().year == df.start_work.dt.year
df.time.astype('datetime64[ns]').dt.date == pd.to_datetime('today')
# 定义个天数
import datetime
days = lambda x: datetime.timedelta(days=x)
days(2)
# 同上，直接用 pd 包装的
pd.Timedelta(days=2)
# unix 时间戳
pd.to_datetime(ted.film_date, unit='ms')
# 按月（YMDHminS）采集合计数据
df.set_index('date').resample('M')['quantity'].sum()
df.set_index('date').groupby('name')['ext price'].resample("M").sum()
# 按天汇总，index 是 datetime 时间类型
df.groupby(by=df.index.date).agg({'uu':'count'})
# 按周汇总
df.groupby(by=df.index.weekday).uu.count()
# 按月进行汇总
df.groupby(['name', pd.Grouper(key='date', freq='M')])['ext price'].sum()
# 按月进行汇总
df.groupby(pd.Grouper(key='day', freq='1M')).sum()
# 按照年度，且截止到12月最后一天统计 ext price 的 sum 值
df.groupby(['name', pd.Grouper(key='date', freq='A-DEC')])['ext price'].sum()
# 按月的平均重新采样
df['Close'].resample('M').mean()
# https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases
# 取时间范围，并取工作日
rng = pd.date_range(start="6/1/2016",end="6/30/2016",freq='B')
# 重新定时数据频度，按一定补充方法
df.asfreq('D', method='pad')
# 时区，df.tz_convert('Europe/Berlin')
df.time.tz_localize(tz='Asia/Shanghai')
# 转北京时间
df['Time'] = df['Time'].dt.tz_localize('UTC').dt.tz_convert('Asia/Shanghai')
# 查看所有时区
from pytz import all_timezones
print (all_timezones)
# 时长，多久，两个时间间隔时间，时差
df['duration'] = pd.to_datetime(df['end']) - pd.to_datetime(df['begin'])
# 指定时间进行对比
df.Time.astype('datetime64[ns]') < pd.to_datetime('2019-12-11 20:00:00', format='%Y-%m-%d %H:%M:%S')

14 常用备忘

# 解决科学计数法问题
df = pd.read_csv('111.csv', sep='\t').fillna('')[:].astype('str')
# 和订单量相关性最大到小显示
dd.corr().total_order_num.sort_values(ascending=False)

# 解析列表、json 字符串
import ast
ast.literal_eval("[{'id': 7, 'name': 'Funny'}]")

# Series apply method applies a function to
# every element in a Series and returns a Series
ted.ratings.apply(str_to_list).head()
# lambda is a shorter alternative
ted.ratings.apply(lambda x: ast.literal_eval(x))
# an even shorter alternative is to apply the 
# function directly (without lambda)
ted.ratings.apply(ast.literal_eval)
# 索引 index 使用 apply()
df.index.to_series().apply()

15 样式显示

# https://pbpython.com/styling-pandas.html
df['per_cost'] = df['per_cost'].map('{:,.2f}%'.format) # 显示%比形式
# 指定列表（值大于0）加背景色
df.style.applymap(lambda x: 'background-color: grey' if x>0 else '',
subset=pd.IndexSlice[:, ['B', 'C']])

# 最大值最小值加背景色
df.style.highlight_max(color='lightgreen').highlight_min(color='#cd4f39')
df.style.format('{:.2%}', subset=pd.IndexSlice[:, ['B']]) # 显示百分号

# 指定各列的样式
format_dict = {'sum':'${0:,.0f}',
'date': '{:%Y-%m}',
'pct_of_total': '{:.2%}'
'c': str.upper}

# 一次性样式设置
(df.style.format(format_dict) # 多种样式形式
.hide_index()
# 指定列按颜色深度表示值大小, cmap 为 matplotlib colormap
.background_gradient(subset=['sum_num'], cmap='BuGn')
# 表格内作横向 bar 代表值大小
.bar(color='#FFA07A', vmin=100_000, subset=['sum'], align='zero')
# 表格内作横向 bar 代表值大小
.bar(color='lightgreen', vmin=0, subset=['pct_of_total'], align='zero')
# 下降（小于0）为红色, 上升为绿色
.bar(color=['#ffe4e4','#bbf9ce'], vmin=0, vmax=1, subset=['增长率'], align='zero')
# 给样式表格起个名字
.set_caption('2018 Sales Performance')
.hide_index())

# 按条件给整行加背景色（样式）
def background_color(row):
if row.pv_num >= 10000:
return ['background-color: red'] * len(row)
elif row.pv_num >= 100:
return ['background-color: yellow'] * len(row)
return [''] * len(row)
# 使用
df.style.apply(background_color, axis=1)

16 表格中的直方图，sparkline 图形

import sparklines
import numpy as np
def sparkline_str(x):
bins=np.histogram(x)[0]
sl = ''.join(sparklines.sparklines(bins))
return sl
sparkline_str.__name__ = "sparkline"
# 画出趋势图，保留两位小数
df.groupby('name')['quantity', 'ext price'].agg(['mean', sparkline_str]).round(2)

# sparkline 图形
# https://hugoworld.wordpress.com/2019/01/26/sparklines-in-jupyter-notebooks-ipython-and-pandas/
def sparkline(data, figsize=(4, 0.25), **kwargs):
"""
creates a sparkline
"""

# Turn off the max column width so the images won't be truncated
pd.set_option('display.max_colwidth', -1)

# Turning off the max column will display all the data
# if gathering into sets / array we might want to restrict to a few items
pd.set_option('display.max_seq_items', 3)

#Monkey patch the dataframe so the sparklines are displayed
pd.DataFrame._repr_html_ = lambda self: self.to_html(escape=False)

from matplotlib import pyplot as plt
import base64
from io import BytesIO

data = list(data)

*_, ax = plt.subplots(1, 1, figsize=figsize, **kwargs)
ax.plot(data)
ax.fill_between(range(len(data)), data, len(data)*[min(data)], alpha=0.1)
ax.set_axis_off()

img = BytesIO()
plt.savefig(img)
plt.close()
return '<img src="data:image/png;base64, {}" />'.format(base64.b64encode(img.getvalue()).decode())

# 使用
df.groupby('name')['quantity', 'ext price'].agg(['mean', sparkline])
df.apply(sparkline, axis=1) # 仅支持横向数据画线，可做 T 转置

17 可视化

kind : str

• 'line' : line plot (default)
• 'bar' : vertical bar plot
• 'barh' : horizontal bar plot
• 'hist' : histogram
• 'box' : boxplot
• 'kde' : Kernel Density Estimation plot
• 'density' : same as 'kde'
• 'area' : area plot
• 'pie' : pie plot

常用方法：

df88.plot.bar(y='rate', figsize=(20, 10)) # 图形大小，单位英寸
df_1[df_1.p_day > '2019-06-01'].plot.bar(x='p_day', y=['total_order_num','order_user'], figsize=(16, 6)) # 柱状图
# 每条线一个站点，各站点的 home_remain, stack的意思是堆叠，堆积
# unstack 即“不要堆叠”
(df[(df.p_day >= '2019-05-1') & (df.utype == '老客')].groupby(['p_day', 'site_id'])['home_remain'].sum().unstack().plot.line())
# 折线图，多条, x 轴默认为 index
dd.plot.line(x='p_day', y=['uv_all', 'home_remain'])
dd.loc['新访客', 2].plot.scatter(x='order_user', y='paid_order_user') # 散点图
dd.plot.bar(color='blue') # 柱状图, barh 为横向柱状图
sns.heatmap(dd.corr()) # 相关性可视化
# 刻度从0开始，指定范围 ylim=(0,100), x 轴相同
s.plot.line(ylim=0)

# 折线颜色 https://matplotlib.org/examples/color/named_colors.html
# 样式( '-','--','-.',':' )
# 折线标记 https://matplotlib.org/api/markers_api.html
# grid=True 显示刻度 etc: https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html
s.plot.line(color='green', linestyle='-', marker='o')

# 两个图绘在一起
[df['数量'].plot.kde(), df['数量'].plot.hist()]

# 对表中的数据按颜色可视化
import seaborn as sns
cm = sns.light_palette("green", as_cmap=True)
df.style.background_gradient(cmap=cm, axis=1)

# 将数据转化为二维数组
[i for i in zip([i.strftime('%Y-%m-%d') for i in s.index.to_list()], s.to_list())]

# 和 plot 用法一样 https://hvplot.pyviz.org/user_guide/Plotting.html
import hvplot.pandas

# 打印 Sqlite 建表语句
print(pd.io.sql.get_schema(fdf, 'table_name'))

18 Jupyter notebooks 问题

# jupyter notebooks plt 图表配置
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (15.0, 8.0) # 固定显示大小
plt.rcParams['font.family'] = ['sans-serif'] # 显示中文问题
plt.rcParams['font.sans-serif'] = ['SimHei'] # 显示中文问题

# 输出单行全部变量
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all'

# jupyter notebooks 页面自适应宽度
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))
# 背景白色 <style>#notebook_panel {background: #ffffff;}</style>

# jupyter notebooks 嵌入页面内容
from IPython.display import IFrame
IFrame('https://arxiv.org/pdf/1406.2661.pdf', width=800, height=450)

# Markdown 一个 cell 不支持多张粘贴图片
# 一个文件打印打开只显示一张图片问题解决
# /site-packages/notebook/static/notebook/js/main.min.js var key 处
# 33502、33504 行
key = utils.uuid().slice(2,6)+encodeURIandParens(blob.name);
key = utils.uuid().slice(2,6)+Object.keys(that.attachments).length;
# https://github.com/ihnorton/notebook/commit/55687c2dc08817da587977cb6f19f8cc0103bab1

# 多行输出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all' #默认为'last'

# 执行 shell 命令: ! <命令语句>

# 在线可视化工具
https://plot.ly/create

19 Slideshow 幻灯片

安装 RISE 库：pip install RISE

• [Alt+r] 播放/退出播放
• 「,」逗号隐藏左侧两个大操作按钮，「t」总览 ppt，「/」黑屏
• Slide：主页面，通过按左右方向键进行切换。
• Sub-Slide：副页面，通过按上下方向键进行切换。全屏
• Fragment：一开始是隐藏的，按空格键或方向键后显示，实现动态效果。在一个页面
• Skip：在幻灯片中不显示的单元。
• Notes：作为演讲者的备忘笔记，也不在幻灯片中显示。

关于作者：李庆辉，数据产品专家，某电商公司数据产品团队负责人，擅长通过数据治理、数据分析、数据化运营提升公司的数据应用水平。

精通Python数据科学及Python Web开发，曾独立开发公司的自动化数据分析平台，参与教育部“1+X”数据分析（Python）职业技能等级标准评审。

中国人工智能学会会员，企业数字化、数据产品和数据分析讲师，在个人网站“盖若”上编写的技术和产品教程广受欢迎。

延伸阅读

推荐语：这是一本全面覆盖了Pandas使用者的普遍需求和痛点的著作，基于实用、易学的原则，从功能、使用、原理等多个维度对Pandas做了全方位的详细讲解，既是初学者系统学习Pandas难得的入门书，又是有经验的Python工程师案头必不可少的查询手册。