关于人工智能:Numpy的终极备忘录

作者 |Rashida Nasrin Sucky
编译 |VK
起源 |Towards Data Science

Python 是开源的。对于应用 python 的数据科学家来说，Numpy 这个库是必不可少的。其余一些根本的库，如 Pandas，Scipy 是建设在 Numpy 的根底上。所以我决定做一份备忘录。这里我包含了到目前为止应用的所有 Numpy 函数。我置信这些函数将足以让你在日常工作中作为数据科学家或数据分析员实现你的工作。

我将从十分根本的 Numpy 性能开始，缓缓地向更高级的性能挪动。然而应用 Numpy 很容易。在这里你不会发现任何简单的编码技巧。

在 Numpy 文档中，Numpy 的定义如下：

NumPy 是 Python 中科学计算的根本包。它是一个 Python 库，它提供多维数组对象、各种派生对象 (如掩码数组和矩阵) 以及数组上疾速操作的各种例程，包含数学、逻辑、形态解决、排序、抉择、I/O、离散傅立叶变换、根本线性代数，根本的统计操作，随机模仿等等。

我每天都用这个库。如果是 python 用户，大多数数据科学家都会这么做。它疾速，易于应用，了解，简略。我不想写太多对于它是如何和为什么这么好的。因为在浏览本文的过程中，你将亲眼看到这一点。

我的指标是记录 Numpy 每天应用的办法。

正如文章名所说，这是一本对于 Numpy 的指南。它也能够用作备忘录。如果你应用 Numpy 库或打算未来应用，或正在学习，此页面能够成为你日常生活的一个很好的资源。

这里将探讨以下主题：

Numpy 数组基础知识
反复
数学运算
统计
初始化不同类型的数组
重新排列或从新组织数组
数组的索引与切片
增加行或列
追加、插入、删除和排序
随机
文件导入、保留和加载

咱们开始吧！！

整个练习我都用了一个 Jupyter Notebook。第一个导入 Numpy。

import numpy as np

做一个 Numpy 数组。为此，咱们须要传递一个 Python 列表。

输出：

a = np.array([1,2,3])
a

输入：

array([1, 2, 3])

在数组 ’a’ 中，我应用了所有的整数。当初，制作一个浮点数组：

输出：

b = np.array([[9.0, 10.0, 6.0], [6.0,1.0,7.0]])
b

输入：

array([[9., 10.,  6.],
       [6.,  1.,  7.]])

让咱们试着用浮点型和浮点型数组：

输出：

np.array([1, 3.0, 0.004, -2])

输入：

array([1.   ,  3.   ,  0.004, -2.])

留神，Numpy 主动将整数转换为浮点！

找出数组 a 和 b 的尺寸：

输出：

a.ndim

输入：

输出：

b.ndim

输入：

数组“a”是一维数组，数组 b 是二维数组。

当初，找出数组“a”和“b”的形态：

输出：

a.shape

输入：

(3,)

输出：

b.shape

输入：

(2, 3)

数组“a”是一维数组。它只有一个值。然而数组 b 是一个二维数组。所以，它的形态是 2×3。这意味着它有 2 行 3 列。

输出：

len(a)

输入：

输出：

len(b)

输入：

数组 a 的长度是 3，因为它外面有 3 个元素。数组“b”是一个二维数组。因而，数组的长度并不意味着其中元素的数量。长度示意其中一维数组的数量或其中的行数。它有两行。长度是 2。

有几种不同的办法能够反复数组的元素。如果你想反复整个数组，

输出：

np.array([2,4,6]*4)

输入：

array([2, 4, 6, 2, 4, 6, 2, 4, 6, 2, 4, 6])

看，数组 [2，4，6] 被反复了 4 次。

上面是如何做元素级的反复，

输出：

np.repeat([1,2,3], 3)

输入：

array([1, 1, 1, 2, 2, 2, 3, 3, 3])

这次每个元素反复 3 次。

咱们把这个用于二维数组，

输出：

arr = np.array([[2, 4, 6]])
arr

输入：

array([[2, 4, 6]])

当初，在它下面反复：

输出：

np.repeat(arr,3,axis=0)

