NumPy arange()：如何使用 np.arange()

返回值及参数np.arange()

数值模拟arange()是基于数值范围的数组创建例程之一。它创建一个实例ndarray和均匀分布的值并返回对其的引用。

您可以使用以下四个参数定义数组中包含的值的间隔、它们之间的空间以及它们的类型arange():

numpy.arange([start, ]stop, [step, ], dtype=None) -> numpy.ndarray

前三个参数确定值的范围，而第四个参数指定元素的类型：

1. start是个数字（整数或小数）定义数组中的第一个值。
2. stop是定义数组末尾且不包含在数组中的数字。
3. step是定义数组中每两个连续值之间的间距（差异）的数字，默认为1.
4. dtype是输出数组元素的类型，默认为没有任何.

step不能为零。否则，你会得到一个ZeroDivisionError。你无法离开任何地方start如果增量或减量是0.

If dtype被省略，arange()将尝试从数组元素的类型中推断出数组元素的类型start, stop， 和step.

您可以找到有关参数和返回值的更多信息arange()在里面官方文档.

范围参数np.arange()

NumPy 的参数arange()定义数组中包含的值对应于数字参数start, stop， 和step。你必须通过最后一个其中。

以下示例将向您展示如何arange()行为取决于参数的数量及其值。

提供所有范围参数

使用 NumPy 例程时，必须首先导入 NumPy：

>>>

>>> import numpy as np

现在，您已导入 NumPy，并准备好应用arange().

让我们看一下如何使用 NumPy 的第一个示例arange():

>>>

>>> np.arange(start=1, stop=10, step=3)
array([1, 4, 7])

在这个例子中，start是1。因此，得到的数组的第一个元素是1. step是3，这就是为什么你的第二个值是 1+3，即4，而数组中的第三个值是 4+3，等于7.

按照这种模式，下一个值将是10(7+3)，但计数必须结束前 stop已达到，所以不包括这一点。

你可以通过start, stop， 和step也作为位置参数：

>>>

>>> np.arange(1, 10, 3)
array([1, 4, 7])

此代码示例与前一个示例等效，但比前一个更简洁。

的价值stop不包含在数组中。这就是为什么你可以用不同的方法获得相同的结果stop价值观：

>>>

>>> np.arange(1, 8, 3)
array([1, 4, 7])

此代码示例返回与前两个具有相同值的数组。使用任何值都可以获得相同的结果stop严格大于7且小于或等于10.

但是，如果你使stop比...更棒10，那么计数将在之后结束10到达了：

>>>

>>> np.arange(1, 10.1, 3)
array([ 1.,  4.,  7., 10.])

在本例中，您将获得包含四个元素的数组，其中包括10.

请注意，与前一个示例不同，此示例创建了一个浮点数数组。那是因为你没有定义dtype， 和arange()为你推演了。您将在本文后面了解更多相关信息。

您可以在下图中看到这三个示例的图形表示：

start显示为绿色，stop为红色，同时step数组中包含的值是蓝色的。

从上图可以看出，前两个示例有三个值（1, 4， 和7）算了。他们不允许10被包括。在第三个例子中，stop大于10，并且它包含在结果数组中。

