diff --git a/docs/6.md b/docs/6.md
index 0b9752844e7bcfeb256278d7450072735c929fef..3be85217b361edd5b549cdd3b8ddf841a1ac4068 100644
--- a/docs/6.md
+++ b/docs/6.md
@@ -166,7 +166,7 @@ Out[24]:
 2  9  10  11  12     foo
 ```
 
-缺失值处理是文件解析任务中的一个重要组成部分。缺失数据经常是要么没有（空字符串），要么用某个标记值表示。默认情况下，pandas 会用一组经常出现的标记值进行识别，比如 NA 及 NULL：
+缺失值处理是文件解析任务中的一个重要组成部分。缺失数据经常是要么没有（空字符串），要么用某个标记值表示。默认情况下，pandas 会用一组经常出现的标记值进行识别，比如 NA 及`NULL`：
 ```python
 In [25]: !cat examples/ex5.csv
 something,a,b,c,d,message
diff --git a/docs/8.md b/docs/8.md
index 0097bf9e748b6371e8e897a5177aa2b63edaf61a..ea6a016eb0215898f7c34476f3cfa95c6781c333 100644
--- a/docs/8.md
+++ b/docs/8.md
@@ -26,7 +26,7 @@ d  2    0.281746
 dtype: float64
 ```
 
-看到的结果是经过美化的带有 MultiIndex 索引的`Series`的格式。索引之间的“间隔”表示“直接使用上面的标签”：
+看到的结果是经过美化的带有`MultiIndex`索引的`Series`的格式。索引之间的“间隔”表示“直接使用上面的标签”：
 ```python
 In [11]: data.index
 Out[11]: 
@@ -69,7 +69,7 @@ d    0.281746
 dtype: float64
 ```
 
-层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过 unstack 方法将这段数据重新安排到一个`DataFrame`中：
+层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过`unstack`方法将这段数据重新安排到一个`DataFrame`中：
 ```python
 In [16]: data.unstack()
 Out[16]: 
@@ -80,7 +80,7 @@ c  1.393406  0.092908       NaN
 d       NaN  0.281746  0.769023
 ```
 
-unstack 的逆运算是 stack：
+`unstack`的逆运算是`stack`：
 ```python
 In [17]: data.unstack().stack()
 Out[17]: 
@@ -96,7 +96,7 @@ d  2    0.281746
 dtype: float64
 ```
 
-stack 和 unstack 将在本章后面详细讲解。
+`stack`和`unstack`将在本章后面详细讲解。
 
 对于一个`DataFrame`，每条轴都可以有分层索引：
 ```python
@@ -132,7 +132,7 @@ b    1        6   7        8
      2        9  10       11
 ```
 
-> 注意：小心区分索引名 state、color 与行标签。
+> 注意：小心区分索引名`state`、`color`与行标签。
 
 有了部分列索引，因此可以轻松选取列分组：
 ```python
@@ -146,7 +146,7 @@ b    1         6    7
      2         9   10
 ```
 
-可以单独创建 MultiIndex 然后复用。上面那个`DataFrame`中的（带有分级名称）列可以这样创建：
+可以单独创建`MultiIndex`然后复用。上面那个`DataFrame`中的（带有分级名称）列可以这样创建：
 ```python
 MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
                        names=['state', 'color'])
@@ -154,7 +154,7 @@ MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']]
 
 ## 重排与分级排序
 
-有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel 接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：
+有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。`swaplevel`接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：
 ```python
 In [24]: frame.swaplevel('key1', 'key2')
 Out[24]: 
@@ -167,7 +167,7 @@ key2 key1
 2    b        9  10       11
 ```
 
-而 sort_index 则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到 sort_index，这样最终结果就是按照指定顺序进行字母排序了：
+而`sort_index`则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到`sort_index`，这样最终结果就是按照指定顺序进行字母排序了：
 ```python
 In [25]: frame.sort_index(level=1)
 Out[25]: 
@@ -192,7 +192,7 @@ key2 key1
 
 ## 根据级别汇总统计
 
-许多对`DataFrame`和`Series`的描述和汇总统计都有一个 level 选项，它用于指定在某条轴上求和的级别。再以上面那个`DataFrame`为例，我们可以根据行或列上的级别来进行求和：
+许多对`DataFrame`和`Series`的描述和汇总统计都有一个`level`选项，它用于指定在某条轴上求和的级别。再以上面那个`DataFrame`为例，我们可以根据行或列上的级别来进行求和：
 ```python
 In [27]: frame.sum(level='key2')
 Out[27]: 
