【Python库】NumPy超详细教程（1）：NumPy数组

系列⽂章地址

⽂章⽬录

Numpy 是 Python 中科学计算的核⼼库，NumPy 这个词来源于 Numerical 和 Python 两个单词。它提供了⼀个⾼性能的数组对象，以及⼤量的库函数和操作，可以帮助程序员轻松地进⾏数值计算，⼴泛应⽤于机器学习模型、图像处理和计算机图形学、数学任务等领域。

Numpy 数组：ndarray

NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型，它是描述相同类型的元素集合。ndarray 中的每个元素都是数据类型对象(dtype)的对象。ndarray 中的每个元素在内存中使⽤相同⼤⼩的块。

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

参数objectdtype

描述

任何暴露数组接⼝⽅法的对象数据类型

如果为 True，则 object 对象被复制，否则，只有当__array__返回副本，object 是嵌套序列，或者需要副本来满⾜任何其他要求（dtype，order等）时，才会⽣成副本。

指定阵列的内存布局。 如果 object 不是数组，则新创建的数组将按⾏排列（C），如果指定了（F），则按列排列。 如果 object 是⼀个数组，则以下成⽴。C（按⾏）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回⼦类。返回数组的最⼩维数

copy

order

subokndmin

例⼀：最简单的⽰例

import numpy as npa = [1, 2, 3]b = np.array(a)print(b)

print(type(b))

输出：

[1 2 3]

注意：list 打印显⽰是 [1, 2, 3]，⽽ ndarray 打印显⽰是 [1 2 3]，当中没有逗号。

例⼆：dtype 参数⽤法⽰例NumPy ⽀持⽐ Python 更多种类的数值类型

import numpy as np

a = [1, 2, 3]

b = np.array(a, dtype=np.float_)# 或者

b = np.array(a, dtype=float)print(b)

print(b.dtype)print(type(b[0]))

输出：

[1. 2. 3.]float

例三：copy 参数的⽤法

import numpy as npa = np.array([1, 2, 3])

b = np.array(a, copy=True)a[0] = 0print(a)print(b)

输出：

[0 2 3][1 2 3]

可以看到 a 和 b 的值不同，说明 b 是 a 的副本，两个是不同的对象。

import numpy as npa = np.array([1, 2, 3])

b = np.array(a, copy=False)a[0] = 0print(a)print(b)

输出：

[0 2 3][0 2 3]

a 改变同时引起了 b 的改变，说明 a 和 b 指向的是同⼀个对象。例四：ndmin 参数⽤法⽰例

import numpy as npa = [1, 2, 3]

b = np.array(a, ndmin=2)print(b)

输出：

[[1 2 3]]

可以看到结果已经变成了⼆维数组。

例五：subok 参数⽤法⽰例看解释不是很清楚，看下⾯这个例⼦就会明⽩许多。其中 matrix 是矩阵，将在之后的内容中介绍。

import numpy as np

a = np.matrix('1 2 7; 3 4 8; 5 6 9')print(type(a))print(a)

at = np.array(a, subok=True)af = np.array(a, subok=False)print(type(at))print(type(af))

输出：

[[1 2 7] [3 4 8] [5 6 9]]

NumPy 数组属性

NumPy 数组的维度（⼜称维数）称为秩（rank），⼀维数组的秩为 1，⼆维数组的秩为 2，以此类推。NumPy 中，每⼀个线性的数组称为是⼀个轴（axis），也就是维度（dimensions）。

属性

ndarray.ndimndarray.shapendarray.sizendarray.dtypendarray.itemsizendarray.flagsndarray.realndarray.imagndarray.data

说明

秩，即轴的数量或维度的数量数组的维度，对于矩阵，n ⾏ m 列

数组元素的总个数，相当于 .shape 中 n*m 的值ndarray 对象的元素类型

ndarray 对象中每个元素的⼤⼩，以字节为单位ndarray 对象的内存信息

ndarray 元素的实部（复数的实部）ndarray 元素的虚部（复数的虚部）

包含实际数组元素的缓冲区，由于⼀般通过数组的索引获取元素，所以通常不需要使⽤这个属性。

1、ndarray.shape

返回⼀个包含数组维度的元组，对于矩阵，n ⾏ m 列，它也可以⽤于调整数组维度。例⼀：

import numpy as np

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

