From da47f5192280a44758bcbb80f54baceb1aaed051 Mon Sep 17 00:00:00 2001
From: wizardforcel <562826179@qq.com>
Date: Fri, 1 Jan 2021 13:30:34 +0800
Subject: [PATCH] 2021-01-01 13:30:34

---
 docs/5.md | 144 +++++++++++++++++++++++++++---------------------------
 1 file changed, 72 insertions(+), 72 deletions(-)

diff --git a/docs/5.md b/docs/5.md
index eb9f207..c82221b 100644
--- a/docs/5.md
+++ b/docs/5.md
@@ -416,7 +416,7 @@ six    2003  Nevada  3.2   NaN    False
 
 > 注意：不能用`frame2.eastern`创建新的列。
 
-del 方法可以用来删除这列：
+`del`方法可以用来删除这列：
 ```python
 In [63]: del frame2['eastern']
 
@@ -424,7 +424,7 @@ In [64]: frame2.columns
 Out[64]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
 ```
 
-> 注意：通过索引方式返回的列只是相应数据的视图而已，并不是副本。因此，对返回的`Series`所做的任何就地修改全都会反映到源`DataFrame`上。通过`Series`的 copy 方法即可指定复制列。
+> 注意：通过索引方式返回的列只是相应数据的视图而已，并不是副本。因此，对返回的`Series`所做的任何就地修改全都会反映到源`DataFrame`上。通过`Series`的`copy`方法即可指定复制列。
 
 另一种常见的数据形式是嵌套字典：
 ```python
@@ -479,7 +479,7 @@ Out[71]:
 
 ![](img/7178691-106835b28c0cea5a.png)
 
-如果设置了`DataFrame`的 index 和 columns 的 name 属性，则这些信息也会被显示出来：
+如果设置了`DataFrame`的`index`和`columns`的`name`属性，则这些信息也会被显示出来：
 ```python
 In [72]: frame3.index.name = 'year'; frame3.columns.name = 'state'
 
@@ -492,7 +492,7 @@ year
 2002      2.9   3.6
 ```
 
-跟`Series`一样，values 属性也会以二维 ndarray 的形式返回`DataFrame`中的数据：
+跟`Series`一样，`values`属性也会以二维`ndarray`的形式返回`DataFrame`中的数据：
 ```python
 In [74]: frame3.values
 Out[74]: 
@@ -501,7 +501,7 @@ array([[ nan,  1.5],
        [ 2.9,  3.6]])
 ```
 
-如果`DataFrame`各列的数据类型不同，则值数组的 dtype 就会选用能兼容所有列的数据类型：
+如果`DataFrame`各列的数据类型不同，则值数组的`dtype`就会选用能兼容所有列的数据类型：
 ```python
 In [75]: frame2.values
 Out[75]:
