NumPy 最详细教程（1）：NumPy 数组 - 好文

文章目录

* Numpy 数组：ndarray
<https://blog.csdn.net/guliang21/article/details/88566158#Numpy_ndarray_3>
* NumPy 数组属性
<https://blog.csdn.net/guliang21/article/details/88566158#NumPy__132>
* 1、ndarray.shape
<https://blog.csdn.net/guliang21/article/details/88566158#1ndarrayshape_148>
* 2、ndarray.ndim
<https://blog.csdn.net/guliang21/article/details/88566158#2ndarrayndim_194>
* 3、ndarray.flags
<https://blog.csdn.net/guliang21/article/details/88566158#3ndarrayflags_214>
* 4、ndarray.real
<https://blog.csdn.net/guliang21/article/details/88566158#4ndarrayreal_243>
* NumPy 中的常数
<https://blog.csdn.net/guliang21/article/details/88566158#NumPy__259>
* NumPy 创建数组
<https://blog.csdn.net/guliang21/article/details/88566158#NumPy__298>
* 1、numpy.empty
<https://blog.csdn.net/guliang21/article/details/88566158#1numpyempty_300>
* 2、numpy.zeros
<https://blog.csdn.net/guliang21/article/details/88566158#2numpyzeros_326>
* 3、numpy.ones
<https://blog.csdn.net/guliang21/article/details/88566158#3numpyones_344>
* 4、numpy.full
<https://blog.csdn.net/guliang21/article/details/88566158#4numpyfull_361>
* NumPy 从数值范围创建数组
<https://blog.csdn.net/guliang21/article/details/88566158#NumPy__387>
* 1、numpy.arange
<https://blog.csdn.net/guliang21/article/details/88566158#1numpyarange_388>
* 2、numpy.linspace
<https://blog.csdn.net/guliang21/article/details/88566158#2numpylinspace_417>
* 3、numpy.logspace
<https://blog.csdn.net/guliang21/article/details/88566158#3numpylogspace_475>
* 4、numpy.geomspace
<https://blog.csdn.net/guliang21/article/details/88566158#4numpygeomspace_503>
* NumPy 从已有的数组创建数组
<https://blog.csdn.net/guliang21/article/details/88566158#NumPy__529>
* 1、numpy.asarray
<https://blog.csdn.net/guliang21/article/details/88566158#1numpyasarray_530>
* 2、numpy.frombuffer
<https://blog.csdn.net/guliang21/article/details/88566158#2numpyfrombuffer_554>
* 3、numpy.fromiter
<https://blog.csdn.net/guliang21/article/details/88566158#3numpyfromiter_624>
* 4、empty_like
<https://blog.csdn.net/guliang21/article/details/88566158#4empty_like_664>
* 5、zeros_like
<https://blog.csdn.net/guliang21/article/details/88566158#5zeros_like_689>
* 6、ones_like
<https://blog.csdn.net/guliang21/article/details/88566158#6ones_like_708>
* 7、numpy.full_like
<https://blog.csdn.net/guliang21/article/details/88566158#7numpyfull_like_727>
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)
参数描述
object 任何暴露数组接口方法的对象
dtype 数据类型
copy 如果为 True，则 object 对象被复制，否则，只有当__array__返回副本，object
是嵌套序列，或者需要副本来满足任何其他要求（dtype，order等）时，才会生成副本。
order 指定阵列的内存布局。如果 object 不是数组，则新创建的数组将按行排列（C），如果指定了（F），则按列排列。如果 object
是一个数组，则以下成立。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）
subok 默认情况下，返回的数组被强制为基类数组。如果为 True，则返回子类。
ndmin 返回数组的最小维数
例一：最简单的示例
import numpy as np a = [1, 2, 3] b = np.array(a) print(b) print(type(b))
输出：
[1 2 3] <class 'numpy.ndarray'>
注意：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.] float64 <class 'numpy.float64'>
例三：copy 参数的用法
import numpy as np a = np.array([1, 2, 3]) b = np.array(a, copy=True) a[0] = 0
print(a) print(b)
输出：
[0 2 3] [1 2 3]
可以看到 a 和 b 的值不同，说明 b 是 a 的副本，两个是不同的对象。
import numpy as np a = np.array([1, 2, 3]) b = np.array(a, copy=False) a[0] = 0
print(a) print(b)
输出：
[0 2 3] [0 2 3]
a 改变同时引起了 b 的改变，说明 a 和 b 指向的是同一个对象。

例四：ndmin 参数用法示例
import numpy as np a = [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))
输出：
<class 'numpy.matrix'> [[1 2 7] [3 4 8] [5 6 9]] <class 'numpy.matrix'> <class
'numpy.ndarray'>
<>NumPy 数组属性

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

