2021-01-01 13:17:43

docs/11.md

@@ -150,7 +150,7 @@ Out[38]: array([False, False,  True], dtype=bool)
 
 NaT（Not a Time）是 pandas 中时间戳数据的 null 值。
 
->注意：dateutil.parser 是一个实用但不完美的工具。比如说，它会把一些原本不是日期的字符串认作是日期（比如"42"会被解析为 2042 年的今天）。
+> 注意：dateutil.parser 是一个实用但不完美的工具。比如说，它会把一些原本不是日期的字符串认作是日期（比如"42"会被解析为 2042 年的今天）。
 
 datetime 对象还有一些特定于当前环境（位于不同国家或使用不同语言的系统）的格式化选项。例如，德语或法语系统所用的月份简写就与英语系统所用的不同。表 11-3 进行了总结。
 
@@ -926,7 +926,7 @@ DatetimeIndex(['2012-03-09 09:30:00+08:00', '2012-03-10 09:30:00+08:00',
               dtype='datetime64[ns, Asia/Shanghai]', freq='D')
 ```
 
->注意：对单纯时间戳的本地化操作还会检查夏令时转变期附近容易混淆或不存在的时间。
+> 注意：对单纯时间戳的本地化操作还会检查夏令时转变期附近容易混淆或不存在的时间。
 
 ## 操作时区意识型 Timestamp 对象
 

docs/12.md

@@ -318,7 +318,7 @@ GroupBy 使用分类操作明显更快，是因为底层的算法使用整数编
 
 ## 分类方法
 
-包含分类数据的`Series`有一些特殊的方法，类似于`Series`.str 字符串方法。它还提供了方便的分类和编码的使用方法。看下面的`Series`：
+包含分类数据的`Series`有一些特殊的方法，类似于`Series.str`字符串方法。它还提供了方便的分类和编码的使用方法。看下面的`Series`：
 ```python
 In [60]: s = pd.Series(['a', 'b', 'c', 'd'] * 2)
 

docs/13.md

@@ -224,7 +224,7 @@ DesignMatrix with shape (5, 2)
     'x1' (column 1)
 ```
 
-Patsy 对象可以直接传递到算法（比如`numpy.linalg`.lstsq）中，它执行普通最小二乘回归：
+Patsy 对象可以直接传递到算法（比如`numpy.linalg.lstsq`）中，它执行普通最小二乘回归：
 ```python
 In [38]: coef, resid, _, _ = np.linalg.lstsq(X, y)
 ```
@@ -478,7 +478,7 @@ statsmodels 包含的模型有：
 - 时间序列过程和状态空间模型
 - 广义矩估计
 
-下面，我会使用一些基本的 statsmodels 工具，探索 Patsy 公式和 pandas`DataFrame`对象如何使用模型接口。
+下面，我会使用一些基本的 statsmodels 工具，探索 Patsy 公式和 pandas `DataFrame`对象如何使用模型接口。
 
 ## 估计线性模型
 

docs/14.md

@@ -461,7 +461,7 @@ In [67]: results2 = count_subset.total / g.total.transform('sum')
 
 GroupLens Research（http://www.grouplens.org/node/73）采集了一组从 20 世纪 90 年末到 21 世纪初由 MovieLens 用户提供的电影评分数据。这些数据中包括电影评分、电影元数据（风格类型和年代）以及关于用户的人口统计学数据（年龄、邮编、性别和职业等）。基于机器学习算法的推荐系统一般都会对此类数据感兴趣。虽然我不会在本书中详细介绍机器学习技术，但我会告诉你如何对这种数据进行切片切块以满足实际需求。
 
-MovieLens 1M 数据集含有来自 6000 名用户对 4000 部电影的 100 万条评分数据。它分为三个表：评分、用户信息和电影信息。将该数据从 zip 文件中解压出来之后，可以通过`pandas.read_table`将各个表分别读到一个 pandas`DataFrame`对象中：
+MovieLens 1M 数据集含有来自 6000 名用户对 4000 部电影的 100 万条评分数据。它分为三个表：评分、用户信息和电影信息。将该数据从 zip 文件中解压出来之后，可以通过`pandas.read_table`将各个表分别读到一个 pandas `DataFrame`对象中：
 ```python
 import pandas as pd
 

docs/3.md

@@ -355,7 +355,7 @@ In [72]: c
 Out[72]: [1, 2, 2, 2, 3, 4, 6, 7]
 ```
 
->注意：``bisect``模块不会检查列表是否已排好序，进行检查的话会耗费大量计算。因此，对未排序的列表使用``bisect``不会产生错误，但结果不一定正确。
+> 注意：``bisect``模块不会检查列表是否已排好序，进行检查的话会耗费大量计算。因此，对未排序的列表使用``bisect``不会产生错误，但结果不一定正确。
 
 ## 切片
 用切边可以选取大多数序列类型的一部分，切片的基本形式是在方括号中使用``start:stop``：
@@ -981,7 +981,7 @@ In [170]: print(a)
 []
 ```
 
->注意：我常常建议人们不要频繁使用`global`关键字。因为全局变量一般是用于存放系统的某些状态的。如果你发现自己用了很多，那可能就说明得要来点儿面向对象编程了（即使用类）。
+> 注意：我常常建议人们不要频繁使用`global`关键字。因为全局变量一般是用于存放系统的某些状态的。如果你发现自己用了很多，那可能就说明得要来点儿面向对象编程了（即使用类）。
 
 ## 返回多个值
 在我第一次用 Python 编程时（之前已经习惯了 Java 和 C++），最喜欢的一个功能是：函数可以返回多个值。下面是一个简单的例子：

docs/4.md

@@ -162,7 +162,7 @@ array([[[ 0.,  0.],
         [ 0.,  0.]]])
 ```
 
->注意：认为`np.empty`会返回全 0 数组的想法是不安全的。很多情况下（如前所示），它返回的都是一些未初始化的垃圾值。
+> 注意：认为`np.empty`会返回全 0 数组的想法是不安全的。很多情况下（如前所示），它返回的都是一些未初始化的垃圾值。
 
 `arange`是 Python 内置函数`range`的数组版：
 ```python
@@ -228,7 +228,7 @@ In [45]: numeric_strings.astype(float)
 Out[45]: array([  1.25,  -9.6 ,  42.  ])
 ```
 
->注意：使用`numpy.string_`类型时，一定要小心，因为 NumPy 的字符串数据是大小固定的，发生截取时，不会发出警告。pandas 提供了更多非数值数据的便利的处理方法。
+> 注意：使用`numpy.string_`类型时，一定要小心，因为 NumPy 的字符串数据是大小固定的，发生截取时，不会发出警告。pandas 提供了更多非数值数据的便利的处理方法。
 
 如果转换过程因为某种原因而失败了（比如某个不能被转换为`float64`的字符串），就会引发一个`ValueError`。这里，我比较懒，写的是`float`而不是`np.float64`；NumPy 很聪明，它会将 Python 类型映射到等价的`dtype`上。
 
@@ -354,7 +354,7 @@ Out[71]: array([ 0,  1,  2,  3,  4, 64, 64, 64,  8,  9])
 
 如果你刚开始接触 NumPy，可能会对此感到惊讶（尤其是当你曾经用过其他热衷于复制数组数据的编程语言）。由于 NumPy 的设计目的是处理大数据，所以你可以想象一下，假如 NumPy 坚持要将数据复制来复制去的话会产生何等的性能和内存问题。
 
->注意：如果你想要得到的是`ndarray`切片的一份副本而非视图，就需要明确地进行复制操作，例如``arr[5:8].copy()``。
+> 注意：如果你想要得到的是`ndarray`切片的一份副本而非视图，就需要明确地进行复制操作，例如``arr[5:8].copy()``。
 
 对于高维度数组，能做的事情更多。在一个二维数组中，各索引位置上的元素不再是标量而是一维数组：
 ```python
@@ -557,7 +557,7 @@ array([[ 0.0929,  0.2817,  0.769 ,  1.2464],
        [ 1.669 , -0.4386, -0.5397,  0.477 ]])
 ```
 
->注意：如果布尔型数组的长度不对，布尔型选择就会出错，因此一定要小心。
+> 注意：如果布尔型数组的长度不对，布尔型选择就会出错，因此一定要小心。
 
 下面的例子，我选取了``names == 'Bob'``的行，并索引了列：
 ```python
@@ -614,7 +614,7 @@ array([[ 0.0929,  0.2817,  0.769 ,  1.2464],
 
 通过布尔型索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样的数组也是如此。
 
->注意：Python 关键字`and`和`or`在布尔型数组中无效。要使用`&`与`|`。
+> 注意：Python 关键字`and`和`or`在布尔型数组中无效。要使用`&`与`|`。
 
 通过布尔型数组设置值是一种经常用到的手段。为了将`data`中的所有负值都设置为 0，我们只需：
 ```python
@@ -1336,7 +1336,7 @@ In [243]: %timeit np.random.normal(size=N)
 In [244]: np.random.seed(1234)
 ```
 
-numpy.random 的数据生成函数使用了全局的随机种子。要避免全局状态，你可以使用`numpy.random`.RandomState，创建一个与其它隔离的随机数生成器：
+`numpy.random`的数据生成函数使用了全局的随机种子。要避免全局状态，你可以使用`numpy.random.RandomState`，创建一个与其它隔离的随机数生成器：
 ```python
 In [245]: rng = np.random.RandomState(1234)
 
@@ -1353,9 +1353,9 @@ array([ 0.4714, -1.191 ,  1.4327, -0.3127, -0.7206,  0.8872,  0.8596,
 ![](img/7178691-6ed04fae3d1178e2.png)
 
 # 4.7 示例：随机漫步
-我们通过模拟随机漫步来说明如何运用数组运算。先来看一个简单的随机漫步的例子：从 0 开始，步长 1 和－1 出现的概率相等。
+我们通过模拟随机漫步来说明如何运用数组运算。先来看一个简单的随机漫步的例子：从 0 开始，步长 1 和 -1 出现的概率相等。
 
-下面是一个通过内置的 random 模块以纯 Python 的方式实现 1000 步的随机漫步：
+下面是一个通过内置的`random`模块以纯 Python 的方式实现 1000 步的随机漫步：
 ```python
 In [247]: import random
    .....: position = 0
@@ -1375,7 +1375,7 @@ In [249]: plt.plot(walk[:100])
 
 ![图 4-4 简单的随机漫步](img/7178691-0833621694f6dda0.png)
 
-不难看出，这其实就是随机漫步中各步的累计和，可以用一个数组运算来实现。因此，我用`np.random`模块一次性随机产生 1000 个“掷硬币”结果（即两个数中任选一个），将其分别设置为 1 或－1，然后计算累计和：
+不难看出，这其实就是随机漫步中各步的累计和，可以用一个数组运算来实现。因此，我用`np.random`模块一次性随机产生 1000 个“掷硬币”结果（即两个数中任选一个），将其分别设置为 1 或 -1，然后计算累计和：
 ```python
 In [251]: nsteps = 1000
 
@@ -1395,13 +1395,13 @@ In [256]: walk.max()
 Out[256]: 31
 ```
 
-现在来看一个复杂点的统计任务——首次穿越时间，即随机漫步过程中第一次到达某个特定值的时间。假设我们想要知道本次随机漫步需要多久才能距离初始 0 点至少 10 步远（任一方向均可）。`np.abs`(walk)>=10 可以得到一个布尔型数组，它表示的是距离是否达到或超过 10，而我们想要知道的是第一个 10 或－10 的索引。可以用 argmax 来解决这个问题，它返回的是该布尔型数组第一个最大值的索引（True 就是最大值）：
+现在来看一个复杂点的统计任务——首次穿越时间，即随机漫步过程中第一次到达某个特定值的时间。假设我们想要知道本次随机漫步需要多久才能距离初始 0 点至少 10 步远（任一方向均可）。`np.abs(walk)>=10`可以得到一个布尔型数组，它表示的是距离是否达到或超过 10，而我们想要知道的是第一个 10 或 -10 的索引。可以用`argmax`来解决这个问题，它返回的是该布尔型数组第一个最大值的索引（`True`就是最大值）：
 ```python
 In [257]: (np.abs(walk) >= 10).argmax()
 Out[257]: 37
 ```
 
-注意，这里使用 argmax 并不是很高效，因为它无论如何都会对数组进行完全扫描。在本例中，只要发现了一个 True，那我们就知道它是个最大值了。
+注意，这里使用`argmax`并不是很高效，因为它无论如何都会对数组进行完全扫描。在本例中，只要发现了一个`True`，那我们就知道它是个最大值了。
 
 ## 一次模拟多个随机漫步
 如果你希望模拟多个随机漫步过程（比如 5000 个），只需对上面的代码做一点点修改即可生成所有的随机漫步过程。只要给`numpy.random`的函数传入一个二元元组就可以产生一个二维数组，然后我们就可以一次性计算 5000 个随机漫步过程（一行一个）的累计和了：
@@ -1436,7 +1436,7 @@ In [265]: walks.min()
 Out[265]: -133
 ```
 
-得到这些数据之后，我们来计算 30 或－30 的最小穿越时间。这里稍微复杂些，因为不是 5000 个过程都到达了 30。我们可以用 any 方法来对此进行检查：
+得到这些数据之后，我们来计算 30 或 -30 的最小穿越时间。这里稍微复杂些，因为不是 5000 个过程都到达了 30。我们可以用`any`方法来对此进行检查：
 ```python
 In [266]: hits30 = (np.abs(walks) >= 30).any(1)
 
@@ -1447,7 +1447,7 @@ In [268]: hits30.sum() # Number that hit 30 or -30
 Out[268]: 3410
 ```
 
-然后我们利用这个布尔型数组选出那些穿越了 30（绝对值）的随机漫步（行），并调用 argmax 在轴 1 上获取穿越时间：
+然后我们利用这个布尔型数组选出那些穿越了 30（绝对值）的随机漫步（行），并调用`argmax`在轴 1 上获取穿越时间：
 ```python
 In [269]: crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)
 
@@ -1455,7 +1455,7 @@ In [270]: crossing_times.mean()
 Out[270]: 498.88973607038122
 ```
 
-请尝试用其他分布方式得到漫步数据。只需使用不同的随机数生成函数即可，如 normal 用于生成指定均值和标准差的正态分布数据：
+请尝试用其他分布方式得到漫步数据。只需使用不同的随机数生成函数即可，如`normal`用于生成指定均值和标准差的正态分布数据：
 ```python
 In [271]: steps = np.random.normal(loc=0, scale=0.25,
    .....:                          size=(nwalks, nsteps))

docs/5.md

@@ -33,7 +33,7 @@ Out[12]:
 dtype: int64
 ```
 
-`Series`的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引，于是会自动创建一个 0 到 N-1（N 为数据的长度）的整数型索引。你可以通过`Series`的 values 和 index 属性获取其数组表示形式和索引对象：
+`Series`的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引，于是会自动创建一个 0 到`N-1`（`N`为数据的长度）的整数型索引。你可以通过`Series`的`values`和`index`属性获取其数组表示形式和索引对象：
 ```python
 In [13]: obj.values
 Out[13]: array([ 4,  7, -5,  3])
@@ -140,9 +140,9 @@ Texas         71000.0
 dtype: float64
 ```
 
-在这个例子中，sdata 中跟 states 索引相匹配的那 3 个值会被找出来并放到相应的位置上，但由于"California"所对应的 sdata 值找不到，所以其结果就为 NaN（即“非数字”（not a number），在 pandas 中，它用于表示缺失或 NA 值）。因为‘Utah’不在 states 中，它被从结果中除去。
+在这个例子中，`sdata`中跟`states`索引相匹配的那 3 个值会被找出来并放到相应的位置上，但由于`"California"`所对应的`sdata`值找不到，所以其结果就为`NaN`（即“非数字”（not a number），在 pandas 中，它用于表示缺失或 NA 值）。因为`Utah`不在`states`中，它被从结果中除去。
 
-我将使用缺失（missing）或 NA 表示缺失数据。pandas 的 isnull 和 notnull 函数可用于检测缺失数据：
+我将使用缺失（missing）或 NA 表示缺失数据。pandas 的`isnull`和`notnull`函数可用于检测缺失数据：
 ```python
 In [32]: pd.isnull(obj4)
 Out[32]: 
@@ -202,9 +202,9 @@ Utah               NaN
 dtype: float64
 ```
 
-数据对齐功能将在后面详细讲解。如果你使用过数据库，你可以认为是类似 join 的操作。
+数据对齐功能将在后面详细讲解。如果你使用过数据库，你可以认为是类似`join`的操作。
 
-`Series`对象本身及其索引都有一个 name 属性，该属性跟 pandas 其他的关键功能关系非常密切：
+`Series`对象本身及其索引都有一个`name`属性，该属性跟 pandas 其他的关键功能关系非常密切：
 ```python
 In [38]: obj4.name = 'population'
 
@@ -267,9 +267,9 @@ Out[45]:
 5  3.2  Nevada  2003
 ```
 
-如果你使用的是 Jupyter 笔记本，pandas`DataFrame`对象会以对浏览器友好的 HTML 表格的方式呈现。
+如果你使用的是 Jupyter 笔记本，pandas `DataFrame`对象会以对浏览器友好的 HTML 表格的方式呈现。
 
-对于特别大的`DataFrame`，head 方法会选取前五行：
+对于特别大的`DataFrame`，`head`方法会选取前五行：
 ```python
 In [46]: frame.head()
 Out[46]: 
@@ -337,12 +337,12 @@ six      2003
 Name: year, dtype: int64
 ```
 
-> 笔记：IPython 提供了类似属性的访问（即 frame2.year）和`Tab`补全。
-frame2[column]适用于任何列的名，但是 frame2.column 只有在列名是一个合理的 Python 变量名时才适用。
+> 笔记：IPython 提供了类似属性的访问（即`frame2.year`）和`Tab`补全。
+`frame2[column]`适用于任何列的名，但是`frame2.column`只有在列名是一个合理的 Python 变量名时才适用。
 
-注意，返回的`Series`拥有原`DataFrame`相同的索引，且其 name 属性也已经被相应地设置好了。
+注意，返回的`Series`拥有原`DataFrame`相同的索引，且其`name`属性也已经被相应地设置好了。
 
-行也可以通过位置或名称的方式进行获取，比如用 loc 属性（稍后将对此进行详细讲解）：
+行也可以通过位置或名称的方式进行获取，比如用`loc`属性（稍后将对此进行详细讲解）：
 ```python
 In [53]: frame2.loc['three']
 Out[53]: 
@@ -397,9 +397,9 @@ five   2002  Nevada  2.9  -1.7
 six    2003  Nevada  3.2   NaN
 ```
 
-为不存在的列赋值会创建出一个新列。关键字 del 用于删除列。
+为不存在的列赋值会创建出一个新列。关键字`del`用于删除列。
 
-作为 del 的例子，我先添加一个新的布尔值的列，state 是否为'Ohio'：
+作为`del`的例子，我先添加一个新的布尔值的列，`state`是否为`'Ohio'`：
 ```python
 In [61]: frame2['eastern'] = frame2.state == 'Ohio'
 
@@ -414,7 +414,7 @@ five   2002  Nevada  2.9  -1.7    False
 six    2003  Nevada  3.2   NaN    False
 ```
 
->注意：不能用 frame2.eastern 创建新的列。
+> 注意：不能用`frame2.eastern`创建新的列。
 
 del 方法可以用来删除这列：
 ```python
@@ -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
@@ -552,7 +552,7 @@ In [84]: obj2.index is labels
 Out[84]: True
 ```
 
->注意：虽然用户不需要经常使用 Index 的功能，但是因为一些操作会生成包含被索引化的数据，理解它们的工作原理是很重要的。
+> 注意：虽然用户不需要经常使用 Index 的功能，但是因为一些操作会生成包含被索引化的数据，理解它们的工作原理是很重要的。
 
 除了类似于数组，Index 的功能也类似一个固定大小的集合：
 ```python
@@ -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

docs/6.md

@@ -702,7 +702,7 @@ Out[90]:
 2  9  10  11  12     foo
 ```
 
->注意：pickle 仅建议用于短期存储格式。其原因是很难保证该格式永远是稳定的；今天 pickle 的对象可能无法被后续版本的库 unpickle 出来。虽然我尽力保证这种事情不会发生在 pandas 中，但是今后的某个时候说不定还是得“打破”该 pickle 格式。
+> 注意：pickle 仅建议用于短期存储格式。其原因是很难保证该格式永远是稳定的；今天 pickle 的对象可能无法被后续版本的库 unpickle 出来。虽然我尽力保证这种事情不会发生在 pandas 中，但是今后的某个时候说不定还是得“打破”该 pickle 格式。
 
 pandas 内置支持两个二进制数据格式：HDF5 和 MessagePack。下一节，我会给出几个 HDF5 的例子，但我建议你尝试下不同的文件格式，看看它们的速度以及是否适合你的分析工作。pandas 或 NumPy 数据的其它存储格式有：
 
@@ -793,7 +793,7 @@ Out[102]:
 
 如果需要本地处理海量数据，我建议你好好研究一下 PyTables 和 h5py，看看它们能满足你的哪些需求。。由于许多数据分析问题都是 IO 密集型（而不是 CPU 密集型），利用 HDF5 这样的工具能显著提升应用程序的效率。
 
->注意：HDF5 不是数据库。它最适合用作“一次写多次读”的数据集。虽然数据可以在任何时候被添加到文件中，但如果同时发生多个写操作，文件就可能会被破坏。
+> 注意：HDF5 不是数据库。它最适合用作“一次写多次读”的数据集。虽然数据可以在任何时候被添加到文件中，但如果同时发生多个写操作，文件就可能会被破坏。
 
 ## 读取 Microsoft Excel 文件
 

docs/7.md

@@ -700,7 +700,7 @@ Out[95]:
 Name: 2, dtype: float64
 ```
 
-要选出全部含有“超过 3 或－3 的值”的行，你可以在布尔型`DataFrame`中使用 any 方法：
+要选出全部含有“超过 3 或 -3 的值”的行，你可以在布尔型`DataFrame`中使用 any 方法：
 ```python
 In [96]: data[(np.abs(data) > 3).any(1)]
 Out[96]: 
@@ -717,7 +717,7 @@ Out[96]:
 803 -3.645860  0.255475 -0.549574 -1.907459
 ```
 
-根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间－3 到 3 以内：
+根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间 -3 到 3 以内：
 ```python
 In [97]: data[np.abs(data) > 3] = np.sign(data) * 3
 
@@ -747,7 +747,7 @@ Out[99]:
 ```
 
 ## 排列和随机采样
-利用`numpy.random`.permutation 函数可以轻松实现对`Series`或`DataFrame`的列的排列工作（permuting，随机重排序）。通过需要排列的轴的长度调用 permutation，可产生一个表示新顺序的整数数组：
+利用`numpy.random.permutation`函数可以轻松实现对`Series`或`DataFrame`的列的排列工作（permuting，随机重排序）。通过需要排列的轴的长度调用 permutation，可产生一个表示新顺序的整数数组：
 ```python
 In [100]: df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
 
@@ -974,7 +974,7 @@ Out[133]:
 9           0           0           0           1           0
 ```
 
-我们用`numpy.random`.seed，使这个例子具有确定性。本书后面会介绍`pandas.get_dummies`。
+我们用`numpy.random.seed`，使这个例子具有确定性。本书后面会介绍`pandas.get_dummies`。
 
 # 7.3 字符串操作
 
@@ -1023,7 +1023,7 @@ In [143]: val.find(':')
 Out[143]: -1
 ```
 
-注意 find 和 index 的区别：如果找不到字符串，index 将会引发一个异常（而不是返回－1）：
+注意 find 和 index 的区别：如果找不到字符串，index 将会引发一个异常（而不是返回 -1）：
 ```python
 In [144]: val.index(':')
 ---------------------------------------------------------------------------

docs/8.md

@@ -132,7 +132,7 @@ b    1        6   7        8
      2        9  10       11
 ```
 
->注意：小心区分索引名 state、color 与行标签。
+> 注意：小心区分索引名 state、color 与行标签。
 
 有了部分列索引，因此可以轻松选取列分组：
 ```python
@@ -469,7 +469,7 @@ Out[53]:
 
 结果中会出现哪些键组合取决于所选的合并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。
 
->注意：在进行列－列连接时，`DataFrame`对象中的索引会被丢弃。
+> 注意：在进行列－列连接时，`DataFrame`对象中的索引会被丢弃。
 
 对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但 merge 有一个更实用的 suffixes 选项，用于指定附加到左右两个`DataFrame`对象的重叠列名上的字符串：
 ```python

docs/9.md

@@ -443,7 +443,7 @@ plot 属性包含一批不同绘图类型的方法。例如，df.plot()等价于
 
 ![表 9-4 专用于`DataFrame`的 plot 参数](img/7178691-96651ecaa90f1c68.png)
 
->注意： 有关时间序列的绘图，请见第 11 章。
+> 注意： 有关时间序列的绘图，请见第 11 章。
 
 ## 柱状图
 

docs/a.md

@@ -103,7 +103,7 @@ array([[0, 1, 2, 3],
        [4, 5, 6, 7]])
 ```
 
-作为参数的形状的其中一维可以是－1，它表示该维度的大小由数据本身推断而来：
+作为参数的形状的其中一维可以是 -1，它表示该维度的大小由数据本身推断而来：
 ```python
 In [22]: arr = np.arange(15)