从小白到大年夜师这里有一份Pandas入门指南_数据_办法

作者：Rudolf Höhn机器之心编译

参与：李诗萌、张倩

在本文中，作者从 Pandas 的简介开始，一步一步讲解了 Pandas 的发展现状、内存优化等问题。
这是一篇最佳实践教程，既适宜用过 Pandas 的读者，也适宜没用过但想要上手的小白。

通过本文，你将有望创造一到多种用 pandas 编码的新方法。

本文包括以下内容：

在阅读本文时，我建议你阅读每个你不理解的函数的文档字符串（docstrings）。
大略的 Google 搜索和几秒钟 Pandas 文档的阅读，都会使你的阅读体验更加愉快。

Pandas 的定义和现状

什么是 Pandas？

Pandas 是一个「开源的、有 BSD 开源协议的库，它为 Python 编程措辞供应了高性能、易于利用的数据架构以及数据剖析工具」。
总之，它供应了被称为 DataFrame 和 Series（对那些利用 Panel 的人来说，它们已经被弃用了）的数据抽象，通过管理索引来快速访问数据、实行剖析和转换运算，乃至可以绘图（用 matplotlib 后端）。

Pandas 确当前最新版本是 v0.25.0 (https://github.com/pandas-dev/pandas/releases/tag/v0.25.0)

Pandas 正在逐步升级到 1.0 版，而为了达到这一目的，它改变了很多人们习以为常的细节。
Pandas 的核心开拓者之一 Marc Garcia 揭橥了一段非常有趣的演讲——「走向 Pandas 1.0」。

演讲链接：https://www.youtube.com/watch?v=hK6o_TDXXN8

用一句话来总结，Pandas v1.0 紧张改进了稳定性（如韶光序列）并删除了未利用的代码库（如 SparseDataFrame）。

数据

让我们开始吧！
选择「1985 到 2016 年间每个国家的自尽率」作为玩具数据集。
这个数据集足够大略，但也足以让你上手 Pandas。

数据集链接：https://www.kaggle.com/russellyates88/suicide-rates-overview-1985-to-2016

在深入研究代码之前，如果你想重现结果，要先实行下面的代码准备数据，确保列名和类型是精确的。

import pandas as pdimport numpy as npimport os# to download https://www.kaggle.com/russellyates88/suicide-rates-overview-1985-to-2016data_path = 'path/to/folder/'df = (pd.read_csv(filepath_or_buffer=os.path.join(data_path, 'master.csv')) .rename(columns={'suicides/100k pop' : 'suicides_per_100k', ' gdp_for_year ($) ' : 'gdp_year', 'gdp_per_capita ($)' : 'gdp_capita', 'country-year' : 'country_year'}) .assign(gdp_year=lambda _df: _df['gdp_year'].str.replace(',','').astype(np.int64)) )

提示：如果你读取了一个大文件，在 read_csv（https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html）中参数设定为 chunksize=N，这会返回一个可以输出 DataFrame 工具的迭代器。

这里有一些关于这个数据集的描述：

>>> df.columnsIndex(['country', 'year', 'sex', 'age', 'suicides_no', 'population', 'suicides_per_100k', 'country_year', 'HDI for year', 'gdp_year', 'gdp_capita', 'generation'], dtype='object')

这里有 101 个国家、年份从 1985 到 2016、两种性别、六个年代以及六个年事组。
有一些得到这些信息的方法：

可以用 unique() 和 nunique() 获取列内唯一的值（或唯一值的数量）；

>>> df['generation'].unique()array(['Generation X', 'Silent', 'G.I. Generation', 'Boomers', 'Millenials', 'Generation Z'], dtype=object)>>> df['country'].nunique()101

可以用 describe() 输出每一列不同的统计数据（例如最小值、最大值、均匀值、总数等），如果指定 include='all'，会针对每一列目标输出唯一元素的数量和涌现最多元素的数量；

可以用 head() 和 tail() 来可视化数据框的一小部分。

通过这些方法，你可以迅速理解正在剖析的表格文件。

内存优化

在处理数据之前，理解数据并为数据框的每一列选择得当的类型是很主要的一步。

在内部，Pandas 将数据框存储为不同类型的 numpy 数组（比如一个 float64 矩阵，一个 int32 矩阵）。

有两种可以大幅降落内存花费的方法。

import pandas as pddef mem_usage(df: pd.DataFrame) -> str: \公众\"大众\"大众This method styles the memory usage of a DataFrame to be readable as MB. Parameters ---------- df: pd.DataFrame Data frame to measure. Returns ------- str Complete memory usage as a string formatted for MB. \"大众\"大众\公众 return f'{df.memory_usage(deep=True).sum() / 1024 2 : 3.2f} MB'def convert_df(df: pd.DataFrame, deep_copy: bool = True) -> pd.DataFrame: \"大众\"大众\公众Automatically converts columns that are worth stored as ``categorical`` dtype. Parameters ---------- df: pd.DataFrame Data frame to convert. deep_copy: bool Whether or not to perform a deep copy of the original data frame. Returns ------- pd.DataFrame Optimized copy of the input data frame. \"大众\"大众\"大众 return df.copy(deep=deep_copy).astype({ col: 'category' for col in df.columns if df[col].nunique() / df[col].shape[0] < 0.5})

Pandas 提出了一种叫做 memory_usage() 的方法，这种方法可以剖析数据框的内存花费。
在代码中，指定 deep=True 来确保考虑到了实际的系统利用情形。

memory_usage()：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.memory_usage.html

理解列的类型（https://pandas.pydata.org/pandas-docs/stable/getting_started/basics.html#basics-dtypes）很主要。
它可以通过两种大略的方法节省高达 90% 的内存利用：

除了降落数值类型的大小（用 int32 而不是 int64）外，Pandas 还提出了分类类型：https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html

如果你是用 R 措辞的开拓职员，你可能以为它和 factor 类型是一样的。

这种分类类型许可用索引更换重复值，还可以把实际值存在其他位置。
教科书中的例子是国家。
和多次存储相同的字符串「瑞士」或「波兰」比起来，为什么不大略地用 0 和 1 更换它们，并存储在字典中呢？

categorical_dict = {0: 'Switzerland', 1: 'Poland'}

Pandas 做了险些相同的事情，同时添加了所有的方法，可以实际利用这种类型，并且仍旧能够显示国家的名称。

回到 convert_df() 方法，如果这一列中的唯一值小于 50%，它会自动将列类型转换成 category。
这个数是任意的，但是由于数据框中类型的转换意味着在 numpy 数组间移动数据，因此我们得到的必须比失落去的多。

接下来看看数据中会发生什么。

>>> mem_usage(df)10.28 MB>>> mem_usage(df.set_index(['country', 'year', 'sex', 'age']))5.00 MB>>> mem_usage(convert_df(df))1.40 MB>>> mem_usage(convert_df(df.set_index(['country', 'year', 'sex', 'age'])))1.40 MB

通过利用「智能」转换器，数据框利用的内存险些减少了 10 倍（准确地说是 7.34 倍）。

索引

Pandas 是强大的，但也须要付出一些代价。
当你加载 DataFrame 时，它会创建索引并将数据存储在 numpy 数组中。
这是什么意思？一旦加载了数据框，只要精确管理索引，就可以快速地访问数据。

访问数据的方法紧张有两种，分别是通过索引和调查。
根据详细情形，你只能选择个中一种。
但在大多数情形中，索引（和多索引）都是最好的选择。
我们来看下面的例子：

>>> %%time>>> df.query('country == \公众Albania\"大众 and year == 1987 and sex == \"大众male\"大众 and age == \"大众25-34 years\"大众')CPU times: user 7.27 ms, sys: 751 µs, total: 8.02 ms# ==================>>> %%time>>> mi_df.loc['Albania', 1987, 'male', '25-34 years']CPU times: user 459 µs, sys: 1 µs, total: 460 µs

什么？加速 20 倍？

你要问自己了，创建这个多索引要多永劫光？

%%timemi_df = df.set_index(['country', 'year', 'sex', 'age'])CPU times: user 10.8 ms, sys: 2.2 ms, total: 13 ms

通过调查数据的韶光是 1.5 倍。
如果你只想检索一次数据（这种情形很少发生），查询是精确的方法。
否则，你一定要坚持用索引，CPU 会为此感激你的。

.set_index(drop=False) 许可不删除用作新索引的列。

.loc[]/.iloc[] 方法可以很好地读取数据框，但无法修正数据框。
如果须要手动构建（比如利用循环），那就要考虑其他的数据构造了（比如字典、列表等），在准备好所有数据后，创建 DataFrame。
否则，对付 DataFrame 中的每一个新行，Pandas 都会更新索引，这可不是大略的哈希映射。

>>> (pd.DataFrame({'a':range(2), 'b': range(2)}, index=['a', 'a']) .loc['a']) a ba 0 0a 1 1

因此，未排序的索引可以降落性能。
为了检讨索引是否已经排序并对它排序，紧张有两种方法：

%%time>>> mi_df.sort_index()CPU times: user 34.8 ms, sys: 1.63 ms, total: 36.5 ms>>> mi_df.index.is_monotonicTrue

更多详情请参阅：

方法链

利用 DataFrame 的方法链是链接多个返回 DataFrame 方法的行为，因此它们都是来自 DataFrame 类的方法。
在现在的 Pandas 版本中，利用方法链是为了不存储中间变量并避免涌现如下情形：

import numpy as npimport pandas as pddf = pd.DataFrame({'a_column': [1, -999, -999], 'powerless_column': [2, 3, 4], 'int_column': [1, 1, -1]}) df['a_column'] = df['a_column'].replace(-999, np.nan) df['power_column'] = df['powerless_column'] 2 df['real_column'] = df['int_column'].astype(np.float64) df = df.apply(lambda _df: _df.replace(4, np.nan)) df = df.dropna(how='all')

用下面的链更换：

df = (pd.DataFrame({'a_column': [1, -999, -999], 'powerless_column': [2, 3, 4], 'int_column': [1, 1, -1]}) .assign(a_column=lambda _df: _df['a_column'].replace(-999, np.nan)) .assign(power_column=lambda _df: _df['powerless_column'] 2) .assign(real_column=lambda _df: _df['int_column'].astype(np.float64)) .apply(lambda _df: _df.replace(4, np.nan)) .dropna(how='all') )

说实话，第二段代码更俊秀也更简洁。

方法链的工具箱是由不同的方法（比如 apply、assign、loc、query、pipe、groupby 以及 agg）组成的，这些方法的输出都是 DataFrame 工具或 Series 工具（或 DataFrameGroupBy）。

理解它们最好的方法便是实际利用。
举个大略的例子：

(df .groupby('age') .agg({'generation':'unique'}) .rename(columns={'generation':'unique_generation'})# Recommended from v0.25# .agg(unique_generation=('generation', 'unique')))

得到每个年事范围中所有唯一年代标签的大略链

在得到的数据框中，「年事」列是索引。

除了理解到「X 代」覆盖了三个年事组外，分解这条链。
第一步是对年事组分组。
这一方法返回了一个 DataFrameGroupBy 工具，在这个工具中，通过选择组的唯一年代标签聚合了每一组。

在这种情形下，聚合方法是「unique」方法，但它也可以接管任何（匿名）函数。

在 0.25 版本中，Pandas 引入了利用 agg 的新方法：https://dev.pandas.io/whatsnew/v0.25.0.html#groupby-aggregation-with-relabeling。

(df .groupby(['country', 'year']) .agg({'suicides_per_100k': 'sum'}) .rename(columns={'suicides_per_100k':'suicides_sum'})# Recommended from v0.25# .agg(suicides_sum=('suicides_per_100k', 'sum')) .sort_values('suicides_sum', ascending=False) .head(10))

用排序值（sort_values）和 head 得到自尽率排前十的国家和年份

(df .groupby(['country', 'year']) .agg({'suicides_per_100k': 'sum'}) .rename(columns={'suicides_per_100k':'suicides_sum'})# Recommended from v0.25# .agg(suicides_sum=('suicides_per_100k', 'sum')) .nlargest(10, columns='suicides_sum'))

用排序值 nlargest 得到自尽率排前十的国家和年份

在这些例子中，输出都是一样的：有两个指标（国家和年份）的 MultiIndex 的 DataFrame，还有包含排序后的 10 个最大值的新列 suicides_sum。

「国家」和「年份」列是索引。

nlargest(10) 比 sort_values(ascending=False).head(10) 更有效。

另一个有趣的方法是 unstack：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.unstack.html，这种方法许可迁徙改变索引水平。

(mi_df .loc[('Switzerland', 2000)] .unstack('sex') [['suicides_no', 'population']])

「age」是索引，列「suicides_no」和「population」都有第二个水平列「sex」。

下一个方法 pipe 是最通用的方法之一。
这种方法许可管道运算（就像在 shell 脚本中）实行比链更多的运算。

管道的一个大略但强大的用法是记录不同的信息。

def log_head(df, head_count=10): print(df.head(head_count)) return dfdef log_columns(df): print(df.columns) return dfdef log_shape(df): print(f'shape = {df.shape}') return df

和 pipe 一起利用的不同记录函数。

举个例子，我们想验证和 year 列比较，country_year 是否精确：

(df .assign(valid_cy=lambda _serie: _serie.apply( lambda _row: re.split(r'(?=\d{4})', _row['country_year'])[1] == str(_row['year']), axis=1)) .query('valid_cy == False') .pipe(log_shape))

用来验证「country_year」列中年份的管道。

管道的输出是 DataFrame，但它也可以在标准输出（console/REPL）中打印。

shape = (0, 13)

你也可以在一条链中用不同的 pipe。

(df .pipe(log_shape) .query('sex == \公众female\"大众') .groupby(['year', 'country']) .agg({'suicides_per_100k':'sum'}) .pipe(log_shape) .rename(columns={'suicides_per_100k':'sum_suicides_per_100k_female'})# Recommended from v0.25# .agg(sum_suicides_per_100k_female=('suicides_per_100k', 'sum')) .nlargest(n=10, columns=['sum_suicides_per_100k_female']))

女性自尽数量最高的国家和年份。

天生的 DataFrame 如下所示：

索引是「年份」和「国家」。

标准输出的打印如下所示：

shape = (27820, 12)shape = (2321, 1)

除了记录到掌握台外，pipe 还可以直接在数据框的列上运用函数。

from sklearn.preprocessing import MinMaxScalerdef norm_df(df, columns): return df.assign({col: MinMaxScaler().fit_transform(df[[col]].values.astype(float)) for col in columns}) for sex in ['male', 'female']: print(sex) print( df .query(f'sex == \公众{sex}\"大众') .groupby(['country']) .agg({'suicides_per_100k': 'sum', 'gdp_year': 'mean'}) .rename(columns={'suicides_per_100k':'suicides_per_100k_sum', 'gdp_year': 'gdp_year_mean'}) # Recommended in v0.25 # .agg(suicides_per_100k=('suicides_per_100k_sum', 'sum'), # gdp_year=('gdp_year_mean', 'mean')) .pipe(norm_df, columns=['suicides_per_100k_sum', 'gdp_year_mean']) .corr(method='spearman') ) print('\n')

自尽数量是否和 GDP 的低落干系？是否和性别干系？

上面的代码在掌握台中的打印如下所示：

male suicides_per_100k_sum gdp_year_meansuicides_per_100k_sum 1.000000 0.421218gdp_year_mean 0.421218 1.000000

female suicides_per_100k_sum gdp_year_meansuicides_per_100k_sum 1.000000 0.452343gdp_year_mean 0.452343 1.000000

深入研究代码。
norm_df() 将一个 DataFrame 和用 MinMaxScaling 扩展列的列表当做输入。
利用字典理解，创建一个字典 {column_name: method, …}，然后将其解压为 assign() 函数的参数 (colunmn_name=method, …)。

在这种分外情形下，min-max 缩放不会改变对应的输出：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.corr.html，它仅用于参数。

在（迢遥的？）未来，缓式评估（lazy evaluation）可能涌如今方法链中，以是在链上做一些投资可能是一个好想法。

末了（随机）的技巧

下面的提示很有用，但不适用于前面的任何部分：

itertuples() 可以更高效地遍历数据框的行；

>>> %%time>>> for row in df.iterrows(): continueCPU times: user 1.97 s, sys: 17.3 ms, total: 1.99 s>>> for tup in df.itertuples(): continueCPU times: user 55.9 ms, sys: 2.85 ms, total: 58.8 ms

把稳：tup 是一个 namedtuple

join() 用了 merge()；在 Jupyter 条记本中，在代码块的开头写上 %%time，可以有效地丈量韶光；UInt8 类：https://pandas.pydata.org/pandas-docs/stable/user_guide/gotchas.html#support-for-integer-na支持带有整数的 NaN 值；

记住，任何密集的 I/O（例如展开大型 CSV 存储）用低级方法都会实行得更好（尽可能多地用 Python 的核心函数）。

还有一些本文没有涉及到的有用的方法和数据构造，这些方法和数据构造都很值得花韶光去理解：

数据透视表：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.pivot.html?source=post_page---------------------------

韶光序列/日期功能：https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html?source=post_page---------------------------；

绘图：https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html?source=post_page---------------------------。

总结

希望你可以由于这篇简短的文章，更好地理解 Pandas 背后的事情事理，以及 Pandas 库的发展现状。
本文还展示了不同的用于优化数据框内存以及快速剖析数据的工具。
希望对现在的你来说，索引和查找的观点能更加清晰。
末了，你还可以试着用方法链写更长的链。

这里还有一些条记：https://github.com/unit8co/medium-pandas-wan?source=post_page---------------------------

除了文中的所有代码外，还包括大略数据索引数据框（df）和多索引数据框（mi_df）性能的定时指标。

熟能生巧，以是连续修炼技能，并帮助我们建立一个更好的天下吧。

PS：有时候纯用 Numpy 会更快。

原文链接：https://medium.com/unit8-machine-learning-publication/from-pandas-wan-to-pandas-master-4860cf0ce442