{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 数据处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们之前详细介绍了 NumPy 和它的 ndarray 对象，这个对象为 Python 多维数组提供了高效的存储和处理方法。下面，我们将基于前面的知识，深入学习 Pandas 程序库提\n",
    "供的数据结构。Pandas 是在 NumPy 基础上建立的新程序库，提供了一种高效的 DataFrame 数据结构。DataFrame 本质上是一种带行标签和列标签、支持相同类型数据和缺失值的多维数组。Pandas 不仅为带各种标签的数据提供了便利的存储界面，还实现了许多强大的操作，这些操作对数据库框架和电子表格程序的用户来说非常熟悉。\n",
    "正如我们之前看到的那样，NumPy 的 ndarray 数据结构为数值计算任务中常见的干净整齐、组织良好的数据提供了许多不可或缺的功能。虽然它在这方面做得很好，但是当我们需要处理更灵活的数据任务（如为数据添加标签、处理缺失值等），或者需要做一些不是对每个元素都进行广播映射的计算（如分组、透视表等）时，NumPy 的限制就非常明显了，而这些都是分析各种非结构化数据时很重要的一部分。建立在 NumPy 数组结构上的Pandas，尤其是它的 Series 和 DataFrame 对象，为数据科学家们处理那些消耗大量时间的\n",
    "“数据清理”（data munging）任务提供了捷径。\n",
    "\n",
    "这里将重点介绍 Series、DataFrame 和其他相关数据结构的高效使用方法。我们会酌情使用真实数据集作为演示示例，但这些示例本身并不是学习重点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 　安装并使用 Pandas\n",
    "\n",
    "在安装 Pandas 之前，确保你的操作系统中有 NumPy。如果你是从源代码直接编译，那么还需要相应的工具编译建立 Pandas 所需的 C 语言与 Cython 代码。详细的安装方法，请参考 Pandas 官方文档（http://pandas.pydata.org）。如果你使用了 Anaconda，\n",
    "那么 Pandas 就已经安装好了。\n",
    "\n",
    "Pandas 安装好之后，可以导入它检查一下版本号："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.4.3'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas\n",
    "pandas.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，本文档基于 Pandas 1.4.3 和 Numpy 1.22.3 测试，若后续版本更新导致该文档中某些内容不再适用，请以官方文档为准！\n",
    "\n",
    "和之前导入 NumPy 并使用别名 np 一样，我们将导入 Pandas 并使用别名 pd："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在下面会沿用这种简写方式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关于显示内置文档的提醒\n",
    "\n",
    "不要忘了 IPython 可以快速浏览软件包的内容（通过 Tab 键补全功\n",
    "能），以及各种函数的文档（使用 ?）。\n",
    "\n",
    "例如，可以通过按下 Tab 键显示 pandas 命名空间的所有内容：\n",
    "\n",
    "```ipython\n",
    "In [3]: pd.<TAB>\n",
    "```\n",
    "\n",
    "如果要显示 Pandas 的内置文档，可以这样做：\n",
    "\n",
    "```ipython\n",
    "In [4]: pd?\n",
    "```\n",
    "\n",
    "详细的文档请参考 http://pandas.pydata.org，里面除了有基础教程，还有许多有用\n",
    "的资源。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 对象简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果从底层视角观察 Pandas 对象，可以把它们看成增强版的 NumPy 结构化数组，行列都\n",
    "不再只是简单的整数索引，还可以带上标签。在后面的内容中我们将会发现，虽然 Pandas 在基本数据结构上实现了许多便利的工具、方法和功能，但是后面将要介绍的每\n",
    "一个工具、方法和功能几乎都需要我们理解基本数据结构的内部细节。因此，在深入学习\n",
    "Pandas 之前，先来看看 Pandas 的三个基本数据结构：Series、DataFrame 和 Index。\n",
    "\n",
    "从导入标准 NumPy 和 Pandas 开始："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 的 Series 对象\n",
    "\n",
    "Pandas 的 Series 对象是一个带索引数据构成的一维数组。可以用一个数组创建 Series 对象，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.25\n",
       "1    0.50\n",
       "2    0.75\n",
       "3    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0])\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的结果中，你会发现 Series 对象将一组数据和一组索引绑定在一起，我们可以通过\n",
    "values 属性和 index 属性获取数据。values 属性返回的结果与 NumPy 数组类似："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "index 属性返回的结果是一个类型为 pd.Index 的类数组对象，我们将在后面的内容里详细介绍它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=4, step=1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和 NumPy 数组一样，数据可以通过 Python 的中括号索引标签获取："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    0.50\n",
       "2    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是我们将会看到，Pandas 的 Series 对象比它模仿的一维 NumPy 数组更加通用、灵活。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Serises 是通用的 NumPy 数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "到目前为止，我们可能觉得 Series 对象和一维 NumPy 数组基本可以等价交换，但两者间的本质差异其实是索引：NumPy 数组通过隐式定义的整数索引获取数值，而 Pandas 的\n",
    "Series 对象用一种显式定义的索引与数值关联。\n",
    "\n",
    "显式索引的定义让 Series 对象拥有了更强的能力。例如，索引不再仅仅是整数，还可以是任意想要的类型。如果需要，完全可以用字符串定义索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "d    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=['a', 'b', 'c', 'd'])\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "获取数值的方式与之前一样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以使用不连续或不按顺序的索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    0.25\n",
       "5    0.50\n",
       "3    0.75\n",
       "7    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=[2, 5, 3, 7])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series 是特殊的字典\n",
    "\n",
    "你可以把 Pandas 的 Series 对象看成一种特殊的 Python 字典。字典是一种将任意键映射到\n",
    "一组任意值的数据结构，而 Series 对象其实是一种将类型键映射到一组类型值的数据结构。类型至关重要：就像 NumPy 数组背后特定类型的经过编译的代码使得它在某些操作上比普通的 Python 列表更加高效一样，Pandas Series 的类型信息使得它在某些操作上比\n",
    "Python 的字典更高效。\n",
    "\n",
    "我们可以直接用 Python 的字典创建一个 Series 对象，让 Series 对象与字典的类比更加清晰："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population_dict = {'California': 38332521,\n",
    "                   'Texas': 26448193,\n",
    "                   'New York': 19651127,\n",
    "                   'Florida': 19552860,\n",
    "                   'Illinois': 12882135}\n",
    "population = pd.Series(population_dict)\n",
    "population"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用字典创建 Series 对象时，其索引默认保持数据原本在字典中的顺序（版本0.23.0及以后）。典型的字典数值获取方式仍然有效："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38332521"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population['California']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和字典不同，Series 对象还支持数组形式的操作，比如切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population['California':'Illinois']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们将在后面介绍 Pandas 取值与切片的一些技巧。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建 Series 对象\n",
    "\n",
    "我们已经见过几种创建 Pandas 的 Series 对象的方法，都是像这样的形式：\n",
    "\n",
    "```python\n",
    ">>> pd.Series(data, index=index)\n",
    "```\n",
    "\n",
    "其中，index 是一个可选参数，data 参数支持多种数据类型。\n",
    "\n",
    "例如，data 可以是列表或 NumPy 数组，这时 index 默认值为整数序列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2\n",
       "1    4\n",
       "2    6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([2, 4, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "data 也可以是一个标量，创建 Series 对象时会重复填充到每个索引上："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100    5\n",
       "200    5\n",
       "300    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(5, index=[100, 200, 300])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "data 还可以是一个字典，index 默认是排序的字典键："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    a\n",
       "1    b\n",
       "3    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series({2:'a', 1:'b', 3:'c'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每一种形式都可以通过显式指定索引筛选需要的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    c\n",
       "2    a\n",
       "dtype: object"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series({2:'a', 1:'b', 3:'c'}, index=[3, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里需要注意的是，Series 对象只会保留显式定义的键值对。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 的 DataFrame 对象\n",
    "\n",
    "Pandas 的另一个基础数据结构是 DataFrame。和之前介绍的 Series 对象一样，DataFrame 既可以作为一个通用型 NumPy 数组，也可以看作特殊的 Python 字典。下面来分别看看。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  DataFrame 是通用的 NumPy 数组\n",
    "\n",
    "如果将 Series 类比为带灵活索引的一维数组，那么 DataFrame 就可以看作是一种既有灵活\n",
    "的行索引，又有灵活列名的二维数组。就像你可以把二维数组看成是有序排列的一维数组\n",
    "一样，你也可以把 DataFrame 看成是有序排列的若干 Series 对象。这里的“排列”指的是\n",
    "它们拥有共同的索引。\n",
    "\n",
    "下面用美国五个州面积的数据创建一个新的 Series 来进行演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "Illinois      149995\n",
       "dtype: int64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area_dict = {'California': 423967, 'Texas': 695662, 'New York': 141297,\n",
    "             'Florida': 170312, 'Illinois': 149995}\n",
    "area = pd.Series(area_dict)\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再结合之前创建的 population 的 Series 对象，用一个字典创建一个包含这些信息的二维\n",
    "对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>area</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "      <td>423967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "      <td>695662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "      <td>149995</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population    area\n",
       "California    38332521  423967\n",
       "Texas         26448193  695662\n",
       "New York      19651127  141297\n",
       "Florida       19552860  170312\n",
       "Illinois      12882135  149995"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states = pd.DataFrame({'population': population,\n",
    "                       'area': area})\n",
    "states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和 Series 对象一样，DataFrame 也有一个 index 属性可以获取索引标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['California', 'Texas', 'New York', 'Florida', 'Illinois'], dtype='object')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，DataFrame 还有一个 columns 属性，是存放列标签的 Index 对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['population', 'area'], dtype='object')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此 DataFrame 可以看作一种通用的 NumPy 二维数组，它的行与列都可以通过索引获取。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  DataFrame 是特殊的字典\n",
    "\n",
    "与 Series 类似，我们也可以把 DataFrame 看成一种特殊的字典。字典是一个键映射一个值，而 DataFrame 是一列映射一个 Series 的数据。例如，通过 'area' 的列属性可以返回\n",
    "包含面积数据的 Series 对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "Illinois      149995\n",
       "Name: area, dtype: int64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states['area']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里需要注意的是，在 NumPy 的二维数组里，data[0] 返回第一行；而在 DataFrame 中，\n",
    "data['col0'] 返回第一列。因此，最好把 DataFrame 看成一种通用字典，而不是通用数\n",
    "组，即使这两种看法在不同情况下都是有用的。后面将介绍更多 DataFrame 灵活取值的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  创建 DataFrame 对象\n",
    "\n",
    "Pandas 的 DataFrame 对象可以通过许多方式创建，这里举几个常用的例子。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  通过单个 Series 对象创建\n",
    "\n",
    "DataFrame 是一组 Series 对象的集合，可以用单个 Series创建一个单列的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population\n",
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(population, columns=['population'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过字典列表创建\n",
    "\n",
    "任何元素是字典的列表都可以变成 DataFrame。用一个简单的列表综合来创建一些数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b\n",
       "0  0  0\n",
       "1  1  2\n",
       "2  2  4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [{'a': i, 'b': 2 * i}\n",
    "        for i in range(3)]\n",
    "pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "即使字典中有些键不存在，Pandas 也会用缺失值 NaN（不是数字，not a number）来表示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a  b    c\n",
       "0  1.0  2  NaN\n",
       "1  NaN  3  4.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([{'a': 1, 'b': 2}, {'b': 3, 'c': 4}])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过 Series 对象字典创建\n",
    "\n",
    "就像之前见过的那样，DataFrame 也可以用一个由 Series对象构成的字典创建："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>area</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "      <td>423967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "      <td>695662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "      <td>149995</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population    area\n",
       "California    38332521  423967\n",
       "Texas         26448193  695662\n",
       "New York      19651127  141297\n",
       "Florida       19552860  170312\n",
       "Illinois      12882135  149995"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame({'population': population,\n",
    "              'area': area})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过 NumPy 二维数组创建\n",
    "\n",
    "假如有一个二维数组，就可以创建一个可以指定行列索引值的 DataFrame。如果不指定行列索引值，那么行列默认都是整数索引值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>foo</th>\n",
       "      <th>bar</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.380397</td>\n",
       "      <td>0.328399</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.303661</td>\n",
       "      <td>0.393356</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>0.363551</td>\n",
       "      <td>0.560917</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        foo       bar\n",
       "a  0.380397  0.328399\n",
       "b  0.303661  0.393356\n",
       "c  0.363551  0.560917"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(np.random.rand(3, 2),\n",
    "             columns=['foo', 'bar'],\n",
    "             index=['a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过 NumPy 结构化数组创建\n",
    "\n",
    "由于 Pandas 的 DataFrame与结构化数组十分相似，因此可以通过结构化数组创建 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([(0, 0.), (0, 0.), (0, 0.)], dtype=[('A', '<i8'), ('B', '<f8')])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.zeros(3, dtype=[('A', 'i8'), ('B', 'f8')])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A    B\n",
       "0  0  0.0\n",
       "1  0  0.0\n",
       "2  0  0.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 的 Index 对象\n",
    "\n",
    "我们已经发现，Series 和 DataFrame 对象都使用便于引用和调整的显式索引。Pandas 的 Index 对象是一个很有趣的数据结构，可以将它看作是一个不可变数组或有序集合（实际上是一个多集，因为 Index 对象可能会包含重复值）。这两种观点使得 Index 对象能呈现一些有趣的功能。让我们用一个简单的整数列表来创建一个 Index 对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([2, 3, 5, 7, 11], dtype='int64')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = pd.Index([2, 3, 5, 7, 11])\n",
    "ind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将 Index 看作不可变数组\n",
    "\n",
    "Index 对象的许多操作都像数组。例如，可以通过标准 Python 的取值方法获取数值，也可以通过切片获取数值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([2, 5, 11], dtype='int64')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index 对象还有许多与 NumPy 数组相似的属性："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 (5,) 1 int64\n"
     ]
    }
   ],
   "source": [
    "print(ind.size, ind.shape, ind.ndim, ind.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index 对象与 NumPy 数组之间的不同在于，Index 对象的索引是不可变的，也就是说不能通过通常的方式进行调整："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Index does not support mutable operations",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb Cell 81'\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000080?line=0'>1</a>\u001b[0m ind[\u001b[39m1\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n",
      "File \u001b[0;32m~/miniconda3/envs/summer2/lib/python3.8/site-packages/pandas/core/indexes/base.py:5021\u001b[0m, in \u001b[0;36mIndex.__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m   <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/pandas/core/indexes/base.py?line=5018'>5019</a>\u001b[0m \u001b[39m@final\u001b[39m\n\u001b[1;32m   <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/pandas/core/indexes/base.py?line=5019'>5020</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__setitem__\u001b[39m(\u001b[39mself\u001b[39m, key, value):\n\u001b[0;32m-> <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/pandas/core/indexes/base.py?line=5020'>5021</a>\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mIndex does not support mutable operations\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: Index does not support mutable operations"
     ]
    }
   ],
   "source": [
    "ind[1] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index 对象的不可变特征使得多个 DataFrame 和数组之间进行索引共享时更加安全，尤其是可以避免因修改索引时粗心大意而导致的副作用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  将 Index 看作有序集合\n",
    "\n",
    "Pandas 对象被设计用于实现许多操作，如连接（join）数据集，其中会涉及许多集合操作。\n",
    "Index 对象遵循 Python 标准库的集合（set）数据结构的许多习惯用法，包括并集、交集、差集等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "indA = pd.Index([1, 3, 5, 7, 9])\n",
    "indB = pd.Index([2, 3, 5, 7, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([3, 5, 7], dtype='int64')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indA.intersection(indB)  # intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([1, 2, 3, 5, 7, 9, 11], dtype='int64')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indA.union(indB)  # union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([1, 2, 9, 11], dtype='int64')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indA.symmetric_difference(indB)  # symmetric difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据取值与选择"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前具体介绍了获取、设置、调整 NumPy 数组数值的方法与工具，包括取值操作（如arr[2, 1]）、切片操作（如 arr[:, 1:5]）、掩码操作（如 arr[arr > 0]）、花哨的索引操作（如 arr[0, [1, 5]]），以及组合操作（如 arr[:, [1, 5]]）。下面介绍 Pandas 的 Series 和 DataFrame 对象相似的数据获取与调整操作。如果你用过 NumPy 操作模式，就会非常熟悉 Pandas 的操作模式，只是有几个细节需要注意一下。\n",
    "\n",
    "我们将从简单的一维 Series 对象开始，然后再用比较复杂的二维 DataFrame 对象进行演示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Series 数据选择方法\n",
    "\n",
    "如前所述，Series 对象与一维 NumPy 数组和标准 Python 字典在许多方面都一样。只要牢牢记住这两个类比，就可以帮助我们更好地理解 Series 对象的数据索引与选择模式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将Series看作字典\n",
    "\n",
    "和字典一样，Series 对象提供了键值对的映射："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "d    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=['a', 'b', 'c', 'd'])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们还可以用 Python 字典的表达式和方法来检测键 / 索引和值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['a', 'b', 'c', 'd'], dtype='object')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 0.25), ('b', 0.5), ('c', 0.75), ('d', 1.0)]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(data.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series 对象还可以用字典语法调整数据。就像你可以通过增加新的键扩展字典一样，你也可以通过增加新的索引值扩展 Series："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "d    1.00\n",
       "e    1.25\n",
       "dtype: float64"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['e'] = 1.25\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series 对象的可变性是一个非常方便的特性：Pandas 在底层已经为可能发生的内存布局和数据复制自动决策，用户不需要担心这些问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将 Series 看作一维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series 不仅有着和字典一样的接口，而且还具备和 NumPy 数组一样的数组数据选择功能，包括索引、掩码、花哨的索引等操作，具体示例如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing by explicit index\n",
    "data['a':'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing by implicit integer index\n",
    "data[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    0.50\n",
       "c    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# masking\n",
    "data[(data > 0.3) & (data < 0.8)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "e    1.25\n",
       "dtype: float64"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fancy indexing\n",
    "data[['a', 'e']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上示例中，切片是绝大部分混乱之源。需要注意的是，当使用显式索引（即data['a':'c']）作切片时，结果包含最后一个索引；而当使用隐式索引（即 data[0:2]）作切片时，结果不包含最后一个索引。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 索引器：loc 和 iloc\n",
    "\n",
    "这些切片和取值的习惯用法经常会造成混乱。例如，如果你的 Series 是显式整数索引，那么 data[1] 这样的取值操作会使用显式索引，而 data[1:3] 这样的切片操作却会使用隐式索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "3    b\n",
       "5    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series(['a', 'b', 'c'], index=[1, 3, 5])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# explicit index when indexing\n",
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    b\n",
       "5    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# implicit index when slicing\n",
    "data[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于整数索引很容易造成混淆，所以 Pandas 提供了一些索引器（indexer）属性来作为取值的方法。它们不是 Series 对象的函数方法，而是暴露切片接口的属性。\n",
    "\n",
    "第一种索引器是 loc 属性，表示取值和切片都是显式的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.loc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "3    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.loc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二种是 iloc 属性，表示取值和切片都是 Python 形式的隐式索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    b\n",
       "5    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 代码的设计原则之一是“显式优于隐式”。使用 loc 和 iloc 可以让代码更容易维护，可读性更高。特别是在处理整数索引的对象时，我强烈推荐使用这两种索引器。它们既可以让代码阅读和理解起来更容易，也能避免因误用索引 / 切片而产生的小 bug。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrame 数据选择方法\n",
    "\n",
    "前面曾提到，DataFrame 在有些方面像二维或结构化数组，在有些方面又像一个共享索引的若干 Series 对象构成的字典。这两种类比可以帮助我们更好地掌握这种数据结构的数据选择方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将 DataFrame 看作字典\n",
    "\n",
    "第一种类比是把 DataFrame 当作一个由若干 Series 对象构成的字典。让我们用之前的美国\n",
    "五州面积与人口数据来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>423967</td>\n",
       "      <td>38332521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>149995</td>\n",
       "      <td>12882135</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              area       pop\n",
       "California  423967  38332521\n",
       "Texas       695662  26448193\n",
       "New York    141297  19651127\n",
       "Florida     170312  19552860\n",
       "Illinois    149995  12882135"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area = pd.Series({'California': 423967, 'Texas': 695662,\n",
    "                  'New York': 141297, 'Florida': 170312,\n",
    "                  'Illinois': 149995})\n",
    "pop = pd.Series({'California': 38332521, 'Texas': 26448193,\n",
    "                 'New York': 19651127, 'Florida': 19552860,\n",
    "                 'Illinois': 12882135})\n",
    "data = pd.DataFrame({'area':area, 'pop':pop})\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两个 Series 分别构成 DataFrame 的一列，可以通过对列名进行字典形式（dictionary-style）\n",
    "的取值获取数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "Illinois      149995\n",
       "Name: area, dtype: int64"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['area']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样，也可以用属性形式（attribute-style）选择纯字符串列名的数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "Illinois      149995\n",
       "Name: area, dtype: int64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对同一个对象进行属性形式与字典形式的列数据，结果是相同的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.area is data['area']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然属性形式的数据选择方法很方便，但是它并不是通用的。如果列名不是纯字符串，或者列名与 DataFrame 的方法同名，那么就不能用属性索引。例如，DataFrame 有一个 pop()方法，如果用 data.pop 就不会获取 'pop' 列，而是显示为方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.pop is data['pop']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，还应该避免对用属性形式选择的列直接赋值（即可以用 data['pop'] = z，但不要用data.pop = z）。\n",
    "\n",
    "和前面介绍的 Series 对象一样，还可以用字典形式的语法调整对象，如果要增加一列可以这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>423967</td>\n",
       "      <td>38332521</td>\n",
       "      <td>90.413926</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "      <td>38.018740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>149995</td>\n",
       "      <td>12882135</td>\n",
       "      <td>85.883763</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              area       pop     density\n",
       "California  423967  38332521   90.413926\n",
       "Texas       695662  26448193   38.018740\n",
       "New York    141297  19651127  139.076746\n",
       "Florida     170312  19552860  114.806121\n",
       "Illinois    149995  12882135   85.883763"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['density'] = data['pop'] / data['area']\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里演示了两个 Series 对象算术运算的简便语法，我们将在后面进行详细介绍。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  将 DataFrame 看作二维数组\n",
    "\n",
    "前面曾提到，可以把 DataFrame 看成是一个增强版的二维数组，用 values 属性按行查看数组数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.23967000e+05, 3.83325210e+07, 9.04139261e+01],\n",
       "       [6.95662000e+05, 2.64481930e+07, 3.80187404e+01],\n",
       "       [1.41297000e+05, 1.96511270e+07, 1.39076746e+02],\n",
       "       [1.70312000e+05, 1.95528600e+07, 1.14806121e+02],\n",
       "       [1.49995000e+05, 1.28821350e+07, 8.58837628e+01]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "理解了这一点，就可以把许多数组操作方式用在 DataFrame 上。例如，可以对 DataFrame进行行列转置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>California</th>\n",
       "      <th>Texas</th>\n",
       "      <th>New York</th>\n",
       "      <th>Florida</th>\n",
       "      <th>Illinois</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>area</th>\n",
       "      <td>4.239670e+05</td>\n",
       "      <td>6.956620e+05</td>\n",
       "      <td>1.412970e+05</td>\n",
       "      <td>1.703120e+05</td>\n",
       "      <td>1.499950e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pop</th>\n",
       "      <td>3.833252e+07</td>\n",
       "      <td>2.644819e+07</td>\n",
       "      <td>1.965113e+07</td>\n",
       "      <td>1.955286e+07</td>\n",
       "      <td>1.288214e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>density</th>\n",
       "      <td>9.041393e+01</td>\n",
       "      <td>3.801874e+01</td>\n",
       "      <td>1.390767e+02</td>\n",
       "      <td>1.148061e+02</td>\n",
       "      <td>8.588376e+01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           California         Texas      New York       Florida      Illinois\n",
       "area     4.239670e+05  6.956620e+05  1.412970e+05  1.703120e+05  1.499950e+05\n",
       "pop      3.833252e+07  2.644819e+07  1.965113e+07  1.955286e+07  1.288214e+07\n",
       "density  9.041393e+01  3.801874e+01  1.390767e+02  1.148061e+02  8.588376e+01"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过字典形式对列进行取值显然会限制我们把 DataFrame 作为 NumPy 数组可以获得的能力，尤其是当我们在 DataFrame 数组中使用单个行索引获取一行数据时："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.23967000e+05, 3.83325210e+07, 9.04139261e+01])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而获取一列数据就需要向 DataFrame 传递单个列索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "Illinois      149995\n",
       "Name: area, dtype: int64"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['area']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "因此，在进行数组形式的取值时，我们就需要用另一种方法——前面介绍过的 Pandas 索引器 loc、iloc 和 ix 了。通过 iloc 索引器，我们就可以像对待 NumPy 数组一样索引 Pandas的底层数组（Python 的隐式索引），DataFrame 的行列标签会自动保留在结果中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>423967</td>\n",
       "      <td>38332521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              area       pop\n",
       "California  423967  38332521\n",
       "Texas       695662  26448193\n",
       "New York    141297  19651127"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[:3, :2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类似地，使用loc索引器，我们可以以类似数组的样式索引底层数据，但要使用显式索引和列名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>423967</td>\n",
       "      <td>38332521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>149995</td>\n",
       "      <td>12882135</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              area       pop\n",
       "California  423967  38332521\n",
       "Texas       695662  26448193\n",
       "New York    141297  19651127\n",
       "Florida     170312  19552860\n",
       "Illinois    149995  12882135"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.loc[:'Illinois', :'pop']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "任何用于处理 NumPy 形式数据的方法都可以用于这些索引器。例如，可以在 loc 索引器中结合使用掩码与花哨的索引方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               pop     density\n",
       "New York  19651127  139.076746\n",
       "Florida   19552860  114.806121"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.loc[data.density > 100, ['pop', 'density']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "任何一种取值方法都可以用于调整数据，这一点和 NumPy 的常用方法是相同的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>423967</td>\n",
       "      <td>38332521</td>\n",
       "      <td>90.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "      <td>38.018740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>149995</td>\n",
       "      <td>12882135</td>\n",
       "      <td>85.883763</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              area       pop     density\n",
       "California  423967  38332521   90.000000\n",
       "Texas       695662  26448193   38.018740\n",
       "New York    141297  19651127  139.076746\n",
       "Florida     170312  19552860  114.806121\n",
       "Illinois    149995  12882135   85.883763"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[0, 2] = 90\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你想熟练使用 Pandas 的数据操作方法，最好花点时间在一个简单的 DataFrame 上练习不同的取值方法，包括查看索引类型、切片、掩码和花哨的索引操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  其他取值方法\n",
    "\n",
    "还有一些取值方法和前面介绍过的方法不太一样。它们虽然看着有点奇怪，但是在实践中还是很好用的。首先，如果对单个标签取值就选择列，而对多个标签用切片就选择行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>149995</td>\n",
       "      <td>12882135</td>\n",
       "      <td>85.883763</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            area       pop     density\n",
       "Florida   170312  19552860  114.806121\n",
       "Illinois  149995  12882135   85.883763"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['Florida':'Illinois']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片也可以不用索引值，而直接用行数来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>695662</td>\n",
       "      <td>26448193</td>\n",
       "      <td>38.018740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            area       pop     density\n",
       "Texas     695662  26448193   38.018740\n",
       "New York  141297  19651127  139.076746"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与之类似，掩码操作也可以直接对每一行进行过滤，而不需要使用 loc 索引器："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area</th>\n",
       "      <th>pop</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>141297</td>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>170312</td>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            area       pop     density\n",
       "New York  141297  19651127  139.076746\n",
       "Florida   170312  19552860  114.806121"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data.density > 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这两种操作方法其实与 NumPy 数组的语法类似，虽然它们与 Pandas 的操作习惯不太一致，但是在实践中非常好用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 数值运算方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy 的基本能力之一是快速对每个元素进行运算，既包括基本算术运算（加、减、乘、除），也包括更复杂的运算（三角函数、指数函数和对数函数等）。Pandas 继承了 NumPy的功能，但是 Pandas 也实现了一些高效技巧：对于一元运算（像函数与三角函数），这些通用函数将在输出结果中保留索引和列标签；而对于二元运算（如加法和乘法），Pandas 在传递通用函数时会自动对齐索引进行计算。这就意味着，保存数据内容与组合不同来源的数据——两处在 NumPy 数组中都容易出错的地方——变成了 Pandas 的杀手锏。后面还会介绍一些关于一维 Series 和二维 DataFrame 的便捷运算方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通用函数：保留索引\n",
    "\n",
    "因为 Pandas 是建立在 NumPy 基础之上的，所以 NumPy 的通用函数同样适用于 Pandas 的Series 和 DataFrame 对象。让我们用一个简单的 Series 和 DataFrame 来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6\n",
       "1    3\n",
       "2    7\n",
       "3    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "ser = pd.Series(rng.randint(0, 10, 4))\n",
    "ser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A  B  C  D\n",
       "0  6  9  2  6\n",
       "1  7  4  3  7\n",
       "2  7  2  5  4"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(rng.randint(0, 10, (3, 4)),\n",
    "                  columns=['A', 'B', 'C', 'D'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果对这两个对象的其中一个使用 NumPy 通用函数，生成的结果是另一个保留索引的Pandas 对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     403.428793\n",
       "1      20.085537\n",
       "2    1096.633158\n",
       "3      54.598150\n",
       "dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(ser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者，再做一个比较复杂的运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.000000</td>\n",
       "      <td>7.071068e-01</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-1.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.224647e-16</td>\n",
       "      <td>0.707107</td>\n",
       "      <td>-7.071068e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.224647e-16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A             B         C             D\n",
       "0 -1.000000  7.071068e-01  1.000000 -1.000000e+00\n",
       "1 -0.707107  1.224647e-16  0.707107 -7.071068e-01\n",
       "2 -0.707107  1.000000e+00 -0.707107  1.224647e-16"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(df * np.pi / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通用函数：索引对齐\n",
    "\n",
    "当在两个 Series 或 DataFrame 对象上进行二元计算时，Pandas 会在计算过程中对齐两个对象的索引。当你处理不完整的数据时，这一点非常方便，我们将在后面的示例中看到。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Series 索引对齐\n",
    "\n",
    "来看一个例子，假如你要整合两个数据源的数据，其中一个是美国面积最大的三个州的面 积数据，另一个是美国人口最多的三个州的人口数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "area = pd.Series({'Alaska': 1723337, 'Texas': 695662,\n",
    "                  'California': 423967}, name='area')\n",
    "population = pd.Series({'California': 38332521, 'Texas': 26448193,\n",
    "                        'New York': 19651127}, name='population')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "来看看如果用人口除以面积会得到什么样的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Alaska              NaN\n",
       "California    90.413926\n",
       "New York            NaN\n",
       "Texas         38.018740\n",
       "dtype: float64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population / area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果数组的索引是两个输入数组索引的并集。我们也可以用 Python 标准库的集合运算法则来获得这个索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Alaska', 'California', 'New York', 'Texas'], dtype='object')"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area.index.union(population.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于缺失位置的数据，Pandas 会用 NaN 填充，表示“此处无数”。这是 Pandas 表示缺失值的方法。这种索引对齐方式是通过 Python 内置的集合运算规则实现的，任何缺失值默认都用 NaN 填充："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    NaN\n",
       "1    5.0\n",
       "2    9.0\n",
       "3    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = pd.Series([2, 4, 6], index=[0, 1, 2])\n",
    "B = pd.Series([1, 3, 5], index=[1, 2, 3])\n",
    "A + B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果用 NaN 值不是我们想要的结果，那么可以用适当的对象方法代替运算符。例如，A.add(B) 等价于 A + B，也可以设置参数自定义 A 或 B 缺失的数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2.0\n",
       "1    5.0\n",
       "2    9.0\n",
       "3    5.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.add(B, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame 索引对齐\n",
    "\n",
    "在计算两个 DataFrame 时，类似的索引对齐规则也同样会出现在共同（并集）列中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A   B\n",
       "0  1  11\n",
       "1  5   1"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = pd.DataFrame(rng.randint(0, 20, (2, 2)),\n",
    "                 columns=list('AB'))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   B  A  C\n",
       "0  4  0  9\n",
       "1  5  8  0\n",
       "2  9  2  6"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = pd.DataFrame(rng.randint(0, 10, (3, 3)),\n",
    "                 columns=list('BAC'))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>13.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B   C\n",
       "0   1.0  15.0 NaN\n",
       "1  13.0   6.0 NaN\n",
       "2   NaN   NaN NaN"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你会发现，两个对象的行列索引可以是不同顺序的，结果的索引会自动按顺序排列。在Series 中，我们可以通过运算符方法的 fill_value 参数自定义缺失值。这里，我们将用 A中所有值的均值来填充缺失值（计算 A 的均值需要用 stack 将二维数组压缩成一维数组）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>13.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>13.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6.5</td>\n",
       "      <td>13.5</td>\n",
       "      <td>10.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B     C\n",
       "0   1.0  15.0  13.5\n",
       "1  13.0   6.0   4.5\n",
       "2   6.5  13.5  10.5"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill = A.stack().mean()\n",
    "A.add(B, fill_value=fill)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下表列举了与 Python 运算符相对应的 Pandas 对象方法。\n",
    "\n",
    "| Python Operator | Pandas Method(s)                      |\n",
    "|-----------------|---------------------------------------|\n",
    "| ``+``           | ``add()``                             |\n",
    "| ``-``           | ``sub()``, ``subtract()``             |\n",
    "| ``*``           | ``mul()``, ``multiply()``             |\n",
    "| ``/``           | ``truediv()``, ``div()``, ``divide()``|\n",
    "| ``//``          | ``floordiv()``                        |\n",
    "| ``%``           | ``mod()``                             |\n",
    "| ``**``          | ``pow()``                             |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通用函数：DataFrame 与 Series 的运算\n",
    "\n",
    "我们经常需要对一个 DataFrame 和一个 Series 进行计算，行列对齐方式与之前类似。也就是说，DataFrame 和 Series 的运算规则，与 NumPy 中二维数组与一维数组的运算规则是一样的。来看一个常见运算，让一个二维数组减去自身的一行数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 8, 2, 4],\n",
       "       [2, 6, 4, 8],\n",
       "       [6, 1, 3, 8]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rng.randint(10, size=(3, 4))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  0],\n",
       "       [-1, -2,  2,  4],\n",
       "       [ 3, -7,  1,  4]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A - A[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "根据 NumPy 的广播规则，让二维数组减自身的一行数据会按行计算。在 Pandas 里默认也是按行运算的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1</td>\n",
       "      <td>-2</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>-7</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Q  R  S  T\n",
       "0  0  0  0  0\n",
       "1 -1 -2  2  4\n",
       "2  3 -7  1  4"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(A, columns=list('QRST'))\n",
    "df - df.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你想按列计算，那么就需要利用前面介绍过的运算符方法，通过 axis 参数设置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-5</td>\n",
       "      <td>0</td>\n",
       "      <td>-6</td>\n",
       "      <td>-4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-4</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Q  R  S  T\n",
       "0 -5  0 -6 -4\n",
       "1 -4  0 -2  2\n",
       "2  5  0  2  7"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.subtract(df['R'], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你会发现 DataFrame / Series 的运算与前面介绍的运算一样，结果的索引都会自动对齐："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Q    3\n",
       "S    2\n",
       "Name: 0, dtype: int64"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halfrow = df.iloc[0, ::2]\n",
    "halfrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Q   R    S   T\n",
       "0  0.0 NaN  0.0 NaN\n",
       "1 -1.0 NaN  2.0 NaN\n",
       "2  3.0 NaN  1.0 NaN"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df - halfrow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这些行列索引的保留与对齐方法说明 Pandas 在运算时会一直保存这些数据内容，从而避免在处理数据类型有差异和 / 或维度不一致的 NumPy 数组时可能遇到的问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 处理缺失值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们将介绍一些处理缺失值的通用规则，Pandas 对缺失值的表现形式，并演示 Pandas 自带的几个处理缺失值的工具的用法。涉及的缺失值主要有三种形式：null、NaN 或 NA。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 选择处理缺失值的方法\n",
    "\n",
    "在数据表或 DataFrame 中有很多识别缺失值的方法。一般情况下可以分为两种：一种方法是通过一个覆盖全局的掩码表示缺失值，另一种方法是用一个标签值（sentinel value）表示缺失值。\n",
    "\n",
    "在掩码方法中，掩码可能是一个与原数组维度相同的完整布尔类型数组，也可能是用一个比特（0 或 1）表示有缺失值的局部状态。\n",
    "\n",
    "在标签方法中，标签值可能是具体的数据（例如用 -9999 表示缺失的整数），也可能是些极少出现的形式。另外，标签值还可能是更全局的值，比如用 NaN（不是一个数）表示缺失的浮点数，它是 IEEE 浮点数规范中指定的特殊字符。\n",
    "\n",
    "使用这两种方法之前都需要先综合考量：使用单独的掩码数组会额外出现一个布尔类型数组，从而增加存储与计算的负担；而标签值方法缩小了可以被表示为有效值的范围，可能需要在 CPU 或 GPU 算术逻辑单元中增加额外的（往往也不是最优的）计算逻辑。通常使用的 NaN 也不能表示所有数据类型。\n",
    "\n",
    "大多数情况下，都不存在最佳选择，不同的编程语言与系统使用不同的方法。例如，R 语言在每种数据类型中保留一个比特作为缺失数据的标签值，而 SciDB 系统会在每个单元后面加一个额外的字节表示 NA 状态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 的缺失值\n",
    "\n",
    "Pandas 里处理缺失值的方式延续了 NumPy 程序包的方式，并没有为浮点数据类型提供内置的 NA 作为缺失值。\n",
    "\n",
    "Pandas 原本也可以按照 R 语言采用的比特模式为每一种数据类型标注缺失值，但是这种方法非常笨拙。R 语言包含 4 种基本数据类型，而 NumPy 支持的类型远超 4 种。例如，R 语言只有一种整数类型，而 NumPy 支持 14 种基本的整数类型，可以根据精度、符号、编码类型按需选择。如果要为 NumPy 的每种数据类型都设置一个比特标注缺失值，可能需要为不同类型的不同操作耗费大量的时间与精力，其工作量几乎相当于创建一个新的 NumPy程序包。另外，对于一些较小的数据类型（例如 8 位整型数据），牺牲一个比特作为缺失值标注的掩码还会导致其数据范围缩小。\n",
    "\n",
    "当然，NumPy 也是支持掩码数据的，也就是说可以用一个布尔掩码数组为原数组标注“无缺失值”或“有缺失值”。Pandas 也集成了这个功能，但是在存储、计算和编码维护方面都需要耗费不必要的资源，因此这种方式并不可取。\n",
    "\n",
    "综合考虑各种方法的优缺点，Pandas 最终选择用标签方法表示缺失值，包括两种 Python 原有的缺失值：浮点数据类型的 NaN 值，以及 Python 的 None 对象。后面我们将会发现，虽然这么做也会有一些副作用，但是在实际运用中的效果还是不错的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### None：Python 对象类型的缺失值\n",
    "\n",
    "Pandas 可以使用的第一种缺失值标签是 None，它是一个 Python 单体对象，经常在代码中表示缺失值。由于 None 是一个 Python 对象，所以不能作为任何 NumPy / Pandas 数组类型的缺失值，只能用于 'object' 数组类型（即由 Python 对象构成的数组）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, None, 3, 4], dtype=object)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals1 = np.array([1, None, 3, 4])\n",
    "vals1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里 dtype=object 表示 NumPy 认为由于这个数组是 Python 对象构成的，因此将其类型判断为 object。虽然这种类型在某些情景中非常有用，对数据的任何操作最终都会在Python 层面完成，但是在进行常见的快速操作时，这种类型比其他原生类型数组要消耗更多的资源："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype = object\n",
      "84.4 ms ± 2.48 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "\n",
      "dtype = int\n",
      "1.35 ms ± 72.5 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for dtype in ['object', 'int']:\n",
    "    print(\"dtype =\", dtype)\n",
    "    %timeit np.arange(1E6, dtype=dtype).sum()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 Python 对象构成的数组就意味着如果你对一个包含 None 的数组进行累计操作，如sum() 或者 min()，那么通常会出现类型错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'NoneType'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb Cell 206'\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000205?line=0'>1</a>\u001b[0m vals1\u001b[39m.\u001b[39;49msum()\n",
      "File \u001b[0;32m~/miniconda3/envs/summer2/lib/python3.8/site-packages/numpy/core/_methods.py:48\u001b[0m, in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m     <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/numpy/core/_methods.py?line=45'>46</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_sum\u001b[39m(a, axis\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, dtype\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, out\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, keepdims\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m,\n\u001b[1;32m     <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/numpy/core/_methods.py?line=46'>47</a>\u001b[0m          initial\u001b[39m=\u001b[39m_NoValue, where\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[0;32m---> <a href='file:///~/miniconda3/envs/summer2/lib/python3.8/site-packages/numpy/core/_methods.py?line=47'>48</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m umr_sum(a, axis, dtype, out, keepdims, initial, where)\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
     ]
    }
   ],
   "source": [
    "vals1.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这就是说，在 Python 中没有定义整数与 None 之间的加法运算。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  NaN：数值类型的缺失值\n",
    "\n",
    "另一种缺失值的标签是 NaN（全称 Not a Number，不是一个数字），是一种按照 IEEE 浮点\n",
    "数标准设计、在任何系统中都兼容的特殊浮点数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals2 = np.array([1, np.nan, 3, 4]) \n",
    "vals2.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意，NumPy 会为这个数组选择一个原生浮点类型，这意味着和之前的 object 类型数组不同，这个数组会被编译成 C 代码从而实现快速操作。你可以把 NaN 看作是一个数据类病毒——它会将与它接触过的数据同化。无论和 NaN 进行何种操作，最终结果都是 NaN："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 *  np.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然这些累计操作的结果定义是合理的（即不会抛出异常），但是并非总是有效的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(nan, nan, nan)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals2.sum(), vals2.min(), vals2.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy 也提供了一些特殊的累计函数，它们可以忽略缺失值的影响："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.0, 1.0, 4.0)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "谨记，NaN 是一种特殊的浮点数，不是整数、字符串以及其他数据类型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Pandas 中 NaN 与 None 的差异\n",
    "\n",
    "虽然 NaN 与 None 各有各的用处，但是 Pandas 把它们看成是可以等价交换的，在适当的时候会将两者进行替换："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       1\n",
       "1    <NA>\n",
       "2       2\n",
       "3    <NA>\n",
       "dtype: Int64"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([1, np.nan, 2, None], dtype=pd.Int64Dtype())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 会将没有标签值的数据类型自动转换为 NA。例如，当我们将整型数组中的一个值设置为 np.nan 时，这个值就会强制转换成浮点数缺失值 NA。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = pd.Series(range(2), dtype=int)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    NaN\n",
       "1    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0] = None\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从 1.0.0 版本开始，Pandas 增加了一个原生的缺失值 pd.NA，在 pd.array 中表示缺失值，替换了原来使用的 None 和 NaN。但为了向后兼容，Series 对象在默认情况下仍然会将整形数组强制转换为浮点数数组，用 NaN 代表缺失值。因此，最好的办法是在构造时显式地声明 dtype，避免由于强制转换造成类型上的问题。\n",
    "\n",
    "尽管这些仿佛会魔法的类型比 R 语言等专用统计语言的缺失值要复杂一些，但是 Pandas 的标签 / 转换方法在实践中的效果非常好。\n",
    "\n",
    "需要注意的是，Pandas 中字符串类型的数据通常是用 object 类型存储的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 处理缺失值\n",
    "\n",
    "我们已经知道，Pandas 基本上把 None 和 NaN 看成是可以等价交换的缺失值形式。为了完成这种交换过程，Pandas 提供了一些方法来发现、剔除、替换数据结构中的缺失值，主要包括以下几种。\n",
    "\n",
    "- ``isnull()``: 创建一个布尔类型的掩码标签缺失值。\n",
    "- ``notnull()``: 与 ``isnull()``操作相反\n",
    "- ``dropna()``: 返回一个剔除缺失值的数据。\n",
    "- ``fillna()``: 返回一个填充了缺失值的数据副本。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 发现缺失值\n",
    "Pandas 数据结构有两种有效的方法可以发现缺失值：isnull() 和 notnull()。每种方法都\n",
    "返回布尔类型的掩码数据，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = pd.Series([1, np.nan, 'hello', None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就像在前面介绍的，布尔类型掩码数组可以直接作为 Series 或 DataFrame 的索引使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        1\n",
       "2    hello\n",
       "dtype: object"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data.notnull()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Series 里使用的 isnull() 和 notnull() 同样适用于 DataFrame，产生的结果同样是布尔类型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 剔除缺失值\n",
    "\n",
    "除了前面介绍的掩码方法，还有两种很好用的缺失值处理方法，分别是 dropna()（剔除缺失值）和 fillna()（填充缺失值）。在 Series 上使用这些方法非常简单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        1\n",
       "2    hello\n",
       "dtype: object"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而在 DataFrame 上使用它们时需要设置一些参数，例如下面的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "0  1.0  NaN  2\n",
       "1  2.0  3.0  5\n",
       "2  NaN  4.0  6"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame([[1,      np.nan, 2],\n",
    "                   [2,      3,      5],\n",
    "                   [np.nan, 4,      6]])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们没法从 DataFrame 中单独剔除一个值，要么是剔除缺失值所在的整行，要么是整列。根据实际需求，有时你需要剔除整行，有时可能是整列，DataFrame 中的 dropna() 会有一些参数可以配置。\n",
    "\n",
    "默认情况下，dropna() 会剔除任何包含缺失值的整行数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "1  2.0  3.0  5"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以设置按不同的坐标轴剔除缺失值，比如 axis=1（或 axis='columns'）会剔除任何包含缺失值的整列数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   2\n",
       "0  2\n",
       "1  5\n",
       "2  6"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是这么做也会把非缺失值一并剔除，因为可能有时候只需要剔除全部是缺失值的行或列，或者绝大多数是缺失值的行或列。这些需求可以通过设置 how 或 thresh 参数来满足，它们可以设置剔除行或列缺失值的数量阈值。\n",
    "\n",
    "默认设置是 how='any'，也就是说只要有缺失值就剔除整行或整列（通过 axis 设置坐标轴）。你还可以设置 how='all'，这样就只会剔除全部是缺失值的行或列了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  NaN  2 NaN\n",
       "1  2.0  3.0  5 NaN\n",
       "2  NaN  4.0  6 NaN"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[3] = np.nan\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "0  1.0  NaN  2\n",
       "1  2.0  3.0  5\n",
       "2  NaN  4.0  6"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='columns', how='all')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以通过 thresh 参数设置行或列中非缺失值的最小数量，从而实现更加个性化的配置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "1  2.0  3.0  5 NaN"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='rows', thresh=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第 1 行与第 3 行被剔除了，因为它们只包含两个非缺失值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  填充缺失值\n",
    "\n",
    "有时候你可能并不想移除缺失值，而是想把它们替换成有效的数值。有效的值可能是像0、1、2 那样单独的值，也可能是经过填充（imputation）或转换（interpolation）得到的。虽然你可以通过 isnull() 方法建立掩码来填充缺失值，但是 Pandas 为此专门提供了一个fillna() 方法，它将返回填充了缺失值后的数组副本。\n",
    "\n",
    "来用下面的 Series 演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    NaN\n",
       "c    2.0\n",
       "d    NaN\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们将用一个单独的值来填充缺失值，例如用 0："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    0.0\n",
       "c    2.0\n",
       "d    0.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用缺失值前面的有效值来从前往后填充（forward-fill）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    1.0\n",
       "c    2.0\n",
       "d    2.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# forward-fill\n",
    "data.fillna(method='ffill')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以用缺失值后面的有效值来从后往前填充（back-fill）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    2.0\n",
       "c    2.0\n",
       "d    3.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# back-fill\n",
    "data.fillna(method='bfill')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "DataFrame 的操作方法与 Series 类似，只是在填充时需要设置坐标轴参数 axis："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  NaN  2 NaN\n",
       "1  2.0  3.0  5 NaN\n",
       "2  NaN  4.0  6 NaN"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1    2    3\n",
       "0  1.0  1.0  2.0  2.0\n",
       "1  2.0  3.0  5.0  5.0\n",
       "2  NaN  4.0  6.0  6.0"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.fillna(method='ffill', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，假如在从前往后填充时，需要填充的缺失值前面没有值，那么它就仍然是缺失值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 层级索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "到目前为止，我们接触的都是一维数据和二维数据，用 Pandas 的 Series 和 DataFrame 对象就可以存储。但我们也经常会遇到存储多维数据的需求，数据索引超过一两个键。因此，Pandas 提供了 Panel 和 Panel4D 对象解决三维数据与四维数据。\n",
    "而在实践中，更直观的形式是通过层级索引（hierarchical indexing，也被称为多级索引，\n",
    "multi-indexing）配合多个有不同等级（level）的一级索引一起使用，这样就可以将高维数组转换成类似一维 Series 和二维 DataFrame 对象的形式。 \n",
    "\n",
    "接下来我们将介绍创建 MultiIndex 对象的方法，多级索引数据的取值、切片和统计值的计算，以及普通索引与层级索引的转换方法。\n",
    "\n",
    "首先导入 Pandas 和 NumPy："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 多级索引 Series\n",
    "\n",
    "让我们看看如何用一维的 Series 对象表示二维数据——用一系列包含特征与数值的数据点来简单演示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "###  笨办法\n",
    "\n",
    "假设你想要分析美国各州在两个不同年份的数据。如果你用前面介绍的 Pandas 工具来处理，那么可能会用一个 Python 元组来表示索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(California, 2000)    33871648\n",
       "(California, 2010)    37253956\n",
       "(New York, 2000)      18976457\n",
       "(New York, 2010)      19378102\n",
       "(Texas, 2000)         20851820\n",
       "(Texas, 2010)         25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = [('California', 2000), ('California', 2010),\n",
    "         ('New York', 2000), ('New York', 2010),\n",
    "         ('Texas', 2000), ('Texas', 2010)]\n",
    "populations = [33871648, 37253956,\n",
    "               18976457, 19378102,\n",
    "               20851820, 25145561]\n",
    "pop = pd.Series(populations, index=index)\n",
    "pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "通过元组构成的多级索引，你可以直接在 Series 上取值或用切片查询数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(California, 2010)    37253956\n",
       "(New York, 2000)      18976457\n",
       "(New York, 2010)      19378102\n",
       "(Texas, 2000)         20851820\n",
       "dtype: int64"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[('California', 2010):('Texas', 2000)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "但是这么做很不方便。假如你想要选择所有 2000 年的数据，那么就得用一些比较复杂的（可能也比较慢的）方法了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(California, 2010)    37253956\n",
       "(New York, 2010)      19378102\n",
       "(Texas, 2010)         25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[[i for i in pop.index if i[1] == 2010]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "这么做虽然也能得到需要的结果，但是与 Pandas 令人爱不释手的切片语法相比，这种方法确实不够简洁（在处理较大的数据时也不够高效）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "###  好办法：Pandas 多级索引\n",
    "好在 Pandas 提供了更好的解决方案。用元组表示索引其实是多级索引的基础，Pandas\n",
    "的 MultiIndex 类型提供了更丰富的操作方法。我们可以用元组创建一个多级索引，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([('California', 2000),\n",
       "            ('California', 2010),\n",
       "            (  'New York', 2000),\n",
       "            (  'New York', 2010),\n",
       "            (     'Texas', 2000),\n",
       "            (     'Texas', 2010)],\n",
       "           )"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = pd.MultiIndex.from_tuples(index)\n",
    "index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果将前面创建的 pop 的索引重置（reindex）为 MultiIndex，就会看到层级索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop = pop.reindex(index)\n",
    "pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "其中前两列表示 Series 的多级索引值，第三列是数据。你会发现有些行仿佛缺失了第一列数据——这其实是多级索引的表现形式，每个空格与上面的索引相同。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "现在可以直接用第二个索引获取 2010 年的全部数据，与 Pandas 的切片查询用法一致："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    37253956\n",
       "New York      19378102\n",
       "Texas         25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[:, 2010]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "结果是单索引的数组，正是我们需要的。与之前的元组索引相比，多级索引的语法更简洁。（操作也更方便！）下面继续介绍层级索引的取值操作方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 高维数据的多级索引\n",
    "\n",
    "你可能已经注意到，我们其实完全可以用一个带行列索引的简单 DataFrame 代替前面的多级索引。其实 Pandas 已经实现了类似的功能。unstack() 方法可以快速将一个多级索引的Series 转化为普通索引的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2000</th>\n",
       "      <th>2010</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>33871648</td>\n",
       "      <td>37253956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>18976457</td>\n",
       "      <td>19378102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>20851820</td>\n",
       "      <td>25145561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                2000      2010\n",
       "California  33871648  37253956\n",
       "New York    18976457  19378102\n",
       "Texas       20851820  25145561"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_df = pop.unstack()\n",
    "pop_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "当然了，也有 stack() 方法实现相反的效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_df.stack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "你可能会纠结于为什么要费时间研究层级索引。其实理由很简单：如果我们可以用含多级索引的一维 Series 数据表示二维数据，那么我们就可以用 Series 或 DataFrame 表示三维甚至更高维度的数据。多级索引每增加一级，就表示数据增加一维，利用这一特点就可以轻松表示任意维度的数据了。假如要增加一列显示每一年各州的人口统计指标（例如 18岁以下的人口），那么对于这种带有 MultiIndex 的对象，增加一列就像 DataFrame 的操作一样简单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>total</th>\n",
       "      <th>under18</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">California</th>\n",
       "      <th>2000</th>\n",
       "      <td>33871648</td>\n",
       "      <td>9267089</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>37253956</td>\n",
       "      <td>9284094</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">New York</th>\n",
       "      <th>2000</th>\n",
       "      <td>18976457</td>\n",
       "      <td>4687374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>19378102</td>\n",
       "      <td>4318033</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Texas</th>\n",
       "      <th>2000</th>\n",
       "      <td>20851820</td>\n",
       "      <td>5906301</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>25145561</td>\n",
       "      <td>6879014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    total  under18\n",
       "California 2000  33871648  9267089\n",
       "           2010  37253956  9284094\n",
       "New York   2000  18976457  4687374\n",
       "           2010  19378102  4318033\n",
       "Texas      2000  20851820  5906301\n",
       "           2010  25145561  6879014"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_df = pd.DataFrame({'total': pop,\n",
    "                       'under18': [9267089, 9284094,\n",
    "                                   4687374, 4318033,\n",
    "                                   5906301, 6879014]})\n",
    "pop_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "另外，所有在之前介绍过的通用函数和其他功能也同样适用于层级索引。我们可以计算上面数据中 18 岁以下的人口占总人口的比例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2000</th>\n",
       "      <th>2010</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>0.273594</td>\n",
       "      <td>0.249211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>0.247010</td>\n",
       "      <td>0.222831</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>0.283251</td>\n",
       "      <td>0.273568</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                2000      2010\n",
       "California  0.273594  0.249211\n",
       "New York    0.247010  0.222831\n",
       "Texas       0.283251  0.273568"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f_u18 = pop_df['under18'] / pop_df['total']\n",
    "f_u18.unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "同样，我们也可以快速浏览和操作高维数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 多级索引的创建方法\n",
    "\n",
    "为 Series 或 DataFrame 创建多级索引最直接的办法就是将 index 参数设置为至少二维的索引数组，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">a</th>\n",
       "      <th>1</th>\n",
       "      <td>0.332320</td>\n",
       "      <td>0.854627</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.009528</td>\n",
       "      <td>0.536031</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">b</th>\n",
       "      <th>1</th>\n",
       "      <td>0.987409</td>\n",
       "      <td>0.277708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.843856</td>\n",
       "      <td>0.327978</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        data1     data2\n",
       "a 1  0.332320  0.854627\n",
       "  2  0.009528  0.536031\n",
       "b 1  0.987409  0.277708\n",
       "  2  0.843856  0.327978"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(np.random.rand(4, 2),\n",
    "                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],\n",
    "                  columns=['data1', 'data2'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "MultiIndex 的创建工作将在后台完成。\n",
    "\n",
    "同理，如果你把将元组作为键的字典传递给 Pandas， Pandas 也会默认转换为 MultiIndex："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "dtype: int64"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = {('California', 2000): 33871648,\n",
    "        ('California', 2010): 37253956,\n",
    "        ('Texas', 2000): 20851820,\n",
    "        ('Texas', 2010): 25145561,\n",
    "        ('New York', 2000): 18976457,\n",
    "        ('New York', 2010): 19378102}\n",
    "pd.Series(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "但是有时候显式地创建 MultiIndex 也是很有用的，下面来介绍一些创建方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 显式地创建多级索引\n",
    "\n",
    "你可以用 pd.MultiIndex 中的类方法更加灵活地构建多级索引。例如，就像前面介绍的，你可以通过一个有不同等级的若干简单数组组成的列表来构建 MultiIndex："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([('a', 1),\n",
       "            ('a', 2),\n",
       "            ('b', 1),\n",
       "            ('b', 2)],\n",
       "           )"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], [1, 2, 1, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "也可以通过包含多个索引值的元组构成的列表创建 MultiIndex："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([('a', 1),\n",
       "            ('a', 2),\n",
       "            ('b', 1),\n",
       "            ('b', 2)],\n",
       "           )"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "还可以用两个索引的笛卡尔积（Cartesian product）创建 MultiIndex："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([('a', 1),\n",
       "            ('a', 2),\n",
       "            ('b', 1),\n",
       "            ('b', 2)],\n",
       "           )"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.MultiIndex.from_product([['a', 'b'], [1, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "更可以直接提供 levels（包含每个等级的索引值列表的列表）和 codes（包含每个索引值标签列表的列表）创建 MultiIndex："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([('a', 1),\n",
       "            ('a', 2),\n",
       "            ('b', 1),\n",
       "            ('b', 2)],\n",
       "           )"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.MultiIndex(levels=[['a', 'b'], [1, 2]],\n",
    "              codes=[[0, 0, 1, 1], [0, 1, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "在创建 Series 或 DataFrame 时，可以将这些对象作为 index 参数，或者通过 reindex 方法更新 Series 或 DataFrame 的索引。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 多级索引的等级名称\n",
    "\n",
    "给 MultiIndex 的等级加上名称会为一些操作提供便利。你可以在前面任何一个 MultiIndex构造器中通过 names 参数设置等级名称，也可以在创建之后通过索引的 names 属性来修改名称："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop.index.names = ['state', 'year']\n",
    "pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "在处理复杂的数据时，为等级设置名称是管理多个索引值的好办法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 多级列索引\n",
    "\n",
    "每个 DataFrame 的行与列都是对称的，也就是说既然有多级行索引，那么同样可以有多级列索引。让我们通过一份医学报告的模拟数据来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>subject</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Bob</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Guido</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Sue</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>38.3</td>\n",
       "      <td>38.0</td>\n",
       "      <td>36.2</td>\n",
       "      <td>35.0</td>\n",
       "      <td>38.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>45.0</td>\n",
       "      <td>39.2</td>\n",
       "      <td>41.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>34.0</td>\n",
       "      <td>37.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2014</th>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>36.1</td>\n",
       "      <td>40.0</td>\n",
       "      <td>37.1</td>\n",
       "      <td>41.0</td>\n",
       "      <td>38.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>25.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>33.0</td>\n",
       "      <td>37.6</td>\n",
       "      <td>33.0</td>\n",
       "      <td>34.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject      Bob       Guido         Sue      \n",
       "type          HR  Temp    HR  Temp    HR  Temp\n",
       "year visit                                    \n",
       "2013 1      38.0  38.3  38.0  36.2  35.0  38.8\n",
       "     2      45.0  39.2  41.0  37.4  34.0  37.2\n",
       "2014 1      50.0  36.1  40.0  37.1  41.0  38.2\n",
       "     2      25.0  37.4  33.0  37.6  33.0  34.7"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hierarchical indices and columns\n",
    "index = pd.MultiIndex.from_product([[2013, 2014], [1, 2]],\n",
    "                                   names=['year', 'visit'])\n",
    "columns = pd.MultiIndex.from_product([['Bob', 'Guido', 'Sue'], ['HR', 'Temp']],\n",
    "                                     names=['subject', 'type'])\n",
    "\n",
    "# mock some data\n",
    "data = np.round(np.random.randn(4, 6), 1)\n",
    "data[:, ::2] *= 10\n",
    "data += 37\n",
    "\n",
    "# create the DataFrame\n",
    "health_data = pd.DataFrame(data, index=index, columns=columns)\n",
    "health_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "多级行列索引的创建非常简单。上面创建了一个简易的四维数据，四个维度分别为被检查人的姓名、检查项目、检查年份和检查次数。可以在列索引的第一级查询姓名，从而获取包含一个人（例如 Guido）全部检查信息的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>36.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>41.0</td>\n",
       "      <td>37.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2014</th>\n",
       "      <th>1</th>\n",
       "      <td>40.0</td>\n",
       "      <td>37.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>33.0</td>\n",
       "      <td>37.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "type          HR  Temp\n",
       "year visit            \n",
       "2013 1      38.0  36.2\n",
       "     2      41.0  37.4\n",
       "2014 1      40.0  37.1\n",
       "     2      33.0  37.6"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data['Guido']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果想获取包含多种标签的数据，需要通过对多个维度（姓名、国家、城市等标签）的多次查询才能实现，这时使用多级行列索引进行查询会非常方便。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 多级索引的取值与切片\n",
    "\n",
    "对 MultiIndex 的取值和切片操作很直观，你可以直接把索引看成额外增加的维度。我们先来介绍 Series 多级索引的取值与切片方法，再介绍 DataFrame 的用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Series多级索引\n",
    "\n",
    "看看下面由各州历年人口数量创建的多级索引 Series："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "可以通过对多个级别索引值获取单个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33871648"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop['California', 2000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "MultiIndex 也支持局部取值（partial indexing），即只取索引的某一个层级。假如只取最高级的索引，获得的结果是一个新的 Series，未被选中的低层索引值会被保留："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "year\n",
       "2000    33871648\n",
       "2010    37253956\n",
       "dtype: int64"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop['California']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "类似的还有局部切片，不过要求 MultiIndex 是按顺序排列的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "dtype: int64"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop.loc['California':'New York']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果索引已经排序，那么可以用较低层级的索引取值，第一层级的索引可以用空切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state\n",
       "California    33871648\n",
       "New York      18976457\n",
       "Texas         20851820\n",
       "dtype: int64"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[:, 2000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "其他取值与数据选择的方法也都起作用。下面的例子是通过布尔掩码选择数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "Texas       2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[pop > 22000000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "也可以用花哨的索引选择数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[['California', 'Texas']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### DataFrame多级索引\n",
    "\n",
    "DataFrame 多级索引的用法与 Series 类似。还用之前的体检报告数据来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>subject</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Bob</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Guido</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Sue</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>38.3</td>\n",
       "      <td>38.0</td>\n",
       "      <td>36.2</td>\n",
       "      <td>35.0</td>\n",
       "      <td>38.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>45.0</td>\n",
       "      <td>39.2</td>\n",
       "      <td>41.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>34.0</td>\n",
       "      <td>37.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2014</th>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>36.1</td>\n",
       "      <td>40.0</td>\n",
       "      <td>37.1</td>\n",
       "      <td>41.0</td>\n",
       "      <td>38.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>25.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>33.0</td>\n",
       "      <td>37.6</td>\n",
       "      <td>33.0</td>\n",
       "      <td>34.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject      Bob       Guido         Sue      \n",
       "type          HR  Temp    HR  Temp    HR  Temp\n",
       "year visit                                    \n",
       "2013 1      38.0  38.3  38.0  36.2  35.0  38.8\n",
       "     2      45.0  39.2  41.0  37.4  34.0  37.2\n",
       "2014 1      50.0  36.1  40.0  37.1  41.0  38.2\n",
       "     2      25.0  37.4  33.0  37.6  33.0  34.7"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "由于 DataFrame 的基本索引是列索引，因此 Series 中多级索引的用法到了 DataFrame 中就应用在列上了。例如，可以通过简单的操作获取 Guido 的心率数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "year  visit\n",
       "2013  1        38.0\n",
       "      2        41.0\n",
       "2014  1        40.0\n",
       "      2        33.0\n",
       "Name: (Guido, HR), dtype: float64"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data['Guido', 'HR']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "与单索引类似，loc和iloc索引器都可以使用，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>subject</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Bob</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>38.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>45.0</td>\n",
       "      <td>39.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject      Bob      \n",
       "type          HR  Temp\n",
       "year visit            \n",
       "2013 1      38.0  38.3\n",
       "     2      45.0  39.2"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data.iloc[:2, :2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "虽然这些索引器将多维数据当作二维数据处理，但是在 loc 和 iloc 中可以传递多个层级的索引元组，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "year  visit\n",
       "2013  1        38.0\n",
       "      2        45.0\n",
       "2014  1        50.0\n",
       "      2        25.0\n",
       "Name: (Bob, HR), dtype: float64"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data.loc[:, ('Bob', 'HR')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "这种索引元组的用法不是很方便，如果在元组中使用切片还会导致语法错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3311942670.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [154]\u001b[0;36m\u001b[0m\n\u001b[0;31m    health_data.loc[(:, 1), (:, 'HR')]\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "health_data.loc[(:, 1), (:, 'HR')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "虽然你可以用 Python 内置的 slice() 函数获取想要的切片，但是还有一种更好的办法，就是使用 IndexSlice 对象。Pandas 专门用它解决这类问题，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>subject</th>\n",
       "      <th>Bob</th>\n",
       "      <th>Guido</th>\n",
       "      <th>Sue</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>HR</th>\n",
       "      <th>HR</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>38.0</td>\n",
       "      <td>35.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>41.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject      Bob Guido   Sue\n",
       "type          HR    HR    HR\n",
       "year visit                  \n",
       "2013 1      38.0  38.0  35.0\n",
       "2014 1      50.0  40.0  41.0"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = pd.IndexSlice\n",
    "health_data.loc[idx[:, 1], idx[:, 'HR']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 多级索引行列转换\n",
    "\n",
    "使用多级索引的关键是掌握有效数据转换的方法。Pandas 提供了许多操作，可以让数据在内容保持不变的同时，按照需要进行行列转换。之前我们用一个简短的例子演示过stack() 和 unstack() 的用法，但其实还有许多合理控制层级行列索引的方法，让我们来一探究竟。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 有序的索引和无序的索引\n",
    "\n",
    "在前面我们曾经简单提过多级索引排序，这里需要详细介绍一下。如果MultiIndex 不是有序的索引，那么大多数切片操作都会失败。让我们演示一下。\n",
    "\n",
    "首先创建一个不按字典顺序（lexographically）排列的多级索引 Series："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "char  int\n",
       "a     1      0.173713\n",
       "      2      0.803474\n",
       "c     1      0.230841\n",
       "      2      0.172203\n",
       "b     1      0.750987\n",
       "      2      0.679482\n",
       "dtype: float64"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = pd.MultiIndex.from_product([['a', 'c', 'b'], [1, 2]])\n",
    "data = pd.Series(np.random.rand(6), index=index)\n",
    "data.index.names = ['char', 'int']\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果想对索引使用局部切片，那么就会出现错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.errors.UnsortedIndexError'>\n",
      "'Key length (1) was greater than MultiIndex lexsort depth (0)'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    data['a':'b']\n",
    "except KeyError as e:\n",
    "    print(type(e))\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "尽管从错误信息里面看不出具体的细节，但问题是出在 MultiIndex 无序排列上。局部切片和许多其他相似的操作都要求 MultiIndex 的各级索引是有序的（即按照字典顺序由 A 至 Z）。为此，Pandas 提供了许多便捷的操作完成排序，如 sort_index() 和 sortlevel() 方法。我们用最简单的 sort_index() 方法来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "char  int\n",
       "a     1      0.173713\n",
       "      2      0.803474\n",
       "b     1      0.750987\n",
       "      2      0.679482\n",
       "c     1      0.230841\n",
       "      2      0.172203\n",
       "dtype: float64"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = data.sort_index()\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "索引排序之后，局部切片就可以正常使用了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "char  int\n",
       "a     1      0.173713\n",
       "      2      0.803474\n",
       "b     1      0.750987\n",
       "      2      0.679482\n",
       "dtype: float64"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['a':'b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 索引 stack 与 unstack\n",
    "\n",
    "前面曾提过，我们可以将一个多级索引数据集转换成简单的二维形式，可以通过 level 参数设置转换的索引层级："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>state</th>\n",
       "      <th>California</th>\n",
       "      <th>New York</th>\n",
       "      <th>Texas</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>33871648</td>\n",
       "      <td>18976457</td>\n",
       "      <td>20851820</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>37253956</td>\n",
       "      <td>19378102</td>\n",
       "      <td>25145561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "state  California  New York     Texas\n",
       "year                                 \n",
       "2000     33871648  18976457  20851820\n",
       "2010     37253956  19378102  25145561"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop.unstack(level=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>year</th>\n",
       "      <th>2000</th>\n",
       "      <th>2010</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>state</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>33871648</td>\n",
       "      <td>37253956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>18976457</td>\n",
       "      <td>19378102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>20851820</td>\n",
       "      <td>25145561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "year            2000      2010\n",
       "state                         \n",
       "California  33871648  37253956\n",
       "New York    18976457  19378102\n",
       "Texas       20851820  25145561"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop.unstack(level=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "unstack() 是 stack() 的逆操作，同时使用这两种方法让数据保持不变："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state       year\n",
       "California  2000    33871648\n",
       "            2010    37253956\n",
       "New York    2000    18976457\n",
       "            2010    19378102\n",
       "Texas       2000    20851820\n",
       "            2010    25145561\n",
       "dtype: int64"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop.unstack().stack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 索引的设置与重置\n",
    "\n",
    "层级数据维度转换的另一种方法是行列标签转换，可以通过 reset_index 方法实现。如果在上面的人口数据 Series 中使用该方法，则会生成一个列标签中包含之前行索引标签state 和 year 的 DataFrame。也可以用数据的 name 属性为列设置名称："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>California</td>\n",
       "      <td>2000</td>\n",
       "      <td>33871648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>California</td>\n",
       "      <td>2010</td>\n",
       "      <td>37253956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>New York</td>\n",
       "      <td>2000</td>\n",
       "      <td>18976457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>New York</td>\n",
       "      <td>2010</td>\n",
       "      <td>19378102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Texas</td>\n",
       "      <td>2000</td>\n",
       "      <td>20851820</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Texas</td>\n",
       "      <td>2010</td>\n",
       "      <td>25145561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state  year  population\n",
       "0  California  2000    33871648\n",
       "1  California  2010    37253956\n",
       "2    New York  2000    18976457\n",
       "3    New York  2010    19378102\n",
       "4       Texas  2000    20851820\n",
       "5       Texas  2010    25145561"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_flat = pop.reset_index(name='population')\n",
    "pop_flat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "在解决实际问题的时候，如果能将类似这样的原始输入数据的列直接转换成 MultiIndex，通常将大有裨益。其实可以通过 DataFrame 的 set_index 方法实现，返回结果就会是一个带多级索引的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>state</th>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">California</th>\n",
       "      <th>2000</th>\n",
       "      <td>33871648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>37253956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">New York</th>\n",
       "      <th>2000</th>\n",
       "      <td>18976457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>19378102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Texas</th>\n",
       "      <th>2000</th>\n",
       "      <td>20851820</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010</th>\n",
       "      <td>25145561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 population\n",
       "state      year            \n",
       "California 2000    33871648\n",
       "           2010    37253956\n",
       "New York   2000    18976457\n",
       "           2010    19378102\n",
       "Texas      2000    20851820\n",
       "           2010    25145561"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_flat.set_index(['state', 'year'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "在实践中，用这种重建索引的方法处理数据集非常好用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 多级索引的数据累计方法\n",
    "\n",
    "前面我们已经介绍过一些 Pandas 自带的数据累计方法，比如 mean()、sum() 和 max()。而对于层级索引数据，可以设置参数 level 实现对数据子集的累计操作。\n",
    "\n",
    "再一次以体检数据为例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>subject</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Bob</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Guido</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Sue</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th>visit</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2013</th>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>38.3</td>\n",
       "      <td>38.0</td>\n",
       "      <td>36.2</td>\n",
       "      <td>35.0</td>\n",
       "      <td>38.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>45.0</td>\n",
       "      <td>39.2</td>\n",
       "      <td>41.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>34.0</td>\n",
       "      <td>37.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">2014</th>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>36.1</td>\n",
       "      <td>40.0</td>\n",
       "      <td>37.1</td>\n",
       "      <td>41.0</td>\n",
       "      <td>38.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>25.0</td>\n",
       "      <td>37.4</td>\n",
       "      <td>33.0</td>\n",
       "      <td>37.6</td>\n",
       "      <td>33.0</td>\n",
       "      <td>34.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject      Bob       Guido         Sue      \n",
       "type          HR  Temp    HR  Temp    HR  Temp\n",
       "year visit                                    \n",
       "2013 1      38.0  38.3  38.0  36.2  35.0  38.8\n",
       "     2      45.0  39.2  41.0  37.4  34.0  37.2\n",
       "2014 1      50.0  36.1  40.0  37.1  41.0  38.2\n",
       "     2      25.0  37.4  33.0  37.6  33.0  34.7"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "health_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果你需要计算每一年各项指标的平均值，那么可以将参数 level 设置为索引 year："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th>subject</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Bob</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Guido</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Sue</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013</th>\n",
       "      <td>41.5</td>\n",
       "      <td>38.75</td>\n",
       "      <td>39.5</td>\n",
       "      <td>36.80</td>\n",
       "      <td>34.5</td>\n",
       "      <td>38.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>37.5</td>\n",
       "      <td>36.75</td>\n",
       "      <td>36.5</td>\n",
       "      <td>37.35</td>\n",
       "      <td>37.0</td>\n",
       "      <td>36.45</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "subject   Bob        Guido          Sue       \n",
       "type       HR   Temp    HR   Temp    HR   Temp\n",
       "year                                          \n",
       "2013     41.5  38.75  39.5  36.80  34.5  38.00\n",
       "2014     37.5  36.75  36.5  37.35  37.0  36.45"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_mean = health_data.groupby(level='year').mean()\n",
    "data_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "如果再设置 axis 参数，就可以对列索引进行类似的累计操作了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>type</th>\n",
       "      <th>HR</th>\n",
       "      <th>Temp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013</th>\n",
       "      <td>38.5</td>\n",
       "      <td>37.85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>37.0</td>\n",
       "      <td>36.85</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "type    HR   Temp\n",
       "year             \n",
       "2013  38.5  37.85\n",
       "2014  37.0  36.85"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_mean.groupby(axis=1, level='type').mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "通过这两行数据，我们就可以获取每一年所有人的平均心率和体温了。这种语法其实就是"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Panel 数据\n",
    "\n",
    "这里还有一些 Pandas 的基本数据结构没有介绍到，包括 pd.Panel 对象和 pd.Panel4D对象。这两种数据结构可以分别看成是（一维数组）Series 和（二维数组）DataFrame的三维与四维形式。如果你熟悉 Series 和 DataFrame 的使用方法，那么 Panel 和Panel4D 使用起来也会很简单，loc 和 iloc 索引器在高维数据结构上的用法更是完全相同。\n",
    "\n",
    "多级索引在大多数情况下都是更实用、更直观的高维数据形式。另外，Panel 采用密集数据存储形式，而多级索引采用稀疏数据存储形式。在解决许多真实的数据集时，随着维度的不断增加，密集数据存储形式的效率将越来越低。但是这类数据结构对一些有特殊需求的应用还是有用的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 合并数据集：Concat 与 Append 操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将不同的数据源进行合并是数据科学中最有趣的事情之一，这既包括将两个不同的数据集非常简单地拼接在一起，也包括用数据库那样的连接（join）与合并（merge）操作处理有重叠字段的数据集。Series 与 DataFrame 都具备这类操作，Pandas 的函数与方法让数据合并变得快速简单。\n",
    "\n",
    "先来用 pd.concat 函数演示一个 Series 与 DataFrame 的简单合并操作。之后，我们将介绍\n",
    "Pandas 中更复杂的 merge 和 join 内存数据合并操作。\n",
    "\n",
    "首先导入 Pandas 和 NumPy："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "简单起见，定义一个能够创建 DataFrame 某种形式的函数，后面将会用到："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "      <td>C0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    A   B   C\n",
       "0  A0  B0  C0\n",
       "1  A1  B1  C1\n",
       "2  A2  B2  C2"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_df(cols, ind):\n",
    "    \"\"\"Quickly make a DataFrame\"\"\"\n",
    "    data = {c: [str(c) + str(i) for i in ind]\n",
    "            for c in cols}\n",
    "    return pd.DataFrame(data, ind)\n",
    "\n",
    "# example DataFrame\n",
    "make_df('ABC', range(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，我们将创建一个快速类，允许我们并排显示多个DataFrame。代码使用了特殊的repr_uhtml方法，IPython使用该方法实现其丰富的对象显示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class display(object):\n",
    "    \"\"\"Display HTML representation of multiple objects\"\"\"\n",
    "    template = \"\"\"<div style=\"float: left; padding: 10px;\">\n",
    "    <p style='font-family:\"Courier New\", Courier, monospace'>{0}</p>{1}\n",
    "    </div>\"\"\"\n",
    "    def __init__(self, *args):\n",
    "        self.args = args\n",
    "        \n",
    "    def _repr_html_(self):\n",
    "        return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n",
    "                         for a in self.args)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n",
    "                           for a in self.args)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 知识回顾：NumPy 数组的合并\n",
    "\n",
    "合并 Series 与 DataFrame 与合并 NumPy 数 组基本相同，后者通过前面介绍的np.concatenate函数即可完成。你可以用这个函数将两个或两个以上的数组合并成一个数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "z = [7, 8, 9]\n",
    "np.concatenate([x, y, z])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一个参数是需要合并的数组列表或元组。还有一个 axis 参数可以设置合并的坐标轴方向："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2],\n",
       "       [3, 4, 3, 4]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [[1, 2],\n",
    "     [3, 4]]\n",
    "np.concatenate([x, x], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过 pd.concat 实现简易合并"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 有一个 pd.concat() 函数与 np.concatenate 语法类似，但是配置参数更多，功能也更强大：\n",
    "\n",
    "```python\n",
    "# Signature in Pandas v1.4.3\n",
    "pd.concat(objs, \n",
    "        axis=0, \n",
    "        join='outer',   \n",
    "        ignore_index=False, \n",
    "        keys=None, \n",
    "        levels=None, \n",
    "        names=None, \n",
    "        verify_integrity=False, \n",
    "        sort=False, \n",
    "        copy=True)\n",
    "```\n",
    "\n",
    "pd.concat() 可以简单地合并一维的 Series 或 DataFrame 对象，与 np.concatenate() 合并\n",
    "数组一样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    A\n",
       "2    B\n",
       "3    C\n",
       "4    D\n",
       "5    E\n",
       "6    F\n",
       "dtype: object"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser1 = pd.Series(['A', 'B', 'C'], index=[1, 2, 3])\n",
    "ser2 = pd.Series(['D', 'E', 'F'], index=[4, 5, 6])\n",
    "pd.concat([ser1, ser2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "它也可以用来合并高维数据，例如下面的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>A4</td>\n",
       "      <td>B4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([df1, df2])</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>A4</td>\n",
       "      <td>B4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1\n",
       "    A   B\n",
       "1  A1  B1\n",
       "2  A2  B2\n",
       "\n",
       "df2\n",
       "    A   B\n",
       "3  A3  B3\n",
       "4  A4  B4\n",
       "\n",
       "pd.concat([df1, df2])\n",
       "    A   B\n",
       "1  A1  B1\n",
       "2  A2  B2\n",
       "3  A3  B3\n",
       "4  A4  B4"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 = make_df('AB', [1, 2])\n",
    "df2 = make_df('AB', [3, 4])\n",
    "display('df1', 'df2', 'pd.concat([df1, df2])')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "默认情况下，DataFrame 的合并都是逐行进行的（默认设置是 axis=0）。与 np.concatenate()一样，pd.concat 也可以设置合并坐标轴，例如下面的示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df3</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df4</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>C0</td>\n",
       "      <td>D0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C1</td>\n",
       "      <td>D1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([df3, df4], axis=1)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "      <td>C0</td>\n",
       "      <td>D0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "      <td>D1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df3\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "\n",
       "df4\n",
       "    C   D\n",
       "0  C0  D0\n",
       "1  C1  D1\n",
       "\n",
       "pd.concat([df3, df4], axis=1)\n",
       "    A   B   C   D\n",
       "0  A0  B0  C0  D0\n",
       "1  A1  B1  C1  D1"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3 = make_df('AB', [0, 1])\n",
    "df4 = make_df('CD', [0, 1])\n",
    "display('df3', 'df4', \"pd.concat([df3, df4], axis=1)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 索引重复\n",
    "\n",
    "np.concatenate 与 pd.concat 最主要的差异之一就是 Pandas 在合并时会保留索引，即使索引是重复的！例如下面的简单示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>x</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>y</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([x, y])</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "x\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "\n",
       "y\n",
       "    A   B\n",
       "0  A2  B2\n",
       "1  A3  B3\n",
       "\n",
       "pd.concat([x, y])\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "0  A2  B2\n",
       "1  A3  B3"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = make_df('AB', [0, 1])\n",
    "y = make_df('AB', [2, 3])\n",
    "y.index = x.index  # make duplicate indices!\n",
    "display('x', 'y', 'pd.concat([x, y])')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你会发现结果中的索引是重复的。虽然 DataFrame 允许这么做，但结果并不是我们想要的。pd.concat() 提供了一些解决这个问题的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 捕捉索引重复的错误\n",
    "\n",
    "如果你想要检测 pd.concat() 合并的结果中是否出现了重复的索引，可以设置 verify_integrity 参数。将参数设置为 True，合并时若有索引重复就会触发异常。下面的示例可以让我们清晰地捕捉并打印错误信息："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ValueError: Indexes have overlapping values: Int64Index([0, 1], dtype='int64')\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    pd.concat([x, y], verify_integrity=True)\n",
    "except ValueError as e:\n",
    "    print(\"ValueError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 忽略索引\n",
    "\n",
    "有时索引无关紧要，那么合并时就可以忽略它们，可以通过设置 ignore_index 参数来实现。如果将参数设置为 True，那么合并时将会创建一个新的整数索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>x</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>y</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([x, y], ignore_index=True)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "x\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "\n",
       "y\n",
       "    A   B\n",
       "0  A2  B2\n",
       "1  A3  B3\n",
       "\n",
       "pd.concat([x, y], ignore_index=True)\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "2  A2  B2\n",
       "3  A3  B3"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('x', 'y', 'pd.concat([x, y], ignore_index=True)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  增加多级索引\n",
    "\n",
    "另一种处理索引重复的方法是通过 keys 参数为数据源设置多级索引标签，这样结果数据就会带上多级索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>x</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>y</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([x, y], keys=['x', 'y'])</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">x</th>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">y</th>\n",
       "      <th>0</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A3</td>\n",
       "      <td>B3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "x\n",
       "    A   B\n",
       "0  A0  B0\n",
       "1  A1  B1\n",
       "\n",
       "y\n",
       "    A   B\n",
       "0  A2  B2\n",
       "1  A3  B3\n",
       "\n",
       "pd.concat([x, y], keys=['x', 'y'])\n",
       "      A   B\n",
       "x 0  A0  B0\n",
       "  1  A1  B1\n",
       "y 0  A2  B2\n",
       "  1  A3  B3"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('x', 'y', \"pd.concat([x, y], keys=['x', 'y'])\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "示例合并后的结果是多级索引的 DataFrame，可以用之前介绍的方法将它转换成我们需要的形式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  类似 join 的合并\n",
    "\n",
    "前面介绍的简单示例都有一个共同特点，那就是合并的 DataFrame 都是同样的列名。而在实际工作中，需要合并的数据往往带有不同的列名，而 pd.concat 提供了一些选项来解决这类合并问题。看下面两个 DataFrame，它们的列名部分相同，却又不完全相同："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df5</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df6</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>B3</td>\n",
       "      <td>C3</td>\n",
       "      <td>D3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B4</td>\n",
       "      <td>C4</td>\n",
       "      <td>D4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([df5, df6])</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>B3</td>\n",
       "      <td>C3</td>\n",
       "      <td>D3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NaN</td>\n",
       "      <td>B4</td>\n",
       "      <td>C4</td>\n",
       "      <td>D4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df5\n",
       "    A   B   C\n",
       "1  A1  B1  C1\n",
       "2  A2  B2  C2\n",
       "\n",
       "df6\n",
       "    B   C   D\n",
       "3  B3  C3  D3\n",
       "4  B4  C4  D4\n",
       "\n",
       "pd.concat([df5, df6])\n",
       "     A   B   C    D\n",
       "1   A1  B1  C1  NaN\n",
       "2   A2  B2  C2  NaN\n",
       "3  NaN  B3  C3   D3\n",
       "4  NaN  B4  C4   D4"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df5 = make_df('ABC', [1, 2])\n",
    "df6 = make_df('BCD', [3, 4])\n",
    "display('df5', 'df6', 'pd.concat([df5, df6])')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "默认情况下，某个位置上缺失的数据会用 NaN 表示。如果不想这样，可以用 join 参数设置合并方式。默认的合并方式是对所有输入列进行并集合并（join='outer'），当然也可以用 join='inner' 实现对输入列的交集合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df5</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df6</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>B3</td>\n",
       "      <td>C3</td>\n",
       "      <td>D3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B4</td>\n",
       "      <td>C4</td>\n",
       "      <td>D4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.concat([df5, df6], join='inner')</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>B3</td>\n",
       "      <td>C3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B4</td>\n",
       "      <td>C4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df5\n",
       "    A   B   C\n",
       "1  A1  B1  C1\n",
       "2  A2  B2  C2\n",
       "\n",
       "df6\n",
       "    B   C   D\n",
       "3  B3  C3  D3\n",
       "4  B4  C4  D4\n",
       "\n",
       "pd.concat([df5, df6], join='inner')\n",
       "    B   C\n",
       "1  B1  C1\n",
       "2  B2  C2\n",
       "3  B3  C3\n",
       "4  B4  C4"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df5', 'df6',\n",
    "        \"pd.concat([df5, df6], join='inner')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pd.concat 的合并功能可以满足你在合并两个数据集时的许多需求，操作时请记住这一点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 合并数据集：合并与连接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 的基本特性之一就是高性能的内存式数据连接（join）与合并（merge）操作。如果你有使用数据库的经验，那么对这类操作一定很熟悉。Pandas 的主接口是 pd.merge 函数，下面让我们通过一些示例来介绍它的用法。\n",
    "\n",
    "为了方便起见，我们将从重新定义 display 开始："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "class display(object):\n",
    "    \"\"\"Display HTML representation of multiple objects\"\"\"\n",
    "    template = \"\"\"<div style=\"float: left; padding: 10px;\">\n",
    "    <p style='font-family:\"Courier New\", Courier, monospace'>{0}</p>{1}\n",
    "    </div>\"\"\"\n",
    "    def __init__(self, *args):\n",
    "        self.args = args\n",
    "        \n",
    "    def _repr_html_(self):\n",
    "        return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n",
    "                         for a in self.args)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n",
    "                           for a in self.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关系代数\n",
    "\n",
    "pd.merge() 实现的功能基于关系代数（relational algebra）的一部分。关系代数是处理关系型数据的通用理论，绝大部分数据库的可用操作都以此为理论基础。关系代数方法论的强大之处在于，它提出的若干简单操作规则经过组合就可以为任意数据集构建十分复杂的操作。借助在数据库或程序里已经高效实现的基本操作规则，你可以完成许多非常复杂的操作。\n",
    "\n",
    "Pandas 在 pd.merge() 函数与 Series 和 DataFrame 的 join() 方法里实现了这些基本操作规则。下面来看看如何用这些简单的规则连接不同数据源的数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据连接的类型\n",
    "\n",
    "pd.merge() 函数实现了三种数据连接的类型：一对一、多对一和多对多。这三种数据连接类型都通过 pd.merge() 接口进行调用，根据不同的数据连接需求进行不同的操作。下面将通过一些示例来演示这三种类型，并进一步介绍更多的细节。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一对一连接\n",
    "\n",
    "一对一连接可能是最简单的数据合并类型了，与按列合并十分相似。如下面示例所示，有两个包含同一所公司员工不同信息的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bob</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1\n",
       "  employee        group\n",
       "0      Bob   Accounting\n",
       "1     Jake  Engineering\n",
       "2     Lisa  Engineering\n",
       "3      Sue           HR\n",
       "\n",
       "df2\n",
       "  employee  hire_date\n",
       "0     Lisa       2004\n",
       "1      Bob       2008\n",
       "2     Jake       2012\n",
       "3      Sue       2014"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],\n",
    "                    'group': ['Accounting', 'Engineering', 'Engineering', 'HR']})\n",
    "df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],\n",
    "                    'hire_date': [2004, 2008, 2012, 2014]})\n",
    "display('df1', 'df2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "若想将这两个 DataFrame 合并成一个 DataFrame，可以用 pd.merge() 函数实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  employee        group  hire_date\n",
       "0      Bob   Accounting       2008\n",
       "1     Jake  Engineering       2012\n",
       "2     Lisa  Engineering       2004\n",
       "3      Sue           HR       2014"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3 = pd.merge(df1, df2)\n",
    "df3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pd.merge() 方法会发现两个 DataFrame 都有“employee”列，并会自动以这列作为键进行连接。两个输入的合并结果是一个新的 DataFrame。需要注意的是，共同列的位置可以是不一致的。例如在这个例子中，虽然 df1 与 df2 中“employee”列的位置是不一样的，但是 pd.merge() 函数会正确处理这个问题。另外还需要注意的是，pd.merge() 会默认丢弃原来的行索引，不过也可以自定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  多对一连接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多对一连接是指，在需要连接的两个列中，有一列的值有重复。通过多对一连接获得的结果 DataFrame 将会保留重复值。请看下面的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df3</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df4</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "      <th>supervisor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>Carly</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>Guido</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>HR</td>\n",
       "      <td>Steve</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df3, df4)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "      <th>supervisor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "      <td>Carly</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "      <td>Guido</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "      <td>Guido</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "      <td>Steve</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df3\n",
       "  employee        group  hire_date\n",
       "0      Bob   Accounting       2008\n",
       "1     Jake  Engineering       2012\n",
       "2     Lisa  Engineering       2004\n",
       "3      Sue           HR       2014\n",
       "\n",
       "df4\n",
       "         group supervisor\n",
       "0   Accounting      Carly\n",
       "1  Engineering      Guido\n",
       "2           HR      Steve\n",
       "\n",
       "pd.merge(df3, df4)\n",
       "  employee        group  hire_date supervisor\n",
       "0      Bob   Accounting       2008      Carly\n",
       "1     Jake  Engineering       2012      Guido\n",
       "2     Lisa  Engineering       2004      Guido\n",
       "3      Sue           HR       2014      Steve"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'],\n",
    "                    'supervisor': ['Carly', 'Guido', 'Steve']})\n",
    "display('df3', 'df4', 'pd.merge(df3, df4)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在结果 DataFrame 中多了一个“supervisor”列，里面有些值会因为输入数据的对应关系而有所重复。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  多对多连接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多对多连接是个有点儿复杂的概念，不过也可以理解。如果左右两个输入的共同列都包含重复值，那么合并的结果就是一种多对多连接。用一个例子来演示可能更容易理解。来看下面的例子，里面有一个 DataFrame 显示不同岗位人员的一种或多种能力。\n",
    "通过多对多链接，就可以得知每位员工所具备的能力："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df5</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "      <th>skills</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>math</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>spreadsheets</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>coding</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>linux</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>HR</td>\n",
       "      <td>spreadsheets</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>HR</td>\n",
       "      <td>organization</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df1, df5)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>skills</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>math</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>spreadsheets</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>coding</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>linux</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>coding</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>linux</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>spreadsheets</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>organization</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1\n",
       "  employee        group\n",
       "0      Bob   Accounting\n",
       "1     Jake  Engineering\n",
       "2     Lisa  Engineering\n",
       "3      Sue           HR\n",
       "\n",
       "df5\n",
       "         group        skills\n",
       "0   Accounting          math\n",
       "1   Accounting  spreadsheets\n",
       "2  Engineering        coding\n",
       "3  Engineering         linux\n",
       "4           HR  spreadsheets\n",
       "5           HR  organization\n",
       "\n",
       "pd.merge(df1, df5)\n",
       "  employee        group        skills\n",
       "0      Bob   Accounting          math\n",
       "1      Bob   Accounting  spreadsheets\n",
       "2     Jake  Engineering        coding\n",
       "3     Jake  Engineering         linux\n",
       "4     Lisa  Engineering        coding\n",
       "5     Lisa  Engineering         linux\n",
       "6      Sue           HR  spreadsheets\n",
       "7      Sue           HR  organization"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df5 = pd.DataFrame({'group': ['Accounting', 'Accounting',\n",
    "                              'Engineering', 'Engineering', 'HR', 'HR'],\n",
    "                    'skills': ['math', 'spreadsheets', 'coding', 'linux',\n",
    "                               'spreadsheets', 'organization']})\n",
    "display('df1', 'df5', \"pd.merge(df1, df5)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这三种数据连接类型可以直接与其他 Pandas 工具组合使用，从而实现各种各样的功能。但是工作中的真实数据集往往并不像示例中演示的那么干净、整洁。下面就来介绍pd.merge() 的一些功能，它们可以让你更好地应对数据连接中的问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置数据合并的键"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们已经见过 pd.merge() 的默认行为：它会将两个输入的一个或多个共同列作为键进行合并。但由于两个输入要合并的列通常都不是同名的，因此 pd.merge() 提供了一些参数处理这个问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参数 on 的用法\n",
    "\n",
    "最简单的方法就是直接将参数 on 设置为一个列名字符串或者一个包含多列名称的列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bob</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df1, df2, on='employee')</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1\n",
       "  employee        group\n",
       "0      Bob   Accounting\n",
       "1     Jake  Engineering\n",
       "2     Lisa  Engineering\n",
       "3      Sue           HR\n",
       "\n",
       "df2\n",
       "  employee  hire_date\n",
       "0     Lisa       2004\n",
       "1      Bob       2008\n",
       "2     Jake       2012\n",
       "3      Sue       2014\n",
       "\n",
       "pd.merge(df1, df2, on='employee')\n",
       "  employee        group  hire_date\n",
       "0      Bob   Accounting       2008\n",
       "1     Jake  Engineering       2012\n",
       "2     Lisa  Engineering       2004\n",
       "3      Sue           HR       2014"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df1', 'df2', \"pd.merge(df1, df2, on='employee')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个参数只能在两个 DataFrame 有共同列名的时候才可以使用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### left_on 与 right_on 参数\n",
    "\n",
    "有时你也需要合并两个列名不同的数据集，例如前面的员工信息表中有一个字段不是“employee”而是“name”。在这种情况下，就可以用 left_on 和 right_on 参数来指定列名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df3</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>70000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>80000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>120000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>90000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df1, df3, left_on=\"employee\", right_on=\"name\")</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>Bob</td>\n",
       "      <td>70000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>Jake</td>\n",
       "      <td>80000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>Lisa</td>\n",
       "      <td>120000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>Sue</td>\n",
       "      <td>90000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1\n",
       "  employee        group\n",
       "0      Bob   Accounting\n",
       "1     Jake  Engineering\n",
       "2     Lisa  Engineering\n",
       "3      Sue           HR\n",
       "\n",
       "df3\n",
       "   name  salary\n",
       "0   Bob   70000\n",
       "1  Jake   80000\n",
       "2  Lisa  120000\n",
       "3   Sue   90000\n",
       "\n",
       "pd.merge(df1, df3, left_on=\"employee\", right_on=\"name\")\n",
       "  employee        group  name  salary\n",
       "0      Bob   Accounting   Bob   70000\n",
       "1     Jake  Engineering  Jake   80000\n",
       "2     Lisa  Engineering  Lisa  120000\n",
       "3      Sue           HR   Sue   90000"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],\n",
    "                    'salary': [70000, 80000, 120000, 90000]})\n",
    "display('df1', 'df3', 'pd.merge(df1, df3, left_on=\"employee\", right_on=\"name\")')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "获取的结果中会有一个多余的列，可以通过 DataFrame 的 drop() 方法将这列去掉："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>70000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>80000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>120000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>90000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  employee        group  salary\n",
       "0      Bob   Accounting   70000\n",
       "1     Jake  Engineering   80000\n",
       "2     Lisa  Engineering  120000\n",
       "3      Sue           HR   90000"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.merge(df1, df3, left_on=\"employee\", right_on=\"name\").drop('name', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### left_index 与 right_index 参数\n",
    "\n",
    "除了合并列之外，你可能还需要合并索引。就像下面例子中的数据那样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1a\n",
       "                group\n",
       "employee             \n",
       "Bob        Accounting\n",
       "Jake      Engineering\n",
       "Lisa      Engineering\n",
       "Sue                HR\n",
       "\n",
       "df2a\n",
       "          hire_date\n",
       "employee           \n",
       "Lisa           2004\n",
       "Bob            2008\n",
       "Jake           2012\n",
       "Sue            2014"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1a = df1.set_index('employee')\n",
    "df2a = df2.set_index('employee')\n",
    "display('df1a', 'df2a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可以通过设置 pd.merge() 中的 left_index 和 / 或 right_index 参数将索引设置为键来实\n",
    "现合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df1a, df2a, left_index=True, right_index=True)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1a\n",
       "                group\n",
       "employee             \n",
       "Bob        Accounting\n",
       "Jake      Engineering\n",
       "Lisa      Engineering\n",
       "Sue                HR\n",
       "\n",
       "df2a\n",
       "          hire_date\n",
       "employee           \n",
       "Lisa           2004\n",
       "Bob            2008\n",
       "Jake           2012\n",
       "Sue            2014\n",
       "\n",
       "pd.merge(df1a, df2a, left_index=True, right_index=True)\n",
       "                group  hire_date\n",
       "employee                        \n",
       "Bob        Accounting       2008\n",
       "Jake      Engineering       2012\n",
       "Lisa      Engineering       2004\n",
       "Sue                HR       2014"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df1a', 'df2a',\n",
    "        \"pd.merge(df1a, df2a, left_index=True, right_index=True)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了方便考虑，DataFrame 实现了 join() 方法，它可以按照索引进行数据合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1a.join(df2a)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1a\n",
       "                group\n",
       "employee             \n",
       "Bob        Accounting\n",
       "Jake      Engineering\n",
       "Lisa      Engineering\n",
       "Sue                HR\n",
       "\n",
       "df2a\n",
       "          hire_date\n",
       "employee           \n",
       "Lisa           2004\n",
       "Bob            2008\n",
       "Jake           2012\n",
       "Sue            2014\n",
       "\n",
       "df1a.join(df2a)\n",
       "                group  hire_date\n",
       "employee                        \n",
       "Bob        Accounting       2008\n",
       "Jake      Engineering       2012\n",
       "Lisa      Engineering       2004\n",
       "Sue                HR       2014"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df1a', 'df2a', 'df1a.join(df2a)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果想将索引与列混合使用，那么可以通过结合 left_index 与 right_on，或者结合 left_on 与 right_index 来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df1a</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>employee</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bob</th>\n",
       "      <td>Accounting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jake</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lisa</th>\n",
       "      <td>Engineering</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sue</th>\n",
       "      <td>HR</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df3</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>70000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>80000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>120000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>90000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df1a, df3, left_index=True, right_on='name')</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>group</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Accounting</td>\n",
       "      <td>Bob</td>\n",
       "      <td>70000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>Jake</td>\n",
       "      <td>80000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Engineering</td>\n",
       "      <td>Lisa</td>\n",
       "      <td>120000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>HR</td>\n",
       "      <td>Sue</td>\n",
       "      <td>90000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df1a\n",
       "                group\n",
       "employee             \n",
       "Bob        Accounting\n",
       "Jake      Engineering\n",
       "Lisa      Engineering\n",
       "Sue                HR\n",
       "\n",
       "df3\n",
       "   name  salary\n",
       "0   Bob   70000\n",
       "1  Jake   80000\n",
       "2  Lisa  120000\n",
       "3   Sue   90000\n",
       "\n",
       "pd.merge(df1a, df3, left_index=True, right_on='name')\n",
       "         group  name  salary\n",
       "0   Accounting   Bob   70000\n",
       "1  Engineering  Jake   80000\n",
       "2  Engineering  Lisa  120000\n",
       "3           HR   Sue   90000"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df1a', 'df3', \"pd.merge(df1a, df3, left_index=True, right_on='name')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，这些参数都适用于多个索引和 / 或多个列名，函数接口非常简单。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置数据连接的集合操作规则"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过前面的示例，我们总结出数据连接的一个重要条件：集合操作规则。当一个值出现在一列，却没有出现在另一列时，就需要考虑集合操作规则了。来看看下面的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df6</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Peter</td>\n",
       "      <td>fish</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Paul</td>\n",
       "      <td>beans</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df7</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mary</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Joseph</td>\n",
       "      <td>beer</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df6, df7)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df6\n",
       "    name   food\n",
       "0  Peter   fish\n",
       "1   Paul  beans\n",
       "2   Mary  bread\n",
       "\n",
       "df7\n",
       "     name drink\n",
       "0    Mary  wine\n",
       "1  Joseph  beer\n",
       "\n",
       "pd.merge(df6, df7)\n",
       "   name   food drink\n",
       "0  Mary  bread  wine"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df6 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'],\n",
    "                    'food': ['fish', 'beans', 'bread']},\n",
    "                   columns=['name', 'food'])\n",
    "df7 = pd.DataFrame({'name': ['Mary', 'Joseph'],\n",
    "                    'drink': ['wine', 'beer']},\n",
    "                   columns=['name', 'drink'])\n",
    "display('df6', 'df7', 'pd.merge(df6, df7)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们合并两个数据集，在“name”列中只有一个共同的值：Mary。默认情况下，结果中只会包含两个输入集合的交集，这种连接方式被称为内连接（inner join）。我们可以用 how 参数设置连接方式，默认值为 'inner'："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   name   food drink\n",
       "0  Mary  bread  wine"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.merge(df6, df7, how='inner')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "how 参数支持的数据连接方式还有 'outer'、'left' 和 'right'。外连接（outer join）返回\n",
    "两个输入列的交集，所有缺失值都用 NaN 填充："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df6</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Peter</td>\n",
       "      <td>fish</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Paul</td>\n",
       "      <td>beans</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df7</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mary</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Joseph</td>\n",
       "      <td>beer</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df6, df7, how='outer')</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Peter</td>\n",
       "      <td>fish</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Paul</td>\n",
       "      <td>beans</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Joseph</td>\n",
       "      <td>NaN</td>\n",
       "      <td>beer</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df6\n",
       "    name   food\n",
       "0  Peter   fish\n",
       "1   Paul  beans\n",
       "2   Mary  bread\n",
       "\n",
       "df7\n",
       "     name drink\n",
       "0    Mary  wine\n",
       "1  Joseph  beer\n",
       "\n",
       "pd.merge(df6, df7, how='outer')\n",
       "     name   food drink\n",
       "0   Peter   fish   NaN\n",
       "1    Paul  beans   NaN\n",
       "2    Mary  bread  wine\n",
       "3  Joseph    NaN  beer"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df6', 'df7', \"pd.merge(df6, df7, how='outer')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "左连接（left join）和右连接（right join）返回的结果分别只包含左列和右列，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df6</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Peter</td>\n",
       "      <td>fish</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Paul</td>\n",
       "      <td>beans</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df7</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mary</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Joseph</td>\n",
       "      <td>beer</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df6, df7, how='left')</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>food</th>\n",
       "      <th>drink</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Peter</td>\n",
       "      <td>fish</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Paul</td>\n",
       "      <td>beans</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mary</td>\n",
       "      <td>bread</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df6\n",
       "    name   food\n",
       "0  Peter   fish\n",
       "1   Paul  beans\n",
       "2   Mary  bread\n",
       "\n",
       "df7\n",
       "     name drink\n",
       "0    Mary  wine\n",
       "1  Joseph  beer\n",
       "\n",
       "pd.merge(df6, df7, how='left')\n",
       "    name   food drink\n",
       "0  Peter   fish   NaN\n",
       "1   Paul  beans   NaN\n",
       "2   Mary  bread  wine"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df6', 'df7', \"pd.merge(df6, df7, how='left')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在输出的行中只包含左边输入列的值。如果用 how='right' 的话，输出的行则只包含右边输入列的值。\n",
    "\n",
    "这四种数据连接的集合操作规则都可以直接应用于前面介绍过的连接类型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 重复列名：suffixes 参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，你可能会遇到两个输入 DataFrame 有重名列的情况。来看看下面的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df8</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df9</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df8, df9, on=\"name\")</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank_x</th>\n",
       "      <th>rank_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df8\n",
       "   name  rank\n",
       "0   Bob     1\n",
       "1  Jake     2\n",
       "2  Lisa     3\n",
       "3   Sue     4\n",
       "\n",
       "df9\n",
       "   name  rank\n",
       "0   Bob     3\n",
       "1  Jake     1\n",
       "2  Lisa     4\n",
       "3   Sue     2\n",
       "\n",
       "pd.merge(df8, df9, on=\"name\")\n",
       "   name  rank_x  rank_y\n",
       "0   Bob       1       3\n",
       "1  Jake       2       1\n",
       "2  Lisa       3       4\n",
       "3   Sue       4       2"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df8 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],\n",
    "                    'rank': [1, 2, 3, 4]})\n",
    "df9 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],\n",
    "                    'rank': [3, 1, 4, 2]})\n",
    "display('df8', 'df9', 'pd.merge(df8, df9, on=\"name\")')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于输出结果中有两个重复的列名，因此 pd.merge() 函数会自动为它们增加后缀 _x 或 _y，当然也可以通过 suffixes 参数自定义后缀名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df8</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df9</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pd.merge(df8, df9, on=\"name\", suffixes=[\"_L\", \"_R\"])</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>rank_L</th>\n",
       "      <th>rank_R</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df8\n",
       "   name  rank\n",
       "0   Bob     1\n",
       "1  Jake     2\n",
       "2  Lisa     3\n",
       "3   Sue     4\n",
       "\n",
       "df9\n",
       "   name  rank\n",
       "0   Bob     3\n",
       "1  Jake     1\n",
       "2  Lisa     4\n",
       "3   Sue     2\n",
       "\n",
       "pd.merge(df8, df9, on=\"name\", suffixes=[\"_L\", \"_R\"])\n",
       "   name  rank_L  rank_R\n",
       "0   Bob       1       3\n",
       "1  Jake       2       1\n",
       "2  Lisa       3       4\n",
       "3   Sue       4       2"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df8', 'df9', 'pd.merge(df8, df9, on=\"name\", suffixes=[\"_L\", \"_R\"])')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "suffixes 参数同样适用于任何连接方式，即使有三个及三个以上的重复列名时也同样适用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 案例：美国各州的统计数据\n",
    "\n",
    "数据的合并与连接是组合来源不同的数据的最常用方法。下面通过美国各州的统计数据来进行一个演示，数据可以在 https://github.com/jakevdp/data-USstates/ 找到，下面用 Pandas 的 read_csv() 函数看看这三个数据集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>pop.head()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2012</td>\n",
       "      <td>1117489.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2012</td>\n",
       "      <td>4817528.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2010</td>\n",
       "      <td>1130966.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>4785570.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2011</td>\n",
       "      <td>1125763.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>areas.head()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>area (sq. mi)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Alaska</td>\n",
       "      <td>656425</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Arizona</td>\n",
       "      <td>114006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Arkansas</td>\n",
       "      <td>53182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>California</td>\n",
       "      <td>163707</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>abbrevs.head()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>abbreviation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Alabama</td>\n",
       "      <td>AL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Alaska</td>\n",
       "      <td>AK</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Arizona</td>\n",
       "      <td>AZ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Arkansas</td>\n",
       "      <td>AR</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>California</td>\n",
       "      <td>CA</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "pop.head()\n",
       "  state/region     ages  year  population\n",
       "0           AL  under18  2012   1117489.0\n",
       "1           AL    total  2012   4817528.0\n",
       "2           AL  under18  2010   1130966.0\n",
       "3           AL    total  2010   4785570.0\n",
       "4           AL  under18  2011   1125763.0\n",
       "\n",
       "areas.head()\n",
       "        state  area (sq. mi)\n",
       "0     Alabama          52423\n",
       "1      Alaska         656425\n",
       "2     Arizona         114006\n",
       "3    Arkansas          53182\n",
       "4  California         163707\n",
       "\n",
       "abbrevs.head()\n",
       "        state abbreviation\n",
       "0     Alabama           AL\n",
       "1      Alaska           AK\n",
       "2     Arizona           AZ\n",
       "3    Arkansas           AR\n",
       "4  California           CA"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop = pd.read_csv('https://raw.githubusercontent.com/jakevdp/data-USstates/master/state-population.csv')\n",
    "areas = pd.read_csv('https://raw.githubusercontent.com/jakevdp/data-USstates/master/state-areas.csv')\n",
    "abbrevs = pd.read_csv('https://raw.githubusercontent.com/jakevdp/data-USstates/master/state-abbrevs.csv')\n",
    "\n",
    "display('pop.head()', 'areas.head()', 'abbrevs.head()')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看过这些数据之后，我们想要计算一个比较简单的指标：美国各州的人口密度排名。虽然可以直接通过计算每张表获取结果，但这次试着用数据集连接来解决这个问题。\n",
    "\n",
    "首先用一个多对一合并获取人口（pop）DataFrame 中各州名称缩写对应的全称。我们需要将 pop 的 state/region 列与 abbrevs 的abbreviation 列进行合并，还需要通过 how='outer'确保数据没有丢失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2012</td>\n",
       "      <td>1117489.0</td>\n",
       "      <td>Alabama</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2012</td>\n",
       "      <td>4817528.0</td>\n",
       "      <td>Alabama</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2010</td>\n",
       "      <td>1130966.0</td>\n",
       "      <td>Alabama</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>4785570.0</td>\n",
       "      <td>Alabama</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2011</td>\n",
       "      <td>1125763.0</td>\n",
       "      <td>Alabama</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state/region     ages  year  population    state\n",
       "0           AL  under18  2012   1117489.0  Alabama\n",
       "1           AL    total  2012   4817528.0  Alabama\n",
       "2           AL  under18  2010   1130966.0  Alabama\n",
       "3           AL    total  2010   4785570.0  Alabama\n",
       "4           AL  under18  2011   1125763.0  Alabama"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged = pd.merge(pop, abbrevs, how='outer',\n",
    "                  left_on='state/region', right_on='abbreviation')\n",
    "merged = merged.drop(columns='abbreviation') # drop duplicate info\n",
    "merged.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "来全面检查一下数据是否有缺失，我们可以对每个字段逐行检查是否有缺失值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state/region    False\n",
       "ages            False\n",
       "year            False\n",
       "population       True\n",
       "state            True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged.isnull().any()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "部分 population 是缺失值，让我们仔细看看那些数据！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2448</th>\n",
       "      <td>PR</td>\n",
       "      <td>under18</td>\n",
       "      <td>1990</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2449</th>\n",
       "      <td>PR</td>\n",
       "      <td>total</td>\n",
       "      <td>1990</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2450</th>\n",
       "      <td>PR</td>\n",
       "      <td>total</td>\n",
       "      <td>1991</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2451</th>\n",
       "      <td>PR</td>\n",
       "      <td>under18</td>\n",
       "      <td>1991</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2452</th>\n",
       "      <td>PR</td>\n",
       "      <td>total</td>\n",
       "      <td>1993</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     state/region     ages  year  population state\n",
       "2448           PR  under18  1990         NaN   NaN\n",
       "2449           PR    total  1990         NaN   NaN\n",
       "2450           PR    total  1991         NaN   NaN\n",
       "2451           PR  under18  1991         NaN   NaN\n",
       "2452           PR    total  1993         NaN   NaN"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged[merged['population'].isnull()].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好像所有的人口缺失值都出现在 2000 年之前的波多黎各，此前并没有统计过波多黎各的人口。\n",
    "\n",
    "更重要的是，我们还发现一些新的州的数据也有缺失，可能是由于名称缩写没有匹配上全程！来看看究竟是哪个州有缺失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['PR', 'USA'], dtype=object)"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged.loc[merged['state'].isnull(), 'state/region'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以快速解决这个问题：人口数据中包含波多黎各（PR）和全国总数（USA），但这两项没有出现在州名称缩写表中。来快速填充对应的全称："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state/region    False\n",
       "ages            False\n",
       "year            False\n",
       "population       True\n",
       "state           False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged.loc[merged['state/region'] == 'PR', 'state'] = 'Puerto Rico'\n",
    "merged.loc[merged['state/region'] == 'USA', 'state'] = 'United States'\n",
    "merged.isnull().any()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在 state 列没有缺失值了，万事俱备！\n",
    "\n",
    "让我们用类似的规则将面积数据也合并进来。用两个数据集共同的 state 列来合并"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "      <th>area (sq. mi)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2012</td>\n",
       "      <td>1117489.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2012</td>\n",
       "      <td>4817528.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2010</td>\n",
       "      <td>1130966.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>4785570.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2011</td>\n",
       "      <td>1125763.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state/region     ages  year  population    state  area (sq. mi)\n",
       "0           AL  under18  2012   1117489.0  Alabama        52423.0\n",
       "1           AL    total  2012   4817528.0  Alabama        52423.0\n",
       "2           AL  under18  2010   1130966.0  Alabama        52423.0\n",
       "3           AL    total  2010   4785570.0  Alabama        52423.0\n",
       "4           AL  under18  2011   1125763.0  Alabama        52423.0"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final = pd.merge(merged, areas, on='state', how='left')\n",
    "final.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再检查一下数据，看看哪些列还有缺失值，没有匹配上："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state/region     False\n",
       "ages             False\n",
       "year             False\n",
       "population        True\n",
       "state            False\n",
       "area (sq. mi)     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final.isnull().any()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "面积 area 列里面还有缺失值。来看看究竟是哪些地区面积缺失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['United States'], dtype=object)"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final['state'][final['area (sq. mi)'].isnull()].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们发现面积（areas）DataFrame 里面不包含全美国的面积数据。可以插入全国总面积数据（对各州面积求和即可），但是针对本案例，我们要去掉这个缺失值，因为全国的人口密度在此无关紧要："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "      <th>area (sq. mi)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2012</td>\n",
       "      <td>1117489.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2012</td>\n",
       "      <td>4817528.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2010</td>\n",
       "      <td>1130966.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>4785570.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AL</td>\n",
       "      <td>under18</td>\n",
       "      <td>2011</td>\n",
       "      <td>1125763.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state/region     ages  year  population    state  area (sq. mi)\n",
       "0           AL  under18  2012   1117489.0  Alabama        52423.0\n",
       "1           AL    total  2012   4817528.0  Alabama        52423.0\n",
       "2           AL  under18  2010   1130966.0  Alabama        52423.0\n",
       "3           AL    total  2010   4785570.0  Alabama        52423.0\n",
       "4           AL  under18  2011   1125763.0  Alabama        52423.0"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final.dropna(inplace=True)\n",
    "final.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在所有的数据都准备好了。为了解决眼前的问题，先选择 2000 年的各州人口以及总人口数据。让我们用 query() 函数进行快速计算（这需要用到 numexpr 程序库）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state/region</th>\n",
       "      <th>ages</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "      <th>area (sq. mi)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AL</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>4785570.0</td>\n",
       "      <td>Alabama</td>\n",
       "      <td>52423.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>AK</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>713868.0</td>\n",
       "      <td>Alaska</td>\n",
       "      <td>656425.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101</th>\n",
       "      <td>AZ</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>6408790.0</td>\n",
       "      <td>Arizona</td>\n",
       "      <td>114006.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>189</th>\n",
       "      <td>AR</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>2922280.0</td>\n",
       "      <td>Arkansas</td>\n",
       "      <td>53182.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>CA</td>\n",
       "      <td>total</td>\n",
       "      <td>2010</td>\n",
       "      <td>37333601.0</td>\n",
       "      <td>California</td>\n",
       "      <td>163707.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    state/region   ages  year  population       state  area (sq. mi)\n",
       "3             AL  total  2010   4785570.0     Alabama        52423.0\n",
       "91            AK  total  2010    713868.0      Alaska       656425.0\n",
       "101           AZ  total  2010   6408790.0     Arizona       114006.0\n",
       "189           AR  total  2010   2922280.0    Arkansas        53182.0\n",
       "197           CA  total  2010  37333601.0  California       163707.0"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data2010 = final.query(\"year == 2010 & ages == 'total'\")\n",
    "data2010.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在来计算人口密度并按序排列。首先对索引进行重置，然后再计算结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data2010.set_index('state', inplace=True)\n",
    "density = data2010['population'] / data2010['area (sq. mi)']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state\n",
       "District of Columbia    8898.897059\n",
       "Puerto Rico             1058.665149\n",
       "New Jersey              1009.253268\n",
       "Rhode Island             681.339159\n",
       "Connecticut              645.600649\n",
       "dtype: float64"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density.sort_values(ascending=False, inplace=True)\n",
    "density.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算结果是美国各州加上华盛顿特区（Washington, DC）、波多黎各在 2010 年的人口密度排序，以万人 / 平方英里为单位。我们发现人口密度最高的地区是华盛顿特区的哥伦比亚地区（the District of Columbia）。在各州的人口密度中，新泽西州（New Jersey）是最高的。\n",
    "\n",
    "还可以看看人口密度最低的几个州的数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state\n",
       "South Dakota    10.583512\n",
       "North Dakota     9.537565\n",
       "Montana          6.736171\n",
       "Wyoming          5.768079\n",
       "Alaska           1.087509\n",
       "dtype: float64"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，人口密度最低的州是阿拉斯加（Alaska），刚刚超过 1 万人 / 平方英里。\n",
    "\n",
    "当我们用现实世界的数据解决问题时，合并这类脏乱的数据是十分常见的任务。希望这个案例可以帮你把前面介绍过的工具串起来，从而在数据中找到想要的答案！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 累计与分组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "在对较大的数据进行分析时，一项基本的工作就是有效的数据累计（summarization）：计算累计（aggregation）指标，如 sum()、mean()、median()、min() 和 max()，其中每一个指标都呈现了大数据集的特征。接下来我们将探索 Pandas 的累计功能，从类似前面NumPy 数组中的简单操作，到基于 groupby 实现的复杂操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了方便起见，我们将使用与面相同的 display 函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "class display(object):\n",
    "    \"\"\"Display HTML representation of multiple objects\"\"\"\n",
    "    template = \"\"\"<div style=\"float: left; padding: 10px;\">\n",
    "    <p style='font-family:\"Courier New\", Courier, monospace'>{0}</p>{1}\n",
    "    </div>\"\"\"\n",
    "    def __init__(self, *args):\n",
    "        self.args = args\n",
    "        \n",
    "    def _repr_html_(self):\n",
    "        return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n",
    "                         for a in self.args)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n",
    "                           for a in self.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 行星数据\n",
    "\n",
    "我们将通过 Seaborn 程序库（http://seaborn.pydata.org）用一份行星数据来进行演示，其中包含天文学家观测到的围绕恒星运转的行星数据（通常简称为太阳系外行星或外行星）。行星数据可以直接通过 Seaborn 下载："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1035, 6)"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "planets = sns.load_dataset('planets')\n",
    "planets.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>number</th>\n",
       "      <th>orbital_period</th>\n",
       "      <th>mass</th>\n",
       "      <th>distance</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>269.300</td>\n",
       "      <td>7.10</td>\n",
       "      <td>77.40</td>\n",
       "      <td>2006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>874.774</td>\n",
       "      <td>2.21</td>\n",
       "      <td>56.95</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>763.000</td>\n",
       "      <td>2.60</td>\n",
       "      <td>19.84</td>\n",
       "      <td>2011</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>326.030</td>\n",
       "      <td>19.40</td>\n",
       "      <td>110.62</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>516.220</td>\n",
       "      <td>10.50</td>\n",
       "      <td>119.47</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            method  number  orbital_period   mass  distance  year\n",
       "0  Radial Velocity       1         269.300   7.10     77.40  2006\n",
       "1  Radial Velocity       1         874.774   2.21     56.95  2008\n",
       "2  Radial Velocity       1         763.000   2.60     19.84  2011\n",
       "3  Radial Velocity       1         326.030  19.40    110.62  2007\n",
       "4  Radial Velocity       1         516.220  10.50    119.47  2009"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据中包含了截至 2014 年已被发现的一千多颗外行星的资料。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 的简单累计功能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前我们介绍过 NumPy 数组的一些数据累计指标。与一维 NumPy 数组相同，Pandas 的 Series 的累计函数也会返回一个统计值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.374540\n",
       "1    0.950714\n",
       "2    0.731994\n",
       "3    0.598658\n",
       "4    0.156019\n",
       "dtype: float64"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "ser = pd.Series(rng.rand(5))\n",
    "ser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.811925491708157"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5623850983416314"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataFrame 的累计函数默认对每列进行统计："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.155995</td>\n",
       "      <td>0.020584</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.058084</td>\n",
       "      <td>0.969910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.866176</td>\n",
       "      <td>0.832443</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.601115</td>\n",
       "      <td>0.212339</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.708073</td>\n",
       "      <td>0.181825</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "0  0.155995  0.020584\n",
       "1  0.058084  0.969910\n",
       "2  0.866176  0.832443\n",
       "3  0.601115  0.212339\n",
       "4  0.708073  0.181825"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({'A': rng.rand(5),\n",
    "                   'B': rng.rand(5)})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    0.477888\n",
       "B    0.443420\n",
       "dtype: float64"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设置 axis 参数，你就可以对每一行进行统计了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.088290\n",
       "1    0.513997\n",
       "2    0.849309\n",
       "3    0.406727\n",
       "4    0.444949\n",
       "dtype: float64"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean(axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 的 Series 和 DataFrame 支持所有前面介绍的常用累计函数。另外，还有一个非常方便的 describe() 方法可以计算每一列的若干常用统计值。让我们在行星数据上试验一下，首先丢弃有缺失值的行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>number</th>\n",
       "      <th>orbital_period</th>\n",
       "      <th>mass</th>\n",
       "      <th>distance</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>498.00000</td>\n",
       "      <td>498.000000</td>\n",
       "      <td>498.000000</td>\n",
       "      <td>498.000000</td>\n",
       "      <td>498.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.73494</td>\n",
       "      <td>835.778671</td>\n",
       "      <td>2.509320</td>\n",
       "      <td>52.068213</td>\n",
       "      <td>2007.377510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.17572</td>\n",
       "      <td>1469.128259</td>\n",
       "      <td>3.636274</td>\n",
       "      <td>46.596041</td>\n",
       "      <td>4.167284</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.00000</td>\n",
       "      <td>1.328300</td>\n",
       "      <td>0.003600</td>\n",
       "      <td>1.350000</td>\n",
       "      <td>1989.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.00000</td>\n",
       "      <td>38.272250</td>\n",
       "      <td>0.212500</td>\n",
       "      <td>24.497500</td>\n",
       "      <td>2005.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.00000</td>\n",
       "      <td>357.000000</td>\n",
       "      <td>1.245000</td>\n",
       "      <td>39.940000</td>\n",
       "      <td>2009.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.00000</td>\n",
       "      <td>999.600000</td>\n",
       "      <td>2.867500</td>\n",
       "      <td>59.332500</td>\n",
       "      <td>2011.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6.00000</td>\n",
       "      <td>17337.500000</td>\n",
       "      <td>25.000000</td>\n",
       "      <td>354.000000</td>\n",
       "      <td>2014.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          number  orbital_period        mass    distance         year\n",
       "count  498.00000      498.000000  498.000000  498.000000   498.000000\n",
       "mean     1.73494      835.778671    2.509320   52.068213  2007.377510\n",
       "std      1.17572     1469.128259    3.636274   46.596041     4.167284\n",
       "min      1.00000        1.328300    0.003600    1.350000  1989.000000\n",
       "25%      1.00000       38.272250    0.212500   24.497500  2005.000000\n",
       "50%      1.00000      357.000000    1.245000   39.940000  2009.000000\n",
       "75%      2.00000      999.600000    2.867500   59.332500  2011.000000\n",
       "max      6.00000    17337.500000   25.000000  354.000000  2014.000000"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.dropna().describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是一种理解数据集所有统计属性的有效方法。例如，从年份 year 列中可以看出，1989 年首次发现外行星，而且一半的已知外行星都是在 2010 年及以后的年份被发现的。这主要得益于开普勒计划——一个通过激光望远镜发现恒星周围椭圆轨道行星的太空计划。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 内置的一些累计方法如下表所示。\n",
    "\n",
    "| Aggregation              | Description                     |\n",
    "|--------------------------|---------------------------------|\n",
    "| ``count()``              | Total number of items           |\n",
    "| ``first()``, ``last()``  | First and last item             |\n",
    "| ``mean()``, ``median()`` | Mean and median                 |\n",
    "| ``min()``, ``max()``     | Minimum and maximum             |\n",
    "| ``std()``, ``var()``     | Standard deviation and variance |\n",
    "| ``mad()``                | Mean absolute deviation         |\n",
    "| ``prod()``               | Product of all items            |\n",
    "| ``sum()``                | Sum of all items                |\n",
    "\n",
    "DataFrame 和 Series 对象支持以上所有方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但若想深入理解数据，仅仅依靠累计函数是远远不够的。数据累计的下一级别是 groupby 操作，它可以让你快速、有效地计算数据各子集的累计值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GroupBy：分割、应用和组合\n",
    "\n",
    "简单的累计方法可以让我们对数据集有一个笼统的认识，但是我们经常还需要对某些标签或索引的局部进行累计分析，这时就需要用到 groupby 了。虽然“分组”（group by）这个名字是借用 SQL 数据库语言的命令，但其理念引用发明 R 语言 frame 的 Hadley Wickham的观点可能更合适：分割（split）、应用（apply）和组合（combine）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 分割、应用和组合\n",
    "\n",
    "一个经典分割 - 应用 - 组合操作示例如下图所示，其中“apply”的是一个求和函数。\n",
    "![图片.png](https://wkphoto.cdn.bcebos.com/8b13632762d0f703e82b04ba18fa513d2697c53f.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "图片清晰地描述了 GroupBy 的过程。\n",
    "\n",
    "- 分割步骤将 DataFrame 按照指定的键分割成若干组。\n",
    "- 应用步骤对每个组应用函数，通常是累计、转换或过滤函数。\n",
    "- 组合步骤将每一组的结果合并成一个输出数组。\n",
    "\n",
    "虽然我们也可以通过前面介绍的一系列的掩码、累计与合并操作来实现，但是意识到中间分割过程不需要显式地暴露出来这一点十分重要。而且 GroupBy（经常）只需要一行代码，就可以计算每组的和、均值、计数、最小值以及其他累计值。GroupBy 的用处就是将这些\n",
    "步骤进行抽象：用户不需要知道在底层如何计算，只要把操作看成一个整体就够了。\n",
    "\n",
    "用 Pandas 进行图中所示的计算作为具体的示例。从创建输入 DataFrame 开始："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  key  data\n",
       "0   A     0\n",
       "1   B     1\n",
       "2   C     2\n",
       "3   A     3\n",
       "4   B     4\n",
       "5   C     5"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C'],\n",
    "                   'data': range(6)}, columns=['key', 'data'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以用 DataFrame 的 groupby() 方法进行绝大多数常见的分割 - 应用 - 组合操作，将需要分组的列名传进去即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7fa9cf989190>"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，这里的返回值不是一个 DataFrame 对象，而是一个 DataFrameGroupBy 对象。这个对象的魔力在于，你可以将它看成是一种特殊形式的 DataFrame，里面隐藏着若干组数据，但是在没有应用累计函数之前不会计算。这种“延迟计算”（lazy evaluation）的方法使得大多数常见的累计操作可以通过一种对用户而言几乎是透明的（感觉操作仿佛不存在）方式非常高效地实现。\n",
    "\n",
    "为了得到这个结果，可以对 DataFrameGroupBy 对象应用累计函数，它会完成相应的应用组合步骤并生成结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     data\n",
       "key      \n",
       "A       3\n",
       "B       5\n",
       "C       7"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sum() 只是众多可用方法中的一个。你可以用 Pandas 或 NumPy 的任意一种累计函数，也可以用任意有效的 DataFrame 对象。下面就会介绍。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  GroupBy 对象\n",
    "\n",
    "GroupBy 对象是一种非常灵活的抽象类型。在大多数场景中，你可以将它看成是 DataFrame的集合，在底层解决所有难题。让我们用行星数据来做一些演示。\n",
    "\n",
    "GroupBy 中最重要的操作可能就是 aggregate、filter、transform 和 apply（累计、过滤、转换、应用）了，后面将详细介绍这些内容，现在先来介绍一些 GroupBy 的基本操作方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  按列取值\n",
    "\n",
    "GroupBy 对象与 DataFrame 一样，也支持按列取值，并返回一个修改过的 GroupBy 对象，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7fa9cf9899d0>"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.groupby('method')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.generic.SeriesGroupBy object at 0x7fa9cf989f40>"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.groupby('method')['orbital_period']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里从原来的 DataFrame 中取某个列名作为一个 Series 组。与 GroupBy 对象一样，直到我们运行累计函数，才会开始计算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "method\n",
       "Astrometry                         631.180000\n",
       "Eclipse Timing Variations         4343.500000\n",
       "Imaging                          27500.000000\n",
       "Microlensing                      3300.000000\n",
       "Orbital Brightness Modulation        0.342887\n",
       "Pulsar Timing                       66.541900\n",
       "Pulsation Timing Variations       1170.000000\n",
       "Radial Velocity                    360.200000\n",
       "Transit                              5.714932\n",
       "Transit Timing Variations           57.011000\n",
       "Name: orbital_period, dtype: float64"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.groupby('method')['orbital_period'].median()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样就可以获得不同方法下所有行星公转周期（按天计算）的中位数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 按组迭代\n",
    "\n",
    "GroupBy 对象支持直接按组进行迭代，返回的每一组都是 Series 或 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Astrometry                     shape=(2, 6)\n",
      "Eclipse Timing Variations      shape=(9, 6)\n",
      "Imaging                        shape=(38, 6)\n",
      "Microlensing                   shape=(23, 6)\n",
      "Orbital Brightness Modulation  shape=(3, 6)\n",
      "Pulsar Timing                  shape=(5, 6)\n",
      "Pulsation Timing Variations    shape=(1, 6)\n",
      "Radial Velocity                shape=(553, 6)\n",
      "Transit                        shape=(397, 6)\n",
      "Transit Timing Variations      shape=(4, 6)\n"
     ]
    }
   ],
   "source": [
    "for (method, group) in planets.groupby('method'):\n",
    "    print(\"{0:30s} shape={1}\".format(method, group.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尽管通常还是使用内置的 apply 功能速度更快，但这种方式在手动处理某些问题时非常有用，后面会详细介绍。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 调用方法\n",
    "\n",
    "借助 Python 类的魔力（@classmethod），可以让任何不由 GroupBy 对象直接实现的方法直接应用到每一组，无论是 DataFrame 还是 Series 对象都同样适用。例如，你可以用 DataFrame 的 describe() 方法进行累计，对每一组数据进行描述性统计："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "       method                       \n",
       "count  Astrometry                          2.0\n",
       "       Eclipse Timing Variations           9.0\n",
       "       Imaging                            38.0\n",
       "       Microlensing                       23.0\n",
       "       Orbital Brightness Modulation       3.0\n",
       "                                         ...  \n",
       "max    Pulsar Timing                    2011.0\n",
       "       Pulsation Timing Variations      2007.0\n",
       "       Radial Velocity                  2014.0\n",
       "       Transit                          2014.0\n",
       "       Transit Timing Variations        2014.0\n",
       "Length: 80, dtype: float64"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets.groupby('method')['year'].describe().unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这张表可以帮助我们对数据有更深刻的认识，例如大多数行星都是通过 Radial Velocity和 Transit 方法发现的，而且后者在近十年变得越来越普遍（得益于更新、更精确的望远镜）。最新的 Transit Timing Variation 和 Orbital Brightness Modulation 方法在 2011 年之后才有新的发现。\n",
    "\n",
    "这只是演示 Pandas 调用方法的示例之一。方法首先会应用到每组数据上，然后结果由GroupBy 组合后返回。另外，任意 DataFrame / Series 的方法都可以由 GroupBy 方法调用，从而实现非常灵活强大的操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 累计、过滤、转换和应用\n",
    "\n",
    "虽然前面只重点介绍了组合操作，但是还有许多操作没有介绍，尤其是 GroupBy 对象的 aggregate()、filter()、transform() 和 apply() 方法，在数据组合之前实现了大量高效的操作。\n",
    "\n",
    "为了方便后面内容的演示，使用下面这个 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  key  data1  data2\n",
       "0   A      0      5\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "3   A      3      3\n",
       "4   B      4      7\n",
       "5   C      5      9"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(0)\n",
    "df = pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C'],\n",
    "                   'data1': range(6),\n",
    "                   'data2': rng.randint(0, 10, 6)},\n",
    "                   columns = ['key', 'data1', 'data2'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 累计\n",
    "\n",
    "我们目前比较熟悉的 GroupBy 累计方法只有 sum() 和 median() 之类的简单函数，但是 aggregate() 其实可以支持更复杂的操作，比如字符串、函数或者函数列表，并且能一次性计算所有累计值。下面来快速演示一个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">data1</th>\n",
       "      <th colspan=\"3\" halign=\"left\">data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>min</th>\n",
       "      <th>median</th>\n",
       "      <th>max</th>\n",
       "      <th>min</th>\n",
       "      <th>median</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>3.5</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>2</td>\n",
       "      <td>3.5</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    data1            data2           \n",
       "      min median max   min median max\n",
       "key                                  \n",
       "A       0    1.5   3     3    4.0   5\n",
       "B       1    2.5   4     0    3.5   7\n",
       "C       2    3.5   5     3    6.0   9"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').aggregate(['min', np.median, max])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另一种用法就是通过 Python 字典指定不同列需要累计的函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     data1  data2\n",
       "key              \n",
       "A        0      5\n",
       "B        1      7\n",
       "C        2      9"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').aggregate({'data1': 'min',\n",
    "                             'data2': 'max'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  过滤\n",
    "\n",
    "过滤操作可以让你按照分组的属性丢弃若干数据。例如，我们可能只需要保留标准差超过某个阈值的组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df.groupby('key').std()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>2.12132</td>\n",
       "      <td>1.414214</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>2.12132</td>\n",
       "      <td>4.949747</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>2.12132</td>\n",
       "      <td>4.242641</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df.groupby('key').filter(filter_func)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df\n",
       "  key  data1  data2\n",
       "0   A      0      5\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "3   A      3      3\n",
       "4   B      4      7\n",
       "5   C      5      9\n",
       "\n",
       "df.groupby('key').std()\n",
       "       data1     data2\n",
       "key                   \n",
       "A    2.12132  1.414214\n",
       "B    2.12132  4.949747\n",
       "C    2.12132  4.242641\n",
       "\n",
       "df.groupby('key').filter(filter_func)\n",
       "  key  data1  data2\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "4   B      4      7\n",
       "5   C      5      9"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def filter_func(x):\n",
    "    return x['data2'].std() > 4\n",
    "\n",
    "display('df', \"df.groupby('key').std()\", \"df.groupby('key').filter(filter_func)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "filter() 函数会返回一个布尔值，表示每个组是否通过过滤。由于 A 组 'data2' 列的标准差不大于 4，所以被丢弃了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  转换\n",
    "\n",
    "累计操作返回的是对组内全量数据缩减过的结果，而转换操作会返回一个新的全量数据。数据经过转换之后，其形状与原来的输入数据是一样的。常见的例子就是将每一组的样本数据减去各组的均值，实现数据标准化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.5</td>\n",
       "      <td>-3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.5</td>\n",
       "      <td>-3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.5</td>\n",
       "      <td>-1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.5</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.5</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   data1  data2\n",
       "0   -1.5    1.0\n",
       "1   -1.5   -3.5\n",
       "2   -1.5   -3.0\n",
       "3    1.5   -1.0\n",
       "4    1.5    3.5\n",
       "5    1.5    3.0"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').transform(lambda x: x - x.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  apply() 方法\n",
    "\n",
    "apply() 方法让你可以在每个组上应用任意方法。这个函数输入一个 DataFrame，返回一个 Pandas 对象（DataFrame 或 Series）或一个标量（scalar，单个数值）。组合操作会适应返回结果类型。\n",
    "\n",
    "下面的例子就是用 apply() 方法将第一列数据以第二列的和为基数进行标准化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df.groupby('key').apply(norm_by_data2)</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>0.142857</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>0.375000</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>0.571429</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>0.416667</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df\n",
       "  key  data1  data2\n",
       "0   A      0      5\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "3   A      3      3\n",
       "4   B      4      7\n",
       "5   C      5      9\n",
       "\n",
       "df.groupby('key').apply(norm_by_data2)\n",
       "  key     data1  data2\n",
       "0   A  0.000000      5\n",
       "1   B  0.142857      0\n",
       "2   C  0.166667      3\n",
       "3   A  0.375000      3\n",
       "4   B  0.571429      7\n",
       "5   C  0.416667      9"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def norm_by_data2(x):\n",
    "    # x is a DataFrame of group values\n",
    "    x['data1'] /= x['data2'].sum()\n",
    "    return x\n",
    "\n",
    "display('df', \"df.groupby('key').apply(norm_by_data2)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GroupBy 里的 apply() 方法非常灵活，唯一需要注意的地方是它总是输入分组数据的 DataFrame ，返回 Pandas 对象或标量。具体如何选择需要视情况而定。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置分割的键\n",
    "\n",
    "前面的简单例子一直在用列名分割 DataFrame。这只是众多分组操作中的一种，下面将继续介绍更多的分组方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 将列表、数组、Series 或索引作为分组键\n",
    "\n",
    "分组键可以是长度与 DataFrame 匹配的任意 Series 或列表，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df.groupby(L).sum()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df\n",
       "  key  data1  data2\n",
       "0   A      0      5\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "3   A      3      3\n",
       "4   B      4      7\n",
       "5   C      5      9\n",
       "\n",
       "df.groupby(L).sum()\n",
       "   data1  data2\n",
       "0      7     17\n",
       "1      4      3\n",
       "2      4      7"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [0, 1, 0, 1, 2, 0]\n",
    "display('df', 'df.groupby(L).sum()')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此，还有一种比前面直接用列名更啰嗦的表示方法 df.groupby('key')："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df.groupby(df['key']).sum()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>5</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>7</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df\n",
       "  key  data1  data2\n",
       "0   A      0      5\n",
       "1   B      1      0\n",
       "2   C      2      3\n",
       "3   A      3      3\n",
       "4   B      4      7\n",
       "5   C      5      9\n",
       "\n",
       "df.groupby(df['key']).sum()\n",
       "     data1  data2\n",
       "key              \n",
       "A        3      8\n",
       "B        5      7\n",
       "C        7     12"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df', \"df.groupby(df['key']).sum()\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 用字典或 Series 将索引映射到分组名称\n",
    "\n",
    "另一种方法是提供一个字典，将索引映射到分组键："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2.groupby(mapping).sum()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>consonant</th>\n",
       "      <td>12</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vowel</th>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df2\n",
       "     data1  data2\n",
       "key              \n",
       "A        0      5\n",
       "B        1      0\n",
       "C        2      3\n",
       "A        3      3\n",
       "B        4      7\n",
       "C        5      9\n",
       "\n",
       "df2.groupby(mapping).sum()\n",
       "           data1  data2\n",
       "key                    \n",
       "consonant     12     19\n",
       "vowel          3      8"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = df.set_index('key')\n",
    "mapping = {'A': 'vowel', 'B': 'consonant', 'C': 'consonant'}\n",
    "display('df2', 'df2.groupby(mapping).sum()')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 任意 Python 函数\n",
    "\n",
    "与前面的字典映射类似，你可以将任意 Python 函数传入 groupby，函数映射到索引，然后新的分组输出："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>\n",
       "<div style=\"float: left; padding: 10px;\">\n",
       "    <p style='font-family:\"Courier New\", Courier, monospace'>df2.groupby(str.lower).mean()</p><div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.5</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>2.5</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>3.5</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    </div>"
      ],
      "text/plain": [
       "df2\n",
       "     data1  data2\n",
       "key              \n",
       "A        0      5\n",
       "B        1      0\n",
       "C        2      3\n",
       "A        3      3\n",
       "B        4      7\n",
       "C        5      9\n",
       "\n",
       "df2.groupby(str.lower).mean()\n",
       "     data1  data2\n",
       "key              \n",
       "a      1.5    4.0\n",
       "b      2.5    3.5\n",
       "c      3.5    6.0"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display('df2', 'df2.groupby(str.lower).mean()')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 多个有效键构成的列表\n",
    "\n",
    "此外，任意之前有效的键都可以组合起来进行分组，从而返回一个多级索引的分组结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>data1</th>\n",
       "      <th>data2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <th>vowel</th>\n",
       "      <td>1.5</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <th>consonant</th>\n",
       "      <td>2.5</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <th>consonant</th>\n",
       "      <td>3.5</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               data1  data2\n",
       "key key                    \n",
       "a   vowel        1.5    4.0\n",
       "b   consonant    2.5    3.5\n",
       "c   consonant    3.5    6.0"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.groupby([str.lower, mapping]).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 分组案例\n",
    "\n",
    "通过下例中的几行 Python 代码，我们就可以运用上述知识，获取不同方法和不同年份发现的行星数量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>decade</th>\n",
       "      <th>1980s</th>\n",
       "      <th>1990s</th>\n",
       "      <th>2000s</th>\n",
       "      <th>2010s</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>method</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Astrometry</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Eclipse Timing Variations</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Imaging</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>29.0</td>\n",
       "      <td>21.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Microlensing</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>15.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Orbital Brightness Modulation</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pulsar Timing</th>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pulsation Timing Variations</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Radial Velocity</th>\n",
       "      <td>1.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>475.0</td>\n",
       "      <td>424.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Transit</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>64.0</td>\n",
       "      <td>712.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Transit Timing Variations</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "decade                         1980s  1990s  2000s  2010s\n",
       "method                                                   \n",
       "Astrometry                       0.0    0.0    0.0    2.0\n",
       "Eclipse Timing Variations        0.0    0.0    5.0   10.0\n",
       "Imaging                          0.0    0.0   29.0   21.0\n",
       "Microlensing                     0.0    0.0   12.0   15.0\n",
       "Orbital Brightness Modulation    0.0    0.0    0.0    5.0\n",
       "Pulsar Timing                    0.0    9.0    1.0    1.0\n",
       "Pulsation Timing Variations      0.0    0.0    1.0    0.0\n",
       "Radial Velocity                  1.0   52.0  475.0  424.0\n",
       "Transit                          0.0    0.0   64.0  712.0\n",
       "Transit Timing Variations        0.0    0.0    0.0    9.0"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decade = 10 * (planets['year'] // 10)\n",
    "decade = decade.astype(str) + 's'\n",
    "decade.name = 'decade'\n",
    "planets.groupby(['method', decade])['number'].sum().unstack().fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此例足以展现 GroupBy 在探索真实数据集时快速组合多种操作的能力——只用寥寥几行代码，就可以让我们立即对过去几十年里不同年代的行星发现方法有一个大概的了解。\n",
    "\n",
    "我建议你花点时间分析这几行代码，确保自己真正理解了每一行代码对结果产生了怎样的影响。虽然这个例子的确有点儿复杂，但是理解这几行代码的含义可以帮你掌握分析类似数据的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据透视表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们已经介绍过 GroupBy 抽象类是如何探索数据集内部的关联性的了。数据透视表（pivot table）是一种类似的操作方法，常见于 Excel 与类似的表格应用中。数据透视表将每一列数据作为输入，输出将数据不断细分成多个维度累计信息的二维数据表。人们有时容易弄混数据透视表与 GroupBy，但我觉得数据透视表更像是一种多维的 GroupBy 累计操作。也就是说，虽然你也可以分割 - 应用 - 组合，但是分割与组合不是发生在一维索引上，而是在二维网格上（行列同时分组）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Motivating Pivot Tables\n",
    "\n",
    "接下来的示例将采用泰坦尼克号的乘客信息数据库来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "titanic = sns.load_dataset('titanic')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>pclass</th>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th>sibsp</th>\n",
       "      <th>parch</th>\n",
       "      <th>fare</th>\n",
       "      <th>embarked</th>\n",
       "      <th>class</th>\n",
       "      <th>who</th>\n",
       "      <th>adult_male</th>\n",
       "      <th>deck</th>\n",
       "      <th>embark_town</th>\n",
       "      <th>alive</th>\n",
       "      <th>alone</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>man</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>no</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>C</td>\n",
       "      <td>First</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>C</td>\n",
       "      <td>Cherbourg</td>\n",
       "      <td>yes</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>yes</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>S</td>\n",
       "      <td>First</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>C</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>yes</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>man</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>no</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   survived  pclass     sex   age  sibsp  parch     fare embarked  class  \\\n",
       "0         0       3    male  22.0      1      0   7.2500        S  Third   \n",
       "1         1       1  female  38.0      1      0  71.2833        C  First   \n",
       "2         1       3  female  26.0      0      0   7.9250        S  Third   \n",
       "3         1       1  female  35.0      1      0  53.1000        S  First   \n",
       "4         0       3    male  35.0      0      0   8.0500        S  Third   \n",
       "\n",
       "     who  adult_male deck  embark_town alive  alone  \n",
       "0    man        True  NaN  Southampton    no  False  \n",
       "1  woman       False    C    Cherbourg   yes  False  \n",
       "2  woman       False  NaN  Southampton   yes   True  \n",
       "3  woman       False    C  Southampton   yes  False  \n",
       "4    man        True  NaN  Southampton    no   True  "
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这份数据包含了惨遭厄运的每位乘客的大量信息，包括性别（gender）、年龄（age）、船舱等级（class）和船票价格（fare paid）等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 手工制作数据透视表\n",
    "\n",
    "在研究这些数据之前，先将它们按照性别、最终生还状态或其他组合属性进行分组。如果你看过前面的章节，你可能会用 GroupBy 来实现，例如这样统计不同性别乘客的生还率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>0.742038</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>0.188908</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        survived\n",
       "sex             \n",
       "female  0.742038\n",
       "male    0.188908"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.groupby('sex')[['survived']].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这组数据会立刻给我们一个直观感受：总体来说，有四分之三的女性被救，但只有五分之一的男性被救！\n",
    "\n",
    "这组数据很有用，但是我们可能还想进一步探索，同时观察不同性别与船舱等级的生还情况。根据 GroupBy 的操作流程，我们也许能够实现想要的结果：将船舱等级（'class'）与性别（'sex'）分组，然后选择生还状态（'survived'）列，应用均值（'mean'）累计函数，再将各组结果组合，最后通过行索引转列索引操作将最里层的行索引转换成列索引，形成二维数组。代码如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>0.968085</td>\n",
       "      <td>0.921053</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>0.368852</td>\n",
       "      <td>0.157407</td>\n",
       "      <td>0.135447</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class      First    Second     Third\n",
       "sex                                 \n",
       "female  0.968085  0.921053  0.500000\n",
       "male    0.368852  0.157407  0.135447"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.groupby(['sex', 'class'])['survived'].aggregate('mean').unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然这样就可以更清晰地观察乘客性别、船舱等级对其是否生还的影响，但是代码看上去有点复杂。尽管这个管道命令的每一步都是前面介绍过的，但是要理解这个长长的语句可不是那么容易的事。由于二维的 GroupBy 应用场景非常普遍，因此 Pandas 提供了一个快捷方式 pivot_table 来快速解决多维的累计分析任务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据透视表语法\n",
    "\n",
    "用 DataFrame 的 pivot_table 实现的效果等同于上一节的管道命令的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>0.968085</td>\n",
       "      <td>0.921053</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>0.368852</td>\n",
       "      <td>0.157407</td>\n",
       "      <td>0.135447</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class      First    Second     Third\n",
       "sex                                 \n",
       "female  0.968085  0.921053  0.500000\n",
       "male    0.368852  0.157407  0.135447"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.pivot_table('survived', index='sex', columns='class')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与 GroupBy 方法相比，这行代码可读性更强，而且取得的结果也一样。可能与你对 20 世纪初的那场灾难的猜想一致，生还率最高的是船舱等级高的女性。一等舱的女性乘客基本全部生还（露丝自然得救），而三等舱男性乘客的生还率仅为十分之一（杰克为爱牺牲）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 多级数据透视表\n",
    "\n",
    "与 GroupBy 类似，数据透视表中的分组也可以通过各种参数指定多个等级。例如，我们可能想把年龄（'age'）也加进去作为第三个维度，这就可以通过 pd.cut 函数将年龄进行分段："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">female</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>0.909091</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.511628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 80]</th>\n",
       "      <td>0.972973</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.423729</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">male</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>0.800000</td>\n",
       "      <td>0.600000</td>\n",
       "      <td>0.215686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 80]</th>\n",
       "      <td>0.375000</td>\n",
       "      <td>0.071429</td>\n",
       "      <td>0.133663</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class               First    Second     Third\n",
       "sex    age                                   \n",
       "female (0, 18]   0.909091  1.000000  0.511628\n",
       "       (18, 80]  0.972973  0.900000  0.423729\n",
       "male   (0, 18]   0.800000  0.600000  0.215686\n",
       "       (18, 80]  0.375000  0.071429  0.133663"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = pd.cut(titanic['age'], [0, 18, 80])\n",
    "titanic.pivot_table('survived', ['sex', age], 'class')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对某一列也可以使用同样的策略——让我们用 pd.qcut 将船票价格按照计数项等分为两份，加入数据透视表看看："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>fare</th>\n",
       "      <th colspan=\"3\" halign=\"left\">(-0.001, 14.454]</th>\n",
       "      <th colspan=\"3\" halign=\"left\">(14.454, 512.329]</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">female</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.714286</td>\n",
       "      <td>0.909091</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.318182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 80]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.880000</td>\n",
       "      <td>0.444444</td>\n",
       "      <td>0.972973</td>\n",
       "      <td>0.914286</td>\n",
       "      <td>0.391304</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">male</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.260870</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>0.818182</td>\n",
       "      <td>0.178571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 80]</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.098039</td>\n",
       "      <td>0.125000</td>\n",
       "      <td>0.391304</td>\n",
       "      <td>0.030303</td>\n",
       "      <td>0.192308</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "fare            (-0.001, 14.454]                     (14.454, 512.329]  \\\n",
       "class                      First    Second     Third             First   \n",
       "sex    age                                                               \n",
       "female (0, 18]               NaN  1.000000  0.714286          0.909091   \n",
       "       (18, 80]              NaN  0.880000  0.444444          0.972973   \n",
       "male   (0, 18]               NaN  0.000000  0.260870          0.800000   \n",
       "       (18, 80]              0.0  0.098039  0.125000          0.391304   \n",
       "\n",
       "fare                                 \n",
       "class              Second     Third  \n",
       "sex    age                           \n",
       "female (0, 18]   1.000000  0.318182  \n",
       "       (18, 80]  0.914286  0.391304  \n",
       "male   (0, 18]   0.818182  0.178571  \n",
       "       (18, 80]  0.030303  0.192308  "
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fare = pd.qcut(titanic['fare'], 2)\n",
    "titanic.pivot_table('survived', ['sex', age], [fare, 'class'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果是一个带层级索引的四维累计数据表，通过网格显示不同数值之间的相关性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 其他数据透视表选项\n",
    "\n",
    "DataFrame 的 pivot_table 方法的完整签名如下所示：\n",
    "\n",
    "```python\n",
    "# call signature as of Pandas 1.4.3\n",
    "DataFrame.pivot_table(data, \n",
    "                    values=None, index=None, columns=None,\n",
    "                    aggfunc='mean', fill_value=None, margins=False,\n",
    "                    dropna=True, margins_name='All',\n",
    "                    observed=False,\n",
    "                    sort=True)\n",
    "```\n",
    "\n",
    "我们已经介绍过前面三个参数了，现在来看看其他参数。fill_value 和 dropna 这两个参数用于处理缺失值，用法很简单，我们将在后面的示例中演示其用法。\n",
    "\n",
    "aggfunc 参数用于设置累计函数类型，默认值是均值（mean）。与 GroupBy 的用法一样，累计函数可以用一些常见的字符串（'sum'、'mean'、'count'、'min'、'max' 等）表示，也可以用标准的累计函数（np.sum()、min()、sum() 等）表示。另外，还可以通过字典为不同的列指定不同的累计函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">fare</th>\n",
       "      <th colspan=\"3\" halign=\"left\">survived</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>106.125798</td>\n",
       "      <td>21.970121</td>\n",
       "      <td>16.118810</td>\n",
       "      <td>91</td>\n",
       "      <td>70</td>\n",
       "      <td>72</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>67.226127</td>\n",
       "      <td>19.741782</td>\n",
       "      <td>12.661633</td>\n",
       "      <td>45</td>\n",
       "      <td>17</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              fare                       survived             \n",
       "class        First     Second      Third    First Second Third\n",
       "sex                                                           \n",
       "female  106.125798  21.970121  16.118810       91     70    72\n",
       "male     67.226127  19.741782  12.661633       45     17    47"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.pivot_table(index='sex', columns='class',\n",
    "                    aggfunc={'survived':sum, 'fare':'mean'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，这里忽略了一个参数 values。当我们为 aggfunc 指定映射关系的时候，待透视的数值就已经确定了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "当需要计算每一组的总数时，可以通过 margins 参数来设置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>0.968085</td>\n",
       "      <td>0.921053</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>0.742038</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>0.368852</td>\n",
       "      <td>0.157407</td>\n",
       "      <td>0.135447</td>\n",
       "      <td>0.188908</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>0.629630</td>\n",
       "      <td>0.472826</td>\n",
       "      <td>0.242363</td>\n",
       "      <td>0.383838</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class      First    Second     Third       All\n",
       "sex                                           \n",
       "female  0.968085  0.921053  0.500000  0.742038\n",
       "male    0.368852  0.157407  0.135447  0.188908\n",
       "All     0.629630  0.472826  0.242363  0.383838"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.pivot_table('survived', index='sex', columns='class', margins=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样就可以自动获取不同性别下船舱等级与生还率的相关信息、不同船舱等级下性别与生还率的相关信息，以及全部乘客的生还率为 38%。margin 的标签可以通过 margins_name 参数进行自定义，默认值是 \"All\"。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 案例：美国人的生日\n",
    "\n",
    "再来看一个有趣的例子——由美国疾病防治中心（Centers for Disease Control，CDC）提供的公开生日数据，这些数据可以从 https://raw.githubusercontent.com/jakevdp/data-CDCbirths/master/births.csv 下载。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "births = pd.read_csv('https://raw.githubusercontent.com/jakevdp/data-CDCbirths/master/births.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "只简单浏览一下，就会发现这些数据比较简单，只包含了不同出生日期（年月日）与性别的出生人数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>year</th>\n",
       "      <th>month</th>\n",
       "      <th>day</th>\n",
       "      <th>gender</th>\n",
       "      <th>births</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1969</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>F</td>\n",
       "      <td>4046</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1969</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>M</td>\n",
       "      <td>4440</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1969</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>F</td>\n",
       "      <td>4454</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1969</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>M</td>\n",
       "      <td>4548</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1969</td>\n",
       "      <td>1</td>\n",
       "      <td>3.0</td>\n",
       "      <td>F</td>\n",
       "      <td>4548</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year  month  day gender  births\n",
       "0  1969      1  1.0      F    4046\n",
       "1  1969      1  1.0      M    4440\n",
       "2  1969      1  2.0      F    4454\n",
       "3  1969      1  2.0      M    4548\n",
       "4  1969      1  3.0      F    4548"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "births.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用一个数据透视表来探索这份数据。先增加一列表示不同年代，看看各年代的男女出生比例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>gender</th>\n",
       "      <th>F</th>\n",
       "      <th>M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>decade</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1960</th>\n",
       "      <td>1753634</td>\n",
       "      <td>1846572</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1970</th>\n",
       "      <td>16263075</td>\n",
       "      <td>17121550</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1980</th>\n",
       "      <td>18310351</td>\n",
       "      <td>19243452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990</th>\n",
       "      <td>19479454</td>\n",
       "      <td>20420553</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>18229309</td>\n",
       "      <td>19106428</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "gender         F         M\n",
       "decade                    \n",
       "1960     1753634   1846572\n",
       "1970    16263075  17121550\n",
       "1980    18310351  19243452\n",
       "1990    19479454  20420553\n",
       "2000    18229309  19106428"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "births['decade'] = 10 * (births['year'] // 10)\n",
    "births.pivot_table('births', index='decade', columns='gender', aggfunc='sum')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们马上就会发现，每个年代的男性出生率都比女性出生率高。如果希望更直观地体现这种趋势，可以用 Pandas 内置的画图功能将每一年的出生人数画出来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set()  # use Seaborn styles\n",
    "births.pivot_table('births', index='year', columns='gender', aggfunc='sum').plot()\n",
    "plt.ylabel('total births per year');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "借助一个简单的数据透视表和 plot() 方法，我们马上就可以发现不同性别出生率的趋势。通过肉眼观察，得知过去 50 年间的男性出生率比女性出生率高 5%。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 深入探索\n",
    "\n",
    "虽然使用数据透视表并不是必须的，但是通过 Pandas 的这个工具可以展现一些有趣的特征。我们必须对数据做一点儿清理工作，消除由于输错了日期而造成的异常点（如 6 月 31号）或者是缺失值（如 1999 年 6 月）。消除这些异常的简便方法就是直接删除异常值，可\n",
    "以通过更稳定的 sigma 消除法（sigma-clipping，按照正态分布标准差划定范围，SciPy 中默认是四个标准差）操作来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "quartiles = np.percentile(births['births'], [25, 50, 75])\n",
    "mu = quartiles[1]\n",
    "sig = 0.74 * (quartiles[2] - quartiles[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后一行是样本均值的稳定性估计（robust estimate），其中 0.74 是指标准正态分布的分位\n",
    "数间距。在 query() 方法中用这个范围就可以将有效的生日数据筛选出来了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "births = births.query('(births > @mu - 5 * @sig) & (births < @mu + 5 * @sig)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后，将 day 列设置为整数。这列数据在筛选之前是字符串，因为数据集中有的列含有缺失值 'null'："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# set 'day' column to integer; it originally was a string due to nulls\n",
    "births['day'] = births['day'].astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在就可以将年月日组合起来创建一个日期索引了，这样就可以快速计算每一行是星期几："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create a datetime index from the year, month, day\n",
    "births.index = pd.to_datetime(10000 * births.year +\n",
    "                              100 * births.month +\n",
    "                              births.day, format='%Y%m%d')\n",
    "\n",
    "births['dayofweek'] = births.index.dayofweek"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用这个索引可以画出不同年代不同星期的日均出生数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "\n",
    "births.pivot_table('births', index='dayofweek',\n",
    "                    columns='decade', aggfunc='mean').plot()\n",
    "plt.xlabel('day of week');\n",
    "plt.ylabel('mean births per day');\n",
    "plt.gca().set_xticks([0, 1, 2, 3, 4, 5, 6], ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'])\n",
    "plt.gca().set_xticklabels(['Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat', 'Sun'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由图可知，周末的出生人数比工作日要低很多。另外，因为 CDC 只提供了 1989 年之前的数据，所以没有 20 世纪 90 年代和 21 世纪的数据。\n",
    "\n",
    "另一个有趣的图表是画出各个年份平均每天的出生人数，可以按照月和日两个维度分别对数据进行分组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>births</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">1</th>\n",
       "      <th>1</th>\n",
       "      <td>4009.225</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4247.400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4500.900</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4571.350</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4603.625</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       births\n",
       "1 1  4009.225\n",
       "  2  4247.400\n",
       "  3  4500.900\n",
       "  4  4571.350\n",
       "  5  4603.625"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "births_by_date = births.pivot_table('births', \n",
    "                                    [births.index.month, births.index.day])\n",
    "births_by_date.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果只关心月和日的话，这就是一个可以反映一年中平均每天出生人数的时间序列。可以用 plot 方法将数据画成图，从图中可以看到一些有趣的趋势"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the results\n",
    "fig, ax = plt.subplots(figsize=(12, 4))\n",
    "births_by_date.plot(ax=ax);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "从图中可以明显看出，在美国节假日的时候，出生人数急速下降（例如美国独立日、劳动节、感恩节、圣诞节以及新年）。这种现象可能是由于医院放假导致的接生减少（自己在家生），而非某种自然生育的心理学效应。\n",
    "\n",
    "通过这个简单的案例，你会发现许多前面介绍过的 Python 和 Pandas 工具都可以相互结合，并用于从大量数据集中获取信息。我们将在后面的章节中介绍如何用这些工具创建更复杂的应用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量化字符串操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 Python 的一个优势就是字符串处理起来比较容易。在此基础上创建的 Pandas 同样提供了一系列向量化字符串操作（vectorized string operation），它们都是在处理（清洗）现实工作中的数据时不可或缺的功能。接下来我们将介绍 Pandas 的字符串操作，学习如何用它们对一个从网络采集来的杂乱无章的数据集进行局部清理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 字符串操作简介\n",
    "\n",
    "前面已经介绍过如何用 NumPy 和 Pandas 进行一般的运算操作，因此我们也能简便快速地对多个数组元素执行同样的操作，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  6, 10, 14, 22, 26])"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([2, 3, 5, 7, 11, 13])\n",
    "x * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "向量化操作简化了纯数值的数组操作语法——我们不需要再担心数组的长度或维度，只需要关心需要的操作。然而，由于 NumPy 并没有为字符串数组提供简单的接口，因此需要通过繁琐的 for 循环来解决问题："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Peter', 'Paul', 'Mary', 'Guido']"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = ['peter', 'Paul', 'MARY', 'gUIDO']\n",
    "[s.capitalize() for s in data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然这么做对于某些数据可能是有效的，但是假如数据中出现了缺失值，那么这样做就会引起异常，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'NoneType' object has no attribute 'capitalize'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb Cell 603'\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000605?line=0'>1</a>\u001b[0m data \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39mpeter\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mPaul\u001b[39m\u001b[39m'\u001b[39m, \u001b[39mNone\u001b[39;00m, \u001b[39m'\u001b[39m\u001b[39mMARY\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mgUIDO\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000605?line=1'>2</a>\u001b[0m [s\u001b[39m.\u001b[39mcapitalize() \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m data]\n",
      "\u001b[1;32m/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb Cell 603'\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000605?line=0'>1</a>\u001b[0m data \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39mpeter\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mPaul\u001b[39m\u001b[39m'\u001b[39m, \u001b[39mNone\u001b[39;00m, \u001b[39m'\u001b[39m\u001b[39mMARY\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mgUIDO\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/luohaowen/Documents/sino-Japanese/Pandas_refined.ipynb#ch0000605?line=1'>2</a>\u001b[0m [s\u001b[39m.\u001b[39;49mcapitalize() \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m data]\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'capitalize'"
     ]
    }
   ],
   "source": [
    "data = ['peter', 'Paul', None, 'MARY', 'gUIDO']\n",
    "[s.capitalize() for s in data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas 为包含字符串的 Series 和 Index 对象提供的 str 属性堪称两全其美的方法，它既可以满足向量化字符串操作的需求，又可以正确地处理缺失值。例如，我们用前面的数据 data 创建了一个 Pandas 的 Series："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    peter\n",
       "1     Paul\n",
       "2     None\n",
       "3     MARY\n",
       "4    gUIDO\n",
       "dtype: object"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "names = pd.Series(data)\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在就可以直接调用转换大写方法 capitalize() 将所有的字符串变成大写形式，缺失值会被跳过："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Peter\n",
       "1     Paul\n",
       "2     None\n",
       "3     Mary\n",
       "4    Guido\n",
       "dtype: object"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.str.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 str 属性后面用 Tab 键，可以看到 Pandas 支持的所有向量化字符串方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 字符串方法列表\n",
    "\n",
    "如果你熟悉 Python 的字符串方法的话，就会发现 Pandas 绝大多数的字符串语法都很直观，甚至可以列成一个表格。在深入论述后面的内容之前，让我们先从这一步开始。这一节的示例将采用一些人名来演示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam',\n",
    "                   'Eric Idle', 'Terry Jones', 'Michael Palin'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 Python 字符串方法相似的方法\n",
    "几乎所有 Python 内置的字符串方法都被复制到 Pandas 的向量化字符串方法中。下面的表格列举了 Pandas 的 str 方法借鉴 Python 字符串方法的内容：\n",
    "\n",
    "|             |                  |                  |                  |\n",
    "|-------------|------------------|------------------|------------------|\n",
    "|``len()``    | ``lower()``      | ``translate()``  | ``islower()``    | \n",
    "|``ljust()``  | ``upper()``      | ``startswith()`` | ``isupper()``    | \n",
    "|``rjust()``  | ``find()``       | ``endswith()``   | ``isnumeric()``  | \n",
    "|``center()`` | ``rfind()``      | ``isalnum()``    | ``isdecimal()``  | \n",
    "|``zfill()``  | ``index()``      | ``isalpha()``    | ``split()``      | \n",
    "|``strip()``  | ``rindex()``     | ``isdigit()``    | ``rsplit()``     | \n",
    "|``rstrip()`` | ``capitalize()`` | ``isspace()``    | ``partition()``  | \n",
    "|``lstrip()`` |  ``swapcase()``  |  ``istitle()``   | ``rpartition()`` |\n",
    "\n",
    "需要注意的是，这些方法的返回值不同，例如 lower() 方法返回一个字符串 Series："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    graham chapman\n",
       "1       john cleese\n",
       "2     terry gilliam\n",
       "3         eric idle\n",
       "4       terry jones\n",
       "5     michael palin\n",
       "dtype: object"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是有些方法返回数值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    14\n",
       "1    11\n",
       "2    13\n",
       "3     9\n",
       "4    11\n",
       "5    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.len()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有些方法返回布尔值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3    False\n",
       "4     True\n",
       "5    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.startswith('T')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有些方法返回列表或其他复合值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [Graham, Chapman]\n",
       "1       [John, Cleese]\n",
       "2     [Terry, Gilliam]\n",
       "3         [Eric, Idle]\n",
       "4       [Terry, Jones]\n",
       "5     [Michael, Palin]\n",
       "dtype: object"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在接下来的内容中，我们将进一步学习这类由列表元素构成的 Series（series-of-lists）对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用正则表达式的方法\n",
    "\n",
    "还有一些支持正则表达式的方法可以用来处理每个字符串元素。表中的内容是 Pandas 向量化字符串方法根据 Python 标准库的 re 模块函数实现的 API。\n",
    "\n",
    "| Method | Description |\n",
    "|--------|-------------|\n",
    "| ``match()`` | Call ``re.match()`` on each element, returning a boolean. |\n",
    "| ``extract()`` | Call ``re.match()`` on each element, returning matched groups as strings.|\n",
    "| ``findall()`` | Call ``re.findall()`` on each element |\n",
    "| ``replace()`` | Replace occurrences of pattern with some other string|\n",
    "| ``contains()`` | Call ``re.search()`` on each element, returning a boolean |\n",
    "| ``count()`` | Count occurrences of pattern|\n",
    "| ``split()``   | Equivalent to ``str.split()``, but accepts regexps |\n",
    "| ``rsplit()`` | Equivalent to ``str.rsplit()``, but accepts regexps |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过这些方法，你就可以实现各种有趣的操作了。例如，可以提取元素前面的连续字母作为每个人的名字（first name）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     Graham\n",
       "1       John\n",
       "2      Terry\n",
       "3       Eric\n",
       "4      Terry\n",
       "5    Michael\n",
       "dtype: object"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.extract('([A-Za-z]+)', expand=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们还能实现更复杂的操作，例如找出所有开头和结尾都是辅音字母的名字——这可以用\n",
    "则表达式中的开始符号（^）与结尾符号（$）来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [Graham Chapman]\n",
       "1                  []\n",
       "2     [Terry Gilliam]\n",
       "3                  []\n",
       "4       [Terry Jones]\n",
       "5     [Michael Palin]\n",
       "dtype: object"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.findall(r'^[^AEIOU].*[^aeiou]$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "能将正则表达式应用到 Series 与 DataFrame 之中的话，就有可能实现更多的数据分析与清洗方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 其他字符串方法\n",
    "还有其他一些方法也可以实现方便的操作：\n",
    "\n",
    "| Method | Description |\n",
    "|--------|-------------|\n",
    "| ``get()`` | Index each element |\n",
    "| ``slice()`` | Slice each element|\n",
    "| ``slice_replace()`` | Replace slice in each element with passed value|\n",
    "| ``cat()``      | Concatenate strings|\n",
    "| ``repeat()`` | Repeat values |\n",
    "| ``normalize()`` | Return Unicode form of string |\n",
    "| ``pad()`` | Add whitespace to left, right, or both sides of strings|\n",
    "| ``wrap()`` | Split long strings into lines with length less than a given width|\n",
    "| ``join()`` | Join strings in each element of the Series with passed separator|\n",
    "| ``get_dummies()`` | extract dummy variables as a dataframe |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 向量化字符串的取值与切片操作\n",
    "\n",
    "这里需要特别指出的是，get() 与 slice() 操作可以\n",
    "从每个字符串数组中获取向量化元素。例如，我们可以通过 str.slice(0, 3) 获取每个字符串数组的前三个字符。通过 Python 的标准取值方法也可以取得同样的效果，例如 df.str.slice(0, 3) 等价于 df.str[0:3]："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Gra\n",
       "1    Joh\n",
       "2    Ter\n",
       "3    Eri\n",
       "4    Ter\n",
       "5    Mic\n",
       "dtype: object"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "df.str.get(i) 与 df.str[i] 的按索引取值效果类似。\n",
    "\n",
    "get() 与 slice() 操作还可以在 split() 操作之后使用。例如，要获取每个姓名的姓（last name），可以结合使用 split() 与 get()："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Chapman\n",
       "1     Cleese\n",
       "2    Gilliam\n",
       "3       Idle\n",
       "4      Jones\n",
       "5      Palin\n",
       "dtype: object"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte.str.split().str.get(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 指标变量\n",
    "\n",
    "另一个需要多花点儿时间解释的是 get_dummies() 方法。当你的数据有一列包含了若干已被编码的指标（coded indicator）时，这个方法就能派上用场了。例如，假设有一个包含了某种编码信息的数据集，如 A= 出生在美国、B= 出生在英国、C= 喜欢奶酪、D= 喜欢午餐肉："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>info</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Graham Chapman</td>\n",
       "      <td>B|C|D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>John Cleese</td>\n",
       "      <td>B|D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Terry Gilliam</td>\n",
       "      <td>A|C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Eric Idle</td>\n",
       "      <td>B|D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Terry Jones</td>\n",
       "      <td>B|C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Michael Palin</td>\n",
       "      <td>B|C|D</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             name   info\n",
       "0  Graham Chapman  B|C|D\n",
       "1     John Cleese    B|D\n",
       "2   Terry Gilliam    A|C\n",
       "3       Eric Idle    B|D\n",
       "4     Terry Jones    B|C\n",
       "5   Michael Palin  B|C|D"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_monte = pd.DataFrame({'name': monte,\n",
    "                           'info': ['B|C|D', 'B|D', 'A|C',\n",
    "                                    'B|D', 'B|C', 'B|C|D']})\n",
    "full_monte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "get_dummies() 方法可以让你快速将这些指标变量分割成一个 DataFrame（每个元素都是 0 或 1）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A  B  C  D\n",
       "0  0  1  1  1\n",
       "1  0  1  0  1\n",
       "2  1  0  1  0\n",
       "3  0  1  0  1\n",
       "4  0  1  1  0\n",
       "5  0  1  1  1"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_monte['info'].str.get_dummies('|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过 Pandas 自带的这些字符串操作方法，你就可以建立一个功能无比强大的字符串处理程序来清洗自己的数据了。\n",
    "\n",
    "数据科学的真相就是：真实数据的清洗与整理工作往往会占据的大部分时间，而使用 Pandas 提供的工具可以提高你的工作效率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 处理时间序列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于 Pandas 最初是为金融模型而创建的，因此它拥有一些功能非常强大的日期、时间、带时间索引数据的处理工具。这里将介绍的日期与时间数据主要包含三类。\n",
    "\n",
    "- 时间戳表示某个具体的时间点（例如 2015 年 7 月 4 日上午 7 点）。\n",
    "- 时间间隔与周期表示开始时间点与结束时间点之间的时间长度，例如 2015 年（指的是\n",
    "2015 年 1 月 1 日至 2015 年 12 月 31 日这段时间间隔）。周期通常是指一种特殊形式的\n",
    "时间间隔，每个间隔长度相同，彼此之间不会重叠（例如，以 24 小时为周期构成每一天）。\n",
    "- 时间增量（time delta）或持续时间（duration）表示精确的时间长度（例如，某程序运\n",
    "行持续时间 22.56 秒）。\n",
    "\n",
    "在开始介绍 Pandas 的时间序列工具之前，我们先简单介绍一下 Python 处理日期与时间数据的工具。在介绍完一些值得深入学习的资源之后，再通过一些简短的示例来演示 Pandas 处理时间序列数据的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 的日期与时间工具\n",
    "\n",
    "在 Python 标准库与第三方库中有许多可以表示日期、时间、时间增量和时间跨度（timespan）的工具。尽管 Pandas 提供的时间序列工具更适合用来处理数据科学问题，但是了解 Pandas 与 Python 标准库以及第三方库中的其他时间序列工具之间的关联性将大有裨益。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 原生Python的日期与时间工具：datetime与dateutil\n",
    "\n",
    "Python 基本的日期与时间功能都在标准库的 datetime 模块中。如果和第三方库 dateutil 模块搭配使用，可以快速实现许多处理日期与时间的功能。例如，你可以用 datetime 类型创建一个日期："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 7, 4, 0, 0)"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "datetime(year=2015, month=7, day=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者使用 dateutil 模块对各种字符串格式的日期进行正确解析："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 7, 4, 0, 0)"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dateutil import parser\n",
    "date = parser.parse(\"4th of July, 2015\")\n",
    "date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "一旦有了 datetime 对象，就可以进行许多操作了，例如打印出这一天是星期几："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Saturday'"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date.strftime('%A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在最后一行代码中，为了打印出是星期几，我们使用了一个标准字符串格式（standard \n",
    "string format）代码 \"%A\"，你可以在 [Python 的 datetime 文档](https://docs.python.org/3/library/datetime.html)的[“strftime”节](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)查看具体信息。关于 dateutil 的其他日期功能可以通过 [dateutil 的在线文档](http://labix.org/python-dateutil)学习。还有一个值得关注的程序包是 [pytz](http://pytz.sourceforge.net/)，这个工具解决了绝大多数时间序列数据都会遇到的难题：时区。\n",
    "\n",
    "datetime 和 dateutil 模块在灵活性与易用性方面都表现出色，你可以用这些对象及其相应的方法轻松完成你感兴趣的任意操作。但如果你处理的时间数据量比较大，那么速度就会比较慢。就像之前介绍过的 Python 的原生列表对象没有 NumPy 中已经被编码的数值类型数组的性能好一样，Python 的原生日期对象同样也没有 NumPy 中已经被编码的日期（encoded dates）类型数组的性能好。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 时间类型数组：NumPy 的 datetime64 类型\n",
    "\n",
    "Python 原生日期格式的性能弱点促使 NumPy 团队为 NumPy 增加了自己的时间序列类型。datetime64 类型将日期编码为 64 位整数，这样可以让日期数组非常紧凑（节省内存）。datetime64 需要在设置日期时确定具体的输入类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array('2015-07-04', dtype='datetime64[D]')"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "date = np.array('2015-07-04', dtype=np.datetime64)\n",
    "date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但只要有了这个日期格式，就可以进行快速的向量化运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2015-07-04', '2015-07-05', '2015-07-06', '2015-07-07',\n",
       "       '2015-07-08', '2015-07-09', '2015-07-10', '2015-07-11',\n",
       "       '2015-07-12', '2015-07-13', '2015-07-14', '2015-07-15'],\n",
       "      dtype='datetime64[D]')"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date + np.arange(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为 NumPy 的 datetime64 数组内元素的类型是统一的，所以这种数组的运算速度会比 Python 的 datetime 对象的运算速度快很多，尤其是在处理较大数组时\n",
    "\n",
    "atetime64 与 timedelta64 对 象 的 一 个 共 同 特 点 是， 它 们 都 是 在 基本时间单位\n",
    "（fundamental time unit）的基础上建立的。由于 datetime64 对象是 64 位精度，所以可编码的时间范围可以是基本单元的 264 倍。也就是说，datetime64 在时间精度（time resolution）与最大时间跨度（maximum time span）之间达成了一种平衡。\n",
    "\n",
    "比如你想要一个时间纳秒（nanosecond，ns）级的时间精度，那么你就可以将时间编码到0~264 纳秒或 600 年之内，NumPy 会自动判断输入时间需要使用的时间单位。例如，下面是一个以天为单位的日期："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2015-07-04')"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.datetime64('2015-07-04')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而这是一个以分钟为单位的日期："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2015-07-04T12:00')"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.datetime64('2015-07-04 12:00')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，时区将自动设置为执行代码的操作系统的当地时区。你可以通过各种格式的代码设置基本时间单位。例如，将时间单位设置为纳秒："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2015-07-04T12:59:59.500000000')"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.datetime64('2015-07-04 12:59:59.50', 'ns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy 的 [datetime64 文档](http://docs.scipy.org/doc/numpy/reference/arrays.datetime.html)\n",
    "总结了所有支持相对与绝对时间跨度的时间与日期单位格式代码，下表对此总结如下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Code    | Meaning     | Time span (relative) | Time span (absolute)   |\n",
    "|--------|-------------|----------------------|------------------------|\n",
    "| ``Y``  | Year\t       | ± 9.2e18 years       | [9.2e18 BC, 9.2e18 AD] |\n",
    "| ``M``  | Month       | ± 7.6e17 years       | [7.6e17 BC, 7.6e17 AD] |\n",
    "| ``W``  | Week\t       | ± 1.7e17 years       | [1.7e17 BC, 1.7e17 AD] |\n",
    "| ``D``  | Day         | ± 2.5e16 years       | [2.5e16 BC, 2.5e16 AD] |\n",
    "| ``h``  | Hour        | ± 1.0e15 years       | [1.0e15 BC, 1.0e15 AD] |\n",
    "| ``m``  | Minute      | ± 1.7e13 years       | [1.7e13 BC, 1.7e13 AD] |\n",
    "| ``s``  | Second      | ± 2.9e12 years       | [ 2.9e9 BC, 2.9e9 AD]  |\n",
    "| ``ms`` | Millisecond | ± 2.9e9 years        | [ 2.9e6 BC, 2.9e6 AD]  |\n",
    "| ``us`` | Microsecond | ± 2.9e6 years        | [290301 BC, 294241 AD] |\n",
    "| ``ns`` | Nanosecond  | ± 292 years          | [ 1678 AD, 2262 AD]    |\n",
    "| ``ps`` | Picosecond  | ± 106 days           | [ 1969 AD, 1970 AD]    |\n",
    "| ``fs`` | Femtosecond | ± 2.6 hours          | [ 1969 AD, 1970 AD]    |\n",
    "| ``as`` | Attosecond  | ± 9.2 seconds        | [ 1969 AD, 1970 AD]    |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于日常工作中的时间数据类型，默认单位都用纳秒 datetime64[ns]，因为用它来表示时间范围精度可以满足绝大部分需求。\n",
    "\n",
    "最后还需要说明一点，虽然 datetime64 弥补了 Python 原生的 datetime 类型的不足，但它缺少了许多 datetime（尤其是 dateutil）原本具备的便捷方法与函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Pandas 的日期与时间工具：理想与现实的最佳解决方案\n",
    "\n",
    "andas 所有关于日期与时间的处理方法全部都是通过 Timestamp 对象实现的，它利用 numpy.datetime64 的有效存储和向量化接口将 datetime 和 dateutil 的易用性有机结合起来。Pandas 通过一组 Timestamp 对象就可以创建一个可以作为 Series 或 DataFrame 索引的DatetimeIndex，我们将在后面介绍许多类似的例子。\n",
    "\n",
    "例如，可以用 Pandas 的方式演示前面介绍的日期与时间功能。我们可以灵活处理不同格式的日期与时间字符串，获取某一天是星期几："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2015-07-04 00:00:00')"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "date = pd.to_datetime(\"4th of July, 2015\")\n",
    "date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Saturday'"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date.strftime('%A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，也可以直接进行 NumPy 类型的向量化运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-04', '2015-07-05', '2015-07-06', '2015-07-07',\n",
       "               '2015-07-08', '2015-07-09', '2015-07-10', '2015-07-11',\n",
       "               '2015-07-12', '2015-07-13', '2015-07-14', '2015-07-15'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date + pd.to_timedelta(np.arange(12), 'D')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面将详细介绍 Pandas 用来处理时间序列数据的工具。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 时间序列：用时间作索引\n",
    "\n",
    "Pandas 时间序列工具非常适合用来处理带时间戳的索引数据。例如，我们可以通过一个时间索引数据创建一个 Series 对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2014-07-04    0\n",
       "2014-08-04    1\n",
       "2015-07-04    2\n",
       "2015-08-04    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 297,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = pd.DatetimeIndex(['2014-07-04', '2014-08-04',\n",
    "                          '2015-07-04', '2015-08-04'])\n",
    "data = pd.Series([0, 1, 2, 3], index=index)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有了一个带时间索引的 Series 之后，就能用它来演示之前介绍过的 Series 取值方法，可以直接用日期进行切片取值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2014-07-04    0\n",
       "2014-08-04    1\n",
       "2015-07-04    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['2014-07-04':'2015-07-04']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，还有一些仅在此类 Series 上可用的取值操作，例如直接通过年份切片获取该年的数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2015-07-04    2\n",
       "2015-08-04    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['2015']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面将介绍一些示例，体现将日期作为索引为运算带来的便利性。在此之前，让我们仔细看看现有的时间序列数据结构。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas 时间序列数据结构\n",
    "\n",
    "下面将介绍 Pandas 用来处理时间序列的基础数据类型。\n",
    "\n",
    "- 针对时间戳数据，Pandas 提供了 Timestamp 类型。与前面介绍的一样，它本质上是 Python 的原生 datetime 类型的替代品，但是在性能更好的 numpy.datetime64 类型的基础上创建。对应的索引数据结构是 DatetimeIndex。\n",
    "- 针对时间周期数据，Pandas 提供了 Period 类型。这是利用 numpy.datetime64 类型将固定频率的时间间隔进行编码。对应的索引数据结构是 PeriodIndex。\n",
    "- 针对时间增量或持续时间，Pandas 提供了 Timedelta 类型。Timedelta 是一种代替 Python 原生 datetime.timedelta 类型的高性能数据结构，同样是基于 numpy.timedelta64 类型。对应的索引数据结构是 TimedeltaIndex。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最基础的日期 / 时间对象是 Timestamp 和 DatetimeIndex。这两种对象可以直接使用，最常用的方法是 pd.to_datetime() 函数，它可以解析许多日期与时间格式。对 pd.to_datetime() 传递一个日期会返回一个 Timestamp 类型，传递一个时间序列会返回一个 DatetimeIndex 类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-06', '2015-07-07',\n",
       "               '2015-07-08'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates = pd.to_datetime([datetime(2015, 7, 3), '4th of July, 2015',\n",
    "                       '2015-Jul-6', '07-07-2015', '20150708'])\n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "任何 DatetimeIndex 类型都可以通过 to_period() 方法和一个频率代码转换成 PeriodIndex 类型。下面用 'D' 将数据转换成单日的时间序列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2015-07-03', '2015-07-04', '2015-07-06', '2015-07-07',\n",
       "             '2015-07-08'],\n",
       "            dtype='period[D]')"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates.to_period('D')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当用一个日期减去另一个日期时，返回的结果是 TimedeltaIndex 类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days', '1 days', '3 days', '4 days', '5 days'], dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates - dates[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 有规律的时间序列：pd.date_range()\n",
    "\n",
    "为了能更简便地创建有规律的时间序列，Pandas 提供了一些方法：pd.date_range() 可以处理时间戳、pd.period_range() 可以处理周期、pd.timedelta_range() 可以处理时间间隔。我们已经介绍过，Python 的 range() 和 NumPy 的 np.arange() 可以用起点、终点和步长（可选的）创建一个序列。pd.date_range() 与之类似，通过开始日期、结束日期和频率代码（同样是可选的）创建一个有规律的日期序列，默认的频率是天："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-05', '2015-07-06',\n",
       "               '2015-07-07', '2015-07-08', '2015-07-09', '2015-07-10'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2015-07-03', '2015-07-10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，日期范围不一定非是开始时间与结束时间，也可以是开始时间与周期数 periods："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-05', '2015-07-06',\n",
       "               '2015-07-07', '2015-07-08', '2015-07-09', '2015-07-10'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2015-07-03', periods=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可以通过 freq 参数改变时间间隔，默认值是 D。例如，可以创建一个按小时变化的时间戳："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03 00:00:00', '2015-07-03 01:00:00',\n",
       "               '2015-07-03 02:00:00', '2015-07-03 03:00:00',\n",
       "               '2015-07-03 04:00:00', '2015-07-03 05:00:00',\n",
       "               '2015-07-03 06:00:00', '2015-07-03 07:00:00'],\n",
       "              dtype='datetime64[ns]', freq='H')"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2015-07-03', periods=8, freq='H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要创建一个有规律的周期或时间间隔序列，有类似的函数 pd.period_range() 和 pd.timedelta_range()。下面是一个以月为周期的示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2015-07', '2015-08', '2015-09', '2015-10', '2015-11', '2015-12',\n",
       "             '2016-01', '2016-02'],\n",
       "            dtype='period[M]')"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.period_range('2015-07', periods=8, freq='M')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以及一个以小时递增的序列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:00:00', '0 days 01:00:00', '0 days 02:00:00',\n",
       "                '0 days 03:00:00', '0 days 04:00:00', '0 days 05:00:00',\n",
       "                '0 days 06:00:00', '0 days 07:00:00', '0 days 08:00:00',\n",
       "                '0 days 09:00:00'],\n",
       "               dtype='timedelta64[ns]', freq='H')"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.timedelta_range(0, periods=10, freq='H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "掌握 Pandas 频率代码是使用所有这些时间序列创建方法的必要条件。接下来，我们将总结这些代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 时间频率与偏移量\n",
    "\n",
    "Pandas 时间序列工具的基础是时间频率或偏移量（offset）代码。就像之前见过的 D（day） 和 H（hour）代码，我们可以用这些代码设置任意需要的时间间隔。下表总结了主要的频率代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Code   | Description         | Code   | Description          |\n",
    "|--------|---------------------|--------|----------------------|\n",
    "| ``D``  | Calendar day        | ``B``  | Business day         |\n",
    "| ``W``  | Weekly              |        |                      |\n",
    "| ``M``  | Month end           | ``BM`` | Business month end   |\n",
    "| ``Q``  | Quarter end         | ``BQ`` | Business quarter end |\n",
    "| ``A``  | Year end            | ``BA`` | Business year end    |\n",
    "| ``H``  | Hours               | ``BH`` | Business hours       |\n",
    "| ``T``  | Minutes             |        |                      |\n",
    "| ``S``  | Seconds             |        |                      |\n",
    "| ``L``  | Milliseonds         |        |                      |\n",
    "| ``U``  | Microseconds        |        |                      |\n",
    "| ``N``  | nanoseconds         |        |                      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "月、季、年频率都是具体周期的结束时间（月末、季末、年末），而有一些以 S（start，开始）为后缀的代码表示日期开始（如下表所示）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Code    | Description            || Code    | Description            |\n",
    "|---------|------------------------||---------|------------------------|\n",
    "| ``MS``  | Month start            ||``BMS``  | Business month start   |\n",
    "| ``QS``  | Quarter start          ||``BQS``  | Business quarter start |\n",
    "| ``AS``  | Year start             ||``BAS``  | Business year start    |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，你可以在频率代码后面加三位月份缩写字母来改变季、年频率的开始时间。\n",
    "\n",
    "- ``Q-JAN``, ``BQ-FEB``, ``QS-MAR``, ``BQS-APR``, etc.\n",
    "- ``A-JAN``, ``BA-FEB``, ``AS-MAR``, ``BAS-APR``, etc.\n",
    "\n",
    "同理，也可以在后面加三位星期缩写字母来改变一周的开始时间。\n",
    "\n",
    "- ``W-SUN``, ``W-MON``, ``W-TUE``, ``W-WED``, etc.\n",
    "\n",
    "在这些代码的基础上，还可以将频率组合起来创建的新的周期。例如，可以用小时（H）和分钟（T）的组合来实现 2 小时 30 分钟："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:00:00', '0 days 02:30:00', '0 days 05:00:00',\n",
       "                '0 days 07:30:00', '0 days 10:00:00', '0 days 12:30:00',\n",
       "                '0 days 15:00:00', '0 days 17:30:00', '0 days 20:00:00'],\n",
       "               dtype='timedelta64[ns]', freq='150T')"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.timedelta_range(0, periods=9, freq=\"2H30T\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所有这些频率代码都对应 Pandas 时间序列的偏移量，具体内容可以在 pd.tseries.offsets 模块中找到。例如，可以用下面的方法直接创建一个工作日偏移序列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-01', '2015-07-02', '2015-07-03', '2015-07-06',\n",
       "               '2015-07-07'],\n",
       "              dtype='datetime64[ns]', freq='B')"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pandas.tseries.offsets import BDay\n",
    "pd.date_range('2015-07-01', periods=5, freq=BDay())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 重新取样、迁移和窗口\n",
    "\n",
    "用日期和时间直观地组织与获取数据是 Pandas 时间序列工具最重要的功能之一。Pandas 不仅支持普通索引功能（合并数据时自动索引对齐、直观的数据切片和取值方法等），还专为时间序列提供了额外的操作。\n",
    "\n",
    "下面让我们用一些股票数据来演示这些功能。由于 Pandas 最初是为金融数据模型服务的，因此可以用它非常方便地获取金融数据。例如，pandas-datareader 程序包（可以通过 conda install pandas-datareader 进行安装）知道如何从一些可用的数据源导入金融数据，包含 Yahoo 财经、Google 财经和其他数据源。下面来导入 Google 的历史股票价格："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Open</th>\n",
       "      <th>Close</th>\n",
       "      <th>Volume</th>\n",
       "      <th>Adj Close</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-12-31</th>\n",
       "      <td>27.920347</td>\n",
       "      <td>27.553225</td>\n",
       "      <td>27.702166</td>\n",
       "      <td>27.913124</td>\n",
       "      <td>54519590.0</td>\n",
       "      <td>27.913124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-01-02</th>\n",
       "      <td>27.839401</td>\n",
       "      <td>27.603037</td>\n",
       "      <td>27.782366</td>\n",
       "      <td>27.724083</td>\n",
       "      <td>73129082.0</td>\n",
       "      <td>27.724083</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-01-03</th>\n",
       "      <td>27.818977</td>\n",
       "      <td>27.520098</td>\n",
       "      <td>27.770908</td>\n",
       "      <td>27.521841</td>\n",
       "      <td>66917888.0</td>\n",
       "      <td>27.521841</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-01-06</th>\n",
       "      <td>27.867046</td>\n",
       "      <td>27.557707</td>\n",
       "      <td>27.721344</td>\n",
       "      <td>27.828691</td>\n",
       "      <td>71037271.0</td>\n",
       "      <td>27.828691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-01-07</th>\n",
       "      <td>28.385853</td>\n",
       "      <td>27.924334</td>\n",
       "      <td>28.019974</td>\n",
       "      <td>28.365179</td>\n",
       "      <td>102486711.0</td>\n",
       "      <td>28.365179</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 High        Low       Open      Close       Volume  Adj Close\n",
       "Date                                                                          \n",
       "2013-12-31  27.920347  27.553225  27.702166  27.913124   54519590.0  27.913124\n",
       "2014-01-02  27.839401  27.603037  27.782366  27.724083   73129082.0  27.724083\n",
       "2014-01-03  27.818977  27.520098  27.770908  27.521841   66917888.0  27.521841\n",
       "2014-01-06  27.867046  27.557707  27.721344  27.828691   71037271.0  27.828691\n",
       "2014-01-07  28.385853  27.924334  28.019974  28.365179  102486711.0  28.365179"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pandas_datareader import data\n",
    "\n",
    "goog = data.DataReader('GOOG', start='2014', end='2016',\n",
    "                       data_source='yahoo')\n",
    "goog.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "出于简化的目的，这里只用收盘价："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "goog = goog['Close']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设置 Matplotlib 之后，就可以通过 plot() 画出可视化图了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "goog.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 重新取样与频率转换\n",
    "\n",
    "处理时间序列数据时，经常需要按照新的频率（更高频率、更低频率）对数据进行重新取样。你可以通过 resample() 方法解决这个问题，或者用更简单的 asfreq() 方法。这两个方法的主要差异在于，resample() 方法是以数据累计（data aggregation）为基础，而 asfreq() 方法是以数据选择（data selection）为基础。\n",
    "\n",
    "看到 Google 的收盘价之后，让我们用两种方法对数据进行向后取样（down-sample）。这里用年末（'BA'，最后一个工作日）对数据进行重新取样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEGCAYAAACaSwWnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABoHUlEQVR4nO2dd2Ac1dW3n5ntRb3LkuXeK2AbY8AOxRgcwLQEXgKBAC8QYlPehFAMIQRi4KMaQgLEQOghEIgDcQKhGIwxGNyL3G1ZvZftuzPz/bHa0UqWZEnWSmv5Pv/YszM7+9vR3TNnzj33HEnTNA2BQCAQDAjk/hYgEAgEgt5DGHWBQCAYQAijLhAIBAMIYdQFAoFgACGMukAgEAwghFEXCASCAYQw6gKBQDCAMPa3AIC6Ojeq2v10+bQ0JzU1rhgoOjKEru4hdHUPoat7xKsu6Jk2WZZISXF0uD8ujLqqaj0y6pH3xiNCV/cQurqH0NU94lUX9L42EX4RCASCAYQw6gKBQDCAiIvwS1sUJURdXRWhUKDT4yorZVRV7SNVXSfedBmNZlJSMvpbhkAg6APi0qjX1VVhtdpxOLKRJKnD44xGmVAofoxnhHjSpWkabncjdXVVZGen9LccgUAQY+Iy/BIKBXA4Ejs16IKuIUkSDkfiYZ96BAJB36BqGo3u2P0e49KoA8Kg9yLiWgoE8cPu4gY+XVdMg8sfk/PHrVEXCASCgUhDs5fe5AnG5PzCqHeBwsJtPPTQ73rtfKWlJSxZcn+vnU8gEBw9mIxhs+sPKTE5f1xOlMYbY8aM4447xvXa+crLyygpKe618wkEgqOHiFEPBGOTTCGMehdYt+47XnzxeQDGjRvPxo0bqK+v45ZbfsXMmbN48MH7sFgsbN++DbfbzTXXXMuZZ57DsmXPAXDNNdcDcPHF5/L008/x1FOPUlpawmOPPcz//d+v++17CQSCvieygjQQPIY99aKKJooqDq2PYDBIKMqRLbEdnOVkcFZCl48PBkM899xLrFr1BS+88EdmzpwFQElJMc899xK1tTVcc80VHHfc9A7PcfPNv+TFF58XBl0gGCA0uPxYzUYMBgmjofOodkhRW/3b2xwVRj2emDFjJgDDhg2nqalRf/2cc87FaDSSmZnFpEmT2bRpQz8pFAgEfUlIUflsfQkAqYlWTp6Ug9xJxlnEEQ3Gg1F/6qmn+M9//oMkSVx88cVcffXVrFq1ikceeQRVVRk3bhwPPPAAZrO5V0UOzkpo15vuj0U+ke8mSRKa1vKUYDC0XEpN0zAYjIccEwqF+k6oQCDoE6ILctU2+jhQ3sTQnMQOj9c99VBsiox1Ofvl22+/Zc2aNSxfvpx3332XV199lb1793L33XfzxBNP8MEHH+Dz+fjHP/4RE6HxzqeffoymaZSXl7F16xYmT55CUlIy+/btAWDbti3U1FQD4RuAosQmniYQCPoWpU2Vxe0H6vAHOv59h5o99ViFX7ps1KdPn84rr7yC0WikpqYGRVGw2+0oioLL5UJRFPx+PxaLJSZC4x2/38c111zBr351M3fccTdJScmcccZcGhsb+clPLuHdd//KyJGjARgyZAguVxO/+909/axaIBAcKdFP46mJVgJBhfJaT4fH+wLhJ/a4CL+YTCaWLl3Kiy++yLx588jKyuK+++7jiiuuwOl0kpeXx7x582IitD857rgTOO64E1q9lpOTyzvv/FPf/sEPzuCcc84FWsJCSUnJLF36p3bP+eqrb8dOsEAg6DOiPfVkp5naRh/BDsLCIUXF7Qvp/48F3Z4oXbRoEddddx033HADf/jDH/jggw/44IMPyMvLY8mSJSxZsoTf/OY33TpnWpqz1XZlpYzR2LWHiK4eF0skSUKWpVZa4kFXNLIc1pOR0fVMn75E6OoeQlf3iKUuY5MPhyMcoUhPc1LZ4MfutJCRkcDug/UYDBJDc5MAqKrzYrJpZCUn4vMrMdHWZaO+Z88eAoEAY8eOxWazMXfuXN544w1GjRrF4MGDAfjRj37ELbfc0m0RNTWuVpMNqqp2aQI0Xqoh3nVX+CYW0RIvuqKJlAKuqmrqZyWHkpGRIHR1A6Gre/S2ruIqFwcrXGSn2RmSnUC9K4DbHa7jUlfvIRAIUV3joirZymdrDwCw4JRhAGw5WMrKhreZaB3JRSPOB7r/m5Rl6RBHuNX+Ln+R4mIWL15MIBAgEAjwySefcN5557Fp0yaqq8MTgJ988gkTJ07slkCBQCA4miiv8VBR52Hj7mrcvlArh1RTNUwGud3wS52vnjf2vYKHRo7LnoDNEpuM8i6fdfbs2WzatIkFCxZgMBiYO3cu119/PZmZmVx55ZUYDAYKCgq4/35R00QgEAxcomPo/oCCEjVRqmrhMgBtjXqNt5an1j+PO+TitKQLGJc2Omb6unWrWLhwIQsXLmz12gUXXMAFF1zQq6IEAoEgXlFUFYMsoaga/qCCQW5ZaJSaaKHJEyAQZdRVTeWZjX/GE/JygumHjEwdFlN9YkWpQCAQdANF1bBZjLi8QTburtYLdM2ckE1Wip3qBh/FlS6U5nksWZI5b8i57NzrwaKkkOSIbdp3fKVoCAQCQZwTMeoA/qCCyxuuix55LTPZRkhR2VC8h1J1BwBmXxYWJdxOMsnRuyvu2yI89aOQttUfBQJB36EoGnaLTHaanfKalkVGkTCM1WygXi3ns93/woSVLGk4ZdVuAPIznTjtppjqE566QCAQdANV1TDIMieOy2b+zAL99UgRrwPufaxTPsCElROM52GQwqGawVkJHD86s9NiX73BUeOpe/65BNOokzGNPgVNDeH98P9hGTcHw/CZaCE/3hWPYxp3GqbhM9ACHrz/eQrThDMxDT0B1deE7+NnME+ah7FgKqqnHt8nf8Q8ZT7G/EmH/ex1677jj39ciqKo5OTkYLPZ2bt3D6qqcvnlV3LmmfPYvXsXjzzyIIqiYLFYuPPOe8nPH8y77/6Vf//7X/h8XkwmE/fd9yCDBw/h4ovP5YwzzmLt2m8wGAxcddW1vPXWaxQXH+Smm27h9NPPPKRO+1VXXcO8efNbaVuzZjXLlv2JUChETs4gfv3rcIkCgUAQGxRV071yk9Ggvy7LEltrCnl5x6tYSeB44w+xSA59f3qStU/0CU+9ixw8WMTSpX8iL28wo0eP5cUXX+MPf3ieV155kZKSYt5++w0uvfQnLFv2KueffwFbt27G7XbxxRcreeaZ53j11bc56aRTePfdlvIAqalpLFv2KkOGDOW1117m8cef4Z577ue1117Sj4nUaV+69I/84Q9P6UXBAOrq6vjTn57hscee4aWX3mD69BP54x+f7tPrIhAcayiqisHQ4m0nJ4QnPg2yRKmrnGx7JicYz2tl0KHvjPpR46nbz71T/78kG7Gfe6e+clMyWlrvN9tbbcvWhNbb9uRW210hP78Ap9PJd999i9/v48MPlwPg8/nYt28vM2fO4vHHH+Gbb1Zz6qmzOfHEkzEYDNx33wP8978fcfBgEd98s1ov6gVw4oknAZCVlU16egZGo5Hs7ByamlpWmEXXaZ84sXWd9m3btlBRUc6iRTcAoKoKiYlJ3fpeAoGg6/gDCsGQ2iqNcdaEHMrq6zEaZM4smMOcvFn8e024XeW8GYP58OsD2K0m7NbYxtIjHDVGvb+JVJ9UVYV77vkdo0ePAaC2tobExCSMRiMTJkziq6++5K23XmfVqi+56qprWbjwei666EeceOJJpKamsWvXDv2cJlPLH9lgMNAereu0q622VVVh0qTJPPzwEwD4/X68Xm/vfWmBQNCKbftrAWh0B/TX1lZ+x/u7/8Wtx99IjiMLk8GEyWjAYTNiNMgYDHKfeekgwi/d5rjjpvH+++8AUF1dzU9/ehkVFeXce++dbN++jQULLuJ///dGduwopLBwG3l5+fz4x5czduw4vvjiM1S1e3XUo+u0b9sWrtMeYdy4CWzdupmionB9iZdf/jN/+MOTvfVVBQJBG+RmDz2/uWnP5we/4vXCdxicmEeaNUU/bsSgJEYMSkKSJGaMy2JsQUq754sFwlPvJj/72XU89tjDXHHFj1BVlZ//fBGDBuVxxRVX8/DDD/Dyyy9gMpn45S/vYMiQYbz33jv85CeXoGkaU6Ycx969e7r1eZE67cFggF/9qvUkaFpaOnfccS/33nsnqqqQkZHFvfeKMg0CQW/iDygUVTYxYlASsixhMsoMSnfw0YHP+MeeFUxOH8/VEy7HJLeY0xF5LWHQzGRbn+qVtOgK7/1E2yqN5eUHyM4u6OQdYeKxGiL0nq4HH7yPqVOP1+u0Hwnl5QeYOHHCMVFFr7cQurrHQNPl8QWpqPNS2+jjYKWLWRNzKK5yUVHrJWNILS9ufYPjMyfz03GXYpDbD5/GQtvhqjQKT10gEAjaYU9pI3tKGkhyhufTfAEFRdEwGiQmZ0zgkpHnc2reTGQpvqLYwqjHMXfffV9/SxAIjllqGn0ANDVPijZ5Aqxv/JrBhvEYZSNz8mf1p7wOEUZdIBAI2hAMqTS4wsZc1TQ0TeWj8g/Y5dmCbDcBI/pXYCcIoy4QCARtqHf50TQNk1HGHwyyRfmUCs8ehsknkBqIXS303iC+gkECgUAQB3iam0OnJ5vZpHxMhbaHkfKJDDecgBTj2i1HSreM+lNPPcU555zD/Pnzeeml8FL29evX86Mf/Yj58+dz2223EQgEDnMWgUAgiG88/hCSJJGYKOHW6hgjn8wQwxQA0vpwIVFP6LJR//bbb1mzZg3Lly/n3Xff5dVXX6WwsJCFCxdy//338+GHHwLwzjvvxEzs0cCOHYWcf/453HTTdf0tRSAQ9JAmrweTUWJMbjY/H/9zpqScAEBmio2TJmT3s7rO6XJMffr06bzyyisYjUYqKipQFIXt27czZcoUxowJL5lfvHgxitK9FZMDjdWrv2TevLO57rqb+luKQCDoAU1+F/8of4sUUzrnSD9laFYKFTV+AFITrBjk+I5ad2ui1GQysXTpUl588UXmzZtHVVUVdrudW2+9lb1793Lcccdxxx13xEprvxEKhXjssYfYu3cPtbW1jBgxgrvv/i2//e3d1NTUAOGVpgaDgffeCz+pGI1mSktLaGhooKTkIDfeuIi0tDSWLn0cv99HUlIyv/rVXeTmDqKwcDuPPPIAADNmnMTHH/+bd975Z799X4HgWKUp4OLJdc/ToFZxRvYc/XVjsyFPiHHXot6g29kvixYt4rrrruOGG24gLy+PVatW8de//pXc3Fzuvvtunn/++UOaUx+OtqujKitljMbWd8PH1j57yPuOz5rMnMGzCCgBnl7350P2z8ydxkmDpuEKuHlu418O2X9q/klMy55yWH2bN2/GbDaxbNlfUFWVm266nq++Wklubi5PPPE0O3fu4D//+RcLF95KYeFFAFx33fXcf/9vSE5O5vHHnyIYDHL11T/h0UefJDs7hzVrVvPIIw/yzDN/4oEH7uWWW/6PE088iT//OdzVqO33P1Lk5kGZkZHQq+ftLYSu7iF0dY+u6Kr11vP0589T7avmRMd5/HDKLL2yYlqlmzpPkKH5KfpipL7U1h26bNT37NlDIBBg7Nix2Gw25s6dy8MPP8ysWbPIz88H4Oyzz+a1117rtoi2ZQJUVT1kmX1HxQxCIZWQora7X1G18P5Q+/tV5dDPaY+JE6ficCTy17++RVHRfg4eLKKkpISVKz+nsrKSmTNP5sorryEUUlFVDVmWmj9TY9y4CYRCKvv27aOkpJhf/vJW/bxut5uqqhpqamo44YQTCYVUfvjDBXzwwfJeL3+gNjfBHUjLuGON0NU9jmZdqqby8NqnqXDVMNlwDmkMwtXoxd0UXoDk9fjx+YL43H4C3t5LBunXMgHFxcUsXbqUN998E4BPPvmE+++/n8cff5yysjJycnL47LPPGD9+fLcEdpVbjrvhkNciNVbMBnO7+yM4zY5O9x+OVatW8uc/P8cll1zKOeecR319PdnZObzxxjusWfM1X331BW+99Rqvvfa3Q94bKdmrKCq5uYN4+eU3mrcV6upq9f0RokvrCgSCvkGWZC4c8UO+3lxFspxFssPSKnVx+KAkctMdepXGeKbLz/izZ89mzpw5LFiwgIsuuoipU6eyYMEC7r//fm644QbmzZtHQ0MD118/8Johf/fdt5x22hnMn38eTqeT9eu/x+VysWzZc5x22hn83//dQV1dHW63u8NzFBQMobGxkY0b1wPw4YfLue++u7Hb7RQUDGHVqpUAfPzxv/vkOwkEAihzV/BV6TcAmHyZJMtZACQ5W8fOLSYDyb0cdokV3XILFy5ceEi8fM6cOcyZM6c3NcUd5557Ab/97d3897//wWg0MXHiJCoqyigqOsCVV/4Yg8HATTctIiGh49iY2Wzmd797iKeeepRAIIDd7mDx4t8CsHjxb3nood+xbNlzFBQM7auvJRAc0xxsKuGZDX/GIMmMSxrPpj0trSIT7fE/IdoRovRuDDgSXWVlpSxceH2vZ7+I0rvdR+jqHkeTrn0NRfxh4zKsBguLpl6H6nOwZmu5vv/04/NI6APDHouYenwnXAoEAkEvs6tuL09veB6Hyc6tx91Ipj2DBpdf3z93Wn6fGPRYIWbl4oycnFyRoy4QxJASdxkplmQWTr2OZEu4Q1GjJwjA5BHpfdYgOlYIoy4QCI4JvCEvNqONOXmzOClnOmZDi/FucPnJTXcwNCexHxX2DnEbfomDUP+AQVxLwbHO9xUbuHf1QxxsKgFoZdBDiorbFyLpKFgt2hXi0qgbjWbc7kZhjHoBTdNwuxsxGgfGgBUIusvn+77mpa1vkuPIJt2Wdsj+RncATdNIHCBGPS7DLykpGdTVVeFy1Xd6nCzL+krJeCLedBmNZlJSMvpbhkDQ53xRvJq/7nyfMSkjuX7STzEbDjXc/mC4CKHVHJfmsNvE5bcwGIykp+cc9rijKYVKIBD0LVuqt/PXne9zfO5Erhh5KSZD+xOgkYDAUbBYtEvEpVEXCASCI2Vs6iguGnkuF02eS12tt8PjImHeeO9o1FXiMqYuEAgEPUHTNP5btJIGfxMG2cBp+adgPEw9pYinPkBsuvDUBQLBwEDVVN7ZtZyVxatRVIWzhpzWpfdF0jEGiqcujLpAIDjqUTWVNwvfZXXZWk7PP5W5BT/o8ntbwi+xUte3CKMuEAiOahRV4ZXtf+W7ig2cPeQM5g89s1tetx5+YWBYdWHUBQLBUY1P8VPsKuP8YWczd0jXPfQIqvDUBQKBoP8JKEFkScJhsvPrExa2m4PeHQaKURfZLwKB4KjDF/Lx7MZl/GXbW2iadkQGXT2WUxqfeuopzjnnHObPn89LL73Uat9rr73GFVdc0aviBAKBoC2eoJdnNixjT8N+JqWPP2JjfMwuPvr2229Zs2YNy5cvJxQKcc455zB79myGDRvG7t27ef755ykoOHxjC4FAIOgproCbZzb+mVJXOdeMv5wpmROP/KR6iamBYdW77KlPnz6dV155BaPRSE1NDYqiYLfbCQQC3HvvvSxatCiWOgUCwTGOpmk8v/kvlLsr+N+JV/aOQecYnyg1mUwsXbqUF198kXnz5pGVlcVDDz3ERRddRF5eXqw0CgQCAZIksWDEfIJKkNGpI3rtvJE8dXmAWPUe9Sj1er3ccMMNnH322axevZqlS5fyzTff8Mwzz/Dqq6/GQqdAIDhGqXBVsbF8O3NHnBqT82/eU83m3dVcNnf0gJgs7bKnvmfPHgKBAGPHjsVmszF37lw2btzIrl27OP/88/F4PFRXV3PLLbfw5JNPdktE28bTXSVeqyEKXd1D6Ooex5KucnclS9c/T0gLMdI2CqfZ0eu66uo8uN1+qqtdRyK1R/Rr4+ni4mIWL15MIBAgEAjwySefcPLJJ7NixQr+8Y9/8MADDzBhwoRuG3SBQCBojxJXGU+s+yMqKrdMvaFHBr0raJo2YEIv0A1Pffbs2WzatIkFCxZgMBiYO3cu8+fPj6U2gUBwlKNqGjuL6hmam4jFZOjy+w40HuSZDX/GbDCzaOr/kmWPXZMXTRs4k6TQzYnShQsXsnDhwnb3zZgxgxkzZvSKKIFAMDBocAUoLKqjtsnHSRMO3/gmQomrHLvRxsKp/0u6LTWGCkFjYFl1USZAIBDEDEPzip6aBl+XjveGfNiMVk7KncYJWZOPeOl/V9C0gbPwCESZAIFAEEMi6Q9KFxIhNldv497VS9jbcACgTww6hGPqAyHrJYIw6gKBIHZEZUwHQx03Y19XuYnnN79Cui0tpvHzttS7/ASC6kCKvojwi0AgiB3R/nmD2096ku2QY74p+55Xt7/N0KQCfj75amzGQ4+JBS5vkM/XlwBgNQ8cUyg8dYFA0CfUNwUOeW1n3R5e3f42I1OG84sp1/aZQQfYUVSn/1946gKBQNAFoterby+qIznB3MpbH5E8lAtGzOeUQTMxG0x6fFtRw6Eagxwbv7OizkNxlVvfFjF1gUAg6AZjC1JQFFX31j8v/oo6Xz2yJHP64FMxG0ys31nFf78vprreyz+/2s8/v9qPP6jERE9RhQtZlvSwy8Ax6cKoCwSCGBIpLZXoCGeyhBSF5Xv+zd92/oMvSr5udeyBiibc3iBfbSnXXwvEyKgHQwpJDjNWS3hB1ABy1EX4RSAQxB65ORF8ZdV/2dT4HbNyZ3DusLNaHWM1G/EFQkTXGOxKKmRPCIZUzEYDoeYwjwi/CAQCQRdosc8aheoXbGr8jh/kncxloy9EllqbH4s57DUn2Fvy00NKx2mQR0IwpGIyyhgNYQ0DyKYLoy4QCGKH1pzUGFADNKiVTEk8kYtGntuuZ6yqGlmpdk47bhDHj84EQFFi5KkrKkajrK94HUieugi/CASCmBFSQihaCKvByin2i8hOTOzQgKqahskgI0kSSXoMvvc99bomP/6AglGWUIWnLhAIBF0joAR5a+9bbFI+Bk3DbDB32jdBUzU99m40hP8NxcBT31Vcr/8/4qkPpNK7wqgLBIJex68E+OOml9jVuJsMqQBJljAYZH1isj1UrcW4Gpo96M6O7ymRzxiZn4zRGP4cs3HgmEIRfhEIBL2KN+Tl2Y0vsa/hAAsKFuAuzUJCwiBLnXrqqnaopx6LmLrHHyIj2YbFZNBrvA+kmPrAuT0JBIK44MUtb7C/sYifTbicSamTgXDMWpakTo20ompEFpDKkoQsSb0WUw+GVIqrXHj9IRrdARxWE4Bu1HvQqjlu6Zan/tRTT/Gf//wHSZK4+OKLufrqq/nrX//Kq6++iiRJTJgwgd/+9reYzX1TMlMgEMQf5w4/i1P9M5mYPo6KWo/+usEg4Q+2NtKqplFW7SYnzRGOqUst2SiSFN7fG2zdV8v+8kasZiOapjEiLwkAU3PYZQDZ9K576t9++y1r1qxh+fLlvPvuu7z66qvs3buXZcuW8dZbb7F8+XJUVeWNN96IpV6BQBCH1Psb+PeuzwEYnJDHxPRxrfZLUjj80tZTr23wsbawknU7q8Lhl6gwiCxLXTa2je4AH393EH+g/RWoXn8IAF8gxKj8ZJw2U7Ou8H6NgWPVu+ypT58+nVdeeQWj0UhFRQWKomCxWPjNb36D0xnubD1q1ChKS0tjJlYgEMQf1d5alq5/Hk/Iw/AZI0i2JOn7ok1lezH1UPN2WU24uJYc1YJIkqQuh0V2HKzH7Q1SWe8lP9N5yP5oo52ZYtf/n55kJS/DyZiClC59ztFAt2LqJpOJpUuXMn/+fGbOnElubi6zZs0CoLa2ltdff53TTz89JkIFAkH8UeGp4ol1f8Qb8nLPnJtbGXRoiVVLUthgt132H4mZR15v5alLEl1NfomcJzLB2ha3N6T/32lr8WUNsswJYzJ1z30g0O3sl0WLFnHddddxww038Pbbb/PjH/+YiooKrr32Wi666KIeNZ9OSzv0ztpVMjISevzeWCJ0dQ+hq3vEg66i+hKe2vAcGiq/Pf02CpLzDjnGp4LDYSE9zUmDT6HBG2qlvcGv4HBY9O20NIe+PyHBQkKilYyMBHYW1ZGX6cRubd/42u11OPwKKSmOQ66NompIBpnUZDtJTgu5Ocm98O17j97+W3bZqO/Zs4dAIMDYsWOx2WzMnTuXHTt2sGfPHq699lquuOIKfvazn/VIRE2Nq9NUp47IyEigqqqpR58ZS4Su7iF0dY940bW1fA+SJrFoyg3Yg2EPva2u2lo3brefmlo3riYfTU2+VsdU17hwu/36dkODh6qqsFnyuAPUGyQOHKxj5XdFpCRYmD1lULtaauvcuN0BSssbkUKKXkcGwGwz43L7OW5UBoOz4uPaRejJ31KWpU4d4S6HX4qLi1m8eDGBQIBAIMAnn3zCpEmTuOaaa7j55pt7bNAFAsHRhS/kA+CE7Knce+KvyHZkdnhs25i6omqtqzC2mTiViI6ph7NSIqEVr7/9SVB/UKHBHa7TvmlPNSu+OdBqv8sbBBhQIZbO6LKnPnv2bDZt2sSCBQswGAzMnTuX+vp6qqureemll3jppZcAOO2007j55ptjJlggEPQfO+t28+ctr3HthCsYlTIci+Ew6cuRmDotk6CKqtHo9iNF5aFnJNuoqvfqKYY0H69qml5TvaNJ00hmS0c0NRt8hzDqh7Jw4UIWLlzY6rWrrrqqN/UIBII4ZWvNDl7Y/BfSbWlk2Tv2zqPRzbAUzlMH8PhCfLGxFIvJoHc2OmlCNnVNfpKdLfF1SWo26qGw4e8oZz0U6nw2tckTwGSUB1QpgM4QZQIEAsFh2VC1hRe3vE6uM5tfTL4Wp9nRtTc222GJluJZNY3h8E10qzpJkkhNtLZ6qyyBpkIgFD6uo3m3YDurTtWo4mBNngAOm2lAlQLojGPj1iUQCHrMgcaDLNvyGoMT8lg05X+7btBp8dSl5mX/ADUNvlbHmDrwoHVPPdiS9tieYW+vkmN0eYEmTxBnB1kzAxHhqQsEgk7JTxjEguHnMCt3Olaj9fBviCI6Dh6pvFhc5dJfy8twctzojHbfKzcb9ehzuHxBEqM6IwWCCr5AOKZ+1vTBVNR52LCrmiZPkLQkA4qq4vEGSUmzH3L+gYrw1AUCQbusLv2Wam8NsiRz+uBTu23Qo5GklvALwLghqQAMznJ2WMs8kv0S7ZxHJj0jrNlWwdZ9tQCYTTKm5hvHl5tK8fpDBEMqGi2Fu44FhFEXCASH8NGBz3i98B0+PfjlEZ1Hi4qpR2x3stPCiEFJnDQhm4xkW4fvjWS/tKxKlWjyBKPOrempjBD27I1RoZygouorVTtaaToQEeEXgUCgo2kaH+77mBX7/8sJWVO4aMS5vXRmibREK8MHJTEqLxlZllrVYGn3Hc2euqaFvXyrxUiTt8Woe/0KiqKSlmjFZjEiSRI2S4tJUxRNv6lEPyUMdIRRFwgEQNigv7f7Qz45+AUn5UzjsjEXIUu98zAvSWA0yEwcltbl94Rrv4Q9dUmSSLCbaPK0eOYeX9jAjy5IIbPZ40+0mxlbkML2A3WEFBWDFmm6cewEJY6dbyoQCDolqAbZ3bCP2Xkn9ZpBP5KStnJzlUZVC98UEuxmXN6gngHjb85Pt7TJnok8AYQUVa8CKTx1gUBwzKBqKiFVwWwwc/PU6zHLvZfTrcfUe3C6cEpj+AlCliQcViOqquELKNitRn2lqbnNJGjrVnhhw28QnrpAIDgWUFSFl7e+yXObXkZRFSwGc0wW6UTXdOkqshQ26BqRJhthcxVZWVrbGC4EZja1NmORUEv0RKnhGJooFUZdIDhGCSpBXtjyKt9XbmRs2igMcu+n/R1JmzipTfZLZIXof787iD+ocLAyXN0wYuwjRIy6omh6wTCjfOyYOhF+EQiOQQJKgOc2/YXCul38eNQCTs07KSafo0XXCegmclT2i9wmz72+yd/h+yJeeUhRiUwLHEueujDqAsExyCvb32ZH3W5+MvZHzMw5IXYf1HObjskgEwypqKqm9ziNUFXvBcKFwNoiSxImo6zXjAGRpy4QCAY45ww5g+MyJ3Fc5qSYfk5L7Zfuv9diNqJpGv6gcsiK1Mp6L3arqcNcd7vFiMcfwu0LkeQwHxKiGcgcO9+0Gxwob+KD1fvZebAeVdPYvLeGvaWN/S1LIDgimgIuPju4Ck3TyHVmx9ygA61r73YTS/MEqC+ghAuCRRn1RneAZGfHtdxtFiNev0KjO0BqUs/LGxyNCE+9HcprPYQUlR0H67GYDOwpaQBgaE7CMVO+UzCwqPc38PT6F6jx1TI+bQyZ9vQ++dxITL1HnnpzqqIvEMJuMbYy6gBJjs6Nem2TH1XVDkl5HOh0y1N/6qmnOOecc5g/f77e6Wj16tWce+65zJ07lyeeeCImIvsCTdP0cp2N7gA2ixFFUdmyr0Y/Zt3OKpTm9uaBoELwMMX5BYJ4oMZbxxPr/kSdv56bJl/TZwYdjiz7xdzcZzQYUg+JqQMkRTXUaIvNEs5jDylqh6V9Bypd/rbffvsta9asYfny5bz77ru8+uqrFBYWctddd/Hss8/yr3/9iy1btrBy5cpY6o0ZhUX1fLT2INX1Xty+ICMGJWE1GwmGVNKSrIwtSOFgpYuSKjcA/1pzgH9/W9TPqgWCzqn0VPPEuj/iDnpYOOU6RqYM7xcdPfHUrdEetnToqtDOPHV7VA2YeCwRoDZWogV9hz+wB3T5206fPp1XXnkFo9FITU0NiqLQ2NhIQUEB+fn5GI1Gzj33XP7973/HRGgsqWvys/NgPYGgwvrd1ZiMMoOzEshODU/C2MxGRuYlA2Fv3d1cc0Jpp+OKQBBPlLrLCWkhbp76vwxNKug3HT1ZfGQyynpZXrkdT91q7jisYosDo6753WihcK0apWofnn8uQakvDW/XHESpPtDZ23tMt76tyWRi6dKlzJ8/n5kzZ1JZWUlGRkuB+8zMTCoqKnpdZCxRVY31u6r0AeP2Bhmak4jJKJPdXFjf1iaeV9fYcY6sQBAP+ELhMTolYwL3nfhr8hMG9YsOTet5TqMkSXo8PLpxNUBBdufzW9FGvS/CL1rAS3DnVy1Gu2o/rr/cRKh4S/gAgxlNVSAQ9s6N+RMwpMfmJtvtidJFixZx3XXXccMNN7B///5WFzZSTa27pKU5u/2eCBkZCT1+L8C+0gYUJE6bXsC6HZXYrUZOnJKHxWQgNdVBeb2PUcPSyEh34nCEY3jJKfZW/zcZD/UYjlRXrBC6usfRqGtXzT4e/uZZbprxU6bmTAD67ju01VXe6MdR7SEzo2dJBumpduqa/CQm2sjKTNR/d3NPGtbp+1RVw7Et7GAaDXKv/B01VUELBpAtNtSAj8rlS3GOPQnn+JNRPBoHXn6B1NN/SvLI0ahJI2k87Qocw0diSk2AjDEw+uGos7Xo6e0x1mWjvmfPHgKBAGPHjsVmszF37lz+/e9/YzC0GLSqqioyM7vWZTyamhpXh01lOyMjI4GqqqZuvy+a3ftrCQVC2Awwa1wmkiTRWO/R908ZlgqaRlVVE0MznWzZV0NxaQNud9gT2ri9goLs1n+U3tAVC4Su7nE06tpVt4c/bnqJBHMCtmBin+pvT1d9nQe3209VVVOPjHrQH8Lt9uMyyVRXu8hLtZGVau/S94r8Rk1GuUfXIXRwExgtGHNGo2karld+gWnUyVhnXoamafhqK1Fq6vBWNQESjh89RCAxo+WzRpxOvQJ08tk9GWOyLHXqCHf5uaS4uJjFixcTCAQIBAJ88sknXHrppezbt48DBw6gKAoffPABp556arcE9je+QAhrc4H9ww26YYMSkSRJj6kD1DbFZrKjL9Ga62scrHRR3bxSLxZU1nk4UB5/RnKgsK1mB3/Y+CIplmRuPe4G0mwp/S1JL8bV01TgSPglElsfOySV1MSu5Z1HUiI7C79ooZZQqv+7v+P/7r2W7TVvEdwUniOUJAnLcedhzJ+kbzsu+A3msXP04+XkbKQY1M/pLl321GfPns2mTZtYsGABBoOBuXPnMn/+fFJTU1m4cCF+v5/Zs2czb968WOrtVTy+IOW1nk5bakUTWX7cGNVCyx9QOnnH0cHHaw/isJn0pdcLTun80banrN5SDkB+J30pBT2j1FXOc5teJsuRycIp15Fg7nlIs1c5kpxGwGJuNsg9GC7TxmZS1+QnJcFKTY0LpbYEtbEC05DjAPB+/AxqUzWOC+8DQHXVEO3n2s5chGRP1LfNE8/q4bfoW7oVU1+4cCELFy5s9drMmTNZvnx5r4rqK/Y0rxKtbey6t202ynpfxGSnBV/w6DfqHn8Ijz+kb4cUNaYZA+HVgB3nGAu6T44ji/OGn83MnBOwmzpvE9eXaPSs7kuEiLfdVR9AU0JIhrBZS6rZgmP/OuSpvwQguO0Tgru/xvjTZ5EkCeOwaWg+l/5e25zrWp1LTj60rszRQPwlcPYhEcM1dVTGYY5sIfI4aLMYSXKYB4Sn3pbaJr/egCAm5xfZQ73G2vL1VLgrkSSJ0wefGlcGHZqrBByBVbe0Cb9Eo3obCe7/Hk0JOySBbZ/ieul6tED4iVPz1KPWHEQNNtddn3w2jgt/q7/fNHwG5vGn91xcnHJMGfUNu6uprGuZBA2GFMwmA3kZXX9UjRTkT0mwYDUb8AeUHk3yxgtqO4/HqzeXsW5n1RGd1x9QWL+rSr85qFGZUd15MhJ0zBfFq3l525v858Bn/S2lY7Qj9dRlaB47Sm0J3s9fQG0Kj02lZBu+j55GrS8DwJBegHnyOaA2d0SacCaOSx5ANoWfCuWEDOTEzAFf6uOYMeqapnGgvImyGg+aprFpTzWl1R7M3cxhtTSnLyY7LTjtZlRNwxXV4fxoQ9U7w8jkZyZgMspIkkR5reeIyiCs2VbOgfImqhrCBtwfUPSc5eIql5gwPUL+W7SSv+58n4npY7ls9IX9LadDNLQux040JUiobAeqqxYApaYI2/JfkebeHb4xhPwoxVv1/ca8CdgX3KuHSQyZw7FMuwjJGifzCf3EMWTU0ct4+oMKe0sb8QVC+LoZPomEX5ITLCTYTQA0HcVGPdLua9yQFI4fncEZx+czPDc8OfRdYWWH7ztQ3sRXm8va3dfoDlDX3MQgsuo2cuOLrNJdv+vIngSOVTRN452tH/Le7g85LnMS1024EpPB1N+yOqYdTz1yc9dCfnxr3gqnDgKaz4X3n0sI7f8eANmZhjxkGgGDM1ylMWMozp88iTFnNACS1YkhcxhSPH//fuCYMeqRMIM/qBAItnigESPTVRw2I0aDTIrTjNMWHkwuT+Aw7+p/VFVj694aPFHpmJV1Ht1wR1bUWswGHM3fq87Vcex7/a4qquq97T6lHKxsmXyKXOtIGmh0/WvtCDMjjkUUTWFzRSEzso/n6vH/E5MWdL2J0V2Bwx8eY5qm4f7b3QTWvhveaTAR2vkVSk0xAJI9GdvZt2EcPiO8bXFgP/Uqmmw5SBIDPmzSWxwzpXcjHmkgqOpx3hnjsshM6Vo6Y4RITZjIKlK71USTJ/499d0lDRyocqMEFU6akE2iw8zWfbV6Jk/0RFRBdgIbd1d3muppNMiEFJXCA3WcMKb1grMmT4BEh5lGd4Ct+2sZNigRlzeIQZZISWjJegkpGiaj+KF2BVVTCakhzAYzd576CxpqfchS/PlkgW2fAmAedxoAmRtexGzKBKaHKy3mTUBOzQNAkmQcVzyF1Pw9JEnS88AjyHK4VIBIge068TcqegmtubnF9gN1QEvsOBBU8DfHiu1WU7c7osiShNXcci9MsJniPvyiqCrb9tfq219vLafJE9ANOrSugCdLEskJFr0UcVuimwEXV7nYV9a6gUiTJ0iiPVxBT9M0quq8uL0h7FYTNkuLZ9nR+QWtUTWVNwrf5ZkNywiqIaxGS78ZdNXXhFK9X9/2rXoFz4f/T98OHVhP6MAGfbt67CUcyD5N37bOvAzTiBP1bakL32PqyHSG5SYe9jhBmAFr1CvrvOwpaWBHUR2qqumeuj+o6GmI3Z0kbY8EuwmXNxjXoQR/IGw8R+YnMyw3Ea8/RFGFKxynjFTBa1MBzyBLeif2tjS6AyiqxvGjM8lOtbNpTw01zROiIUXF4w/p8w0AVQ3hcsYOm1FPUYscK+gcRVX4y7a3+LpsLaNShmOU+jbcEirdjj8SLgEC3/wN778e07fl5BwMGUP1bdtZN2M/+zZ925M8HJ+16ynD7ZGT5iCxkzK7gtYMSKMeUlT2lbd4j42eQKvUPZc37KFG0hOPBKfdhKKoFBbVH/G5epvKei/f76jC3xxuykl36EumiyqbSEu06vHztmVNjQaZkNq+0a1pTklMS7RywphMjAaJospwNkuTJ3yDc9rNzJ9ZgNUcbivm8YVwWE1IksS0sVlAOPwSfTOM5xtjfxBUQyzb8hrfVWzg/OFn88Nhc3s9rqwpQZSaonAFQSC4azWuN3/VUjK2Yg+BLR/ry+lN40/HevqN+t/KPOFMLNMv1s8nya0juqqqHTK2BLFlwMXU65r8rNxQAoQzVOqb/Id4nE2eICaj3CvNaDOTwxN/DZ1MKvYX63ZU4QuEONhscK1mo27U/QGF3DQTIVfYcHfHU69t9GO3GLFbw8MnLcmqLyjaebAeSZJIcZoxGQ0k2E00eQKEFFWvfx3pPRn5O82bNYxNOyrwBRROnZzbm5fgqOatHX9nY/VWLhl5PnPyZ/XKOdXGSoK7vsY0djayPZnQnm/xff4C9h/9HkNyLpItEUPmcLSgD8loxjxxLuYp5+hhku6Wi1VV7ZCxJYgtA85Tr4la2DI8NwkIx5SjFwg1eYKY2ymX2xPsViPJCZYjLXERExIdrVO9rBYjpqjl/2aTQfei2uo3GuR2m4CU13ooqXK1KqrksJrw+kM0uAOU1bgZnZ+M3Rr+bLvFqE8kd7Q68MsNJZRWu4/JRUmqprFhd7WeAhrN3MFzuHLsj7tl0DVNQ3XVovnDHbqUuhLcf/8NodLC8Od5Ggh8/z5qbfiGasgdi/X0G5Ft4d+KMW8CttNvQLaFY9iS0dyluHdHhFQVQxx2HhrIDKirraoaW/aGe4omO1vyyJWomDqEKzP2Ruglgqk5EyTeiBjRGeOyyM90YrcYW1Wss5gM+rbSZlWsQZZQVI0Gd0BPg/QHFNZsDRflSo7KYrGYDIQUle0HajEa5FaTWvlZTj1P2drcuCDBbibZaeGUSbmHeHFH8+rcnrB+ZxX7yxr1cesJevn04JdomkaWI5MZOcd3+n4tFCCw9b8oFbvD265q3G/cRnDvWgAkawKSNUFfAGTIHIrz6j9hzBsPgOxMxTR8BpLFEZPvJ8Ivfc+AMuqR2LHdauLUybn6YFIU7ZDl8L3ZYdxgkAjFoTEKKRpJDjM5aQ6OH52JLEsYo4y6hsbk4ekMyU4ks036YiRl8est5WzdH84gCoRaFmrlprXkm0fCKuU1HobkJLS6tulJNsYPS0WWJJzN3rvJKDNn6iDSkqz6E1PkPV9sKu3NSxDXBEOqntNvsxhxBdws3fA87+/+F6Xucv04LehH9TSE/6+plL31AIHN/wnvlA34v35LzziRnGlYTr4SY+6Y8G5bIvZzftmyYEc2Ipn6rpiaomoiHbGPGRAxdY8vSJMnqE/6jS1IQZZbehoqqoahjdHtrfALgFGWCYVa0hobXH5Urf8Hc0g59NE3OvxiNRmwWYxMGXlod3mjIeypK4EQvuYKjqHmGPuJ47P18Aq0eODQEvKKZnhuEgVZCe1WflRUFQMGEu1mqhu81LcThhioRIebGoONPLn+Vaq9NVybdTKZ1aXgzEHTNBreuhNTzkgcZ9yIJMlIRjNEcrtlA47LHw9744RTBCM54vGAomr6HIqgbxgQRv2jtQcBmD0l3IfRaGh+1JRbQgttwwupib3nrRiNLZki9S4/a9eVMDTTyYi8Qw1cX6Komn4tItgsRk6ZlEtIVQ/xztseF8EbUNi8t0YPMbU9Z2pUKCb6fdF0VMo3GFIxW8IF0qobYtegI57QNBXN20RTc225vKZPec+3F5dR4sZJP2Pw1+8SCK3DNOR4Gt0BtqfMxmlPY2Lz+7Mvvr1Vt5xI/DseEeGXvueoN+rRYRV38yKgiAExGCKeuoqqth5YXW2M0RWMBkn3YtdurwSDjDcQOsy7Yk8wpGI1H1oXIy3p8J1j7FHG2eMLsqekQd82tTHQRoPMieOze5T3PyjDSb0nSHqSlV3F3X77UYFSU4RStQ/zmNkA+Fa+hFKylabpd2IxG2gyBPBLClPl88m1DcZ62vV6jFtRNSqSJhKwH5315xVFGPW+pltG/ZlnnmHFihVAuBPS7bffzqpVq3jkkUdQVZVx48bxwAMPYDb33UKBUFQlwYbmGiwRox6ZhFPb8dQd1t67n5maM0VUTQsvsnFYWhnF3mJPSQM1jT6mN+d5d4amaTR5AiQ7e/a3sHdyfYztGO/u1tCJcPzoDNLTnBTurdZf62kD8/5EC3jAZEWSZEL71xPY+jG2s29Dko2E9n1PYN1yTCNmIhnNmEbOxJA1nHqXG6fNzNRJ15FYUsXBMh+KoiEnJOvn7enEcXW9l9Qka7+HABWR0tjndNm1Wr16NatWreK9997j/fffZ+vWrXz88cfcfffdPPHEE3zwwQf4fD7+8Y9/xFLvIQSjsk52HawHWsIDsiQhy+FJzEjO9amTc5kzdVCvGo2IkfNGdQ9SNY2SardepqA32Ly3htJqN0oHi4KiKa4Kp7T1tIOR3Wri+NGZTBreXry992KksiRhMMhoUcar7Q043lA9DQR3fqWnDQZ3rcb18s/RmsIZLJoaQgv69a46pvGnh2ucGMM3WOOgcVTmjeKf9S9Tre3DaTNRkB7uJxpsk0XVdrsr1DX5WbW5jO37e2/s9RRVE556X9PlX2dGRgZ33HEHZrMZk8nE8OHDKS0tRVEUXC4XiqLg9/uxWPr2MTFS8zu6Hku00YksoonEg1MSLL3eSs3anLkRXdhLVTXWbq9gR1Hv/LBahZl8UTcPVWNPScMhtc8jDaRHD07u8WfmZzoZlpuoh2v0Rr4xyDuOTpE8kjruXSHcaFttKQGraWihgL6qUtNUtIAHrXnyW22owPvxMyhV+8Pb9aX4Pn8BpWofAIaMYZinXQzNRts0bBqOBfcg25OBcMw7Ou69v7GIJ9c/B5pEXkIO0OIYtF0b0JNrEfHuo6tl9ge1jT4CQYVgKL5v0gONLv86R44cyZQpUwDYv38/K1asYPbs2dx3331cccUVnHLKKdTV1fVZ4+lgKICnrpygL5xBcPyIFKyBOmQ1gNEgo4UCqPVlmLUgvkCInfsrcfoqIBg+Xgt4Uar2tbS+8rsJle9q2fa5CJVu17dVTwOhg5tatt11hPavRwv6sJqNWIP1+HZ+g6yGQ0CSq4qshs3IatgwKHWlBHd82bL8uqaIwLZP9VZcStW+8HLsZsOilO8isPFf+vd17dtCQfUqIFzXJnRwM/51yymrcbN5bw0l67/C/33LU5J24Dsmur7Sb3bBXaup/fxNfX+gcCX+b99p2d7ycevtjf/C/+3fAJg1IYezrBs5Wfma40ZlIMsS/m//hv+bt/Xjfatfb739xYuttr2fPtd6+6Ol+vkBlI8eZ5ayJqxVUfH848FWetzv3tOqBonrrV+36vzuenVRq+/f9OL1+NeFe+dqSpCmF67Bv+GD8M6gD9cLP9M7xeN343rxfwk2VxjUvI24Xv45rq1fhvcbjCg1B9G84dIThsxh2C/5PYZI2mByNpapP0S2H35ifHf9Pp5e/wJW2co04/nkNzd4iDgioahVvA0uP9UN3V+QpTTfrHz9PK8TaWQeXcRNEHu6HfjdtWsX119/PbfffjsOh4NHH32UDz74gLy8PJYsWcKSJUv4zW9+061zpqV1v1PJPz/5nNeq3iLJaMcopeEuTSahdg1Dh59LTvYJ+Mv2Uvr2nQyZ/DP2e+1kSLVM2PcczhmLsQ+aivdAEWXv/Zacy+/DNmginr17KV/+ILlXPog1YwzuXTuo+OBhcq9+GGtGJu7CrVSseJxB1z6GJSMTV+UGKj96irzrn8KWnEnRNyWkbXqX5In/hx9I8uwnp/Q9vp90OxkZCTTs30PNymUUTJ2FwZFA/d491K56hZwTz0S22KnbuZu61a+Tc8oPkY1m6rbvpu6bt8k9/UdIkkTTmkKGVX9OzZAz2F/pZohSSHDzJzRlzsHhsKCW7iDUsIW8eT/B6w/hdBeR7tlDRkY41a16XTGeom3kzbksvP19Gf7q/S37fdUEG8r17apAPYqnvmUbL5rkY9iE8DL+KikIqC37TSAZJdIj2zYrBpuF1Mh2QgLGhARSItup6ZiSU0lu3nZk5YE1A0fAQnKyHS1vOOasfBKb90tDJ2LJHYojzcmm3VVkDZ9KwpAROJv3yxNPxVowGkdk+/izsA0dhz0jAU1VMM48H9uwidgyEtAUK6ZTfoxt2CSsGQmoQTPmH1yObcgkLBkJqAETljN+iiljMAkZCZCRAAufjRp9CZBzaFjqcFS4qnh25TLS7ClcOfpqCnd7GZKfQoLdjKN5LiYh0UpGRgK7D9bz7c7wPIPDYcHptOrXGmj1/7b4tfB7ABwJ1lbpp7EmWldFox9HtYeTj8vv91WlnV2v/qa3tUlaN6ooff/99yxatIi77rqL+fPns2LFClasWMHSpUuBsMG/5ZZb+PDDD7sloqbG1e0JoVUbt7Gr+hM8Dgsl3iYUQxOukIerhv2QaUNOZVflVp7f9iZOOQlJScKp2UgPBDjvxLNITs5D87lQKnYjZw1HtiaEt6v3Y8gYimRxhLdrizGkFyCZbWg+F2pDOXJqPpLJEt5uqkZOyUWRjPz7y+1Ygk14LGnYnXZyHRrFB8vwmVM4/9QRaAEvmt+N5EhFkmW0oC9cX8OWiCTJ4YJJoSBYHEiShKYEw70WjRYkSWLTrkqKKho5ZepgPltXzNjByQwblMS/vynCYjLg8Yf4wXF5JDnMlFa7+XZ7BadOzm21nD8jI6FVKly8ENFVVe/lq81lnDwxh/QOspMa3AE+W1dMbrqjSxPGvaGrt9A0jc+KV3FC1hSKigPsK2tk/klDkCWJYEjlw6/3M2FoGiPyknj/y71Ay8peu9XE3Gn5XdJVUuVibXPzk+NHZ5Kf2Tft3drq2rq/lr0lDZw7a2gn74o98TruoWfaZFnq1BHusqdeVlbGTTfdxBNPPMHMmTMBGDVqFA8//DDV1dWkp6fzySefMHHixMOcqXcYmT8Er3IhHk+AkQ4DZ07Lx6/4kZtLkzrsaRyXcxwH6yuodFdSSRN7zBqzOJ1kYH3jXj4s/4SMhvWkW9NIt6WRbktlpNGEhXCrrMiqPJq3DdYRbbbDF9YInHbiaHaX1LO3NPyIHjJY8VrSgHA8/Kvtdbh9IebNCHt4ksmKZGoxuJLRAsaWuLJkMEFUm656T4ikBDtJDjNpSVaKqz3YrCYUVWNobiJb99XqK2qrG7wYZImkHma+9BfRi8U6ItLgJFIrJvqmFa9sqNpChi2NQc4cTss/BYDaplKSnRY9OyUyuV9S7WJITgJpiVZqGn2cfWIBe0oa2H6gjmBIbVXmoSOir19FrafPjPohOtpZ/CaIPV026suWLcPv9/PQQw/pr1166aXcfPPNXHnllRgMBgoKCrj//vtjIrQt4TzzOjRNIyc97N1ajS0/8FxnNpeNvpDaRh9fbCxF1RR8uMhPCC9QshttZNnSqfLWsKNuDwElHOv+3Ul3YjGYWVWyhu8rNpJuSyPDlka6PY10ayp5CbntNiiwW41MGp7O2IIUvt1Z3So2qqpaq0Jj3UXVwjVYhmSHH9MGpTvZtKea3SUNWM1GslLtYaMeUPSl5zlpjl6pQtmXRAxAZyUXIkZdliW27a/j5Ek5faKtp3xT9j2vbn+byRnjuW7ilfrrje4Ag7NaHrsj2Vh1TX5WbSqj3uUnO9WO0SDrtcSbPIEu3cQiRj033UFZjbvfVjeHFA2jyHzpc7ps1BcvXszixYvb3XfBBRf0mqCuEp37mpvWcTGihOYOPLJkwE4S5mbvd0zqSMakjgSac7qDLqq9NSRbkpqPlwmqQTZVb8UVDKeuSUg8OedBZEnmv0UrKWosbjb46eF/bakkW5KaH6db6qQcaYpekyeIoqh61k52qo1Ne8KGIS/DqWff+AIhSqvdBEPqUdkppqVWT8cZH4HmbJDBWQnsL2vssvfaH3xZsoa3dvyd0SkjuHLcpfrrqhrOxupo+Xx9cxnnyHeNrHlweYOtsrw6IpK+m5ZopbTajccX0vvp9iXtlakQxJ6jekVpSoIFt9vf6ZJ/k1HGYTXh9gU5cXx2u8dIkkSiOYFEc4vndFLudE7KnQ6AL+SjyltLg78BY3MTAE/Qy/7Gg6yr3IRG+EeUbEniwVl3I8sS6+vX0KA0YSOJrTVe3JofGz2bEImslI1UnYz+YVvMLZUWt+6rZXR+clhLL6dt9gVGQ9fDL5FFVYGQ0hx3VvW+sfHAp0Vf8O7uD5iQNoZrJ1yBKSqUFtTLLXRu8CLrHiJ/7427q7GYDBTkp3T6vsg6hoiH7/YG+8WoK8qhZSoEseeoNuqnTRtMRUXjYRcSRWLLPV31aDVayU/IJT+hpYHDecPncd7weSiqQo2vjmpvDYHm9EVZlqgJVlCuHkAlxI5t4VTEJCmLC/k/AFbs+y8G2dAS3rGlYTO2/2jta26/F6mGKMvhBTuKomI2ykiSRGaKjco6LxX1XowG+ahcxafX6umgOYeqalTV+zCbDLqh8wcUtu2vo6TKxfknD42LlaiqprK1ZgdTMyZyxdgfU98UIiO5xahG1ky0fcI4eWIOqzaX6dvjhqQC4Q5dshSeMPX4Q4dNVYxURowYco+/f1IbQ4raqwvVBF3jqDbqluYqg4dj3JBU3cPrbQyygUx7Opn2lhQ3WZI43nI2XoIE8DJ2tIVVhbsxRF3ub8q/p8pb0+pcJ2afwBXjfgTAv/d/SpIlkQxbGnWe8A8juqRtxHRFvNNpYzL515oi6pv8Xbom8Uh0rZ72KK5yUd3gZcLQNH0hVCCkUlIVXmTT5An2ay9LTdMIqkHMBjPXT/opBslASZWHdTurmDUxR683FFlQ1NbgpSfbSE20Utvo46zpg/W/oyRJWM0GfAEFVdNodAXo7NalqBoGg6TfNGK9mKsjQqqGTVRo7HOOzl9/N3HaTNCHj58GWSKoqEiShAU7BY5B7JXDRihS1+S+mb/GG/JR7a2l2ltDtbeGjOYbg18J8MHe/+hhHQAZI/aiM5lb8AOCSpADoc1YtARcigFFdWAyGkhJsFDb6OuVhtr9QXRZh/aIhCOG5SbqBdOamuv9QHixS38ZdU3TeGfXcvY1FnHL1OsxG8I6Ipr3lDboRj1Sr6i9uYCE5nHa9sY8eUQ6IUVlbWElTZ4AiZ0s6AkX0ZIxyOHG4j0pNdAb+AMKyaJhdJ9zTBj1vkaWpVaTfdExYk3Tm9BgayesA2AxmHlyzoPU+uqo8taydu8+6gN15DrCcwLVvlq2hcKrHdfvAmmXRKo1mWmJs4Fs/KqX9ZWbm0M7qa2yguKd9troKaqKP6DiD4YnRWVZ0j31fWUtOb77y5sYmpPY56EnVVN5a8ff+ar0W36QfzImucWB8DaHzipqvbiaY9udxdQnj0g/pKELQFaqHVUNOwRuX7BTo+4PKphN4bCcySi3KnrXHh5fuBNYb4ZKFFXFFwh1WhhOEBvEFY8BnbVoU1QVWT78hJ5RNpJpzyDTnkFVkROr3cCE9LBRz7ZncvO429heWkJapkJ9oI4qbw2DklMpqoNidyn/3NKyAMxpcpBuS+N/p19GEmk0+Bup8taQYUsj0ZwQF3HoCGajrM8hRNi0p4YD5U1kp9l1Y240tEyA2y1Gxg9NZW1hJVX1XrJ6OHfSExRV4dXtf2NtxTrmFZzGD4ed1ep6+gIhbBYj/qDC6i3lTBuTqYdD2vPUZVlC7iC4IsvhMIzbG4ROyif7g0qr6xRSVPxBJXxDbPO31jSNj9YWkZpo7dWm315/+G94tIYCj2bEFY8BbUMAihZt1DW6GwjyBZRWC4kkSWJUdjajsg/N5jF4q5lgn8hZCSOoag7rREI8FqMZArClZjtvFIbrqJhlU/PCqzR+NOp8UqzJ1PsbCChB0qwpGLpwA+pNEh1mGt2BVq9V1Ydz/Gsb/a2yOOxWI25fkMxUO1mpdmRZorrBpxv1Rk+APSUNeP0hThyXHRMP/u+7P2BtxTrOHTaPeUMO7TjkCygkOswYZInSajcrN5QwYVh4UVpPOgLZLUbc3nBIZ/uBOiwmwyHpq/6gQkpz9pPRKFPb6GfFmgP6atVoXM2ZVbWNPjy+EPvKGinITqCuyc/ByiZmjs9u96bv8YX4bH0xM8ZlkZ506OrfyORsLEpQCzpHXPEYMHxQMuu2tfSYjJ6o6m45BFXT8AeVLuUnQ/jxPUJkoVWEjKTwkuSJ6eP4+eSkKKNfQ6W3Wg8brCr5hhX7/4ssyaRYkvUc/ItGnovZYKYp4MIkm7Aaez9tMtFupqzG0ypzwmo24PEFCQQVHCktXviIvCSq6r0MznRiNMikJFioau6epGkaKzeU6qGcepe/11efqqpGRmgcFwxN54whs9o9xudXSHKYkaK8b39ACfeL7UG4w2I24AuE0DRNrwDq8QcZnpuke8WBoIKlOVPKIEs0NDcOr6r3oqgqwwclcbDSFX6CiHoq2rIvXNpZ0zR2NzdFcXeQ436wsolgSGV3SUO7Rt3bXElUhF/6HnHFY0B0GVmg1Q+nuwuRAkEFTdP0dMbeINGcwPi0MR3uPyFrCmm2VN3gV3lr2FJTyI9HhxeZvb/nX6wp+44Ek1Mvr5DtyGTekNMB8IX8WAzmHoV1Eh1mNE1j675aJg5LaxU/H5GXxMi8ZP3YrBQ7580aqnvgGUk2dhysxx9U2L6/DkVRSbCbafIEqG7wkZxgQYIjDjf5lQBflaxhSso06msM5GWMbPe46BtyfqaT/eXhEhIubxCLydAjHVazgVp3kECwxVHYU9JIkyfIzPHZhBSVYEjVr1n0J1TUeaio8+DyBvWyvFmpdixmA8GQSllNuL+eN2q8NrgDBEMq9S4/Q3MSCYYU1u+q1o/1+dvPKvP4gs1ZO8LE9DXiiseImeOz2XGwntpGX6sYcXc99ciPty8zWrIdmWQ7MjvcPyP7eLJsGbqnv6dhP0VNJbpRf2HzK+xtPEC6NVXPwc9PGMS07KlAeGKxvVIL0BK62lfWSILdzLDcRBRVJSXBwoShaYccHx1SSU+yUliksWLNAQBG5ScztiCFz9aXUN3gZdv+WoblJjFp+KHn6SrekJdnN77EvoYDJI7MBoyUVrvx+kOHxI93HaxH0zQsJgNOm4lTJuXy5aZSymrcPV4cZjUbCTb42bq/FgiPs33ljXoMu23YY/KIdPxBhS17a2hoDmtF11lv8gTJTLYRUjTKasIrp+uiG2K7/GzYVUUwpJKb5qDO5ae02k1Gso3kBAu7ixsIBJVW6bZhHQo2s+GoXC9xtCOMeozISrWTkWJj+ap9etwSwOULUd3ooyAroUuP35H8+rY/mv5kVMpwRqUMb/WaqrV4jjNyjifHmUW1t4YKbzXbancwNLFAN+q///YJAkpQD+sMqcklXc5iZMqwVo/rkUU6IUXrUimAlDYri8cWpCBJEulJVr3Q2t7Shk6NeqRoaXtetCvo5g8bllHsKuVnEy4nKZRFMTWomkZRRROpiVbSk6z6eyMhDKfNqOszGeWwJ93DJ6/IE1txpYuCrAQykm2UVrtpcIUN9tdbwmG/yHWM3CQj6xkMbbKLvP4QdouDBIdZN+rRi5Xq3QFMhrDmijoPkemhKSPT8fhC7DpYT53LT1ZK68lpjz8oJkn7CXHVY4jcnFJWG+X5fFdYiaZpBAIKY5tXDLYlEFSobvCRm+7Q63/Ee+55tOc9Pfs4pmcfp2+rmopf8evbx2dOpsxdQbW3lvWVm1lV+g0zso9nZMowJGBV8A3Mko2D5RnsCmZT6ZHIT8gHOi/eZZBlpo7MYP2uKsYMTtGNa1qSTTfqBoPMgfImnDZTuw2412yrwCBLh5T1bQw08fT6F6j0VnP9xJ8yIX0sW/fVIssSNouRAxUuth+oY2ReMuOHhv+uyU4LLm9Qz0+XJUk3wj1dtp+b7iAxyYZFasksMZlkvP4QX20u0/Pi28ayIzdFu8XYKrdf08JlfbNT7a0MflaKHavZQGmNmwS7GY8/RGmNm9SEli5YkTHZ4AocYtS9vlCXGpwLeh9h1GOMQZbxBUIYZIn8zAQ9rhox1sGQSoPL36p++L6yRrYfqOPsGQUEmguDxVNdk+4iSzI2Y8v3O3voGa3225MMlFXWAxBSQwxNGEqZq4piTxE7mraioREyzQTG4Al6eHL9c3osPxLeyXPmkmB2UpCdQEF26xo7WSktn200SKzfVQXAglOGtTouGFKpqvOiahpV9d5WzQvK3ZXU+xu4cdLVeiG4kKJiMoTzuz3Nk5F7ShsYPzQVf0AhEAxnLUV7/clOC6XV7h737TQaZEZmJ7WqwR1pLxjpNJSdZj8klh0xwBaTgcg7p4xMJxBUyU13YDTIHDcqA5cnQFBRGVeQSkWdhwMVTbpTUlnrxSiHv2/kKdNhNelhnQiqpuELKCLzpZ8QVz3GRIzypOHpJNhNulGPxBo37q6muMrVall4ffOjtC8QaompD+Dl1g6znSRL883LYOKmaZfz0bdFpCXZGD88iXdXb2F0Sjhk4lcCpFiSqXBXsrWmkJAa9kwvHX0hpww6kQp3JW/v/Afp9paaOhm2NMYNTWbbvnqMsoyfQyf3VFXjw6/3A+G/zVeby8jJTiSgBDAbzIxKGc79J93Zqj6PooabKhtkSc9wUtVww/G12yuAQwurDc1JoMkTYGhO71XRbLtidMzgQwt+mZvDNlazAbvVhMcXJMlhISVqUn9QugNoqXiakWzTm3REyhcUV7lwRD1lJDnNelXJCP7mcgZWYdT7BXHVY8yM5sf4rFQ7mqbhsJlwe4N6FkykznpptZuC7HCcPeL5+AIKpTVurGbjMdeRPZK6p4QkHFIyGY5wSCPFmsyNk68GwmGdBn9jqxILPsWPJ+RlXcVGPCGvfr4bJ11NRnIy+xoOsD+0BZuUyFfFNeQkZJJhS0NSWtYBTB2Zwfc7KtlUtJ83dv2F84efzbTsqYcUXAvXWJEP+dtEDDocGps3GQ0cP7rjSeieMDw3ieJKt17oK1LNM5pILF6SYPKINFzeoF7psiOMBpmMFBvlNR5SEyx4/SG8/hCDo5puRJ48oktNB4+SkOFARRj1GBO9ulGSJMYWpPBdYSWBoEJdk1+PgW7eW0NNo4+pI9P1R/naJj/1TX4mDE2Lq1WffYHdaqLB1XJ92mteLEsyKdZkUqzJ+msFifn8etoiADxBj56hU5CYz45qD27FRa1Wgl/byd6d3+nv+/nYnwOgOqr4rnE75ZLKV9vXIcvhhivtEa4X3n6+uSRJaJrWJ02XbRYjx41KZ3XzJGl7zVFMURqzUuxkdV69V2dIdiLlNR4cNhNTR2VwsMLVKq00siiuwRUgl3DoJTLhaoqjyf1jiW4Z9WeeeYYVK1YAMHv2bG6//XbWr1/PkiVLcLvdjB49moceegizWRTx6Yi8DCel1W5qGn1kNXvkyU4LSGHPPJLFAOjVB9OTj70JJ7vFSHmN+4iWm9tNdgpMdgoS85tf8ZAlDyNLHoaihUhKUcjOgSpvDVYSgXrMiS4+Lv6KkBrCKju4Ydy1DHK2P0EbLpwltfLUxwxOobCoDofVyIxxWX2WAaJnt3TwRBd5vbtNK7JT7Zw7a4h+o8hs0zs2ubnBdU2jj5IqF5t3VnOwMhy1F556/9DlEbd69WpWrVrFe++9hyRJXHvttbz33ns89thj/PnPf2bMmDHcdtttvPPOO/zP//xPLDUf9WSn2sNpaM1Gfca4LDbvrcHlDdLQnJlgkCVc3iAmo9yv5WT7C5vFiKJqNDTHa3vDOGan2fEFFCYNT+PTdcWkWVOYkJ4BwLb9tciSxNnDfsA5w39AWWMNhft91FeboIMMSEVVMRsNeslgaMk6MciS3nWrL4g0o+horOSkORidn8zwQUnt7u+MztoiWszh8tfbD9RRVO3B7W6Jrwuj3j90+ZeSkZHBHXfcoXvhw4cPp6SkhClTpjBmTHh14uLFi1GU2NQtH0hE4puRMIvJGM4mCIVUGl0BLOZwE4gGl5+0RGu/9JfsbyIpeI2egH59jpS8DCd5GeF4cKLD3Kp8Q22jn0SnWTdgg5IyaEhtoKyy407vkbrl0UYvMjnY152nnDYTYwtSWvU9jUaWpQ5TaI+URLsZrz9ETroDkq16fn48ra04lujyL2XkyJFMmTIFgP3797NixQrMZjN2u51bb72V888/n6effprExKOvN2ZfExnsbl8o3MWouQ5IUFFpcAdIcpj1lafHaq5vxPNs8gRjkhpnMsp6ZpGiqtQ1+UhvUxsmOcHSPKndfunaUKRueZSnnuwwM2NcFhOPYNVqT5AkidGDU/plwc+YghSSnBamjspkZHM7Reg4FCSILd0eAbt27eL666/n9ttvp7y8nFWrVvHXv/6V3Nxc7r77bp5//nkWLlzYrXOmpTkPf1AHROcSxxOd6bI5rTgc1SBLpCTZyMxMJL3BT0WDD0WSGJybjKZB4YFaJo3OwtmLj/FHy/VSZBmHox6A3OyEXtedluLA7QuSkZFAVZ0Xq83MiCFprT7Hq2jY7GZMVjNp7RStstlMpKbasVmMlNaGM22yshIZlJvcq1rbI57+jhkZCYwaFs4+SnKacTTH2TMz48fBi6fr1Zbe1tYto/7999+zaNEi7rrrLubPn8/f/vY3Jk+eTH5+eCLq7LPP5rXXXuu2iJoaV7drokD4YkQvwogXDqcrpKh67NFpM1FV1YSryae/pgZD5GU4yU7Kxuv243X7OzxXb+rqL9rT1djk16+HQXX2um4lGKK8somS0noOVDSFPysUavU5KYlW3G4/+4rqULMP7fPZ0OgjxW5CCRh1rTU1rpiHy+L571hd7cLt9pPstMSNxni9XtAzbbIsdeoIdzn8UlZWxk033cSjjz7K/PnzATj55JPZunUrZWXhZrmfffYZ48eP75bAY5HojInIStLo2iaW5kJIR/Mq0iMlugt9ckLvTzgOzkpAUTWKKl16nfa2qzCdNlOrdQPRqJoWXlFqlFtNCB6L8x9tmTdjMCdP6rykgyB2dNlTX7ZsGX6/n4ceekh/7dJLL+X+++/nhhtuwO/3M3bsWH7961/HROhAQpIkjh+dicEg6Sli0XnEFjHBpE+MSpIUk0nHJIeZtEQr+8oaMcgSznYW7EiS1G7TDmjpM2o0yOLv1QZRbrd/6fLVX7x4MYsXL25335w5c3pLzzFDbrqj1Xb0BJcwEi1GPcFu6tXemdHkZTrZuLsaCJftbQ+nzaTXVIkmsjTfZJRFlocgrhCJpHFCdFU9YdTRM0pimRoYHfLqKGvEZJT1EsDRRPcZHch1eQRHH+I5KU6I7mwkGguEY9MThqWREcOUzuiUuw6NenMtcU3TWpVqiIRfTFHhl1g9UQgE3UEY9ThBkiROmZSLwyb+JBFG9GD1Y3eIXjLfUS68sdmbD0+KGlA1ja82l+kF2YzNC6NOnphzTK78FcQfwoLEEcfqQqP+wiB1zVMHCIY0TMZwT86ahnBlTUlq6Z+annxoHrtA0B8Ioy44ZoleCdpRe7lIamUkrh4pbzttTCZOm0m0bBPEHSIIKDhmiZ676Ci/PBJ+2dHcRDpSCthpN5PUx/VdBIKuIIy64JjF2IUJaXPzArCSKhdN3qDelcrWw8bRAkGsEUZdcMzSWUnZCElOM3ZreGGSL6BwsNJFVopd5KYL4hZh1AXHLF1JHZUliZMmhDsfuTxBfIHQMdm0RHD0IIy64JgleqK0MyJrCKobwitLHdZDSwoIBPGCMOqCY5bI5OjhapUYDTIOq4mKWg8QLh0gEMQrIh9LcExz0sQcErpgpEcPTmbdzipkWRJGXRDXCKMuOKZp20i5I/Iznewta0SWJFHGQRDXCKMuEHQBSZKYNSGbHvRyEQj6FGHUBYIuciw3LREcPYiJUoFAIBhAdMuoP/PMM8yfP5/58+fzyCOPtNr32muvccUVV/SqOIFAIBB0jy4b9dWrV7Nq1Sree+893n//fbZu3crHH38MwO7du3n++edjJlIgEAgEXaPLRj0jI4M77rgDs9mMyWRi+PDhlJaWEggEuPfee1m0aFEsdQoEAoGgC0iapnV7Pn///v1cdtllvPnmm7z55puMGjWKvLw8nnnmGV599dVY6BQIBAJBF+h29suuXbu4/vrruf322ykpKaGsrIw777yTb775psci6urcqD3IFUtLc1JT4+rx58YKoat7CF3dQ+jqHvGqC3qmTZYlUlIcHe7vlqf+/fffs2jRIu666y7mz5/PnXfeyYYNGzCbzXg8Hqqrq5k9ezZPPvlkt0QKBAKBoHfoslEvKyvjggsu4IknnmDmzJmH7P/mm29E+EUgEAj6mS6HX5YtW4bf7+ehhx7SX7v00ku57LLLYiJMIBAIBN2nRxOlAoFAIIhPxIpSgUAgGEAIoy4QCAQDCGHUBQKBYAAhjLpAIBAMIIRRFwgEggGEMOoCgUAwgBBGfYAhMlQFsUSMr/hHGPUjQFXV/pZwCA0NDYD48Q0ExPgS9IS4Nur79+/n+++/B+JnEBUWFvL//t//A+JHE8DatWuZO3cuv/vd74BwT814YM2aNfz3v//F5Yq/gkpifHWdeB1fEL9jrL/GV1z3KH366adJSUlh9OjROJ3O/pYDwM6dO1m2bBkXXnghw4cPR1EUDIb+6125b98+/vCHP1BeXo7dbueUU04Bwl6eLPffPTsQCHDPPfewZ88eRo4cyYoVK7jgggs4+eST+11bBDG+Dk+8ji+I/zHWX+Or/39Z7aBpGoWFhXzzzTeUlZXx6aef9rcknYaGBnJzc/nVr34F0K8/OK/XywMPPMDw4cN57bXXuOiii9i3bx9Avw9or9eLLMu8+eabLFmyhJNPPpnFixfHhTYxvrpGPI8viN8x1t/jq///Ms2sXLmSwsJCQqEQkiRRWlrKxRdfzIwZM9i6dStFRUVA3z7GRDQpigKAoiiUlZWxbNkyamtr9XZ+/aFr+/bt2Gw2li1bxo033giEvbyCggKgf+KxhYWFVFZWAuFHzy1btmAymdA0jQsuuICMjAweffTRftEnxlf3dMXj+IL4HWPxNL763ahXVFRwySWX8OKLL/Lss8/y1FNPUV9fz+DBg7nmmmuYMWMGgUCAL7/8EuibWF5bTU8++SQVFRUYDAbq6upITExkyZIl3H777dxwww3U1tb2qa5ly5bxxz/+kccee4zq6mp9f3Z2NmvWrAH63lMpLS3l3nvvZf369QBMnjwZo9HIyy+/rF+bBx54gOXLl9PY2Nhn+sT46r6ueBxfEJ9jLB7HV78b9b179zJ9+nT+8pe/cPPNN+Pz+ViyZAkjRowgISGB0aNHM2rUKPbs2cOmTZuA2N/t2moKBAI8/vjj+mfX19fz+eefYzabCQaDpKamEgwGY6opWtcrr7yi63rkkUf0/WPHjiU5OZn6+vqYa2nLl19+yY4dO/j+++8pLCwE4NZbb+XNN9/E5/MBMHLkSE444QR98qgvEOOr+7ricXxBfI6xeBxf/W7UN23axK5duwAoKCjg6quvZuvWrXz99df6Maeeeipms5mPP/6YQCAQ87tdW00//elP2bx5M2vXrsXr9XLVVVeRlZXFG2+8wVdffUVNTQ0mkymmmjrStW3bNv1aGY1GKioqMBr7fv67qamJX/7yl/h8PrZs2YLf7+fUU09l1KhRepwzGAzi8XgYO3Zsn+kS4+vIdMXL+IL4HGPxOL763KhH4oeRu9WCBQuorKxky5YtGI1GcnNz+fGPf8wbb7yhv2fQoEGMHz+ewYMH95umyy+/nOeee46LL76Y5cuX87Of/Yzhw4dzzz33YDAYYnL37eq1ev3114Hw4Nm8eTP//Oc/e11Le7qiGTJkCFdccQXjx49nw4YNbN++HYAlS5ZQWVnJ4sWLufjii8nIyCA5OTkm1yuS0qZpWtyMr65q6uvx1Z1r1dfjK1pbNPEwxiLEy/hqjz4x6pWVldx7771Ay2x+5G6VnJzM6aefrrfB0zSNCRMmYLVaqaio0C/e/PnzueSSSzCbzf2iacyYMaSlpTF+/HhSUlL0x+HLL7+c5OTkXrv79uRa2Ww2SkpKAHjwwQcZP358r2g5nC5oMfBnnHEGEP47aZrG+vXrqampwel08vTTT3PZZZfx4IMP8rvf/Q6r1dqr3sqmTZu4+eab+eijj4Dw9erv8dVdTX01vnpyrfpifHWkDfp/jG3ZsoWXX35ZD/lEa+uv8dUZfWLUKyoqePvtt/n8888BCIVChEIhACwWC+eccw7V1dW8+eabSJKEoiioqkpWVpZ+8Xp70qO7mjRNIxQKkZqaChCzx+GeXqtBgwYBMHPmTCZNmtQnutrLoXY6nZxxxhls2bKFDRs2AJCUlMT48eN7XVcgEODXv/41Dz74IBdeeCEXXnhhq33Q9+Orp5piPb6O9FrFcnx1pi0YDPbrGPvTn/7Efffdx86dO3nuuefYvHkzQL/br87ok+BYZWUlw4YNY/HixaxatapVTO7ll1/GZDJx4403cs8997Bz505Wr17N5ZdfDoTvfLGIQcWjpqNV10svvYQkSVx11VUA/OAHP2D16tVYLJaYaIlQWFiI1+vlwQcfZN++fTzxxBNMmTKFmTNnYrVagb6/ZvGoKZ51dVVbf42xoqIifv/73zNq1Cg8Hg92ux1AH//9+ZvsiF7rURoRv2fPHsxmM/n5+fqqrmeffZZTTz2VJUuWMH36dG6++Waqq6u55pprGDFiBLfccgv5+fmUlpZSWFjIiBEjeiX+FI+aBqqu2267jUGDBuneeyAQ6NVHzWhtRqORgoICKisr+f3vf08oFMJqtTJ27FhWr15NRkYGDz30EOeddx4jR47sk/EVL5riWdeRaovlGGtv7JeVlXHFFVfwz3/+k40bN/Lcc88xadIkPW7eV9esJ1+m1wgEAtpll12mvfHGG1ogENBff+qpp7Q1a9ZodXV12pgxY7Srr75a2717t7Z9+3b9GFVVe1NKXGsSuo5cm9/v1zRN05YuXapdddVV+jFut1ubNm2atnHjRq2oqCjm2uJRUzzrimdt0bp8Pp+maZr2i1/8Qlu0aJF2//33a59++qn20Ucfaccff7y2du1arbS0tE90dZdeDfSsWbOGrVu3smHDBrZu3QqEJzkaGxsxmUy89957pKSkUFJSwvDhwxkzZgwQXvkVq0eUeNQkdB25tkhs89prr+Wmm24CwrFZu93O2WefzebNm8nPz4+5tnjUFM+64llbtK5t27YBcNlll7Fx40YGDx7MD37wA84880x+/OMfs2LFCnJycvpEV3c5IqP+7bffUlZWpm+XlpZy66234nQ6Wb9+PXV1dRgMBhoaGvjFL35BVVUVH3zwAQcOHGDdunUtInpxEiEeNQldva9t06ZN1NXVYbPZGDNmDJ988on+KF5XV8fkyZNjoi0eNcWzrnjW1pmuDRs24HK5mDFjBscff3yrkg319fXMmjUrZrqOlB5NlO7du5eFCxeSlZWFLMucffbZnHfeeeTn5zNjxgy++OIL/vWvfzF69GhOOukkfvjDH7Jo0SL9jvvII4+Qmpraq5MI8ahJ6IqttlGjRjFr1iwsFgtPPvkkn3zyCTt37iQ3N5fc3Nx+GV99qSmedcWztq7o+vDDD/Wxf//993PppZeyePFidu/erWfaxCvdmiiNTEz87W9/w+VycfXVV/Ppp5/y+eefM2jQIK6//nr92N///vfY7Xb+53/+h8zMTCD8GC/Lcq/+geJRk9DVN9qcTicXXngheXl5HDx4kPLyctxuN3PmzBnQmuJZVzxr664uh8PBRRddRF5eHrW1tdTU1FBVVcVJJ53Uq7p6my49N4RCIR577DEWL17MypUrWblypb4YYdasWZx11lmsWbNGXy4LcO6553Lw4EFWr16tJ+AbDIZeMwbxqEno6lttBw4c4LvvvkPTNPLz85k2bVqvGYJ41BTPuuJZW091FRUV6bpSU1MZOXJk3Bt06IJRr62tZdGiRXg8HubMmcPy5csZM2YMZWVlFBcXY7FYGDNmDFOnTuWDDz7Q3zdx4kQKCgpissQ5HjUJXQNHWzxqimdd8awtXnXFksPG1Gtra6mtreXZZ58Fwp1QNm7cyJgxY3j//ff5xS9+QXJyMtnZ2ezbtw+/34/RaMRgMHDjjTfGZOVlPGoSugaOtnjUFM+64llbvOqKJYf11BMSEpg3b55emH7QoEFkZGQwadIkdu7cycqVKzEYDJjNZgKBABaLRV/WG6sLEo+ahK6Boy0eNcWzrnjWFq+6YsrhEtlVVdXq6+v17auvvlp7++23tWAwqL3//vva6aefrj344IPa6aefrn344Yf6e2JJPGoSugaOtnjUFM+64llbvOqKJd1aUVpUVKTNnj1ba2pq0jRN0/bv36+tXLlS+/DDD7WDBw/GRODRqEnoGjja4lFTPOuKZ23xqqu36Vae+sGDBzn99NOpqqri5ptvJikpiTvvvJOMjIxYPUgclZqEroGjLR41xbOueNYWr7p6m24Z9cLCQl5//XU2b97MJZdcwiWXXBIrXUe1JhC6ekI8aotHTRC/uiB+tcWrrt6mW4uP3n33XcrLy7nuuuv6pNh7V4hHTSB09YR41BaPmiB+dUH8aotXXb1Nt4y61g+1gQ9HPGoCoasnxKO2eNQE8asL4ldbvOrqbXqtnrpAIBAI+p/4Ki8mEAgEgiNCGHWBQCAYQAijLhAIBAOIPmk8LRDEA8XFxZx55pmMGjUKCHescTgcXHnllZxzzjmdvveZZ55hzJgxnHHGGX0hVSDoMcKoC44prFYr//jHP/TtkpISrrrqKgwGA2eddVaH7/vmm28YMWJEX0gUCI4IYdQFxzSDBg1i0aJFLFu2jFGjRnH//ffjdrupqqpizJgxPPnkk7zzzjts2bKFRx55BIPBwOzZs3n00UdZu3YtiqIwbtw4Fi9ejNPp7O+vIxCImLpAMGbMGHbu3Mnbb7/NggULePvtt/noo48oLi7m888/5/LLL2fChAncfvvtnHnmmTz//PMYDAb+/ve/s3z5cjIzM3n00Uf7+2sIBIDw1AUCJEnCarXyq1/9iq+++ooXXniB/fv3U1lZicfjOeT4zz//nKamJlavXg1AMBgkLS2tr2ULBO0ijLrgmGfz5s2MGjWK2267DUVROPvss5kzZw5lZWXtdr1RVZW77rqL2bNnA+B2u/H7/X0tWyBoFxF+ERzT7Nu3j2effZaf/exnrFq1iptuuknPhNm4cSOKogDh3qyhUAiAk08+mddff51AIICqqtxzzz08/vjj/fYdBIJohKcuOKbw+Xycf/75AMiyjMVi4bbbbmPOnDnceuut3HTTTdjtdpxOJ9OmTaOoqAiA0047jccff5xgMMjPf/5zHn74YS644AIURWHs2LHccccd/fm1BAIdUftFIBAIBhAi/CIQCAQDCGHUBQKBYAAhjLpAIBAMIIRRFwgEggGEMOoCgUAwgBBGXSAQCAYQwqgLBALBAEIYdYFAIBhA/H/V/Znp15L/awAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "goog.plot(alpha=0.5, style='-')\n",
    "goog.resample('BA').mean().plot(style=':')\n",
    "goog.asfreq('BA').plot(style='--');\n",
    "plt.legend(['input', 'resample', 'asfreq'],\n",
    "           loc='upper left');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意这两种取样方法的差异：在每个数据点上，resample 反映的是上一年的均值，而 asfreq 反映的是上一年最后一个工作日的收盘价。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意这两种取样方法的差异：在每个数据点上，resample 反映的是上一年的均值，而\n",
    "asfreq 反映的是上一年最后一个工作日的收盘价。\n",
    "在进行向前取样（up-sampling）时，resample() 与 asfreq() 的用法大体相同，不过重新取\n",
    "样有许多种配置方式。操作时，两种方法都默认将向前取样作为缺失值处理，也就是说在\n",
    "里面填充 NaN。与前面介绍过的 pd.fillna() 函数类似，asfreq() 有一个 method 参数可以\n",
    "设置填充缺失值的方式。下面将对工作日数据按天进行重新取样（即包含周末）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEgCAYAAAC5LnRsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABKTUlEQVR4nO3deUBU5frA8e8s7IsLgqigKIK44p7mgvuGZlqaaS51vdnNsmwx0/rZNUszl+7N6tbNVttMRcvC9bqEG0rmvpCKoCwisi8zzMz5/UFSCMg2wwzwfP4RZjjPeQaZ88w573mfV6UoioIQQog6S23tBIQQQliXFAIhhKjjpBAIIUQdJ4VACCHqOCkEQghRx0khEEKIOk4KgRBC1HFaaydwN6mp2ZhMlpnm4OHhSkpKlkViCyFEdfs1OpnIs0ksfKxXhbe16UJgMikWKwS34wshRE136Ewin4efp76bQ6W2l0tDQghRw23adwm9wVTp7aUQCCFEDZeSoavS9lIIhBCihvNwr9wlodukEAghRA03rn+rKm0vhUAIIWo4BzsNAM6OdpXaXgqBEELUcNuPxtGoniP/N717pbaXQiCEEDXYpfh0fr+WztAevqjVqkrFkEIghBA12I7IOJwctPTr1KTSMco1oWzNmjWEh4cDEBISwrx584iIiGD58uWYTCbatWvHkiVLsLe3L7JdWFgYK1euxMPDA4ABAwYwd+7cSicrhBDiTzfTcjl24QYjejbH0b7y84PL3PLgwYNEREQQFhaGSqVi5syZ7Ny5kyVLlvDJJ5/g7+/PnDlz2LJlCxMmTCiy7enTp5k/fz6jR4+udIJCCCFKtivqGmqVisHdfKoUp8xLQ56ensyfPx97e3vs7Ozw9/cnPj4eo9FIVlYWRqMRnU6Hg0Px+1hPnTpFWFgYY8aM4YUXXiA9Pb1KyQohhCiQk2dg/4l4erT1oqG7Y5VilVkIAgIC6Ny5MwAxMTGEh4cTEhLCa6+9xtSpU+nXrx+pqamMGDGi2Laenp48+eST/PDDDzRp0oTFixdXKVkhhBAF9p+IJ09vZHiP5lWOpVIUpVyd16Kjo5k1axZPP/00ffv2ZerUqXz00Uf4+PiwdOlSDAYDixYtKnX79PR0hg4dSmRkZJWTFkKIusxgNPH3N3fRxMOFN5/sU+V45RpdiIqKYs6cOSxYsIDQ0FDCw8MJDAykefOCSjRx4kSeffbZIttkZmayceNGZsyYAYCiKGg0mgoll5KSZbEOoZ6ebiQnZ1okthBCWNLhs4ncTMtl8pCAIscxtVqFh4drheOVeWkoISGB2bNns2LFCkJDQwEIDAzk5MmT3Lx5E4Ddu3fTsWPHIts5Ozvz8ccfc+LECQDWrVvH0KFDK5ygEEKIPymKwo7IOLwbOtPJ38MsMcs8I1i7di06nY5ly5YVPjZp0iSeeeYZpk2bhkajoUWLFoXX/xcuXMigQYMYPHgw77zzDq+99hp5eXn4+fmxfPlysyQtRG116Ewim/ZdIiVDh4e7A+ND/Ond3tvaaQkbcjEujZjETKYNb4NaVbkJZHcq9xiBNcilIVGX3F5c5K995e21aqaPDJJiIAq9u/Ek0dfSefvJewt7DN1W2UtDNr1CmRC1XWaOnquJmVxJzGTrwRjy71hcRG8wsWnfJSkEAoCkWzn8Fn2T0ff6FSsCVSGFQIhqcvugH5OY+ce/GeVaUKSqi46I2mPHsTg0GhWDujYza1wpBEJUQHmv4Wfl5hOTmFFwwE8oOPinZOQVPu/VwAn/ZvUY3M2dFt5utGjsyqJPIks86Des4qIjonbIys3nwMkEerX3pp6ref8mpBAIUU53XsNPydDxefh58vRGvOo7EZOYUfhp/2b6Xw769Z1o1dSdQd2a4dfYjRbebiX2jR8f4l9sjAAKVp8ymkxo1NIjsi7be/w6eoOJYT18zR5bCoEQ5VTSAuF6g4kvt18o/N6zviMtm7gzsEuzgk/63m64lHOxkNtnFn8942jZxI1jF27yfthpnhjbHjut+a4Li5oj32Bid9Q1OrRsiI9nxQeDyyKFQIhyutu1+hcmda7QQb80vdt7F7vUtDvqGl/tvMjq9Sd4+oFOODnI27auiTyXRHq2nr/1NP/ZAMh6BEKUW2nX6j3cHWjn17DKRaA0g7v58Pcx7bgYl87b3xwnM0dvkf0I26QoCtsjY2nm6UJ7v4YW2YcUAiHKqWOr4rM47bVqxof4W3zfvdt789T4jly/mc2yr37l1l8GnkXtdvZqKteSsxnWwxeVmSaQ3UkKgRDloM83cupyCo3cHQrPDDzcHap1slfngEY8NzGY1EwdS9f9StKtnGrZr7Cu7ZGxuLvY06ud5f7O5GKjEOWwK+oatzJ0vPhwF9q2aGC1PNo0b8BLk7uy8rvfWLouiuce6kzzxm5Wy0dY1vXkLE5fvsW4fi2x01ruc7ucEQhRhswcPT8diqGTv4dVi8BtLbzdePmRrmi1at76+jgX49KsnZKwkB1H47DXqhnQxbwTyO4khUCIMvx4MIY8vZEJAyw/FlBeTTxceHlKN9xd7Fn13W+cvJRi7ZSEmaVn6zl0Jol7OzbBzdm+7A2qQAqBEHdxIzWHPb9ep1+nJjSzwP3bVeFRz5GXp3TF28OZdzee5MjZJGunJMxoz6/XMBgtM4HsTlIIhLiLjfsuo9GoGNu3lbVTKZG7iz3zHu6Kf7N6fPTDGfYcv27tlIQZ6PON/O/X63Ru3Qjvhs4W358UAiFKcSk+naPnbzC8R3MauNluvx9nRy3PTQymo78HX26/wE+HYrDh7vKiHA6eSSQrN5/hFppAdicpBEKUQFEUvt9zCXdnO0bcU/XFwS3N3k7DU+M70qtdYzbuu8z3ey5JMaihTIrCzqNxtGjsRqBv/WrZp9w+KkQJfvv9Jhfj0pg6LLDGtHTQatTMHNMOZ0ct2yJjyc7LZ/qIINRqy0xCEpZx6lIKCSk5PD6mncUmkN2pZvyFC1GNjCYTG/ZewruhM/2Cm1o7nQpRq1RMGRqIi6MdPx6MIUdn4PEx7S16D7owrx1H42jg5kD3IK9q26f8dQhxh19OJJCQksODA/zRamreW0SlUjGufysmDWpN1IVk/rXhBHl6g7XTEuUQm5TJuaupDOnuU61/ezXvr1wIC8rTG9gccYXWPvXoEtDI2ulUybCezXlsVFvOXU1lxbe/kZWbb+2URBm2R8bhYK8hpJrPROXSkBB/se1ILBnZep4e37Hars9aUt9OTXB21PKfLaf5v0+OoFJUpGbdfXW1yirv6m2iZKmZOiLPJTGwa7MSFy6yJDkjEOIPaVk6tkfG0b2NJ/7N6lk7HbPpGujJsB6+pGXqSc0qWFPh9upqh84kmmUft1dvu71mg7nj1wW7o65hUhSGdq+eW0b/Ss4IhPjDlogrGIwmHrChVhLmUtKsY73BxCc/nWP7kVhQFYwtqADVX74u8jh/fP3HidLtr1XAxbh08o3FV2/btO+SnBWUQ57ewN7j1+kW6Ilnfadq378UAiGA+JvZ7D8Rz6CuPjRuYPmZnNWttNXVjCaFhu6OKIqCAigKKCgof3xT+NgfcxIUBUymPx5HKXhcoVgRKGu/oqgDpxLJ0RkY1tM6c1akEAgBbNh7CUd7DWP6+Fk7FYvwcHco8aDs4e7AnAc7VTn+i+8fKDW+uDuTSWHH0Vj8m7nT2kqXJGWMQNR5F2JT+e33m4zq1QJ3C3d5tJbxIf7Y3zGXwJyrq1k6fm12PPomyWl5DO9hvRnsckYg6jRFUVi/53cauDkwxAqDdNXl9nV6S93VY+n4tdn2o7E0qudI10BPq+UghUDUaUfP3+BKQiaPjWqLg53G2ulYVO/23hY9MFs6fm10KT6d36+l8/DgAKu2ApFLQ6LOyjcUtJLw8XTh3g5yABPVb0dkHE4OWvp2amLVPKQQiDprz/Hr3EzPY+LA1tKYTVS7m2m5HLtwg5DOTa3e2FAKgaiTcvLy+fHAFdr5NaB9y4bWTkfUQbuirqFWqRjSzcfaqUghEHXTT4eukpNnYMKA1rWilYSoWXLyDOw/EU+PIC8aujtaO53yFYI1a9YQGhpKaGgoy5cvByAiIoL77ruP0aNHM2/ePPR6fbHt4uPjmTJlCiNGjOAf//gH2dnZ5s1eiEpISc9j57Fr9GrvTQtvN2unI+qg/SfiydMbGVZNK5CVpcxCcPDgQSIiIggLC2Pz5s2cOXOGnTt3snDhQlavXs3WrVvJy8tjy5Ytxbb95z//yeTJk9m2bRsdOnTg/ffft8iLEKIiwn65DMD4/ra5DrGo3YwmE7ui4mjjWx8/b3drpwOUoxB4enoyf/587O3tsbOzw9/fn/j4eIxGI1lZWRiNRnQ6HQ4ORWcQ5ufnc/ToUYYPHw7A+PHj2bZtm2VehRDlFJuUyaHTiQzt7oNHPeufkou659j5ZG5l6BhupXYSJSlzqDogIKDw65iYGMLDw/nmm29o1qwZU6dOxdXVFR8fH0aMGFFku9TUVFxdXdFqC3bh6elJUlLxxld34+HhWqGfryhPT7ksUNf8e9MpXJ3tmDamA65O1dvqV9Rte6Pi+OLncySn5aJRq9Daa23mGFTue5aio6OZNWsW8+bNw8XFhRUrVrB161Z8fHxYunQpS5cuZdGiRYU/ryhKsUG4ig7KpaRkYTJZZgFuT083kpMzLRJb2KbTl1P47WIykwYHkJuVR25WnrVTEnXE7TbdekNBcz6jSWHN97+RmZVn1kl4arWqUh+gyzVYHBUVxYwZM3j++ecZN24cx44dIzAwkObNm6NWq5k4cSKRkZFFtmnYsCGZmZkYjUYAkpOT8fKqvjU4hfgrk0lh/Z5LNKrnyMAuzaydjqhjNu27VFgEbrvdptsWlFkIEhISmD17NitWrCA0NBSAwMBATp48yc2bNwHYvXs3HTt2LLKdnZ0d3bt35+effwZg8+bN9O/f39z5C1EuB08nci05iwcH+MtC7qLaldaO21badJd5aWjt2rXodDqWLVtW+NikSZN45plnmDZtGhqNhhYtWrB48WIAFi5cyKBBgxg8eDCLFi1i/vz5fPDBBzRp0oRVq1ZVKLmlX0bRv3NT6V8iqkSfbyTsl8u0bOJGjyA5KxXV725twG2BSrm94oQN+tuSHaRl6pg+MsjsxUDGCOqOnw7FsHHfZV6a3IU2zRtYOx1RB905RgAFbbrNfWyz6BiBNdnSdTRR82Tk6Pnp0FU6t24kRUBYTe/23kwfGVR4BuDh7mCRD7iVVSPaUNvKdTRR82w9EIMu38iDtXAdYlGz2HKbbps/IwDbuY4mapak1Bz2HL9O/+CmNG3kYu10hLBZNl8IZLk7UVkb911Gq1Eztm9La6cihE2z6UtDDVwdGNu3pc2eTgnbdel6OsfO3+C+Pn7Ud5UzSiHuxqYLwctTu1lsZrGonQ6dSSxcN1elgoZyWVGIMtl0IRCiIu68RU9R4Oud0dhpNXJWKcRd2PwYgRDlZevT+IWwVVIIRK1h69P4hbBVUghErVHabcZy+7EQdyeFQNQa40P8sb+joZzcfixE2WSwWNQatweEb9815OHuwPgQfxkoFqIMNt10ThamEUKI8qu1TeeEEEJYllwaMrO/TmiSSxNCiJpACoEZ3TmhKSVDx+fh5wGkGAghbJZcGjIjmdAkhKiJpBCYkUxoEkLURFIIzKi0iUtqFZy+klLN2QghRPlIITCjkiY02WnUuDnbseq7E3y54wI6vdFK2QkhRMlksNiMSpvQ1C3Qk037L7PzaBxnrtxi5uh2tG5Wz8rZCiFEAZlQVo3OX01l7U9nuZWpY1SvFozt2xKtRk7KhBDmUdkJZVIIqlmuzsA3u6KJOJVAcy9XZo5uh49Xxf/jhBDiTlIIKsjaLSaORyfzefh5cnQGxvVvxfAezVGrVVbLRwhR80khqCBrFwKAjBw9X2y7wK8XkwnwqcffRrfDq76TVXMSQtRcUggqyBYKAYCiKBw6k8hXOy9iMsGkwa3pH9wUlUrODoQQFSOFoIJspRDcdisjj7U/nePc1VQ6+XswY2QQ9V1lQRUhRPlJIaggWysEACZF4X9R19iw9xJ2WjXTRgTRI8jL2mkJIWoIKQQVZIuF4LaElGw+3nqOKwkZ9GrXmCnDAnFxtLN2WkIIGyeFoIJsuRAAGE0mfj50lR8OxODmbMdjoW3p0NLD2mkJIWyYFIIKsvVCcNvVxEz+u/Us8TezGdilGX7ebvxw4IqsdyCEKMaihWDNmjWEh4cDEBISwj333MOqVasKn09KSiI4OJgPP/ywyHZhYWGsXLkSD4+CT7IDBgxg7ty55U5OCkGBfIORTfsvsz0yrthz9lo100cGSTEQQlS6EJTZa+jgwYNEREQQFhaGSqVi5syZdOnShS1btgCQnJzMww8/zMsvv1xs29OnTzN//nxGjx5d4cTEn+y0Gh4aFMCh04lk5OQXee72egdSCIQQlVVmoxtPT0/mz5+Pvb09dnZ2+Pv7Ex8fX/j88uXLmTRpEn5+fsW2PXXqFGFhYYwZM4YXXniB9PR0syZf19xZBG6T9Q6EEFVRZiEICAigc+fOAMTExBAeHk5ISEjh95GRkUybNq3EbT09PXnyySf54YcfaNKkCYsXLzZf5nVQaesdlPa4EEKUR7kHi6Ojo5k1axZPP/0048aNA+Ctt96ifv36zJo1q8zt09PTGTp0KJGRkVXLuA7bGxXHmu9PoMv/c00DBzsNT00IZkA3XytmJoSoycq1HkFUVBRz5sxhwYIFhIaGFj6+e/du1q5dW+I2mZmZbNy4kRkzZgAFrRQ0Gk2FkktNzbbYYLGHhyspKVkWiW0pHf0aMOv+9mw/HEtqlo4Grg4M79Wcjn4NatxrEUKYn1qtokEDlwpvV2YhSEhIYPbs2axevZrevXsXPn7r1i3y8vLw9S35k6izszMff/wxXbp0ITg4mHXr1jF06NAKJVeZF1QRlRldt7ahHq4M7dXS2mkIIWqRMgvB2rVr0el0LFu2rPCxSZMm0b59e7y9i9+psnDhQgYNGsTgwYN55513eO2118jLy8PPz4/ly5ebN3shhBBVZtMTyoQQQlierJMohBB1nBQCIYSo46QQCCFEHSeFQAgh6jgpBEIIUcdJIRBCiDpOCoEQQtRxUgiEEKKOk0IghBB1nBQCIYSo46QQCCFEHSeFQAgh6jgpBEIIUcdJIRBCiDpOCoEQQtRxUgiEEKKOk0IghBB1nBQCIYSo48pcs9iaUlOzMZkss5Kmh4crKSlZFokthBDWoFaraNDApcLb2XQhMJkUixWC2/GFEKI2OLsnHI+kIzR4emWFt5VLQ0IIUcOd3RNO44sbcFdlV2p7KQRCCFHDuV38CXuVsdLbSyEQQogarh5VG++06TGCkhiNBlJTkzEY9FWKc+OGGpPJZKasahe1WoOTkyuurvVQqVTWTkcIUYZ0XKlfhWJQ4wpBamoyjo7OuLh4V+kgpdWqMRikENxJURSMRgOZmWmkpibTsKGXtVMSQpQhrflA6sX+WOnta9ylIYNBj4uLu3xStRCVSoVWa0f9+h7o9XnWTkcIUQ6m3HRUKshSnCq1fY0rBIAUgWqgUqkBub1WCFuny83FKzmSWLuWNJ78eqVi1MhCIIQQokD0L9txVeXh1HlUpWPUiUJw6EwiL75/gMeW/Y8X3z/AoTOJZov966/HeOqpx6sU4+eff+SNN14r8+fWrv2Q8eND+fbbdcyYMbnwsbVrPwSgb9/uVcpDCFGzmBSFyBgdZ1WB+AV3q3Sccg0Wr1mzhvDwcABCQkKYN28eERERLF++HJPJRLt27ViyZAn29vZFtgsLC2PlypV4eHgAMGDAAObOnVvpZCvj0JlEPg8/j/6PgeGUDB2fh59Ho1HRM6hxteZSVdu2/cw777xP8+YtmDTpEWunI4SwstOXU4i45UnbMSGo1ZX/XF9mITh48CARERGEhYWhUqmYOXMmO3fuZMmSJXzyySf4+/szZ84ctmzZwoQJE4omefo08+fPZ/To0ZVO8G4OnEog4mTCXX/mUnw6BmPRa916g4mPfzzLnqjrpW7Xt1MT+nRsUq480tPTeO65p7l58wbt2nXguede4scfw9i27Wfy8nKxs7PjtdfeoHlzP44ePcKaNe+gKCa8vZuwaNGSIrH+9a+V3LqVwv/93+toNJrCx99++02Sk5NYsOAFFi1awqOPTiEi4li58hNC1E6XDuyiiZsXPYKqdndfmSXE09OT+fPnY29vj52dHf7+/sTHx2M0GsnKysJoNKLT6XBwcCi27alTpwgLC2PMmDG88MILpKenVynZyrizCJT1eGUkJMQzd+6LfP75t+Tk5LB580b279/HmjUf8uWX67n33n5s3LgevV7P4sWv8sorr/HFF9/RqlVrwsO3FsZZu/ZDkpNv8Oqri4sUAYAXX1xAo0aevP32vwgIaGO23IUQNdP1i+cYkreNh3wT0GqqdpW/zDOCgICAwq9jYmIIDw/nm2++oVmzZkydOhVXV1d8fHwYMWJEsW09PT157LHH6Nq1K6tWrWLx4sWsXFn+hkgeHq7FHrtxQ41WW/CiQ7o0I6RLs7vGmPtuBCnpxW+D9KjnyMLpVb+mrtGo6dy5Ky1b+gEwYsQofvrpB15//U327NlJbGwshw8fJCAgkKtXL+Pp6UXbtm0BeOqpOQBs3foDhw8fJC0tlU8//RJHR/vSdodG8+fr12rVqNWqwq//+q85qNVqPD3dzBZPCGE+Z77+GQdFS49xE3FvWLX3abknlEVHRzNr1izmzZuHi4sLK1asYOvWrfj4+LB06VKWLl3KokWLimzz3nvvFX49c+ZMhg4dWqHkUlKyinUINZlMFZoINr5/qyJjBAD2WjUTBvqbZUKZ0WhCrdYUxjIYjGRkZDBz5nQeeGAiPXv2pn79hkRHX+D2Cdjtn83KyiInp6DVtrd3E2bNepLly5fxn/98wsWL51m2rOCyUVBQW+bPf7Vwf3/uy1T4+/nrY+ZiMplITs40WzwhhHmkJiXRNPMMsfW60shoV/g+VatVJX6ALku5Pj5GRUUxY8YMnn/+ecaNG8exY8cIDAykefPmqNVqJk6cSGRkZJFtMjMz+eyzzwq/VxSl2OWO6tC7vTfTRwbh4V5w6crD3YHpI4O4t0P5rv+Xx8mTv5GYmIjJZGLbtp/o1etefHx8eeihKbRt2479+/dgMhlp3rwFaWmpXLlyGYCvvvqczZs3AuDn15LRo+/HycmJTZvWExTUjs8++5rPPvu6sAgIIQRA7C8/oEahad/7zBKvzDOChIQEZs+ezerVq+nduzcAgYGBvPXWW9y8eZNGjRqxe/duOnbsWGQ7Z2dnPv74Y7p06UJwcDDr1q2r8BmBufRu703v9t4Wi9+yZSuWLl1MSspNunXrztixD3D06BEeeWQCiqLQuXNXLl++hIODA6++upglSxZhMOTTtKkPr766mL17dxfGev75+Tz55N/o338gXl41664mUXVn94TjdvEn6pFFOq5kBobSbuBIa6clbIhObyTrRjyxzgF09GlulpgqRVHuOmq6ZMkSNm7cSPPmf+5w0qRJODo68t///heNRkOLFi1YvHgxDRs2ZOHChQwaNIjBgwdz7Ngx3njjDfLy8vDz82P58uW4uZX/WlZJl4YSE6/i7d2igi+zOOk1VDZz/a5F+dzuKf/XdsJ6RUNS4INSDESh3VHX+GrnRRZMDqZ1c48iz1X20lCZhcCapBBYlxSC6hX34Wzql7CwSJriiu+sNVbISNgao8HIso//B84NWDit+M0ulS0ENa77qBC1QWZaKkm/nyPn+iXUqbHU0yVQj5JXl6pqr3lRe/x+ZB+zVV8TF/SkWeNKIRDCwjLT0rjx+zkyEmI5aGjH1cRM7jNuI9g+FoBbijtpjs2wz7uCM8XX2UjHFffqTlrYpnM7ycSFtl07mzWsFAIhKqCswdys3HyuJmWSfvFX3OMjcdcl0ECViRfgBWw2edKyiRe4DeNGfTsaBwTRwr1eYWztHWMEigK3mvXFt5pfp7A9sWdO0dSUwBWfkfhq7cwaWwqBEOV052BufbJwufg9p2J/AxTc8xL4MGMgicb63GN/iREuCaQ7NiGtQS9cmvnTuHUQ/6xXv9T47QaO5CwUFposnLBT9DS6vp/4S11p6h9YHS9T2Kj0Y1txUuxoHRJq9thSCIQop5IWCLdTmfDTXSBVcSPDoQlDuzfDq2UAzb364uZc+gzx0rQbOBL+OMNwBxIuRZOz8wO+3XqOyRMa49+0njleiqhhbt64SbO8aOIa9CTYteKDwWWpE22oLenNN//JhAlj2blzm9VyeOqpx/n11+IN6LKzs/jb36YydepEvv/+Wz7++D8APPjgGBIS4svd/loUKG3QVlGg+ax36TBjAQMH3kN7v4aVKgIlaeIfQP2HXifbwYsV3xznwplzZokrapZdp1J5M30cvgPGWyR+nTgj0EcfRH90I0pWCipXD+x7PIC2bV+zxA4P38r//ncQOzvzXrMzh+joi9jZ2bF27ZfWTqVWyMCZeuQUe9zSg7meDVyY/0hX/vfNOrwivuBC6hTa9B1swT0KW5KTl8/+E/EEB7WioZdl1hCv9YVAH30Q3S+fgaHgbgwlKwXdL5+h0ajRtOpVpdgvvTQXRVH4+9+nM2TIMLZv/xmVSkWbNm2ZO3cezs7OjB49hDZt2pGScpP8fD1vvPE2fn4tee21hbi6uvLCCy9z+vRJPv98LUuXrmTlymVcvnyJW7du0bp1a1577Q1u3brF888/Tb169XFwcGD58nd4663XOX/+HN7eTUlPTyuWW2rqLZYuXcytWym89NJcQkIGcfx4FAsXvlal11yXZWga4m7M4a8rpeoVDZmB5r9me6f6rg4Mm/gA17+PxvvMOs7kZtN+qHnaCwjb9vuuDcxwOIlnl+ctto8aXwhyflxa7DFtq57Ytx+MYtCh2/cJmAxFf8CgJ+/w9zg1bU/ezuITdezaDcLO/54y9/3WW6vp27c7r766mAULXuCjjz6jXr36rFz5Fp9++l9mz36GtLQ0pkyZRteu3fngg3eJiorEz68lly//XhjnyJFD3HtvP06fPolWa8eHH36KyWRizpwnOHToAG3atCU29irff/8uTZo05euvCz7hf/XVBuLiYpk+/eFiuTVo0JCXXnqFTz75iLfeWs3PP/9Y5usRpUuMuUxT43WuaXxwM6ZZpQWEa736tHj4/7j83Vs0v7KJk1uz6TS6+P+9qD0MhnwaXD9AtoM7LX0bWWw/Nb4QlOnOInD74awUs+3it9+i6NOnH/X+uCPkvvvGsXTpPwufb9++AwC9e/fhu+++pmvXHrRs2YqrV6+SmnqLw4cP8Prry/H29sbdvR4bN64nNjaGa9fiyM3NBQoO7E2aNC3c3333FVwr9PVtTseOncz2WkTJbu79Gm80NBv3LPU8Ct6Q1ri339HFmYBHFnL+mxU0v76DbTtbMXxIT1R/PU0RtUb0wT34qLLIaf+gRfdT4wuB85iXS31OpXVA5eqBUsJBX+3qgdrR7a7bl9edbTBAwWj88+4SBwdHADp06MQbb/yTY8ci6dKlGw0aeLBnz24MBgPe3t5EROzj448/ZMKESYwadR9paWnc7gBSdOEfFfDnPm93df344/8QEbEfgJkzZ+Hs7FLl1ybg94sxNNFd4Xrj/nTysNynsvKys7en3ZSX+GnrHjZHZZNsusiUYYGopRjUKiaTCe2FXaQo9Wh9Tz+L7qvW3zVk3+MB0N5xB4fWHsdeE0reoBK6dOlGRMR+MjIKVmD74YfNdOlSvA+IVqulXbt2bNjwLV26dKdbt+588cUn9OrVB4BjxyIZNGgIoaH34erqyvHjUZhMxmJxunfvyY4d2zCZTCQmJnDq1EkAZs58orB1dd++IWZ7fXWZoih8d/gm7+ZPIHCo+f5mqkqj1TBm7GBG9mrOzdOHOP3l2+TnF5+VLGquq6d+w1u5QVaL/mjUlm3hX+PPCMpiH3AvQLG7hhwC7zVb07nWrQOYOvVRnnrqcQwGA23atOXFF0s+0+jduy+//fYrLVr40bChB6mpt+jTp6Dajxkzjn/+cyG7dm1Hq7WjY8dOxMfH061b0Rjjx0/gypVLTJnyIN7eTWjVyt8sr0MU99upK1yKT2fGyE44ujhbO50iVCoVEwa05kRmJC0TzhL95VJaPfwijk62laeonB0XDdTX92BsiOXHoKT7qChVXe8+mq/XE//pC1xV+dJ35guFy4LaotM7NuN7ZTOJmib4TJyPi7tMPKvJklJzWPDhYULvbcH4/uX/oGfRFcqEqIvO7/6BhqoMmgT3sukiANBh2P3Et52MlzGJxG9fJz0tw9opiSq4tGsj3RxjGNTVp1r2J4VAiBJkZ2TgGbuL6xof/Hv0sXY65dK2/zBSuv6NMzpvln13mpvpudZOSVRCZloabW7to2+jW9R3dSh7AzOQQiBECX7f8R0uqjxc+kxCra45b5PWPfrQbtzfycwx8PG63SRevmTtlEQFXdn3I/YqAx73jKm2fdacv/C/sOFhjVpDUUwU3KZa99xKy6bezRPEOLbFN6iDtdOpsNY+9Xhpchfu1+yFncuJO3fayhmJ8srX6/FIPMQ1TXOaBbSptv3WuEKg1dqTnZ0hxcBCFEXBYMgnLe0m9vaO1k7HKjYfiGVl5n00GTbD2qlUmm9jNxqGPoUee5z2v8Pl40etnZIoh4sRO3FX5WDXcXi17rfG3T7aoIEnqanJZGWlVSmOWq3GZJK7hkqiVmtwcnLF1bXu3XlyLS6BQ6euM6RnSxp5N7Z2OlXi5etH6v0LSdvyFvUjP+BCbjZt7h1g7bREKRRFIepyFrm0omv33tW67xp3+6i5eHq6kZycaZHYouY6+8kiTLpcWkxfYrZW0taWmZZK4vfLMObn4aw2UF+VbZE+SWWt3lZVJXURvj1PqCbEL8vZmFus+PY3ZowMon9w00rFkMXrhaii36MO42u4yhWf4bWmCAC41W9ATIt7aXrlh2Krq51IS6JhUHcUrQOKmzcqFaizbqA2GUCtQoUKlUoNdvYozg1Rq1SoclJQKSZQFTyPWsX1347gE/dzkfjOFzdw3pBLYJ9BqDR2qBwKWp6YctKK5ajS2qOyd0ZRFJTc9GLPG66eQHfoq6JdhPd/iqLPwa5l94J2MvZOKCYTSl7xW2dVdk6o7BxQTAaUvOLrShjiTqI7sK5Yl2Kg2orBhQN7aORcn97tq/9MVM4IhACMJiNXPn4Je0WH94y3sXeoXeMjcR8+RX1VyQvrAMQYGrE6YxQAL7n/QFNtWpHnL+R7837mMAD+r94mPDRFY+kVTbHV2/5KG3AvTgMfByBz7d/BmF/kebt2g3DsOw3FZCTr478VD2DnCPl5pca37z4eh673YcpKIfvr4u2aHXpPxr7jMIy3rpOzYWHxAA4uoMsu9rDK1QPXyStL3a+5JF6+hMuu17nsOZDgcdMrHUfOCISoggv7duDLTa61mVTrigDcfXW1xE6PotU68lS9VigKmFIduJ6f+8fzBeNoDlpXHq/XCgXIumkix6gDRaHgY6SC76WNpcZ37Dcddb0/P+U69HkE7hifUzdsVvCFSoVD3+IHQl3E56W+Noe+09F4tSzY3N65xO013q0L9uNcr0LxS2pYaQk3Dv2Aj6KhZcjoatnfnaQQiDov32Ak98IhEjWeBPYfau10LCIdV+qXUAzScSWw950NCj3LiOZd7JG4S9tLjJ9qcmHLWQ8mD2nJ7b6t9kGlN0RUqdTYtxtY7HH9b1tLPCirXD2K/LzK3qnE7Qufd3StUHyAvEPf4Njbcus+ZKSk4JN1imtunejU0MNi+7mbGnf7qBDmtivqGu+n9ccUMtviXR6tJTMwFL1S9LWZc3W10uKfaxDCuaupvPLxEbYejCG/kv29SusibN/jgcqmXHZ8jT1qn46onApWnlAUxSK3rV/Z/wN2KhNevatvAtmd5IxA1GmZ6ensOniRjv5etAn0s3Y6FtNu4EjOgsXu6ikt/oiBI+mZkcc3u6PZtP8yB08n8siwQNr5NaxQ/NK6CJtrILc88Q0xUeSf2oFD32loGpqnB5A+30hO4lViHVvSvqX1ugjLYLGo00589z6eqScx3fc6Pk3LuiQiquLU5RS+2nGRG2m53NOuMQ8Nal1tvXTMIf9SJLqILwruVOo4DIdu96Oyq9p40v4T8XwWfp4XJ7anbauq3y0k3UeFqKDka7E0TzvGTddAKQLVoGMrD16f2ZP7+vgRdSGZBR8dZuexOIw1ZGKnnX9PXB5ahl2bfuSf3Eb2+pcxXP2t0vGMJhO/HDlP88auBLX0Ml+ilSCFQNRZibu/xoQK36FTrJ1KnWGn1XB/v1a8/reetG5Wj292RfP6Z8e4dL343AFbpHJ0xbH/oziPfQWVoxtKfuU7vF4+epAnlXXc30ax+prTUghEnRR37hR+uvNca3QvDRrX7FYSNVHjhs7MnRjMk/d3IDM3nze+jOKz8PNk5eaXvbEN0DRujfO4RWj9ewGgP70T3bEwFEP5lws1nN5ODo60797FUmmWW7kGi9esWUN4eDgAISEhzJs3j4iICJYvX47JZKJdu3YsWbIEe/uio+7x8fG8+OKLpKSk0LJlS1asWIGLiyyoLqxLURSiD/9CW8WRgOEPWTudOkulUtE9yIv2LRvyw4Er7Dx6jV8vJjNhgD99OjVBbeVPyWVR/eUOM9OtOPLP7yf/90M49nkErW+nu257/eI5fIxxXGkyhGb21p/FXuYZwcGDB4mIiCAsLIzNmzdz5swZdu7cycKFC1m9ejVbt24lLy+PLVu2FNv2n//8J5MnT2bbtm106NCB999/3yIvQoiKOHEphXVJQUR3fhZn14oPrAnzcnLQ8tCgAF57tAfeHs58Gn6eZet+Je5G6TOhbY1j/8dwCp2HSqUmN3wVuTvXYMq6VerPpxz5Cb2ipZWVJpDdqcxC4Onpyfz587G3t8fOzg5/f3/i4+MxGo1kZWVhNBrR6XQ4OBQd/c/Pz+fo0aMMH17QTnX8+PFs27bNMq9CiHIyGPLZ8b9fadzQmXu7B1o7HfEXPl6uzJ/SlcdGtSXxVg7//PQo3+6OJldnsHZq5aJt1g7nB1/HvscDGOJOYiplglpqSho+Oee4Vi8Y13r1qzfJUpR5aSggIKDw65iYGMLDw/nmm29o1qwZU6dOxdXVFR8fH0aMGFFku9TUVFxdXdFqC3bh6elJUlKSmdMXomLO/28rf1d+5Fr3Z9BqZIjM1qhVKvp2akLngEZs2neJnUfjiDyXxKTBARiMJsL2XyYlQ4eHuwPjQ/zp3b74LOfKOnQmkU37LlUpvkpjh0OXMdi3HYjKseBsU38iHLVXKy6ev/znPAuTE4q77YxNlXtCWXR0NLNmzWLevHm4uLiwYsUKtm7dio+PD0uXLmXp0qUsWrSo8OcVpfhIeEVHxitzP2xFeHq6WTS+sC3ZmVk0vLKDZK03A4bdW6OWoKxrPIHnpzZkTEgq7288wX+2nEGlgtuznlIydHyx7QLubo4M6OZb5f3tjYrji20X0OUbzRS/4Nhiytdx7cIedEe+o6miQqMqeAH1Nbk4x23nyuGG9Bwzrsr5V1W5CkFUVBRz5sxhwYIFhIaGEh4eTmBgIM2bNwdg4sSJPPvss0W2adiwIZmZmRiNRjQaDcnJyXh5VexeWZlQJszpZNhntFTlkn/PLFJSineaFLangZOWlyd3Zc6/fyEnr+glIl2+kfc2nODc5ao3hvvfr9cKi4C542saPUqf1FU4qYreEWWvMqI9sZnkXkOqFP+vLNZ9NCEhgdmzZ7N69Wp69y5YNScwMJC33nqLmzdv0qhRI3bv3k3Hjh2LbGdnZ0f37t35+eefGTNmDJs3b6Z///4VTlAIc0i/mUzTGxFcdQigQ4fO1k5HVIBarSpWBG7L0xvZcTS2yvswGEv+wGmu+IPdS74ttrSusNWtzEKwdu1adDody5YtK3xs0qRJPPPMM0ybNg2NRkOLFi1YvHgxAAsXLmTQoEEMHjyYRYsWMX/+fD744AOaNGnCqlWrLPdKhLiLY/sP0BkFr4Eyeawm8nB3ICVDV+Ljbz/Zp8rxX3z/gEXjx324sdTur+5Vjl51Nt1r6PS7z5PS+B4LLXd3C5Vrw2pfjk5Uv4SUbF79OJJhnRoycWSwtdMRlXDoTCKfh59H/5fupfZaNdNHBpllwNjS8c/uCafxxQ1FFu/RKxqSAh806/GtVi5M467KRntxA2fBLL8sffTBguXnrLgcnah+u3Ydwd5Ow4iQttZORVTS7YNxVe/qsVZ8S3d/rSqbPiOIXfMEhvRkTAqoHZzReAfgPGIuANmbXsOUcaPIz2t9OuA05MmC59e/jCnnjv4lJiMYip/+VddydKL6XTkRRaMj73LW90HuGWkbk3eEsJRaeUZwmwqwC+yD2v3Pu460fl1R8ore9aNu0OzP51t2R7ljjdP80ztLjF9dy9GJ6mUymTBEridDcSF4wCBrpyOEzaoRhSDV5MJNj2F0a/Nnq2CHrvfddRuHElYuMsT8WvJBX6XGcO0MWp/2Vc5V2I6LB/5HMyWJWP8HaObkbO10hLBZNj+jRq9o2KP05L2wU7y36RRpWcUv7ZRXycvRacHRlbxfPkMx1oyp7KJs+Xo9Tmd/IJmGBA0YZe10hLBpNn1GkKG4kBI4iEf6D8czMpYtETGc/e8RHhrUmn6dmlR4pnLR5ej+vGvIrmV3TFk3UWm0KAY9hmun0bboYvUe4aLyIg8fx1/JI6vLdDTa2rkOsRDmYtODxXfOLE68lcPn4ee5EJdGUPP6TB8ZROMGlTvlL21msf70TnQHv0LbogsOfaaidq3Y2qo1nTn6rVgz/tk94YV3ZqQpzmQGhtJ+kHkWaBfC1lV2sLhGFQIAk6Lwy4l41u+5hMFoYmzflgzv6Yumgn1jSisEislI/ukd6I6GgVqNwz0TsWs7AJXK5q+iVVlJ91LbadVMGhxAj6CqL6V39PwNvt0dTb6F4l+K2IHP5U0Wv1dbCFtVZwrBbamZOr7aeZFfLybTvLErj45sSwvv8jeRK6vXkCnjBnm/fI7x+hns2g/Bsc8jFc6/piltdmVNsajeRhpqivcQSlNc8Z21xgoZCVG9avXtoyVp4ObAU+M7EnXhBut2XOT1z48xvKcv9/VtiYNd1a8Jq929cBr1AoaLEag9WwKg6HNBa4dKXWN/bXd1tyIweUhAqc+V19e7oi0av0FUyY3kbKWfixC2qsYf0bq18SKoRQO+3/M74UdiibqQzPSRQbRt0aDKsVUqFXZt+hV+n/fL55hSr+HY/zE0Xq2qHN+WpGfrUatVJZ6Bebg7MKR71Vv9bo+MLbWfS1XjG1PiyIoqmHNyJ1vp5yKEraoVF75dHO2YMbItL07qDMDb3xzn05/PkZ1n3oWw7fzvQcnLImfL6+Qd+gYlv+ZeRvmrrNx8Vnx7HBUKWk3RQ6m9Vs34EH+z7Gd8iD/22qJ/cuaIr5gM5O74NyatE3ql6NmgXtGQGSiDxULcTY0dIyiNPt/IlogrbI+Mw83ZjilDA+lewkBkZdcjUPQ56I58T/65PajcGuE09Ck0jfwqHMdW5OQZePvb41xPzubZCZ1Iz9bXyLuGjEm/o3Jw5fzx4zbbz0UIS6tzg8VluZqYyafh54hNyqJroCdThgbSwO3PdZWrujCNIeECuiPrcRr2NGrn+pWOY015egOrvjvBlYQMnn6gI538G1k7pQoxZaVgvH62yOU7IeoyKQQlMJpM7IiMY3PEFbQaFRMGtsZeqyZs/2VuZehoWMVPpLeX41QUE3m73kfbqgfRsSm4XfzZ5j+R6vON/GvDSc7HpvKPsR1KPGuyZaacNHJ+XIqSm4HLQ2+hdpJRACGkENxFUmrBRLTzsWlF1j0F8/QcN+VmkLttNabkK5gUFWrVnzuwxfvYDUYTazad4tSlFGaObkfvDua79FMdTHmZ5P64DFPmTZxHvYDGu+p3HAlRG0ghKIOiKMz51y9kl7DknaOdhj4dm1RxByaGXFmFs1pf7Clbuo/daDLxn81niLqYzPQRbQjp3KzsjWyIossmZ+tyTGnxOI2Yi7ZZO2unJITNqHPzCCpKpVKVWAQA8vKNHD6bWOV9jHEqXgTAdu5jN5kU1m49R9TFZB4eHFDjigCAIe4UptTrOA2bI0VACDOpM4UALL/uadyH60tclzQbR1xNJtQVbINhToqi8MX28xw+m8QDIa0Y2qPq8wKswa51LzSNW6N2q1kD20LYsloxj6C8LHUf+22ZgaHF7mM3KGpcVXmc+fItMtNSzbKfilIUhW92RbP/RAKj7/UjtLefVfKoLMWYT+6u9zDEnweQIiCEmdWpQtC7vTfTRwbh4e6AioIzAXMtTg0F65ImBT5ImuKKohSMDcQHPMCVxoPxyYsm87sFXDy83yz7Ki9FUdi47zK7oq4xrIcv4/q1rNb9V5ViMpC3+z8YLh9FyUy2djpC1Ep1ZrD4TlWdR1BR1y+eQ7f3v3hyi1P1BtLl/ik4OVj+ytyPB64Q9ssVBnRpxtRhgTVqjQXFZCJvz0cYLh3G4d5HsO8wxNopCWHTKjtYXKfOCKypWWBbfKYv5VLDe9l61Y1Fn0RyMfaWRfe5PTKWsF+ucG8Hbx6paUVAMaH75TMMlw5j33OCFAEhLEgKQTWyd3Cg84OPM+PhQahUcH3Lu5xY/x/0eXlm39eeX6/x3f9+p3uQF4+OCkJdg4oAAIqCYtRj3/U+HDpLryAhLEkuDVlJbp6O6E0f0DLrN5JpgEPI32nWxjy3Qx44lcDan87RuXUjnhzXAa2m5tR7RVEgPw+VvROKYgJUNepMRghrkktDNYyTowOdJj9LYvBMHBQdLnvf5uTmLzAYqtYxNfJcEp/8fI72fg34x/3ta1QRAND/uoXssNcw5WWiUqmlCAhRDWrWUaIWCrinL+4PvUGcYyBeiRG8+9VBkm7lVCrWb9E3+e+PZwloVo+nxnfCroYt2q4/8TP6qM1oGgegcnCxdjpC1BlyaciGRB2/wGf7kjAYjPy9s47gQUPRqMt3MD9z5Rb/2nACXy83XpjUuVruSDIn/Zld6A6sQ9uqJ46DnkBlxcl3QtRU0mKiFujWpQ2tWvuxd8sWAi7/zMWrB2kc+g8aet+9D9KF2FTe3XiSJh4uzJ0YXOOKQP7lowVFoEUXHAc9LkVAiGomZwQ2yGQycXbnZprE/IwRNTcDxxEUMrzEFhWX4tNZ8e1vNHRz4KXJXXF3sbdCxlVjys1Af/xHHHpOQKWtefkLYSuk+2gF2XIhuO1GXAyp2z+kqSmBs05daffAE7g5/3mgjE3KZPnXx3F1suOlKV2LLLxTExiTfkfdyA+VpmadwQhhq6QQVFBNKAQARoORMz9/w0/RGpLsfRnve4OWSf+jHlmkmlzYaejG/dMeplE9J7PsTx99EP3RjShZKahcPbDv8QD2AfeaJfad8QE0vsE4j5xrtvhC1GUWLQRr1qwhPDwcgJCQEO655x5WrVpV+HxSUhLBwcF8+OGHRbYLCwtj5cqVeHh4ADBgwADmzi3/m14KwZ/ibmSxe8NG7tfsRXPHwjfJrUYTNHQcAKaMG0VX3gGwd0Lt5I6iKCgZN4oHd3BG7eiG/uIBdL98Bsa/3MKqscOh92Ts2w1EMRlRMm8W21zl6IrKwQXFaCg8wBd53skNlb0z+gu/oIv4onj8/o+atdgIUVdZbLD44MGDREREEBYWhkqlYubMmXTp0oUtW7YAkJyczMMPP8zLL79cbNvTp08zf/58Ro8eXeHERFG+Xq4M1hwtUgQA7FVGPC//BBQUguzvXwFj0XUR7NoOxLHfdEAh+7uXisW26zQSx14PoT+6sehBGsCYjy5yfUEhyEkvcXuHXg9j32k4powb5Hy/oPjz/R/FPigEfeSGEuPrj26UQiCEFZVZCDw9PZk/fz729gXXpv39/YmPjy98fvny5UyaNAk/P79i2546dYqYmBg+/PBD2rRpw6uvvkq9evXMl30dU9oCN3b8ueCOY8hjoJiKPK+u1/iPr1Q4Dny82PbqBk0BULJL6X2kzy3Y2sGl5O0b+RX861K/xOc1XgVtvpXc9BLDl3QWIYSoPmUWgoCAP9eDjYmJITw8nG+++abw+8jISN54440St/X09OSxxx6ja9eurFq1isWLF7Ny5cpyJ1eZU5yK8PR0s2h8c4vDtcSFb9Jxxf/2a/EcevcgXsNLfSrXvRGGjOKXfrTujf74XblB09K3BzdoVpX4QghrKPftGtHR0cyaNYt58+YVfvr/7rvvmDx5cuHZwp3ee++9wq9nzpzJ0KFlHKTuIGMERWUGhuJ8cQP2KmPhY3pFQ2ZgqFlei6bbeAy/fAaGv1xa0tqj6Ta+RsQXoq6z6ISyqKgo5syZw4IFCwgN/bMT5O7du1m7dm2J22RmZrJx40ZmzJgBFDQT02gq1vJArbZsnxlLxze3DoNHEe3sjOuVPbiRTSYuZLUcSIfeA8wS37FNHzQOjuSf2IaSk4rKuQF2wSOw8+tWI+ILUddV9phW5l1DCQkJjBs3jtWrV9O7d+/Cx2/dusX999/P/v0lr7hlNBoJCQnhvffeIzg4mDVr1nDjxg0WL15cqUSFEEJYRplnBGvXrkWn07Fs2bLCxyZNmkT79u3x9i6+xOPChQsZNGgQgwcP5p133uG1114jLy8PPz8/li9fbt7shRBCVJlNTygTQghhedLdSwgh6jgpBEIIUcdJIRBCiDpOCoEQQtRxUgiEEKKOk0JgBj/++COjRo1i2LBhfPXVV0DBrOvRo0czZswYXn75ZfR6fRlRKhb/66+/JjQ0lFGjRvHWW29RlZu/Sop/27p165g6dWqlY5cW/+WXX2bYsGGMHTuWsWPHsnPnTrPGP378OBMnTiQ0NJTnnnvOrL//ffv2FeY9duxYevXqxaxZs8yaf0REBPfddx+jR49m3rx5Zv/72bRpE6NGjWLMmDEsWbIEg8FQRpTSZWVlMXr0aK5duwYUNKocM2YMw4YNY/Xq1ZWOe7d9AMybN49NmzaZPbY537slxTfne9dsFFEliYmJysCBA5XU1FQlOztbGTNmjHLu3Dll6NChSmZmpmIymZR58+Ypn376qdniX7x4URk6dKiSnZ2tGAwG5aGHHlJ++eUXs8WPjo5WFEVRoqOjlX79+imPPPJIpWLfLf7o0aOVpKSkSse9W/xz584pffr0Uc6dO6coiqLMnTtX+eqrr8ya/203btxQBg8erFy5csWs8fv376/8/vvviqIoytNPP62sX7/ebPHPnTun9OvXr/D3v2jRIuWTTz6pVPzffvtNGT16tNK+fXslLi5Oyc3NVUJCQpTY2FglPz9feeyxx5S9e/dWKnZp+0hMTFRmzZqldOrUSdm4caNZY1++fNls792S4sfGxprtvWtONnNG8K9//YtRo0YRGhrKp59+Wvh4fn4+06dP58iRI5WOXdonXnPEPnjwIL169aJ+/fo4OzszfPhwdu3axaJFi3B1dUWlUhEYGFikY2tV42/fvp2ffvoJZ2dnMjIyyMrKwt3d3Wzxt23bhl6v5//+7/+YM2dOpeKWFT8+Pp4FCxYwZswY/v3vf2MymcoOVs74u3btonPnzgQFBQHwyiuvVLjPVVn533a37rtViW80GsnKysJoNKLT6XBwqNzqc3f7/Xh5eQEwcOBAdu3aVan469evZ9GiRYWxTp48SYsWLfD19UWr1TJmzJgivy9z7OPHH39k8ODBjBw5skpxS4ptb29vtvduSfF9fX3N9t69raSzJajY2bxNFILIyEgOHz7MDz/8wMaNG/nyyy+5fPkyly9fZurUqRw/frzSsZOSkli9ejVff/01mzdv5rvvvuP33383S2yAGzdu4OnpWfi9l5cXSUlJ9OnTByhoxfHVV18xePBgs8a3s7Nj/fr1DBkyBE9Pz8KDnrnir1y5kgceeABfX99Kxb1b/F9//ZVevXrx5ptvsn79eo4dO8aGDRvMFv/dd9/F2dmZuXPnMnbsWN59991Kv9lK+/3An913p02bVqnYd4v/2muvMXXqVPr160dqaiojRowwW/zIyEhOnDhBQkICRqORbdu2cfNm8a6w5fHGG2/QvXv3Ml9PVdy5j5kzZzJhwoQqxSwtdrNmzcz23i0pPmC29y7AiRMnePjhh4mJiSny+O+//85HH31U7jg2UQh69uzJF198gVarJSUlBaPRiLOzMxs2bGDmzJkEBwdXOnZpn7jMERsKFppXqf5s9KQoSuH3SUlJTJ8+nQceeIB77rnH7PEnTpzIkSNHaNSoEWvWrDFb/EOHDpGQkMADDzxQqZhlxffx8eG9997Dy8sLJycnpk6dyr59+8wWX6vVEhERwXPPPcemTZvIzc2t0JuirPi3vy+r+25V4q9YsYKtW7cSERFBcHAwS5cuNVt8Pz8/nn/+ef7xj38wZcoU2rRpg52dXaVfQ1n7++v3NYU53rt3Y473LhQ/4wAqdTZvE4UACqrkv//9b0JDQ+nduzeNGzdm3rx5DBkypEpxS/uEYo7YAN7e3iQnJxd+n5ycjJeXF5cuXWLSpEmMGzeO2bNnmz1+VFQUAFqtltDQUC5cuGC2+NeuXSM6OpqxY8fyyiuvcPr0aZ599lmz5r99+/bCx24fvM0V/x//+AfBwcH4+vqi0WgYOXIkJ0+eNGv+UNB9d9SoUZWKW1b8wMBAmjdvjlqtZuLEiURGRpo1fqdOndi8eTPffvstjRs3rvKZX1n7q0nM9d4tSUJCgtneu1DyGUdlzuZtphAAzJkzp/DT6Pr1680S09KfUO69914OHTrErVu3yM3NZceOHfTs2ZO//e1vPPPMMzz22GNmj3/PPffw4osvkpGRgaIobN++nW7dKtfKuaT469evJzw8nC1btrBkyRI6dOjAO++8Y9b833zzTdLT08nPz+e7776r9DX80n7/Z86cISEhAYA9e/bQvn17s8Xv378/t27dIi8vr8oH0NLyP3nyZOHlmt27d9OxY0ezxe/Xrx8zZswgKysLvV7PunXrqlzQbgsODubKlStcvXoVo9HI1q1b6d+/v1liV4esrCyzvXdLkpmZabb3bkkOHDhQqbP5yn0MM7NLly6h1+tp27YtTk5ODBs2rEpV8q+8vb05duxY4ffm/oTSuHFj5s6dy7Rp08jPz+fBBx/k7Nmz3Lx5k08//bRw4HvQoEE888wzZonfo0cPHn/8cSZNmoRGo6F79+48+uijZsu/U6dOlYpV0fwffvhhDAYDw4YNq/S61iXF79mzJ4sXL+aJJ55Ap9PRtm1bXnqp+FrLlY3fqVMnTp48WWL3XXPl/8wzzzBt2jQ0Gg0tWrSodPv2kuIHBwcze/ZsHnroIQwGQ+Gtkubg4ODAsmXLePrpp9HpdISEhFR6fMMaNmzYYLb3bkkCAwPN9t4tydatWwvP5nNycrh58ybPPvts2R/krHKv0h327t2rjB8/XtHpdIpOp1MeffRRZevWrYXPP/LII8rhw4crFfv27XMpKSlKTk6Oct999yknTpwwS2whhLAFAwcOVOLi4oo8dvjw4XLf+m0TZwQhISGcPHmS+++/H41Gw7Bhw4qshFYVlv7EK4QQNZ2sRyCEEHWcTQ0WCyGEqH5SCIQQoo6TQiCEEHVcrS8EmzZtYv78+dZOQwghbFatLwRCCCHuziZuH60OkZGRrF69mry8PDIyMnj55ZcZMmQI8+fPx9XVlTNnzpCUlMTs2bPN0mNHCCFqijpTCNatW8eSJUvw9/fn0KFDvPnmm4W9hhITE/n666+5ePEi06ZNk0IghKhT6kwhePvtt9mzZw/btm3jxIkTZGdnFz7Xp0+fwt7jaWlp1ktSCCGsoFaOERw7dqywB7qiKGg0GiZPnszJkyfp0KEDTzzxRJGfv73oR01slyuEEFVVKwvBxo0bC1dcunDhAr6+vsTExPDMM8/Qv39/du/ejdFotHKWQghhG2rlpaHHH3+cefPmsW7dOry9vXnnnXdITU0lNDQUrVZLr169yMvLIycnx9qpCiGE1UmvISGEqONq5aUhIYQQ5SeFQAgh6rhaVQjWrFlDaGgooaGhLF++HChYvH7MmDEMGzaM1atXF9tm3rx5bNq0qdjjZ8+epUOHDhbPWQghrK3WFIKDBw8SERFBWFgYmzdv5syZM2zdupUFCxbw/vvv8/PPP3P69Gn27dsHQFJSEk888USRRdRvy83N5fXXXyc/P7+6X4YQQlS7WlMIPD09mT9/Pvb29tjZ2eHv709MTAwtWrTA19cXrVbLmDFj2LZtGwA//vgjgwcPZuTIkcViLVu2jOnTp1f3SxBCCKuoNYUgICCAzp07AxATE0N4eDgqlQpPT8/Cn/Hy8iqcaDZz5kwmTJhQLM7u3bvJy8urUQtuCyFEVdS6eQTR0dHMmjWLefPmodFoiImJKXxOUZS7zh5OTk7mgw8+4LPPPrN8okIIYSNqzRkBQFRUFDNmzOD5559n3LhxeHt7k5ycXPh8cnIyXl5epW6/d+9e0tLSmDJlCmPHjgVg7NixZGVlWTx3IYSwllpzRpCQkMDs2bNZvXo1vXv3BiA4OJgrV65w9epVfHx82Lp16107i06YMKHI5aI2bdqwZcsWi+cuhBDWVGsKwdq1a9HpdCxbtqzwsUmTJrFs2TKefvppdDodISEhcu1fCCHuIC0mhBCijqtVYwRCCCEqTgqBEELUcVIIhBCijpNCIIQQdZwUAiGEqONqze2jQlTFtWvXGDp0KIGBgQCYTCZcXFyYNm0ao0aNuuu2a9asISgoiCFDhlRHqkKYnRQCIf7g6OhYZALh9evXmTFjBhqNhuHDh5e63ZEjR2jdunV1pCiERUghEKIUzZo1Y86cOaxdu5bAwEAWL15MdnY2ycnJBAUF8c4777BhwwZOnz7N8uXL0Wg0hISEsGLFCo4ePYrRaKRdu3a88soruLq6WvvlCFEqGSMQ4i6CgoK4ePEi69ev5/7772f9+vXs2LGDa9eusXfvXqZMmUKHDh2YN28eQ4cO5aOPPkKj0bBp0yZ++OEHvLy8WLFihbVfhhB3JWcEQtyFSqXC0dGRF198kQMHDvDf//6XmJgYbty4QU5OTrGf37t3L5mZmRw8eBCA/Px8PDw8qjttISpECoEQd3Hq1CkCAwN57rnnMBqNjBw5kgEDBpCQkEBJ3VlMJhMLFiwgJCQEgOzsbHQ6XXWnLUSFyKUhIUpx5coV3n//fR577DEiIiKYPXt24R1EJ06cwGg0AqDRaDAYDAD07duXr776Cr1ej8lk4tVXX2XVqlVWew1ClIecEQjxh7y8vMJ1KNRqNQ4ODjz33HMMGDCAuXPnMnv2bJydnXF1daVHjx7ExsYCMGjQIFatWkV+fj5PPvkkb731FuPGjcNoNNK2bVvmz59vzZclRJmk+6gQQtRxcmlICCHqOCkEQghRx0khEEKIOk4KgRBC1HFSCIQQoo6TQiCEEHWcFAIhhKjjpBAIIUQd9/9hO5xgK77sTAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, sharex=True)\n",
    "data = goog.iloc[:10]\n",
    "\n",
    "data.asfreq('D').plot(ax=ax[0], marker='o')\n",
    "\n",
    "data.asfreq('D', method='bfill').plot(ax=ax[1], style='-o')\n",
    "data.asfreq('D', method='ffill').plot(ax=ax[1], style='--o')\n",
    "ax[1].legend([\"back-fill\", \"forward-fill\"]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面那幅图是原始数据：非工作日的股价是缺失值，所以不会出现在图上。而下面那幅图通过向前填充与向后填充这两种方法填补了缺失值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 时间迁移\n",
    "\n",
    "另一种常用的时间序列操作是对数据按时间进行迁移，即shift()函数。\n",
    "\n",
    "下面我们将用 shift() 让数据迁移 100 天："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7fa9b177a910>"
      ]
     },
     "execution_count": 316,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, sharey=True)\n",
    "\n",
    "# apply a frequency to the data\n",
    "goog = goog.asfreq('D', method='pad')\n",
    "\n",
    "goog.plot(ax=ax[0])\n",
    "goog.shift(100).plot(ax=ax[1])\n",
    "\n",
    "# legends and annotations\n",
    "local_max = pd.to_datetime('2016-12-31')\n",
    "offset = pd.Timedelta(10, 'D')\n",
    "\n",
    "ax[0].legend(['input'], loc=2)\n",
    "ax[0].get_xticklabels()[2].set(weight='heavy', color='red')\n",
    "ax[0].axvline(local_max, alpha=0.3, color='red')\n",
    "\n",
    "ax[1].legend(['shift(100)'], loc=2)\n",
    "ax[1].get_xticklabels()[2].set(weight='heavy', color='red')\n",
    "ax[1].axvline(local_max + offset, alpha=0.3, color='red')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们会发现，shift(100) 将数据向前推进了 100 天，这样图形中的一段就消失了（最左侧就变成了缺失值）\n",
    "\n",
    "这类迁移方法的常见使用场景就是计算数据在不同时段的差异。例如，我们可以用迁移后的值来计算 Google 股票一年期的投资回报率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ROI = 100 * (goog.shift(-365) / goog - 1)\n",
    "ROI.plot()\n",
    "plt.ylabel('% Return on Investment');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  移动时间窗口\n",
    "\n",
    "Pandas 处理时间序列数据的第 3 种操作是移动统计值（rolling statistics）。这些指标可以通过 Series 和 DataFrame 的 rolling() 属性来实现，它会返回与 groupby 操作类似的结果。移动视图（rolling view）使得许多累计操作成为可能。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与 groupby 操作一样，aggregate() 和 apply() 方法都可以用来自定义移动计算。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 更多学习资料\n",
    "\n",
    "Wes McKinney（Pandas 创建者）所著的《利用 Python 进行数据分析》。虽然这本书已经有些年头了，但仍然是学习 Pandas 的好资源，尤其是这本书重点介绍了时间序列工具在商业与金融业务中的应用，作者用大量笔墨介绍了工作日历、时区和相关主题的具体内容。\n",
    "\n",
    "你当然可以用 IPython 的帮助功能来浏览和深入探索上面介绍过的函数与方法，这可能是学习各种 Python 工具的最佳途径。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 案例：美国西雅图自行车统计数据的可视化\n",
    "\n",
    "下面来介绍一个比较复杂的时间序列数据，统计自 2012 年以来每天经过美国西雅图弗莱蒙特桥上的自行车的数\n",
    "量，数据由安装在桥东西两侧人行道的传感器采集。\n",
    "\n",
    "可以用 Pandas 读取 CSV 文件获取一个 DataFrame。我们将 Date 作为时间索引，并希望这些日期可以被自动解析："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Fremont Bridge Total</th>\n",
       "      <th>Fremont Bridge East Sidewalk</th>\n",
       "      <th>Fremont Bridge West Sidewalk</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-11-01 00:00:00</th>\n",
       "      <td>12.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-11-01 01:00:00</th>\n",
       "      <td>7.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-11-01 02:00:00</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-11-01 03:00:00</th>\n",
       "      <td>6.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-11-01 04:00:00</th>\n",
       "      <td>6.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Fremont Bridge Total  Fremont Bridge East Sidewalk  \\\n",
       "Date                                                                      \n",
       "2019-11-01 00:00:00                  12.0                           7.0   \n",
       "2019-11-01 01:00:00                   7.0                           0.0   \n",
       "2019-11-01 02:00:00                   1.0                           0.0   \n",
       "2019-11-01 03:00:00                   6.0                           6.0   \n",
       "2019-11-01 04:00:00                   6.0                           5.0   \n",
       "\n",
       "                     Fremont Bridge West Sidewalk  \n",
       "Date                                               \n",
       "2019-11-01 00:00:00                           5.0  \n",
       "2019-11-01 01:00:00                           7.0  \n",
       "2019-11-01 02:00:00                           1.0  \n",
       "2019-11-01 03:00:00                           0.0  \n",
       "2019-11-01 04:00:00                           1.0  "
      ]
     },
     "execution_count": 320,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('https://data.seattle.gov/api/views/65db-xm6k/rows.csv?accessType=DOWNLOAD', index_col='Date', parse_dates=True)\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了方便后面的计算，缩短数据集的列名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data.columns = ['Total', 'East', 'West']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在来看看这三列的统计值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Total</th>\n",
       "      <th>East</th>\n",
       "      <th>West</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>151598.000000</td>\n",
       "      <td>151598.000000</td>\n",
       "      <td>151598.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>109.497098</td>\n",
       "      <td>49.585463</td>\n",
       "      <td>59.911635</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>139.334944</td>\n",
       "      <td>64.073157</td>\n",
       "      <td>86.540658</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>14.000000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>7.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>60.000000</td>\n",
       "      <td>27.000000</td>\n",
       "      <td>30.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>144.000000</td>\n",
       "      <td>67.000000</td>\n",
       "      <td>74.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1097.000000</td>\n",
       "      <td>698.000000</td>\n",
       "      <td>850.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Total           East           West\n",
       "count  151598.000000  151598.000000  151598.000000\n",
       "mean      109.497098      49.585463      59.911635\n",
       "std       139.334944      64.073157      86.540658\n",
       "min         0.000000       0.000000       0.000000\n",
       "25%        14.000000       6.000000       7.000000\n",
       "50%        60.000000      27.000000      30.000000\n",
       "75%       144.000000      67.000000      74.000000\n",
       "max      1097.000000     698.000000     850.000000"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dropna().describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  数据可视化\n",
    "\n",
    "通过可视化，我们可以对数据集有一些直观的认识。先画出原始数据画图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import seaborn; seaborn.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.plot()\n",
    "plt.ylabel('Hourly Bicycle Count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在图中显示的样本数据对我们来说实在太多了，因此可以通过重新取样将数据转换成更大的颗粒度，比如按周累计："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weekly = data.resample('W').sum()\n",
    "weekly.plot(style=[':', '--', '-'])\n",
    "plt.ylabel('Weekly bicycle count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这就显示出一些季节性的特征了。正如你所想，夏天骑自行车的人比冬天多，而且某个季节中每一周的自行车数量也在变化。\n",
    "\n",
    "另一种对数据进行累计的简便方法是用 pd.rolling_mean() 函数求移动平均值。下面将计算数据的 30 日移动均值，并让图形在窗口居中显示（center=True）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "daily = data.resample('D').sum()\n",
    "daily.rolling(30, center=True).sum().plot(style=[':', '--', '-'])\n",
    "plt.ylabel('mean hourly count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于窗口太小，现在的图形还不太平滑。我们可以用另一个移动均值的方法获得更平滑的图形，例如高斯分布时间窗口。下面的代码将设置窗口的宽度（选择 50 天）和窗口内高斯平滑的宽度（选择 10 天）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "daily.rolling(50, center=True,\n",
    "              win_type='gaussian').sum(std=10).plot(style=[':', '--', '-']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 深入挖掘数据\n",
    "\n",
    "虽然我们已经从上图的平滑数据图观察到了数据的总体趋势，但是它们还隐藏了一些有趣的特征。例如，我们可能希望观察单日内的小时均值流量，这可以通过 GroupBy 操作来解决："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "by_time = data.groupby(data.index.time).mean()\n",
    "hourly_ticks = 4 * 60 * 60 * np.arange(6)\n",
    "by_time.plot(xticks=hourly_ticks, style=[':', '--', '-']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "小时均值流量呈现出十分明显的双峰分布特征，早间峰值在上午 8 点，晚间峰值在下午 5 点。这充分反映了过桥上下班往返自行车流量的特征。进一步分析会发现，桥西的高峰在早上（因为人们每天会到西雅图的市中心上班），而桥东的高峰在下午（下班再从市中心离开）。\n",
    "\n",
    "我们可能还会对周内每天的变化产生兴趣，这时依然可以通过一个简单的 groupby 来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "by_weekday = data.groupby(data.index.dayofweek).mean()\n",
    "by_weekday.index = ['Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat', 'Sun']\n",
    "by_weekday.plot(style=[':', '--', '-']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "工作日与周末的自行车流量差十分显著，周一到周五通过的自行车差不多是周六、周日的两倍。\n",
    "\n",
    "看到这个特征之后，让我们用一个复合 groupby 来观察一周内工作日与双休日每小时的数据。用一个标签表示双休日和工作日的不同小时："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "weekend = np.where(data.index.weekday < 5, 'Weekday', 'Weekend')\n",
    "by_time = data.groupby([weekend, data.index.time]).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在用一些 Matplotlib 工具画出两张图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(1, 2, figsize=(14, 5))\n",
    "by_time.loc['Weekday'].plot(ax=ax[0], title='Weekdays',\n",
    "                           xticks=hourly_ticks, style=[':', '--', '-'])\n",
    "by_time.loc['Weekend'].plot(ax=ax[1], title='Weekends',\n",
    "                           xticks=hourly_ticks, style=[':', '--', '-']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果很有意思，我们会发现工作日的自行车流量呈双峰通勤模式（bimodal commute pattern），而到了周末就变成了单峰娱乐模式（unimodal recreational pattern）。假如继续挖掘数据应该还会发现更多有趣的信息，比如研究天气、温度、一年中的不同时间以及其他因素对人们通勤模式的影响。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 高性能 Pandas：eval() 与 query()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前面的章节已经介绍过，Python 数据科学生态环境的强大力量建立在 NumPy 与 Pandas 的基础之上，并通过直观的语法将基本操作转换成 C 语言：在 NumPy 里是向量化 / 广播运算，在 Pandas 里是分组型的运算。虽然这些抽象功能可以简洁高效地解决许多问题，但是它们经常需要创建临时中间对象，这样就会占用大量的计算时间与内存。\n",
    "\n",
    "Pandas 从 0.13 版开始（2014 年 1 月）就引入了实验性工具，让用户可以直接运行 C 语言速度的操作，不需要十分费力地配置中间数组。它们就是 eval() 和 query() 函数，都依赖于 [Numexpr](https://github.com/pydata/numexpr)程序包。我们将在下面的 Notebook 中演示其用法，并介绍一些使用时的注意事项。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## query() 与 eval() 的设计动机：复合代数式\n",
    "\n",
    "前面已经介绍过，NumPy 与 Pandas 都支持快速的向量化运算。例如，你可以对下面两个数组进行求和："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.71 ms ± 214 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "rng = np.random.RandomState(42)\n",
    "x = rng.rand(1000000)\n",
    "y = rng.rand(1000000)\n",
    "%timeit x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样做比普通的 Python 循环或列表综合要快很多："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "277 ms ± 33.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.fromiter((xi + yi for xi, yi in zip(x, y)), dtype=x.dtype, count=len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是这种运算在处理复合代数式（compound expression）问题时的效率比较低，例如下面的表达式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mask = (x > 0.5) & (y < 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于 NumPy 会计算每一个代数子式，因此这个计算过程等价于："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tmp1 = (x > 0.5)\n",
    "tmp2 = (y < 0.5)\n",
    "mask = tmp1 & tmp2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也就是说，每段中间过程都需要显式地分配内存。如果 x 数组和 y 数组非常大，这么运算就会占用大量的时间和内存消耗。Numexpr 程序库可以让你在不为中间过程分配全部内存的前提下，完成元素到元素的复合代数式运算。虽然 Numexpr 文档里提供了更详细的内容，但是简单点儿说，这个程序库其实就是用一个 NumPy 风格的字符串代数式进行运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numexpr\n",
    "mask_numexpr = numexpr.evaluate('(x > 0.5) & (y < 0.5)')\n",
    "np.allclose(mask, mask_numexpr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这么做的好处是，由于 Numexpr 在计算代数式时不需要为临时数组分配全部内存，因此计算比 NumPy 更高效，尤其适合处理大型数组。马上要介绍的 Pandas 的 eval() 和 query() 工具其实也是基于 Numexpr 实现的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用 pandas.eval() 实现高性能运算\n",
    "\n",
    "Pandas 的 eval() 函数用字符串代数式实现了 DataFrame 的高性能运算，例如下面的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "nrows, ncols = 100000, 100\n",
    "rng = np.random.RandomState(42)\n",
    "df1, df2, df3, df4 = (pd.DataFrame(rng.rand(nrows, ncols))\n",
    "                      for i in range(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要用普通的 Pandas 方法计算四个 DataFrame 的和，可以这么写："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47.9 ms ± 2.3 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit df1 + df2 + df3 + df4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以通过 pd.eval 和字符串代数式计算并得出相同的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.1 ms ± 908 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit pd.eval('df1 + df2 + df3 + df4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目前经过 Pandas 不断的版本迭代和优化，普通的 Pandas 计算方法在一些运算的效率已经与 eval() 方法差距不大，但eval() 方法仍然可以节省内存。可以看到，两种方式的计算结果是一样的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(df1 + df2 + df3 + df4,\n",
    "            pd.eval('df1 + df2 + df3 + df4'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pd.eval() 支持的运算\n",
    "\n",
    "从 Pandas v0.16 版开始，pd.eval() 就支持许多运算了。为了演示这些运算，创建一个整数类型的 DataFrame："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df1, df2, df3, df4, df5 = (pd.DataFrame(rng.randint(0, 1000, (100, 3)))\n",
    "                           for i in range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 算术运算符\n",
    "pd.eval() 支持所有的算术运算符，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 342,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = -df1 * df2 / (df3 + df4) - df5\n",
    "result2 = pd.eval('-df1 * df2 / (df3 + df4) - df5')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 比较运算符\n",
    "pd.eval() 支持所有的比较运算符，包括链式代数式（chained expression）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = (df1 < df2) & (df2 <= df3) & (df3 != df4)\n",
    "result2 = pd.eval('df1 < df2 <= df3 != df4')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 位运算符\n",
    "pd.eval() 支持 &（与）和 |（或）等位运算符："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 344,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = (df1 < 0.5) & (df2 < 0.5) | (df3 < df4)\n",
    "result2 = pd.eval('(df1 < 0.5) & (df2 < 0.5) | (df3 < df4)')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，你还可以在布尔类型的代数式中使用 and 和 or 等字面值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 345,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result3 = pd.eval('(df1 < 0.5) and (df2 < 0.5) or (df3 < df4)')\n",
    "np.allclose(result1, result3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对象属性与索引\n",
    "\n",
    "pd.eval() 可以通过 obj.attr 语法获取对象属性，通过 obj[index] 语法获取对象索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = df2.T[0] + df3.iloc[1]\n",
    "result2 = pd.eval('df2.T[0] + df3.iloc[1]')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 其他运算\n",
    "目前 pd.eval() 还不支持函数调用、条件语句、循环以及更复杂的运算。如果你想要进行这些运算，可以借助 Numexpr 来实现。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用 DataFrame.eval() 实现列间运算\n",
    "\n",
    "由于 pd.eval() 是 Pandas 的顶层函数，因此 DataFrame 有一个 eval() 方法可以做类似的运算。使用 eval() 方法的好处是可以借助列名称进行运算，示例如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.375506</td>\n",
       "      <td>0.406939</td>\n",
       "      <td>0.069938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.069087</td>\n",
       "      <td>0.235615</td>\n",
       "      <td>0.154374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.677945</td>\n",
       "      <td>0.433839</td>\n",
       "      <td>0.652324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.264038</td>\n",
       "      <td>0.808055</td>\n",
       "      <td>0.347197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.589161</td>\n",
       "      <td>0.252418</td>\n",
       "      <td>0.557789</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B         C\n",
       "0  0.375506  0.406939  0.069938\n",
       "1  0.069087  0.235615  0.154374\n",
       "2  0.677945  0.433839  0.652324\n",
       "3  0.264038  0.808055  0.347197\n",
       "4  0.589161  0.252418  0.557789"
      ]
     },
     "execution_count": 347,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(rng.rand(1000, 3), columns=['A', 'B', 'C'])\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果用前面介绍的 pd.eval()，就可以通过下面的代数式计算这三列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = (df['A'] + df['B']) / (df['C'] - 1)\n",
    "result2 = pd.eval(\"(df.A + df.B) / (df.C - 1)\")\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而 DataFrame.eval() 方法可以通过列名称实现简洁的代数式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 349,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result3 = df.eval('(A + B) / (C - 1)')\n",
    "np.allclose(result1, result3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意，这里用列名称作为变量来计算代数式，结果同样是正确的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用 DataFrame.eval() 新增列\n",
    "\n",
    "除了前面介绍的运算功能，DataFrame.eval() 还可以创建新的列。还用前面的 DataFrame 来演示，列名是 'A'、'B' 和 'C':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.375506</td>\n",
       "      <td>0.406939</td>\n",
       "      <td>0.069938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.069087</td>\n",
       "      <td>0.235615</td>\n",
       "      <td>0.154374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.677945</td>\n",
       "      <td>0.433839</td>\n",
       "      <td>0.652324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.264038</td>\n",
       "      <td>0.808055</td>\n",
       "      <td>0.347197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.589161</td>\n",
       "      <td>0.252418</td>\n",
       "      <td>0.557789</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B         C\n",
       "0  0.375506  0.406939  0.069938\n",
       "1  0.069087  0.235615  0.154374\n",
       "2  0.677945  0.433839  0.652324\n",
       "3  0.264038  0.808055  0.347197\n",
       "4  0.589161  0.252418  0.557789"
      ]
     },
     "execution_count": 350,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用 df.eval() 创建一个新的列 'D'，然后赋给它其他列计算的值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.375506</td>\n",
       "      <td>0.406939</td>\n",
       "      <td>0.069938</td>\n",
       "      <td>11.187620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.069087</td>\n",
       "      <td>0.235615</td>\n",
       "      <td>0.154374</td>\n",
       "      <td>1.973796</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.677945</td>\n",
       "      <td>0.433839</td>\n",
       "      <td>0.652324</td>\n",
       "      <td>1.704344</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.264038</td>\n",
       "      <td>0.808055</td>\n",
       "      <td>0.347197</td>\n",
       "      <td>3.087857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.589161</td>\n",
       "      <td>0.252418</td>\n",
       "      <td>0.557789</td>\n",
       "      <td>1.508776</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B         C          D\n",
       "0  0.375506  0.406939  0.069938  11.187620\n",
       "1  0.069087  0.235615  0.154374   1.973796\n",
       "2  0.677945  0.433839  0.652324   1.704344\n",
       "3  0.264038  0.808055  0.347197   3.087857\n",
       "4  0.589161  0.252418  0.557789   1.508776"
      ]
     },
     "execution_count": 351,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.eval('D = (A + B) / C', inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以修改已有的列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.375506</td>\n",
       "      <td>0.406939</td>\n",
       "      <td>0.069938</td>\n",
       "      <td>-0.449425</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.069087</td>\n",
       "      <td>0.235615</td>\n",
       "      <td>0.154374</td>\n",
       "      <td>-1.078728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.677945</td>\n",
       "      <td>0.433839</td>\n",
       "      <td>0.652324</td>\n",
       "      <td>0.374209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.264038</td>\n",
       "      <td>0.808055</td>\n",
       "      <td>0.347197</td>\n",
       "      <td>-1.566886</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.589161</td>\n",
       "      <td>0.252418</td>\n",
       "      <td>0.557789</td>\n",
       "      <td>0.603708</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B         C         D\n",
       "0  0.375506  0.406939  0.069938 -0.449425\n",
       "1  0.069087  0.235615  0.154374 -1.078728\n",
       "2  0.677945  0.433839  0.652324  0.374209\n",
       "3  0.264038  0.808055  0.347197 -1.566886\n",
       "4  0.589161  0.252418  0.557789  0.603708"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.eval('D = (A - B) / C', inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  DataFrame.eval() 使用局部变量\n",
    "\n",
    "DataFrame.eval() 方法还支持通过 @ 符号使用 Python 的局部变量，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 353,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "column_mean = df.mean(1)\n",
    "result1 = df['A'] + column_mean\n",
    "result2 = df.eval('A + @column_mean')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "@ 符号表示“这是一个变量名称而不是一个列名称”，从而让你灵活地用两个“命名空间”的资源（列名称的命名空间和 Python 对象的命名空间）计算代数式。需要注意的\n",
    "是，@ 符号只能在 DataFrame.eval() 方法中使用，而不能在 pandas.eval() 函数中使用，因为 pandas.eval() 函数只能获取一个（Python）命名空间的内容。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrame.query() 方法\n",
    "\n",
    "DataFrame 基于字符串代数式的运算实现了另一个方法，被称为 query()，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 354,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result1 = df[(df.A < 0.5) & (df.B < 0.5)]\n",
    "result2 = pd.eval('df[(df.A < 0.5) & (df.B < 0.5)]')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和前面介绍过的 DataFrame.eval() 一样，这是一个用 DataFrame 列创建的代数式，但是不能用 DataFrame.eval() 语法。不过，对于这种过滤运算，你可以用 query() 方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 355,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result2 = df.query('A < 0.5 and B < 0.5')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了计算性能更优之外，这种方法的语法也比掩码代数式语法更好理解。需要注意的是，query() 方法也支持用 @ 符号引用局部变量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 356,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cmean = df['C'].mean()\n",
    "result1 = df[(df.A < Cmean) & (df.B < Cmean)]\n",
    "result2 = df.query('A < @Cmean and B < @Cmean')\n",
    "np.allclose(result1, result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 性能决定使用时机\n",
    "\n",
    "在考虑要不要用这两个函数时，需要思考两个方面：计算时间和内存消耗，而内存消耗是更重要的影响因素。就像前面介绍的那样，每个涉及 NumPy 数组或 Pandas 的 DataFrame 的复合代数式都会产生临时数组，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = df[(df.A < 0.5) & (df.B < 0.5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "它基本等价于："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tmp1 = df.A < 0.5\n",
    "tmp2 = df.B < 0.5\n",
    "tmp3 = tmp1 & tmp2\n",
    "x = df[tmp3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果临时 DataFrame 的内存需求比你的系统内存还大，那么最好还是使用 eval() 和 query() 代数式。你可以通过下面的方法大概估算一下变量的内存消耗："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32000"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.values.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在性能方面，即使你没有使用最大的系统内存，eval() 的计算速度也比普通方法快。现在的性能瓶颈变成了临时 DataFrame 与系统 CPU 的 L1 和 L2 缓存之间的对比了——如果系统缓存足够大，那么 eval() 就可以避免在不同缓存间缓慢地移动临时文件。在实际工作中，普通的计算方法与 eval/ query 计算方法在计算时间上的差异并非总是那么明显，普通方法在处理较小的数组时反而速度更快！ eval/ query 方法的优点主要是节省内存，有时语法也更加简洁。\n",
    "\n",
    "我们已经介绍了 eval() 与 query() 的绝大多数细节，若想了解更多的信息，请参考 Pandas 文档。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 更多资料"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "我们已经介绍了许多关于如何通过 Pandas 实现高效数据分析的基础知识。如果你想学习更多的 Pandas 知识，推荐参考下面的资源。\n",
    "\n",
    "- [Pandas online documentation](http://pandas.pydata.org/): 这是 Pandas 程序包最详细的文档。虽然文档中的示例都是在处理小数据集，但是它们内容完整、功能全面，对于理解各种函数非常有用。同时，它会保持和最新版本的Pandas同步更新。\n",
    "\n",
    "- [*Python for Data Analysis*](http://shop.oreilly.com/product/0636920023784.do) 这是 Wes McKinney（Pandas 创建者）的著作，里面介绍了许多本章没有介绍的 Pandas 知识，非常详细。值得一提的是，由于作者曾经是一名金融分析师，因此他深刻论述了用 Pandas 处理时间序列的工具。这本书中还有许多有趣的示例，通过 Pandas 探索真实数据集的规律。但需要注意的是，由于这本书已经有些年头，而 Pandas 程序包作为开源项目，发展速度很快，所以许多新特性书中并没有介绍。\n",
    "\n",
    "- [Stack Overflow](http://stackoverflow.com/questions/tagged/pandas): Pandas 的用户很多，只有你有问题，就可以到 Stack Overflow 上看看别人是不是已经问过同样的问题。使用 Pandas 的过程中，Google 等搜索引擎也必不可少。在你最喜欢的搜索引擎中敲入遇到的问题或异常，可能会得到比 Stack Overflow 上更多的答案。\n",
    "\n",
    "- [Pandas on PyVideo](http://pyvideo.org/search?q=pandas): 从 PyCon 到 SciPy 再到 PyData，许多会议都有 Pandas 开发者和专家分享的教程。PyCon 的教程特别受欢迎，好评最多。\n",
    "\n",
    "希望通过以上的全部内容和这些资源，可以让你学会如何通过 Pandas 解决工作中遇到的所有数据分析问题！"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "interpreter": {
   "hash": "3d6b570fd79ac60e08d7cb15c4920cf068ddf265ddaa1ba9d441106fe4b8e39c"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 ('summer')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
