数据！数据！数据！没有黏土我无法造出砖来！pandas数据分析

数据！数据！数据！没有黏土我无法造出砖来！——夏洛克•福尔摩斯

本章介绍pandas，这是一个聚焦于表格数据的数据分析程序库。pandas是一个强大的工具，它不仅提供了许多实用类和函数，而且很好地封装了来自其他软件包的功能。该工具提供了一个用户接口，能够让用户方便且高效地实现数据分析，特别是金融分析。

本章介绍如下基本数据结构：

本章的组织如下。

DataFrame类

本节首先用简单的小数据集来探索pandas中DataFrame类的基本特性和功能；然后说明如何将NumPy中的ndarray对象转换为DataFrame对象。

基本分析与基本可视化

这两节介绍基本分析与可视化功能（后续的章节将深入介绍这些主题）。

Series类

本节短小精悍，介绍了pandas的Series类。从某种意义上讲，它是DataFrame的一种特例，只有一列数据。

GroupBy操作

DataFrame的优势之一是根据一列或者多列来分组数据。这一节探索pandas的分组能力。

复杂选择

这一节介绍如何使用（复杂）条件，轻松地从DataFrame对象中选择数据。

联接、连接和合并

将不同数据集合而为一是数据分析中的重要操作。pandas提供了实现这一任务的不同选项，本节将对此进行介绍。

性能特征

pandas往往提供实现相同目标的多个选项，这符合Python的常规。本节简单介绍潜在的性能差异。

5.1　DataFrame类

pandas（以及本章）的核心是DataFrame，它是设计用于高效处理表格数据（也就是以列进行组织的数据）的类。为此，DataFrame提供了列标签以及数据集中各行（记录）的索引功能，这与关系数据库的一个表或者Excel电子表格类似。

本节介绍pandas中 DataFrame类的一些根本特性。该类非常复杂且强大，这里只能介绍其中的一小部分功能。后续章节将提供更多示例，揭示其不同方面的特征。

5.1.1　使用DataFrame类的第一步

从最根本的层面上看，DataFrame类设计用来管理具有索引和标签的数据，这些数据与来自SQL数据库表或者电子表格应用中工作表的数据没有太多的不同。考虑如下代码创建的DataFrame对象：

<code>In [1]: import pandas as pd ❶In [2]: df = pd.DataFrame([10, 20, 30, 40], ❷                          columns=['numbers'], ❸                          index=['a', 'b', 'c', 'd']) ❹In [3]: df ❺Out[3]:   numbers        A      10        b      20        c      30        d      40/<code>

❶ 导入pandas。

❷ 定义列表对象形式的数据。

❸ 指定列标签。

❹ 指定索引值/标签。

❺ 显示DataFrame对象的数据以及列和索引标签。

这个简单的例子已经说明了DataFrame在存储数据上的主要特性，具体如下。

• 数据本身可以用不同组成及类型（列表、元组、ndarray和字典对象都是候选者）展现。
• 数据以列的方式被组织，可以自定义列名（标签）。
• 索引可以采用不同的格式（如数值、字符串、时间信息）。

使用这种DataFrame对象总体上相当方便和高效，例如，当您想要进行扩大现有对象等工作时，我推荐你使用DataFrame对象。相比之下，常规的ndarray对象更专门化，也更受限制。与此同时，DataFrame对象往往在计算上和ndarray对象一样高效。下面是简单的例子，说明了DataFrame对象的典型操作：

<code>In [4]: df.index ❶Out[4]: Index(['a', 'b', 'c', 'd'], dtype='object')In [5]: df.columns ❷Out[5]: Index(['numbers'], dtype='object')In [6]: df.loc['c']❸Out[6]: numbers 30        Name: c, dtype: int64In [7]: df.loc[['a', 'd']] ❹Out[7]:    numbers        a       10        d       40In [8]: df.iloc[1:3] ❺Out[8]:    numbers        b 20        c 30In [9]: df.sum() ❻Out[9]: numbers 100        dtype: int64In [10]: df.apply(lambda x: x ** 2) ❼Out[10]:    numbers         a      100         b      400         c      900         d      1600In [11]: df ** 2 ❽Out[11]:    numbers         a      100         b      400         c      900         d     1600/<code>

❶ index属性和Index对象。

❷ columns属性和Index对象。

❸ 选择对应于索引c的值。

❹ 选择对应于索引a和b的两个值。

❺ 通过索引位置选择第二行和第三行。

❻ 计算单列总和。

❼ 使用apply方法，以向量化的方式计算平方值。

❽ 和ndarray对象一样，直接应用向量化。

与NumPy的ndarray对象不同，可以在两个维度上同时扩增DataFrame对象：

<code>In [12]: df['floats'] = (1.5, 2.5, 3.5, 4.5) ❶In [13]: dfOut[13]:    numbers floats         a       10    1.5         b       20    2.5         c       30    3.5         d       40    4.5In [14]: df['floats'] ❷Out[14]: a 1.5         b 2.5         c 3.5         d 4.5         Name: floats, dtype: float64/<code>

❶ 添加一个新列，该包含以元组形式提供的浮点数对象。

❷ 选择该列并显示其数据和索引标签。

也可以使用整个DataFrame对象来定义一个新列。在这种情况下，索引自动对齐：

<code>In [15]: df['names'] = pd.DataFrame(['Yves', 'Sandra', 'Lilli', 'Henry'],                                   index=['d', 'a', 'b', 'c']) ❶In [16]: dfOut[16]:   numbers floats    names         A      10   1.5     Sandra         b      20   2.5     Lilli         c      30   3.5     Henry         d      40   4.5     Yves/<code>