输出：

(2, 3)

例⼆：

import numpy as np

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

输出：

[[1 2] [3 4] [5 6]]

例三：NumPy 也提供了reshape() 函数来调整数组维度。只是 reshape() 返回调整维度后的副本，⽽不改变原 ndarray。

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])b = a.reshape(3, 2)print(b) # a 没变

输出：

[[1 2] [3 4] [5 6]]

2、ndarray.ndim

返回数组的维度（秩）。例⼀：

import numpy as npa = np.arange(24)print(a.ndim)

# 现在调整其⼤⼩b = a.reshape(2, 4, 3)print(b.ndim)

输出：

13

3、ndarray.flags

ndarray.flags 返回 ndarray 对象的内存信息，包含以下属性：

属性

C_CONTIGUOUSF_CONTIGUOUSOWNDATAWRITEABLEALIGNED

WRITEBACKIFCOPYUPDATEIFCOPY

import numpy as np

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

描述

数据是在⼀个单⼀的C风格的连续段中数据是在⼀个单⼀的Fortran风格的连续段中数组拥有它所使⽤的内存或从另⼀个对象中借⽤它数据区域可以被写⼊，将该值设置为 False，则数据为只读数据和所有元素都适当地对齐到硬件上

UPDATEIFCOPY 已弃⽤，由 WRITEBACKIFCOPY 取代;

这个数组是其它数组的⼀个副本，当这个数组被释放时，原数组的内容将被更新

输出：

C_CONTIGUOUS : TrueF_CONTIGUOUS : FalseOWNDATA : TrueWRITEABLE : TrueALIGNED : True

WRITEBACKIFCOPY : FalseUPDATEIFCOPY : False

4、ndarray.real

import numpy as npx = np.sqrt([1+0j, 0+1j])print(x)print(x.real)

print(x.real.dtype)

输出：

[1. +0.j 0.70710678+0.70710678j][1. 0.70710678]float

NumPy 中的常数

正⽆穷：Inf = inf = infty = Infinity = PINF负⽆穷：NINF正零：PZERO负零：NZERO

⾮数值：nan = NaN = NAN⾃然数e：eπ：pi

伽马：euler_gammaNone 的别名：newaxis

⽰例：

print(np.inf)print(np.NINF)print(np.PZERO)print(np.NZERO)print(np.nan)print(np.e)print(np.pi)

print(np.euler_gamma)print(np.newaxis)

输出：

inf-inf0.0-0.0nan

2.7182818284590453.14159265357930.57721569015329None

NumPy 创建数组

1、numpy.empty

此⽅法⽤来创建⼀个指定维度（shape）、数据类型（dtype）的未初始化的数组。

numpy.empty(shape, dtype=float, order='C')

参数shapedtypeorder

描述

⼀个表⽰数组维度的元组数据类型

有 \"C\" 和 \"F\" 两个选项

⽰例：

import numpy as np

x = np.empty([3, 2], dtype=int)print(x)

输出：

[[ 0 1072693248] [ 0 1072693248] [ 0 1072693248]]

empty() ⽅法和 zeros() ⽅法不同，不会将数组值设置为零，因此可能会略微加快。另⼀⽅⾯，它要求⽤户⼿动设置数组中的所有值，并应谨慎使⽤。

2、numpy.zeros

创建指定维度，以 0 填充的新数组。

numpy.zeros(shape, dtype=float, order='C')

⽰例：

import numpy as npx = np.zeros(5)print(x)

输出：

[0. 0. 0. 0. 0.]

注意：默认是 float 类型的

3、numpy.ones

创建指定维度，以 1 填充的新数组。

numpy.ones(shape, dtype=float, order='C')

⽰例：

import numpy as npx = np.ones(5)print(x)

输出：

[1. 1. 1. 1. 1.]

4、numpy.full

返回给定维度和类型的新数组，填充 fill_value。

numpy.full(shape, fill_value, dtype=None, order='C')

参数shapefill_valuedtypeorder

描述

返回数组的维度填充值

返回数组的数据类型，默认值 None 指：np.array(fill_value).dtype

在计算机内存中的存储元素的顺序，只⽀持 'C'（按⾏）、'F'（按列），默认 'C'

⽰例：

import numpy as npa = np.full((2, 3), 9)print(a)

输出：