>>> np.arange(start=1, stop=10, step=1)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=1, stop=10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.arange(1, 10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.arange(start=0, stop=10, step=1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10, 1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=0, stop=10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.arange(10)  # Stop is 10, start is 0, and step is 1!
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.arange(stop=10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: arange() missing required argument 'start' (pos 1)

>>> np.arange(-5, -1)
array([-5, -4, -3, -2])
>>> np.arange(-8, -2, 2)
array([-8, -6, -4])
>>> np.arange(-5, 6, 4)
array([-5, -1,  3])

倒数

有时您需要一个数组，其值从左到右递减。在这种情况下，您可以使用arange()为负值step，并用一个start比...更棒stop:

>>>

>>> np.arange(5, 1, -1)
array([5, 4, 3, 2])
>>> np.arange(7, 0, -3)
array([7, 4, 1])

在此示例中，请注意以下模式：获取的数组以第一个参数的值开始，并递减step朝向第二个参数的值。

在最后的声明中，start是7，结果数组以此值开始。step是-3所以第二个值为 7+(−3)，即4。第三个值是 4+(−3)，或者1。自此停止计数stop (0) 在下一个值 (-2).

您可以在下图中看到此示例的图形表示：

再次，start显示为绿色，stop为红色，同时step数组中包含的值是蓝色的。

这次，箭头显示从右到左的方向。那是因为start大于stop, step是负数，你基本上是在倒数。

前面的示例产生与以下相同的结果：

>>>

>>> np.arange(1, 8, 3)[::-1]
array([7, 4, 1])
>>> np.flip(np.arange(1, 8, 3))
array([7, 4, 1])

然而，具有负值的变体step更加优雅简洁。

>>> np.arange(2, 2)
array([], dtype=int64)

>>> np.arange(8, 2, 1)
array([], dtype=int64)
>>> np.arange(2, 8, -1)
array([], dtype=int64)

数据类型np.arange()

NumPy 数组中元素的类型是使用它们的一个重要方面。当与arange()，您可以使用参数指定元素的类型dtype.

你可以随意省略dtype。在这种情况下，arange()将尝试推断结果数组的数据类型。这取决于类型start, stop， 和step，如以下示例所示：

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')
>>> x.itemsize  # In bytes
8

这里，有一个论点（5) 定义值的范围。它的类型是int。这就是数组的 dtype 的原因x将是 NumPy 提供的整数类型之一。在这种情况下，NumPy 选择int64默认为数据类型。这是 64 位（8 字节）整数类型。

上一示例中的数组与此等效：

>>> x = np.arange(5, dtype=int)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')

论据dtype=int 不参考Pythonint。它翻译为 NumPyint64或者简单地np.int.

NumPy 为您提供了几种整数固定大小的数据类型，它们在内存和限制方面有所不同：

• np.int8:8 位有符号整数（来自-128到127)
• np.uint8:8 位无符号整数（来自0到255)
• np.int16:16 位有符号整数（来自-32768到32767)
• np.uint16:16 位无符号整数（来自0到65535)
• np.int32:32 位有符号整数（来自-2**31到2**31-1)
• np.uint32:32 位无符号整数（来自0到2**32-1)
• np.int64:64 位有符号整数（来自-2**63到2**63-1)
• np.uint64:64 位无符号整数（来自0到2**64-1)

如果您想要数组元素的其他整数类型，则只需指定dtype:

>>> x = np.arange(5, dtype=np.int32)
>>> x
array([0, 1, 2, 3, 4], dtype=int32)
>>> x.dtype
dtype('int32')
>>> x.itemsize  # In bytes
4

现在，生成的数组具有与前一种情况相同的值，但元素的类型和大小不同。论据dtype=np.int32（或者dtype='int32') 强制每个元素的大小x为 32 位（4 字节）。

当您的参数是十进制数而不是整数时，dtype 将是某种 NumPy 浮点类型，在这种情况下float64:

>>> y = np.arange(5.0)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

最后四个示例中元素的值相同，但数据类型不同。

一般来说，当您至少提供一个浮点参数时arange()，即使其他参数是整数，结果数组也将具有浮点元素：

>>> np.arange(1, 5.1)
array([1., 2., 3., 4., 5.])
>>> np.arange(1, 5.1).dtype
dtype('float64')
>>> np.arange(0, 9, 1.5)
array([0. , 1.5, 3. , 4.5, 6. , 7.5])
>>> np.arange(0, 9, 1.5).dtype
dtype('float64')

在上面的例子中，start是一个整数，但 dtype 是np.float64因为stop或者step是浮点数。

如果您指定dtype， 然后arange()将尝试生成一个包含所提供数据类型的元素的数组：

>>> y = np.arange(5, dtype=float)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

论据dtype=float这里翻译为 NumPyfloat64， 那是np.float。它不参考Pythonfloat。固定大小的别名float64是np.float64和np.float_.

当您需要具有较低精度和大小（以字节为单位）的浮点数据类型时，您可以显式指定：

