Python之NumPy详解

NumPy(Numerical Python) 是Python语言的一个数值计算扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy的前身Numeric最早是由Jim Hugunin与其它协作者共同开发，2005年，Travis Oliphant在Numeric中结合了另一个同性质的程序库Numarray的特色，并加入了其它扩展而开发了NumPy。NumPy为开放源代码并且由许多协作者共同维护开发。

NumPy是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象ndarray，对数组进行函数运算；
• 数值积分；
• 广播功能函数；
• 整合C/C++/Fortran代码的工具；
• 线性代数、傅里叶变换、随机数生成等功能。

NumPy通常与SciPy（Scientific Python）和Matplotlib（绘图库）一起使用， 这种组合广泛用于替代MatLab，是一个强大的科学计算环境，有助于我们通过Python学习数据科学或者机器学习。

SciPy是一个开源的Python算法库和数学工具包。SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

Matplotlib是Python编程语言及其数值数学扩展包NumPy的可视化操作界面。它为利用通用的图形用户界面工具包，如Tkinter, wxPython, Qt或GTK+向应用程序嵌入式绘图提供了应用程序接（API）。

标准的Python中用list（列表）保存值，可以当做数组使用，但因为列表中的元素可以是任何对象，所以浪费了CPU运算时间和内存。NumPy诞生为了弥补这些缺陷，它提供了两种基本的对象。

• ndarray：全称（n-dimensional array object）是储存单一数据类型的多维数组；
• ufunc：全称（universal function object）它是一种能够对数组进行处理的函数。

NumPy官网（https://numpy.org/）

SciPy官网（https://scipy.org/）

Matplotlib官网（https://matplotlib.org/）

⛄ndarray对象

NumPy最重要的一个特点是其N维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引。NumPy里面所有的函数都是围绕ndarray展开的。

ndarray对象是用于存放同类型元素的多维数组。

ndarray中的每个元素在内存中都有相同存储大小的区域。

ndarray内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针；
• 数据类型或dtype，描述在数组中的固定大小值的格子；
• 一个表示数组形状（shape）的元组，表示各维度大小的元组；
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此

👀ndarray的创建

👁numpy.array()函数创建

创建一个ndarray只需调用NumPy的array函数即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
# 参数说明
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

# 例子
# dtype参数  
import numpy as np 
a = np.array([1,2,3], dtype = complex)  
print(a)
# 输出结果
[1.+0.j 2.+0.j 3.+0.j]

# 最小维度  
import numpy as np 
a = np.array([1,2,3,4,5], ndmin = 2)  
print(a)
# 输出结果
[[1 2 3 4 5]]

ndarray对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。

👁特殊函数创建

• numpy.empty()
• numpy.zeros()
• numpy.ones()
• numpy.full()
• numpy.random.*
• numpy.eye()
• …

（1）numpy.empty()方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

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

# 参数说明
shape	数组形状，可以是int或是元组，也可以是列表，如：（3，4）or 3 or [3,4]
dtype	数据类型，可选
order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

# 例子
import numpy as np 
x = np.empty([3,2], dtype = int) 
print(x)
# 输出结果
[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]]

注意：数组元素为随机值，因为它们未初始化。

（2）numpy.zeros()创建指定大小的数组，数组元素以0来填充：

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

# 参数说明
shape	数组形状
dtype	数据类型，可选
order	'C'用于C的行数组，或者'F'用于FORTRAN的列数组

# 例子
import numpy as np
# 默认为浮点数
x = np.zeros(5) 
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = int) 
print(y)
# 自定义类型
z = np.zeros((2,2), dtype = [('x','i4'), ('y','i4')])  
print(z)
# 输出结果
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

（3）numpy.ones()创建指定形状的数组，数组元素以1来填充：

numpy.ones(shape, dtype = None, order = 'C')
# 参数说明
shape	数组形状
dtype	数据类型，可选
order	'C' 用于C的行数组，或者'F'用于 FORTRAN 的列数组