❶ 根据一个DataFrame对象创建另一个新列。

附加数据的方法也类似。但是，在下面的例子中，我们会看到在操作过程中必须避免的一个副作用——索引被简单的编号索引代替：

<code>In [17]: df.append({'numbers': 100, 'floats': 5.75, 'names': 'Jil'},                        ignore_index=True) ❶Out[17]:    numbers  floats   names         0       10    1.50  Sandra         1       20    2.50   Lilli         2       30    3.50   Henry         3       40    4.50    Yves         4       100    5.75    JilIn [18]: df = df.append(pd.DataFrame({'numbers': 100, 'floats': 5.75,                                      'names': 'Jil'}, index=['y',])) ❷In [19]: dfOut[19]:    numbers floats    names         a       10   1.50   Sandra         b       20   2.50    Lilli         c       30   3.50    Henry         d       40   4.50     Yves         y       100  5.75      JilIn [20]: df = df.append(pd.DataFrame({'names': 'Liz'}, index=['z',]),                        sort=False) ❸In [21]: dfOut[21]:    numbers floats    names         A     10.0   1.50   Sandra         b     20.0   2.50    Lilli         c     30.0   3.50    Henry         d     40.0   4.50     Yves         y     100.0  5.75      Jil         z     NaN     NaN      LizIn [22]: df.dtypes ❹Out[22]: numbers float64         floats float64         names object         dtype: object/<code>

❶ 通过一个字典对象附加新行；这是一个临时操作，操作期间索引信息丢失。

❷ 根据带索引信息的DataFrame对象附加行；原始索引信息保留。

❸ 向DataFrame对象附加不完整的数据行，生成NaN值。

❹ 返回各列的不同dtype，这与结构化ndarray对象类似。

尽管此时有遗漏的值，但大部的分方法调用仍然可以正常工作：

<code>In [23]: df[['numbers', 'floats']].mean() ❶Out[23]: numbers    40.00         Floats      3.55         dtype: float64In [24]: df[['numbers', 'floats']].std() ❷Out[24]: numbers    35.355339         Floats      1.662077         dtype: float64/<code>

❶ 计算指定两列的均值（忽略带NaN值的行）。

❷ 计算指定两列的标准差（忽略带NaN值的行）。

5.1.2　使用DataFrame类的第二步

本节的例子基于一个包含标准正态分布随机数的ndarray对象。该例探索管理时间序列数据的更多功能，如DatetimeIndex：

<code>In [25]: import numpy as npIn [26]: np.random.seed(100)In [27]: a = np.random.standard_normal((9, 4))In [28]: aOut[28]: array([[-1.74976547, 0.3426804 ,  1.1530358 , -0.25243604],                [ 0.98132079, 0.51421884,  0.22117967, -1.07004333],                [-0.18949583, 0.25500144, -0.45802699,  0.43516349],                [-0.58359505, 0.81684707,  0.67272081, -0.10441114],                [-0.53128038, 1.02973269, -0.43813562, -1.11831825],                [ 1.61898166, 1.54160517, -0.25187914, -0.84243574],                [ 0.18451869, 0.9370822 ,  0.73100034,  1.36155613],                [-0.32623806, 0.05567601,  0.22239961, -1.443217 ],                [-0.75635231, 0.81645401,  0.75044476, -0.45594693]])/<code>

您可以更直接地构造DataFrame对象（正如前面所见），但是使用ndarray对象通常是一个更好的选择，因为pandas将保留基本结构，“只”添加元信息（例如索引值）。这也代表了金融应用和科学研究的一种典型用例。例如：

<code>In [29]: df = pd.DataFrame(a) ❶In [30]: dfOut[30]:           0        1         2         3         0 -1.749765 0.342680  1.153036 -0.252436         1  0.981321 0.514219  0.221180 -1.070043         2 -0.189496 0.255001 -0.458027  0.435163         3 -0.583595 0.816847  0.672721 -0.104411         4 -0.531280 1.029733 -0.438136 -1.118318         5  1.618982 1.541605 -0.251879 -0.842436         6  0.184519 0.937082  0.731000  1.361556         7 -0.326238 0.055676  0.222400 -1.443217         8 -0.756352 0.816454  0.750445 -0.455947/<code>

❶ 由ndarray对象创建一个DataFrame对象。

表5-1列出了DataFrame函数使用的参数。表中，“类似数组”意味着和ndarray对象类似的数据结构——如列表对象。“索引”是pandas的Index类的一个实例。

表5-1　DataFrame函数参数

和结构数组一样，我们已经了解，DataFrame对象可以通过指定一个具有合适数量元素的列表来直接定义列名。下面的例子说明，我们可以随时定义/更改DataFrame对象的属性：

<code>In [31]: df.columns = ['No1', 'No2', 'No3', 'No4'] ❶In [32]: dfOut[32]:         No1      No2       No3       No4         0 -1.749765 0.342680  1.153036 -0.252436         1  0.981321 0.514219  0.221180 -1.070043         2 -0.189496 0.255001 -0.458027  0.435163         3 -0.583595 0.816847  0.672721 -0.104411         4 -0.531280 1.029733 -0.438136 -1.118318         5  1.618982 1.541605 -0.251879 -0.842436         6  0.184519 0.937082  0.731000  1.361556         7 -0.326238 0.055676  0.222400 -1.443217         8 -0.756352 0.816454  0.750445 -0.455947In [33]: df['No2'].mean() ❷Out[33]: 0.7010330941456459/<code>

❶ 通过列表对象指定列标签。