输入：

array([[2, 4, 6],
       [2, 4, 6],
       [2, 4, 6]])

这里，咱们提到 axis=0。所以，反复产生在 0 轴方向或行方向。

输出：

np.repeat(arr,3,axis=1)

输入：

array([[2, 2, 2, 4, 4, 4, 6, 6, 6]])

轴 1 批示列的方向。所以，反复产生在列的方向上。

在这一节中，我将展现数学运算。大多数操作都是显而易见的。我将从一个数组的数学运算开始。

输出：

a = np.array([1,2,3,4])
a

输入：

array([1, 2, 3, 4])

输出：

a+2

输入：

array([3, 4, 5, 6])

它向数组的每个元素增加 2。

输出：

a-2

输入：

array([-1,  0,  1,  2])

你能够简略地应用相似的操作，例如：

输出：

a/2

输入：

array([0.5, 1. , 1.5, 2.])

输出：

a**2

输入：

array([1,  4,  9, 16], dtype=int32)

两个星号示意指数。“a”中的每个元素都是平方的。

输出：

np.sqrt(a)  # 平方根

输入：

array([1.        , 1.41421356, 1.73205081, 2.])

咱们还能够执行一些三角运算：

输出：

np.cos(a)

输入：

array([0.54030231, -0.41614684, -0.9899925 , -0.65364362])

输出：

np.sin(a)

输入：

array([0.84147098,  0.90929743,  0.14112001, -0.7568025])

输出：

np.tan(a)

输入：

array([1.55740772, -2.18503986, -0.14254654,  1.15782128])

当初看看咱们如何在两个数组或矩阵中做一些数学运算。首先，再做一个数组，

输出：

b = np.array([3,4,5,6])

输入：

array([3, 4, 5, 6])

作为揭示，咱们的数组“a”如下所示：

array([1, 2, 3, 4])

当初，咱们有两个数组，a 和 b。让咱们做同样的数学运算。再说一次，这很简略，不言自明，

输出：

a + b

输入：

array([4,  6,  8, 10])

你能够用同样的办法进行以下操作：

a - b
a*b
a/b
a**b

另一种宽泛应用的操作是，

输出：

a.dot(b)

输入：

什么是 a.dot(b)？这是先利用元素的乘法，而后再进行累加，

1*3 + 2*4 + 3*5 + 4*6

其中数组“a”是[1,2,3,4]，数组 b 是[3,4,5,6]。

你也能够写一些不同的语法，

np.dot(a, b)

这是一样的。输入将是 50。

咱们能够在多维数组中应用这个过程。咱们做两个多维数组，

输出：

c = np.array([[3, 5, 1], [6, 4, 9]])
c

输入：

array([[3, 5, 1],
       [6, 4, 9]])

输出：

d = np.array([[5,2], [7,9], [4, 3]])
d

输入：

array([[5, 2],
       [7, 9],
       [4, 3]])

咱们筹备好在多维数组上进行“点”运算，

输出：

c.dot(d)

输入：

array([[54, 54],
       [94, 75]])

当输出为二维数组时，“点”函数的行为相似于矩阵乘法。

这意味着你只能在第一个数组的列数与第二个数组中的行数匹配时执行“点”操作。

如果第一个数组是 mxn，那么第二个数组应该是 nxp。

矩阵乘法还有另一个表达式，

输出：

np.matmul(c, d)

输入：

array([[54, 54],
       [94, 75]])

‘np.matmul’ 在一维数组中不起作用

记住，这个乘法规定不适用于其余运算，如加法、减法或除法。咱们须要有雷同形态和大小的数组来对一个矩阵进行加法、减法或除法。

Numpy 也有根本的统计操作。这里有一些例子。

首先创立一个新数组。

输出：

x = np.array([1,3,4,6,-3,-2])
x.sum()

输入：

输出：

x.max()

输入：

输出：

x.min()

输入：

-3

输出：

x.mean()

输入：

1.5

输出：

x.std()  # 标准差

输入：

3.2015621187164243

还有另外两个十分有用的函数，它们不是齐全统计的，

输出：

x.argmin()

输入：

输出：

x.argmax()