# 例子
import numpy as np
# 默认为浮点数
x = np.ones(5) 
print(x)
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)
# 输出结果
[1. 1. 1. 1. 1.]
[[1 1]
 [1 1]]

（4）numpy.full()创建指定形状的数组，数组元素以fill_value来填充：

numpy.full(shape, fill_value, dtype=None, order='C')
# 参数说明
shape	数组形状
fill_value	填充值（标量或类似数组）
dtype	数据类型，可选
order	'C' 用于C的行数组，或者'F'用于 FORTRAN 的列数组

# 例子
import numpy as np
a = np.full((2,2),np.pi)
b = np.full((2,2),1)
c = np.full((2,2),[1,2])
print(a)
print(b)
print(c)
# 输出结果
[[3.14159265 3.14159265]
 [3.14159265 3.14159265]]
[[1 1]
 [1 1]]
[[1 2]
 [1 2]]

（5）numpy.random.*

在Python中，有两个模块可以产生随机数：

• python自带random包： 提供一些基本的随机数产生函数，可满足基本需要；
• numpy.random：提供一些产生随机数的高级函数，满足高级需求。

from numpy import random
# 例子1 Numpy创建标准正态分布数组
# 创建randn(size)服从X~N(0,1)的正态分布随机数组
a = random.randn(2,3)
print(a)
# 输出结果
[[-0.75827863 -0.0696867  -2.23015832]
 [-0.57744225 -0.20939873 -1.2368758 ]]

# 例子2 Numpy创建随机分布整数型数组
# 利用randint([low,high],size)创建一个整数型指定范围在[low.high]之间的数组
b=random.randint(100,300,(4,4))
print(b)
# 输出结果
[[130 136 156 208]
 [221 241 124 244]
 [203 266 160 222]
 [142 183 203 215]]

（6）numpy.eye()

import numpy as np
# 创建对角矩阵数组
a = np.eye(5)
print(a)
# 输出结果
[[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.]]

👁NumPy从已有的数组创建数组

• numpy.asarray()
• numpy.frombuffer()
• numpy.fromiter()

（1）numpy.asarray()

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

numpy.asarray(a, dtype = None, order = None)
# 参数说明
a	任意形式的输入参数，可以是：列表、列表的元组、元组、元组的元组、元组的列表、多维数组
dtype	数据类型，可选
order	可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

import numpy as np
# 将列表转换为ndarray
x = [1,2,3]
a1 = np.asarray(x)  
a2 = np.asarray(x, dtype = float)  
print(a1)
print(a2)
# 将元组转换为ndarray
y = (1,2,3) 
b = np.asarray(y)  
print(b)
# 将元组列表转换为ndarray
z = [(1,2,3),(4,5)] 
c = np.asarray(z)  
print(c)

# 输出结果
[1 2 3]
[1. 2. 3.]
[1 2 3]
[(1, 2, 3) (4, 5)]

（2）numpy.frombuffer()

numpy.frombuffer()用于实现动态数组。

numpy.frombuffer()接受buffer输入参数，以流的形式读入转化成ndarray对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
# 注意：buffer是字符串的时候，Python3默认str是Unicode类型，所以要转成bytestring在原str前加上b。
buffer	可以是任意对象，会以流的形式读入。
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据。
offset	读取的起始位置，默认为0。

# Python3例子
import numpy as np 
str = b'Hello World9527' 
a = np.frombuffer(str, 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' b'9' b'5' b'2' b'7']

（3）numpy.fromiter()

numpy.fromiter()方法从可迭代对象中建立ndarray对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)
# 参数说明
iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量，默认为-1，读取所有数据

import numpy as np 
# 使用range函数创建列表对象  
list=range(5)
it=iter(list)
print(it)
# 使用迭代器创建 ndarray 
x=np.fromiter(it, dtype = float)
print(x)

