2021-02-22 21:08:46

new/begin-ds-py-jupyter/0.md

@@ -6,11 +6,11 @@
 
 # 这本书涵盖的内容
 
-[第 1 课](1.html "Chapter 1. Jupyter Fundamentals")， *Jupyter 基础知识，*涵盖了 Jupyter 中的数据分析基础。 我们将从 Jupyter 的用法说明和功能入手，例如魔术功能和制表符补全。 然后，我们将过渡到特定于数据科学的材料。 我们将在实时 Jupyter Notebook 中进行探索性分析。 我们将使用视觉辅助，例如散点图，直方图和小提琴图，以加深我们对数据的理解。 我们还将执行简单的预测建模。
+第 1 课， “Jupyter 基础知识”，涵盖了 Jupyter 中的数据分析基础。 我们将从 Jupyter 的用法说明和功能入手，例如魔术功能和制表符补全。 然后，我们将过渡到特定于数据科学的材料。 我们将在实时 Jupyter Notebook 中进行探索性分析。 我们将使用视觉辅助，例如散点图，直方图和小提琴图，以加深我们对数据的理解。 我们还将执行简单的预测建模。
 
-[第 2 课](2.html "Chapter 2. Data Cleaning and Advanced Machine Learning")，*数据清理和高级机器学习*显示了如何在 Jupyter Notebook 中训练预测模型。 我们将讨论如何计划机器学习策略。 本课还说明了机器学习术语，例如监督学习，非监督学习，分类和回归。 我们将讨论使用 scikit-learn 和 pandas 预处理数据的方法。
+第 2 课，“数据清理和高级机器学习”显示了如何在 Jupyter Notebook 中训练预测模型。 我们将讨论如何计划机器学习策略。 本课还说明了机器学习术语，例如监督学习，非监督学习，分类和回归。 我们将讨论使用 scikit-learn 和 pandas 预处理数据的方法。
 
-[第 3 课](3.html "Chapter 3. Web Scraping and Interactive Visualizations")， *Web 抓取和交互式可视化*解释了如何剪贴网页表，然后使用交互式可视化来研究数据。 我们将首先研究 HTTP 请求的工作方式，重点是 GET 请求及其响应状态代码。 然后，我们将进入 Jupyter Notebook，并使用 Requests 库通过 Python 发出 HTTP 请求。 我们将看到 Jupyter 如何用于在笔记本中呈现 HTML 以及可以与之交互的实际网页。 发出请求后，我们将看到如何使用 Beautiful Soup 来解析 HTML 中的文本，并使用该库来刮擦表格数据。
+第 3 课， “Web 抓取和交互式可视化”解释了如何剪贴网页表，然后使用交互式可视化来研究数据。 我们将首先研究 HTTP 请求的工作方式，重点是 GET 请求及其响应状态代码。 然后，我们将进入 Jupyter Notebook，并使用 Requests 库通过 Python 发出 HTTP 请求。 我们将看到 Jupyter 如何用于在笔记本中呈现 HTML 以及可以与之交互的实际网页。 发出请求后，我们将看到如何使用 Beautiful Soup 来解析 HTML 中的文本，并使用该库来刮擦表格数据。
 
 # 这本书需要什么
 
@@ -33,7 +33,7 @@ Anaconda 安装随附的 Python 库：
 *   要求 2.18.4+
 *   beautifulsoup4 4.6.0+
 *   numpy 的 1.13.1+
-*   熊猫 0.20.3+
+*   Pandas 0.20.3+
 *   scikit 学习 0.19.0+
 *   Seaborn 0.8.0+
 *   散景 0.12.10+
@@ -90,7 +90,7 @@ Anaconda 安装随附的 Python 库：
 
 在本书中，您将找到许多可以区分不同类型信息的文本样式。 以下是这些样式的一些示例，并解释了其含义。
 
-文本中的代码字和 Python 语言关键字*如下所示：“使用新创建的空白 Notebook，单击顶部的单元格并键入`print('hello world')`”*
+文本中的代码字和 Python 语言关键字如下所示：“使用新创建的空白 Notebook，单击顶部的单元格并键入`print('hello world')`”
 
 文件夹名称，文件名，文件扩展名，路径名，包括文本中的文件名，如下所示：“头文件`boost/asio.hpp`包含使用 Asio 库所需的大多数类型和功能”。
 
@@ -102,7 +102,7 @@ del df['MEDV']
 df = pd.concat((y, df), axis=1)
 ```
 
-新术语和重要词以粗体显示。 您在屏幕上看到的字词，例如在菜单或对话框中的字样，如下所示：“单击右上角的 **New**，然后从下拉菜单中选择一个内核 。”
+新术语和重要词以粗体显示。 您在屏幕上看到的字词，例如在菜单或对话框中的字样，如下所示：“单击右上角的**新建**，然后从下拉菜单中选择一个内核 。”
 
 重要的新**编程术语**用粗体显示。 *概念术语*以斜体显示。
 

new/begin-ds-py-jupyter/2.md

@@ -200,7 +200,7 @@
 
     ![Explore data preprocessing tools and methods](img/image2_12.jpg)
 
-    通常，简单地降低`NaN`值通常不是最佳选择，因为丢失数据永远不会是一件好事，尤其是在仅丢失一小部分采样值的时。 熊猫提供了一种以多种不同方式填充`NaN`条目的方法，我们将在其中举例说明。
+    通常，简单地降低`NaN`值通常不是最佳选择，因为丢失数据永远不会是一件好事，尤其是在仅丢失一小部分采样值的时。 Pandas提供了一种以多种不同方式填充`NaN`条目的方法，我们将在其中举例说明。
 
 9.  运行包含`df.fillna?`的单元格以为 Pandas 的`NaN-fill`方法打印文档字符串：
 
@@ -375,7 +375,7 @@
 
 回想一下，如前所述，有效的分析技术可以产生有影响力的业务决策。 考虑到这一点，如果我们能够预测员工离职的可能性，那么业务可以有选择地针对这些员工进行特殊待遇。 例如，可以提高他们的薪水或减少他们的项目数量。 此外，可以使用模型估算这些变化的影响！
 
-为了评估该计划的有效性，让我们考虑一下我们的数据。 每行代表在公司工作或已离职的雇员，如名为**左**的列所标记。 因此，给定一组功能，我们可以训练一个模型来预测此目标。
+为了评估该计划的有效性，让我们考虑一下我们的数据。 每行代表在公司工作或已离职的雇员，如名为**剩余**的列所标记。 因此，给定一组功能，我们可以训练一个模型来预测此目标。
 
 评估目标变量。 通过运行以下代码来检查丢失条目的分布和数量：
 
@@ -723,7 +723,7 @@ k 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
 
     ![Training k-nearest neighbors fork-Nearest Neighborstraining our model](img/image2_47.jpg)
 
-    如我们所见，决策边界的波动性大大降低，蓝色的口袋也大大减少了。 1 类的准确性略低，但是我们需要使用更全面的方法（例如 k 倍交叉验证）来确定两个模型之间是否存在显着差异。
+    如我们所见，决策边界的波动性大大降低，蓝色的口袋也大大减少了。 1 类的准确性略低，但是我们需要使用更全面的方法（例如 K 折交叉验证）来确定两个模型之间是否存在显着差异。
 
     请注意，增加`n_neighbors`对训练时间没有影响，因为该模型只是存储数据。 但是，预测时间将受到很大影响。
 
@@ -781,7 +781,7 @@ k 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
 
 就是说，仅这样的数据分割训练模型还不够好。 数据中存在自然差异，这会导致准确性根据训练和测试分裂而有所不同（甚至略有不同）。 此外，仅使用一个训练/测试组来比较模型会导致对某些模型的偏见并导致过度拟合。
 
-**k 倍交叉验证**为提供了解决此问题的方法，并允许通过每次准确性计算中的误差估计来解决方差。 反过来，这自然会导致使用验证曲线来调整模型参数。 这些将精度绘制为超参数的函数，例如随机森林中使用的决策树数或最大深度。
+**K 折交叉验证**为提供了解决此问题的方法，并允许通过每次准确性计算中的误差估计来解决方差。 反过来，这自然会导致使用验证曲线来调整模型参数。 这些将精度绘制为超参数的函数，例如随机森林中使用的决策树数或最大深度。
 
 ### 注意
 
@@ -794,16 +794,16 @@ k 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
 k 折交叉验证算法如下：
 
 1.  将数据拆分为大小近似相等的 k 个“折叠”。
-2.  在不同的折叠组合上测试并训练`k`模型。 每个模型将包括 *k-1* 折叠训练数据，剩余的折叠用于测试。 在这种方法中，每个折叠最终仅被用作一次验证数据。
+2.  在不同的折叠组合上测试并训练`k`模型。 每个模型将包括`k-1`折叠训练数据，剩余的折叠用于测试。 在这种方法中，每个折叠最终仅被用作一次验证数据。
 3.  通过取`k`值的平均值来计算模型精度。 还计算标准偏差以在值上提供误差线。
 
-标准设置为 *k = 10* ，但如果使用大数据集，则应考虑使用`k`较小的值。
+标准设置为`k = 10`，但如果使用大数据集，则应考虑使用`k`较小的值。
 
 此验证方法可用于可靠地比较具有不同超参数（例如，SVM 的`C`参数或 KNN 分类器中最近邻居的数量）的模型性能。 它也适合比较完全不同的模型。
 
 一旦确定了*最佳模型*，应在整个数据集上对其进行重新训练，然后再用于预测实际分类。
 
-当使用 scikit-learn 实现此功能时，通常会使用略微改进的普通 k 倍算法的变体来代替。 这被称为**分层 k 倍**。 的改进之处在于，分层的 k 倍交叉验证可在折叠中大致维持类标签种群。 可以想象，这减少了模型的整体方差，并降低了高度不平衡的模型引起偏差的可能性。
+当使用 scikit-learn 实现此功能时，通常会使用略微改进的普通 K 折算法的变体来代替。 这被称为**分层 K 折**。 的改进之处在于，分层的 K 折交叉验证可在折叠中大致维持类标签种群。 可以想象，这减少了模型的整体方差，并降低了高度不平衡的模型引起偏差的可能性。
 
 **验证曲线**是训练和验证指标作为某些模型参数的函数的图。 它们使我们能够进行良好的模型参数选择。 在本书中，我们将使用准确性得分作为这些图的度量。
 
@@ -840,7 +840,7 @@ k 折交叉验证算法如下：
     clf = RandomForestClassifier(n_estimators=100, max_depth=5)
     ```
 
-4.  为了使用分层的 k 倍交叉验证来训练模型，我们将使用`model_selection.cross_val_score`函数。
+4.  为了使用分层的 K 折交叉验证来训练模型，我们将使用`model_selection.cross_val_score`函数。
 
     使用分层 k 折检验训练我们模型`clf`的 10 个变体。 请注意，默认情况下，scikit-learn 的`cross_val_score`会进行这种类型的验证。 运行包含以下代码的单元格：
 
@@ -868,7 +868,7 @@ k 折交叉验证算法如下：
 
     使用`cross_val_score`非常方便，但是并不能告诉我们每个类的精度。 我们可以使用`model_selection.StratifiedKFold`类手动完成此操作。 此类将折叠数作为初始化参数，然后使用 split 方法为数据构建随机采样的“掩码”。 掩码只是一个包含另一个数组中项目索引的数组，然后可以通过执行以下操作返回项目：`data[mask]`。
 
-6.  定义一个自定义类，以计算 k 倍交叉验证类的准确性。 运行包含以下代码的单元格：
+6.  定义一个自定义类，以计算 K 折交叉验证类的准确性。 运行包含以下代码的单元格：
 
     ```py
     from sklearn.model_selection import StratifiedKFold…
@@ -896,7 +896,7 @@ k 折交叉验证算法如下：
 
     现在我们可以看到每折的班级准确性！ 很整洁吧？
 
-8.  让我们继续展示如何使用`model_selection.validation_curve`来计算验证曲线。 此函数使用分层的 k 倍交叉验证来训练给定参数各种值的模型。
+8.  让我们继续展示如何使用`model_selection.validation_curve`来计算验证曲线。 此函数使用分层的 K 折交叉验证来训练给定参数各种值的模型。
 
     通过在`max_depth`值范围内训练随机森林，进行绘制验证曲线所需的计算。 运行包含以下代码的单元格：
 
@@ -925,7 +925,7 @@ k 折交叉验证算法如下：
 
     回想一下如何为决策树设置最大深度来限制过拟合的数量？ 这反映在验证曲线中，在该曲线中，我们看到右侧的较大最大深度值发生过拟合。 `max_depth`的一个好值似乎是`6`，在这里我们看到了训练和验证的准确性。 当`max_depth`等于`3`时，由于训练和验证精度较低，我们看到模型不适合数据。
 
-总而言之，我们已经学习并实现了两种重要的技术来构建可靠的预测模型。 第一种这样的技术是 k 倍交叉验证，该技术用于将数据拆分为各种训练/测试批次并产生设定的准确性。 然后，从这个集合中，我们计算出平均准确度和标准偏差作为误差的度量。 这很重要，因此我们可以衡量模型的可变性，并可以产生可信赖的准确性。
+总而言之，我们已经学习并实现了两种重要的技术来构建可靠的预测模型。 第一种这样的技术是 K 折交叉验证，该技术用于将数据拆分为各种训练/测试批次并产生设定的准确性。 然后，从这个集合中，我们计算出平均准确度和标准偏差作为误差的度量。 这很重要，因此我们可以衡量模型的可变性，并可以产生可信赖的准确性。
 
 我们还了解了另一种可以确保获得值得信赖的结果的技术：验证曲线。 这些使我们可以根据比较训练和验证准确性来可视化模型何时过度拟合。 通过在选定的超参数的范围内绘制曲线，我们可以确定其最佳值。
 
@@ -933,7 +933,7 @@ k 折交叉验证算法如下：
 
 ## 子主题 C：降维技术
 
-降维可以仅涉及从训练数据中删除不重要的特征，但是存在更多奇特的方法，例如**主成分分析**（**PCA**）和 **Linear 判别分析**（**LDA**）。 这些技术允许进行数据压缩，其中可以将仅来自大量特征的最重要信息编码为几个特征。
+降维可以仅涉及从训练数据中删除不重要的特征，但是存在更多奇特的方法，例如**主成分分析**（**PCA**）和**线性判别分析**（**LDA**）。 这些技术允许进行数据压缩，其中可以将仅来自大量特征的最重要信息编码为几个特征。
 
 在本子主题中，我们将重点介绍 PCA。 通过将投影到正交的“主成分”的新子空间中，该技术将其转换为数据，其中具有最高特征值的成分编码用于训练模型的最多信息。 然后，我们可以简单地选择一些主要成分来代替原始的高维数据集。 例如，PCA 可用于编码图像中每个像素的信息。 在这种情况下，原始特征空间的尺寸将等于图像中像素的数量。 然后，可以使用 PCA 来减少此高维空间，在该空间中，用于训练预测模型的大多数有用信息可能会减少到仅几个维。 这不仅可以节省训练和使用模型时的时间，还可以通过消除数据集中的噪声使它们表现更好。
 
@@ -950,7 +950,7 @@ k 折交叉验证算法如下：
 *   在标记的训练数据上进行有监督的学习
 *   具有两个类别标签的分类问题（二进制）
 
-尤其是，我们正在训练模型，以根据一系列连续和明确的特征来确定员工是否已离开公司。 在*活动 A* 和*中准备了用于机器学习的数据之后，准备训练员工保留问题*的预测模型，我们接着实现了 SVM，k 最近邻和随机 森林算法仅使用两个功能。 这些模型能够以超过 90％的总体准确性进行预测。 但是，在查看特定班级的准确性时，我们发现离职的员工（`class-label 1`）只能以 70-80％的准确度进行预测。 让我们看看可以通过利用全部功能空间将改进多少。
+尤其是，我们正在训练模型，以根据一系列连续和明确的特征来确定员工是否已离开公司。 在“活动 A”和“训练员工保留问题的预测模型”中准备了用于机器学习的数据之后，我们接着实现了 SVM，k 最近邻和随机 森林算法仅使用两个功能。 这些模型能够以超过 90％的总体准确性进行预测。 但是，在查看特定班级的准确性时，我们发现离职的员工（`class-label 1`）只能以 70-80％的准确度进行预测。 让我们看看可以通过利用全部功能空间将改进多少。
 
 1.  在`lesson-2-workbook.ipynb`笔记本中，向下滚动到该部分的代码。 我们应该已经从上一节中加载了预处理的数据，但是如果需要，可以通过执行`df = pd.read_csv('../data/hr-analytics/hr_data_processed.csv')`再次完成。 然后，使用`print(df.columns)`打印 DataFrame 列。
 2.  定义所有功能的列表，方法是将`df.columns`中的输出复制并粘贴到新列表中（确保删除目标变量`left`）。 然后，像之前一样定义`X`和`Y`。 如下所示：
@@ -999,7 +999,7 @@ k 折交叉验证算法如下：
 
     ```
 