@@ -514,7 +514,7 @@ array([[2000, 'Ohio', 1.5, nan],
 ```
 
 ## 索引对象
-pandas 的索引对象负责管理轴标签和其他元数据（比如轴名称等）。构建`Series`或`DataFrame`时，所用到的任何数组或其他序列的标签都会被转换成一个 Index：
+pandas 的索引对象负责管理轴标签和其他元数据（比如轴名称等）。构建`Series`或`DataFrame`时，所用到的任何数组或其他序列的标签都会被转换成一个`Index`：
 ```python
 In [76]: obj = pd.Series(range(3), index=['a', 'b', 'c'])
 
@@ -527,12 +527,12 @@ In [79]: index[1:]
 Out[79]: Index(['b', 'c'], dtype='object')
 ```
 
-Index 对象是不可变的，因此用户不能对其进行修改：
+`Index`对象是不可变的，因此用户不能对其进行修改：
 ```python
 index[1] = 'd'  # TypeError
 ```
 
-不可变可以使 Index 对象在多个数据结构之间安全共享：
+不可变可以使`Index`对象在多个数据结构之间安全共享：
 ```python
 In [80]: labels = pd.Index(np.arange(3))
 
@@ -552,9 +552,9 @@ In [84]: obj2.index is labels
 Out[84]: True
 ```
 
-> 注意：虽然用户不需要经常使用 Index 的功能，但是因为一些操作会生成包含被索引化的数据，理解它们的工作原理是很重要的。
+> 注意：虽然用户不需要经常使用`Index`的功能，但是因为一些操作会生成包含被索引化的数据，理解它们的工作原理是很重要的。
 
-除了类似于数组，Index 的功能也类似一个固定大小的集合：
+除了类似于数组，`Index`的功能也类似一个固定大小的集合：
 ```python
 In [85]: frame3
 Out[85]: 
@@ -573,7 +573,7 @@ In [88]: 2003 in frame3.index
 Out[88]: False
 ```
 
-与 python 的集合不同，pandas 的 Index 可以包含重复的标签：
+与 python 的集合不同，pandas 的`Index`可以包含重复的标签：
 ```python
 In [89]: dup_labels = pd.Index(['foo', 'foo', 'bar', 'bar'])
 
@@ -591,7 +591,7 @@ Out[90]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')
 本节中，我将介绍操作`Series`和`DataFrame`中的数据的基本手段。后续章节将更加深入地挖掘 pandas 在数据分析和处理方面的功能。本书不是 pandas 库的详尽文档，主要关注的是最重要的功能，那些不大常用的内容（也就是那些更深奥的内容）就交给你自己去摸索吧。
 
 ## 重新索引
-pandas 对象的一个重要方法是 reindex，其作用是创建一个新对象，它的数据符合新的索引。看下面的例子：
+pandas 对象的一个重要方法是`reindex`，其作用是创建一个新对象，它的数据符合新的索引。看下面的例子：
 ```python
 In [91]: obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
 
@@ -604,7 +604,7 @@ c    3.6
 dtype: float64
 ```
 
-用该`Series`的 reindex 将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值：
+用该`Series`的`reindex`将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值：
 ```python
 In [93]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
 
@@ -618,7 +618,7 @@ e    NaN
 dtype: float64
 ```
 
-对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method 选项即可达到此目的，例如，使用 ffill 可以实现前向值填充：
+对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。`method`选项即可达到此目的，例如，使用`ffill`可以实现前向值填充：
 ```python
 In [95]: obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
 
@@ -640,7 +640,7 @@ Out[97]:
 dtype: object
 ```
 
-借助`DataFrame`，reindex 可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行：
+借助`DataFrame`，`reindex`可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行：
 ```python
 In [98]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
    ....:                      index=['a', 'c', 'd'],
@@ -664,7 +664,7 @@ c   3.0    4.0         5.0
 d   6.0    7.0         8.0
 ```
 
-列可以用 columns 关键字重新索引：
+列可以用`columns`关键字重新索引：
 ```python
 In [102]: states = ['Texas', 'Utah', 'California']
 
@@ -676,12 +676,12 @@ c      4   NaN           5
 d      7   NaN           8
 ```
 
-表 5-3 列出了 reindex 函数的各参数及说明。
+表 5-3 列出了`reindex`函数的各参数及说明。
 
 ![](img/7178691-efa3dbd4b83c61ec.jpg)
 
 ## 丢弃指定轴上的项
-丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，所以 drop 方法返回的是一个在指定轴上删除了指定值的新对象：
+丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，所以`drop`方法返回的是一个在指定轴上删除了指定值的新对象：
 ```python
 In [105]: obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
 
@@ -727,7 +727,7 @@ Utah        8    9     10    11
 New York   12   13     14    15
 ```
 
-用标签序列调用 drop 会从行标签（axis 0）删除值：
+用标签序列调用`drop`会从行标签（轴 0）删除值：
 ```python
 In [112]: data.drop(['Colorado', 'Ohio'])
 Out[112]: 
@@ -736,7 +736,7 @@ Utah        8    9     10    11
 New York   12   13     14    15
 ```
 
-通过传递 axis=1 或 axis='columns'可以删除列的值：
+通过传递`axis=1`或`axis='columns'`可以删除列的值：
 ```python
 In [113]: data.drop('two', axis=1)
 Out[113]: 
@@ -755,7 +755,7 @@ Utah        8     10
 New York   12     14
 ```
 
-许多函数，如 drop，会修改`Series`或`DataFrame`的大小或形状，可以就地修改对象，不会返回新的对象：
+许多函数，如`drop`，会修改`Series`或`DataFrame`的大小或形状，可以就地修改对象，不会返回新的对象：
 ```python
 In [115]: obj.drop('c', inplace=True)
 
@@ -768,10 +768,10 @@ e    4.0
 dtype: float64
 ```
 
-小心使用 inplace，它会销毁所有被删除的数据。
+小心使用`inplace`，它会销毁所有被删除的数据。
 
 ## 索引、选取和过滤
-`Series`索引（obj[...]）的工作方式类似于 NumPy 数组的索引，只不过`Series`的索引值不只是整数。下面是几个例子：
+`Series`索引（`obj[...]`）的工作方式类似于 NumPy 数组的索引，只不过`Series`的索引值不只是整数。下面是几个例子：
 ```python
 In [117]: obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
 
@@ -884,7 +884,7 @@ Utah        8    9     10    11
 New York   12   13     14    15
 ```
 
-选取行的语法 data[:2]十分方便。向[ ]传递单一的元素或列表，就可选择列。
+选取行的语法`data[:2]`十分方便。向`[ ]`传递单一的元素或列表，就可选择列。
 
 另一种用法是通过布尔型`DataFrame`（比如下面这个由标量比较运算得出的）进行索引：
 ```python
@@ -909,8 +909,8 @@ New York   12   13     14    15
 
 这使得`DataFrame`的语法与 NumPy 二维数组的语法很像。
 
-## 用 loc 和 iloc 进行选取
-对于`DataFrame`的行的标签索引，我引入了特殊的标签运算符 loc 和 iloc。它们可以让你用类似 NumPy 的标记，使用轴标签（loc）或整数索引（iloc），从`DataFrame`选择行和列的子集。
+## 用`loc`和`iloc`进行选取
+对于`DataFrame`的行的标签索引，我引入了特殊的标签运算符`loc`和`iloc`。它们可以让你用类似 NumPy 的标记，使用轴标签（`loc`）或整数索引（`iloc`），从`DataFrame`选择行和列的子集。
 
 作为一个初步示例，让我们通过标签选择一行和多列：
 ```python
@@ -921,7 +921,7 @@ three    6
 Name: Colorado, dtype: int64
 ```
 
-然后用 iloc 和整数进行选取：
+然后用`iloc`和整数进行选取：
 ```python
 In [138]: data.iloc[2, [3, 0, 1]]
 Out[138]: 
@@ -964,10 +964,10 @@ New York   12   13     14
 
 所以，在 pandas 中，有多个方法可以选取和重新组合数据。对于`DataFrame`，表 5-4 进行了总结。后面会看到，还有更多的方法进行层级化索引。
 
-> 笔记：在一开始设计 pandas 时，我觉得用 frame[:, col]选取列过于繁琐（也容易出错），因为列的选择是非常常见的操作。我做了些取舍，将花式索引的功能（标签和整数）放到了 ix 运算符中。在实践中，这会导致许多边缘情况，数据的轴标签是整数，所以 pandas 团队决定创造 loc 和 iloc 运算符分别处理严格基于标签和整数的索引。
-ix 运算符仍然可用，但并不推荐。
+> 笔记：在一开始设计 pandas 时，我觉得用`frame[:, col]`选取列过于繁琐（也容易出错），因为列的选择是非常常见的操作。我做了些取舍，将花式索引的功能（标签和整数）放到了`ix`运算符中。在实践中，这会导致许多边缘情况，数据的轴标签是整数，所以 pandas 团队决定创造`loc`和`iloc`运算符分别处理严格基于标签和整数的索引。
+`ix`运算符仍然可用，但并不推荐。
 
-![表 5-4`DataFrame`的索引选项](img/7178691-64354f2ab777bd8c.png)
+![表 5-4 `DataFrame`的索引选项](img/7178691-64354f2ab777bd8c.png)
 
 ## 整数索引
 处理整数索引的 pandas 对象常常难住新手，因为它与 Python 内置的列表和元组的索引语法不同。例如，你可能不认为下面的代码会出错：
@@ -977,7 +977,7 @@ ser
 ser[-1]
 ```
 
-这里，pandas 可以勉强进行整数索引，但是会导致小 bug。我们有包含 0,1,2 的索引，但是引入用户想要的东西（基于标签或位置的索引）很难：
+这里，pandas 可以勉强进行整数索引，但是会导致小 bug。我们有包含`0,1,2`的索引，但是引入用户想要的东西（基于标签或位置的索引）很难：
 ```python
 In [144]: ser
 Out[144]: 
@@ -995,7 +995,7 @@ In [146]: ser2[-1]
 Out[146]: 2.0
 ```
 
-为了进行统一，如果轴索引含有整数，数据选取总会使用标签。为了更准确，请使用 loc（标签）或 iloc（整数）：
+为了进行统一，如果轴索引含有整数，数据选取总会使用标签。为了更准确，请使用`loc`（标签）或`iloc`（整数）：
 ```python
 In [147]: ser[:1]
 Out[147]: 
@@ -1156,7 +1156,7 @@ Out[170]:
 3   NaN   NaN   NaN   NaN NaN
 ```
 
-使用 df1 的 add 方法，传入 df2 以及一个 fill_value 参数：
+使用`df1`的`add`方法，传入`df2`以及一个`fill_value`参数：
 ```python
 In [171]: df1.add(df2, fill_value=0)
 Out[171]: 
@@ -1167,7 +1167,7 @@ Out[171]:
 3  15.0  16.0  17.0  18.0  19.0
 ```
 
-表 5-5 列出了`Series`和`DataFrame`的算术方法。它们每个都有一个副本，以字母 r 开头，它会翻转参数。因此这两个语句是等价的：
+表 5-5 列出了`Series`和`DataFrame`的算术方法。它们每个都有一个副本，以字母`r`开头，它会翻转参数。因此这两个语句是等价的：
 ```python
 In [172]: 1 / df1
 Out[172]: 
@@ -1217,7 +1217,7 @@ array([[ 0.,  0.,  0.,  0.],
        [ 8.,  8.,  8.,  8.]])
 ```
 
-当我们从 arr 减去 arr[0]，每一行都会执行这个操作。这就叫做广播（broadcasting），附录 A 将对此进行详细讲解。`DataFrame`和`Series`之间的运算差不多也是如此：
+当我们从`arr`减去`arr[0]`，每一行都会执行这个操作。这就叫做广播（broadcasting），附录 A 将对此进行详细讲解。`DataFrame`和`Series`之间的运算差不多也是如此：
 ```python
 In [179]: frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
    .....:                      columns=list('bde'),
@@ -1294,10 +1294,10 @@ Texas  -1.0  0.0  1.0
 Oregon -1.0  0.0  1.0
 ```
 
-传入的轴号就是希望匹配的轴。在本例中，我们的目的是匹配`DataFrame`的行索引（axis='index' or axis=0）并进行广播。
+传入的轴号就是希望匹配的轴。在本例中，我们的目的是匹配`DataFrame`的行索引（`axis='index'`或`axis=0`）并进行广播。
 
 ## 函数应用和映射
-NumPy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象：
+NumPy 的`ufuncs`（元素级数组方法）也可用于操作 pandas 对象：
 ```python
 In [190]: frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
    .....:                      index=['Utah', 'Ohio', 'Texas', 'Oregon'])
@@ -1319,7 +1319,7 @@ Texas   0.092908  0.281746  0.769023
 Oregon  1.246435  1.007189  1.296221
 ```
 
-另一个常见的操作是，将函数应用到由各列或行所形成的一维数组上。`DataFrame`的 apply 方法即可实现此功能：
+另一个常见的操作是，将函数应用到由各列或行所形成的一维数组上。`DataFrame`的`apply`方法即可实现此功能：
 ```python
 In [193]: f = lambda x: x.max() - x.min()
 
@@ -1331,9 +1331,9 @@ e    2.689627
 dtype: float64
 ```
 
-这里的函数 f，计算了一个`Series`的最大值和最小值的差，在 frame 的每列都执行了一次。结果是一个`Series`，使用 frame 的列作为索引。
+这里的函数`f`，计算了一个`Series`的最大值和最小值的差，在`frame`的每列都执行了一次。结果是一个`Series`，使用`frame`的列作为索引。
 
-如果传递 axis='columns'到 apply，这个函数会在每行执行：
+如果传递`axis='columns'`到`apply`，这个函数会在每行执行：
 ```python
 In [195]: frame.apply(f, axis='columns')
 Out[195]:
@@ -1344,9 +1344,9 @@ Oregon    2.542656
 dtype: float64
 ```
 
-许多最为常见的数组统计功能都被实现成`DataFrame`的方法（如 sum 和 mean），因此无需使用 apply 方法。
+许多最为常见的数组统计功能都被实现成`DataFrame`的方法（如`sum`和`mean`），因此无需使用`apply`方法。
 
-传递到 apply 的函数不是必须返回一个标量，还可以返回由多个值组成的`Series`：
+传递到`apply`的函数不是必须返回一个标量，还可以返回由多个值组成的`Series`：
 ```python
 In [196]: def f(x):
    .....:     return pd.Series([x.min(), x.max()], index=['min', 'max'])
@@ -1358,7 +1358,7 @@ min -0.555730  0.281746 -1.296221
 max  1.246435  1.965781  1.393406
 ```
 
-元素级的 Python 函数也是可以用的。假如你想得到 frame 中各个浮点值的格式化字符串，使用 applymap 即可：
+元素级的 Python 函数也是可以用的。假如你想得到`frame`中各个浮点值的格式化字符串，使用`applymap`即可：
 ```python
 In [198]: format = lambda x: '%.2f' % x
 
@@ -1371,7 +1371,7 @@ Texas    0.09  0.28   0.77
 Oregon   1.25  1.01  -1.30
 ```
 
-之所以叫做 applymap，是因为`Series`有一个用于应用元素级函数的 map 方法：
+之所以叫做`applymap`，是因为`Series`有一个用于应用元素级函数的`map`方法：
 ```python
 In [200]: frame['e'].map(format)
 Out[200]: 
@@ -1383,7 +1383,7 @@ Name: e, dtype: object
 ```
 
 ## 排序和排名
-根据条件对数据集排序（sorting）也是一种重要的内置运算。要对行或列索引进行排序（按字典顺序），可使用 sort_index 方法，它将返回一个已排序的新对象：
+根据条件对数据集排序（sorting）也是一种重要的内置运算。要对行或列索引进行排序（按字典顺序），可使用`sort_index`方法，它将返回一个已排序的新对象：
 ```python
 In [201]: obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
 
@@ -1424,7 +1424,7 @@ three  0  3  2  1
 one    4  7  6  5
 ```
 
-若要按值对`Series`进行排序，可使用其 sort_values 方法：
+若要按值对`Series`进行排序，可使用其`sort_values`方法：
 ```python
 In [207]: obj = pd.Series([4, 7, -3, 2])
 
@@ -1452,7 +1452,7 @@ Out[210]:
 dtype: float64
 ```
 
-当排序一个`DataFrame`时，你可能希望根据一个或多个列中的值进行排序。将一个或多个列的名字传递给 sort_values 的 by 选项即可达到该目的：
+当排序一个`DataFrame`时，你可能希望根据一个或多个列中的值进行排序。将一个或多个列的名字传递给`sort_values`的`by`选项即可达到该目的：
 ```python
 In [211]: frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
 
@@ -1484,7 +1484,7 @@ Out[214]:
 1  1  7
 ```
 
-排名会从 1 开始一直到数组中有效数据的数量。接下来介绍`Series`和`DataFrame`的 rank 方法。默认情况下，rank 是通过“为各组分配一个平均排名”的方式破坏平级关系的：
+排名会从 1 开始一直到数组中有效数据的数量。接下来介绍`Series`和`DataFrame`的`rank`方法。默认情况下，`rank`是通过“为各组分配一个平均排名”的方式破坏平级关系的：
 ```python
 In [215]: obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
 In [216]: obj.rank()
@@ -1530,7 +1530,7 @@ Out[218]:
 dtype: float64
 ```
 
-表 5-6 列出了所有用于破坏平级关系的 method 选项。`DataFrame`可以在行或列上计算排名：
+表 5-6 列出了所有用于破坏平级关系的`method`选项。`DataFrame`可以在行或列上计算排名：
 ```python
 In [219]: frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
    .....:                       'c': [-2, 5, 8, -2.5]})