输入：

什么是“argmin()”或“argmax()”？

“argmin()”提供数组最小元素的索引，“argmax()”返回数组最大值的索引。

数组“x”的最小元素是 -3，数组“x”的最大元素是 6。能够查看他们的索引是否匹配。

Numpy 中有很多不同的办法来初始化数组。这里我将探讨一些罕用的办法：

输出：

np.arange(10)

输入：

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

这是初始化一系列数字的办法。留神它从 0 开始到 9 完结。始终排除下限。这里的下限是 10。所以，它在 9 进行。

咱们还能够增加一个数学运算：

输出：

np.arange(10)**2

输入：

array([0,  1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

在本例中，咱们要求平方，咱们失去了输入数组中 0 到 9 的平方。

咱们能够用肯定的距离把一系列的数字组成一个数组。

np.arange(0, 15, 3)

输入：

array([0,  3,  6,  9, 12])

这里，0 是上限，15 是下限，3 是距离。

还有另一种办法能够提供略微不同的序列：

输出：

np.linspace(0, 3, 15)

输入：

array([0.        , 0.21428571, 0.42857143, 0.64285714, 0.85714286,
       1.07142857, 1.28571429, 1.5       , 1.71428571, 1.92857143,
       2.14285714, 2.35714286, 2.57142857, 2.78571429, 3.        ])

这里的元素数是 0，下限是 3。在本例中，Numpy 主动生成 15 个元素，这些元素的间距从 0 到 3 相等。

还有几种其余类型的数组：

输出：

np.ones((3, 4))

输入：

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

输出：

np.zeros((2, 3))

输入：

array([[0., 0., 0.],
       [0., 0., 0.]])

你能够失去一个三维数组：

输出：

np.ones((4,3,2), dtype='int32')

输入：

array([[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]]])

这里，(4,3,2)示意 4 个二维数组，每个数组有 3 行 2 列。

还有另一种办法叫做 full，它能够替换数组的元素：

输出：

np.full((2,2), 30)

输入：

array([[30, 30],
       [30, 30]])

输出：

ar = np.array([[2,3], [4,5]])
ar

输入：

array([[2, 3],
       [4, 5]])

输出：

np.full_like(ar, 4)

输入：

array([[4, 4],
       [4, 4]])

还有另一种类型的矩阵称为单位矩阵：

输出：

np.identity(5)

输入：

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

这是一个 5 ×5 的矩阵，只有对角元素是 1，其余元素都是 0。

还有一种类型叫做“eye”。它的参数是矩阵的形态：

输出：

np.eye(3,3)

输入：

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

输出：

np.eye(3,4)

输入：

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])

对角线上的数字能够不同于 1。

输出：

a = np.array([2,4,5])
np.diag(a)

输入：

array([[2, 0, 0],
       [0, 4, 0],
       [0, 0, 5]])

有不同的办法来重新排列或组织数组。

首先，做一个数组，

输出：

x = np.arange(0, 45, 3)
x

输入：

array([0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])

我在上一节中解释了“arange”函数。让咱们看看如何重塑它。

输出：

x.reshape(3, 5)

输入：

array([[0,  3,  6,  9, 12],
       [15, 18, 21, 24, 27],
       [30, 33, 36, 39, 42]])

咱们传入了(3，5)。因而，它变成了一个有 3 行 5 列的二维数组。咱们能够通过应用：

x.resize(3,5)

如果咱们想回到原来的一维数组呢？

这是办法之一

输出：

x.ravel()

输入：

array([0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])

看，咱们找回了原来的数组！

留神另一件事。咱们扭转了数组的维数。数组“x”是一维数组。咱们通过重塑它使它成为一个二维数组。

当初，制作另一个数组来更好地了解它。这是另一个例子。

输出：

c = np.array([4,5,6])
c

输入：

array([4, 5, 6])

这次我将应用 resize。“reshape”也会这样做。为了练习调整大小，让咱们在这里应用 resize。

输出：

c.resize(3,1)

输入：

array([[4],
       [5],
       [6]])

咱们提供了 (3,1) 作为调整大小的参数。所以它有 3 行 1 列。这是一个 3 ×1 矩阵。咱们也能够有一个 1 ×3 矩阵。