[[9 9 9] [9 9 9]]

NumPy 从数值范围创建数组

1、numpy.arange

该函数等效于 Python 内置 range 函数，但返回的是 ndarray ⽽不是列表。

arange([start,] stop[, step,], dtype=None)

[ ] 括起来的表⽰可选参数。

参数startstopstepdtype

描述

起始值，默认为 0终⽌值（不包含）步长，默认为1

创建的 ndarray 的数据类型，如果没有提供，则会使⽤输⼊数据的类型。

⽰例：

import numpy as npa = np.arange(5)

b = np.arange(10, 20, 2)print(a)print(b)

输出：

[0 1 2 3 4]

[10 12 14 16 18]

2、numpy.linspace

创建⼀个⼀维等差数列的数组，与 arange 函数不同，arange 是固定步长，⽽ linspace 则是固定元素数量。

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数startstopnumendpointretstepdtype

描述序列的起始值

序列的终⽌值，如果 endpoint 为 True，则该值包含于数列中要⽣成的等步长的样本数量，默认为 50

该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。如果为 True 时，⽣成的数组中会显⽰间距，反之不显⽰。ndarray 的数据类型

参数描述

例⼀：endpoint 参数的⽤法我特意挑了下⾯这个除不尽的例⼦来显⽰ endpoint 的效果。可以看到，endpoint=False 取值是endpoint=True，并且 num = num + 1 的结果去掉终⽌值。这话有点拗⼝啊，对⽐⼀下下例中的 num 参数值及输出结果就明⽩了。

import numpy as np

a = np.linspace(0, 5, 3, endpoint=False)b = np.linspace(0, 5, 4, endpoint=True)print(a)print(b)

输出：

[0. 1.66666667 3.33333333]

[0. 1.66666667 3.33333333 5. ]

例⼆：retstep 参数的⽤法返回⼀个元组，第⼀个元素是 numpy.ndarray，第⼆个元素是步长。

import numpy as np

a = np.linspace(0, 10, 5, retstep=True)print(a)

输出：

(array([ 0. , 2.5, 5. , 7.5, 10. ]), 2.5)

例三：dtype 参数dtype 参数指定后会将结果强制转换成 dtype 指定的类型，如果是 float 转 int，最终值就可能不是等差的了。

import numpy as np

a = np.linspace(0, 10, 5, dtype=int)print(a)

输出：

[ 0 2 5 7 10]

3、numpy.logspace

numpy.logspace 函数⽤于创建⼀个等⽐数列。

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数startstopnumendpointbasedtype

描述

序列的起始值为：base ** start （幂运算）

序列的终⽌值为：base ** stop。如果 endpoint 为 True，该值包含于数列中要⽣成的等步长的样本数量，默认为50

该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。对数 log 的底数。ndarray 的数据类型

⽰例：其实没啥好说的，主要是注意 start 参数的值并⾮是真正的起始值。

import numpy as np

a = np.logspace(1, 4, num=4)print(a)

输出：

[ 10. 100. 1000. 10000.]

4、numpy.geomspace

创建⼀个⼀维等⽐数列。

numpy.geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)

参数startstopnumendpointdtypeaxis

描述序列的起始值

序列的终⽌值，如果 endpoint 为 True，该值包含于数列中要⽣成的样本数量，默认为 50

该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。ndarray 的数据类型

1.16.0 版本中的新功能 ，没看懂怎么⽤，官⽹上连个例⼦都没有，值为 0 和 -1 的时候结果相同，其他时候都报错。

⽰例：

import numpy as np

a = np.geomspace(1, 8, num=4)print(a)

输出：

[1. 2. 4. 8.]

NumPy 从已有的数组创建数组

1、numpy.asarray

numpy.asarray 类似 numpy.array，但 numpy.asarray 的参数只有三个。

numpy.asarray(a, dtype=None, order=None)

参数描述

adtype

输⼊数据，可以转换为数组的任何形式。 这包括列表，元组列表，元组，元组元组，列表元组和 ndarray。数据类型

order参数在计算机内存中的存储元素的顺序，只⽀持 'C'（按⾏）、'F'（按列），默认 'C'描述

⽰例：

import numpy as npa = np.asarray([1, 2, 3])print(a)

输出：

[1 2 3]

2、numpy.frombuffer