@@ -1555,7 +1555,7 @@ Out[221]:
 ![表 5-6 排名时用于破坏平级关系的方法](img/7178691-7edfab5b4a147581.png)
 
 ## 带有重复标签的轴索引
-直到目前为止，我所介绍的所有范例都有着唯一的轴标签（索引值）。虽然许多 pandas 函数（如 reindex）都要求标签唯一，但这并不是强制性的。我们来看看下面这个简单的带有重复索引值的`Series`：
+直到目前为止，我所介绍的所有范例都有着唯一的轴标签（索引值）。虽然许多 pandas 函数（如`reindex`）都要求标签唯一，但这并不是强制性的。我们来看看下面这个简单的带有重复索引值的`Series`：
 ```python
 In [222]: obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
 
@@ -1569,7 +1569,7 @@ c    4
 dtype: int64
 ```
 
-索引的 is_unique 属性可以告诉你它的值是否是唯一的：
+索引的`is_unique`属性可以告诉你它的值是否是唯一的：
 ```python
 In [224]: obj.index.is_unique
 Out[224]: False
@@ -1609,7 +1609,7 @@ b  0.476985  3.248944 -1.021228
 ```
 
 # 5.3 汇总和计算描述统计
-pandas 对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计，用于从`Series`中提取单个值（如 sum 或 mean）或从`DataFrame`的行或列中提取一个`Series`。跟对应的 NumPy 数组方法相比，它们都是基于没有缺失数据的假设而构建的。看一个简单的`DataFrame`：
+pandas 对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计，用于从`Series`中提取单个值（如`sum`或`mean`）或从`DataFrame`的行或列中提取一个`Series`。跟对应的 NumPy 数组方法相比，它们都是基于没有缺失数据的假设而构建的。看一个简单的`DataFrame`：
 ```python
 In [230]: df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
    .....:                    [np.nan, np.nan], [0.75, -1.3]],
@@ -1625,7 +1625,7 @@ c   NaN  NaN
 d  0.75 -1.3
 ```
 