输出：

c.resize(1,3)
c

输入：

array([[4, 5, 6]])

原来 c 是一维数组。或者当初是二维矩阵。

不要认为你只能重塑一个一维数组的大小。也能够在高维数组中执行此操作。

我举几个例子：

输出：

x = np.array([[1,2,3,4], [5,6,7,8]])
x

输入：

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

当初重塑这个二维数组，

输出：

x.reshape(4,2)
x

输入：

array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

你能够应用我后面提到的“resize”来实现这一点。还有另一种办法，

输出：

y = x.reshape(4, -1)
y

输入：

array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

看起来很困惑？设想一下，你有一个微小的数组或数据集。在重塑之前，你只晓得一个维度。因而，在 reshape 办法中，给出了其余维的大小，剩下的 numpy 能够本人计算。

在下面的例子中，我传递了第一个维度 4。这意味着我要让 Numpy 做 4 行。我不晓得有多少列。所以我就设置参数 -1。所以，它会主动生成 2 列。

当咱们解决大数据集或数据帧时，这是一个十分有用的技巧，咱们必须构建机器学习算法。

在下面的所有例子中，咱们看到了如何重塑和扭转尺寸。

这是扭转尺寸的办法。下面的数组“y”是一个 4 ×2 矩阵。让咱们再做一个 2 ×4 矩阵。

输出：

y.T

输入：

array([[1, 3, 5, 7],
       [2, 4, 6, 8]])

这种办法称为转置。当你在数组或矩阵上应用转置时，它只是扭转了维数。2×3 矩阵变为 3 ×2，3×6 矩阵变为 6 ×3 或 1 ×3 矩阵变为 3 ×1。

索引和切片是一项十分常见的日常工作。咱们来举几个例子：

输出：

a = np.array([2,5,1,7,6,3,9,0,4])

输出：

a[0]

输入：

a[0]给出数组的第一个元素。同样，咱们能够持续应用 a[1]，a[2]，始终到整个数组。

输出：

a[3]

输入：

咱们也能够切片，

输出：

a[1:5]

输入：

array([5, 1, 7, 6])

咱们输出了[1:5]。因而，切片将从索引 1 开始，在索引 5 之前完结。记住，包含上限，排除下限。

在本文中，我不再深刻探讨切片和索引。因为我曾经写了另一篇文章具体解释过了。请检查一下。学好它很重要。

https://towardsdatascience.co…

Numpy 有几种不同的办法来增加行或列。这里有一些例子。

这次我将应用一些列表或数组。Numpy 会在重叠时主动将它们变成数组。

这里有两个列表：

x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [1, 0, 9, 5]

当初垂直重叠它们。

输出：

np.vstack([x1, x2])

输入：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5]])

你能够把它们叠成你想要的次数。

输出：

np.vstack([x1, x2, x2])

输入：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5],
       [1, 0, 9, 5]])

让咱们做一些程度重叠。咱们须要行数雷同的数组。

“x1”有 2 行。用它做一个数组。

输出：

np.array(x1)

输入：

array([[2, 4, 3, 7],
       [2, 5, 3, 1]])

生成另一个数组“x3”。

输出：

x3 = np.ones((2,3))
x3

输入：

array([[1., 1., 1.],
       [1., 1., 1.]])

程度重叠

输出：

np.hstack([x1, x3])

输入：

array([[2., 4., 3., 7., 1., 1., 1.],
       [2., 5., 3., 1., 1., 1., 1.]])

另一种增加列或行的办法。但与重叠相同，这次咱们须要两个雷同维度的数组。记住，当咱们进行垂直重叠时，咱们有一个二维和一维列表。

这是我在这个例子中的两个列表。

x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [[1, 0, 9, 5]]

concatenate 操作

输出：

np.concatenate((x1, x2), axis=0)

输入：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5]])

当初，程度连贯。但咱们须要两个行数雷同的数组。

x3 = [[2,4], [7,5]]

连贯 x1 和 x3。

输出：

np.concatenate((x1, x3), axis=1)

输入：