@@ -212,7 +212,7 @@ b    1        14    7
      2        20   10
 ```
 
-这其实是利用了 pandas 的 groupby 功能，本书稍后将对其进行详细讲解。
+这其实是利用了 pandas 的`groupby`功能，本书稍后将对其进行详细讲解。
 
 ## 使用`DataFrame`的列进行索引
 
@@ -235,7 +235,7 @@ Out[30]:
 6  6  1  two  3
 ```
 
-`DataFrame`的 set_index 函数会将其一个或多个列转换为行索引，并创建一个新的`DataFrame`：
+`DataFrame`的`set_index`函数会将其一个或多个列转换为行索引，并创建一个新的`DataFrame`：
 ```python
 In [31]: frame2 = frame.set_index(['c', 'd'])
 
@@ -267,7 +267,7 @@ two 0  3  4  two  0
     3  6  1  two  3
 ```
 
-reset_index 的功能跟 set_index 刚好相反，层次化索引的级别会被转移到列里面：
+`reset_index`的功能跟`set_index`刚好相反，层次化索引的级别会被转移到列里面：
 ```python
 In [34]: frame2.reset_index()
 Out[34]:
@@ -285,15 +285,15 @@ c  d  a  b
 
 pandas 对象中的数据可以通过一些方式进行合并：
 
--`pandas.merge`可根据一个或多个键将不同`DataFrame`中的行连接起来。SQL 或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的 join 操作。
--`pandas.concat`可以沿着一条轴将多个对象堆叠到一起。
-- 实例方法 combine_first 可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。
+- `pandas.merge`可根据一个或多个键将不同`DataFrame`中的行连接起来。SQL 或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的连接操作。
+- `pandas.concat`可以沿着一条轴将多个对象堆叠到一起。
+- 实例方法`combine_first`可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。
 
 我将分别对它们进行讲解，并给出一些例子。本书剩余部分的示例中将经常用到它们。
 
 ##数据库风格的`DataFrame`合并
 
-数据集的合并（merge）或连接（join）运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库（基于 SQL）的核心。pandas 的 merge 函数是对数据应用这些算法的主要切入点。
+数据集的合并（merge）或连接（join）运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库（基于 SQL）的核心。pandas 的`merge`函数是对数据应用这些算法的主要切入点。
 
 以一个简单的例子开始：
 ```python
@@ -322,7 +322,7 @@ Out[38]:
 2      2   d
 ```
 
-这是一种多对一的合并。df1 中的数据有多个被标记为 a 和 b 的行，而 df2 中 key 列的每个值则仅对应一行。对这些对象调用 merge 即可得到：
+这是一种多对一的合并。`df1`中的数据有多个被标记为`a`和`b`的行，而`df2`中`key`列的每个值则仅对应一行。对这些对象调用`merge`即可得到：
 ```python
 In [39]: pd.merge(df1, df2)
 Out[39]: 
@@ -335,7 +335,7 @@ Out[39]:
 5      5   a      0
 ```
 
-注意，我并没有指明要用哪个列进行连接。如果没有指定，merge 就会将重叠列的列名当做键。不过，最好明确指定一下：
+注意，我并没有指明要用哪个列进行连接。如果没有指定，`merge`就会将重叠列的列名当做键。不过，最好明确指定一下：
 ```python
 In [40]: pd.merge(df1, df2, on='key')
 Out[40]: 
@@ -367,7 +367,7 @@ Out[43]:
 5      5    a      0    a
 ```
 
-可能你已经注意到了，结果里面 c 和 d 以及与之相关的数据消失了。默认情况下，merge 做的是“内连接”；结果中的键是交集。其他方式还有"left"、"right"以及"outer"。外连接求取的是键的并集，组合了左连接和右连接的效果：
+可能你已经注意到了，结果里面`c`和`d`以及与之相关的数据消失了。默认情况下，`merge`做的是“内连接”；结果中的键是交集。其他方式还有`"left"`、`"right"`以及`"outer"`。外连接求取的是键的并集，组合了左连接和右连接的效果：
 ```python
 In [44]: pd.merge(df1, df2, how='outer')
 Out[44]: 