-    我们正在测试 10 个具有 k 倍交叉验证的模型。 通过设置`k = 5`，我们从得出每个模型的准确性的五个估计，我们从中提取平均值和标准偏差以绘制在验证曲线中。 我们总共训练了 50 个模型，由于`n_estimators`设置为 20，所以我们总共训练了 1,000 个决策树！ 大约需要 10 秒钟！
+    我们正在测试 10 个具有 K 折交叉验证的模型。 通过设置`k = 5`，我们从得出每个模型的准确性的五个估计，我们从中提取平均值和标准偏差以绘制在验证曲线中。 我们总共训练了 50 个模型，由于`n_estimators`设置为 20，所以我们总共训练了 1,000 个决策树！ 大约需要 10 秒钟！
 
 4.  使用上一个练习中的自定义`plot_validation_curve`函数绘制验证曲线。 运行以下代码：
 
@@ -1014,7 +1014,7 @@ k 折交叉验证算法如下：
 
     我们确实应该对`n_estimators`做同样的事情，但是出于节省时间的精神，我们将跳过它。 欢迎您自己绘制。 您应该在训练和验证集之间找到适用于各种价值的协议。 通常，最好在“随机森林”中使用更多的决策树估计器，但这是以增加训练时间为代价的。 我们将使用 200 个估算器来训练我们的模型。
 
-5.  使用`cross_val_class_score`（我们之前创建的按类进行 k 倍交叉验证）来测试所选模型，即`max_depth = 6`和`n_estimators = 200`的随机森林：
+5.  使用`cross_val_class_score`（我们之前创建的按类进行 K 折交叉验证）来测试所选模型，即`max_depth = 6`和`n_estimators = 200`的随机森林：
 
     ```py
     np.random.seed(1)clf = RandomForestClassifier(n_estimators=200, max_depth=6)scores = cross_val_class_score(clf, X, y)print('accuracy = {} +/- {}'\.format(scores.mean(axis=0), scores.std(axis=0)))
@@ -1098,7 +1098,7 @@ k 折交叉验证算法如下：
     y = df.left.values
     ```
 
-11.  通过 k 倍交叉验证来评估新模型的准确性。 可以通过运行与以前相同的代码来完成此操作，其中`X`现在指向不同的功能。 代码如下：
+11.  通过 K 折交叉验证来评估新模型的准确性。 可以通过运行与以前相同的代码来完成此操作，其中`X`现在指向不同的功能。 代码如下：
 
     ```py
     np.random.seed(1)

new/begin-ds-py-jupyter/3.md

@@ -49,7 +49,7 @@ HTTP 方法
 | 邮政 | 发送附加信息以附加到指定 URL 的资源 |
 | 放 | 发送附加信息以替换指定 URL 上的资源 |
 
-每次我们在浏览器中输入网页地址并按**时，都会发送 GET 请求。输入**。 对于 Web 抓取，通常这是我们感兴趣的唯一 HTTP 方法，也是在本课程中将使用的唯一方法。
+每次我们在浏览器中输入网页地址并按**输入**时，都会发送 GET 请求。 对于 Web 抓取，通常这是我们感兴趣的唯一 HTTP 方法，也是在本课程中将使用的唯一方法。
 
 发送请求后，可以从服务器返回各种响应类型。 这些被标记为，具有 100 级到 500 级代码，其中代码的第一位数字表示响应类别。 这些可以描述如下：
 
@@ -59,13 +59,13 @@ HTTP 方法
 *   **4xx**：客户端错误，例如，请求的资源不存在。
 *   **5xx**：服务器错误，例如，网站服务器接收的流量过多，无法满足请求。
 
-为了进行网页抓取，我们通常只关心响应类，即响应代码的第一位。 但是，每个类中都存在响应的子类别，这些子类别提供了所发生事件的更多粒度。 例如，401 代码表示*未经授权的*响应，而 404 代码表示未找到*页面*响应。 这种区别是值得注意的，因为 404 表示我们请求的页面不存在，而 401 则表示我们需要登录才能查看特定资源。
+为了进行网页抓取，我们通常只关心响应类，即响应代码的第一位。 但是，每个类中都存在响应的子类别，这些子类别提供了所发生事件的更多粒度。 例如，401 代码表示*未经授权*响应，而 404 代码表示*未找到页面*响应。 这种区别是值得注意的，因为 404 表示我们请求的页面不存在，而 401 则表示我们需要登录才能查看特定资源。
 
 让我们看看如何在 Python 中完成 HTTP 请求，并使用 Jupyter Notebook 探索其中一些主题。
 
 ## 子主题 B：在 Jupyter 笔记本中发出 HTTP 请求
 
-既然我们已经讨论了 HTTP 请求如何工作以及应该期望哪种类型的响应，让我们看看如何在 Python 中完成此工作。 我们将使用一个名为 **Requests** 的库，该库恰好是 Python 上下载次数最多的外部库。 可以使用 Python 的内置工具，例如 **urllib** 来发出 HTTP 请求，但是请求要直观得多，事实上，在官方 Python 文档中，建议使用 urllib。
+既然我们已经讨论了 HTTP 请求如何工作以及应该期望哪种类型的响应，让我们看看如何在 Python 中完成此工作。 我们将使用一个名为 **Requests** 的库，该库恰好是 Python 上下载次数最多的外部库。 可以使用 Python 的内置工具，例如`urllib`来发出 HTTP 请求，但是请求要直观得多，事实上，在官方 Python 文档中，建议使用 urllib。
 
 请求是用于进行简单和高级 Web 请求的绝佳选择。 它允许对标头，cookie 和授权进行各种自定义。 它跟踪重定向并提供用于返回特定页面内容（例如 JSON）的方法。 此外，还有一整套高级功能。 但是，它不允许呈现 JavaScript。
 
@@ -132,7 +132,7 @@ HTTP 方法
 
     ![Handling HTTP requests Jupyter NotebooksHTTP requests, handling with Pythonwith Python in a Jupyter Notebook](img/image3_05.jpg)
 
-    鉴于没有运行 JavaScript 代码且未加载任何外部资源，在这里，我们将尽可能地看到呈现的 HTML。 例如，不会呈现在 jupyter.org 服务器上的图像，而是显示`alt`文本：**编程图标圈**，**jupyter 徽标**等，依此类推 。
+    鉴于没有运行 JavaScript 代码且未加载任何外部资源，在这里，我们将尽可能地看到呈现的 HTML。 例如，不会呈现在 jupyter.org 服务器上的图像，而是显示`alt`文本：**编程图标圆圈**，**jupyter 徽标**等，依此类推。
 
 9.  让我们将其与实时网站进行比较，可以使用 IFrame 在 Jupyter 中打开它。 通过运行以下代码来执行此操作：
 
@@ -308,7 +308,7 @@ HTTP 方法
 
     我们在前面遇到了一些不良字符。 可以通过仅搜索`<a>`标签的文本来解决此。
 
-18.  运行`d1.find('a').text`以返回该单元格正确的*清除的*数据。
+18.  运行`d1.find('a').text`以返回该单元格正确的*清晰*数据。
 19.  在接下来的两个单元格中运行，以打印`d2`及其文本。 此数据看起来足够干净，可以直接转换为浮点数。
 20.  运行接下来的两个单元格以打印`d3`及其文本：
 
@@ -400,9 +400,9 @@ HTTP 方法
     IFrame(url, height=300, width=800)
     ```
 
-    页面应在笔记本电脑中加载。 向下滚动，我们可以看到按人口标题显示的世界**国家及其下的价值表。 我们将从此表中刮取前三列，以获取国家/地区，人口和年度人口变化。**
+    页面应在笔记本电脑中加载。 向下滚动，我们可以看到按人口标题显示的世界**国家及其人口**表。 我们将从此表中刮取前三列，以获取国家/地区，人口和年度人口变化。
 
-4.  通过选择单元格并单击**，关闭 IFrame。 **从 Jupyter 笔记本电脑的**单元格**菜单中清除**。**
+4.  通过选择单元格并从 Jupyter 笔记本的**单元格**菜单中单击**当前输出 | 清空**，关闭 IFrame。 
 5.  通过运行以下代码来请求页面并将其作为`BeautifulSoup`对象加载：
 
     ```py
@@ -534,7 +534,7 @@ HTTP 方法
 
 ## 子主题 A：构建用于存储和组织数据的数据框
 
-正如在本书中一次又一次地看到的那样，熊猫是使用 Python 和 Jupyter Notebooks 进行数据科学不可或缺的一部分。 DataFrames 提供了一种组织和存储带标签数据的方法，但是更重要的是，pandas 提供了节省时间的方法来转换 DataFrame 中的数据。 我们在本书中看到的示例包括删除重复项，将字典映射到列，在列上应用函数以及填写缺失值。
+正如在本书中一次又一次地看到的那样，Pandas是使用 Python 和 Jupyter Notebooks 进行数据科学不可或缺的一部分。 DataFrames 提供了一种组织和存储带标签数据的方法，但是更重要的是，pandas 提供了节省时间的方法来转换 DataFrame 中的数据。 我们在本书中看到的示例包括删除重复项，将字典映射到列，在列上应用函数以及填写缺失值。
 
 关于可视化，DataFrames 提供了用于创建各种 matplotlib 图的方法，包括`df.plot.barh()`，`df.plot.hist()`等。 交互式可视化库 Bokeh 以前依靠 pandas DataFrames 来获取*高级*图表。 它们的工作方式与 Seaborn 相似，就像我们在上一课前面所看到的那样，其中 DataFrame 与要绘制的特定列一起传递给了 plotting 函数。 但是，Bokeh 的最新版本已放弃对此行为的支持。 相反，现在可以使用与 Matplotlib 相同的方式创建图，在图中可以将数据存储在简单列表或 NumPy 数组中。 讨论的重点是，DataFrames 并非完全必要，但对于在可视化之前组织和操作数据仍然非常有帮助。
 
@@ -732,7 +732,7 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 我们将加载所需的 Bokeh 模块，并显示一些可以使用 Bokeh 进行的简单交互式绘图。 请注意，本书中的示例是使用 Bokeh 的 0.12.10 版设计的。
 
 1.  在`lesson-3-workbook.ipynb` Jupyter 笔记本中，滚动到`Subtopic B: Introduction to Bokeh`。
-2.  像 scikit-learn 一样，Bokeh 模块通常是分段加载的（例如，与熊猫不同，一次加载整个库）。 通过运行以下代码导入一些基本的绘图模块：
+2.  像 scikit-learn 一样，Bokeh 模块通常是分段加载的（例如，与Pandas不同，一次加载整个库）。 通过运行以下代码导入一些基本的绘图模块：
 
     ```py
     from bokeh.plotting import figure, show, output_notebookoutput_notebook()
@@ -758,7 +758,7 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 
     我们实例化该图（由变量`p`引用），然后绘制一条线。 在 Jupyter 中运行此程序会产生，它是一个交互式图形，右侧带有各种选项。
 
-    前三个选项（从 0.12.10 版本开始）是 **Pan**，**Box Zoom** 和 **Wheel Zoom**。 尝试这些，并尝试它们的工作方式。 使用重置选项可重新加载默认绘图限制。
+    前三个选项（从 0.12.10 版本开始）是**平移**，**盒子缩放** 和**滚轮缩放**。 尝试这些，并尝试它们的工作方式。 使用重置选项可重新加载默认绘图限制。
 
 5.  其他图可以用图的替代方法来创建。 通过运行以下代码来绘制散点图，其中我们将前面代码中的`line`替换为`circle`：
 
@@ -868,9 +868,9 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 
     ![Activity B: Exploring Data with Interactive Visualizations](img/image3_41.jpg)
 