array([[2, 4, 3, 7, 2, 4],
       [2, 5, 3, 1, 7, 5]])

你可能晓得这些口头的函数。

append

输出：

np.append([2,3], [[4,5], [1, 3]])

输入：

array([2, 3, 4, 5, 1, 3])

输出：

np.append([2, 3, 1], [[4, 5], [1,3]])

输入：

array([2, 3, 1, 4, 5, 1, 3]

咱们在这些例子中没有提到任何轴心。所以，默认状况下，它们取轴 1，或者在列方向或程度方向。当初，在垂直方向执行追加操作。

输出：

np.append([[1,3,5], [4,3,6]], [[1,2,3]], axis=0)

输入：

array([[1, 3, 5],
       [4, 3, 6],
       [1, 2, 3]])

Insert

这次咱们将在某个地位插入一个元素。从一个新数组开始。

输出：

a = np.array([[2, 2], [3, 4], [5, 6]])
a

输入：

array([[2, 2],
       [3, 4],
       [5, 6]])

在数组的结尾插入元素 5。

输出：

np.insert(a, 0, 5)

输入：

array([5, 2, 2, 3, 4, 5, 6])

首先，了解输出。在 (a，0，5) 中，a 是数组，0 是要插入元素的地位，5 是要插入的元素。

留神，插入是如何产生的。首先，二维数组 a 被展平成一维数组。而后在索引 0 处增加 5。

咱们也能够沿着轴插入。

输出：

np.insert(a, 0, 5, axis=1)

输入：

array([[5, 2, 2],
       [5, 3, 4],
       [5, 5, 6]])

看，一列 5 被增加到数组 ’a’ 中。咱们也能够增加一行 5。

输出：

np.insert(a, 0, 5, axis=0)

输入：

array([[5, 5],
       [2, 2],
       [3, 4],
       [5, 6]])

Delete

我会像以前一样做一个新的数组。

输出：

a= np.array([[1,3,2,6], [4,1,6,7], [9, 10, 6, 3]])
a

输入：

array([[1,  3,  2,  6],
       [4,  1,  6,  7],
       [9, 10,  6,  3]])

输出：

np.delete(a, [1, 2, 5])

输入：

array([1,  6,  4,  6,  7,  9, 10,  6,  3])

与插入操作一样，删除操作也会使数组变平。在输出 [1,2,5] 中是要删除的索引列表。为了分明地看到它，让咱们展平原始数组 ’a’。

输出：

a.flatten()

输入：

array([1,  3,  2,  6,  4,  1,  6,  7,  9, 10,  6,  3])

当初检查一下，索引 1、2 和 5 的元素都被删除了。

与插入相似，咱们能够删除特定的行或列。

删除列索引 1。

输出：

np.delete(a, 1, 1)

输入：

array([[1, 2, 6],
       [4, 6, 7],
       [9, 6, 3]])

在输出 (a，1，1) 中，a 是数组，1 是要删除的列的索引，最初一个 1 是轴。

输出：

np.delete(a, 1, 0)

输入：

array([[1,  3,  2,  6],
       [9, 10,  6,  3]])

Sort

数组“a”：

array([[1,  3,  2,  6],
       [4,  1,  6,  7],
       [9, 10,  6,  3]])

输出：

np.sort(a)

输入：

array([[1,  2,  3,  6],
       [1,  4,  6,  7],
       [3,  6,  9, 10]])

看，它是双向排列的。咱们能够指定轴并按特定轴排序。

输出：

np.sort(a, axis=None)

输入：

array([1,  1,  2,  3,  3,  4,  6,  6,  6,  7,  9, 10])

当轴为“None”时，它展平数组并进行排序。当初，按轴 0 和轴 1 排序。

输出：

np.sort(a, axis=0)

输入：

array([[1,  1,  2,  3],
       [4,  3,  6,  6],
       [9, 10,  6,  7]])

输出：

np.sort(a, axis=1)

输入：

array([[1,  2,  3,  6],
       [1,  4,  6,  7],
       [3,  6,  9, 10]])

Flip

它的确像听起来那样。翻转数组和行。

这是该数组。

arr

输入：

array([[1,  2,  3,  4],
       [5,  6,  7,  8],
       [9, 10, 11, 12]])

当初，沿轴 0 和 1 的方向翻转该数组。

输出：

np.flip(arr, 0)

输入：

array([[9, 10, 11, 12],
       [5,  6,  7,  8],
       [1,  2,  3,  4]])

输出：

np.flip(arr, 1)

输入：

array([[4,  3,  2,  1],
       [8,  7,  6,  5],
       [12, 11, 10,  9]])

Numpy 有很好的随机数生成性能。它们在机器学习、钻研或统计方面十分有用。这里有一些例子。

输出：

np.random.rand()

输入：

0.541670003513435

它生成一个介于 0 到 1 之间的数字。咱们能够从这样的随机数中失去一个数组或矩阵。

输出：

np.random.rand(3)

输入：

array([0.6432591 , 0.78715203, 0.81071309])

输出：

np.random.rand(2, 3)

输入：

array([[0.91757316, 0.74438045, 0.85259742],
       [0.19826903, 0.84990728, 0.48328816]])

它不肯定是从 0 到 1 的数字。咱们能够生成随机整数。

输出：

np.random.randint(25)

输入：

它产生了一个 0 到 25 范畴内的随机数。咱们能够指定要生成多少个数字。

输出：

np.random.randint(1, 100, 10)

输入：

array([96, 44, 90, 13, 47, 16,  9, 46, 49, 20])

在这里，咱们要求 Numpy 生成 10 个介于 1 到 100 之间的数字。

当初，生成 1 到 100 范畴内的 3 ×3 矩阵。

输出：

np.random.randint(1, 100, (3,3))

输入：

array([[25, 80, 42],
       [95, 82, 66],
       [64, 95, 55]])

你能够提供一个数组，并要求 Numpy 应用你提供的数组中的数字生成一个 3 ×3 矩阵，而不是一个范畴。

输出：

np.random.choice([1,2,3,4,5,6,7,8,9,10], size=(3,3))

输入：

array([[7,  9,  2],
       [6,  4,  6],
       [3, 10,  6]])

另一个有用的函数是“shuffle”。让咱们做一个新的数组并进行 shuffle。

输出：

a = np.array([3,6,3,1,0, 11])
np.random.shuffle(a)
a

输入：

array([3,  0,  6,  3, 11,  1])

听着，咱们有雷同的元素，只是在 shuffle 后重新排列。

咱们能够将数组“arr”保留在一个文件中。

输出：

np.save('arrfile', arr)

这里，咱们正在生成一个名为“arrfile”的文件来保留数组“arr”。文件将以“.npy”扩展名保留。

咱们能够加载该文件并将其带回来持续应用该数组，

输出：

np.load('arrfile.npy')

输入：

array([[1,  2,  3,  4],
       [5,  6,  7,  8],
       [9, 10, 11, 12]])

咱们能够应用 Numpy 作为数组导入 CSV 文件或文本文件。我在 Jupyter Notebook 雷同的文件夹中有一个名为 ’Cartwheeldata.csv“，我编写了这些示例。当初，在这里导入该文件。

输出：

filedata = np.genfromtxt('Cartwheeldata.csv', delimiter=',')
filedata=filedata.astype('int32')
filedata

输入：

我在这里展现数组的一部分。因为文件很大。所以，这是对于那个文件的局部信息。

这些类型的数组在机器学习中十分有用。

这就是我想在本文中分享的所有 Numpy 函数。Numpy 是个大库。它有很多可用的办法。然而这些函数应该足够适宜日常应用。

原文链接：https://towardsdatascience.co…

欢送关注磐创 AI 博客站：
http://panchuang.net/

sklearn 机器学习中文官网文档：
http://sklearn123.com/

欢送关注磐创博客资源汇总站：
http://docs.panchuang.net/

关于人工智能:Numpy的终极备忘录

什么是 Numpy

Numpy 数组基础知识

查找数组的长度：

反复

数学运算

统计

初始化不同类型的数组

重新排列或从新组织数组

索引或切片

增加行或列

连贯

追加、插入、删除和排序

随机

保留、加载和导入文件

论断