@@ -430,7 +430,7 @@ Out[49]:
 10      5   b    3.0
 ```
 
-多对多连接产生的是行的笛卡尔积。由于左边的`DataFrame`有 3 个"b"行，右边的有 2 个，所以最终结果中就有 6 个"b"行。连接方式只影响出现在结果中的不同的键的值：
+多对多连接产生的是行的笛卡尔积。由于左边的`DataFrame`有 3 个`"b"`行，右边的有 2 个，所以最终结果中就有 6 个`"b"`行。连接方式只影响出现在结果中的不同的键的值：
 ```python
 In [50]: pd.merge(df1, df2, how='inner')
 Out[50]: 
@@ -471,7 +471,7 @@ Out[53]:
 
 > 注意：在进行列－列连接时，`DataFrame`对象中的索引会被丢弃。
 
-对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但 merge 有一个更实用的 suffixes 选项，用于指定附加到左右两个`DataFrame`对象的重叠列名上的字符串：
+对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但`merge`有一个更实用的`suffixes`选项，用于指定附加到左右两个`DataFrame`对象的重叠列名上的字符串：
 ```python
 In [54]: pd.merge(left, right, on='key1')
 Out[54]: 
@@ -494,19 +494,19 @@ Out[55]:
 5  bar       one     3        two     7
 ```
 
-merge 的参数请参见表 8-2。使用`DataFrame`的行索引合并是下一节的主题。
+`merge`的参数请参见表 8-2。使用`DataFrame`的行索引合并是下一节的主题。
 
-表 8-2 merge 函数的参数
+表 8-2 `merge`函数的参数
 
 ![](img/7178691-35ca716a4f1b8475.png)
 
 ![](img/7178691-c86672e733ceccd9.png)
 
-indicator 添加特殊的列 _merge，它可以指明每个行的来源，它的值有 left_only、right_only 或 both，根据每行的合并数据的来源。
+`indicator`添加特殊的列`_merge`，它可以指明每个行的来源，它的值有`left_only`、`right_only`或`both`，根据每行的合并数据的来源。
 
 ## 索引上的合并
 
-有时候，`DataFrame`中的连接键位于其索引中。在这种情况下，你可以传入 left_index=True 或 right_index=True（或两个都传）以说明索引应该被用作连接键：
+有时候，`DataFrame`中的连接键位于其索引中。在这种情况下，你可以传入`left_index=True`或`right_index=True`（或两个都传）以说明索引应该被用作连接键：
 ```python
 In [56]: left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
    ....:                       'value': range(6)})
@@ -540,7 +540,7 @@ Out[60]:
 4   b      4        7.0
 ```
 
-由于默认的 merge 方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：
+由于默认的`merge`方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：
 ```python
 In [61]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
 Out[61]: 
@@ -586,7 +586,7 @@ Ohio   2000       4       5
        2002      10      11
 ```
 
-这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用 how='outer'对重复索引值的处理）：
+这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用`how='outer'`对重复索引值的处理）：
 ```python
 In [66]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
 Out[66]: 
@@ -645,7 +645,7 @@ d   NaN     NaN      11.0     12.0
 e   5.0     6.0      13.0     14.0
 ```
 
-`DataFrame`还有一个便捷的 join 实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的`DataFrame`对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：
+`DataFrame`还有一个便捷的`join`实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的`DataFrame`对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：
 ```python
 In [73]: left2.join(right2, how='outer')
 Out[73]: 
@@ -657,7 +657,7 @@ d   NaN     NaN      11.0     12.0
 e   5.0     6.0      13.0     14.0
 ```
 
-因为一些历史版本的遗留原因，`DataFrame`的 join 方法默认使用的是左连接，保留左边表的行索引。它还支持在调用的`DataFrame`的列上，连接传递的`DataFrame`索引：
+因为一些历史版本的遗留原因，`DataFrame`的`join`方法默认使用的是左连接，保留左边表的行索引。它还支持在调用的`DataFrame`的列上，连接传递的`DataFrame`索引：
 ```python
 In [74]: left1.join(right1, on='key')
 Out[74]: 
@@ -670,7 +670,7 @@ Out[74]:
 5   c      5        NaN
 ```
 
-最后，对于简单的索引合并，你还可以向 join 传入一组`DataFrame`，下一节会介绍更为通用的 concat 函数，也能实现此功能：
+最后，对于简单的索引合并，你还可以向`join`传入一组`DataFrame`，下一节会介绍更为通用的`concat`函数，也能实现此功能：
 ```python
 In [75]: another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
    ....:                        index=['a', 'c', 'e', 'f'],
@@ -705,7 +705,7 @@ f   NaN     NaN       NaN      NaN      16.0    17.0
 
 ## 轴向连接
 
-另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy 的 concatenation 函数可以用 NumPy 数组来做：
+另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy 的`concatenation`函数可以用 NumPy 数组来做：
 ```python
 In [79]: arr = np.arange(12).reshape((3, 4))
 
