Numpy 教程

什么是Numpy？Numpy(Numerical Python)是一个Python扩展库，支持大量的维度数组和矩阵运算，此外也针对数组运算提供大量的数学函数库。

其主要用于数组计算，特点包括：

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

一、Ndarray对象

Ndarray(N-dimension array)是一个N维数组对象，他是一系列同类型数据的集合。

其内部构成为：

  • 一个指向数据的指针
  • 数据类型dtype，描述在数组中的固定大小的格子
  • 一个表示数组形状shape的元组
  • 一个跨度元组stride,也就是我们索引切片的时候选择的跨度
image-20220907131758920

风格印象🐉

  • 快！很快！非常快！
image-20220913170301299

ndarray中所有元素类型都是相同的，其存储位置是连续的！可以免去寻址步骤节省时间！

  • 全局解释器锁(Global Interpreter Lock)

Numpy 底层通过C编写，解除了GIL，其效率远高于Python！

下面我们来看看具体的生成器：

1
2
3
4
5
6
7
8
9
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
'''
	object: 数组或嵌套的数列
	dtype: 数据类型
	copy: 对象是否需要复制(new的内存空间)
	order: 创建数组的样式，A为任意方向，C为行方向，F为列方向
	subok: 返回一个与基类型一致的数组
	ndmin: 指定生成数组的最小维度
'''

生成最小维度

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

# [[1 2 3 4 5]]

ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块的一个位置。

二、数据类型

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

三、数组属性

Numpy的数组维度数量称为秩(rank)，每一个线性的数组是一个轴(axis)，也就是维度。

例如：二维数组由两个一维数组构成：

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

# [A,B,C]

# 或者是：
# [ A,
#	B,
#   C ]

# A=[1,2,3]

第一个一维数组中的每个元素又是一个一维数组。第一个轴也成为了底层数组，第二个则是底层数组中的数组，以此类推。

简单说一下，axis=0的情况表示沿着第0轴进行操作，也就是列，axis=1则是沿着第1轴进行操作，也就是行。

我们来理一理这个逻辑吧~

image-20221109193101547

创建一个三维数组，此时数组可以视作：

1
2
3
4
data=[
	[A,B,C],
	[D,E,F],
	[G,H,I] ]

其中，AA 是一列向量，表示[1,4,7][1,4,7]，这样，我们就从三维数组变成了二维数组(视觉上)。

来看看对axis=0的操作，此时我们做max(axis=0)，理应从列出发，得到如下结果：

[max(A,D,G),max(B,E,H),max(C,F,I)][max(A,D,G),max(B,E,H),max(C,F,I)]

image-20221109193402363

好的确实如此。

那axis=1的操作，应该就是：

[max(A,B,C),max(D,E,F),max(G,H,I)][max(A,B,C),max(D,E,F),max(G,H,I)]

image-20221109193529848

嗯，也确实是这个逻辑，只不过，二维情况下比较的是元素，高维比较的是向量。

那最后一个维度比的总得是元素了吧！此时做的工作类似于下面的逻辑：

1
2
3
res=[]
i in data.shape[0]:
	res.append(i.max(dim=1))
image-20221109193725257

常用属性

属性 说明
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️⃣ ndim

1
2
3
4
5
6
7
import numpy as np

a=np.arange(24)
a.ndim # 1

a=a.reshape(2,3,4)
a.ndim # 3

2️⃣ shape

1
a.shape # (2,3,4)

3️⃣ size

1
a.size # 24

4️⃣ dtype

1
2
3
a.dtype # dtype('int32')
a.dtype=np.float64
a.dtype # dtype('float64')

四、Numpy 创建数组

除却使用ndarray底层构造器外，我们还可以采用以下的方式来创建数组哦。

1️⃣ numpy.empty

参数说明

1
2
3
4
5
6
7
numpy.empty(shape, dtype = float, order = 'C')

'''
	shape: 数组形状
	dtype: 数据类型
	order: 行优先还是列优先，表示在计算机内中存储元素的顺序
'''

创建一个空数组

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

数组的元素为随机数，因为并未进行初始化。

2️⃣ numpy.zeros

参数说明

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

创建一个零数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 默认浮点
x=np.zeros(5)
print(x) # [0. 0. 0. 0. 0.]

# 设置类型为整数
y=np.zeros((5,),dtype=int)
print(y) # [0 0 0 0 0]

# 自定义类型
z=np.zeros((2,2),dtype=[('x','i4'),('y','i4')])
print(z) 
'''
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]
'''

3️⃣ numpy.ones(shape,dtype,order)

