2-工具与软件-1-Numpy

NumPy用于数据分析，提供了大量的维度数组与矩阵运算，NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用。

安装

sudo apt-get install python3-numpy python3-scipy python3-matplotlib ipython ipython-notebook python-pandas python-sympy python-nose

或使用pycharm在import numpy后自动导入。

N 维数组对象 ndarray

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

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

数据类型

int8, int16, int32, int64 四种数据类型可以使用字符串 ‘i1’, ‘i2’,’i4’,’i8’ 代替

名称 描述
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 位浮点数（实数部分和虚数部分）

在创建dtype中（数据类型对象），每个内建类型都有一个唯一定义它的字符代码

字符 对应类型
b 布尔型
i (有符号) 整型
u 无符号整型 integer
f 浮点型
c 复数浮点型
m timedelta（时间间隔）
M datetime（日期时间）
O (Python) 对象
S, a (byte-)字符串
U Unicode
V 原始数据 (void)

Numpy数组

维数——秩（rank），维度——轴（axis）

属性 说明
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.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

1
numpy.empty(shape, dtype = float, order = 'C')
参数 描述
shape 数组形状
dtype 数据类型，可选
order 有”C”和”F”两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

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

1
numpy.zeros(shape, dtype = float, order = 'C')
参数 描述
shape 数组形状
dtype 数据类型，可选 默认为浮点数
order ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

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

1
numpy.ones(shape, dtype = None, order = 'C')
参数 描述
shape 数组形状
dtype 数据类型，可选 默认为浮点数
order ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

numpy.zeros_like numpy.ones_like 创建一个模仿数组，以1或者0进行填充。

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

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

参数说明：

参数 描述
a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype 数据类型，可选
order 可选，有”C”和”F”两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

例:

1
2
3
4
5
6
import numpy as np

x = [1, 2, 3]
a = np.asarray(x)
print(x)
print(a)
Output
1
2
3
[1, 2, 3]
[1 2 3]
#由此可以看出list和array的区别

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

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

1
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
参数 描述
buffer 可以是任意对象，会以流的形式读入。
dtype 返回数组的数据类型，可选
count 读取的数据数量，默认为-1，读取所有数据。
offset 读取的起始位置，默认为0。

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

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

从数值范围创建数组

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

1
numpy.arange(start, stop, step, dtype)

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

参数 描述
start 起始值，默认为0
stop 终止值（不包含）
step 步长，默认为1
dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

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

1
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 的数据类型

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

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

base 参数意思是取对数的时候 log 的下标。

参数 描述
start 序列的起始值为：base ** start
stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base 对数 log 的底数。
dtype ndarray 的数据类型

切片和索引

与list的切片相差不大，使用slice方法或者[:::] (start:finish:step)即可，另外对于多维数组的切分，可使用省略号... 

1
2
3
4
5
6
import numpy as np

a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a[..., 1])  # 第2列元素
print(a[1, ...])  # 第2行元素
print(a[..., 1:])  # 第2列及剩下的所有元素
1
2
3
4
5
6
7
8
9
10
11
[[1 2 3]
 [3 4 5]
 [4 5 6]]
---------------------
[2 4 5]
---------------------
[3 4 5]
---------------------
[[2 3]
 [4 5]
 [5 6]]

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
#这里的索引是0 0,0 2,3 0,3 2
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)

Output
1
2
3
4
5
6
7
8
9
10
我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


这个数组的四个角元素是：
[[ 0  2]
 [ 9 11]]

关于 np.ix_ 的具体使用：

x[np.ix_([1,5,7,2],[0,3,1,2])] 这句话会输出一个4*4的矩阵，其中的元素分别是：

1
2
3
4
x[1,0] x[1,3] x[1,1] x[1,2]
x[5,0] x[5,3] x[5,1] x[5,2]
x[7,0] x[7,3] x[7,1] x[7,2]
x[2,0] x[2,3] x[2,1] x[2,2]

相当于：