numpy.frombuffer ⽤于实现动态数组。numpy.frombuffer 接受 buffer 输⼊参数，以流的形式读⼊转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)

参数bufferdtypecountoffset

描述

实现了 __buffer__ ⽅法的对象，（绝对不是菜鸟教程上说的任意对象都可以）返回数组的数据类型

读取的数据数量，默认为 -1，读取所有数据。读取的起始位置，默认为 0。

例⼀：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

import numpy as np

a = np.frombuffer(b'Hello World', dtype='S1')print(a)

输出：

[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

例⼆：看了上⾯的例⼦，似乎对“实现动态数组”没啥感觉，那么我们来看这个例⼦。

import numpy as npimport array

a = array.array('i', [1, 2, 3, 4])print(a)

na = np.frombuffer(a, dtype=np.int_)print(na)a[0] = 10print(a)print(na)

输出：

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

array('i', [10, 2, 3, 4])[10 2 3 4]

array.array 创建的数组对象内存是连续的（这⾥不能⽤ list，会报：AttributeError: 'list' object has no attribute

'buffer'），numpy.frombuffer 从 array.array 的内存中创建数组，从上例中可以看出，改变 array.array 的值，numpy.frombuffer的值也会跟着改变，由此可见。

例三：array.array 数组中的值改变是可以的，但是如果是添加值，那就不⾏了。

import numpy as npimport array

a = array.array(\"i\", [1, 2, 3, 4])na = np.frombuffer(a, dtype=int)print(na)a.append(5)print(na)

输出：

[1 2 3 4]

[1406288 381 3 4]

3、numpy.fromiter

numpy.fromiter ⽅法从可迭代对象中建⽴ ndarray 对象，返回⼀维数组。

numpy.fromiter(iterable, dtype, count=-1)

参数iterabledtypecount

描述可迭代对象

返回数组的数据类型

读取的数据数量，默认为 -1，读取所有数据

例⼀：

import numpy as np

iterable = (x * x for x in range(5))a = np.fromiter(iterable, int)print(a)

输出：

[ 0 1 4 9 16]

看起来有点像 numpy.array，array ⽅法需要传⼊的是⼀个 list，⽽ fromiter 可以传⼊可迭代对象。

例⼆：将上例换成 array 试试看。

import numpy as np

iterable = (x * x for x in range(5))a = np.array(iterable)print(a)

输出：

at 0x000000001442DD00>

4、empty_like

返回⼀个与给定数组具有相同维度和类型的未初始化的新数组。

numpy.empty_like(prototype, dtype=None, order='K', subok=True)

参数prototypedtypeordersubok

描述给定的数组

覆盖结果的数据类型，版本1.6.0中的新功能。

指定阵列的内存布局。C（按⾏）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回⼦类。

⽰例：

import numpy as np

a = np.empty_like([[1, 2, 3], [4, 5, 6]])print(a)

输出：*

[[870 0 0] [ 0 0 0]]

5、zeros_like

numpy.zeros_like(a, dtype=None, order='K', subok=True)

参数同上。⽰例：

import numpy as np

a = np.zeros_like([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])print(a)

输出：*

[[0. 0. 0.] [0. 0. 0.]]

6、ones_like

numpy.ones_like(a, dtype=None, order='K', subok=True)

参数同上。⽰例：

import numpy as np

a = np.ones_like([[1, 2, 3], [4, 5, 6]])print(a)

输出：*

[[1 1 1] [1 1 1]]

7、numpy.full_like

返回与给定数组具有相同维度和类型的并以 fill_value 填充的数组。

numpy.full_like(a, fill_value, dtype=None, order='K', subok=True)

参数afill_valuedtypeordersubok

描述给定的数组填充值

返回数组的数据类型，默认值 None，则使⽤给定数组的类型

指定阵列的内存布局。C（按⾏）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回⼦类。

zeros_like、ones_like 其实都是此⽅法的特例。⽰例：

import numpy as np

x = np.arange(6, dtype=int)print(x)

print('-------------------')a = np.full_like(x, 1)b = np.full_like(x, 0.1)

c = np.full_like(x, 0.1, dtype=np.double)print(a)print(b)print(c)

输出：

[0 1 2 3 4 5]-------------------[1 1 1 1 1 1][0 0 0 0 0 0]

[0.1 0.1 0.1 0.1 0.1 0.1]