Numpy的终极备忘录

时间 2020-12-04

标签 python 算法数组 app dom 机器学习 ide 函数学习大数据栏目 Python 繁體版

原文原文链接

做者|Rashida Nasrin Sucky
编译|VK
来源|Towards Data Sciencepython

Python是开源的。对于使用python的数据科学家来讲，Numpy这个库是必不可少的。其余一些基本的库，如Pandas，Scipy是创建在Numpy的基础上。因此我决定作一份备忘录。这里我包括了到目前为止使用的全部Numpy函数。我相信这些函数将足以让你在平常工做中做为数据科学家或数据分析员完成你的工做。算法

我将从很是基本的Numpy功能开始，慢慢地向更高级的功能移动。可是使用Numpy很容易。在这里你不会发现任何复杂的编码技巧。数组

什么是Numpy

在Numpy文档中，Numpy的定义以下：app

NumPy是Python中科学计算的基本包。它是一个Python库，它提供多维数组对象、各类派生对象(如掩码数组和矩阵)以及数组上快速操做的各类例程，包括数学、逻辑、形状处理、排序、选择、I/O、离散傅立叶变换、基本线性代数，基本的统计操做，随机模拟等等。dom

我天天都用这个库。若是是python用户，大多数数据科学家都会这么作。它快速，易于使用，理解，简单。我不想写太多关于它是如何和为何这么好的。由于在阅读本文的过程当中，你将亲眼看到这一点。机器学习

个人目标是记录Numpy天天使用的方法。ide

正如文章名所说，这是一本关于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.]])

这是一个5x5的矩阵，只有对角元素是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列。这是一个3x1矩阵。咱们也能够有一个1x3矩阵。

输入：

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”是一个4x2矩阵。让咱们再作一个2x4矩阵。

输入：

y.T

输出：

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

这种方法称为转置。当你在数组或矩阵上使用转置时，它只是改变了维数。2x3矩阵变为3x2，3x6矩阵变为6x3或1x3矩阵变为3x1。

索引或切片

索引和切片是一项很是常见的平常任务。咱们来举几个例子：

输入：

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.com/indexing-and-slicing-of-1d-2d-and-3d-arrays-in-numpy-e731afff0bbe

添加行或列

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])

如今检查一下，索引一、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范围内的3x3矩阵。

输入：

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

输出：

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

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

输入：

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.com/an-ultimate-cheat-sheet-for-numpy-bb1112b0488f

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

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

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