属性说明
ndarray.ndim 秩，即轴的数量或维度的数量
ndarray.shape 数组的维度，对于矩阵，n 行 m 列
ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype ndarray 对象的元素类型
ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags ndarray 对象的内存信息
ndarray.real ndarray 元素的实部（复数的实部）
ndarray.imag ndarray 元素的虚部（复数的虚部）
ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
<>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 np a = np.arange(24) print(a.ndim) # 现在调整其大小 b = a.reshape(2, 4
, 3) print(b.ndim)
输出：
1 3
<>3、ndarray.flags

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

属性描述
C_CONTIGUOUS 数据是在一个单一的C风格的连续段中
F_CONTIGUOUS 数据是在一个单一的Fortran风格的连续段中
OWNDATA 数组拥有它所使用的内存或从另一个对象中借用它
WRITEABLE 数据区域可以被写入，将该值设置为 False，则数据为只读
ALIGNED 数据和所有元素都适当地对齐到硬件上
WRITEBACKIFCOPY UPDATEIFCOPY 已弃用，由 WRITEBACKIFCOPY 取代;
UPDATEIFCOPY 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 import numpy as np a = np.
array([[1, 2, 3], [4, 5, 6]]) print(a.flags)
输出：
C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : True
ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False
<>4、ndarray.real
import numpy as np x = 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] float64
<>NumPy 中的常数

* 正无穷：Inf = inf = infty = Infinity = PINF
* 负无穷：NINF
* 正零：PZERO
* 负零：NZERO
* 非数值：nan = NaN = NAN
* 自然数e：e
* π：pi
* 伽马：euler_gamma
* None 的别名：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 -inf 0.0 -0.0 nan 2.718281828459045 3.141592653589793 0.5772156649015329
None
<>NumPy 创建数组

<>1、numpy.empty

此方法用来创建一个指定维度（shape）、数据类型（dtype）的未初始化的数组。
numpy.empty(shape, dtype=float, order='C')
参数描述
shape 一个表示数组维度的元组
dtype 数据类型
order 有 “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 np x = 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 np x = np.ones(5) print(x)
输出：
[1. 1. 1. 1. 1.]
<>4、numpy.full

返回给定维度和类型的新数组，填充 fill_value。
numpy.full(shape, fill_value, dtype=None, order='C')
参数描述
shape 返回数组的维度
fill_value 填充值
dtype 返回数组的数据类型，默认值 None 指：np.array(fill_value).dtype
order 在计算机内存中的存储元素的顺序，只支持 ‘C’（按行）、‘F’（按列），默认 ‘C’
示例：
import numpy as np a = 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)
[ ] 括起来的表示可选参数。

参数描述
start 起始值，默认为 0
stop 终止值（不包含）
step 步长，默认为1
dtype 创建的 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型。
示例：
import numpy as np a = 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)
参数描述
start 序列的起始值
stop 序列的终止值，如果 endpoint 为 True，则该值包含于数列中
num 要生成的等步长的样本数量，默认为 50
endpoint 该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。
retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype 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)
参数描述
start 序列的起始值为：base ** start （幂运算）
stop 序列的终止值为：base ** stop。如果 endpoint 为 True，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。
base 对数 log 的底数。
dtype 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)
参数描述
start 序列的起始值
stop 序列的终止值，如果 endpoint 为 True，该值包含于数列中
num 要生成的样本数量，默认为 50
endpoint 该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。
dtype ndarray 的数据类型
axis 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)
参数描述
a 输入数据，可以转换为数组的任何形式。这包括列表，元组列表，元组，元组元组，列表元组和 ndarray。
dtype 数据类型
order 在计算机内存中的存储元素的顺序，只支持 ‘C’（按行）、‘F’（按列），默认 ‘C’
示例：
import numpy as np a = 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)
参数描述
buffer 实现了 __buffer__ 方法的对象，（绝对不是菜鸟教程上说的任意对象都可以）
dtype 返回数组的数据类型
count 读取的数据数量，默认为 -1，读取所有数据。
offset 读取的起始位置，默认为 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 np import array a = array.array('i', [1, 2, 3, 4]) print(a) na
= np.frombuffer(a, dtype=np.int_) print(na) a[0] = 10 print(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 np import 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] [140896288 381 3 4]
<>3、numpy.fromiter

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
numpy.fromiter(iterable, dtype, count=-1)
参数描述
iterable 可迭代对象
dtype 返回数组的数据类型
count 读取的数据数量，默认为 -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)
输出：
<generator object <genexpr> at 0x000000001442DD00>
<>4、empty_like

返回一个与给定数组具有相同维度和类型的未初始化的新数组。
numpy.empty_like(prototype, dtype=None, order='K', subok=True)
参数描述
prototype 给定的数组
dtype 覆盖结果的数据类型，版本1.6.0中的新功能。
order 指定阵列的内存布局。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）
subok 默认情况下，返回的数组被强制为基类数组。如果为 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)
参数描述
a 给定的数组
fill_value 填充值
dtype 返回数组的数据类型，默认值 None，则使用给定数组的类型
order 指定阵列的内存布局。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）
subok 默认情况下，返回的数组被强制为基类数组。如果为 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]
欢迎扫码关注我的个人公众号：大龄码农的Python之路

热门工具换一换