-调用`DataFrame`的 sum 方法将会返回一个含有列的和的`Series`：
+调用`DataFrame`的`sum`方法将会返回一个含有列的和的`Series`：
 ```python
 In [232]: df.sum()
 Out[232]: 
@@ -1634,7 +1634,7 @@ two   -5.80
 dtype: float64
 ```
 
-传入 axis='columns'或 axis=1 将会按行进行求和运算：
+传入`axis='columns'`或`axis=1`将会按行进行求和运算：
 ```python
 In [233]: df.sum(axis=1)
 Out[233]:
@@ -1644,7 +1644,7 @@ c     NaN
 d   -0.55
 ```
 
-NA 值会自动被排除，除非整个切片（这里指的是行或列）都是 NA。通过 skipna 选项可以禁用该功能：
+NA 值会自动被排除，除非整个切片（这里指的是行或列）都是 NA。通过`skipna`选项可以禁用该功能：
 ```python
 In [234]: df.mean(axis='columns', skipna=False)
 Out[234]: 
@@ -1659,7 +1659,7 @@ dtype: float64
 
 ![](img/7178691-af35e3809278410e.jpg)
 
-有些方法（如 idxmin 和 idxmax）返回的是间接统计（比如达到最小值或最大值的索引）：
+有些方法（如`idxmin`和`idxmax`）返回的是间接统计（比如达到最小值或最大值的索引）：
 ```python
 In [235]: df.idxmax()
 Out[235]: 
