目录
NumPy 是 Python 中用于科学计算的基本包。它是一个 Python 库,提供了一个多维数组对象、各种派生对象(比如屏蔽数组和矩阵) ,以及一系列用于数组快速操作的例程,包括数学、逻辑、形状操作、排序、选择、 i/o、离散傅里叶变换、基本线性代数、基本统计操作、随机模拟等等。
官网文档地址:NumPy -
单纯学习 Numpy 会比较闷,因为 Numpy 是用于科学计算的。只是学习了各种 API 的使用,会很苦闷学来干啥,跟人工智能有什么关系?
安装 numpy 比较简单,直接使用命令安装即可:
pip install numpy
测试是否正常:
import numpy as np
print(np.__version__)
基础使用
基本数据类型
下表列举了常用 NumPy 基本类型。
名称 | 描述 |
---|---|
bool_ | 布尔型数据类型(True 或者 False) |
int_ | 默认的整数类型(类似于 C 语言中的 long,int32 或 int64) |
intc | 与 C 的 int 类型一样,一般是 int32 或 int 64 |
intp | 用于索引的整数类型(类似于 C 的 ssize_t,一般情况下仍然是 int32 或 int64) |
int8 | 字节(-128 to 127) |
int16 | 整数(-32768 to 32767) |
int32 | 整数(-2147483648 to 2147483647) |
int64 | 整数(-9223372036854775808 to 9223372036854775807) |
uint8 | 无符号整数(0 to 255) |
uint16 | 无符号整数(0 to 65535) |
uint32 | 无符号整数(0 to 4294967295) |
uint64 | 无符号整数(0 to 18446744073709551615) |
float_ | float64 类型的简写 |
float16 | 半精度浮点数,包括:1 个符号位,5 个指数位,10 个尾数位 |
float32 | 单精度浮点数,包括:1 个符号位,8 个指数位,23 个尾数位 |
float64 | 双精度浮点数,包括:1 个符号位,11 个指数位,52 个尾数位 |
complex_ | complex128 类型的简写,即 128 位复数 |
complex64 | 复数,表示双 32 位浮点数(实数部分和虚数部分) |
complex128 | 复数,表示双 64 位浮点数(实数部分和虚数部分) |
每个内建类型都有一个唯一定义它的字符代码,如下:
字符 | 对应类型 |
---|---|
b | 布尔型 |
i | (有符号) 整型 |
u | 无符号整型 integer |
f | 浮点型 |
c | 复数浮点型 |
m | timedelta(时间间隔) |
M | datetime(日期时间) |
O | (Python) 对象 |
S, a | (byte-)字符串 |
U | Unicode |
V | 原始数据 (void) |
numpy 有个 dtype 函数,用于定义变量类型,其定义如下:
class numpy.dtype(dtype, align=False, copy=False[, metadata])
比如这段代码定义了一个numpy 中 int32 类型的变量:
import numpy as np
a = np.dtype(dtype="int32")
print(a)
也可以使用短代码:
import numpy as np
a = np.dtype("i")
print(a)
等效代码:
import numpy as np
a = np.dtype(np.int32)
print(a)
运行代码后,都会打印:
int32
这个类型是 numpy 中的类型,不是 Python 中的类型,要注意区分。numpy 的数值类型实际上是 dtype 对象的实例,并对应唯一的字符,包括 np.bool_,np.int32,np.float32,等等。
因为 Python 是弱类型,没有 int32 a = ...
这种语法,所以为了明确定义这个变量是何种类型,需要使用类型的字符串名称。
这句话现在可以先不管,后面会在很多地方使用 dtype,用熟了就知道了。
要注意的是 np.dtype
是创建一个类型标识,本身并没有存储变量值。
示例:
import numpy as np
def test(object, dtype):
if dtype == np.int32:
print(f"{object} int32")
elif dtype == np.int64:
print(f"{object} int64")
elif dtype == np.str_:
print(f"{object} str_")
a = 111
b = np.dtype(dtype="int32")
test(a, b)
c = '111'
d = np.dtype(dtype="str")
test(c, d)
创建基本数组
Numpy 提供了一个多维数组对象、各种派生对象(比如屏蔽数组和矩阵)
,numpy 中最重要的对象是数组和矩阵。所以要学会 numpy ,最基本的是学会 numpy 数组。
numpy 创建数组的定义:
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明:
名称 | 描述 |
---|---|
object | 数组或嵌套的数列 |
dtype | 数组元素的数据类型,可选 |
copy | 对象是否需要复制,可选 |
order | 创建数组的样式,C为行方向,F为列方向,A为任意方向(默认) |
subok | 默认返回一个与基类类型一致的数组 |
ndmin | 指定生成数组的最小维度 |
创建一个基本数组:
import numpy as np
a = np.array([1, 2, 3])
创建多维数组
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
定义一个数组,然后生成多维数组:
import numpy as np
a = np.array([1, 2, 3, 4, 5], ndmin = 2)
# 相当于 np.array([[1, 2, 3, 4, 5]])
print (a)
b = np.array([1, 2, 3, 4, 5], ndmin = 3)
# 相当于 np.array([[[1, 2, 3, 4, 5]]])
print (b)
c = np.array([[1, 2, 3, 4, 5],[1, 2, 3, 4, 5]], ndmin = 3)
# 相当于 np.array([[[1, 2, 3, 4, 5],[1, 2, 3, 4, 5]]])
print (c)
数组属性
由于 Python 是弱类型,所以想学习和了解细节的时候,会比较懵逼。因此,我们尽量在编写 Python 代码时,获取代码的一些文档注释。
如下面代码中,定义了一个数组:
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
numpy 的数组,其类型为 ndarray[Any, dtype]
,完整文档如下:
a: ndarray[Any, dtype] = np.array([[1, 2], [3, 4]])
所以,要掌握 numpy 数组,实际上就是在了解 ndarray
。
ndarray 中比较重要的属性如下:
属性 | 说明 |
---|---|
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 | 包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。 |
回到之前提到过的 numpy.dtype
,结合 numpy.array
,其示例代码如下:
import numpy
import numpy as np
a = np.array([1, 2])
print(a.dtype)
print(a)
t = np.dtype(numpy.float64)
b = np.array(object=[1, 2], dtype=t)
print(b.dtype)
print(b)
如果我们不配置 dtype
参数,那么数组的 dtype 会以数组元素类型为依据。如果配置了 dtype,那么数组元素都会被转换为对应的类型,如 np.array(object=[1, 2], dtype='float64')
。
数组生成
zeros、ones、empty 数组生成
numpy.zeros
numpy.zeros
的作用是创建一个元素全部为 0 的数组。
其定义如下:
def zeros(shape, dtype=float, order='C', *, like=None, /)
参数 | 描述 |
---|---|
shape | 数组形状 |
dtype | 数据类型,可选 |
order | 有"C"和"F"两个选项,分别代表,行优先和列优先,在计算机内存中的存储元素的顺序。 |
创建一个全部由 0 填充的数组:
import numpy as np
# 长度为 2
a = np.zeros(2)
print(a)
np.zeros()
默认创建的数组是 float64 类型,如果需要自定义类型,可以使用 dtype:
import numpy as np
# 长度为 2
a = np.zeros(2,dtype=int)
print(a)
numpy.ones
ones
创建一个元素值均为 1 的数组。
其定义如下:
def ones(shape, dtype=None, order='C', *, like=None)
示例如下:
import numpy as np
# 长度为 2
a = np.ones(2,dtype=int)
print(a)
由于其 API 与 numpy.zeros
一致,因此不再赘述。
numpy.empty
创建一个指定长度的空数组,但是不会对内存区域进行初始化,所以其被分配的内存区域可能已经有值。
其定义如下:
def empty(shape, dtype=None, order='C', *args, **kwargs)
示例:
import numpy as np
# 长度为 2
a = np.empty(2)
print(a)
由于其没有初始化内存,因此内存区域会残留数据。
其它说明
此外,还有三个对应的原型复制函数:
def empty_like(prototype, dtype=None, order=None, subok=None, shape=None
def zeros_like(prototype, dtype=None, order='K', subok=True, shape=None)
def ones_like(prototype, dtype=None, order='K', subok=True, shape=None)
它们的作用是根据数组类型,拷贝一个相同的结构,然后填充对应值。
如下示例,复制数组相同的结构,但是填充的值为 0。
import numpy as np
a = np.array([[1],[1]])
b = np.zeros_like(a)
print(b)
此外,这三个函数,可以传递元组,生成多维的数组(矩阵)。
import numpy
import numpy as np
a = np.zeros(shape=(2, 3, 4), dtype=numpy.double)
print(a)
numpy.random
numpy.random
是一个类,不是一个函数,numpy.random
中有一些随机生成数组的函数。
以下是一些常用的 API:
#生成具有给定形状的均匀分布的随机样本,范围在[0, 1)之间。
numpy.random.rand(size)
# 生成具有给定形状的标准正态分布(平均值为0,方差为1)的随机样本。随机样本取值范围是[0,1)。
numpy.random.randn(size)
# 正态分布,指定均值和方差
numpy.random.normal(loc=0.0, scale=1.0, size=None)
# 随机生成
numpy.random.random(size=None)
# 从给定的上下限范围内生成随机整数。
numpy.random.randint(low, high=None, size=None, dtype=int)
# 从给定的一维数组中生成随机样本。
numpy.random.choice(a, size=None, replace=True, p=None)
# 随机打乱给定数组的顺序。
numpy.random.shuffle(x)
随机数值生成和正态分布生成示例如下:
import numpy as np
a = np.random.rand(10)
b = np.random.rand(10)
print(a)
print(b)
[0.39809428 0.83922059 0.10808865 0.00332159 0.75922001 0.26850704
0.04497839 0.59012908 0.0438718 0.59988563]
[0.78161896 0.91401858 0.10980276 0.89723959 0.06802148 0.18993732
0.10664519 0.14121531 0.27353601 0.56878734]
x1 = np.random.randint(10, size=6) # 一维数组
x2 = np.random.randint(10, size=(3, 4)) # 二维数组
x3 = np.random.randint(10, size=(3, 4, 5)) # 三维数组
对于其它 API,由于篇幅有限,不再赘述。
numpy.arange
numpy.arange
用于有规律地生成数组。
其定义如下:
numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)
参数 | 描述 |
---|---|
start | 起始值,默认为0 |
stop | 终止值(不包含) |
step | 步长,默认为1 |
dtype | 返回ndarray 的数据类型,如果没有提供,则会使用输入数据的类型。 |
numpy.arange
默认从 0 开始生成数组,间隔为 1。
比如,下面代码会生成一个元素值不超过 4 的数组,即范围是 [0,4)
。
import numpy as np
# 长度为 4
a = np.arange(4)
print(a)
arange(start, stop)
指定开始结束范围,但是依然步长为 1。
import numpy as np
# 长度为 4
a = np.arange(1,4)
print(a)
arange(start, stop, step)
自定义设置范围和步长。
import numpy as np
# 长度为 4
a = np.arange(1,10,3)
print(a)
numpy.linspace
numpy.linspace
可以使用线性间隔的方式生成数组:
np.linspace(0, 10, num=5)
num=5
的含义是从来的之间平均取得 5 个数值。
[ 0.
2.5
5.
7.5
10. ]
但是跟我们预料的结果可能不太一样,因为 linspace()
是包括起始点的,所以 0-10
其实个数是 11 个。
import numpy as np
# 长度为 4
a = np.linspace(0, 10, num=10)
print(a)
import numpy as np
# 长度为 4
a = np.linspace(0, 10, num=11)
print(a)
数组操作
数组排序
排序会返回数组的副本。
主要排序函数如下:
sort :按照大小排序
argsort:它是沿指定轴的间接排序,
lexsort:它是对多个键的间接稳定排序,
searchsorted, 它将查找排序数组中的元素。
partition, 分区,这是一个部分排序。
对于 numpy 的数组,请使用 numpy 的函数排序,不要使用 Python 自带的函数排序。
import numpy as np
# 长度为 4
a = np.random.rand(10)
print(a)
# 使用 Python 内置函数
print(sorted(a))
# 使用 numpy.sort
print(np.sort(a))
如上图所示,使用 Python 自带的函数,会导致精确度出现问题。
切片索引
可以使用 slice(start,stop,step)
函数或 [start:stop:step]
进行切片。
import numpy as np
a = np.arange(10)
print(a)
# 索引范围是 2-7 ,间隔为2
# [0 1 2 3 4 5 6 7 8 9]
s1 = slice(2, 7, 2)
# 索引范围是 2-8 ,间隔为2
# [0 1 2 3 4 5 6 7 8 9]
s2 = slice(2, 8, 2)
print(a[s1])
print(a[s2])
等同于:
import numpy as np
a = np.arange(10)
print(a)
print(a[2:7:2])
print(a[2:8:2])
对于二维数组,可以通过坐标点取值。
import numpy as np
x = np.array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
# 左上角、右上角、左下角、右下角 四个点
a1 = np.array([[0, 0], [3, 3]])
a2 = np.array([[0, 2], [0, 2]])
y = x[a1, a2]
print(y)
[[ 0 2]
[ 9 11]]
取值时,跟一维数组一致,可以通过索引取值。
import numpy as np
x = np.array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
y = x[1:2]
print(y)
数组还可以通过表达式取值,如 x>5
、x<5
等。
import numpy as np
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
print(x)
print(x[x > 5])
详细的表达式操作方法,可以查阅官网文档,这里不再赘述。
数组运算符
numpy 数组,可以通过操作符直接操作。
如两个数组的值相加:
import numpy as np
a1 = np.array([1, 2, 3])
a2 = np.array([4, 5, 6])
a3 = a1 + a2
a4 = a1 * a2
print(a3)
print(a4)
得到:
[5 7 9]
[ 4 10 18]
广播规则
对于不同形状的数组(即维数不同),numpy 可以自动补全维数。
其规则约束如下:
-
两个数组的形状相同
-
维数比较少的数组,需要是一维数组。
import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
b = np.array([100, 100, 100])
print(a + b)
[ [
[1, 2, 3] + [100, 100, 100]
[4, 5, 6] + [100, 100, 100]
[7, 8, 9] + [100, 100, 100]
] ]
相加后:
[
[101 102 103]
[104 105 106]
[107 108 109]
]
但是要注意,如果两个数组的一个维中,元素个数不一致,则运算会报错。
import numpy as np
a1 = np.array([1, 2, 3])
a2 = np.array([4, 5, 6, 7])
a3 = a1 + a2
print(a3)
如果两个数组维度一致,但是形状不一样,维数少的数组必须是一维数组。
如下面代码会报错:
import numpy as np
a = np.array([[1, 2, 3],
[1, 1, 1],
[1, 1, 1]])
b = np.array([[1, 1, 1],
[2, 2, 2]])
print(a + b)
修改数组
Numpy 中包含了一些函数用于处理数组,大概可分为以下几类:
- 修改数组形状
- 翻转数组
- 修改数组维度
- 连接数组
- 分割数组
- 数组元素的添加与删除
修改数组的形状
主要有以下函数:
函数 | 描述 |
---|---|
reshape | 不改变数据的条件下修改形状 |
flat | 数组元素迭代器 |
flatten | 返回一份数组拷贝,对拷贝所做的修改不会影响原始数组 |
ravel | 返回展开数组 |
将一维数组,转换为二维数组,每个数组元素有 3 个,其示例如下:
import numpy as np
a = np.arange(6).reshape(2, 3)
b = np.array([0,1,2,3,4,5]).reshape(2, 3)
print(a)
print(b)
[[0 1 2]
[3 4 5]]
[[0 1 2]
其它几个函数可以使用以下示例表达:
import numpy as np
a = np.arange(10)
print(a)
# 数组迭代器 .flat
for element in a.flat:
print(element)
# 将数组转换为二维数组
b = a.reshape(2,5)
print("将数组转换为二维:")
print(b)
print("将多维数组合并为一维:")
c = b.ravel()
print(c)
[0 1 2 3 4 5 6 7 8 9]
0
1
2
3
4
5
6
7
8
9
将数组转换为二维:
[[0 1 2 3 4]
[5 6 7 8 9]]
将多维数组合并为一维:
[0 1 2 3 4 5 6 7 8 9]
翻转数组
其常用函数定义如下:
函数 | 描述 |
---|---|
transpose | 对换数组的维度 |
ndarray.T | 和 self.transpose() 相同 |
rollaxis | 向后滚动指定的轴 |
swapaxes | 对换数组的两个轴 |
transpose
、ndarray.T
都可以将数组翻转,例如将 2x5
的数组翻转为 5x2
。
import numpy
import numpy as np
a = np.arange(10).reshape(2,5)
print(a)
b = numpy.transpose(a)
c = a.T
print(b)
print(c)
[[0 1 2 3 4]
[5 6 7 8 9]]
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]
rollaxis
、swapaxes
都有三个参数:
arr:数组
axis:要向后滚动的轴,其它轴的相对位置不会改变。取值范围为 [0, a.ndim]
start:默认为零,表示完整的滚动。会滚动到特定位置。取值范围为 [-a.ndim, a.ndim]
注意:二维只有 0
、1
两个轴,三维有 0
、1
、2
三个轴。axis、start 都是填写轴的序号。
使用 print(a1.ndim)
可以打印数组的维数,即轴数。
swapaxes
用于指定交互两个轴的位置。
如:
import numpy
import numpy as np
a1 = np.array([
[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]
])
b = np.swapaxes(a1, 0, 1)
print(b)
原数组:
[[0, 0, 0, 0]
[1, 1, 1, 1]
[2, 2, 2, 2]
[3, 3, 3, 3]]
变换后的数组:
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
也可以理解成坐标系的 x 轴 和 y 轴,x 轴变成了 y 轴。
swapaxes
在更多维数组的情况下,有更多的轴,例如三维的 x、y、z 三个轴。这里不再赘述。
至于 numpy.rollaxis
,我也不会。
修改数组维度
其主要函数如下:
维度 | 描述 |
---|---|
broadcast | 产生模仿广播的对象 |
broadcast_to | 将数组广播到新形状 |
expand_dims | 扩展数组的形状 |
squeeze | 从数组的形状中删除一维条目 |
连接数组
其主要函数如下:
函数 | 描述 |
---|---|
concatenate | 连接沿现有轴的数组序列 |
stack | 沿着新的轴加入一系列数组。 |
hstack | 水平堆叠序列中的数组(列方向) |
vstack | 竖直堆叠序列中的数组(行方向) |
numpy.concatenate
将两个数组拼接成一个新的数组:
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
c = np.concatenate((a, b))
print(c)
分割数组
其主要函数如下:
函数 | 数组及操作 |
---|---|
split | 将一个数组分割为多个子数组 |
hsplit | 将一个数组水平分割为多个子数组(按列) |
vsplit | 将一个数组垂直分割为多个子数组(按行) |
其使用方法比较简单,这里不再赘述。
增删数组元素
其主要函数如下:
函数 | 元素及描述 |
---|---|
resize | 返回指定形状的新数组 |
append | 将值添加到数组末尾 |
insert | 沿指定轴将值插入到指定下标之前 |
delete | 删掉某个轴的子数组,并返回删除后的新数组 |
unique | 查找数组内的唯一元素 |
其使用方法比较简单,这里不再赘述。
数组迭代
前面提到过 .flat
。
import numpy as np
# 这里是二维
a = np.arange(10).reshape(2,5)
# 数组迭代器 .flat
for element in a.flat:
print(element)
.flat
会按照顺序打印每一个元素。
0
1
2
3
4
5
6
7
8
9
.nditer
也是如此。
import numpy as np
a = np.arange(10).reshape(2,5)
# 数组迭代器 .flat
for element in np.nditer(a):
print(element)
.nditer
可以控制遍历规则。
for x in np.nditer(a.T, order='C')
,默认,行遍历。
for x in np.nditer(a, order='F')
,列遍历。
import numpy as np
a = np.arange(10).reshape(2, 5)
# 数组迭代器 .flat
for element in np.nditer(a, order='F'):
print(element)
0
5
1
6
2
7
3
8
4
9
.nditer
可以控制迭代多维数组的维还是元素。
前面提到的代码,均是迭代逐个元素。
如果设置了 flags
参数,则可以迭代维。
import numpy as np
a = np.arange(10).reshape(2, 5)
# 数组迭代器 .flat
for element in np.nditer(a, order='F', flags=['external_loop']):
print(element)
原数组:
[[0 1 2 3 4]
[5 6 7 8 9]]
按照迭代方向 F:
[0 5]
[1 6]
[2 7]
[3 8]
[4 9]