使用方式一样哦，创建全1数组

4️⃣ numpy.arange(start=0,stop,step,dtype)

返回一个0~n-1的ndarray数组~

5️⃣ numpy.full(shape,val)

生成一个值全为val的数组~

6️⃣ numpy.eye(n)

生成单位矩阵~

7️⃣ numpy.diag(list)

生成对角线矩阵！

8️⃣ numpy.asarray(a,dtype,order)

从给定的参数中生成ndarray

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

从可迭代对象中创建ndarray对象，返回一维数组，count表示读取的数据量，默认是读取所有数据

image-20220907135445064

☀️ numpy.linspace

用于创建一个等差数列的一维数组

1
2
3
4
5
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
'''
	endpoint: 是否包含终止点
	retstep: 是否输出间距
'''
1
2
a=np.linspace(1,10,10)
print(a) # [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

🌙 numpy.logspace

用于创建一个等比数列

1
2
3
4
5
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
'''
	base: 默认底数
	num: 区间内生成指数个
'''
1
2
3
4
5
a=np.logspace(1,2,num=10)
print(a)

[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
  35.93813664  46.41588834  59.94842503  77.42636827 100.      ]
image-20221109195516187 
1
2
3
4
a=np.logspace(0,9,num=10,base=2)
print(a)

# [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

五、Numpy的切片和索引

ndarray中的对象内容可以通过索引或切片来访问和修改。

有两种比较主流的索引方式：

  • 内置slice函数
  • 冒号分隔符

我们重点说冒号分隔符。

1
A[star:step:end]

注意左闭右开。

除却本身list的机制外，我们还可以采用省略号。

表示取到某一维度上的所有数据，譬如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a=np.arange(1,10).reshape([3,3])
print(a)

print(a[...,1]) # 第二列
print(a[1,...]) # 第二行
print(a[...,1:]) # 第二列开始的所有元素

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

[2 5 8]

[4 5 6]

[[2 3]
 [5 6]
 [8 9]]

除此之外，Numpy有一些更高级的索引方式。

1️⃣整数数组索引

1
2
3
4
5
6
7
8
9
10
x=np.arange(1,7).reshape(3,2)
print(x)
y=x[[0,1,2,1],[0,1,0,0]]
print(y)

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

[1 4 5 3]

根据数组维度，第一个索引数组表示axis=0，第二个索引数组表示axis=1，他们之间的一一映射确保了行列之间的取值。

维度不对会报错

当然，当第一个数组或者第二个数组维度为1时，不会报错，表示就要这一个位置。

image-20220907161526604 image-20220907161653950

我们的索引可以与切片:或...进行组合：

image-20220907162130989

基本上能满足项目需要的索引组合了。

2️⃣ 布尔索引

可以通过布尔运算来过滤指定条件之外的元素！

下面看个栗子：

1
2
3
4
5
6
7
8
9
10
x=np.arange(0,12).reshape(4,3)
print(x)
print(x[x>5]) # 找出大于5的元素

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
 
[ 6  7  8  9 10 11]

下面的实例采用了逻辑非~对NaN数据进行过滤

1
2
3
4
x=np.array([np.nan,1,2,np.nan,3,4,5])
print(x[~np.isnan(x)])

[1. 2. 3. 4. 5.]

过滤非复数元素

1
2
3
4
a=np.array([1,2+6j,5,3.5+5j])
print(a[np.iscomplex(a)])

[2. +6.j 3.5+5.j]

六、Numpy的广播机制

广播(Broadcast)是numpy对不同形状的数组进行数值计算的方式。

☀️

若两个数组a和b形状相同，对应的操作应当是每个元素之间的操作。

这要求维数相同，且各维度的长度相同。

1
2
3
4
5
a=np.array([1,2,3,4])
b=np.array([10,20,30,40])
print(a*b)

# [ 10  40  90 160]

🌙

在两个数组形状不同时，numpy将自动触发广播机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
a=np.array([
    [0,0,0],
    [10,10,10],
    [20,20,20],
    [30,30,30]
])
b=np.array([0,1,2])
print(a+b)

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

其内部运算逻辑如下图：

image-20220907164617941

这种广播要求的是一定有一个维度长度是匹配的，将较小的数组通过重复扩张到大的维度，以匹配维度为核心进行运算。

规则

  • 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
    • 例如：a(2,3) b(3)—>b(1,3)
  • 输出数组的形状是输入数组形状的各个维度上的最大值。
  • 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
  • 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解