❷ 选择一列很容易。

为了高效处理金融事件序列数据，我们还必须很好地处理时间索引。这也可以视为pandas的一个重要优势。例如，假定分为4列的9个数据项对应于2019年1月开始的月底数据。然后，用date_range生成一个DatetimeIndex对象：

<code>In [34]: dates = pd.date_range('2019-1-1', periods=9, freq='M') ❶In [35]: datesOut[35]: DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',                     '2019-05-31', '2019-06-30', '2019-07-31', '2019-08-31',                    '2019-09-30'],                     dtype='datetime64[ns]', freq='M')/<code>

❶ 创建一个DatetimeIndex对象。

表5-2列出了date_range函数的参数。

表5-2　date_range函数参数

下列代码将刚刚创建的DatetimeIndex对象定义为相关的索引对象，并建立原始数据集的一个时间序列：

<code>In [36]: df.index = datesIn [37]: dfOut[37]:                  No1      No2       No3       No4         2019-01-31 -1.749765 0.342680  1.153036 -0.252436         2019-02-28  0.981321 0.514219  0.221180 -1.070043         2019-03-31 -0.189496 0.255001 -0.458027  0.435163         2019-04-30 -0.583595 0.816847  0.672721 -0.104411         2019-05-31 -0.531280 1.029733 -0.438136 -1.118318         2019-06-30  1.618982 1.541605 -0.251879 -0.842436         2019-07-31  0.184519 0.937082  0.731000  1.361556         2019-08-31 -0.326238 0.055676  0.222400 -1.443217         2019-09-30 -0.756352 0.816454  0.750445 -0.455947/<code>

至于在date_range函数帮助下生成的DatetimeIndex对象，频率参数freq有多种选择。表6-3列出了其所有选项。

表5-3　date_range函数的频率参数值(略)

在某些情况下，以ndarray对象的形式访问原始数据是有好处的。values属性提供直接访问的方式：

<code>In [38]: df.valuesOut[38]: array([[-1.74976547, 0.3426804 , 1.1530358 , -0.25243604],                [ 0.98132079, 0.51421884, 0.22117967, -1.07004333],                [-0.18949583, 0.25500144, -0.45802699, 0.43516349],                [-0.58359505, 0.81684707, 0.67272081, -0.10441114],                [-0.53128038, 1.02973269, -0.43813562, -1.11831825],                [ 1.61898166, 1.54160517, -0.25187914, -0.84243574],                [ 0.18451869, 0.9370822 , 0.73100034, 1.36155613],                [-0.32623806, 0.05567601, 0.22239961, -1.443217 ],                [-0.75635231, 0.81645401, 0.75044476, -0.45594693]])In [39]: np.array(df)Out[39]: array([[-1.74976547, 0.3426804 , 1.1530358 , -0.25243604],                [ 0.98132079, 0.51421884, 0.22117967, -1.07004333],                [-0.18949583, 0.25500144, -0.45802699, 0.43516349],                [-0.58359505, 0.81684707, 0.67272081, -0.10441114],                [-0.53128038, 1.02973269, -0.43813562, -1.11831825],                [ 1.61898166, 1.54160517, -0.25187914, -0.84243574],                [ 0.18451869, 0.9370822 , 0.73100034, 1.36155613],                [-0.32623806, 0.05567601, 0.22239961, -1.443217 ],                [-0.75635231, 0.81645401, 0.75044476, -0.45594693]])/<code>

数组和DataFrame

通常可以从一个ndarray对象生成DataFrame对象。也可以通过NumPy的np.array函数或DataFrame类的values属性，来从DataFrame对象生成ndarray对象。

5.2　基本分析

和NumPy的ndarray类一样，pandas的DataFrame类有多个便利的内建方法。首先考虑info和describe方法：

<code>In [40]: df.info() ❶         <class>         DatetimeIndex: 9 entries, 2019-01-31 to 2019-09-30         Freq: M         Data columns (total 4 columns):         No1    9 non-null float64         No2    9 non-null float64         No3    9 non-null float64         No4    9 non-null float64         dtypes: float64(4)         memory usage: 360.0 bytesIn [41]: df.describe() ❷Out[41]:             No1      No2       No3       No4         Count  9.000000 9.000000  9.000000  9.000000         Mean  -0.150212 0.701033  0.289193 -0.387788         Std    0.988306 0.457685  0.579920  0.877532         Min   -1.749765 0.055676 -0.458027 -1.443217         25%   -0.583595 0.342680 -0.251879 -1.070043         50%   -0.326238 0.816454  0.222400 -0.455947         75%    0.184519 0.937082  0.731000 -0.104411         max    1.618982 1.541605  1.153036  1.361556/<class>/<code>

❶ 提供关于数据、列和索引的元信息。

❷ 提供有用的每列汇总统计（对于数值数据）信息。

此外，你可以轻松地求得按列/行计算的总和、平均值和累计总和：