# 输出结果
<range_iterator object at 0x0000023512CA7E70>
[0. 1. 2. 3. 4.]

👁NumPy从数值范围创建数组

• numpy.arange()
• numpy.linspace()
• numpy.logspace()

（1）numpy.arange()

numpy包中的使用arange函数创建数值范围并返回ndarray对象，函数格式如下：

numpy.arange(start, stop, step, dtype)
# 根据start与stop指定的范围以及step设定的步长，生成一个ndarray
# 参数说明
start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

import numpy as np
a1 = np.arange(10)
a2 = np.arange(10, dtype = float)
b = np.arange(10, 20)
c = np.arange(10, 20, 2)
print(a1)
print(a2)
print(b)
print(c)
# 输出结果
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[10 11 12 13 14 15 16 17 18 19]
[10 12 14 16 18]

（2）numpy.linspace()

numpy.linspace函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# 参数说明
start	序列的起始值
stop	序列的终止值，如果endpoint为true，该值包含于数列中
num		要生成的等步长的样本数量，默认为50
endpoint	该值为true时，数列中包含stop值，反之不包含，默认是True。
retstep		如果为True时，生成的数组中会显示间距，反之不显示。
dtype		ndarray的数据类型

# 例子1
import numpy as np
a = np.linspace(1,10,10)
b = np.linspace(1,1,10)
c = np.linspace(10, 20, 5, endpoint = False) 
d = np.linspace(10, 20, 5)  
print(a)
print(b)
print(c)
print(d)
# 输出结果
[1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[10. 12. 14. 16. 18.]
[10. 12.5 15. 17.5 20. ]

# 例子2
import numpy as np
e1 = np.linspace(1,10,10,retstep= True)
e2 = np.linspace(1,10,5,retstep= True) 
print(e1)
print(e2)
# 拓展例子
f = np.linspace(1,10,10).reshape([10,1])
print(f)
#输出结果
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
(array([ 1.,  3.25,  5.5,  7.75, 10.]), 2.25)
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]
 [ 6.]
 [ 7.]
 [ 8.]
 [ 9.]
 [10.]]

（3）numpy.logspace()

numpy.logspace函数用于创建一个于等比数列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
# 参数说明
start	序列的起始值为：base ** start
stop	序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num		要生成的等步长的样本数量，默认为50
endpoint	该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base	对数 log 的底数。
dtype	ndarray 的数据类型

import numpy as np
# 默认底数是10
a = np.logspace(1.0, 2.0, num = 10)
# 将对数的底数设置为 2 
b = np.logspace(0, 9, 10,base = 2)
print(a)
print(b)

# 输出结果
[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
  35.93813664  46.41588834  59.94842503  77.42636827 100.        ]
[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

👁结构数组

C语言中可以通过struct关键字定义结构类型。NumPy中也有类似的结构数组。

import numpy as np
# 例子1
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) 
print(a)
print(a[0])
# 输出结果
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]
(b'abc', 21, 50.)

# 例子2
persontype = np.dtype({
    'names':['name','age','weight'],
    'formats':['S30','i','f']})
b = np.array([('Zhang',32,75.5),('Wang',24,65.2)],dtype = persontype)
print(b)
print(b[0])
# 输出结果
[(b'Zhang', 32, 75.5) (b'Wang', 24, 65.2)]
(b'Zhang', 32, 75.5)

Python打印字符串，前面出现b:

• b: bytes
• python3.x里默认的str是(py2.x里的)unicode, bytes是(py2.x)的str, b”“前缀代表的就是bytes ;
• python2.x里, b前缀没什么具体意义， 只是为了兼容python3.x的这种写法.

👀NumPy数据类型对象(dtype)

NumPy支持的数据类型比Python内置的类型要多很多，基本上可以和C语言的数据类型对应上，其中部分类型对应为Python内置的类型。

名称	描述
bool_	布尔型数据类型（True 或者 False）
int8	字节&