Numpy
Numpy是Python中科学计算的核心库。Numpy提供了高性能的多维数组对象，还有用于处理这些数组的工具。
数组
Numpy的主要数据类型是ndarray即多维数组，可以用嵌套的Python列表中初始化numpy数组，并使用方括号访问元素。数组具有以下几个属性：
ndarray.ndim： 数组的维数
ndarray.shape： 数组每一维的大小
ndarray.size： 数组中全部元素的数量
ndarray.dtype： 数组中元素的类型（numpy.int32, numpy.int16, and numpy.float64等）
ndarray.itemsize：每个元素占几个字节
数组操作
import numpy as np # 导入numpy模块
a = np.array([1,2,3])
print(type(a)) # a的类型是numpy.ndarray
print(a.shape) # 一维数组，列向量
print(a[0],a[1],a[2]) # 下标从0开始计数
a[0] = 5 # 修改数组元素的值
print(a)
b = np.array([[1,2,3],[4,5,6]])
print(b.shape) # 二维数组，2×3
print(b[0,0],b[0,1],b[1,0]) # 二维数组下标
c = np.array([1,]) # 一维数组
print(c.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果
<class 'numpy.ndarray'>
(3,)
1 2 3
[5 2 3]
(2, 3)
1 2 4
(1,)
1
2
3
4
5
6
7
8
9
10
11
12
创建数组
import numpy as np
a = np.zeros((2,2)) # 2×2全零数组
print(a)
b = np.ones((1,2)) # 2×2全一数组
print(b)
c = np.full((2,2),7) # 2×2常量数组，运行结果是‘7’而不是‘7.’
print(c)
d = np.eye(2) # 2×2单位数组
print(d)
e = np.random.random((2,2)) # 2×2随机数组，范围为[0,1]
print(e)
1
2
3
4
5
6
7
8
9
10
11
运行结果
[[ 0. 0.]
[ 0. 0.]]
[[ 1. 1.]]
[[7 7]
[7 7]]
[[ 1. 0.]
[ 0. 1.]]
[[ 0.75674195 0.00198805]
[ 0.0375324 0.72334415]]
1
2
3
4
5
6
7
8
9
10
11
12
13
数组索引
Numpy提供了几种索引数组的方法。
切片
类似于Python中的列表List，可以将numpy数组进行切片。如果是多维数组，需要为数组的每个维度指定一个切片。
import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
b = a[:2,1:3]
print(a)
print(b)
print(a[0,1]) # 第一行第二个
b[0,0] = 77 # a、b共用同一数据
print(a[0,1])
a[0,1] = 60 # 改变a或b，都会改动另一方，类似C++中引用
print(b[0,0])
1
2
3
4
5
6
7
8
9
10
11
12
运行结果
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[2 3]
[6 7]]
2
77
60
1
2
3
4
5
6
7
8
9
10
11
12
整型索引与切片索引混合
这个做法会产生比原始数组更低级的数组。
import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
row_r1 = a[1,:] # 产生一维数组
row_r2 = a[1:2,:] # 产生二维数组
print(row_r1,row_r1.shape)
print(row_r2,row_r2.shape)
col_r1 = a[:,1]
col_r2 = a[:,1:2]
print(col_r1,col_r1.shape)
print(col_r2,col_r2.shape)
1
2
3
4
5
6
7
8
9
10
11
运行结果
[5 6 7 8] (4,)
[[5 6 7 8]] (1, 4)
[ 2 6 10] (3,)
[[ 2]
[ 6]
[10]] (3, 1)
1
2
3
4
5
6
7
8
9
整数数组索引
当对numpy数组使用切片索引时，生成的数组将始终是原始数组的子数组。而整数数组索引则允许使用另一个数组的数据构造任意的数组。
import numpy as np
a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(a[[0,1,2],[0,1,0]]) # 行、列
print(np.array([a[0,0],a[1,1],a[2,0]])) # 每个的坐标
b = np.array([0,2,0,1])
print(a[np.arange(4),b])
a[np.arange(4),b] += 10
print(a)
1
2
3
4
5
6
7
8
9
10
运行结果
[1 5 7]
[1 5 7]
[ 1 6 7 11]
[[11 2 3]
[ 4 5 16]
[17 8 9]
[10 21 12]]
1
2
3
4
5
6
7
8
9
10
布尔数组索引
布尔数组索引可挑选出一个数组的任意元素。通常，这种类型的索引用于选择满足某些条件的数组的元素。
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
bool_idx = (a > 2) # 逐个比较
print(bool_idx)
print(a[bool_idx])
print(a[a > 2])
1
2
3
4
5
6
运行结果
[[False False]
[ True True]
[ True True]]
[3 4 5 6]
[3 4 5 6]
1
2
3
4
5
6
7
数据类型
import numpy as np
x = np.array([1,2]) # int64
print(x,x.dtype)
x = np.array([1.0,2.0]) # float64
print(x,x.dtype)
x = np.array([1.5,2.8],dtype = np.int64) # 强制转换，int64
print(x,x.dtype)
1
2
3
4
5
6
7
8
9
运行结果
[1 2] int32
[ 1. 2.] float64
[1 2] int64
1
2
3
4
5
数组计算
数组可以进行基本的数学函数计算，并且可以作为操作符重载和在numpy模块中的函数。
import numpy as np
x = np.array([[1,2],[3,4]],dtype = np.float64)
y = np.array([[5,6],[7,8]],dtype = np.float64)
print(x + y) # 加法
print(np.add(x,y))
print(x - y) # 减法
print(np.subtract(x,y))
print(x * y) # 乘法
print(np.multiply(x,y))
print(x / y) # 除法
print(np.divide(x,y))
print(np.sqrt(x)) # 开方
print(np.sum(x)) # 所有元素相加
print(np.sum(x,axis = 0)) # 列向量相加
print(np.sum(x,axis = 1)) # 行向量相加
v = np.array([9,10])
w = np.array([11,12])
print(x.T) # 多维数组转置
print(v.T) # 一维数组转置不发生改变
print(v.dot(w)) # 计算内积
print(np.dot(v,w))
print(np.dot(x,v))
print(np.dot(x,y))
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
运行结果
[[ 6. 8.] # 加法
[ 10. 12.]]
[[ 6. 8.]
[ 10. 12.]]
[[-4. -4.] # 减法
[-4. -4.]]
[[-4. -4.]
[-4. -4.]]
[[ 5. 12.] # 乘法
[ 21. 32.]]
[[ 5. 12.]
[ 21. 32.]]
[[ 0.2 0.33333333] # 除法
[ 0.42857143 0.5 ]]
[[ 0.2 0.33333333]
[ 0.42857143 0.5 ]]
[[ 1. 1.41421356] # 开方
[ 1.73205081 2. ]]
10.0 # 所有元素相加
[ 4. 6.] # 列向量相加
[ 3. 7.] # 行向量相加
[[ 1. 3.] # 多维数组转置
[ 2. 4.]]
[ 9 10] # 一维数组转置不发生改变
219 # 计算内积v.dot(w)
219 # 计算内积np.dot(v,w)
[ 29. 67.] # 计算内积np.dot(x,v)
[[ 19. 22.] # 计算内积np.dot(x,y)
[ 43. 50.]]
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
Broadcasting
Broadcasting广播机制是Python中一种强大的机制，它允许numpy在执行算术运算时使用不同形状的数组。当对一个较小的数组和一个较大的数组进行运算时，通过多次使用较小的数组来对较大的数组执行一些操作。
import numpy as np
x = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v = np.array([1,0,1])
y_empty = np.empty_like(x) # 创建一个与x大小相同的空矩阵
for i in range(4):
y_empty[i,:] = x[i,:] + v;
print(y_empty)
vv = np.tile(v,(4,1)) # 将v垂直地堆叠起来，形成新数组vv，比上一种方法运行速度快
print(vv)
y_tile = x + vv
print(y_tile)
y_bc = x + v # 传播机制BoardCasting
print(y_bc)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果
[[ 2 2 4] # y_empty
[ 5 5 7]
[ 8 8 10]
[11 11 13]]
[[1 0 1] # vv
[1 0 1]
[1 0 1]
[1 0 1]]
[[ 2 2 4] # y_tile
[ 5 5 7]
[ 8 8 10]
[11 11 13]]
[[ 2 2 4] # y_bc
[ 5 5 7]
[ 8 8 10]
[11 11 13]]
---------------------
转载，仅作分享，侵删
作者：wangprince2017
原文：https://blog.csdn.net/u010608296/article/details/85341744
|
|
收藏
淘帖
踩
奈斯