<code>In [43]: df.sum() ❶Out[43]: No1   -1.351906         No2    6.309298         No3    2.602739         No4   -3.490089         dtype: float64In [44]: df.mean()Out[44]: No1   -0.150212         No2    0.701033         No3    0.289193         No4   -0.387788         dtype: float64In [45]: df.mean(axis=0) ❷Out[45]: No1   -0.150212         No2    0.701033         No3    0.289193         No4   -0.387788         dtype: float64In [46]: df.mean(axis=1) ❸Out[46]: 2019-01-31   -0.126621         2019-02-28    0.161669         2019-03-31    0.010661         2019-04-30    0.200390         2019-05-31   -0.264500         2019-06-30    0.516568         2019-07-31    0.803539         2019-08-31   -0.372845         2019-09-30    0.088650         Freq: M, dtype: float64In [47]: df.cumsum() ❹Out[47]:                  No1      No2      No3       No4         2019-01-31 -1.749765 0.342680 1.153036 -0.252436         2019-02-28 -0.768445 0.856899 1.374215 -1.322479         2019-03-31 -0.957941 1.111901 0.916188 -0.887316         2019-04-30 -1.541536 1.928748 1.588909 -0.991727         2019-05-31 -2.072816 2.958480 1.150774 -2.110045         2019-06-30 -0.453834 4.500086 0.898895 -2.952481         2019-07-31 -0.269316 5.437168 1.629895 -1.590925         2019-08-31 -0.595554 5.492844 1.852294 -3.034142         2019-09-30 -1.351906 6.309298 2.602739 -3.490089/<code>

❶ 列总和。

❷ 列均值。

❸ 行均值。

❹ 列累计总和（从第一个索引位置起）。

DataFrame对象也能理解为NumPy通用函数，这与预期相符：

<code>In [48]: np.mean(df) ❶Out[48]: No1   -0.150212         No2    0.701033         No3    0.289193         No4   -0.387788         dtype: float64In [49]: np.log(df) ❷Out[49]: No1 No2 No3 No4         2019-01-31       NaN -1.070957  0.142398       NaN         2019-02-28 -0.018856 -0.665106 -1.508780       NaN         2019-03-31       NaN -1.366486       NaN -0.832033         2019-04-30       NaN -0.202303 -0.396425       NaN         2019-05-31       NaN  0.029299       NaN       NaN         2019-06-30  0.481797  0.432824       NaN       NaN         2019-07-31 -1.690005 -0.064984 -0.313341  0.308628         2019-08-31       NaN -2.888206 -1.503279       NaN         2019-09-30       NaN -0.202785 -0.287089       NaNIn [50]: np.sqrt(abs(df)) ❸Out[50]:                  No1       No2       No3       No4         2019-01-31  1.322787  0.585389  1.073795  0.502430         2019-02-28  0.990616  0.717091  0.470297  1.034429         2019-03-31  0.435311  0.504977  0.676777  0.659669         2019-04-30  0.763934  0.903796  0.820196  0.323127         2019-05-31  0.728890  1.014757  0.661918  1.057506         2019-06-30  1.272392  1.241614  0.501876  0.917843         2019-07-31  0.429556  0.968030  0.854986  1.166857         2019-08-31  0.571173  0.235958  0.471593  1.201340         2019-09-30  0.869685  0.903578  0.866282  0.675238In [51]: np.sqrt(abs(df)).sum() ❹Out[51]: No1    7.384345         No2    7.075190         No3    6.397719         No4    7.538440         dtype: float64In [52]: 100 * df + 100 ❺Out[52]:                   No1        No2        No3       No4         2019-01-31 -74.976547 134.268040 215.303580 74.756396         2019-02-28 198.132079 151.421884 122.117967 -7.004333         2019-03-31  81.050417 125.500144  54.197301 143.516349         2019-04-30  41.640495 181.684707 167.272081  89.558886         2019-05-31  46.871962 202.973269  56.186438 -11.831825         2019-06-30 261.898166 254.160517  74.812086  15.756426         2019-07-31 118.451869 193.708220 173.100034 236.155613         2019-08-31  67.376194 105.567601 122.239961 -44.321700         2019-09-30  24.364769 181.645401 175.044476  54.405307/<code>

❶ 列均值。

❷ 每个元素的自然对数；显示警告信息，但计算继续进行，得到多个NaN值。

❸ 每个元素绝对值的平方根。

❹ 按列均值。

❺ 数值数据的线性变换。

NumPy通用函数

一般来说，在NumPy通用函数适用于ndarray对象的所有情况下，都可以将这些函数应用到包含相同数据的pandas的DataFrame对象。

pandas有相当强的容错能力，它可以捕捉错误，在对应数学运算失败时放入NaN值。不仅如此，正如前面已经展示的，在许多情况下，它还可以将这些不完整的数据集当成完整数据集来使用。这种做法很方便，因为现实中不完整数据集往往比人们预想的要多。

5.3　基本可视化

如果数据存储在DataFrame对象中，那么数据图表的绘制通常只需要一行代码（见图5-1）。

图5-1　DataFrame对象的折线图

<code>In [53]: from pylab import plt, mpl ❶         plt.style.use('seaborn') ❶         mpl.rcParams['font.family'] = 'serif' ❶         %matplotlib inlineIn [54]: df.cumsum().plot(lw=2.0, figsize=(10, 6)); ❷/<code>

❶ 定制绘图样式。

❷ 绘制4列累计总和的折线图。

基本上，pandas提供了专为DataFrame对象设计的matplotplib（参见第7章）包装器。plot()方法的参数如表5-4所示。

表5-4　plot方法参数(略)

再举个例子，考虑相同数据的柱状图（见图5-2）：

图5-2　DataFrame对象的柱状图

<code>In [55]: df.plot.bar(figsize=(10, 6), rot=15); ❶# df.plot(kind='bar', figsize=(10, 6)) ❷/<code>

❶ plot.bar()绘制柱状图。

❷ 替代语法：使用kind参数改变绘图类型。

5.4　Series类

迄今为止，本章主要介绍了pandas的DataFrame类。Series是pandas自带的另一个重要的类。它的特点是只有一列数据。从这个意义上讲，它是DataFrame类的特例，两者之间有许多共同特性和功能，但不完全相同。从多列的DataFrame对象上选取一列，可以得到Series对象：