对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

  • 数组拥有相同形状✅
  • 当前维度的值相等✅
  • 当前维度的值有一个是 1✅

1️⃣ 同shape

image-20220907165638282

2️⃣ 某个维度相等

image-20220907165711782

3️⃣ 某个维度为1

image-20220907165745186

4️⃣ 不满足上述条件

image-20220907165815935

弹出ValueError错误

七、Numpy 数组操作与逻辑运算

1️⃣ 逻辑运算

1
2
3
4
a=np.random.randint(0,20,10)
print(a[a>5])

[ 7 11  8 13  7 16  7 19]
1
2
3
4
a=np.random.randint(0,20,10)
print(a[(a>5)|(a*2<10)])

[10 18  8  1  4 16 13 18  1]

2️⃣ 通用判断函数

  • np.all()

    • 返回某个表达式中的元素是否全是满足条件

    • np.all(stock_day_rise[0:2,0:5] > 0)

      1
      2
      3
      4
      5
      6
      7

      + **np.unique()**

        + 返回唯一值

        + ```python
          np.unique(stock_day_rise[0:2,0:5].astype(int))

  • np.any()

    • 只要有一个元素满足条件就返回True
1
np.any(stock_day_rise[0:2,0:5] > 0)

3️⃣ 三元运算符

  • np.where(ndarray , A , B)

    • 如果满足条件，将元素替换为A，否则替换为B
    1
    np.where(temp > 0, 1, 0)
    • 常常结合np.logical_and和np.logical_or使用
    1
    2
    np.where(np.logical_and(temp > 0.5, temp < 1), 1, 0)
    np.where(np.logical_or(temp > 0.5, temp < -0.5), 1, 0)

数组操作
Numpy包含了一些函数用于处理数组，大致可分为以下几类：

  • 修改数组形状
  • 翻转数组
  • 修改数组维度
  • 连接数组
  • 分割数组
  • 数组元素的添加与删除

1️⃣ 修改数组形状

函数 描述
reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel 返回展开数组

numpy.reshape()可以在不改变数据的条件下修改形状。

1
numpy.reshape(arr,newshape,order="C")

np.ndarray.flat是一个数组元素迭代器

1
2
for ele in a.flat:
	print(ele)

np.ndarray.flatten(order=“C”)返回一份展开(序列化)的数组拷贝，对其操作并不会改变原始数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print ('展开的数组：')
print (a.flatten())
print ('\n')
 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

'''
展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

'''

numpy.ravel返回展平的元素视图，对其操作会改变原始数组哦

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('调用 ravel 函数之后：')
print (a.ravel())
print ('\n')
 
print ('以 F 风格顺序调用 ravel 函数之后：')
print (a.ravel(order = 'F'))

'''
原数组：
[[0 1 2 3]
 [4 5 6 7]]


调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]


以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]
'''

2️⃣ 翻转数组

函数 描述
transpose 对换数组的维度
ndarray.T 和 self.transpose() 相同
rollaxis 向后滚动指定的轴
swapaxes 对换数组的两个轴

numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

1
numpy.transpose(arr, axes)

参数说明:

  • arr：要操作的数组
  • axes：整数列表，对应维度，通常所有维度都会对换。

numpy.ndarray.T 类似 numpy.transpose，进行转置。

numpy.swapaxes

numpy.swapaxes 函数用于交换数组的两个轴，格式如下：

1
numpy.swapaxes(arr, axis1, axis2)
  • arr：输入的数组
  • axis1：对应第一个轴的整数
  • axis2：对应第二个轴的整数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print ('原数组：')
print (a)
print ('\n')
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
 
print ('调用 swapaxes 函数后的数组：')
print (np.swapaxes(a, 2, 0))

'''
原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]


调用 swapaxes 函数后的数组：
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]
'''
image-20220910234328333

3️⃣ 修改数组维度

维度 描述
broadcast 产生模仿广播的对象
broadcast_to 将数组广播到新形状
expand_dims 扩展数组的形状
squeeze 从数组的形状中删除一维条目

numpy.expand_dims
numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:

1
numpy.expand_dims(arr, axis)

参数说明：

  • arr：输入数组

  • axis：新轴插入的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
x = np.array(([1,2],[3,4]))
 
print ('数组 x：')
print (x)
print ('\n')
y = np.expand_dims(x, axis = 0)
 
print ('数组 y：')
print (y)
print ('\n')
 
print ('数组 x 和 y 的形状：')
print (x.shape, y.shape)
print ('\n')
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)
 
print ('在位置 1 插入轴之后的数组 y：')
print (y)
print ('\n')
 
print ('x.ndim 和 y.ndim：')
print (x.ndim,y.ndim)
print ('\n')
 
print ('x.shape 和 y.shape：')
print (x.shape, y.shape)

'''
数组 x：
[[1 2]
 [3 4]]


数组 y：
[[[1 2]
  [3 4]]]


数组 x 和 y 的形状：
(2, 2) (1, 2, 2)


在位置 1 插入轴之后的数组 y：
[[[1 2]]

 [[3 4]]]


x.ndim 和 y.ndim：
2 3


x.shape 和 y.shape：
(2, 2) (2, 1, 2)
'''

numpy.squeeze

numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：

1
numpy.squeeze(arr, axis)

参数说明：

  • arr：输入数组
  • axis：整数或整数元组，用于选择形状中一维条目的子集
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import numpy as np
 
x = np.arange(9).reshape(1,3,3)
 
print ('数组 x：')
print (x)
print ('\n')
y = np.squeeze(x)
 
print ('数组 y：')
print (y)
print ('\n')
 
print ('数组 x 和 y 的形状：')
print (x.shape, y.shape)

'''
数组 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]


数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]


数组 x 和 y 的形状：
(1, 3, 3) (3, 3)
'''

连接数组

函数 描述
concatenate 连接沿现有轴的数组序列
stack 沿着新的轴加入一系列数组。
hstack 水平堆叠序列中的数组（列方向）
vstack 竖直堆叠序列中的数组（行方向）

numpy.concatenate

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

1
numpy.concatenate((a1, a2, ...), axis)

参数说明：

  • a1, a2, ...：相同类型的数组
  • axis：沿着它连接数组的轴，默认为 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
# 两个数组的维度相同
 
print ('沿轴 0 连接两个数组：')
print (np.concatenate((a,b)))
print ('\n')
 
print ('沿轴 1 连接两个数组：')
print (np.concatenate((a,b),axis = 1))

'''
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]


沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]
'''

numpy.stack

numpy.stack 函数用于沿新轴连接数组序列，格式如下：

1
numpy.stack(arrays, axis)

参数说明：

  • arrays相同形状的数组序列
  • axis：返回数组中的轴，输入数组沿着它来堆叠
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('沿轴 0 堆叠两个数组：')
print (np.stack((a,b),0))
print ('\n')
 
print ('沿轴 1 堆叠两个数组：')
print (np.stack((a,b),1))

'''
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 堆叠两个数组：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]


沿轴 1 堆叠两个数组：
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]
'''

numpy.hstack

numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('水平堆叠：')
c = np.hstack((a,b))
print (c)
print ('\n')

'''
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]
'''

numpy.vstack

numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('竖直堆叠：')
c = np.vstack((a,b))
print (c)

'''
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
'''

分割数组

函数 数组及操作
split 将一个数组分割为多个子数组
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）

numpy.split

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

1
numpy.split(ary, indices_or_sections, axis)

参数说明：

  • ary：被分割的数组
  • indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
  • axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import numpy as np
 
a = np.arange(9)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)

'''
第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
'''

axis 为 0 时在垂直方向分割，axis 为 1 时在竖直

方向分割：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import numpy as np

a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('\n')
print('默认分割（0轴）：')
b = np.split(a,2)
print(b)
print('\n')

print('沿水平方向分割：')
c = np.split(a,2,1)
print(c)
print('\n')

print('沿水平方向分割：')
d= np.hsplit(a,2)
print(d)

'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


默认分割（0轴）：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]


沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]


沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
'''

numpy.hsplit

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np
 
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array：')
print(harr)
 
print ('拆分后：')
print(np.hsplit(harr, 3))

'''
原array：
[[4. 7. 6. 3. 2. 6.]
 [6. 3. 6. 7. 9. 7.]]
拆分后：
[array([[4., 7.],
       [6., 3.]]), array([[6., 3.],
       [6., 7.]]), array([[2., 6.],
       [9., 7.]])]
'''

numpy.vsplit

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np
 
a = np.arange(16).reshape(4,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('竖直分割：')
b = np.vsplit(a,2)
print (b)

'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


竖直分割：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
'''

数组元素的添加与删除

函数 元素及描述
resize 返回指定形状的新数组
append 将值添加到数组末尾
insert 沿指定轴将值插入到指定下标之前
delete 删掉某个轴的子数组，并返回删除后的新数组
unique 查找数组内的唯一元素

numpy.resize
numpy.resize 函数返回指定大小的新数组。

如果新数组大小大于原始大小，则包含原始数组中的元素的副本。

1
numpy.resize(arr, shape)

参数说明：

  • arr：要修改大小的数组
  • shape：返回数组的新形状
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的形状：')
print (a.shape)
print ('\n')
b = np.resize(a, (3,2))
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('第二个数组的形状：')
print (b.shape)
print ('\n')
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了
 
print ('修改第二个数组的大小：')
b = np.resize(a,(3,3))
print (b)

'''
第一个数组：
[[1 2 3]
 [4 5 6]]


第一个数组的形状：
(2, 3)


第二个数组：
[[1 2]
 [3 4]
 [5 6]]


第二个数组的形状：
(3, 2)


修改第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]
'''

numpy.append

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。

append 函数返回的始终是一个一维数组。

1
numpy.append(arr, values, axis=None)

参数说明：

  • arr：输入数组
  • values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
  • axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('向数组添加元素：')
print (np.append(a, [7,8,9]))
print ('\n')
 
print ('沿轴 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
print ('\n')
 
print ('沿轴 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))


'''
第一个数组：
[[1 2 3]
 [4 5 6]]


向数组添加元素：
[1 2 3 4 5 6 7 8 9]


沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]
'''

numpy.insert

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。

如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。

1
numpy.insert(arr, obj, values, axis)

参数说明：

  • arr：输入数组
  • obj：在其之前插入值的索引
  • values：要插入的值
  • axis：沿着它插入的轴，如果未提供，则输入数组会被展开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import numpy as np
 
a = np.array([[1,2],[3,4],[5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在删除之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
 
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
print ('\n')
 
print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))

'''
第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]
'''

numpy.delete

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

1
Numpy.delete(arr, obj, axis)

参数说明：

  • arr：输入数组
  • obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
  • axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')
 
print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
 
print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]
'''

numpy.unique

numpy.unique 函数用于去除数组中的重复元素。

1
numpy.unique(arr, return_index, return_inverse, return_counts)
  • arr：输入数组，如果不是一维数组则会展开
  • return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
  • return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
  • return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import numpy as np
 
a = np.array([5,2,6,2,7,5,6,8,2,9])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的去重值：')
u = np.unique(a)
print (u)
print ('\n')
 
print ('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print (indices)
print ('\n')
 
print ('我们可以看到每个和原数组下标对应的数值：')
print (a)
print ('\n')
 
print ('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
 
print ('下标为：')
print (indices)
print ('\n')
 
print ('使用下标重构原数组：')
print (u[indices])
print ('\n')
 
print ('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)


第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重数组的索引数组：
[1 0 2 4 7 9]


我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


去重数组的下标：
[2 5 6 7 8 9]


下标为：
[1 0 2 0 3 1 2 4 0 5]


使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


返回去重元素的重复数量：
[2 5 6 7 8 9]

八、位运算与字符串函数

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

举个简单的小栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np

print('13 和 17 的二进制形式：')
a, b = 13, 17
print(bin(a), bin(b))
print('\n')

print('13 和 17 的位与：')
print(np.bitwise_and(13, 17))

print('13 和 17 的位或：')
print(np.bitwise_or(13, 17))


1
2
3
4
5
6
7
8
13 和 17 的二进制形式：
0b1101 0b10001


13 和 17 的位与：
1
13 和 17 的位或：
29

字符串

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

九、数学与统计函数

Numpy包含了大量的数学运算函数，包括三角函数，算数运算的函数，复数处理函数等。

我们介绍一些简单的函数。

三角函数

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

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np
 
a = np.array([0,30,45,60,90])
print ('不同角度的正弦值：')
# 通过乘 pi/180 转化为弧度  
print (np.sin(a*np.pi/180))
print ('\n')
print ('数组中角度的余弦值：')
print (np.cos(a*np.pi/180))
print ('\n')
print ('数组中角度的正切值：')
print (np.tan(a*np.pi/180))

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import numpy as np
 
a = np.array([0,30,45,60,90])  
print ('含有正弦值的数组：')
sin = np.sin(a*np.pi/180)  
print (sin)
print ('\n')
print ('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)  
print (inv)
print ('\n')
print ('通过转化为角度制来检查结果：')
print (np.degrees(inv))
print ('\n')
print ('arccos 和 arctan 函数行为类似：')
cos = np.cos(a*np.pi/180)  
print (cos)
print ('\n')
print ('反余弦：')
inv = np.arccos(cos)  
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))
print ('\n')
print ('tan 函数：')
tan = np.tan(a*np.pi/180)  
print (tan)
print ('\n')
print ('反正切：')
inv = np.arctan(tan)  
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))

'''
含有正弦值的数组：
[0.         0.5        0.70710678 0.8660254  1.        ]


计算角度的反正弦，返回值以弧度为单位：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


通过转化为角度制来检查结果：
[ 0. 30. 45. 60. 90.]


arccos 和 arctan 函数行为类似：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]


反余弦：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制单位：
[ 0. 30. 45. 60. 90.]


tan 函数：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]


反正切：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制单位：
[ 0. 30. 45. 60. 90.]
'''

舍入函数

1
2
3
numpy.around() # 函数返回指定数字的四舍五入值。
numpy.floor() # 返回小于或者等于指定表达式的最大整数，即向下取整。
numpy.ceil() # 返回大于或者等于指定表达式的最小整数，即向上取整。

算术函数

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

需要注意的是数组必须具有相同的形状或符合数组广播规则。

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import numpy as np 
 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print ('第一个数组：')
print (a)
print ('\n')
print ('第二个数组：')
b = np.array([10,10,10])  
print (b)
print ('\n')
print ('两个数组相加：')
print (np.add(a,b))
print ('\n')
print ('两个数组相减：')
print (np.subtract(a,b))
print ('\n')
print ('两个数组相乘：')
print (np.multiply(a,b))
print ('\n')
print ('两个数组相除：')
print (np.divide(a,b))

'''
第一个数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]


第二个数组：
[10 10 10]


两个数组相加：
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]


两个数组相减：
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]


两个数组相乘：
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]


两个数组相除：
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]
'''

除此之外，Numpy也包含了其他重要的算术函数。

reciprocal()

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

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np 
 
a = np.array([0.25,  1.33,  1,  100])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 reciprocal 函数：')
print (np.reciprocal(a))

'''
我们的数组是：
[  0.25   1.33   1.   100.  ]


调用 reciprocal 函数：
[4.        0.7518797 1.        0.01     ]
'''

power()

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

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import numpy as np 
 
a = np.array([10,100,1000])  
print ('我们的数组是；')
print (a)
print ('\n') 
print ('调用 power 函数：')
print (np.power(a,2))
print ('\n')
print ('第二个数组：')
b = np.array([1,2,3])  
print (b)
print ('\n')
print ('再次调用 power 函数：')
print (np.power(a,b))

'''
我们的数组是；
[  10  100 1000]


调用 power 函数：
[    100   10000 1000000]


第二个数组：
[1 2 3]


再次调用 power 函数：
[        10      10000 1000000000]
'''

mod()

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

来看个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
我们的数组是；
[  10  100 1000]


调用 power 函数：
[    100   10000 1000000]


第二个数组：
[1 2 3]


再次调用 power 函数：
[        10      10000 1000000000]import numpy as np
 
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print ('第一个数组：')
print (a)
print ('\n')
print ('第二个数组：')
print (b)
print ('\n')
print ('调用 mod() 函数：')
print (np.mod(a,b))
print ('\n')
print ('调用 remainder() 函数：')
print (np.remainder(a,b))

'''
第一个数组：
[10 20 30]


第二个数组：
[3 5 7]


调用 mod() 函数：
[1 0 2]


调用 remainder() 函数：
[1 0 2]
'''

统计函数

numpy.amin() 和 numpy.amax()

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

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 amin() 函数：')
print (np.amin(a,1))
print ('\n')
print ('再次调用 amin() 函数：')
print (np.amin(a,0))
print ('\n')
print ('调用 amax() 函数：')
print (np.amax(a))
print ('\n')
print ('再次调用 amax() 函数：')
print (np.amax(a, axis =  0))

'''
我们的数组是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


调用 amin() 函数：
[3 3 2]


再次调用 amin() 函数：
[2 4 3]


调用 amax() 函数：
9


再次调用 amax() 函数：
[8 7 9]
'''

numpy.ptp()

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

栗子！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 ptp() 函数：')
print (np.ptp(a))
print ('\n')
print ('沿轴 1 调用 ptp() 函数：')
print (np.ptp(a, axis =  1))
print ('\n')
print ('沿轴 0 调用 ptp() 函数：')
print (np.ptp(a, axis =  0))

'''
我们的数组是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


调用 ptp() 函数：
7


沿轴 1 调用 ptp() 函数：
[4 5 7]


沿轴 0 调用 ptp() 函数：
[6 3 6]
'''

numpy.percentile()

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

1
numpy.percentile(a, q, axis)

看个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import numpy as np 
 
a = np.array([[10, 7, 4], [3, 2, 1]])
print ('我们的数组是：')
print (a)
 
print ('调用 percentile() 函数：')
# 50% 的分位数，就是 a 里排序之后的中位数
print (np.percentile(a, 50)) 
 
# axis 为 0，在纵列上求
print (np.percentile(a, 50, axis=0)) 
 
# axis 为 1，在横行上求
print (np.percentile(a, 50, axis=1)) 
 
# 保持维度不变
print (np.percentile(a, 50, axis=1, keepdims=True))

'''
我们的数组是：
[[10  7  4]
 [ 3  2  1]]
调用 percentile() 函数：
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
 [2.]]
 '''

numpy.median()

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

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np 
 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 median() 函数：')
print (np.median(a))
print ('\n')
print ('沿轴 0 调用 median() 函数：')
print (np.median(a, axis =  0))
print ('\n')
print ('沿轴 1 调用 median() 函数：')
print (np.median(a, axis =  1))

'''
我们的数组是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]


调用 median() 函数：
65.0


沿轴 0 调用 median() 函数：
[50. 90. 60.]


沿轴 1 调用 median() 函数：
[65. 80. 60.]
'''

numpy.mean()

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

算术平均值是沿轴的元素的总和除以元素的数量。

看个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np 
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 mean() 函数：')
print (np.mean(a))
print ('\n')
print ('沿轴 0 调用 mean() 函数：')
print (np.mean(a, axis =  0))
print ('\n')
print ('沿轴 1 调用 mean() 函数：')
print (np.mean(a, axis =  1))

'''
我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]


调用 mean() 函数：
3.6666666666666665


沿轴 0 调用 mean() 函数：
[2.66666667 3.66666667 4.66666667]


沿轴 1 调用 mean() 函数：
[2. 4. 5.]
'''

numpy.average()

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

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import numpy as np 
 
a = np.array([1,2,3,4])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 average() 函数：')
print (np.average(a))
print ('\n')
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])  
print ('再次调用 average() 函数：')
print (np.average(a,weights = wts))
print ('\n')
# 如果 returned 参数设为 true，则返回权重的和  
print ('权重的和：')
print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

'''
我们的数组是：
[1 2 3 4]


调用 average() 函数：
2.5


再次调用 average() 函数：
2.0


权重的和：
(2.0, 10.0)
'''

在多维数组中，可以指定用于计算的轴。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import numpy as np 
 
a = np.arange(6).reshape(3,2)  
print ('我们的数组是：')
print (a)
print ('\n')
print ('修改后的数组：')
wt = np.array([3,5])  
print (np.average(a, axis =  1, weights = wt))
print ('\n')
print ('修改后的数组：')
print (np.average(a, axis =  1, weights = wt, returned =  True))

'''
我们的数组是：
[[0 1]
 [2 3]
 [4 5]]


修改后的数组：
[0.625 2.625 4.625]


修改后的数组：
(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))
'''

方差与标准差

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

标准差是方差的算术平方根。

1
2
3
4
5
6
7
8
9
import numpy as np 
 
print (np.std([1,2,3,4]))

# 1.1180339887498949

print (np.var([1,2,3,4]))

# 1.25

十、矩阵与线性代数

Numpy中包含了一个矩阵库numpy.matlib，该模块返回的是一个矩阵，而不是ndarray对象。

转置

1
2
3
4
5
6
7
8
9
10
import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('转置数组：')
print (a.T)

空矩阵

1
numpy.matlib.empty(shape, dtype, order)

全1矩阵

1
np.matlib.ones()

全0矩阵

1
np.matlib.zeros()

单位矩阵

1
numpy.matlib.eye(n, M,k, dtype)

主对角线矩阵

1
np.matlib.identity(5, dtype =  float)

随机矩阵

1
np.matlib.rand(3,3)

在二维情况下，ndarray和matrix可以进行互换

1
2
3
4
5
6
7
np.matrix('1,2;3,4')

# 转化为ndarray
np.asarray(i)

# 转化为矩阵
np.asmatrix(j)

线性代数函数

函数 描述
dot 两个数组的点积，即元素对应相乘。
vdot 两个向量的点积
inner 两个数组的内积
matmul 两个数组的矩阵积
determinant 数组的行列式
solve 求解线性矩阵方程
inv 计算矩阵的乘法逆矩阵
matrix_power 升幂
qr qr分解，q是一个正交矩阵，r是upper-triangular
matrix_tank 通过SVD方法返回数组的矩阵秩

numpy.linalg.det()

计算输入矩阵的行列式

栗子

1
2
3
4
5
6
import numpy as np
 
b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) 
print (b)
print (np.linalg.det(b))
print (6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))

numpy.linalg.solve()

求解方程结果

栗子

1
2
3
4
5
6
7
# 求解方程组x0+2*x1=1
# 3*x0+5*x1=2
a = np.array([[1, 2], [3, 5]])
b = np.array([1, 2])
x = np.linalg.solve(a, b)

array([-1,1])

numpy.linalg.inv()

计算乘法逆矩阵

栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np 
 
a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
 
print ('数组 a：')
print (a)
ainv = np.linalg.inv(a) 
 
print ('a 的逆：')
print (ainv)
 
print ('矩阵 b：')
b = np.array([[6],[-4],[27]]) 
print (b)
 
print ('计算：A^(-1)B：')
x = np.linalg.solve(a,b) 
print (x)
# 这就是线性方向 x = 5, y = 3, z = -2 的解

十一、IO

Numpy可以读写磁盘上的二进制或者文本文件。

其文件格式为npy，女朋友文件可以重建ndarray的数据、图像和其他info哦

常见的IO函数

1
2
3
4
5
6
7
numpy.save(file,arr,allow_pickle=True,fix_imports=True)
'''
+ file: 要保存的文件，扩展名为.npy
+ arr: 要保存的数组
+ allow_pickle: 允许Python pickles保存对象数组，这玩意会对对象进行序列化和反序列化
+ fix_imports: 主要方便PY3文件向下兼容PY2
'''

栗子

1
2
3
4
5
6
7
import numpy as np
a=np.array([1,2,3,4,5])
np.save('output.npy',a)
# 输出的文件是乱码的，属于加密文件
# 通过load读取就行

b=np.load("output.npy")
1
2
3
4
5
6
numpy.savez(file,*args,**kwds)
'''
+ file: 要保存的文件,后缀是npz
+ args: 要保存的数组，可以通过k-v形式可以设定一个名字，否则default arr_0
+ kwds: 要保存的数组使用关键字名字
'''

栗子

1
2
3
4
5
6
7
8
9
10
11
a = np.array([[1,2,3],[4,5,6]])
b = np.arange(0, 1.0, 0.1)
c = np.sin(b)

# C使用了关键字参数
np.savez("runoob.npz",a,b,sin_array=c)

r=np.load("runoob.npz")
a=r["arr_0"]
b=r["arr_1"]
c=r["sin_array"]

前面捏是存储二进制文件，那对于文本，也可以通过savetxt()和loadtxt()进行操作哦。

1
2
np.loadtxt(filename,dtype=int,delimiter='')
np.savetxt(filename,a,fmt="%d",delimiter=",")

栗子

1
2
3
4
5
a=np.arange(0,10,0.5).reshape(4,-1)
# 保留整数，用逗号作为分隔符
np.savetxt("out.txt",a,fmt="%d"mdelimiter=",")
# 读取数据，也需要指定逗号分隔符
b=np.loadtxt("out.txt",delimiter=",")

https://vimsky.com/examples/usage/python-numpy.linalg.matrix_rank.html)

十二、随机模块

1️⃣ 均匀分布

  • np.random.rand(dim)
    • 返回[0,1)区间内均匀分布的数
  • np.random.uniform(low=0.0,high=1.0,size=None)
    • 在均匀分布区间[low,high)中随机采样
  • np.random,randint(low,high,size,dtype=“I”)
    • 返回随机整数

2️⃣ 正态分布

公式

f(x)=1σ2πe−(x−μ)22σ2f(x)=\frac{1}{\sigma\sqrt{2\pi}}e^{\frac{-(x-\mu)^2}{2\sigma^2}}

  • np.random.randn(dim)
    • 从标准正态分布返回一个或多个样本值
  • np.random.normal(loc=0.0,scale=1.0,size=None)
    • 均值，方差，形状

**案例 ** 随机生成8只股票10天的交易日涨幅数据

1
2
3
4
5
stock_change=np.random.normal(0,1,(8,10))

'''
return : np.ndarray
'''

np.newaxis

np.newaxis 的功能是增加新的维度，但是要注意 np.newaxis 放的位置不同，产生的矩阵形状也不同。

通常按照如下规则：

np.newaxis 放在哪个位置，就会给哪个位置增加维度

x[:, np.newaxis] ，放在后面，会给列上增加维度
x[np.newaxis, :] ，放在前面，会给行上增加维度

用途： 通常用它将一维的数据转换成一个矩阵，这样就可以与其他矩阵进行相乘。