-    我们看到他们属于印度和中国。 这些国家的利率相当平均。 让我们通过使用 **Box Zoom** 工具修改视图窗口大小来关注点的其余部分。
+    我们看到他们属于印度和中国。 这些国家的利率相当平均。 让我们通过使用**盒子缩放**工具修改视图窗口大小来关注点的其余部分。
 
-6.  选择 **Box Zoom** 工具并更改查看窗口，以更好地查看大多数数据：
+6.  选择**盒子缩放**工具并更改查看窗口，以更好地查看大多数数据：
 
     ![Activity B: Exploring Data with Interactive Visualizations](img/image3_43.jpg)
 
@@ -1012,7 +1012,7 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 
 在结束之前，让我们快速回顾一下本书中涉及的主题。
 
-第一个课程是 Jupyter Notebook 平台的简介，其中涵盖了所有基础知识。 我们了解了界面以及如何使用和安装魔术函数。 然后，我们介绍了将要使用的 Python 库，并对 *Boston 房屋*数据集进行了探索性分析。
+第一个课程是 Jupyter Notebook 平台的简介，其中涵盖了所有基础知识。 我们了解了界面以及如何使用和安装魔术函数。 然后，我们介绍了将要使用的 Python 库，并对*波士顿房屋*数据集进行了探索性分析。
 
 在第二课中，我们专注于与 Jupyter 一起进行机器学习。 我们首先讨论了制定预测分析计划的步骤，然后介绍了几种不同类型的模型，包括 SVM，KNN 分类器和随机森林。 在处理*员工保留*数据集时，我们应用了数据清理方法，然后训练了模型以预测员工是否离开。 我们还探讨了更高级的主题，例如过度拟合，k 折交叉验证和验证曲线。
 

new/handson-ds-py-ml/04.md

@@ -299,7 +299,7 @@ df = pd.read_excel('http://cdn.sundog-soft.com/Udemy/DataScience/cars.xls')
 
 我们将在此处引入一个名为`pandas`的新程序包，它使我们能够非常轻松地处理表格数据。 它使我们能够读入数据表，并对它们进行重新排列，修改，切分并以不同的方式切成小方块。 我们将大量使用。
 
-我们将`pandas`导入为`pd`，并且`pd`具有`read_Excel()`函数，我们可以使用该函数继续通过 HTTP 从 Web 读取 Microsoft Excel 电子表格。 因此，那里的熊猫功能相当强大。
+我们将`pandas`导入为`pd`，并且`pd`具有`read_Excel()`函数，我们可以使用该函数继续通过 HTTP 从 Web 读取 Microsoft Excel 电子表格。 因此，那里的Pandas功能相当强大。
 
 我已经开始在自己的域上为您托管该文件，如果我们运行该文件，它将把它加载到我们称为`df`的`DataFrame`对象中。 现在，我可以在此`DataFrame`上调用`head()`以显示它的前几行：
 
@@ -357,7 +357,7 @@ y.groupby(df.Doors).mean()
 
 在那里，您将拥有：多元分析及其运行示例。 与我们探讨的多元分析概念同样重要的是我们在该 Python 笔记本中所做的一些工作。 因此，您可能想回到那里，仔细研究正在发生的事情。
 
-我们介绍了熊猫以及使用熊猫和 DataFrame 对象的方法。 熊猫是一个非常强大的工具。 我们将在以后的部分中更多地使用它，但是请确保您开始注意到这些事情，因为这些将成为 Python 技能中管理大量数据和组织数据的重要技术。
+我们介绍了Pandas以及使用Pandas和 DataFrame 对象的方法。 Pandas是一个非常强大的工具。 我们将在以后的部分中更多地使用它，但是请确保您开始注意到这些事情，因为这些将成为 Python 技能中管理大量数据和组织数据的重要技术。
 
 # 多层次模型
 

new/handson-ds-py-ml/05.md

@@ -219,7 +219,7 @@ print r2
 
 r 平方值原来是`0.6`，这并不奇怪，因为我们在训练数据上对其进行了训练。 坦率地说，测试数据有点未知，也无法测试。 30％，那是 F！
 
-因此，这是一个示例，其中我们使用了训练/测试来评估监督学习算法，就像我之前说的那样，熊猫提供了一些使这一过程变得更加容易的方法。 我们稍后再讨论，还将在本书的稍后部分中查看更多训练/测试示例，包括 k 折交叉验证。
+因此，这是一个示例，其中我们使用了训练/测试来评估监督学习算法，就像我之前说的那样，Pandas提供了一些使这一过程变得更加容易的方法。 我们稍后再讨论，还将在本书的稍后部分中查看更多训练/测试示例，包括 k 折交叉验证。
 
 # 活动
 
@@ -304,9 +304,9 @@ data = data.append(dataFrameFromDirectory(
 
 ```
 
-因此，我们需要做的第一件事是以某种方式阅读所有这些电子邮件，并且我们将再次使用熊猫来简化此操作。 同样，熊猫是用于处理表格数据的有用工具。 我们在这里的示例中导入将要使用的所有不同软件包，其中包括 os 库，io 库，numpy，pandas，以及来自 scikit-learn 的 CountVectorizer 和 MultinomialNB。
+因此，我们需要做的第一件事是以某种方式阅读所有这些电子邮件，并且我们将再次使用Pandas来简化此操作。 同样，Pandas是用于处理表格数据的有用工具。 我们在这里的示例中导入将要使用的所有不同软件包，其中包括 os 库，io 库，numpy，pandas，以及来自 scikit-learn 的 CountVectorizer 和 MultinomialNB。
 
-现在让我们详细研究这段代码。 现在，我们可以跳过`readFiles()`和`dataFrameFromDirectory()`的函数定义，然后转到我们的代码实际要做的第一件事，即创建一个熊猫 DataFrame 对象。
+现在让我们详细研究这段代码。 现在，我们可以跳过`readFiles()`和`dataFrameFromDirectory()`的函数定义，然后转到我们的代码实际要做的第一件事，即创建一个Pandas DataFrame 对象。
 
 我们将从字典中构造它，该字典最初包含一些空列表，用于在类的空列表中显示消息。 因此，这种语法是这样说的：“我想要一个包含两列的 DataFrame：一列包含消息，每封电子邮件的实际文本；一列包含每封电子邮件的类别，即垃圾邮件还是垃圾邮件。 火腿”。 就是说我想创建一个小的电子邮件数据库，该数据库有两列：电子邮件的实际文本以及是否为垃圾邮件。
 
@@ -376,7 +376,7 @@ array(['spam', 'ham'], dtype='|S4')
 
 我们这里有一个非常小的数据集，因此您可以根据需要尝试通过它运行一些不同的电子邮件，看看是否得到不同的结果。 如果您真的想挑战自己，请尝试对本示例进行培训/测试。 因此，判断我的垃圾邮件分类器是否良好的真正衡量标准不仅仅是直观地判断`Free Money now!!!`是垃圾邮件。 您想定量地进行测量。
 
-因此，如果您想挑战一点，请继续尝试将这些数据分为训练集和测试数据集。 实际上，您可以在线查询熊猫如何将数据轻松地分为火车和测试集，或者您可以手工完成。 一切为您工作。 查看是否可以将`MultinomialNB`分类器实际应用于测试数据集并衡量其性能。 因此，如果您想做一点运动，一点挑战，那就继续尝试一下。
+因此，如果您想挑战一点，请继续尝试将这些数据分为训练集和测试数据集。 实际上，您可以在线查询Pandas如何将数据轻松地分为火车和测试集，或者您可以手工完成。 一切为您工作。 查看是否可以将`MultinomialNB`分类器实际应用于测试数据集并衡量其性能。 因此，如果您想做一点运动，一点挑战，那就继续尝试一下。
 
 多么酷啊？ 我们只是使用 Python 中的几行代码编写了自己的垃圾邮件分类器。 使用 scikit-learn 和 Python 相当容易。 这就是朴素贝叶斯（Naive Bayes）的作用，实际上，您已经可以将垃圾邮件或火腿邮件分类，然后进行分类。 很酷的东西。 接下来让我们讨论集群。
 
@@ -614,7 +614,7 @@ df.head()
 
 因此，对于每个候选人 ID，我们都有他们过去的工作经验，是否受雇，以前的雇主数量，他们的最高学历，是否上过一流学校以及是否进行过实习。 ; 最后，在“雇用”列中，答案是-我们知道我们是否向该人员提供了工作机会。
 
-像往常一样，大部分工作只是在实际运行算法之前，对数据进行处理，准备数据，这就是我们在这里需要做的。 现在 scikit-learn 要求所有内容都是数字，因此我们不能包含 Y 和 N，BS 和 MS 和 PhD。 为了使决策树模型正常工作，我们必须将所有这些东西转换为数字。 这样做的方法是在熊猫中使用一些简写形式，这使这些事情变得容易。 例如：
+像往常一样，大部分工作只是在实际运行算法之前，对数据进行处理，准备数据，这就是我们在这里需要做的。 现在 scikit-learn 要求所有内容都是数字，因此我们不能包含 Y 和 N，BS 和 MS 和 PhD。 为了使决策树模型正常工作，我们必须将所有这些东西转换为数字。 这样做的方法是在Pandas中使用一些简写形式，这使这些事情变得容易。 例如：
 
 ```py
 d = {'Y': 1, 'N': 0} 

new/handson-ds-py-ml/06.md

@@ -174,7 +174,7 @@ ratings = pd.merge(movies, ratings)
 
 我们最终得到一个新的 DataFrame，其中包含用户评分的每部电影的`user_id`和评分，并且我们可以读取`movie_id`和`title`并查看其真实含义。 因此，读取方式为`user_id`编号为`Toy Story (1995)`电影`4`星级的`user_id`编号`user_id`编号为`Toy Story (1995)`电影`5`星级的`287`等，依此类推 。 而且，如果我们要继续关注这个 DataFrame 的更多内容，那么我们在浏览不同电影时会看到不同的评分。
 
-现在，熊猫的真正魔力进来了。因此，我们真正想要的是根据观看每对电影的所有用户来查看电影之间的关系，因此，我们最终需要每部电影的矩阵，以及每部电影的矩阵。 用户，以及每个用户对每部电影的所有评分。 Pandas 中的`pivot_table`命令可以为我们做到这一点。 它基本上可以从给定的 DataFrame 构造一个新表，几乎可以用您想要的任何方式。 为此，我们可以使用以下代码：
+现在，Pandas的真正魔力进来了。因此，我们真正想要的是根据观看每对电影的所有用户来查看电影之间的关系，因此，我们最终需要每部电影的矩阵，以及每部电影的矩阵。 用户，以及每个用户对每部电影的所有评分。 Pandas 中的`pivot_table`命令可以为我们做到这一点。 它基本上可以从给定的 DataFrame 构造一个新表，几乎可以用您想要的任何方式。 为此，我们可以使用以下代码：
 
 ```py
 movieRatings = ratings.pivot_table(index=['user_id'],
@@ -189,7 +189,7 @@ movieRatings.head()
 
 ![](img/2be0e510-8351-4be3-93c1-210bf6a1edef.jpg)
 
-怎么能将所有这些整合在一起对我们来说真是太神奇了。 现在，您将看到一些`NaN`值，它们代表**而不是数字**，以及熊猫如何指示缺失值。 因此，这种解释的方式是，例如`user_id`数字`1`没看电影`1-900 (1994)`，但是`user_id`数字`1`却看了`101 Dalmatians (1996)`并将它评为`2`星。 `user_id`数字`1`也观看了`12 Angry Men (1957)`并将其评为`5`星，但没有观看电影`2 Days in the Valley (1996)`，例如，好吗？ 因此，我们最终得到的基本上是一个稀疏矩阵，其中包含每个用户和每个电影，并且在用户对电影进行评分的每个路口处都有一个评分值。
+怎么能将所有这些整合在一起对我们来说真是太神奇了。 现在，您将看到一些`NaN`值，它们代表**而不是数字**，以及Pandas如何指示缺失值。 因此，这种解释的方式是，例如`user_id`数字`1`没看电影`1-900 (1994)`，但是`user_id`数字`1`却看了`101 Dalmatians (1996)`并将它评为`2`星。 `user_id`数字`1`也观看了`12 Angry Men (1957)`并将其评为`5`星，但没有观看电影`2 Days in the Valley (1996)`，例如，好吗？ 因此，我们最终得到的基本上是一个稀疏矩阵，其中包含每个用户和每个电影，并且在用户对电影进行评分的每个路口处都有一个评分值。
 
 因此，现在您可以看到，我们可以很容易地提取用户观看的每部电影的矢量，我们还可以提取对给定电影评分的每个用户的矢量，这正是我们想要的。 因此，这对于基于用户和基于项目的协作过滤都很有用，对吗？ 如果要查找用户之间的关系，可以查看这些用户行之间的相关性，但是如果要查找电影之间的相关性，则对于基于项目的协作过滤，可以根据用户行为查看列之间的相关性。 因此，这就是真正的*翻转用户和基于项目的相似性*的地方。
 
@@ -322,7 +322,7 @@ df.sort_values(['similarity'], ascending=False)[:15]
 
 好的，让我们实际构建一个成熟的推荐器系统，该系统可以查看系统中每个人的所有行为信息以及他们评价的电影，并使用它们为我们数据集中的任何给定用户实际生成最佳推荐电影。 有点神奇，它会变得如此简单，您会感到惊讶。 我们走吧！
 
-让我们开始使用`ItemBasedCF.ipynb`文件，并开始导入已有的 MovieLens 数据集。 再说一次，我们现在使用的子集仅包含 100,000 个评分。 但是，您可以从 GroupLens.org 中获取更大的数据集，直至数百万个评分。 如果你这么倾向。 但是请记住，当您开始处理那些非常大的数据时，您将限制在一台计算机上可以做的事情以及熊猫可以处理的事情。 事不宜迟，这是第一段代码：
+让我们开始使用`ItemBasedCF.ipynb`文件，并开始导入已有的 MovieLens 数据集。 再说一次，我们现在使用的子集仅包含 100,000 个评分。 但是，您可以从 GroupLens.org 中获取更大的数据集，直至数百万个评分。 如果你这么倾向。 但是请记住，当您开始处理那些非常大的数据时，您将限制在一台计算机上可以做的事情以及Pandas可以处理的事情。 事不宜迟，这是第一段代码：
 
 ```py
 import pandas as pd 
@@ -362,7 +362,7 @@ userRatings.head()
 
 我们最终得到的是上面输出中显示的极其有用的矩阵，其中包含每一行的用户和每一列的电影。 而且，对于该矩阵中的每部电影，我们基本上都有每个用户的评分。 因此，例如`user_id`数字`1`给`101 Dalmatians (1996)` 2 星级。 而且，所有这些`NaN`值仍然代表丢失的数据。 因此，这仅表示，例如`user_id`编号`1`没有对影片`1-900 (1994)`进行评分。
 
-同样，这是一个非常有用的矩阵。 如果我们正在执行基于用户的协作过滤，则可以计算每个单独的用户评分向量之间的相关性，以找到相似的用户。 由于我们正在执行基于项目的协作过滤，因此我们对列之间的关系更感兴趣。 因此，例如，在任意两列之间进行相关性评分，这将为我们提供给定电影对的相关性评分。 那么，我们该怎么做呢？ 事实证明，熊猫也使这件事变得非常容易。
+同样，这是一个非常有用的矩阵。 如果我们正在执行基于用户的协作过滤，则可以计算每个单独的用户评分向量之间的相关性，以找到相似的用户。 由于我们正在执行基于项目的协作过滤，因此我们对列之间的关系更感兴趣。 因此，例如，在任意两列之间进行相关性评分，这将为我们提供给定电影对的相关性评分。 那么，我们该怎么做呢？ 事实证明，Pandas也使这件事变得非常容易。
 
 它具有内置的`corr`函数，该函数实际上将计算整个矩阵中找到的每个列对的相关性得分-就像他们在想我们一样。
 
@@ -380,7 +380,7 @@ corrMatrix.head()
 
 我现在有了这个奇妙的矩阵，它将为我提供任何两部电影之间的相似度得分。 这有点令人惊奇，对于我们将要做的事情非常有用。 现在，就像前面一样，我们必须处理虚假的结果。 因此，我不想查看基于少量行为信息的关系。
 
-事实证明，熊猫`corr`函数实际上具有一些您可以给它的参数。 一种是您要使用的实际相关性评分方法，所以我要说使用`pearson`相关性。
+事实证明，Pandas`corr`函数实际上具有一些您可以给它的参数。 一种是您要使用的实际相关性评分方法，所以我要说使用`pearson`相关性。
 
 ```py
 corrMatrix = userRatings.corr(method='pearson', min_periods=100) 
@@ -513,6 +513,6 @@ filteredSims.head(10)
 
 因此，请尝试一下！ 看看您是否可以改善我们的初步结果。 那里有一些简单的想法可以使这些建议变得更好，也有一些更复杂的想法。 现在，没有正确或错误的答案。 我不会要你上交工作，也不会去审查你的工作。 您知道，您决定使用它并对其有所了解，然后进行实验并查看获得的结果。 这就是重点-只是为了使您更加熟悉使用 Python 处理这类事情，并更加熟悉基于项目的协作过滤背后的概念。
 
-在本章中，我们研究了不同的推荐系统-我们排除了基于用户的协作过滤系统，并直接涉足基于项目的系统。 然后，我们使用了熊猫的各种功能来生成和完善我们的结果，希望您在这里已经看到了熊猫的力量。
+在本章中，我们研究了不同的推荐系统-我们排除了基于用户的协作过滤系统，并直接涉足基于项目的系统。 然后，我们使用了Pandas的各种功能来生成和完善我们的结果，希望您在这里已经看到了Pandas的力量。
 
 在下一章中，我们将介绍更高级的数据挖掘和机器学习技术，包括 K 近邻。 我期待着向您解释这些内容，并看看它们将如何有用。
\ No newline at end of file

new/handson-ds-py-ml/07.md

@@ -49,9 +49,9 @@ KNN 听起来很花哨，但实际上它是其中最简单的技术之一！ 假
 
 `MovieLens`数据集中的每部电影都具有有关其流派的其他信息。 电影可以属于一种以上的流派，一种流派是诸如科幻小说，戏剧，喜剧或动画之类的东西。 我们还将根据评价该电影的人数来查看该电影的整体受欢迎程度，我们还将了解每部电影的平均评价。 我可以将所有这些信息组合在一起，从而仅基于收视率信息和体裁信息就可以基本创建两部电影之间的距离度量。 让我们看看我们得到了什么。
 
-我们将再次使用熊猫来简化生活，如果您继续遵循，请再次确保将`MovieLens`数据集的路径更改为安装它的位置，几乎可以肯定这不是 Python 笔记本中的内容。
+我们将再次使用Pandas来简化生活，如果您继续遵循，请再次确保将`MovieLens`数据集的路径更改为安装它的位置，几乎可以肯定这不是 Python 笔记本中的内容。
 
-如果要继续，请继续进行更改。 和以前一样，我们只是要导入实际收视率数据文件，它是使用熊猫中的`read_csv()`函数输入的`u.data`。 我们要说的是它实际上有一个制表符分隔符，而不是逗号。 我们将导入数据集中每个电影评分的前三列，分别代表`user_id`，`movie_id`和评分：
+如果要继续，请继续进行更改。 和以前一样，我们只是要导入实际收视率数据文件，它是使用Pandas中的`read_csv()`函数输入的`u.data`。 我们要说的是它实际上有一个制表符分隔符，而不是逗号。 我们将导入数据集中每个电影评分的前三列，分别代表`user_id`，`movie_id`和评分：
 
 ```py
 import pandas as pd 
@@ -68,7 +68,7 @@ ratings.head()ratings.head()
 
 我们以带有`user_id`，`movie_id`和`rating`的`DataFrame`结尾。 例如，`user_id 0`评级为`movie_id 50`，我认为它是《星球大战》，5 星等，依此类推。
 
-接下来我们要弄清楚的是有关每部电影的收视率的汇总信息。 我们在熊猫中使用`groupby()`函数将所有内容按`movie_id`进行分组。 我们将把每部电影的所有收视率合并在一起，并输出每部电影的收视率数量和平均收视率得分：
+接下来我们要弄清楚的是有关每部电影的收视率的汇总信息。 我们在Pandas中使用`groupby()`函数将所有内容按`movie_id`进行分组。 我们将把每部电影的所有收视率合并在一起，并输出每部电影的收视率数量和平均收视率得分：
 
 ```py
 movieProperties = ratings.groupby('movie_id').agg({'rating': 
@@ -117,7 +117,7 @@ with open(r'c:/DataScience/ml-100k/u.item') as f:
 
 ```
 
-上面的代码实际上将通过`u.item`的每一行。 我们正在努力地做到这一点； 我们没有使用任何熊猫函数； 这次我们将使用直接 Python。 同样，请确保将路径更改为安装此信息的位置。
+上面的代码实际上将通过`u.item`的每一行。 我们正在努力地做到这一点； 我们没有使用任何Pandas函数； 这次我们将使用直接 Python。 同样，请确保将路径更改为安装此信息的位置。
 
 接下来，我们打开`u.item`文件，然后一次遍历文件中的每一行。 我们在末尾去除新行，并根据该文件中的竖线分隔符对其进行分割。 然后，我们提取`movieID`，电影名称和所有单个类型字段。 因此，基本上，在此源数据的 19 个不同字段中有一堆 0 和 1，其中每个字段代表一个给定的体裁。 然后，我们最后构建一个 Python 字典，将电影 ID 映射到它们的名称，流派，然后还折回我们的收视率信息。 因此，我们将使用 0 到 1 的比例来命名，类型，受欢迎程度以及平均评分。 因此，这就是这小段代码。 让我们运行它！ 而且，仅查看最终结果，我们可以提取`movie_id 1`的值：
 

new/handson-ds-py-ml/09.md

@@ -94,7 +94,7 @@
 
 ![](img/417d9e6f-4b8c-4a51-bb1c-694e1cf23530.png)
 
-您显然不想将其保留在`Downloads`文件夹中，所以让我们继续在此处打开一个新的文件浏览器窗口。 我转到`C`驱动器并创建一个新文件夹，让我们将其命名为`spark`。 因此，我的 Spark 安装将在`C:\spark`中运行。 同样，很容易记住。 打开该文件夹。 现在，我回到下载的`spark`文件夹，并使用 *Ctrl* +`A`选择 Spark 发行版中的所有内容， *Ctrl* +`C`复制它，然后返回`C:\spark`，我要放置在其中，然后 *Ctrl* +`V`粘贴到：
+您显然不想将其保留在`Downloads`文件夹中，所以让我们继续在此处打开一个新的文件浏览器窗口。 我转到`C`驱动器并创建一个新文件夹，让我们将其命名为`spark`。 因此，我的 Spark 安装将在`C:\spark`中运行。 同样，很容易记住。 打开该文件夹。 现在，我回到下载的`spark`文件夹，并使用 *Ctrl* +`A`选择 Spark 发行版中的所有内容，`Ctrl + C`复制它，然后返回`C:\spark`，我要放置在其中，然后 *Ctrl* +`V`粘贴到：
 
 ![](img/e5a2e48a-10c4-4849-9ef2-11833945eaa8.png)
 
@@ -120,7 +120,7 @@
 
 ![](img/6257dac5-b9be-45d2-a9dc-58ad1ac9d705.png)
 
-现在，由于我们要在桌面上本地运行脚本，所以这没什么大不了的，我们不需要真正安装 Hadoop。 这只是绕过了另一个在 Windows 上运行 Spark 的怪癖。 因此，现在我们有了它，让我们在`Downloads`文件夹中找到它， *Ctrl* +`C`复制它，然后转到`C`驱动器并创建一个位置 为了生存：
+现在，由于我们要在桌面上本地运行脚本，所以这没什么大不了的，我们不需要真正安装 Hadoop。 这只是绕过了另一个在 Windows 上运行 Spark 的怪癖。 因此，现在我们有了它，让我们在`Downloads`文件夹中找到它，`Ctrl + C`复制它，然后转到`C`驱动器并创建一个位置 为了生存：
 
 ![](img/dccddda5-a8d8-47c0-b4ec-d9c636fe4513.png)
 

new/master-py-ds/00.md

@@ -36,7 +36,7 @@
 
 *   Ubuntu OS，最好是 14.04
 *   Python 2.7
-*   熊猫 0.16.2 库
+*   Pandas 0.16.2 库
 *   NumPy 1.9.2 库
 *   SciPy 0.16 库
 *   IPython 4.0

new/master-py-ds/01.md

@@ -10,7 +10,7 @@
 在本章中，我们将讨论以下主题：
 
 *   使用 NumPy 探索数组
-*   用熊猫处理数据
+*   用Pandas处理数据
 *   读写各种格式的数据
 *   处理丢失的数据
 *   处理数据
@@ -224,17 +224,17 @@ Array[10 10 10 10]
 
 ```
 
-# 利用熊猫进行数据分析
+# 利用Pandas进行数据分析
 
-熊猫库由 Wes McKinny 在 AQR Capital Management 工作时开发。 他想要一种足够灵活的工具来对财务数据进行定量分析。 后来，Chang She 加入了他，并帮助进一步开发了该软件包。
+Pandas库由 Wes McKinny 在 AQR Capital Management 工作时开发。 他想要一种足够灵活的工具来对财务数据进行定量分析。 后来，Chang She 加入了他，并帮助进一步开发了该软件包。
 
 pandas 库是一个开放源代码 Python 库，专门用于数据分析。 它建立在 NumPy 上，可以轻松处理数据。 NumPy 是一个相当底层的工具，可以很好地处理矩阵。
 
 pandas 库在 Python 世界中带来了 R 的丰富功能，可以处理数据。 它具有高效的数据结构，可以处理数据，执行快速联接以及从各种来源读取数据，仅举几例。
 
-## 熊猫的数据结构
+## Pandas的数据结构
 
-熊猫库本质上具有三个数据结构：
+Pandas库本质上具有三个数据结构：
 
 1.  系列
 2.  数据框
@@ -257,7 +257,7 @@ dtype: float64
 
 ```
 
-`random.randn`参数是 NumPy 包的一部分，它生成随机数。 series 函数创建一个由索引组成的熊猫系列，第一列是索引，第二列由随机值组成。 输出的底部是系列的数据类型。
+`random.randn`参数是 NumPy 包的一部分，它生成随机数。 series 函数创建一个由索引组成的Pandas系列，第一列是索引，第二列由随机值组成。 输出的底部是系列的数据类型。
 
 可以通过调用以下命令来定制系列的索引：
 
@@ -348,7 +348,7 @@ Minor_axis axis: 0 to 2
 
 ## 插入和导出数据
 
-数据以的各种形式存储，例如 CSV，TSV，数据库等。 熊猫库使您可以方便地从这些格式读取数据或将其导出为这些格式。 我们将使用一个数据集，其中包含来自美国的在校学生的体重统计数据。
+数据以的各种形式存储，例如 CSV，TSV，数据库等。 Pandas库使您可以方便地从这些格式读取数据或将其导出为这些格式。 我们将使用一个数据集，其中包含来自美国的在校学生的体重统计数据。
 
 我们将使用具有以下结构的文件：
 
@@ -414,7 +414,7 @@ Minor_axis axis: 0 to 2
 
 ### XLS
 
-除了熊猫软件包外，还需要安装`xlrd`软件包，熊猫才能从 Excel 文件中读取数据：
+除了Pandas软件包外，还需要安装`xlrd`软件包，Pandas才能从 Excel 文件中读取数据：
 
 ```py
 >>> d=pd.read_excel('Data/Student_Weight_Status_Category_Reporting_Results__Beginning_2010.xls')
@@ -738,7 +738,7 @@ a41  0.547655  0.692852  0.681825
 
 ## 合并数据
 
-要将数据集组合在一起，可以利用熊猫的`concat`功能。 让我们以`Area Name`和`County`列的前五行为例：
+要将数据集组合在一起，可以利用Pandas的`concat`功能。 让我们以`Area Name`和`County`列的前五行为例：
 
 ```py
 >>> d[['AREA NAME', 'COUNTY']][0:5]
@@ -869,7 +869,7 @@ p2 2  RAVENA COEYMANS SELKIRK CENTRAL SCHOOL DISTRICT      ALBANY
 
 ## 加入
 
-可以使用熊猫在 DataFrame 上执行类似 SQL 的联接。 让我们定义一个查找 DataFrame，它使用以下命令为每个成绩指定级别：
+可以使用Pandas在 DataFrame 上执行类似 SQL 的联接。 让我们定义一个查找 DataFrame，它使用以下命令为每个成绩指定级别：
 
 ```py
 >>> grade_lookup = {'GRADE LEVEL': pd.Series(['ELEMENTARY', 'MIDDLE/HIGH', 'MISC']),
@@ -962,7 +962,7 @@ p2 2  RAVENA COEYMANS SELKIRK CENTRAL SCHOOL DISTRICT      ALBANY
 
 ### 分组功能
 
-通过对熊猫的操作来进行类似于 SQL 的分组很容易。 让我们说，如果您想查找每个年级的肥胖学生人数的总和，则可以使用以下命令：
+通过对Pandas的操作来进行类似于 SQL 的分组很容易。 让我们说，如果您想查找每个年级的肥胖学生人数的总和，则可以使用以下命令：
 
 ```py
 >>> df['NO. OBESE'].groupby(d['GRADE LEVEL']).sum()
@@ -996,9 +996,9 @@ MIDDLE/HIGH      53089   59.251116   65.905591
 
 # 摘要
 
-在本章中，我们熟悉了 NumPy 和 pandas 软件包。 我们了解了熊猫中不同的数据类型以及如何利用它们。 我们学习了如何执行数据清除和操作，其中我们处理了缺失值并执行了字符串操作。 本章为我们提供了数据科学的基础，您可以通过单击以下链接来更深入地了解 NumPy 和熊猫：
+在本章中，我们熟悉了 NumPy 和 pandas 软件包。 我们了解了Pandas中不同的数据类型以及如何利用它们。 我们学习了如何执行数据清除和操作，其中我们处理了缺失值并执行了字符串操作。 本章为我们提供了数据科学的基础，您可以通过单击以下链接来更深入地了解 NumPy 和Pandas：
 
 *   [**NumPy** **文档**](http://docs.scipy.org/doc/)
-*   [**大熊猫** **文档**](http://pandas.pydata.org/)
+*   [**Pandas** **文档**](http://pandas.pydata.org/)
 
 在下一章中，我们将学习推论统计的含义及其作用，以及如何理解推论统计中的不同概念。
\ No newline at end of file

new/master-py-ds/06.md

@@ -259,7 +259,7 @@ Coefficient value of the height is [ 1.00092142]
 *   statsmodels 模块
 *   SciKit 软件包
 
-甚至熊猫都提供了**普通最小二乘**（**OLS**）回归，您可以在完成本章之后进行尝试。 普通最小二乘法是一种估算未知系数和回归方程截距的方法。 我们将从 statsmodels 包开始。 **统计模型**是一个 Python 模块，允许用户浏览数据，估计统计模型和执行统计测试。 描述性统计信息，统计检验，绘图函数和结果统计信息的广泛列表适用于不同类型的数据和每个估计量：
+甚至Pandas都提供了**普通最小二乘**（**OLS**）回归，您可以在完成本章之后进行尝试。 普通最小二乘法是一种估算未知系数和回归方程截距的方法。 我们将从 statsmodels 包开始。 **统计模型**是一个 Python 模块，允许用户浏览数据，估计统计模型和执行统计测试。 描述性统计信息，统计检验，绘图函数和结果统计信息的广泛列表适用于不同类型的数据和每个估计量：
 
 ```py
 >>> result = sm.OLS( y_train, add_constant(X_train) ).fit()

new/master-py-ds/07.md

@@ -221,7 +221,7 @@ Logistic 回归是一种回归分析，可帮助您根据某些给定参数估
 
 ```
 
-在前面的代码中，我们在测试数据上获得预测的概率，然后根据`0.7`的阈值为事件分配`True`或`False`。 我们使用熊猫的交叉表功能，该功能有助于显示两个变量之间的频率分布。 我们将使用它来获取实际值和预测值之间的交叉表，然后我们将使用 SciKit 的`classification_report`函数来获取精度和调用值：
+在前面的代码中，我们在测试数据上获得预测的概率，然后根据`0.7`的阈值为事件分配`True`或`False`。 我们使用Pandas的交叉表功能，该功能有助于显示两个变量之间的频率分布。 我们将使用它来获取实际值和预测值之间的交叉表，然后我们将使用 SciKit 的`classification_report`函数来获取精度和调用值：
 
 ![Evaluating a model based on test data](img/B03450_07_09.jpg)
 

new/py-ds-essentials/1.md

@@ -281,7 +281,7 @@ $> conda remove <package-name>
 
 # 有思想的檐篷
 
-[**Enthought Canopy**](https://www.enthought.com/products/canopy/) 是 Enthought Inc.的 Python 发行版本。它包含 200 多个预装的软件包，例如 NumPy， SciPy，Matplotlib，Jupyter 和熊猫。 此分发针对工程师，数据科学家，定量和数据分析师以及企业。 它的基本版本是免费的（称为 Canopy Express），但是如果您需要高级功能，则必须购买一个前端版本。 它是一个多平台发行版，其命令行安装工具为`canopy_cli`。
+[**Enthought Canopy**](https://www.enthought.com/products/canopy/) 是 Enthought Inc.的 Python 发行版本。它包含 200 多个预装的软件包，例如 NumPy， SciPy，Matplotlib，Jupyter 和Pandas。 此分发针对工程师，数据科学家，定量和数据分析师以及企业。 它的基本版本是免费的（称为 Canopy Express），但是如果您需要高级功能，则必须购买一个前端版本。 它是一个多平台发行版，其命令行安装工具为`canopy_cli`。
 
 # WinPython 的
 
@@ -450,9 +450,9 @@ SciPy 由 Travis Oliphant，Pearu Peterson 和 Eric Jones 共同发起的原始
 *   **打印时的版本**：1.1.0
 *   **建议的安装命令**：``pip install scipy``
 
-# 大熊猫
+# Pandas
 
-大熊猫软件包处理 NumPy 和 SciPy 无法执行的所有操作。 借助其特定的数据结构，即 DataFrames 和 Series，pandas 允许您处理不同类型（NumPy 的数组无法执行的操作）和时间序列的复杂数据表。 由于 Wes McKinney 的创造，您将能够轻松，平稳地从各种来源加载数据。 然后，您可以切片，切块，处理丢失的元素，添加，重命名，聚合，重塑形状，最后随意可视化数据：
+Pandas软件包处理 NumPy 和 SciPy 无法执行的所有操作。 借助其特定的数据结构，即 DataFrames 和 Series，pandas 允许您处理不同类型（NumPy 的数组无法执行的操作）和时间序列的复杂数据表。 由于 Wes McKinney 的创造，您将能够轻松，平稳地从各种来源加载数据。 然后，您可以切片，切块，处理丢失的元素，添加，重命名，聚合，重塑形状，最后随意可视化数据：
 
 *   [**网站**](http://pandas.pydata.org/)
 *   **打印时的版本**：0.23.1
@@ -464,7 +464,7 @@ SciPy 由 Travis Oliphant，Pearu Peterson 和 Eric Jones 共同发起的原始
 import pandas as pd
 ```
 
-# 熊猫分析
+# Pandas分析
 
 这是一个 GitHub 项目，可以轻松地从 pandas DataFrame 创建报告。 该软件包将在交互式 HTML 报告中提供以下措施，该报告用于评估数据科学项目中的手头数据：
 
@@ -1354,7 +1354,7 @@ In:  print (housing[0,:3], 'n', housing_int[0,:3]) Out: [  6.32000000e-03   1.80
 
 可以从[这个页面](http://archive.ics.uci.edu/ml/machine-learning-databases/iris/)下载数据集。 该档案库是 UC Irvine 机器学习存储库，目前存储着 440 个数据集，作为对机器学习社区的服务。 除了该 Iris 数据集之外，您还可以自由下载并尝试使用存储库中存在的任何其他数据集。
 
-此时，使用熊猫的`read_csv`非常简单：
+此时，使用Pandas的`read_csv`非常简单：
 
 ```py
 In: iris_filename = 'datasets-uci-iris.csv'
@@ -1370,7 +1370,7 @@ In: iris_filename = 'datasets-uci-iris.csv'
 
 另外，我们定义的名称使用单个单词（而不是空格，而是使用下划线）。 因此，我们以后可以像调用方法一样直接调用它们来直接提取单个变量。 例如，`iris.sepal_length`将提取萼片长度数据。
 
-此时，如果您需要将熊猫`DataFrame`转换为几个包含数据和目标值的 NumPy 数组，则可以通过以下命令轻松完成：
+此时，如果您需要将Pandas`DataFrame`转换为几个包含数据和目标值的 NumPy 数组，则可以通过以下命令轻松完成：
 
 ```py
 In: iris_data = iris.values[:,:4]

new/py-ds-essentials/3.md

@@ -96,7 +96,7 @@ In: scatterplot = iris.plot(kind='scatter',
 
 ![](img/6e332947-47fe-450a-8354-87a2ce0be9e8.png)
 
-趋势十分明显。 我们推断`x`和`y`密切相关。 您通常在 EDA 期间执行的最后一项操作是检查功能的分布。 要使用大熊猫进行管理，您可以使用直方图来估算分布，这要归功于以下代码段：
+趋势十分明显。 我们推断`x`和`y`密切相关。 您通常在 EDA 期间执行的最后一项操作是检查功能的分布。 要使用Pandas进行管理，您可以使用直方图来估算分布，这要归功于以下代码段：
 
 ```py
 In: distr = iris.petal_width.plot(kind='hist', alpha=0.5, bins=20)

new/py-ds-essentials/4.md

@@ -1725,4 +1725,4 @@ In: w2v.wv.similarity('woman', 'girl'), w2v.similarity('woman', 'boy') **Out:**
 
 在本章中，我们介绍了机器学习的要点。 我们从一些简单但仍然非常有效的分类器开始（线性和逻辑回归器，朴素贝叶斯和 K 最近邻）。 然后，我们继续使用更高级的（SVM）。 我们介绍了如何将弱分类器组合在一起（集合，随机森林，梯度树增强），并介绍了三个很棒的梯度增强分类器：XGboost，LightGBM 和 CatBoost。 最后，我们窥视了大数据，集群和 NLP 中使用的算法。
 
-在下一章中，我们将向您介绍 Matplotlib 可视化的基础知识，如何使用熊猫操作 EDA 并通过 Seaborn 实现漂亮的可视化，以及如何设置 Web 服务器以按需提供信息。
\ No newline at end of file
+在下一章中，我们将向您介绍 Matplotlib 可视化的基础知识，如何使用Pandas操作 EDA 并通过 Seaborn 实现漂亮的可视化，以及如何设置 Web 服务器以按需提供信息。
\ No newline at end of file

new/py-ds-essentials/5.md

@@ -299,7 +299,7 @@ In: plt.imshow(digits.images[0],
 
 ![](img/1078faf0-6c41-4b3e-a435-93958e7f68b4.png)
 
-# 精选的熊猫图形实例
+# 精选的Pandas图形实例
 
 使用适当设置的超参数，许多机器学习算法可以最佳地学习如何根据目标结果映射数据。 但是，通过解决数据中隐藏和细微的问题，可以进一步提高其预测性能。 这不仅仅是检测任何丢失或异常情况的问题。 有时，这取决于数据中是否存在任何组或异常分布（例如，多峰分布）。 明确起草的数据图可以阐明变量之间的关系，并且可以导致创建新的更好的特征，从而以更高的准确性预测目标变量。
 
@@ -320,11 +320,11 @@ In: import pandas as pd
     iris_df['groups'] = pd.Series([iris.target_names[k] for k in groups]) Out: Your pandas version is: 0.23.1  
 ```
 
-请检查您的熊猫版本。 我们在`pandas`的 0.23.1 版本下测试了该书中的代码，它在以后的版本中也应适用。
+请检查您的Pandas版本。 我们在`pandas`的 0.23.1 版本下测试了该书中的代码，它在以后的版本中也应适用。
 
 以下段落中介绍的所有示例都将使用`iris_df` DataFrame。
 
-`pandas`软件包实际上依赖于 matplotlib 函数进行可视化。 它只是为其他复杂的绘图指令提供了一个方便的包装器。 这在速度和简便性方面具有优势，这是任何 EDA 过程的核心价值。 相反，如果您的目的是通过使用精美的可视化效果最好地传达发现，您可能会注意到自定义熊猫图形输出并不是那么容易。 因此，当最重要的是要创建特定的图形输出时，最好使用 matplotlib 指令从头开始直接工作。
+`pandas`软件包实际上依赖于 matplotlib 函数进行可视化。 它只是为其他复杂的绘图指令提供了一个方便的包装器。 这在速度和简便性方面具有优势，这是任何 EDA 过程的核心价值。 相反，如果您的目的是通过使用精美的可视化效果最好地传达发现，您可能会注意到自定义Pandas图形输出并不是那么容易。 因此，当最重要的是要创建特定的图形输出时，最好使用 matplotlib 指令从头开始直接工作。
 
 # 使用箱线图和直方图
 
@@ -431,13 +431,13 @@ In: from pandas.tools.plotting import parallel_coordinates
 
 **![](img/6171eb95-f89e-4111-8cca-0b41ce1358da.png)**
 
-`parallel_coordinates`是一个熊猫函数，为了正常工作，仅需要数据 DataFrame 和包含要测试其可分离性的组的变量的字符串名称作为参数。 因此，您应该在数据集中使用组变量。 但是，使用`DataFrame.drop('variable name', axis=1, inplace=True)`方法完成探索后，不要忘记将其删除。
+`parallel_coordinates`是一个Pandas函数，为了正常工作，仅需要数据 DataFrame 和包含要测试其可分离性的组的变量的字符串名称作为参数。 因此，您应该在数据集中使用组变量。 但是，使用`DataFrame.drop('variable name', axis=1, inplace=True)`方法完成探索后，不要忘记将其删除。
 
 # 总结 matplotlib 的命令
 
-正如我们在上一段中所看到的那样，熊猫可以将可视化的数据浏览速度提高，因为它可以打包成单个命令，而使用 matplotlib 则需要完整的代码片段。 其背后的想法是，除非需要定制和配置特殊的可视化效果，否则使用包装器可以使您更快地创建标准图形。
+正如我们在上一段中所看到的那样，Pandas可以将可视化的数据浏览速度提高，因为它可以打包成单个命令，而使用 matplotlib 则需要完整的代码片段。 其背后的想法是，除非需要定制和配置特殊的可视化效果，否则使用包装器可以使您更快地创建标准图形。
 
-除熊猫外，其他软件包还将来自 matplotlib 的低级指令组装为更用户友好的命令，以用于特定的表示形式和用法：
+除Pandas外，其他软件包还将来自 matplotlib 的低级指令组装为更用户友好的命令，以用于特定的表示形式和用法：
 
 *   Seaborn 是一个软件包，它通过为您提供一组统计图来扩展趋势图和区分组的功能，从而扩展了您的可视化功能
 *   `ggplot`是流行的 R 库`ggplot2`（ [ggplot2.tidyverse.org](https://ggplot2.tidyverse.org/) ）的端口，它基于 Leland Wilkinson 的书《图形语法》中提出的可视化语法。 R 库是不断开发的，它提供了很多功能； Python 移植（ [ggplot.yhathq.com](http://ggplot.yhathq.com/) ）具有基础知识（ [ggplot.yhathq.com/docs/index.html](http://ggplot.yhathq.com/docs/index.html) ），并且其完整的开发工作仍在进行中（ [github .com / yhat / ggplot](https://github.com/yhat/ggpy) ）。
@@ -485,7 +485,7 @@ In: x = np.linspace(0, 5, 50)
 
 **![](img/fada78e1-ba2d-4c7e-a128-174ebfa9d36a.png)**
 
-您可以从任何以前看到的图表中获得有趣的结果，甚至可以使用熊猫中的图形方法生成的图表（毕竟，熊猫还依赖于 matplotlib 来创建其探索性图表）。
+您可以从任何以前看到的图表中获得有趣的结果，甚至可以使用Pandas中的图形方法生成的图表（毕竟，Pandas还依赖于 matplotlib 来创建其探索性图表）。
 
 Seaborn 中有五个预设主题：
 
@@ -949,7 +949,7 @@ Bottle 是一个 Python 网络框架，是 HTTP 上微型应用程序的起点
 
 请注意，在此虚拟示例中，我们仅定义了`/personal/<name>`路由。 除非代码中定义，否则任何其他调用都将导致`Error 404`。
 
-要关闭它，我们需要在命令行中按 *Ctrl* +`C`（记住`run`功能正在阻止）。
+要关闭它，我们需要在命令行中按`Ctrl + C`（记住`run`功能正在阻止）。
 
 现在让我们创建一个更加面向数据科学的服务； 我们将创建一个 HTML 页面，该页面的表单要求隔垫的长度和宽度以及花瓣的长度和宽度，以对虹膜样本进行分类。 在此示例中，我们将使用虹膜数据集来训练 scikit-learn 分类器。 然后，对于每个预测，我们只需在分类器上调用`predict`函数，将预测发送回去：
 
@@ -991,6 +991,6 @@ Bottle 是一个 Python 网络框架，是 HTTP 上微型应用程序的起点
 
 # 概括
 
-本章通过提供数据，机器学习过程和结果的基本和高级图形表示的示例，概述了基本数据科学。 我们探索了来自 matplotlib 的`pylab`模块，该模块可让您最轻松，最快地访问该软件包的图形功能。 我们将熊猫用于 EDA，并测试了 scikit-learn 提供的图形实用程序。 所有示例都像构建块一样，并且都易于定制，以便为您提供快速的可视化模板。
+本章通过提供数据，机器学习过程和结果的基本和高级图形表示的示例，概述了基本数据科学。 我们探索了来自 matplotlib 的`pylab`模块，该模块可让您最轻松，最快地访问该软件包的图形功能。 我们将Pandas用于 EDA，并测试了 scikit-learn 提供的图形实用程序。 所有示例都像构建块一样，并且都易于定制，以便为您提供快速的可视化模板。
 
 在下一章中，将向您介绍**图**，它们是与预测变量/目标平坦矩阵的有趣偏差。 现在，它们已成为数据科学中的热门话题。 期望深入研究非常复杂和复杂的网络。
\ No newline at end of file

new/thoughtful-ds/00.md

@@ -48,7 +48,7 @@
 
 第 2 章，*借助 Jupyter Notebook 和 PixieDust* 进行大规模数据科学，我开始深入研究流行的数据科学工具，例如 Python 及其专用于数据科学的开源库生态系统，以及 当然 Jupyter 笔记本。 我解释了为什么我认为 Jupyter 笔记本电脑将在未来几年成为大赢家。 我还从简单的`display()`方法开始介绍 PixieDust 开源库功能，该方法使用户可以通过构建引人注目的图表直观地浏览交互式用户界面中的数据。 使用此 API，用户可以从多个渲染引擎（例如 Matplotlib，Bokeh，Seaborn 和 Mapbox）中进行选择。 `display()`功能是 PixieDust MVP（最低可行产品）中的唯一功能，但是随着时间的流逝，当我与许多数据科学从业人员进行互动时，我为快速成为 PixieDust 工具箱添加了新功能：
 
-*   **sampleData（）**：一个简单的 API，可轻松将数据加载到熊猫和 Apache Spark DataFrames 中
+*   **sampleData（）**：一个简单的 API，可轻松将数据加载到Pandas和 Apache Spark DataFrames 中
 *   **wrangle_data（）**：用于清理和按摩数据集的简单 API。 此功能包括使用正则表达式从非结构化文本中提取内容的功能，可将列分解为新的列。 `wrangle_data()` API 也可以基于预定义的模式提出建议。
 *   **PackageManager**：允许用户在 Python Notebook 中安装第三方 Apache Spark 软件包。
 *   **Scala Bridge**：使用户能够在 Python Notebook 中运行 Scala 代码。 在 Python 端定义的变量可以在 Scala 中访问，反之亦然。

new/thoughtful-ds/02.md

@@ -71,7 +71,7 @@ GitHub 上的 Jupyter Notebooks 的搜索结果
 
 [PixieDust](https://github.com/ibm-watson-data-lab/pixiedust) 是一个开源项目，主要由三个组件组成，旨在解决本章开头所述的三个目标。
 
-*   一个适用于 Jupyter Notebooks 的辅助 Python 库，它提供了简单的 API，可将各种来源的数据加载到流行的框架（如熊猫和 Apache Spark DataFrame）中，然后以交互方式可视化和浏览数据集。
+*   一个适用于 Jupyter Notebooks 的辅助 Python 库，它提供了简单的 API，可将各种来源的数据加载到流行的框架（如Pandas和 Apache Spark DataFrame）中，然后以交互方式可视化和浏览数据集。
 *   一个基于 Python 的简单编程模型，通过创建功能强大的仪表板 PixieApps，开发人员可以将分析结果直接“产品化”到 Notebook 中。 正如我们将在下一章中看到的那样，PixieApps 与传统的 **BI**（**Business Intelligence** 的缩写）仪表板有所不同，因为开发人员可以直接使用 HTML 和 CSS 来创建 任意复杂的布局。 此外，他们可以将对笔记本中创建的任何变量，类或函数的访问权限嵌入其业务逻辑中。
 *   一个安全的微服务 Web 服务器，称为 PixieGateway，可以将 PixieApps 作为独立的 Web 应用程序运行，也可以作为可以嵌入到任何网站中的组件运行。 使用图形向导可以从 Jupyter Notebook 轻松部署 PixieApps，而无需更改任何代码。 此外，PixieGateway 支持将由 PixieDust 创建的任何图表共享为可嵌入的网页，从而使数据科学家可以轻松地在笔记本电脑外部传达结果。
 
@@ -184,13 +184,13 @@ c.NotebookApp.open_browser = False
 
 将数据加载到笔记本中是数据科学家可以执行的最多重复任务之一，但是根据所使用的框架或数据源，编写代码可能既困难又耗时。
 
-让我们举一个具体的示例，尝试从一个开放的数据站点（例如[这个页面](https://data.cityofnewyork.us)）中将 CSV 文件加载到大熊猫和 Apache Spark DataFrame 中。
+让我们举一个具体的示例，尝试从一个开放的数据站点（例如[这个页面](https://data.cityofnewyork.us)）中将 CSV 文件加载到Pandas和 Apache Spark DataFrame 中。
 
 ### 注意
 
 **注意**：继续，假定所有代码都在 Jupyter Notebook 中运行。
 
-对于熊猫来说，代码非常简单，因为它提供了直接从 URL 加载的 API：
+对于Pandas来说，代码非常简单，因为它提供了直接从 URL 加载的 API：
 
 ```py
 import pandas
@@ -203,7 +203,7 @@ building_df
 
 ![SampleData – a simple API for loading data](img/00016.jpeg)
 
-熊猫 DataFrame 的默认输出
+Pandas DataFrame 的默认输出
 
 但是，对于 Apache Spark，我们需要先将数据下载到文件中，然后使用 Spark CSV 连接器将其加载到 DataFrame 中：
 
@@ -233,7 +233,7 @@ building_df
 
 Spark DataFrame 的默认输出
 
-即使此代码不是那么大，也必须每次都重复，并且很可能需要花费时间进行 Google 搜索以记住正确的语法。 数据也可以采用其他格式，例如 JSON，这将要求为熊猫和 Spark 调用不同的 API。 数据的格式也可能不正确，并且可能在 CSV 文件中包含错误的行或 JSON 语法错误。 不幸的是，所有这些问题并非罕见，并助长了数据科学的 80/20 规则，该规则指出，数据科学家平均花费 80％的时间来获取，清理和加载数据，而只有 20％的时间用于实际分析。
+即使此代码不是那么大，也必须每次都重复，并且很可能需要花费时间进行 Google 搜索以记住正确的语法。 数据也可以采用其他格式，例如 JSON，这将要求为Pandas和 Spark 调用不同的 API。 数据的格式也可能不正确，并且可能在 CSV 文件中包含错误的行或 JSON 语法错误。 不幸的是，所有这些问题并非罕见，并助长了数据科学的 80/20 规则，该规则指出，数据科学家平均花费 80％的时间来获取，清理和加载数据，而只有 20％的时间用于实际分析。
 
 PixieDust 提供了一个简单的`sampleData` API，以帮助改善这种情况。 当不带参数调用时，它将显示准备分析的预整理数据集的列表：
 
@@ -282,7 +282,7 @@ cars = pixiedust.sampleData(1)
 
 使用 PixieDust sampleData API 加载内置数据集
 
-用户还可以传递指向可下载文件的任意 URL。 PixieDust 当前支持 JSON 和 CSV 文件。 在这种情况下，PixieDust 将自动下载文件，将缓存在临时区域中，检测格式，然后根据 Spark 是否在笔记本电脑中可用加载到 Spark 或 pandas DataFrame 中。 请注意，即使使用`forcePandas`关键字参数可以使用 Spark，用户也可以强制加载到熊猫中：
+用户还可以传递指向可下载文件的任意 URL。 PixieDust 当前支持 JSON 和 CSV 文件。 在这种情况下，PixieDust 将自动下载文件，将缓存在临时区域中，检测格式，然后根据 Spark 是否在笔记本电脑中可用加载到 Spark 或 pandas DataFrame 中。 请注意，即使使用`forcePandas`关键字参数可以使用 Spark，用户也可以强制加载到Pandas中：
 
 ```py
 import pixiedust
@@ -390,9 +390,9 @@ wrangle_data（）工作流程
 
 wrangle_data（）模式编辑器
 
-前面的架构窗口小部件显示了列名称`Rosie Type`（特定于 Rosie 的高级类型表示）和`Column Type`（映射至受支持的熊猫类型）。 每行还包含三个操作按钮：
+前面的架构窗口小部件显示了列名称`Rosie Type`（特定于 Rosie 的高级类型表示）和`Column Type`（映射至受支持的Pandas类型）。 每行还包含三个操作按钮：
 
-*   **删除列**：这将从架构中删除列。 此列将不会出现在最终的熊猫 DataFrame 中。
+*   **删除列**：这将从架构中删除列。 此列将不会出现在最终的Pandas DataFrame 中。
 *   **重命名列**：这将更改列的名称。
 *   **转换列**：这通过将列分解为新列来对其进行转换。
 
@@ -435,9 +435,9 @@ wrangle_data（）模式编辑器
 
 ![Wrangling data with pixiedust_rosie](img/00029.jpeg)
 
-编辑结果熊猫数据框的变量名
+编辑结果Pandas数据框的变量名
 
-单击 **Finish** 按钮后，`pixiedust_rosie`应用模式定义遍历整个数据集。 完成后，它将使用生成的代码在当前单元的下面创建一个新单元格，该代码在新生成的熊猫 DataFrame 上调用`display()` API，如下所示：
+单击 **Finish** 按钮后，`pixiedust_rosie`应用模式定义遍历整个数据集。 完成后，它将使用生成的代码在当前单元的下面创建一个新单元格，该代码在新生成的Pandas DataFrame 上调用`display()` API，如下所示：
 
 ```py
 #Code generated by pixiedust_rosie
@@ -461,7 +461,7 @@ display(wrangled_df)
 
 为解决此问题，PixieDust 提供了一个简单的`display()` API，该 API 使 Jupyter Notebook 用户可以使用交互式图形界面来绘制数据而无需任何编码。 这个 API 实际上不会创建图表，但是会在根据用户选择通过调用其 API 委托给渲染器之前完成准备数据的所有繁重工作。
 
-`display()` API 支持多种数据结构（熊猫，Spark 和 JSON）以及多种渲染器（Matplotlib，Seaborn，Bokeh 和 Brunel）。
+`display()` API 支持多种数据结构（Pandas，Spark 和 JSON）以及多种渲染器（Matplotlib，Seaborn，Bokeh 和 Brunel）。
 
 作为说明，让我们使用内置的汽车性能数据集，并通过调用`display()` API 开始可视化数据：
 
@@ -627,7 +627,7 @@ Mapbox 图表的“选项”对话框
 
 在大多数情况下，这是数据科学与软件工程相遇的地方（或者就像人们所说的*，橡胶与道路相遇*）。 团队之间的持续协作（而不是一次交接）是成功完成任务的关键。 通常，他们还必须应对不同的语言和平台，从而导致软件工程团队重写大量代码。
 
-当我们需要构建实时仪表板以可视化结果时，我们在 Twitter 主题标签项目的情绪分析中亲身体验了它。 数据分析是使用熊猫，Apache Spark 和一些绘图库（例如 Matplotlib 和 Bokeh）以 Python 编写的，而仪表板是用 [Node.js](https://nodejs.org) 和 [D3](https://d3js.org) 编写的。
+当我们需要构建实时仪表板以可视化结果时，我们在 Twitter 主题标签项目的情绪分析中亲身体验了它。 数据分析是使用Pandas，Apache Spark 和一些绘图库（例如 Matplotlib 和 Bokeh）以 Python 编写的，而仪表板是用 [Node.js](https://nodejs.org) 和 [D3](https://d3js.org) 编写的。
 
 我们还需要在分析和仪表板之间建立数据接口，并且由于我们需要系统是实时的，因此我们选择使用 Apache Kafka 来流化分析结果格式的事件。
 

new/thoughtful-ds/03.md

@@ -516,7 +516,7 @@ github_token = "XXXXXXXXXX"
 
 为了提供良好的代码模块化和重用性，我们将在新类中实现 Repo Visualization 页面，并使我们的主要 PixieApp 类继承自该类并自动重用其路由。 当您开始拥有大型项目并将其分解为多个类时，请牢记这种模式。
 
-“回购可视化”页面的主要路径返回一个 HTML 片段，该片段具有一个下拉菜单和一个用于可视化的`<div>`占位符。 使用 [Bootstrap `dropdown`类](https://www.w3schools.com/bootstrap/bootstrap_dropdowns.asp)创建下拉菜单。 为了使代码更易于维护，菜单项是通过在元组数组上使用 [Jinja2 `{%for..` `%}`循环](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)生成的，称为`analyses`的元组和序列，其中包含描述和将数据加载到熊猫 DataFrame 中的函数。 再次在这里，我们在自己的单元格中创建此数组，该数组将在 PixieApp 类中引用：
+“回购可视化”页面的主要路径返回一个 HTML 片段，该片段具有一个下拉菜单和一个用于可视化的`<div>`占位符。 使用 [Bootstrap `dropdown`类](https://www.w3schools.com/bootstrap/bootstrap_dropdowns.asp)创建下拉菜单。 为了使代码更易于维护，菜单项是通过在元组数组上使用 [Jinja2 `{%for..` `%}`循环](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)生成的，称为`analyses`的元组和序列，其中包含描述和将数据加载到Pandas DataFrame 中的函数。 再次在这里，我们在自己的单元格中创建此数组，该数组将在 PixieApp 类中引用：
 
 ```py
 analyses = [("Commit Activity", load_commit_activity)]
@@ -576,9 +576,9 @@ class RepoAnalysis():
 
 ## 使用 pd_entity 属性调用 PixieDust display（）API
 
-当使用`pd_options`属性创建内核请求时，PixieApp 框架将当前 PixieApp 类用作目标。 但是，您可以通过指定`pd_entity`属性来更改此目标。 例如，您可以指向另一个 PixieApp，或更有趣的是，指向`display()` API 支持的数据结构，例如熊猫或 Spark DataFrame。 在这种情况下，如果您提供了`display()` API 预期的正确选项，则生成的输出将为图表本身（对于 Matplotlib，为图像；对于 Mapbox，为 Iframe；对于 Mapbox，则为 SVG 散景）。 一种获取正确选项的简单方法是在其自己的单元格中调用`display()` API，使用菜单将其配置为所需的图表，然后通过单击**编辑元数据**复制可用的单元格元数据 JSON 片段。 按钮。 （您可能首先需要使用菜单**视图** | **单元格工具栏** | **编辑元数据**来启用按钮）。
+当使用`pd_options`属性创建内核请求时，PixieApp 框架将当前 PixieApp 类用作目标。 但是，您可以通过指定`pd_entity`属性来更改此目标。 例如，您可以指向另一个 PixieApp，或更有趣的是，指向`display()` API 支持的数据结构，例如Pandas或 Spark DataFrame。 在这种情况下，如果您提供了`display()` API 预期的正确选项，则生成的输出将为图表本身（对于 Matplotlib，为图像；对于 Mapbox，为 Iframe；对于 Mapbox，则为 SVG 散景）。 一种获取正确选项的简单方法是在其自己的单元格中调用`display()` API，使用菜单将其配置为所需的图表，然后通过单击**编辑元数据**复制可用的单元格元数据 JSON 片段。 按钮。 （您可能首先需要使用菜单**视图** | **单元格工具栏** | **编辑元数据**来启用按钮）。
 
-您也可以指定`pd_entity`，不带任何值。 在这种情况下，PixieApp 框架将使用传递为用于启动 PixieApp 应用程序的`run`方法的第一个参数的实体。 例如，以`cars`为熊猫的`my_pixieapp.run(cars)`或通过`pixiedust.sampleData()`方法创建的 Spark DataFrame。 `pd_entity`的值也可以是返回实体的函数调用。 当您要在渲染之前动态计算实体时，这很有用。 与其他变量一样，`pd_entity`的范围可以是 PixieApp 类或在 Notebook 中声明的任何变量。
+您也可以指定`pd_entity`，不带任何值。 在这种情况下，PixieApp 框架将使用传递为用于启动 PixieApp 应用程序的`run`方法的第一个参数的实体。 例如，以`cars`为Pandas的`my_pixieapp.run(cars)`或通过`pixiedust.sampleData()`方法创建的 Spark DataFrame。 `pd_entity`的值也可以是返回实体的函数调用。 当您要在渲染之前动态计算实体时，这很有用。 与其他变量一样，`pd_entity`的范围可以是 PixieApp 类或在 Notebook 中声明的任何变量。
 
 例如，我们可以在其自己的单元格中创建一个函数，该函数将前缀作为参数并返回 pandas DataFrame。 然后我们将其用作我的 PixieApp 中的`pd_entity`值，如以下代码所示：
 
@@ -662,7 +662,7 @@ def load_commit_activity(owner, repo_name):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%203/sampleCode11.py)。
 
-前面的代码将 GET 请求发送到 GitHub，并使用在笔记本开始时设置的`github_user`和`github_token`变量进行身份验证。 响应是一个 JSON 有效负载，我们将使用它创建一个熊猫 DataFrame。 在创建 DataFrame 之前，我们需要将 JSON 有效负载转换为正确的格式。 现在，有效负载如下所示：
+前面的代码将 GET 请求发送到 GitHub，并使用在笔记本开始时设置的`github_user`和`github_token`变量进行身份验证。 响应是一个 JSON 有效负载，我们将使用它创建一个Pandas DataFrame。 在创建 DataFrame 之前，我们需要将 JSON 有效负载转换为正确的格式。 现在，有效负载如下所示：
 
 ```py
 [
@@ -919,7 +919,7 @@ def get_pdf(self):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%203/sampleCode17.py)。
 
-我们使用大熊猫[`describe()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.describe.html)返回包含摘要的 DataFrame 统计信息，例如计数，均值，标准差等。 我们还确保此 DataFrame 的第一列包含统计信息的名称。
+我们使用Pandas[`describe()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.describe.html)返回包含摘要的 DataFrame 统计信息，例如计数，均值，标准差等。 我们还确保此 DataFrame 的第一列包含统计信息的名称。
 
 我们需要做的最后一个更改是初始化`show_stats`变量，因为如果不这样做，那么第一次检查它时，我们会得到`AttributeError`异常。
 

new/thoughtful-ds/04.md

@@ -104,7 +104,7 @@ Pixiedust version 1.1.10
 
 ### 注意
 
-**注意**：要停止 PixieGateway 服务器，只需从终端使用 *Ctrl* +`C`。
+**注意**：要停止 PixieGateway 服务器，只需从终端使用`Ctrl + C`。
 
 现在，您可以通过以下 URL 打开 PixieGateway 管理控制台：`http://localhost:8899/admin`。
 

new/thoughtful-ds/05.md

@@ -628,7 +628,7 @@ PixieDust 扩展层
 
 *   `newDisplayHandler(self,options,entity)`：当用户激活菜单时，将调用`newDisplayHandler()`方法。 此方法必须返回从`pixiedust.display.Display`继承的类实例。 该类的合同用于实现`doRender()`方法，该方法负责创建可视化文件。
 
-让我们以为熊猫 DataFrame 创建自定义表格渲染为例。 我们首先创建用于配置菜单和工厂方法的`DisplayHandlerMeta`类：
+让我们以为Pandas DataFrame 创建自定义表格渲染为例。 我们首先创建用于配置菜单和工厂方法的`DisplayHandlerMeta`类：
 
 ```py
 from pixiedust.display.display import *
@@ -699,7 +699,7 @@ self._addHTMLTemplate('simpleTable.html', custom_arg = "Some value")
 
 ### 注意
 
-**注意**：**简单表**扩展名仅适用于熊猫，不适用于 Spark DataFrame。 因此，如果您的笔记本计算机连接到 Spark，则在调用`sampleData()`时需要使用`forcePandas = True`。
+**注意**：**简单表**扩展名仅适用于Pandas，不适用于 Spark DataFrame。 因此，如果您的笔记本计算机连接到 Spark，则在调用`sampleData()`时需要使用`forcePandas = True`。
 
 ![Extending PixieDust visualizations](img/00091.jpeg)
 

new/thoughtful-ds/06.md

@@ -338,7 +338,7 @@ def eval_input_fn(features, labels, batch_size):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode3.py)。
 
-下一步是构建 PixieApp，它将从作为输入传递给`run`方法的熊猫 DataFrame 创建分类器。 主屏幕将所有数字列的列表构建到一个下拉控件中，并要求用户选择将用作分类器输出的列。 在下面的代码中，这是通过 Jinja2 `{%for ...%}`循环来实现的，该循环在使用`pixieapp_entity`变量引用的作为输入传递的 DataFrame 上进行迭代。
+下一步是构建 PixieApp，它将从作为输入传递给`run`方法的Pandas DataFrame 创建分类器。 主屏幕将所有数字列的列表构建到一个下拉控件中，并要求用户选择将用作分类器输出的列。 在下面的代码中，这是通过 Jinja2 `{%for ...%}`循环来实现的，该循环在使用`pixieapp_entity`变量引用的作为输入传递的 DataFrame 上进行迭代。
 
 ### 注意
 
@@ -396,7 +396,7 @@ app.run(crimes)
 
 ![Simple classification with DNNClassifier](img/00131.jpeg)
 
-主屏幕显示输入熊猫 DataFrame 中的列列表
+主屏幕显示输入Pandas DataFrame 中的列列表
 
 当用户选择预测列（例如`nonviolent`）时，新的`prepare_training`路线将由`pd_options="predictor=$val(cols{{prefix}})"`属性触发。 此路线将显示两个条形图，分别显示训练集和测试集的输出类别分布，它们是使用从原始数据集中以 80/20 分割随机选择的。
 

new/thoughtful-ds/08.md

@@ -266,11 +266,11 @@ statsmodels.tsa.tests.test_stattools.TestACF_FFT
 
 **注意**：pandas 与 NumPy 紧密集成，可让您将这些 NumPy 操作应用于 pandas DataFrames。 在本章其余部分中，当分析时间序列时，我们将大量使用此功能。
 
-以下代码示例创建一个熊猫 DataFrame 并计算所有列的平方：
+以下代码示例创建一个Pandas DataFrame 并计算所有列的平方：
 
 ![Operations on ndarray](img/00168.jpeg)
 
-将 NumPy 操作应用于熊猫 DataFrames
+将 NumPy 操作应用于Pandas DataFrames
 
 ## NumPy 数组上的选择
 
@@ -471,7 +471,7 @@ array([[ 1,  3,  5,  7],
 
     一个有趣的关键字参数`returns`控制该方法返回的数据结构，并且可以采用以下两个值：
 
-    *   `pandas`：返回熊猫 DataFrame
+    *   `pandas`：返回Pandas DataFrame
     *   `numpy`：返回一个 NumPy 数组
 
 *   `quandl.get_table(datatable_code, **kwargs)`：返回有关资源的非时间序列数据集（称为`datatable`）。 我们不会在本章中使用此方法，[但是您可以通过查看以下代码找到更多有关此方法](https://github.com/quandl/quandl-python/blob/master/quandl/get_table.py)。
@@ -583,7 +583,7 @@ display(codes)
 
 WIKI 数据库的数据集列表
 
-在本节的其余部分中，我们将加载过去几年中的 Microsoft 股票（股票代码 MSFT）的历史时间序列数据，并开始探索其统计属性。 在下面的代码中，我们将`quandl.get()`与`WIKI/MSFT`数据集结合使用。 我们添加了一个称为`daily_spread`的列，该列通过调用熊猫`diff()`方法来计算每日收益/损失，该方法返回当前和先前调整后的收盘价之间的差额。 请注意，返回的熊猫 DataFrame 使用日期作为索引，但是 PixieDust 目前不支持通过索引绘制时间序列。 因此，在以下代码中，我们调用`reset_index()`将`DateTime`索引转换为名为`Date`的新列，其中包含日期信息：
+在本节的其余部分中，我们将加载过去几年中的 Microsoft 股票（股票代码 MSFT）的历史时间序列数据，并开始探索其统计属性。 在下面的代码中，我们将`quandl.get()`与`WIKI/MSFT`数据集结合使用。 我们添加了一个称为`daily_spread`的列，该列通过调用Pandas`diff()`方法来计算每日收益/损失，该方法返回当前和先前调整后的收盘价之间的差额。 请注意，返回的Pandas DataFrame 使用日期作为索引，但是 PixieDust 目前不支持通过索引绘制时间序列。 因此，在以下代码中，我们调用`reset_index()`将`DateTime`索引转换为名为`Date`的新列，其中包含日期信息：
 
 ```py
 msft = quandl.get('WIKI/MSFT')
@@ -613,7 +613,7 @@ MSFT 股票的每日价差
 
 作为练习，让我们尝试创建一个图表，该图表显示在选定股票（MSFT）中进行 10,000 美元的假设投资会如何随着时间变化。 为此，我们必须计算一个 DataFrame，其中包含该期间每一天的总投资价值，并考虑到我们在上一段中计算的每日价差，并使用 PixieDust `display()` API 可视化数据。
 
-我们使用 pandas 功能使用基于日期的谓词来选择行，以首先过滤 DataFrame 以仅选择我们感兴趣的时间段内的数据点。然后，通过将 10,000 美元的初始投资除以交易结束时间来计算购买的股票数量 在该期间的第一天定价并加上初始投资价值。 多亏了熊猫的高效序列计算和底层的 NumPy 基础库，所有这些计算都变得非常容易。 我们使用[`np.cumsum()`方法](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.cumsum.html)计算所有 每日收益加上 10,000 美元的初始投资价值。
+我们使用 pandas 功能使用基于日期的谓词来选择行，以首先过滤 DataFrame 以仅选择我们感兴趣的时间段内的数据点。然后，通过将 10,000 美元的初始投资除以交易结束时间来计算购买的股票数量 在该期间的第一天定价并加上初始投资价值。 多亏了Pandas的高效序列计算和底层的 NumPy 基础库，所有这些计算都变得非常容易。 我们使用[`np.cumsum()`方法](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.cumsum.html)计算所有 每日收益加上 10,000 美元的初始投资价值。
 
 最后，我们使用`resample()`方法使图表更易于阅读，该方法将频率从每日转换为每月，并使用当月平均值计算新值。
 
@@ -644,7 +644,7 @@ display(investment)
 
 在尝试生成预测模型之前，必须了解时间序列是否具有可识别的模式，例如季节性或趋势。 一种流行的技术是根据指定的时滞来查看数据点与先前的数据点之间的关系。 直觉是自相关将揭示内部结构，例如，确定发生高相关（正或负）时的时间段。 您可以尝试不同的滞后值（即，对于每个数据点，要考虑多少个先前的点），以找到正确的周期。
 
-计算 ACF 通常需要为[数据点集](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)计算 Pearson R 相关系数。 好消息是`statsmodels` Python 库具有`tsa`程序包（**tsa** 代表**时间序列分析**），该程序包提供了辅助方法来计算 ACF， 与熊猫系列紧密集成。
+计算 ACF 通常需要为[数据点集](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)计算 Pearson R 相关系数。 好消息是`statsmodels` Python 库具有`tsa`程序包（**tsa** 代表**时间序列分析**），该程序包提供了辅助方法来计算 ACF， 与Pandas系列紧密集成。
 
 ### 注意
 
@@ -816,7 +816,7 @@ def set_active_ticker(self, ticker):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode12.py)。
 
-在`set_active_ticker()`中将特定股票代码的股票数据延迟加载到熊猫 DataFrame 中。 我们首先通过查看`df`键是否存在来检查是否已加载 DataFrame，如果不存在，我们用`dataset_code`：`'WIKI/{ticker}'`调用`quandl` API。 我们还添加了一个列，该列计算了将在基本探索屏幕中显示的股票的每日价差。 最后，我们需要在 DataFrame 上调用[`reset_index()`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.reset_index.html)以转换索引， 是`DateTimeIndex`进入其自己的列，称为`Date`。 原因是 PixieDust `display()`尚不支持使用`DateTimeIndex`可视化 DataFrame。
+在`set_active_ticker()`中将特定股票代码的股票数据延迟加载到Pandas DataFrame 中。 我们首先通过查看`df`键是否存在来检查是否已加载 DataFrame，如果不存在，我们用`dataset_code`：`'WIKI/{ticker}'`调用`quandl` API。 我们还添加了一个列，该列计算了将在基本探索屏幕中显示的股票的每日价差。 最后，我们需要在 DataFrame 上调用[`reset_index()`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.reset_index.html)以转换索引， 是`DateTimeIndex`进入其自己的列，称为`Date`。 原因是 PixieDust `display()`尚不支持使用`DateTimeIndex`可视化 DataFrame。
 
 在`explore`路由中，我们返回一个 HTML 片段，该片段构建了整个屏幕的布局。 如前面的模型所示，我们使用`btn-group-vertical`和`btn-group-toggle`引导程序类创建垂直导航栏。 菜单列表和关联的子 PixieApp 在`tabs` Python 变量中定义，我们使用 Jinja2 `{%for loop%}`构建内容。 我们还将在`id ="analytic_screen{{prefix}}"`中添加一个占位符`<div>`元素，该元素将成为子 PixieApp 屏幕的接收者。
 
@@ -1055,7 +1055,7 @@ $("[id^=slider][id$={{prefix}}]").each(function() {
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode19.py)。
 
-在`MovingAverageSubApp`中，我们使用`add_ticker_selection_markup`装饰器并将`chart{{prefix}}`作为默认路由的参数，以添加股票选择器选项卡，并添加一个名为`lag_slider`的`<div>`元素，其中包含`<pd_event_handler>`设置`self.lag`变量并刷新`chart` div。 `chart` div 将`pd_entity`属性与调用`rolling`方法的[`get_moving_average_df()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.rolling.html)一起使用，从选定的熊猫 DataFrame 返回滚动均值，并在其上调用`mean()`方法。 由于 PixieDust `display()`尚不支持 pandas 系列，因此我们将系列索引用作名为`x`的列来构建 pandas DataFrame，并以`get_moving_average_df()`方法返回它。
+在`MovingAverageSubApp`中，我们使用`add_ticker_selection_markup`装饰器并将`chart{{prefix}}`作为默认路由的参数，以添加股票选择器选项卡，并添加一个名为`lag_slider`的`<div>`元素，其中包含`<pd_event_handler>`设置`self.lag`变量并刷新`chart` div。 `chart` div 将`pd_entity`属性与调用`rolling`方法的[`get_moving_average_df()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.rolling.html)一起使用，从选定的Pandas DataFrame 返回滚动均值，并在其上调用`mean()`方法。 由于 PixieDust `display()`尚不支持 pandas 系列，因此我们将系列索引用作名为`x`的列来构建 pandas DataFrame，并以`get_moving_average_df()`方法返回它。
 
 以下代码显示了`MovingAverageSubApp`子 PixieApp 的实现
 
@@ -1280,7 +1280,7 @@ train_set, test_set = msft[:-14], msft[-14:]
 
 从上图可以清楚地看到从 2012 年开始的增长趋势，但没有明显的季节性。 因此，我们可以放心地假设没有平稳性。 让我们首先尝试一次应用对数差分转换，并绘制相应的 ACF 和 PACF 图表。
 
-在以下代码中，我们通过在`Adj. Close`列上使用`np.log()`来构建`logmsft`大熊猫系列，然后使用`logmsft`与 1 的滞后时间之间的差值来构建`logmsft_diff` pandas DataFrame。 `shift()`方法）。 像以前做过一样，我们也调用`reset_index()`将`Date`索引转换为一列，以便 PixieDust `display()`可以处理它：
+在以下代码中，我们通过在`Adj. Close`列上使用`np.log()`来构建`logmsft`Pandas系列，然后使用`logmsft`与 1 的滞后时间之间的差值来构建`logmsft_diff` pandas DataFrame。 `shift()`方法）。 像以前做过一样，我们也调用`reset_index()`将`Date`索引转换为一列，以便 PixieDust `display()`可以处理它：
 
 ```py
 logmsft = np.log(train_set['Adj. Close'])
@@ -1459,7 +1459,7 @@ plot_predict(arima_model, train_set['Date'], 10)
 
 前面的图表显示了预测与训练集中的实际观察值有多接近。 我们现在使用之前保留的测试集来进一步诊断模型。 对于这一部分，我们使用`forecast()`方法预测下一个数据点。 对于`test_set`的每个值，我们从称为历史的观察值数组中构建了新的 ARIMA 模型，其中包含包含每个预测值增加的训练数据。
 
-以下代码显示了`compute_test_set_predictions()`方法的实现，该方法以`train_set`和`test_set`作为参数，并返回一个熊猫数据帧，其中的`forecast`列包含所有预测值，而`test`列包含相应的 实际观测值：
+以下代码显示了`compute_test_set_predictions()`方法的实现，该方法以`train_set`和`test_set`作为参数，并返回一个Pandas数据帧，其中的`forecast`列包含所有预测值，而`test`列包含相应的 实际观测值：
 
 ```py
 def compute_test_set_predictions(train_set, test_set):

new/thoughtful-ds/09.md

@@ -259,7 +259,7 @@ import matplotlib.pyplot as plt
 *   `airlines.csv`：美国航空公司的列表，包括其 IATA 代码。
 *   `flights.csv`：2015 年发生的航班列表。此数据包括日期，始发和目的地机场，计划和实际时间以及延误。
 
-`flights.csv`文件包含将近 600 万条记录，需要清除这些记录才能删除始发地或目的地机场中所有没有 IATA 三字母代码的航班。 我们还想删除`ELAPSED_TIME`列中值缺失的行。 如果不这样做，则会在将数据加载到图形结构中时引起问题。 另一个问题是数据集包含一些时间列，例如`DEPARTURE_TIME`和`ARRIVAL_TIME`，并且为了节省空间，这些列仅以`HHMM`格式存储时间，而实际日期存储在`YEAR`中 ]，`MONTH`和`DAY`列。 我们将在本章中进行的一项分析将需要`DEPARTURE_TIME`的完整日期时间，并且由于进行此转换是一项耗时的操作，因此我们现在进行并将其存储在`flights.csv`的处理版本中 我们将存储在 GitHub 上。 此操作使用通过`to_datetime()`函数和`axis=1`调用的熊猫`apply()`方法（指示对每行应用了转换）。
+`flights.csv`文件包含将近 600 万条记录，需要清除这些记录才能删除始发地或目的地机场中所有没有 IATA 三字母代码的航班。 我们还想删除`ELAPSED_TIME`列中值缺失的行。 如果不这样做，则会在将数据加载到图形结构中时引起问题。 另一个问题是数据集包含一些时间列，例如`DEPARTURE_TIME`和`ARRIVAL_TIME`，并且为了节省空间，这些列仅以`HHMM`格式存储时间，而实际日期存储在`YEAR`中 ]，`MONTH`和`DAY`列。 我们将在本章中进行的一项分析将需要`DEPARTURE_TIME`的完整日期时间，并且由于进行此转换是一项耗时的操作，因此我们现在进行并将其存储在`flights.csv`的处理版本中 我们将存储在 GitHub 上。 此操作使用通过`to_datetime()`函数和`axis=1`调用的Pandas`apply()`方法（指示对每行应用了转换）。
 
 另一个问题是我们希望将文件存储在 GitHub 上，但是最大文件大小限制为 100M。因此，为使文件小于 100 M，我们还删除了一些不需要的列 我们尝试构建的分析文件，然后将其压缩，然后再将其存储在 GitHub 上。 当然，另一个好处是 DataFrame 可以使用较小的文件更快地加载。
 
@@ -323,7 +323,7 @@ flights.to_csv('flights.csv', index=False)
 
 为了方便起见，[这三个文件存储在以下 GitHub 位置](https://github.com/DTAIEB/Thoughtful-Data-Science/tree/master/chapter%209/USFlightsAnalysis)。
 
-以下代码使用`pixiedust.sampleData()`方法将数据加载到对应于`airlines`，`airports`和`flights`的三个熊猫 DataFrame 中：
+以下代码使用`pixiedust.sampleData()`方法将数据加载到对应于`airlines`，`airports`和`flights`的三个Pandas DataFrame 中：
 
 ```py
 airports = pixiedust.sampleData("https://github.com/DTAIEB/Thoughtful-Data-Science/raw/master/chapter%209/USFlightsAnalysis/airports.csv")
@@ -386,7 +386,7 @@ flight_graph = nx.from_pandas_edgelist(
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%209/sampleCode7.py)。
 
-**注意**：NetworkX 支持通过从 多种格式，包括字典，列表，NumPy 和 SciPy 矩阵，当然还有熊猫。 [您可以在此处找到有关这些转换功能的更多信息](https://networkx.github.io/documentation/networkx-2.1/reference/convert.html)。
+**注意**：NetworkX 支持通过从 多种格式，包括字典，列表，NumPy 和 SciPy 矩阵，当然还有Pandas。 [您可以在此处找到有关这些转换功能的更多信息](https://networkx.github.io/documentation/networkx-2.1/reference/convert.html)。
 
 我们可以通过直接打印其节点和边来快速验证我们的图是否具有正确的值：
 
@@ -484,7 +484,7 @@ print(flight_graph.degree)
 [('BMI', 14), ('RDM', 8), ('SBN', 13), ('PNS', 18), ………, ('JAC', 26), ('MEM', 46)]
 ```
 
-现在，我们想向机场数据框添加`DEGREE`列，其中包含前一个数组中每个机场行的度值。 为此，我们需要创建一个具有两列的新 DataFrame：`IATA_CODE`和`DEGREE`并在`IATA_CODE`上执行熊猫`merge()`操作。
+现在，我们想向机场数据框添加`DEGREE`列，其中包含前一个数组中每个机场行的度值。 为此，我们需要创建一个具有两列的新 DataFrame：`IATA_CODE`和`DEGREE`并在`IATA_CODE`上执行Pandas`merge()`操作。
 
 下图说明了合并操作：
 
@@ -1190,7 +1190,7 @@ class SearchShortestRouteApp(MapboxBase):
 
 **注意**：为简洁起见，省略了`SearchShortestRouteApp`的其余实现，因为它与*第 2 部分*完全相同。 要访问该实现，请参阅完整的*第 3 部分*笔记本。
 
-最后要实现的 PixieApp 类是`AirlinesApp`，它将显示所有延迟图。 与`SearchShortestRouteApp`相似，我们从`parent_pixieapp`选项字典中存储`org_airport`和`dest_airport`。 我们还计算了中所有航班超出给定`org_airport`的航空公司的元组列表（代码和名称）。 为此，我们在`AIRLINE`列上使用熊猫`groupby()`方法并获取索引值的列表，如以下代码所示：
+最后要实现的 PixieApp 类是`AirlinesApp`，它将显示所有延迟图。 与`SearchShortestRouteApp`相似，我们从`parent_pixieapp`选项字典中存储`org_airport`和`dest_airport`。 我们还计算了中所有航班超出给定`org_airport`的航空公司的元组列表（代码和名称）。 为此，我们在`AIRLINE`列上使用Pandas`groupby()`方法并获取索引值的列表，如以下代码所示：
 
 ```py
 [[AirlinesApp]]
@@ -1317,7 +1317,7 @@ def compute_delay_airline_df(self, airline, delay_org_airport):
 
 # 第 4 部分–创建 ARIMA 模型以预测航班延误
 
-在第 8 章，*金融时间序列分析和预测*中，我们使用时间序列分析建立了预测金融股票的预测模型。 实际上，我们可以在航班延误中使用相同的技术，因为毕竟我们还在这里处理时间序列，因此在本节中，我们将遵循完全相同的步骤。 对于每个目的地机场和可选航空公司，我们将构建一个熊猫 DataFrame，其中包含匹配的航班信息。
+在第 8 章，*金融时间序列分析和预测*中，我们使用时间序列分析建立了预测金融股票的预测模型。 实际上，我们可以在航班延误中使用相同的技术，因为毕竟我们还在这里处理时间序列，因此在本节中，我们将遵循完全相同的步骤。 对于每个目的地机场和可选航空公司，我们将构建一个Pandas DataFrame，其中包含匹配的航班信息。
 
 ### 注意