<code>In [56]: type(df)Out[56]: pandas.core.frame.DataFrameIn [57]: S = pd.Series(np.linspace(0, 15, 7), name='series')In [58]: SOut[58]: 0     0.0         1     2.5         2     5.0         3     7.5         4     10.0         5     12.5         6     15.0         Name: series, dtype: float64In [59]: type(S)Out[59]: pandas.core.series.SeriesIn [60]: s = df['No1']In [61]: sOut[61]: 2019-01-31 -1.749765         2019-02-28  0.981321         2019-03-31 -0.189496         2019-04-30 -0.583595         2019-05-31 -0.531280         2019-06-30  1.618982         2019-07-31  0.184519         2019-08-31 -0.326238         2019-09-30 -0.756352         Freq: M, Name: No1, dtype: float64In [62]: type(s)Out[62]: pandas.core.series.Series/<code>

DataFrame的主要方法也可用于Series对象，我们以mean和plot方法为例（见图5-3）：

<code>In [63]: s.mean()Out[63]: -0.15021177307319458In [64]: s.plot(lw=2.0, figsize=(10, 6));/<code>

图5-3　Series对象的折线图

5.5　GroupBy操作

pandas具备强大而灵活的分组功能，工作方式类似于SQL中的分组和Microsoft Excel中的透视表。为了进行分组，我们添加一列，表示对应索引数据所属的季度：

<code>In [65]: df['Quarter'] = ['Q1', 'Q1', 'Q1', 'Q2', 'Q2',                          'Q2', 'Q3', 'Q3', 'Q3']         dfOut[65]:                  No1       No2       No3       No4 Quarter         2019-01-31 -1.749765  0.342680  1.153036 -0.252436      Q1         2019-02-28  0.981321  0.514219  0.221180 -1.070043      Q1         2019-03-31 -0.189496  0.255001 -0.458027  0.435163      Q1         2019-04-30 -0.583595  0.816847  0.672721 -0.104411      Q2         2019-05-31 -0.531280  1.029733 -0.438136 -1.118318      Q2         2019-06-30  1.618982  1.541605 -0.251879 -0.842436      Q2         2019-07-31  0.184519  0.937082  0.731000  1.361556      Q3         2019-08-31 -0.326238  0.055676  0.222400 -1.443217      Q3         2019-09-30 -0.756352  0.816454  0.750445 -0.455947      Q3/<code>

现在，我们可以根据Quarter列分组，并输出单独组的统计量：

<code>In [66]: groups = df.groupby('Quarter') ❶In [67]: groups.size() ❷Out[67]: Quarter         Q1    3         Q2    3         Q3    3         dtype: int64In [68]: groups.mean() ❸Out[68]:               No1      No2       No3       No4Quarter         Q1      -0.319314 0.370634  0.305396 -0.295772         Q2       0.168035 1.129395 -0.005765 -0.688388         Q3      -0.299357 0.603071  0.567948 -0.179203In [69]: groups.max() ❹Out[69]:               No1      No2      No3       No4         Quarter         Q1       0.981321 0.514219 1.153036  0.435163         Q2       1.618982 1.541605 0.672721 -0.104411         Q3       0.184519 0.937082 0.750445  1.361556In [70]: groups.aggregate([min, max]).round(2) ❺Out[70]:           No1       No2        No3        No4                   Min  max  min  max   min  max   min   max         Quarter         Q1      -1.75 0.98 0.26 0.51 -0.46 1.15 -1.07  0.44         Q2      -0.58 1.62 0.82 1.54 -0.44 0.67 -1.12 -0.10         Q3      -0.76 0.18 0.06 0.94  0.22 0.75 -1.44  1.36/<code>

❶ 根据Quarter列分组。

❷ 给出每个分组的行数。

❸ 给出每的列均值。

❹ 给出每列的最大值。

❺ 给出每列的最小值和最大值。

分组也可以在多列上进行。为此，我们添加另一列，表示索引日期的月份是奇数还是偶数：

<code>In [71]: df['Odd_Even'] = ['Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even',                          'Odd', 'Even', 'Odd']In [72]: groups = df.groupby(['Quarter', 'Odd_Even'])In [73]: groups.size()Out[73]: Quarter  Odd_Even         Q1       Even        1                  Odd         2         Q2       Even        2                  Odd         1         Q3       Even        1                  Odd         2         dtype: int64In [74]: groups[['No1', 'No4']].aggregate([sum, np.mean])Out[74]:                        No1                 No4                                Sum      mean       sum mean         Quarter Odd_Even         Q1      Even      0.981321  0.981321 -1.070043 -1.070043                 Odd      -1.939261 -0.969631  0.182727  0.091364         Q2      Even      1.035387  0.517693 -0.946847 -0.473423                 Odd      -0.531280 -0.531280 -1.118318 -1.118318         Q3      Even     -0.326238 -0.326238 -1.443217 -1.443217                 Odd      -0.571834 -0.285917  0.905609  0.452805/<code>

对pandas和DataFrame对象使用的介绍到此结束，下面将这组工具应用到现实世界的金融数据中。

5.6　复杂选择

数据选择往往是通过列值上的条件公式实现的，也可以通过符合逻辑的方式来组合多个条件。考虑如下数据集。