@@ -1679,7 +1679,7 @@ c   NaN  NaN
 d  9.25 -5.8
 ```
 
-还有一种方法，它既不是约简型也不是累计型。describe 就是一个例子，它用于一次性产生多个汇总统计：
+还有一种方法，它既不是约简型也不是累计型。`describe`就是一个例子，它用于一次性产生多个汇总统计：
 ```python
 In [237]: df.describe()
 Out[237]: 
@@ -1694,7 +1694,7 @@ min    0.750000 -4.500000
 max    7.100000 -1.300000
 ```
 
-对于非数值型数据，describe 会产生另外一种汇总统计：
+对于非数值型数据，`describe`会产生另外一种汇总统计：
 ```python
 In [238]: obj = pd.Series(['a', 'a', 'b', 'c'] * 4)
 
@@ -1712,12 +1712,12 @@ dtype: object
 ![](img/7178691-11fa967f658ac314.jpg)
 
 ## 相关系数与协方差
-有些汇总统计（如相关系数和协方差）是通过参数对计算出来的。我们来看几个`DataFrame`，它们的数据来自 Yahoo!Finance 的股票价格和成交量，使用的是 pandas-datareader 包（可以用 conda 或 pip 安装）：
+有些汇总统计（如相关系数和协方差）是通过参数对计算出来的。我们来看几个`DataFrame`，它们的数据来自 Yahoo!Finance 的股票价格和成交量，使用的是`pandas-datareader`包（可以用`conda`或`pip`安装）：
 ```python
 conda install pandas-datareader
 ```
 