@@ -728,7 +728,7 @@ array([[ 0,  1,  2,  3,  0,  1,  2,  3],
 - 连接的数据集是否需要在结果对象中可识别？
 - 连接轴中保存的数据是否需要保留？许多情况下，`DataFrame`默认的整数标签最好在连接时删掉。
 
-pandas 的 concat 函数提供了一种能够解决这些问题的可靠方式。我将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的`Series`：
+pandas 的`concat`函数提供了一种能够解决这些问题的可靠方式。我将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的`Series`：
 ```python
 In [82]: s1 = pd.Series([0, 1], index=['a', 'b'])
 
@@ -737,7 +737,7 @@ In [83]: s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e'])
 In [84]: s3 = pd.Series([5, 6], index=['f', 'g'])
 ```
 
-对这些对象调用 concat 可以将值和索引粘合在一起：
+对这些对象调用`concat`可以将值和索引粘合在一起：
 ```python
 In [85]: pd.concat([s1, s2, s3])
 Out[85]: 
@@ -751,7 +751,7 @@ g    6
 dtype: int64
 ```
 
-默认情况下，concat 是在 axis=0 上工作的，最终产生一个新的`Series`。如果传入 axis=1，则结果就会变成一个`DataFrame`（axis=1 是列）：
+默认情况下，`concat`是在`axis=0`上工作的，最终产生一个新的`Series`。如果传入`axis=1`，则结果就会变成一个`DataFrame`（`axis=1`是列）：
 ```python
 In [86]: pd.concat([s1, s2, s3], axis=1)
 Out[86]: 
@@ -765,7 +765,7 @@ f  NaN  NaN  5.0
 g  NaN  NaN  6.0
 ```
 
-这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入 join='inner'即可得到它们的交集：
+这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入`join='inner'`即可得到它们的交集：
 ```python
 In [87]: s4 = pd.concat([s1, s3])
 
@@ -792,9 +792,9 @@ a  0  0
 b  1  1
 ```
 
-在这个例子中，f 和 g 标签消失了，是因为使用的是 join='inner'选项。
+在这个例子中，`f`和`g`标签消失了，是因为使用的是`join='inner'`选项。
 
-你可以通过 join_axes 指定要在其它轴上使用的索引：
+你可以通过`join_axes`指定要在其它轴上使用的索引：
 ```python
 In [91]: pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])
 Out[91]: 
@@ -805,7 +805,7 @@ b  1.0  1.0
 e  NaN  NaN
 ```
 
-不过有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用 keys 参数即可达到这个目的：
+不过有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用`keys`参数即可达到这个目的：
 ```python
 In [92]: result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
 
@@ -827,7 +827,7 @@ two    0.0  1.0  NaN  NaN
 three  NaN  NaN  5.0  6.0
 ```
 
-如果沿着 axis=1 对`Series`进行合并，则 keys 就会成为`DataFrame`的列头：
+如果沿着`axis=1`对`Series`进行合并，则`keys`就会成为`DataFrame`的列头：
 ```python
 In [95]: pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
 Out[95]: 
@@ -871,7 +871,7 @@ b      2   3    NaN  NaN
 c      4   5    7.0  8.0
 ```
 
-如果传入的不是列表而是一个字典，则字典的键就会被当做 keys 选项的值：
+如果传入的不是列表而是一个字典，则字典的键就会被当做`keys`选项的值：
 ```python
 In [101]: pd.concat({'level1': df1, 'level2': df2}, axis=1)
 
@@ -883,7 +883,7 @@ b      2   3    NaN  NaN
 c      4   5    7.0  8.0
 ```
 
-此外还有两个用于管理层次化索引创建方式的参数（参见表 8-3）。举个例子，我们可以用 names 参数命名创建的轴级别：
+此外还有两个用于管理层次化索引创建方式的参数（参见表 8-3）。举个例子，我们可以用`names`参数命名创建的轴级别：
 ```python
 In [102]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],
    .....:           names=['upper', 'lower'])
@@ -915,7 +915,7 @@ Out[106]:
 1 -0.577087  0.124121  0.302614
 ```
 
-在这种情况下，传入 ignore_index=True 即可：
+在这种情况下，传入`ignore_index=True`即可：
 ```python
 In [107]: pd.concat([df1, df2], ignore_index=True)
 Out[107]: 
@@ -927,11 +927,11 @@ Out[107]:
 4  0.302614 -0.577087       NaN  0.124121
 ```
 
-![表 8-3 concat 函数的参数](img/7178691-339436563b519415.png)
+![表 8-3 `concat`函数的参数](img/7178691-339436563b519415.png)
 
 ## 合并重叠数据
 
-还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子，我们使用 NumPy 的 where 函数，它表示一种等价于面向数组的 if-else：
+还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子，我们使用 NumPy 的`where`函数，它表示一种等价于面向数组的`if-else`：
 ```python
 In [108]: a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
    .....:               index=['f', 'e', 'd', 'c', 'b', 'a'])
@@ -965,7 +965,7 @@ In [113]: np.where(pd.isnull(a), b, a)
 Out[113]: array([ 0. ,  2.5,  2. ,  3.5,  4.5,  nan])
 ```
 
-`Series`有一个 combine_first 方法，实现的也是一样的功能，还带有 pandas 的数据对齐：
+`Series`有一个`combine_first`方法，实现的也是一样的功能，还带有 pandas 的数据对齐：
 ```python
 In [114]: b[:-2].combine_first(a[2:])
 Out[114]: 
@@ -978,7 +978,7 @@ f    0.0
 dtype: float64
 ```
 
-对于`DataFrame`，combine_first 自然也会在列上做同样的事情，因此你可以将其看做：用传递对象中的数据为调用对象的缺失数据“打补丁”：
+对于`DataFrame`，`combine_first`自然也会在列上做同样的事情，因此你可以将其看做：用传递对象中的数据为调用对象的缺失数据“打补丁”：
 ```python
 In [115]: df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
    .....:                     'b': [np.nan, 2., np.nan, 6.],
@@ -1014,16 +1014,16 @@ Out[119]:
 4  7.0  8.0   NaN
 ```
 
-# 8.3 重塑和轴向旋转
+# 8.3 重塑和透视
 
-有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑（reshape）或轴向旋转（pivot）运算。
+有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑（reshape）或透视（pivot）运算。
 
 ## 重塑层次化索引
 
 层次化索引为`DataFrame`数据的重排任务提供了一种具有良好一致性的方式。主要功能有二：
 
-- stack：将数据的列“旋转”为行。
-- unstack：将数据的行“旋转”为列。
+- `stack`：将数据的列“旋转”为行。
+- `unstack`：将数据的行“旋转”为列。
 
 我将通过一系列的范例来讲解这些操作。接下来看一个简单的`DataFrame`，其中的行列索引均为字符串数组：
 ```python
@@ -1040,7 +1040,7 @@ Ohio        0    1      2
 Colorado    3    4      5
 ```
 
-对该数据使用 stack 方法即可将列转换为行，得到一个`Series`：
+对该数据使用`stack`方法即可将列转换为行，得到一个`Series`：
 ```python
 In [122]: result = data.stack()
 
@@ -1056,7 +1056,7 @@ Colorado  one       3
 dtype: int64
 ```
 
-对于一个层次化索引的`Series`，你可以用 unstack 将其重排为一个`DataFrame`：
+对于一个层次化索引的`Series`，你可以用`unstack`将其重排为一个`DataFrame`：
 ```python
 In [124]: result.unstack()
 Out[124]: 
@@ -1066,7 +1066,7 @@ Ohio        0    1      2
 Colorado    3    4      5
 ```
 
-默认情况下，unstack 操作的是最内层（stack 也是如此）。传入分层级别的编号或名称即可对其它级别进行 unstack 操作：
+默认情况下，`unstack`操作的是最内层（`stack`也是如此）。传入分层级别的编号或名称即可对其它级别进行`unstack`操作：
 ```python
 In [125]: result.unstack(0)
 Out[125]: 
@@ -1085,7 +1085,7 @@ two        1         4
 three      2         5
 ```
 
-如果不是所有的级别值都能在各分组中找到的话，则 unstack 操作可能会引入缺失数据：
+如果不是所有的级别值都能在各分组中找到的话，则`unstack`操作可能会引入缺失数据：
 ```python
 In [127]: s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
 
@@ -1111,7 +1111,7 @@ one  0.0  1.0  2.0  3.0  NaN
 two  NaN  NaN  4.0  5.0  6.0
 ```
 
-stack 默认会滤除缺失数据，因此该运算是可逆的：
+`stack`默认会滤除缺失数据，因此该运算是可逆的：
 ```python
 In [132]: data2.unstack()
 Out[132]: 
@@ -1145,7 +1145,7 @@ two  a    NaN
 dtype: float64
 ```
 
-在对`DataFrame`进行 unstack 操作时，作为旋转轴的级别将会成为结果中的最低级别：
+在对`DataFrame`进行`unstack`操作时，作为旋转轴的级别将会成为结果中的最低级别：
 ```python
 In [135]: df = pd.DataFrame({'left': result, 'right': result + 5},
    .....:                   columns=pd.Index(['left', 'right'], name='side'))
@@ -1171,7 +1171,7 @@ two       1        4     6        9
 three     2        5     7       10
 ```
 
-当调用 stack，我们可以指明轴的名字：
+当调用`stack`，我们可以指明轴的名字：
 ```python
 In [138]: df.unstack('state').stack('side')
 Out[138]: 
@@ -1218,9 +1218,9 @@ In [144]: data.index = periods.to_timestamp('D', 'end')
 In [145]: ldata = data.stack().reset_index().rename(columns={0: 'value'})
 ```
 
-这就是多个时间序列（或者其它带有两个或多个键的可观察数据，这里，我们的键是 date 和 item）的长格式。表中的每行代表一次观察。
+这就是多个时间序列（或者其它带有两个或多个键的可观察数据，这里，我们的键是`date`和`item`）的长格式。表中的每行代表一次观察。
 
-关系型数据库（如 MySQL）中的数据经常都是这样存储的，因为固定架构（即列名和数据类型）有一个好处：随着表中数据的添加，item 列中的值的种类能够增加。在前面的例子中，date 和 item 通常就是主键（用关系型数据库的说法），不仅提供了关系完整性，而且提供了更为简单的查询支持。有的情况下，使用这样的数据会很麻烦，你可能会更喜欢`DataFrame`，不同的 item 值分别形成一列，date 列中的时间戳则用作索引。`DataFrame`的 pivot 方法完全可以实现这个转换：
+关系型数据库（如 MySQL）中的数据经常都是这样存储的，因为固定架构（即列名和数据类型）有一个好处：随着表中数据的添加，`item`列中的值的种类能够增加。在前面的例子中，`date`和`item`通常就是主键（用关系型数据库的说法），不仅提供了关系完整性，而且提供了更为简单的查询支持。有的情况下，使用这样的数据会很麻烦，你可能会更喜欢`DataFrame`，不同的`item`值分别形成一列，`date`列中的时间戳则用作索引。`DataFrame`的`pivot`方法完全可以实现这个转换：
 ```python
 In [147]: pivoted = ldata.pivot('date', 'item', 'value')
 
@@ -1297,7 +1297,7 @@ date
 1960-03-31  2.31  2847.699    5.2
 ```
 
-注意，pivot 其实就是用 set_index 创建层次化索引，再用 unstack 重塑：
+注意，`pivot`其实就是用`set_index`创建层次化索引，再用`unstack`重塑：
 ```python
 In [154]: unstacked = ldata.set_index(['date', 'item']).unstack('item')
 
@@ -1332,7 +1332,7 @@ Out[158]:
 2  3  6  9  baz
 ```
 
-key 列可能是分组指标，其它的列是数据值。当使用`pandas.melt`，我们必须指明哪些列是分组指标。下面使用 key 作为唯一的分组指标：
+`key`列可能是分组指标，其它的列是数据值。当使用`pandas.melt`，我们必须指明哪些列是分组指标。下面使用`key`作为唯一的分组指标：
 ```python
 In [159]: melted = pd.melt(df, ['key'])
 
@@ -1350,7 +1350,7 @@ Out[160]:
 8  baz        C      9
 ```
 
-使用 pivot，可以重塑回原来的样子：
+使用`pivot`，可以重塑回原来的样子：
 ```python
 In [161]: reshaped = melted.pivot('key', 'variable', 'value')
 
@@ -1363,7 +1363,7 @@ baz       3  6  9
 foo       1  4  7
 ```
 
-因为 pivot 的结果从列创建了一个索引，用作行标签，我们可以使用 reset_index 将数据移回列：
+因为`pivot`的结果从列创建了一个索引，用作行标签，我们可以使用`reset_index`将数据移回列：
 ```python
 In [163]: reshaped.reset_index()
 Out[163]: