Skip to content

A
apachecn-ds-zh

OpenDocCN / apachecn-ds-zh
10 个月 前同步成功

通知 1
Star 287
Fork 69
A
apachecn-ds-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 861195ad 编写于 作者: W wizardforcel
浏览文件
操作

2020-07-21 22:51:07

上级 cb8f6996
展开全部 隐藏空白更改
内联 并排
Showing with 156 addition and 156 deletion
docs/numpy-beginners-guide-3e/ch01.md
浏览文件 @ 861195ad
......@@ -196,7 +196,7 @@ NumPy [具有用于 Windows，各种 Linux 发行版和 MacOSX 的二进制安
# 生效时间–使用`print()`函数进行打印
我们可以使用`print()`功能打印 ，如下所示：
我们可以使用`print()`函数打印 ，如下所示：
1. 旧语法如下：
......@@ -373,7 +373,7 @@ Python 具有`for`语句，其目的与 C++ ，Pascal，Java 和其他语言中
```
3. `range()`功能的 start 和 step 参数是可选的，默认值为`1`。 我们还可以提早结束循环。 遍历数字`0-9`并在到达`3`时跳出循环：
3. `range()`函数的 start 和 step 参数是可选的，默认值为`1`。 我们还可以提早结束循环。 遍历数字`0-9`并在到达`3`时跳出循环：
```py
>>> for i in range(9):
......@@ -706,9 +706,9 @@ $ [sudo] python setup.py install --prefix=/usr/local
return c
```
请注意，`numpysum()`不需要`for`循环。 此外，我们使用了 NumPy 的`arange()`函数，该函数为我们创建了一个整数`0`至`n`的 NumPy 数组。 `arange()`功能已导入； 这就是为什么它以`numpy`为前缀的原因（实际上，习惯上是通过`np`的别名来缩写它）。
请注意，`numpysum()`不需要`for`循环。 此外，我们使用了 NumPy 的`arange()`函数，该函数为我们创建了一个整数`0`至`n`的 NumPy 数组。 `arange()`函数已导入； 这就是为什么它以`numpy`为前缀的原因（实际上，习惯上是通过`np`的别名来缩写它）。
有趣的来了。 序言提到，在数组操作方面，NumPy 更快。 NumPy 快多少？ 以下程序将通过为`numpysum()`和`pythonsum()`功能测量经过的时间（以微秒为单位）向我们展示。 它还打印向量和的最后两个元素。 让我们检查是否通过使用 Python 和 NumPy 得到了相同的答案：
有趣的来了。 序言提到，在数组操作方面，NumPy 更快。 NumPy 快多少？ 以下程序将通过为`numpysum()`和`pythonsum()`函数测量经过的时间（以微秒为单位）向我们展示。 它还打印向量和的最后两个元素。 让我们检查是否通过使用 Python 和 NumPy 得到了相同的答案：
```py
#!/usr/bin/env/python
......@@ -954,7 +954,7 @@ In [4]: %hist
# 在线资源和帮助
当我们处于 IPython 的`pylab`模式时，可以使用`help`命令打开 NumPy 函数的手册页。 不必知道功能名称。 我们可以输入几个字符，然后让制表符完成工作。 例如，让我们浏览`arange()`功能的可用信息：
当我们处于 IPython 的`pylab`模式时，可以使用`help`命令打开 NumPy 函数的手册页。 不必知道功能名称。 我们可以输入几个字符，然后让制表符完成工作。 例如，让我们浏览`arange()`函数的可用信息：
```py
In [2]: help ar<Tab>
......
docs/numpy-beginners-guide-3e/ch02.md
浏览文件 @ 861195ad
......@@ -83,7 +83,7 @@ Python 中的**元组**是一个不变的（不能更改）值序列。 创建
## 刚刚发生了什么？
我们使用值得信赖和喜爱的`arange()`和`array()`函数创建了一个 2 x 2 的数组。 没有任何警告，`array()`功能出现在舞台上。
我们使用值得信赖和喜爱的`arange()`和`array()`函数创建了一个 2 x 2 的数组。 没有任何警告，`array()`函数出现在舞台上。
`array()`函数根据您提供给它的对象创建一个数组。 该对象必须是类似数组的，例如 Python 列表。 在前面的示例中，我们传入了一个数组列表。 该对象是`array()`函数的唯一必需参数。 NumPy 函数倾向于具有许多带有预定义默认值的可选参数。 在 IPython shell 中使用此处提供的`help()`函数查看此函数的文档：
......@@ -562,9 +562,9 @@ Out: array([8, 7, 6, 5, 4, 3, 2, 1, 0])
# 实战时间 – 处理数组形状
我们已经了解了`reshape()`功能。 另一个重复执行的任务是将数组展平。 展平多维 NumPy 数组时，结果是具有相同数据的一维数组。
我们已经了解了`reshape()`函数。 另一个重复执行的任务是将数组展平。 展平多维 NumPy 数组时，结果是具有相同数据的一维数组。
1. **Ravel**：使用`ravel()`功能完成：
1. **Ravel**：使用`ravel()`函数完成：
```py
In: b
......@@ -653,7 +653,7 @@ Out: array([8, 7, 6, 5, 4, 3, 2, 1, 0])
## 堆叠
数组可以水平，深度或垂直堆叠。 为此，我们可以使用`vstack()`，`dstack()`，`hstack()`，`column_stack()`，`row_stack()`和`concatenate()`功能。
数组可以水平，深度或垂直堆叠。 为此，我们可以使用`vstack()`，`dstack()`，`hstack()`，`column_stack()`，`row_stack()`和`concatenate()`函数。
# 实战时间 – 堆叠数组
......@@ -697,7 +697,7 @@ array([[ 0, 2, 4],
```
此图显示了`concatenate()`功能的水平堆叠：
此图显示了`concatenate()`函数的水平堆叠：
![Time for action – stacking arrays](img/4154_02_02.jpg)
2. **Vertical stacking**: With vertical stacking, again, a tuple is formed. This time, it is given to the `vstack()` function as follows:
......@@ -728,7 +728,7 @@ array([[ 0, 2, 4],
```
下图显示了具有`concatenate()`功能的垂直堆叠：
下图显示了具有`concatenate()`函数的垂直堆叠：
![Time for action – stacking arrays](img/4154_02_03.jpg)
3. **深度堆叠**：另外，使用`dstack()`和元组的深度堆叠，沿第三个轴（深度）堆叠了数组的列表。 例如，将图像数据的二维数组彼此堆叠在一起：
......@@ -820,7 +820,7 @@ array([[ 0, 2, 4],
## 刚刚发生了什么？
我们水平，深度和垂直堆叠数组。 我们使用了`vstack()`，`dstack()`，`hstack()`，`column_stack()`，`row_stack()`和`concatenate()`功能，如下表所示：
我们水平，深度和垂直堆叠数组。 我们使用了`vstack()`，`dstack()`，`hstack()`，`column_stack()`，`row_stack()`和`concatenate()`函数，如下表所示：
<colgroup class="calibre22"><col class="calibre23"> <col class="calibre23"></colgroup>
| 函数 | 描述 |
......@@ -897,7 +897,7 @@ array([[ 0, 2, 4],
```
3. **深度拆分**：`dsplit()`功能毫不奇怪地是深度拆分。 分割前先创建一个排列为 3 的数组：
3. **深度拆分**：`dsplit()`函数毫不奇怪地是深度拆分。 分割前先创建一个排列为 3 的数组：
```py
In: c = arange(27).reshape(3, 3, 3)
......@@ -990,7 +990,7 @@ array([[ 0, 2, 4],
```
* `T`属性具有`transpose()`功能的相同效果，如下所示：
* `T`属性具有`transpose()`函数的相同效果，如下所示：
```py
In: b.resize(6,4)
......
docs/numpy-beginners-guide-3e/ch04.md
浏览文件 @ 861195ad
......@@ -14,13 +14,13 @@
# 相关
您是否注意到某些公司的股价会紧随其后，通常是 同一行业的竞争对手？ 理论上的解释是，由于这两家公司属于同一类型的业务，因此它们面临着相同的挑战，需要相同的材料和资源，并争夺相同类型的客户。
您是否注意到某些公司的股价会紧随其后，通常是同一行业的竞争对手？ 理论上的解释是，由于这两家公司属于同一类型的业务，因此它们面临着相同的挑战，需要相同的材料和资源，并争夺相同类型的客户。
您可能想到了许多可能的对，但是您需要检查一下真实的关系。 一种方法是查看两种股票的股票收益的[相关性和因果关系](https://www.khanacademy.org/math/probability/statistical-studies/types-of-studies/v/correlation-and-causality)。 高相关性意味着某种关系。 但是，这并不是因果关系的证明，尤其是如果您没有使用足够的数据。
# 采取行动的时候–交易相关货币对
在本节中，我们将使用两个样本数据集，其中包含日末价格数据。 第一家 公司是必和必拓（BHP），该公司活跃于石油，金属和钻石的开采。 第二个是淡水河谷（VALE），这也是一家金属和采矿公司。 因此，活动有一些重叠，尽管不是 100％。 要评估相关对，请按照下列步骤操作：
在本节中，我们将使用两个样本数据集，其中包含日末价格数据。 第一家公司是必和必拓（BHP），该公司活跃于石油，金属和钻石的开采。 第二个是淡水河谷（VALE），这也是一家金属和采矿公司。 因此，活动有一些重叠，尽管不是 100％。 要评估相关对，请按照下列步骤操作：
1. 首先，从本章示例代码目录中的 CSV 文件加载数据，特别是两种证券的收盘价，并计算收益。 如果您不记得该怎么做，请参阅第 3 章，“熟悉常用功能”中的示例。
2. Covariance tells us how two variables vary together; which is nothing more than unnormalized correlation (see [https://www.khanacademy.org/math/probability/regression/regression-correlation/v/covariance-and-the-regression-line](https://www.khanacademy.org/math/probability/regression/regression-correlation/v/covariance-and-the-regression-line)):![Time for action – trading correlated pairs](img/4154_04_04.jpg)
......@@ -100,7 +100,7 @@
7. Another important point is whether the two stocks under consideration are in sync or not. Two stocks are considered out of sync if their difference is two standard deviations from the mean of the differences.
如果它们不同步，我们可以发起交易，希望它们最终能够再次恢复同步。 计算 两种证券的收盘价之间的差异，以检查同步：
如果它们不同步，我们可以发起交易，希望它们最终能够再次恢复同步。 计算两种证券的收盘价之间的差异，以检查同步：
```py
difference = bhp - vale
......@@ -142,7 +142,7 @@
## 刚刚发生了什么？
我们分析了必和必拓和 VALE 收盘价的 关系。 确切地说，我们计算了他们的股票收益的相关性。 我们通过 `corrcoef()`功能实现了这一目标。 此外，我们看到了如何计算可以从中得出相关性的协方差矩阵。 另外，我们演示了`diagonal()`和`trace()`方法，它们分别为我们提供对角线值和矩阵迹线。 有关源代码，请参见本书代码包中的`correlation.py`文件：
我们分析了必和必拓和 VALE 收盘价的关系。 确切地说，我们计算了他们的股票收益的相关性。 我们通过 `corrcoef()`函数实现了这一目标。 此外，我们看到了如何计算可以从中得出相关性的协方差矩阵。 另外，我们演示了`diagonal()`和`trace()`方法，它们分别为我们提供对角线值和矩阵迹线。 有关源代码，请参见本书代码包中的`correlation.py`文件：
```py
from __future__ import print_function
......@@ -186,7 +186,7 @@ plt.show()
## 小测验-计算协方差
Q1。 哪个函数 返回两个数组的协方差？
Q1。 哪个函数返回两个数组的协方差？
1. 协方差
2. 科瓦
......@@ -313,7 +313,7 @@ NumPy `polyfit()`函数拟合多项式的一组数据点，即使基础函数不
## 刚刚发生了什么？
我们使用 `polyfit()`函数将数据拟合为多项式。 我们了解了用于计算多项式值的`polyval()`函数，用于返回多项式的 根的`roots()`函数以及用于返回多项式导数的`polyder()`函数（ 参见`polynomials.py`）：
我们使用 `polyfit()`函数将数据拟合为多项式。 我们了解了用于计算多项式值的`polyval()`函数，用于返回多项式的根的`roots()`函数以及用于返回多项式导数的`polyder()`函数（ 参见`polynomials.py`）：
```py
from __future__ import print_function
......@@ -352,15 +352,15 @@ plt.show()
## 拥有围棋英雄-提高身体健康
您可以做很多事情来提高合身性。 例如，尝试使用其他幂，因为在本节中选择了三次 多项式。 考虑在拟合之前对数据进行平滑处理。 平滑数据的一种方法是移动平均值。 您可以在第 3 章，“熟悉常用功能”中找到简单和 EMA 计算的示例。
您可以做很多事情来提高合身性。 例如，尝试使用其他幂，因为在本节中选择了三次多项式。 考虑在拟合之前对数据进行平滑处理。 平滑数据的一种方法是移动平均值。 您可以在第 3 章，“熟悉常用功能”中找到简单和 EMA 计算的示例。
# 余量
交易量是 在投资中非常重要的变量； 它表明价格走势有多大。 平衡量指标是 最简单的股票价格指标之一。 它基于当日和前几日的收盘价以及当日的交易量。 对于每一天，如果今天的收盘价高于昨天的收盘价，那么余额表上的交易量的值等于今天的交易量。 另一方面，如果今天的收盘价低于昨天的收盘价，那么资产负债表上交易量指标的价值就是资产负债表上的交易量与今天的交易量之差。 但是，如果收盘价没有变化，那么余额表上的交易量的值为零。
交易量是在投资中非常重要的变量； 它表明价格走势有多大。 平衡交易量指标是最简单的股票价格指标之一。 它基于当日和前几日的收盘价以及当日的交易量。 对于每一天，如果今天的收盘价高于昨天的收盘价，那么余额表上的交易量的值等于今天的交易量。 另一方面，如果今天的收盘价低于昨天的收盘价，那么资产负债表上交易量指标的价值就是资产负债表上的交易量与今天的交易量之差。 但是，如果收盘价没有变化，那么余额表上的交易量的值为零。
# 采取行动的时候-平衡音量
# 采取行动的时候-平衡交易量
换句话说，我们需要 乘以收盘价和交易量的符号。 在本节中，我们研究解决此问题的两种方法：一种使用 NumPy `sign()`函数，另一种使用 NumPy `piecewise()`函数。
换句话说，我们需要乘以收盘价和交易量的符号。 在本节中，我们研究解决此问题的两种方法：一种使用 NumPy `sign()`函数，另一种使用 NumPy `piecewise()`函数。
1. Load the BHP data into a close and volume array:
......@@ -446,7 +446,7 @@ plt.show()
## 刚刚发生了什么？
我们计算了取决于收盘价变化的余额 数量。 使用 NumPy `sign()`和`piecewise()`函数，我们遍历了两种不同的方法来确定更改的符号（请参见`obv.py`），如下所示：
我们计算了取决于收盘价变化的余额数量。 使用 NumPy `sign()`和`piecewise()`函数，我们遍历了两种不同的方法来确定更改的符号（请参见`obv.py`），如下所示：
```py
from __future__ import print_function
......@@ -471,11 +471,11 @@ print("On balance volume", v[1:] * signs)
# 模拟
通常，您会想先尝试一下。 玩耍，试验，但最好不要炸东西或变脏！ NumPy 非常适合进行实验。 我们 将使用 NumPy 模拟交易日，而不会实际亏损。 许多人喜欢逢低买入，换句话说，等待股票价格下跌之后再购买。 一个变种是等待价格下跌一小部分，例如比当天的开盘价低 0.1％。
通常，您会想先尝试一下。 玩耍，试验，但最好不要炸东西或变脏！ NumPy 非常适合进行实验。 我们将使用 NumPy 模拟交易日，而不会实际亏损。 许多人喜欢逢低买入，换句话说，等待股票价格下跌之后再购买。 一个变种是等待价格下跌一小部分，例如比当天的开盘价低 0.1％。
# 实战时间 – 使用`vectorize()`避免循环
`vectorize()`功能是 ，这是另一个可以减少程序循环次数的技巧 。 请按照以下步骤计算一个交易日的利润：
`vectorize()`函数是 ，这是另一个可以减少程序循环次数的技巧 。 请按照以下步骤计算一个交易日的利润：
1. 首先，加载数据：
......@@ -489,13 +489,13 @@ print("On balance volume", v[1:] * signs)
func = np.vectorize(calc_profit)
```
3. 现在，我们可以应用`func()`，就好像它是一个函数一样。 将我们获得的 的`func()`函数结果应用于价格数组：
3. 现在，我们可以应用`func()`，就好像它是一个函数一样。 将我们获得的的`func()`函数结果应用于价格数组：
```py
profits = func(o, h, l, c)
```
4. `calc_profit()`功能非常简单。 首先，我们尝试以低于 的开盘价购买。 如果这超出每日范围，那么很明显，我们的 尝试失败，没有获利，或者我们蒙受了损失，因此将返回 0。否则，我们以收盘价卖出 利润仅仅是买入价和收盘价之间的差。 实际上，查看相对利润实际上更有趣：
4. `calc_profit()`函数非常简单。 首先，我们尝试以较低的开盘价购买。 如果这超出每日范围，那么很明显，我们的尝试失败，没有获利，或者我们蒙受了损失，因此将返回 0。否则，我们以收盘价卖出利润仅仅是买入价和收盘价之间的差。 实际上，查看相对利润实际上更有趣：
```py
def calc_profit(open, high, low, close):
......@@ -597,13 +597,13 @@ print("Average loss %", round(np.mean(losing_trades) * 100, 2))
## 拥有围棋英雄-分析连续的获胜和失利
尽管平均利润为正，但了解我们是否必须承受连续亏损的 连胜也很重要。 如果是这种情况，我们可能只剩下很少甚至没有资本，那么平均利润就无关紧要。
尽管平均利润为正，但了解我们是否必须承受连续亏损也很重要。 如果是这种情况，我们可能只剩下很少甚至没有资本，那么平均利润就无关紧要。
找出是否有这样的损失。 如果需要，您还可以找出是否有长时间的连胜纪录。
# 平滑
嘈杂的数据很难处理，因此我们经常需要进行一些平滑处理。 除了计算 移动平均值外，我们还可以使用 NumPy 函数之一来平滑数据。
嘈杂的数据很难处理，因此我们经常需要进行一些平滑处理。 除了计算移动平均值外，我们还可以使用 NumPy 函数之一来平滑数据。
`hanning()`函数是[由加权余弦形成的窗口函数](http://en.wikipedia.org/wiki/Hann_function) ）：
......@@ -700,7 +700,7 @@ print("Average loss %", round(np.mean(losing_trades) * 100, 2))
```
一些数字是实数，因此请使用`select()`功能选择它们。 `select()`函数 通过根据条件列表从选项列表中获取元素来形成数组：
一些数字是实数，因此请使用`select()`函数选择它们。 `select()`函数根据条件列表从选项列表中获取元素来形成数组：
```py
xpoints = np.select([reals], [xpoints])
......@@ -730,7 +730,7 @@ print("Average loss %", round(np.mean(losing_trades) * 100, 2))
## 刚刚发生了什么？
我们将`hanning()`函数应用于包含股票收益的数组。 我们用 `polysub()`函数减去了两个多项式。 然后，我们使用`isreal()`功能检查实数 ，然后使用`select()`功能选择实数。 最后，我们使用`trim_zeros()`函数从数组中剥离了 零（请参见`smoothing.py`）：
我们将`hanning()`函数应用于包含股票收益的数组。 我们用 `polysub()`函数减去了两个多项式。 然后，我们使用`isreal()`函数检查实数 ，然后使用`select()`函数选择实数。 最后，我们使用`trim_zeros()`函数从数组中剥离了零（请参见`smoothing.py`）：
```py
from __future__ import print_function
......@@ -783,11 +783,11 @@ plt.show()
## 勇往直前–平滑变化
试用其他 平滑功能-`hamming()`，`blackman()`，`bartlett()`和`kaiser()`。 它们的工作方式几乎与`hanning()`功能相同。
试用其他平滑功能-`hamming()`，`blackman()`，`bartlett()`和`kaiser()`。 它们的工作方式几乎与`hanning()`函数相同。
# 初始化
到目前为止，在本书中，我们 遇到了一些用于初始化数组的便捷函数。 `full()`和`full_like()`函数最近被添加到 NumPy，以使初始化更加容易。
到目前为止，在本书中，我们遇到了一些用于初始化数组的便捷函数。 `full()`和`full_like()`函数最近被添加到 NumPy，以使初始化更加容易。
以下简短的 Python 会话显示了这两个函数的（缩写）文档：
......@@ -804,7 +804,7 @@ Return a new array of given shape and type, filled with `fill_value`.
# 实战时间 – 使用`full()`和`full_like()`函数创建值初始化的数组
让我们 演示`full()`和`full_like()`函数的工作方式。 如果您还不在 Python shell 中，请输入以下 ：
让我们演示`full()`和`full_like()`函数的工作方式。 如果您还不在 Python shell 中，请输入以下 ：
```py
$ python
......@@ -849,7 +849,7 @@ $ python
## 刚刚发生了什么？
我们使用`full()`和`full_like()`函数创建了数组。 `full()`函数用数字`42`填充数组。 `full_like()`函数使用 输入数组 的元数据来创建新数组。 这两个功能都可以指定数据类型。
我们使用`full()`和`full_like()`函数创建了数组。 `full()`函数用数字`42`填充数组。 `full_like()`函数使用输入数组的元数据来创建新数组。 这两个功能都可以指定数据类型。
# 总结
......
docs/numpy-beginners-guide-3e/ch05.md
浏览文件 @ 861195ad
# 五、使用矩阵和 ufunc
本章介绍矩阵和通用函数（ufuncs）。 矩阵在数学上是众所周知的，在 NumPy 中也具有 表示。 通用函数适用于数组，逐元素或标量。 ufuncs 期望一组标量作为输入，并产生一组标量作为输出。 通用函数通常可以映射到它们的数学对应物，例如加，减，除，乘等。 我们还将介绍三角函数，按位和比较通用函数。
本章介绍矩阵和通用函数（ufuncs）。 矩阵在数学上是众所周知的，在 NumPy 中也具有表示。 通用函数适用于数组，逐元素或标量。 ufuncs 期望一组标量作为输入，并产生一组标量作为输出。 通用函数通常可以映射到它们的数学对应物，例如加，减，除，乘等。 我们还将介绍三角函数，按位和比较通用函数。
在本章中，我们将介绍以下主题：
......@@ -17,7 +17,7 @@ NumPy 中的矩阵是`ndarray`的子类。 我们可以使用特殊的字符串
# 实战时间 – 建立矩阵
如果输入已经是矩阵或`ndarray`，则 `mat()`函数不会 复制。 调用此函数等效于调用`matrix`（`data, copy=False`）。 我们还将演示转置和求逆矩阵。
如果输入已经是矩阵或`ndarray`，则`mat()`函数不会复制。 调用此函数等效于调用`matrix(data, copy=False)`。 我们还将演示转置和求逆矩阵。
1. Rows are delimited by a semicolon and values by a space. Call the `mat()` function with the following string to create a matrix:
......@@ -82,7 +82,7 @@ NumPy 中的矩阵是`ndarray`的子类。 我们可以使用特殊的字符串
## 刚刚发生了什么？
我们使用 `mat()`函数创建了矩阵。 我们将具有`T`属性的矩阵转置，而 将其具有`I`属性的矩阵反转（请参见`matrixcreation.py`）：
我们使用`mat()`函数创建了矩阵。 我们将使用`T`属性将矩阵转置，并使用`I`属性将其反转（请参见`matrixcreation.py`）：
```py
from __future__ import print_function
......@@ -99,7 +99,7 @@ print("Creation from array", np.mat(np.arange(9).reshape(3, 3)))
# 从其他矩阵创建矩阵
有时，我们想 由其他较小的 矩阵创建矩阵。 我们可以通过 `bmat()`功能来实现。 `b`在这里代表块矩阵。
有时，我们想由其他较小的矩阵创建矩阵。 我们可以通过`bmat()`函数来实现。 `b`在这里代表块矩阵。
# 实战时间 – 从其他矩阵创建矩阵
......@@ -154,7 +154,7 @@ print("Creation from array", np.mat(np.arange(9).reshape(3, 3)))
## 刚刚发生了什么？
我们使用`bmat()`函数从两个较小的矩阵创建了一个 块矩阵。 我们给该函数一个字符串，其中包含矩阵名称，而不是数字的 （请参见`bmatcreation.py`）：
我们使用`bmat()`函数从两个较小的矩阵创建了一个块矩阵。 我们给该函数一个字符串，其中包含矩阵名称，而不是数字（请参见`bmatcreation.py`）：
```py
from __future__ import print_function
......@@ -178,7 +178,7 @@ Q1。 `mat()`和`bmat()`函数接受的字符串中的行分隔符是什么？
# 通用功能
**通用函数**（**ufuncs**）期望一组标量作为输入并产生 一组标量作为输出。 它们实际上是 Python 对象，它们封装了函数的行为。 通常，我们可以将 ufunc 映射到它们的数学对应项，例如加，减，除，乘等。 通常，通用功能由于其特殊的优化以及在本机级别上运行而更快。
**通用函数**（**ufuncs**）期望一组标量作为输入并产生一组标量作为输出。 它们实际上是 Python 对象，它们封装了函数的行为。 通常，我们可以将 ufunc 映射到它们的数学对应项，例如加，减，除，乘等。 通常，通用功能由于其特殊的优化以及在本机级别上运行而更快。
# 采取行动的时候–创建通用功能
......@@ -237,7 +237,7 @@ Q1。 `mat()`和`bmat()`函数接受的字符串中的行分隔符是什么？
## 刚刚发生了什么？
我们定义了一个 Python 函数。 在此函数中，我们使用 和`zeros_like()`函数，根据输入参数的形状将数组的元素初始化为零。 然后，使用`ndarray`的`flat`属性，将数组元素设置为最终答案`42`（请参见`answer42.py`）：
我们定义了一个 Python 函数。 在此函数中，我们使用`zeros_like()`函数，根据输入参数的形状将数组的元素初始化为零。 然后，使用`ndarray`的`flat`属性，将数组元素设置为最终答案`42`（请参见`answer42.py`）：
```py
from __future__ import print_function
......@@ -256,7 +256,7 @@ print("The answer", ufunc(np.arange(4).reshape(2, 2)))
# 通用功能方法
函数 如何具有方法？ 如前所述，通用函数不是函数，而是表示函数的 Python 对象。 通用功能具有五种重要方法，列为 ：
函数如何具有方法？ 如前所述，通用函数不是函数，而是表示函数的 Python 对象。 通用功能具有五种重要方法，如下：
1. `ufunc.reduce(a[, axis, dtype, out, keepdims])`
2. `ufunc.accumulate(array[, axis, dtype, out])`
......@@ -308,7 +308,7 @@ print("The answer", ufunc(np.arange(4).reshape(2, 2)))
```
第一步 与索引`0`和`5`有关。 此步骤可减少索引`0`和`5`之间的数组元素的运算：
第一步与索引`0`和`5`有关。 此步骤可减少索引`0`和`5`之间的数组元素的运算：
```py
print("Reduceat step I", np.add.reduce(a[0:5]))
......@@ -366,7 +366,7 @@ print("The answer", ufunc(np.arange(4).reshape(2, 2)))
print("Outer", np.add.outer(np.arange(3), a))
```
外部总和 的输出结果如下：
外部总和的输出结果如下：
```py
Outer [[ 0 1 2 3 4 5 6 7 8]
......@@ -377,7 +377,7 @@ print("The answer", ufunc(np.arange(4).reshape(2, 2)))
## 刚刚发生了什么？
我们将通用函数的 前四种方法`reduce()`，`accumulate()`，`reduceat()`和`outer()`应用于`add()`函数（请参见`ufuncmethods.py`）：
我们将通用函数的前四种方法`reduce()`，`accumulate()`，`reduceat()`和`outer()`应用于`add()`函数（请参见`ufuncmethods.py`）：
```py
from __future__ import print_function
......@@ -397,11 +397,11 @@ print("Outer", np.add.outer(np.arange(3), a))
# 算术函数
通用算术运算符`+`，`-`和`*`分别隐式链接到 通用函数的加，减和乘。 这意味着在 NumPy 数组上使用这些运算符之一时，将调用相应的通用函数。 除法涉及一个稍微复杂的过程。 与数组划分有关的三个通用函数是`divide()`，`true_divide()`和`floor_division()`。 两个运算符对应于除法：`/`和`//`。
通用算术运算符`+`，`-`和`*`分别隐式链接到通用函数的加，减和乘。 这意味着在 NumPy 数组上使用这些运算符之一时，将调用相应的通用函数。 除法涉及一个稍微复杂的过程。 与数组分割有关的三个通用函数是`divide()`，`true_divide()`和`floor_division()`。 两个运算符对应于除法：`/`和`//`。
# 实战时间 – 分割数组
让我们来看一下数组划分 的作用：
让我们来看一下数组分割的作用：
1. The `divide()` function does truncated integer division and normal floating-point division:
......@@ -485,7 +485,7 @@ print("Outer", np.add.outer(np.arange(3), a))
## 刚刚发生了什么？
`divide()`函数会截断 整数除法和常规浮点除法。 `true_divide()`函数始终返回浮点结果而没有任何截断。 `floor_divide()`函数始终返回整数结果； 结果与通过连续调用`divide()`和`floor()`函数（请参见`dividing.py`）获得的 相同：
`divide()`函数会执行截断整数除法和常规浮点除法。 `true_divide()`函数始终返回浮点结果而没有任何截断。 `floor_divide()`函数始终返回整数结果； 结果与通过连续调用`divide()`和`floor()`函数（请参见`dividing.py`）获得的相同：
```py
from __future__ import print_function
......@@ -507,15 +507,15 @@ print("// operator 2", c//b, b//c)
## 拥有围棋英雄-试用 __future __。division
通过实验确认 导入 __future __。division 的影响。
通过实验确认导入`__future__.division`的影响。
# 模运算
我们可以使用 NumPy `mod()`，`remainder()`和`fmod()`函数来计算模或余数。 同样，我们 可以使用`%`运算符。 这些函数之间的主要区别在于它们如何处理负数。 该组中的奇数是`fmod()`功能。
我们可以使用 NumPy `mod()`，`remainder()`和`fmod()`函数来计算模或余数。 同样，我们可以使用`%`运算符。 这些函数之间的主要区别在于它们如何处理负数。 该组中的奇数是`fmod()`函数。
# 实战时间 – 计算模数
让我们调用前面提到的 函数：
让我们调用前面提到的函数：
1. The `remainder()` function returns the remainder of the two arrays, element-wise. `0` is returned if the second number is `0`:
......@@ -600,11 +600,11 @@ print("Fmod", np.fmod(a, 2))
![Fibonacci numbers](img/4154_05_06.jpg)
这将介绍`matrix()`和`rint()`功能。 `matrix()`函数创建矩阵， 数字四舍五入到最接近的整数，但结果不是整数。
这将介绍`matrix()`和`rint()`函数。 `matrix()`函数创建矩阵， 数字四舍五入到最接近的整数，但结果不是整数。
# 实战时间 – 计算斐波纳契数
矩阵可以 表示斐波那契递归关系。 我们可以将斐波纳契数的计算表示为重复的矩阵乘法：
矩阵可以表示斐波那契递归关系。 我们可以将斐波纳契数的计算表示为重复的矩阵乘法：
1. Create the Fibonacci matrix as follows:
......@@ -653,7 +653,7 @@ print("Fmod", np.fmod(a, 2))
## 刚刚发生了什么？
我们用两种方法计算了 斐波那契数。 在此过程中，我们了解了用于创建矩阵的`matrix()`函数。 我们还了解了 `rint()`函数，该函数将数字四舍五入到最接近的整数，但不将类型更改为整数（请参见`fibonacci.py`）：
我们用两种方法计算了斐波那契数。 在此过程中，我们了解了用于创建矩阵的`matrix()`函数。 我们还了解了`rint()`函数，该函数将数字四舍五入到最接近的整数，但不将类型更改为整数（请参见`fibonacci.py`）：
```py
from __future__ import print_function
......@@ -672,7 +672,7 @@ print("Fibonacci", fibonacci)
## 勇往直前–计时计算
您可能在 想知道哪种方法更快，因此请继续并确定时间。 用`frompyfunc()`创建通用的斐波那契函数，并对其计时。
您可能想知道哪种方法更快，因此请继续并确定时间。 用`frompyfunc()`创建通用的斐波那契函数，并对其计时。
# 李沙育曲线
......@@ -687,7 +687,7 @@ y = B sin(bt)
利萨如的数字是由`A`，`B`，`a`和`b`四个参数确定的 。 为了简单起见，我们将`A`和`B`设置为`1`：
1. 将具有`linspace()`功能的`t`从`-pi`初始化为具有`201`点的`pi`：
1. 将具有`linspace()`函数的`t`从`-pi`初始化为具有`201`点的`pi`：
```py
a = 9
......@@ -741,7 +741,7 @@ plt.show()
# 方波
方波也是您可以在示波器上查看的那些整洁的东西之一。 正弦波可以很好地将其近似为 。 毕竟，方波是 可以用无限**傅立叶级数**表示的信号。
方波也是您可以在示波器上查看的那些整洁的东西之一。 正弦波可以很好地将其近似为 。 毕竟，方波是可以用无限**傅立叶级数**表示的信号。
### 注意
......@@ -753,7 +753,7 @@ plt.show()
# 实战时间 – 绘制方波
就像上一节 一样，我们将初始化`t`。 我们需要总结一些术语。 术语数量越多，结果越准确； `k = 99`应该足够。 为了绘制方波，请按照下列步骤操作：
就像上一节一样，我们将初始化`t`。 我们需要总结一些术语。 术语数量越多，结果越准确； `k = 99`应该足够。 为了绘制方波，请按照下列步骤操作：
1. 我们将从初始化`t`和`k`开始。 将该功能的初始值设置为`0`：
......@@ -764,7 +764,7 @@ plt.show()
f = np.zeros_like(t)
```
2. 使用`sin()`和`sum()`功能计算功能值：
2. 使用`sin()`和`sum()`函数计算功能值：
```py
for i, ti in enumerate(t):
......@@ -788,7 +788,7 @@ plt.show()
## 刚刚发生了什么？
我们使用 `sin()`函数生成了 方波，或者至少是它的近似值。 输入值通过 `linspace()`功能进行组装，而`k`值 通过`arange()`功能进行组装（请参见`squarewave.py`）：
我们使用 `sin()`函数生成了方波，或者至少是它的近似值。 输入值通过 `linspace()`函数进行组装，而`k`值通过`arange()`函数进行组装（请参见`squarewave.py`）：
```py
import numpy as np
......@@ -812,17 +812,17 @@ plt.show()
## 拥有围棋英雄-摆脱循环
您可能已经 注意到代码中存在一个循环。 使用 NumPy 函数摆脱它，并确保性能也得到改善。
您可能已经注意到代码中存在一个循环。 使用 NumPy 函数摆脱它，并确保性能也得到改善。
# 锯齿波和三角波
锯齿波和三角波也是在示波器上容易看到的现象。 就像 方波一样，我们可以定义无限傅立叶级数。 三角波可以通过获取锯齿波的绝对值来找到。 一系列锯齿波的 表示公式如下：
锯齿波和三角波也是在示波器上容易看到的现象。 就像方波一样，我们可以定义无限傅立叶级数。 三角波可以通过获取锯齿波的绝对值来找到。 表示一系列锯齿波的公式如下：
![Sawtooth and triangle waves](img/4154_05_08.jpg)
# 实战时间 – 绘制锯齿波和三角波
就像上一节一样，我们将 初始化`t`。 同样，`k = 99`应该足够。 为了绘制 锯齿波和三角波，请按照下列步骤操作：
就像上一节一样，我们初始化`t`。 同样，`k = 99`应该足够。 为了绘制锯齿波和三角波，请按照下列步骤操作：
1. 将该功能的初始值设置为`zero`：
......@@ -832,7 +832,7 @@ plt.show()
f = np.zeros_like(t)
```
2. 使用`sin()`和`sum()`功能计算功能值：
2. 使用`sin()`和`sum()`函数计算功能值：
```py
for i, ti in enumerate(t):
......@@ -858,7 +858,7 @@ plt.show()
## 刚刚发生了什么？
我们使用`sin()`功能绘制了 锯齿波 。 我们将输入值与`linspace()`功能组合在一起，并将`k`值与`arange()`功能组合在一起。 通过取绝对值从锯齿波中产生一个三角波（请参见`sawtooth.py`）：
我们使用`sin()`函数绘制了锯齿波 。 我们将输入值与`linspace()`函数组合在一起，并将`k`值与`arange()`函数组合在一起。 通过取绝对值从锯齿波中产生一个三角波（请参见`sawtooth.py`）：
```py
import numpy as np
......@@ -916,7 +916,7 @@ plt.show()
| True | False | True |
| False | False | False |
`^`运算符对应于`bitwise_xor()`功能，`<`运算符对应于`less()`功能：
`^`运算符对应于`bitwise_xor()`函数，`<`运算符对应于`less()`函数：
```py
x = np.arange(-9, 9)
......
docs/numpy-beginners-guide-3e/ch06.md
浏览文件 @ 861195ad
......@@ -107,7 +107,7 @@ Q1。 可以创建哪个 函数？
# 求解线性系统
矩阵以线性方式将 向量转换为另一个向量。 该变换在数学上对应于线性方程组。 `numpy.linalg`函数`solve()`求解形式为`Ax = b`的线性方程组，其中`A`是矩阵，`b`可以是一维或二维数组，而`x`是未知数 变量。 我们将看到`dot()`功能的使用。 此函数返回两个浮点数组的点积。
矩阵以线性方式将 向量转换为另一个向量。 该变换在数学上对应于线性方程组。 `numpy.linalg`函数`solve()`求解形式为`Ax = b`的线性方程组，其中`A`是矩阵，`b`可以是一维或二维数组，而`x`是未知数 变量。 我们将看到`dot()`函数的使用。 此函数返回两个浮点数组的点积。
`dot()`函数[计算点积](https://www.khanacademy.org/math/linear-algebra/vectors_and_spaces/dot_cross_products/v/vector-dot-product-and-vector-length)。 对于矩阵`A`和向量`b`，点积等于以下总和：
......@@ -376,7 +376,7 @@ print("Product\n", U * np.diag(Sigma) * V)
# 伪逆
矩阵的 **Moore-Penrose 伪逆**的计算公式为 `numpy.linalg`模块的[`pinv()`功能](http://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse)。 使用 SVD 计算伪逆（请参见前面的示例）。 `inv()`函数仅接受平方 矩阵； `pinv()`函数确实没有 的限制，因此被认为是反函数的推广。
矩阵的 **Moore-Penrose 伪逆**的计算公式为 `numpy.linalg`模块的[`pinv()`函数](http://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse)。 使用 SVD 计算伪逆（请参见前面的示例）。 `inv()`函数仅接受平方 矩阵； `pinv()`函数确实没有 的限制，因此被认为是反函数的推广。
# 作用时间–计算矩阵的伪逆
......@@ -505,7 +505,7 @@ print("Determinant", np.linalg.det(A))
傅立叶变换与 ，**傅立叶级数**相关，在上一章中提到了第 5 章，“处理矩阵和函数”。 傅里叶级数将信号表示为正弦和余弦项之和。
FFT 在更多 朴素算法上进行了改进，其阶数为`O(N log N)`。 DFT 在信号处理，图像处理，求解偏微分方程等方面具有应用。 NumPy 有一个名为`fft`的模块，该模块提供 FFT 功能。 该模块中的许多功能已配对。 对于那些函数，另一个函数执行逆运算。 例如，`fft()`和`ifft()`功能形成这样的一对。
FFT 在更多 朴素算法上进行了改进，其阶数为`O(N log N)`。 DFT 在信号处理，图像处理，求解偏微分方程等方面具有应用。 NumPy 有一个名为`fft`的模块，该模块提供 FFT 功能。 该模块中的许多功能已配对。 对于那些函数，另一个函数执行逆运算。 例如，`fft()`和`ifft()`函数形成这样的一对。
# 作用时间–计算傅立叶变换
......@@ -518,7 +518,7 @@ FFT 在更多 朴素算法上进行了改进，其阶数为`O(N log N)`。 DFT
wave = np.cos(x)
```
2. 用 `fft()`功能变换余弦波：
2. 用 `fft()`函数变换余弦波：
```py
transformed = np.fft.fft(wave)
......@@ -576,7 +576,7 @@ plt.show()
# 移位
`numpy.linalg`模块的`fftshift()`功能 将零频率分量移到频谱中心。 零频率分量对应于信号的平均值 。 `ifftshift()`功能可逆转此操作。
`numpy.linalg`模块的`fftshift()`函数 将零频率分量移到频谱中心。 零频率分量对应于信号的平均值 。 `ifftshift()`函数可逆转此操作。
# 采取行动的时机–变换频率
......@@ -589,13 +589,13 @@ plt.show()
wave = np.cos(x)
```
2. 使用`fft()`功能变换余弦波：
2. 使用`fft()`函数变换余弦波：
```py
transformed = np.fft.fft(wave)
```
3. 使用`fftshift()`功能移动信号：
3. 使用`fftshift()`函数移动信号：
```py
shifted = np.fft.fftshift(transformed)
......@@ -663,9 +663,9 @@ plt.show()
**二项分布**模型是整数个独立试验中的成功的次数，[其中每个实验中成功的概率是固定的数字](https://www.khanacademy.org/math/probability/random-variables-topic/binomial_distribution)。
想象一下一个 17 世纪的 赌场，您可以在上面掷 8 个筹码。 九枚硬币被翻转。 如果少于五个，那么您将损失八分之一，否则将获胜。 让我们模拟一下，从拥有的 1,000 个硬币开始。 为此，可以使用随机模块中的`binomial()`功能。
想象一下一个 17 世纪的 赌场，您可以在上面掷 8 个筹码。 九枚硬币被翻转。 如果少于五个，那么您将损失八分之一，否则将获胜。 让我们模拟一下，从拥有的 1,000 个硬币开始。 为此，可以使用随机模块中的`binomial()`函数。
要了解 `binomial()`功能，请查看以下部分：
要了解 `binomial()`函数，请查看以下部分：
1. 将代表现金余额的数组初始化为零。 调用大小为 10000 的`binomial()`函数。这表示在我们的赌场中有 10,000 次硬币翻转：
......@@ -733,7 +733,7 @@ plt.show()
想象一下，游戏 会显示出参赛者每次正确回答问题时，都会从罐子中拉出三个球，然后放回去。 现在，有一个陷阱，罐子里的一个球不好。 每次拔出时，参赛者将失去 6 分。 但是，如果他们设法摆脱 25 个普通球中的 3 个，则得到 1 分。 那么，如果我们总共有 100 个问题，将会发生什么？ 查看以下部分以了解解决方案：
1. 使用`hypergeometric()`功能初始化 游戏结果。 此函数的第一个参数是做出正确选择的方法数量，第二个参数是做出错误选择的方法数量，第三个参数是采样的项目数量：
1. 使用`hypergeometric()`函数初始化 游戏结果。 此函数的第一个参数是做出正确选择的方法数量，第二个参数是做出错误选择的方法数量，第三个参数是采样的项目数量：
```py
points = np.zeros(100)
......@@ -904,7 +904,7 @@ plt.show()
# 实战时间 – 使用`numpy.random.choice()`进行采样
我们将 使用`numpy.random.choice()`功能对 执行引导。
我们将 使用`numpy.random.choice()`函数对 执行引导。
1. 启动 IPython 或 Python Shell 并导入 NumPy：
......
docs/numpy-beginners-guide-3e/ch07.md
浏览文件 @ 861195ad
......@@ -14,7 +14,7 @@
NumPy 具有 几个数据 排序例程：
* `sort()`函数返回 排序数组
* `lexsort()`功能 使用键列表执行排序
* `lexsort()`函数 使用键列表执行排序
* `argsort()`函数 返回将对数组进行排序的索引
* `ndarray`类 具有执行就地排序的`sort()`方法
* `msort()`函数 沿第一轴对数组进行排序
......@@ -194,7 +194,7 @@ NumPy 具有 几个可以搜索数组的函数：
```
* `argmin()` 和`nanargmin()`功能提供相似的功能 ，但将 的最小值作为功能。 `argmax()`和 `nanargmax()`功能也可用作`ndarray`类的方法。
* `argmin()` 和`nanargmin()`函数提供相似的功能 ，但将 的最小值作为功能。 `argmax()`和 `nanargmax()`函数也可用作`ndarray`类的方法。
* `argwhere()`函数 搜索 非零值，并返回按元素分组的相应索引：
```py
......@@ -262,7 +262,7 @@ print("The full array", np.insert(a, indices, [-2, 7]))
# 数组元素提取
NumPy `extract()`函数使我们可以 根据条件从数组中提取项目。 此 函数类似于第 3 章，“我们熟悉的函数”。 特殊的`nonzero()`功能选择非零元素。
NumPy `extract()`函数使我们可以 根据条件从数组中提取项目。 此 函数类似于第 3 章，“我们熟悉的函数”。 特殊的`nonzero()`函数选择非零元素。
# 实战时间 – 从数组中提取元素
......@@ -389,7 +389,7 @@ plt.show()
# 现值
现值是今天的资产价值。 NumPy `pv()`函数可以计算当前值。 此 功能与`fv()`功能类似，并且需要利率，期间数和定期还款，但是这里我们从终值开始。
现值是今天的资产价值。 NumPy `pv()`函数可以计算当前值。 此 功能与`fv()`函数类似，并且需要利率，期间数和定期还款，但是这里我们从终值开始。
在[上了解有关](http://en.wikipedia.org/wiki/Present_value) 当前值的更多信息，网址为 http://en.wikipedia.org/wiki/Present_value 。 如果需要，可以很容易地从将来值的公式中得出当前值的公式。
......@@ -731,7 +731,7 @@ NumPy `hamming()`函数返回汉明窗口。 唯一的参数是输出窗口中
# 特殊数学函数
我们将以一些特殊的数学函数结束本章。 第一类 0 阶的修改后的 Bessel 函数由`i0()`表示为 NumPy 中的 。 `sinc`函数在 NumPy 中由具有相同名称的函数表示， 也有此函数的二维版本。 **Sinc** 是三角函数； 有关更多详细信息，请参见[这里](http://en.wikipedia.org/wiki/Sinc_function)。 `sinc()`功能具有两个定义。
我们将以一些特殊的数学函数结束本章。 第一类 0 阶的修改后的 Bessel 函数由`i0()`表示为 NumPy 中的 。 `sinc`函数在 NumPy 中由具有相同名称的函数表示， 也有此函数的二维版本。 **Sinc** 是三角函数； 有关更多详细信息，请参见[这里](http://en.wikipedia.org/wiki/Sinc_function)。 `sinc()`函数具有两个定义。
NumPy `sinc()`函数符合以下定义：
......@@ -770,7 +770,7 @@ NumPy `sinc()`函数符合以下定义：
# sinc
`sinc()`功能广泛用于数学和信号处理中的 。 NumPy 具有相同名称的函数。 也存在二维函数。
`sinc()`函数广泛用于数学和信号处理中的 。 NumPy 具有相同名称的函数。 也存在二维函数。
# 作用时间–绘制 Sinc 函数
......@@ -795,7 +795,7 @@ NumPy `sinc()`函数符合以下定义：
plt.show()
```
`sinc()`功能将具有以下输出：
`sinc()`函数将具有以下输出：
![Time for action – plotting the sinc function](img/4154_07_07.jpg)
......
docs/numpy-beginners-guide-3e/ch08.md
浏览文件 @ 861195ad
......@@ -289,7 +289,7 @@ abs(actual - expected) >= 10**-(significant - 1)
# 实战时间 – 比较对象
假设您需要 比较两个元组。 我们可以使用`assert_equal()`功能来做到这一点。
假设您需要 比较两个元组。 我们可以使用`assert_equal()`函数来做到这一点。
调用`assert_equal()`函数：
......@@ -407,11 +407,11 @@ item=1
## 刚刚发生了什么？
我们通过`finfo()`功能确定了机器 epsilon。 然后，我们将`1.0`与`1 + epsilon`与`assert_almost_equal_nulp()`功能进行了比较。 但是，该测试通过了，添加另一个 epsilon 导致异常。
我们通过`finfo()`函数确定了机器 epsilon。 然后，我们将`1.0`与`1 + epsilon`与`assert_almost_equal_nulp()`函数进行了比较。 但是，该测试通过了，添加另一个 epsilon 导致异常。
# 具有更多 ULP 的浮标的比较
`assert_array_max_ulp()`功能允许您指定允许的 ULP 数量的上限。 `maxulp`参数接受整数作为限制。 默认情况下，此参数的值为 1。
`assert_array_max_ulp()`函数允许您指定允许的 ULP 数量的上限。 `maxulp`参数接受整数作为限制。 默认情况下，此参数的值为 1。
# 作用时间–使用 2 的最大值进行比较
......
docs/numpy-beginners-guide-3e/ch09.md
浏览文件 @ 861195ad
......@@ -17,7 +17,7 @@
# 简单图
`matplotlib.pyplot`软件包包含用于简单绘图的功能。 重要的是要记住，每个后续函数调用都会更改当前图的状态。 最终，我们想要 将图保存在文件中，或使用 `show()`功能显示。 但是，如果我们在 Qt 或 Wx 后端上运行的 IPython 中，则该图将交互更新，而无需等待`show()`函数。 这与即时输出文本输出的方式相当。
`matplotlib.pyplot`软件包包含用于简单绘图的功能。 重要的是要记住，每个后续函数调用都会更改当前图的状态。 最终，我们想要 将图保存在文件中，或使用 `show()`函数显示。 但是，如果我们在 Qt 或 Wx 后端上运行的 IPython 中，则该图将交互更新，而无需等待`show()`函数。 这与即时输出文本输出的方式相当。
# 作用时间–绘制多项式函数
......@@ -41,19 +41,19 @@
y = func(x)
```
4. 调用`plot()`功能； 这样 不会立即显示图形：
4. 调用`plot()`函数； 这样 不会立即显示图形：
```py
plt.plot(x, y)
```
5. 使用 `xlabel()`功能在`x`轴上添加标签：
5. 使用 `xlabel()`函数在`x`轴上添加标签：
```py
plt.xlabel('x')
```
6. 使用 和`ylabel()`功能在`y`轴上添加标签：
6. 使用 和`ylabel()`函数在`y`轴上添加标签：
```py
plt.ylabel('y(x)')
......@@ -89,7 +89,7 @@ plt.show()
## 小测验– `plot()`函数
Q1。 `plot()`功能有什么作用？
Q1。 `plot()`函数有什么作用？
1. 它在屏幕上显示二维图。
2. 它将二维图的图像保存在文件中。
......@@ -149,7 +149,7 @@ plt.show()
# 子图
在某一时刻，一个绘图中将有太多的线。 但是，您仍然希望将所有内容组合在一起。 我们 可以通过 `subplot()`功能执行此操作。 此功能在网格中创建多个图。
在某一时刻，一个绘图中将有太多的线。 但是，您仍然希望将所有内容组合在一起。 我们 可以通过 `subplot()`函数执行此操作。 此功能在网格中创建多个图。
# 作用时间–绘制多项式及其导数
......@@ -358,7 +358,7 @@ plt.show()
# 直方图
直方图可视化数值数据的 分布。 `matplotlib`具有方便的`hist()`功能 ，可绘制直方图。 `hist()`函数有两个主要参数-包含数据和条数的数组。
直方图可视化数值数据的 分布。 `matplotlib`具有方便的`hist()`函数 ，可绘制直方图。 `hist()`函数有两个主要参数-包含数据和条数的数组。
# 实战时间 – 绘制股价分布图
......@@ -420,7 +420,7 @@ plt.show()
## 成为英雄-画钟形曲线
使用平均价格和标准偏差覆盖钟形曲线（与**高斯**或正态分布有关）。 当然只是 练习。
使用平均价格和标准差覆盖钟形曲线（与**高斯**或正态分布有关）。 当然只是 练习。
# 对数图
......@@ -573,11 +573,11 @@ plt.show()
# 介于
`fill_between()`功能用指定的颜色填充绘图区域。 我们可以选择一个可选的 Alpha 通道 值。 该函数还具有 where 参数，以便我们可以根据条件对区域进行着色。
`fill_between()`函数用指定的颜色填充绘图区域。 我们可以选择一个可选的 Alpha 通道 值。 该函数还具有 where 参数，以便我们可以根据条件对区域进行着色。
# 作用时间–根据条件对绘图区域进行阴影处理
假设您要在股票图表的某个区域遮蔽 ，该区域的收盘价低于平均水平，而其颜色高于高于均值的颜色。 `fill_between()`功能是工作的最佳选择。 我们将再次省略以下步骤：下载一年前的历史数据，提取日期和收盘价以及创建定位器和日期格式化程序。
假设您要在股票图表的某个区域遮蔽 ，该区域的收盘价低于平均水平，而其颜色高于高于均值的颜色。 `fill_between()`函数是工作的最佳选择。 我们将再次省略以下步骤：下载一年前的历史数据，提取日期和收盘价以及创建定位器和日期格式化程序。
1. 创建一个 matplotlib `Figure`对象：
......@@ -654,7 +654,7 @@ plt.show()
# 图例和注释
图例和注释对于良好的情节至关重要。 我们可以使用`legend()`功能 创建透明的图例，然后让`matplotlib`找出放置它们的位置。 同样，通过 和`annotate()`功能，我们可以 准确地在图形上进行注释。 有大量的注释和箭头样式。
图例和注释对于良好的情节至关重要。 我们可以使用`legend()`函数 创建透明的图例，然后让`matplotlib`找出放置它们的位置。 同样，通过 和`annotate()`函数，我们可以 准确地在图形上进行注释。 有大量的注释和箭头样式。
# 实战时间 – 使用图例和注释
......@@ -836,7 +836,7 @@ plt.show()
# 等高线图
`matplotlib`等高线三维 图有两种样式-填充的和未填充的。 等高线图使用所谓的**等高线**。 您可能熟悉地理地图上的等高线。 在此类地图中，等高线连接了海拔相同高度的点。 我们可以使用`contour()`功能创建法线轮廓图。 对于填充的轮廓图，我们使用`contourf()`功能。
`matplotlib`等高线三维 图有两种样式-填充的和未填充的。 等高线图使用所谓的**等高线**。 您可能熟悉地理地图上的等高线。 在此类地图中，等高线连接了海拔相同高度的点。 我们可以使用`contour()`函数创建法线轮廓图。 对于填充的轮廓图，我们使用`contourf()`函数。
# 作用时间–绘制填充的轮廓图
......
docs/numpy-beginners-guide-3e/ch10.md
浏览文件 @ 861195ad
......@@ -13,7 +13,7 @@ SciPy 是建立在 NumPy 之上的世界著名的 Python 开源科学计算库
# MATLAB 和 Octave
**MATLAB** 及其开源替代品 Octave 是流行的数学程序。 `scipy.io`软件包具有一些函数，可让您加载 MATLAB 或 Octave 矩阵，以及数字或 Python 程序中的字符串，反之亦然。 `loadmat()`功能 加载`.mat`文件。 `savemat()`功能将名称和数组的字典保存到`.mat`文件中。
**MATLAB** 及其开源替代品 Octave 是流行的数学程序。 `scipy.io`软件包具有一些函数，可让您加载 MATLAB 或 Octave 矩阵，以及数字或 Python 程序中的字符串，反之亦然。 `loadmat()`函数 加载`.mat`文件。 `savemat()`函数将名称和数组的字典保存到`.mat`文件中。
# 实战时间 – 保存并加载.mat 文件
......@@ -87,7 +87,7 @@ SciPy 统计模块为 ，称为`scipy.stats`。 一类实现连续分布 ，
print("Mean", "Std", stats.norm.fit(generated))
```
平均值和标准偏差如下所示：
平均值和标准差如下所示：
```py
Mean Std (0.0071293257063200707, 0.95537708218972528)
......@@ -348,7 +348,7 @@ plt.show()
样条插值使用称为样条的[多项式进行插值](http://en.wikipedia.org/wiki/Spline_interpolation) ）。 然后，插值尝试将样条线粘合在一起以拟合数据。 B 样条是样条的一种。
SciPy 信号定义为数字数组。 过滤器的一个示例是`detrend()`功能。 此函数接收信号并对其进行线性拟合。 然后从原始输入数据中减去该趋势。
SciPy 信号定义为数字数组。 过滤器的一个示例是`detrend()`函数。 此函数接收信号并对其进行线性拟合。 然后从原始输入数据中减去该趋势。
# 实战时间 – 检测 QQQ 趋势
......@@ -739,7 +739,7 @@ SciPy 具有数值积分 程序包`scipy.integrate`，在 NumPy 中没有等效
# 作用时间–计算高斯积分
**高斯积分**是与`error()`功能相关的（也称为 在数学上为`erf`，但没有限制。 计算结果为`pi`的平方根。
**高斯积分**是与`error()`函数相关的（也称为 在数学上为`erf`，但没有限制。 计算结果为`pi`的平方根。
![Time for action – calculating the Gaussian integral](img/4154_10_10.jpg)
......@@ -935,7 +935,7 @@ plt.show()
# 实战时间 – 重放音频片段
我们将下载 Austin Powers 的 WAV 文件，称为“Smashing baby”。 可以使用`scipy.io.wavfile`模块中的 `read()`函数将此文件转换为 NumPy 数组。 相同程序包中的 `write()`功能将在本节末尾用于创建新的 WAV 文件。 我们将进一步使用 `tile()`功能重播音频剪辑几次。
我们将下载 Austin Powers 的 WAV 文件，称为“Smashing baby”。 可以使用`scipy.io.wavfile`模块中的 `read()`函数将此文件转换为 NumPy 数组。 相同程序包中的 `write()`函数将在本节末尾用于创建新的 WAV 文件。 我们将进一步使用 `tile()`函数重播音频剪辑几次。
1. Read the file with the `read()` function:
......@@ -945,7 +945,7 @@ plt.show()
这给了我们两项–采样率和音频数据。 对于本节，我们仅对音频数据感兴趣。
2. 应用 `tile()`功能：
2. 应用 `tile()`函数：
```py
repeated = np.tile(data, 4)
......
docs/numpy-beginners-guide-3e/ch11.md
浏览文件 @ 861195ad
......@@ -413,7 +413,7 @@ Pygame `surfarray`模块处理 Pygame `Surface`对象与 NumPy 数组之间的
screen = pygame.display.set_mode((X, Y))
```
3. 使用 NumPy `tile()`功能可以轻松平铺图像。 数据需要转换为整数值，因为 Pygame 将颜色定义为整数：
3. 使用 NumPy `tile()`函数可以轻松平铺图像。 数据需要转换为整数值，因为 Pygame 将颜色定义为整数：
```py
new_pixels = np.tile(pixels, (7, 7)).astype(int)
......
docs/numpy-beginners-guide-3e/ch12.md
浏览文件 @ 861195ad
......@@ -70,7 +70,7 @@
| | |
| --- | --- |
| `plot`功能有什么作用？ | 它既不执行 1、2 也不执行 3 |
| `plot`函数有什么作用？ | 它既不执行 1、2 也不执行 3 |
# 第 10 章，当 NumPy 不够用时–Scipy 和超越
......
docs/numpy-beginners-guide-3e/ch14.md
浏览文件 @ 861195ad
......@@ -75,10 +75,10 @@
* `numpy.row_stack(tup)`：逐行堆叠 数组。
* `numpy.save(file, arr)`：以 NumPy `.npy`格式将 NumPy 数组保存到文件中。
* `numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')`：将 NumPy 数组保存到文本文件。
* `numpy.sinc(a)`：计算 和`sinc`功能。
* `numpy.sinc(a)`：计算 和`sinc`函数。
* `numpy.sort_complex(a)`：首先以 实部对数组元素进行排序，然后是虚部。
* `numpy.split(a, indices_or_sections, axis=0)`：将数组拆分为 子数组。
* `numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False)`：返回沿给定 轴的标准偏差。
* `numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False)`：返回沿给定 轴的标准差。
* `numpy.take(a, indices, axis=None, out=None, mode='raise')`：使用指定的索引从数组中选择 元素。
* `numpy.vsplit(a, indices_or_sections)`：将数组 垂直拆分为子数组。
* `numpy.vstack(tup)`：垂直堆叠数组 。
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或