<code>In [75]: data = np.random.standard_normal((10, 2)) ❶In [76]: df = pd.DataFrame(data, columns=['x', 'y']) ❷In [77]: df.info() ❷         <class>         RangeIndex: 10 entries, 0 to 9         Data columns (total 2 columns):         X    10 non-null float64         Y    10 non-null float64         dtypes: float64(2)         memory usage: 240.0 bytesIn [78]: df.head() ❸Out[78]:           x         y         0  1.189622 -1.690617         1 -1.356399 -1.232435         2 -0.544439 -0.668172         3  0.007315 -0.612939         4  1.299748 -1.733096In [79]: df.tail() ❹Out[79]:           x         y         5 -0.983310  0.357508         6 -1.613579  1.470714         7 -1.188018 -0.549746         8 -0.940046 -0.827932         9  0.108863  0.507810/<class>/<code>

❶ 包含标准正态分布随机数的ndarray对象。

❷ 包含相同随机数的DataFrame对象。

❸ 通过head方法取得前5行。

❹ 通过tail方法取得最后5行。

下面的代码说明了Python比较运算符和逻辑运算符在两列值上的应用：

<code>In [80]: df['x'] > 0.5 ❶Out[80]: 0     True         1    False         2    False         3    False         4     True         5    False         6    False         7    False         8    False         9    False         Name: x, dtype: boolIn [81]: (df['x'] > 0) & (df['y'] < 0) ❷Out[81]: 0     True         1    False         2    False         3     True         4     True         5    False         6    False         7    False         8    False         9    False         dtype: boolIn [82]: (df['x'] > 0) | (df['y'] < 0) ❸Out[82]: 0     True         1     True         2     True         3     True         4     True         5    False         6    False         7     True         8     True         9     True         dtype: bool/<code>

❶ 检查x列的值是否大于0.5。

❷ 检查是否x列的值为正且y列的值为负。

❸ 检查是否x列的值为正或y列的值为负。

利用得到的布尔型Series对象，就可以很容易地实现复杂数据（行）的选择。另外，也可以使用query方法并以字符串对象的形式来传递条件：

<code>In [83]: df[df['x'] > 0] ❶Out[83]:           x         y         0  1.189622 -1.690617         3  0.007315 -0.612939         4  1.299748 -1.733096         9  0.108863  0.507810In [84]: df.query('x > 0') ❶Out[84]:           x         y         0  1.189622 -1.690617         3  0.007315 -0.612939         4  1.299748 -1.733096         9  0.108863  0.507810In [85]: df[(df['x'] > 0) & (df['y'] < 0)] ❷Out[85]:           x         y         0  1.189622 -1.690617         3  0.007315 -0.612939         4  1.299748 -1.733096In [86]: df.query('x > 0 & y < 0') ❷Out[86]:           x         y         0  1.189622 -1.690617         3  0.007315 -0.612939         4  1.299748 -1.733096In [87]: df[(df.x > 0) | (df.y < 0)] ❸Out[87]:           x         y         0  1.189622 -1.690617         1 -1.356399 -1.232435         2 -0.544439 -0.668172         3  0.007315 -0.612939         4  1.299748 -1.733096         7 -1.188018 -0.549746         8 -0.940046 -0.827932         9  0.108863  0.507810/<code> 

❶ 所有第x列的值大于0.5的行。

❷ 所有第x列的值为正且y的列值为负的行。

❸ 所有第x列的值为正或y的列值为负的行（各列通过对应属性访问）。

比较运算符也可以一次性应用到整个DataFrame对象上：

<code>In [88]: df > 0 ❶Out[88]:        x     y         0   True False         1  False False         2  False False         3   True False         4   True False         5  False  True         6  False  True         7  False False         8  False False         9   True  TrueIn [89]: df[df > 0] ❷Out[89]:           x        y         0  1.189622      NaN         1       NaN      NaN         2       NaN      NaN         3  0.007315      NaN         4  1.299748      NaN         5       NaN 0.357508         6       NaN 1.470714         7       NaN      NaN         8       NaN      NaN         9  0.108863 0.507810/<code>

❶ DataFrame对象中的哪些值为正？

❷ 选择所有满足要求的值，并将其他值设为NaN。

5.7　联接、连接和合并

本节简单介绍连接DataFrame对象形式的两个简单数据集的不同方法。这两个简单数据集如下所示：

<code>In [90]: df1 = pd.DataFrame(['100', '200', '300', '400'],                             index=['a', 'b', 'c', 'd'],                             columns=['A',])In [91]: df1Out[91]:       A         a   100         b   200         c   300         d   400In [92]: df2 = pd.DataFrame(['200', '150', '50'],                             index=['f', 'b', 'd'],                             columns=['B',])In [93]: df2Out[93]:       B         f 200         b 150         d 50/<code>

5.7.1　联接

联接（Concatenation）或者附加（Appending）本质上指的是将一个DataFrame对象中的行添加到另一个DataFrame对象上，这可通过append方法或者pd.concat函数完成。需要认真考虑的是索引值的处理方法：

<code>In [94]: df1.append(df2, sort=False) ❶Out[94]:      A    B         a  100  NaN         b  200  NaN         c  300  NaN         d  400  NaN         f  NaN  200         b  NaN  150         d  NaN   50In [95]: df1.append(df2, ignore_index=True, sort=False) ❷Out[95]:      A    B         0  100  NaN         1  200  NaN         2  300  NaN         3  400  NaN         4  NaN  200         5  NaN  150         6  NaN   50In [96]: pd.concat((df1, df2), sort=False) ❸Out[96]:      A    B         a  100  NaN         b  200  NaN         c  300  NaN         d  400  NaN         f  NaN  200         b  NaN  150         d  NaN   50In [97]: pd.concat((df1, df2), ignore_index=True, sort=False) ❹Out[97]:      A    B         0  100  NaN         1  200  NaN         2  300  NaN         3  400  NaN         4  NaN  200         5  NaN  150         6  NaN   50/<code>