>>> z = np.arange(5, dtype=np.float32)
>>> z
array([0., 1., 2., 3., 4.], dtype=float32)
>>> z.dtype
dtype('float32')

使用dtype=np.float32（或者dtype='float32') 使数组的每个元素z32 位（4 字节）大。每个元素的大小y是 64 位（8 字节）：

>>> y.itemsize  # In bytes
8
>>> z.itemsize  # In bytes
4

元素之间的区别y和z，并且一般在np.float64和np.float32，是使用的内存和精度：第一个比后者更大且更精确。

在许多情况下，您不会注意到这种差异。然而，有时这很重要。例如，TensorFlow用途float32 和 int32。同样，当您处理图像时，甚至使用较小的类型，例如 uint8.

什么时候step不是整数，结果可能会不一致浮点运算的局限性.

超越简单范围np.arange()

您可以方便地组合arange()与运算符（如+, -, *, /, **等）和其他 NumPy 例程（例如绝对值()或者罪（）) 产生输出值的范围：

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> 2**x
array([ 1,  2,  4,  8, 16])
>>> y = np.arange(-1, 1.1, 0.5)
>>> y
array([-1. , -0.5,  0. ,  0.5,  1. ])
>>> np.abs(y)
array([1. , 0.5, 0. , 0.5, 1. ])
>>> z = np.arange(10)
>>> np.sin(z)
array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,
       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849])

当您想要在 Matplotlib 中创建绘图.

如果您需要多维数组，那么您可以组合arange()和.reshape()或类似的函数和方法：

>>> a = np.arange(6).reshape((2, 3))
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> a.shape
(2, 3)
>>> a.ndim
2

这就是您可以获得ndarray带有元素的实例[0, 1, 2, 3, 4, 5]和重塑将其转为二维数组。

相对比range和np.arange()

Python有一个内置类range，类似于 NumPyarange()在某种程度上。range和np.arange()具有与应用和性能相关的重要区别。您会看到它们的差异和相似之处。

两者之间的主要区别在于range是一个内置的Python类， 尽管arange()是属于第三方库 (NumPy) 的函数。

另外，他们的目的也不一样！一般来说，range当你需要时更适合迭代使用Python for 循环。如果你想创建一个 NumPy 数组，并在后台应用快速循环，那么arange()是一个更好的解决方案。

>>> import timeit
>>> n = 1
>>> timeit.timeit(f'x = [i**2 for i in range({n})]')
>>> timeit.timeit(f'x = np.arange({n})**2', setup='import numpy as np')

其他基于数值范围的例程

此外arange()，您可以根据数值范围应用其他 NumPy 数组创建例程：

• 林空间()类似于arange()因为它返回均匀分布的数字。但您可以指定要生成的值的数量以及是否包含端点以及是否一次创建多个数组。
• 日志空间()和地理空间()类似于linspace()，但返回的数字在对数刻度上均匀分布。
• 网格（）, 奥格德（）， 和网格（）返回表示为数组的点网格。

所有这些功能都有其特点和用例。您可以根据您的需要选择合适的一种。

正如您已经看到的，NumPy 包含更多创建 ndarray 实例的例程.

快速总结

使用 NumPyarange()，你需要导入numpy第一的：

>>> import numpy as np

下面的表格包含一些示例，总结了如何使用 NumPyarange()。记住各种用途可能会有所帮助：

不要忘记，您还可以通过使用参数指定 NumPy dtypes 来影响数组使用的内存dtype.

结论

您现在知道如何使用 NumPyarange()。功能np.arange()是经常用于创建 NumPy 实例的基本 NumPy 例程之一ndarray。它有四个参数：

1. start:数组的第一个值
2. stop:数组结束的地方
3. step:增量或减量
4. dtype:数组元素的类型

您还了解了 NumPy 如何arange()与Python内置类的比较range当您创建序列并生成要迭代的值时。

您看到还有其他基于数值范围的 NumPy 数组创建例程，例如linspace(), logspace(), meshgrid()， 等等。

如果您有疑问或意见，请将其放在下面的评论部分。