1
2
3
4
y=np.array([[x[1,0], x[1,3], x[1,1], x[1,2]],\
            [x[5,0], x[5,3], x[5,1],x[5,2]],\
            [x[7,0] ,x[7,3], x[7,1], x[7,2]],\
            [x[2,0], x[2,3], x[2,1], x[2,2]]])

就是说，如果 np.xi_ 中输入两个列表，则第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标，第一个列表中的每个元素都会遍历第二个列表中的每个值，构成新矩阵的一行元素。

广播

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

但是两个数组形状不同时，numpy就触发了广播机制。

1
2
3
4
5
6
7
8
import numpy as np

a = np.array([[0, 0, 0],
              [10, 10, 10],
              [20, 20, 20],
              [30, 30, 30]])
b = np.array([0, 1, 2])
print(a + b)

img

Output
1
2
3
4
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

迭代器

NumPy 迭代器对象numpy.nditer提供了一种灵活访问一个或者多个数组元素的方式。

for x in np.nditer(a, order='F'):Fortran order，即是列序优先；

for x in np.nditer(a.T, order='C'):C order，即是行序优先；

1
2
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x

x[…] 是修改原 numpy 元素，x 只是个拷贝。

order = ‘C’，numpy 实例（也就是一个多维数组）本身的存储顺序不会因为转置或 order = ‘C’ 或 ‘F’ 而改变。

只是 numpy 实例中，存储了一个默认的访问顺序的字段。

numpy.copy 做了特殊处理，它拷贝的时候不是直接把对方的内存复制，而是按照上面 order 指定的顺序逐一拷贝。

for x in np.nditer(a, order = ‘C’): 可以在循环中另外指定顺序，如果未指定，则按照上面数组的order顺序访问。

1
2
for x in np.nditer(a, flags = ['external_loop'], order = 'F'): 
    print (x, end=", " )

**flags = [‘external_loop’]**，当数组的 order 与在循环中指定的 order 顺序不同时，打印为多个一维数组，当相同时，是整个一个一维数组。

数组操作

这一部分基本上一些方法，这里只对方法的函数名和描述给出。

修改数组形状

函数 描述
reshape 不改变数据的条件下修改形状 numpy.reshape(arr, newshape, order=’C’)
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 ndarray.flatten(order=’C’)
ravel 返回展开数组 numpy.ravel(a, order=’C’)

翻转数组

函数 描述
transpose 对换数组的维度 numpy.transpose(arr, axes)
ndarray.T 和 self.transpose() 相同
rollaxis 向后滚动指定的轴 numpy.rollaxis(arr, axis, start)
swapaxes 对换数组的两个轴 numpy.swapaxes(arr, axis1, axis2)

修改数组维度

维度 描述
broadcast 产生模仿广播的对象
broadcast_to 将数组广播到新形状 numpy.broadcast_to(array, shape, subok)
expand_dims 扩展数组的形状 numpy.expand_dims(arr, axis)
squeeze 从数组的形状中删除一维条目 numpy.squeeze(arr, axis)

连接数组

函数 描述
concatenate 连接沿现有轴的数组序列 numpy.concatenate((a1, a2, …), axis)
stack 沿着新的轴加入一系列数组。 numpy.stack(arrays, axis)
hstack 水平堆叠序列中的数组（列方向）
vstack 竖直堆叠序列中的数组（行方向）

分割数组

函数 数组及操作
split 将一个数组分割为多个子数组 numpy.split(ary, indices_or_sections, axis)
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）

数组元素的添加与删除

函数 元素及描述
resize 返回指定形状的新数组 numpy.resize(arr, shape)
append 将值添加到数组末尾 numpy.append(arr, values, axis=None)
insert 沿指定轴将值插入到指定下标之前 numpy.insert(arr, obj, values, axis)
delete 删掉某个轴的子数组，并返回删除后的新数组 Numpy.delete(arr, obj, axis)
unique 查找数组内的唯一元素 numpy.unique(arr, return_index, return_inverse, return_counts)

位运算

Numpy也是内置位运算函数的，我认为这部分了解即可

菜鸟教程-NumPy 位运算

NumPy “bitwise_” 开头的函数是位运算函数。

NumPy 位运算包括以下几个函数：