-我使用 pandas_datareader 模块下载了一些股票数据：
+我使用`pandas_datareader`模块下载了一些股票数据：
 ```python
 import pandas_datareader.data as web
 all_data = {ticker: web.get_data_yahoo(ticker)
@@ -1729,7 +1729,7 @@ volume = pd.DataFrame({ticker: data['Volume']
                       for ticker, data in all_data.items()})
 ```
 
-> 注意：此时 Yahoo! Finance 已经不存在了，因为 2017 年 Yahoo!被 Verizon 收购了。参阅 pandas-datareader 文档，可以学习最新的功能。
+> 注意：此时 Yahoo! Finance 已经不存在了，因为 2017 年 Yahoo! 被 Verizon 收购了。参阅`pandas-datareader`文档，可以学习最新的功能。
 
 现在计算价格的百分数变化，时间序列的操作会在第 11 章介绍：
 ```python
@@ -1746,7 +1746,7 @@ Date
 2016-10-21 -0.003930  0.003011 -0.012474  0.042096
 ```
 
-`Series`的 corr 方法用于计算两个`Series`中重叠的、非 NA 的、按索引对齐的值的相关系数。与此类似，cov 用于计算协方差：
+`Series`的`corr`方法用于计算两个`Series`中重叠的、非 NA 的、按索引对齐的值的相关系数。与此类似，`cov`用于计算协方差：
 ```python
 In [244]: returns['MSFT'].corr(returns['IBM'])
 Out[244]: 0.49976361144151144
@@ -1755,13 +1755,13 @@ In [245]: returns['MSFT'].cov(returns['IBM'])
 Out[245]: 8.8706554797035462e-05
 ```
 