❶ 将df2的数据附加到df1中作为新行。

❷ 完成同样的工作，但忽略索引。

❸ 与第一个附加操作效果相同。

❹ 与第二个附加操作效果相同。

5.7.2　连接

连接两个数据集时，DataFrame对象的顺序很重要。只有第一个DataFrame对象的索引值被使用，这种默认行为称为左连接（left join）：

<code>In [98]: df1.join(df2) ❶Out[98]:      A    B         a  100  NaN         b  200  150         c  300  NaN         d  400   50In [99]: df2.join(df1) ❷Out[99]:      B    A         f  200  NaN         b  150  200         d   50  400/<code>

❶ df1的索引值有意义。

❷ df2的索引值有意义。

共有4种不同的连接方法，每种方法都导致索引值和对应数据行的不同处理行为：

<code>In [100]: df1.join(df2, how='left') ❶Out[100]:      A    B          a  100  NaN          b  200  150          c  300  NaN          d  400   50In [101]: df1.join(df2, how='right') ❷Out[101]:      A    B          f  NaN  200          b  200  150          d  400   50In [102]: df1.join(df2, how='inner') ❸Out[102]:      A    B          b  200  150          d  400   50In [103]: df1.join(df2, how='outer') ❹Out[103]:      A    B          a  100  NaN          b  200  150          c  300  NaN          d  400   50          f  NaN  200/<code>

❶ 左连接是默认操作。

❷ 右连接相当于颠倒了DataFrame对象的顺序。

❸ 内连接只保留在两个索引中都存在的索引值。

❹ 外连接保留两个索引中的所有索引值。

连接也可以基于空的DataFrame对象。在这种情况下，列按顺序被创建，这与左连接类似：

<code>In [104]: df = pd.DataFrame()In [105]: df['A'] = df1['A'] ❶In [106]: dfOut[106]:      A          a  100          b  200          c  300          d  400In [107]: df['B'] = df2 ❷In [108]: dfOut[108]:      A    B          a  100  NaN          b  200  150          c  300  NaN          d  400   50/<code>

❶ df1为第一列A。

❷ df2为第二列B。

使用字典来组合数据集可以得到类似于外连接的结果，因为列是同时创建的：

<code>In [109]: df = pd.DataFrame({'A': df1['A'], 'B': df2['B']})In [110]: dfOut[110]:      A    B          a  100  NaN          b  200  150          c  300  NaN          d  400   50          f  NaN  200/<code>

❶ DataFrame对象的各列用作字典对象的值

5.7.3　合并

连接操作根据待连接的DataFrame对象的索引进行，而合并操作通常在两个数据集共享的某列上进行。为此，在两个原始的DataFrame对象上添加一个新列C：

<code>In [111]: c = pd.Series([250, 150, 50], index=['b', 'd', 'c'])          df1['C'] = c          df2['C'] = cIn [112]: df1Out[112]:      A      C          a  100    NaN          b  200  250.0          c  300   50.0          d  400  150.0In [113]: df2Out[113]:      B      C          f  200    NaN          b  150  250.0          d   50  150.0/<code>

默认情况下，这种合并操作根据单一共享列C进行。但也存在其他可能，例如外合并：

<code>In [114]: pd.merge(df1, df2) ❶Out[114]:      A      C    B          0  100    NaN  200          1  200  250.0  150          2  400  150.0   50In [115]: pd.merge(df1, df2, on='C') ❶Out[115]:      A      C    B          0  100    NaN  200          1  200  250.0  150          2  400  150.0   50In [116]: pd.merge(df1, df2, how='outer')Out[116]:      A      C    B          0  100    NaN  200          1  200  250.0  150          2  300   50.0  NaN          3  400  150.0   50/<code>

❶ 默认合并根据C列进行。

❷ 也可以进行外合并，保留所有数据行。

可用的合并操作类型还有很多，下面的代码演示了其中的几种：

<code>In [117]: pd.merge(df1, df2, left_on='A', right_on='B')Out[117]:      A    C_x    B  C_y          0  200  250.0  200  NaNIn [118]: pd.merge(df1, df2, left_on='A', right_on='B', how='outer')Out[118]:      A    C_x    B    C_y          0  100    NaN  NaN    NaN          1  200  250.0  200    NaN          2  300   50.0  NaN    NaN          3  400  150.0  NaN    NaN          4  NaN    NaN  150  250.0          5  NaN    NaN   50  150.0In [119]: pd.merge(df1, df2, left_index=True, right_index=True)Out[119]:      A    C_x    B    C_y          b  200  250.0  150  250.0          d  400  150.0   50  150.0In [120]: pd.merge(df1, df2, on='C', left_index=True)Out[120]:      A      C    B          f  100    NaN  200          b  200  250.0  150          d  400  150.0   50In [121]: pd.merge(df1, df2, on='C', right_index=True)Out[121]:      A      C    B          a  100    NaN  200          b  200  250.0  150          d  400  150.0   50In [122]: pd.merge(df1, df2, on='C', left_index=True, right_index=True)Out[122]:      A    C      B          b  200  250.0  150          d  400  150.0   50/<code>

5.8　性能特征

本章的许多例子说明，用pandas实现同一个目标往往有多种选择。本节以按元素加总两列数值为例来这些选择进行对比。首先用NumPy生成数据集：