函数 描述
bitwise_and 对数组元素执行位与操作
bitwise_or 对数组元素执行位或操作
invert 按位取反
left_shift 向左移动二进制表示的位
right_shift 向右移动二进制表示的位

注：也可以使用 “&”、 “~”、 “|” 和 “^” 等操作符进行计算。

字符串

Numpy的字符串函数是基于Python内置库中的标准字符串函数。

函数 描述
add() 对两个数组的逐个字符串元素进行连接
multiply() 返回按元素多重连接后的字符串
center() 居中字符串
capitalize() 将字符串第一个字母转换为大写
title() 将字符串的每个单词的第一个字母转换为大写
lower() 数组元素转换为小写
upper() 数组元素转换为大写
split() 指定分隔符对字符串进行分割，并返回数组列表
splitlines() 返回元素中的行列表，以换行符分割
strip() 移除元素开头或者结尾处的特定字符
join() 通过指定分隔符来连接数组中的元素
replace() 使用新字符串替换字符串中的所有子字符串
decode() 数组元素依次调用str.decode
encode() 数组元素依次调用str.encode

数学

提供了标准的三角函数：**sin()、cos()、tan()**。

arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。

这些函数的结果可以通过numpy.degrees()函数将弧度转换为角度。

numpy.around() 函数返回指定数字的四舍五入值。
numpy.around(a,decimals) decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 **divide()**。

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

numpy.mod() 计算输入数组中相应元素的相除后的余数。函数numpy.remainder()也产生相同的结果。

统计学

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

这些统计学函数通常带有较多的传入参数，详见统计学函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

numpy.percentile()百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

numpy.mean() 函数返回数组中元素的算术平均值，如果提供了轴，则沿其计算。

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

标准差是一组数据平均值分散程度的一种度量。标准差是方差的算术平方根。

标准差公式如下：

1
2
3
4
std = sqrt(mean((x - x.mean())**2))
#使用例：
print (np.std([1,2,3,4]))
>> 1.1180339887498949

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，

即 mean((x - x.mean())** 2)

换句话说，标准差是方差的平方根。

1
2
3
#使用例：
print (np.var([1,2,3,4]))
>> 1.25

排序

种类 速度 最坏情况
quicksort（快速排序） 1 O(n^2)
mergesort（归并排序） 2 O(n*log(n))
heapsort（堆排序） 3 O(n*log(n))

numpy.sort() 函数返回输入数组的排序副本，numpy中还能以字段关键字排序。

倒序使用

1
x = abs(np.sort(-x))

numpy.argsort() 函数返回的是数组值从小到大的索引值。

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

函数 描述
msort(a) 数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a) 对复数按照先实部后虚部的顺序进行排序。
partition(a, kth[, axis, kind, order]) 指定一个数，对数组进行分区
argpartition(a, kth[, axis, kind, order]) 可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

numpy.nonzero() 函数返回输入数组中非零元素的索引。

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

numpy.extract()函数根据某个条件从数组中抽取元素，返回满条件的元素。

字节交换

  • 大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
  • 小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。

(我并不知道这样做这有什么用)

副本和视图

和数据库语言的副本、视图类似。

视图或浅拷贝：ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。

副本或深拷贝：ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。

矩阵（matrix）与线性代数

一个 m * n 的矩阵

转置： numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。例如有个 m 行 n 列的矩阵，使用 t() 函数就能转换为 n 行 m 列的矩阵。

matlib.empty() 函数返回一个新的矩阵。

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

numpy.matlib.identity() 函数返回给定大小的单位矩阵。

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

线性代数函数库 linalg，该库包含了线性代数所需的所有功能

函数 描述
dot 两个数组的点积，即元素对应相乘。numpy.dot(a, b, out=None)
vdot 两个向量的点积
inner 两个数组的内积
matmul 两个数组的矩阵积
determinant 数组的行列式
solve 求解线性矩阵方程
inv 计算矩阵的乘法逆矩阵

numpy.linalg.det() 函数计算输入矩阵的行列式。

numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。

详见

IO

NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。

npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。

详见

UPDATE TIME ：

2023年9月12日星期二