-因为 MSTF 是一个合理的 Python 属性，我们还可以用更简洁的语法选择列：
+因为`MSTF`是一个合理的 Python 属性，我们还可以用更简洁的语法选择列：
 ```python
 In [246]: returns.MSFT.corr(returns.IBM)
 Out[246]: 0.49976361144151144
 ```
 
-另一方面，`DataFrame`的 corr 和 cov 方法将以`DataFrame`的形式分别返回完整的相关系数或协方差矩阵：
+另一方面，`DataFrame`的`corr`和`cov`方法将以`DataFrame`的形式分别返回完整的相关系数或协方差矩阵：
 ```python
 In [247]: returns.corr()
 Out[247]: 
@@ -1780,7 +1780,7 @@ IBM   0.000078  0.000078  0.000146  0.000089
 MSFT  0.000095  0.000108  0.000089  0.000215
 ```
 
-利用`DataFrame`的 corrwith 方法，你可以计算其列或行跟另一个`Series`或`DataFrame`之间的相关系数。传入一个`Series`将会返回一个相关系数值`Series`（针对各列进行计算）：
+利用`DataFrame`的`corrwith`方法，你可以计算其列或行跟另一个`Series`或`DataFrame`之间的相关系数。传入一个`Series`将会返回一个相关系数值`Series`（针对各列进行计算）：
 ```python
 In [249]: returns.corrwith(returns.IBM)
 Out[249]: 
@@ -1802,7 +1802,7 @@ MSFT   -0.092950
 dtype: float64
 ```
 