<code>In [123]: data = np.random.standard_normal((1000000, 2)) ❶In [124]: data.nbytes ❶Out[124]: 16000000In [125]: df = pd.DataFrame(data, columns=['x', 'y']) ❷In [126]: df.info() ❷          <class>          RangeIndex: 1000000 entries, 0 to 999999          Data columns (total 2 columns):          X    1000000 non-null float64          Y    1000000 non-null float64          dtypes: float64(2)          memory usage: 15.3 MB/<class>/<code>

❶ 包含随机数的ndarray对象。

❷ 包含随机数的DataFrame对象。

其次，实现手边任务的某选择性能还不错：

<code>In [127]: %time res = df['x'] + df['y'] ❶          CPU times: user 7.35 ms, sys: 7.43 ms, total: 14.8 ms          Wall time: 7.48 msIn [128]: res[:3]Out[128]: 0    0.387242          1   -0.969343          2   -0.863159          dtype: float64In [129]: %time res = df.sum(axis=1) ❷          CPU times: user 130 ms, sys: 30.6 ms, total: 161 ms          Wall time: 101 msIn [130]: res[:3]Out[130]: 0    0.387242          1   -0.969343          2   -0.863159          dtype: float64In [131]: %time res = df.values.sum(axis=1) ❸          CPU times: user 50.3 ms, sys: 2.75 ms, total: 53.1 ms          Wall time: 27.9 msIn [132]: res[:3]Out[132]: array([ 0.3872424 , -0.96934273, -0.86315944])In [133]: %time res = np.sum(df, axis=1) ❹          CPU times: user 127 ms, sys: 15.1 ms, total: 142 ms          Wall time: 73.7 msIn [134]: res[:3]Out[134]: 0    0.387242          1   -0.969343          2   -0.863159          dtype: float64In [135]: %time res = np.sum(df.values, axis=1) ❺          CPU times: user 49.3 ms, sys: 2.36 ms, total: 51.7 ms          Wall time: 26.9 msIn [136]: res[:3]Out[136]: array([ 0.3872424 , -0.96934273, -0.86315944])/<code>

❶ 直接使用列（Series对象）是最快的方法。

❷ 调用DataFrame对象的sum方法来计算总和。

❸ 调用ndarray对象的sum方法来计算总和。

❹ 调用DataFrame对象的np.sum方法来计算总和。

❺ 调用ndarray对象的np.sum方法来计算总和。

最后，还有两种选择可以计算元素和，它们分别基于eval和apply方法[1]：

<code>The application of the eval() method requires the numexpr package to   be installed.In [137]: %time res = df.eval('x + y') ❶          CPU times: user 25.5 ms, sys: 17.7 ms, total: 43.2 ms          Wall time: 22.5 msIn [138]: res[:3]Out[138]: 0    0.387242          1   -0.969343          2   -0.863159          dtype: float64In [139]: %time res = df.apply(lambda row: row['x'] + row['y'], axis=1)          CPU times: user 19.6 s, sys: 83.3 ms, total: 19.7 s          Wall time: 19.9 sIn [140]: res[:3]Out[140]: 0    0.387242          1   -0.969343          2   -0.863159          dtype: float64/<code>

❶ eval是专门用于计算（复杂）数值表达式的方法，可以直接处理数据列。

❷ 最慢的选择是逐行使用apply方法，这就像在Python级别上循环访问所有行。

明智的选择

pandas常常为实现统一目标提供多个选择。如果不确定使用哪一个，那么在时间是关键因素的情况下，比较各种选择，选择性能最好的一种。在上面这个简单的例子里，不同选择的执行时间相差好几个数量级。

5.9　结语

pandas是强大的数据分析工具，已经成为所谓的PyData栈的核心软件包。它的DataFrame类特别适合于处理任何类型的表格数据。这些对象上的大部分操作是向量化的，这不仅可以得到和NumPy类似的简洁代码，而且还可以得到高性能。此外，pandas能够很方便地处理不完整数据集（NumPy做不到这一点）。pandas和DataFrame类将是本书后续多个章节的核心，在必要时将使用并介绍它们的更多特性。

5.10　延伸阅读

pandas是一个开源项目，你既可以阅读在线文档，也可以下载其PDF版本[2]。官网上还提供了一些附加资源。

至于NumPy，我们建议的pandas参考书如下。

• McKinney, Wes (2017). Python for Data Analysis. Sebastopol, CA: O’Reilly.
• VanderPlas, Jake (2016). Python Data Science Handbook. Sebastopol, CA: O’Reilly.

[1]　要想使用eval方法需要安装numexpr软件包。——原注

[2]　在本书编写期间，PDF文档共有2500页。——原注

本文摘自《Python金融大数据分析 第2版》[德] 伊夫·希尔皮斯科（Yves Hilpisch） 著，姚军 译

• 金融科技算法交易量化金融教程书籍
• 详细讲解使用Python分析处理金融大数据的专业图书
• 将人工智能应用于金融开发的实战指南，金融应用开发领域从业人员的常备读物

Python已成为数据驱动AI、金融优先选择的编程语言。现在，一些大型的投资银行和对冲资金均使用Python及其生态系统来构建核心交易与风险管理系统。在本书中，作者向开发人员和量化分析人员介绍了使用Python程序库与工具，完成金融数据科学、算法交易和计算金融任务的方法。

Python与金融：Python交互式金融分析与程序开发入门。基本知识：学习Python数据类型与结构、NumPy、pandas及其DataFrame类、面向对象编程。金融数据科学：探索用于金融时间序列数据、I/O操作、推断统计学和机器学习的Python技术与程序库。算法交易：使用Python来验证和部署自动算法交易策略。

閱讀更多 程序員書屋 的文章

關鍵字: 砖来 可视化技术 SQL