-传入 axis='columns'即可按行进行计算。无论如何，在计算相关系数之前，所有的数据项都会按标签对齐。
+传入`axis='columns'`即可按行进行计算。无论如何，在计算相关系数之前，所有的数据项都会按标签对齐。
 
 ## 唯一值、值计数以及成员资格
 还有一类方法可以从一维`Series`的值中抽取信息。看下面的例子：
@@ -1810,7 +1810,7 @@ dtype: float64
 In [251]: obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
 ```
 
-第一个函数是 unique，它可以得到`Series`中的唯一值数组：
+第一个函数是`unique`，它可以得到`Series`中的唯一值数组：
 ```python
 In [252]: uniques = obj.unique()
 
@@ -1818,7 +1818,7 @@ In [253]: uniques
 Out[253]: array(['c', 'a', 'd', 'b'], dtype=object)
 ```
 
-返回的唯一值是未排序的，如果需要的话，可以对结果再次进行排序（uniques.sort()）。相似的，value_counts 用于计算一个`Series`中各值出现的频率：
+返回的唯一值是未排序的，如果需要的话，可以对结果再次进行排序（`uniques.sort()`）。相似的，`value_counts`用于计算一个`Series`中各值出现的频率：
 ```python
 In [254]: obj.value_counts()
 Out[254]: 
@@ -1829,7 +1829,7 @@ d    1
 dtype: int64
 ```
 
-为了便于查看，结果`Series`是按值频率降序排列的。value_counts 还是一个顶级 pandas 方法，可用于任何数组或序列：
+为了便于查看，结果`Series`是按值频率降序排列的。`value_counts`还是一个顶级 pandas 方法，可用于任何数组或序列：
 ```python
 In [255]: pd.value_counts(obj.values, sort=False)
 Out[255]: 
@@ -1840,7 +1840,7 @@ d    1
 dtype: int64
 ```
 
-isin 用于判断矢量化集合的成员资格，可用于过滤`Series`中或`DataFrame`列中数据的子集：
+`isin`用于判断矢量化集合的成员资格，可用于过滤`Series`中或`DataFrame`列中数据的子集：
 ```python
 In [256]: obj
 Out[256]: 
@@ -1880,7 +1880,7 @@ Out[259]:
 dtype: object
 ```
 
-与 isin 类似的是 Index.get_indexer 方法，它可以给你一个索引数组，从可能包含重复值的数组到另一个不同值的数组：
+与`isin`类似的是`Index.get_indexer`方法，它可以给你一个索引数组，从可能包含重复值的数组到另一个不同值的数组：
 ```python
 In [260]: to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a'])
 
@@ -1910,7 +1910,7 @@ Out[264]:
 4    4    3    4
 ```
 
-将`pandas.value_counts`传给该`DataFrame`的 apply 函数，就会出现：
+将`pandas.value_counts`传给该`DataFrame`的`apply`函数，就会出现：
 ```python
 In [265]: result = data.apply(pd.value_counts).fillna(0)
 
-- 
GitLab