上一章：【从 0 到 1 落地】机器学习实操项目目录：覆盖入门到进阶，大学生就业 / 竞赛必备
下一章：
机器学习核心知识点目录：机器学习核心知识点目录
机器学习实战项目：【从 0 到 1 落地】机器学习实操项目目录：覆盖入门到进阶，大学生就业 / 竞赛必备
文章目录
- 基本概念
- 数组的创建
- 打印数组
- 基本操作
- 广播函数
- 索引、切片和迭代
- 数组形状操作
- 更改数组的形状
- 堆砌不同的数组
- 将一个数组划分为多个更小的数组
- 复制和视图
- 不复制
- 视图和浅复制
- 深复制
- 多种多样的索引和索引的小技巧
- 用数组访问数组
- 用布尔数组来访问数组
- ix_()函数
- 线性代数
- 简单的数组操作
- 小技巧和小贴士
- 自动更改数组大小
- 直方图
基本概念
Numpy 的核心是连续的多维数组。
Numpy中的数组叫做np.ndarray，也可以使用别名np.array。
但这里的np.array与Python标准库中的array.array是不同的。
下列是几个ndarray中的重要属性：
ndarray.ndim
数组的维数。
ndarray.shape
数组的形状。
ndarray.size
数组的元素个数。
ndarray.dtype
数组的元素类型。
代码：
import numpy as nppreds = np.array([1,1,1])
labels = np.array([1,2,3])(1/3)*np.sum(np.square(preds-labels))
输出结果：
1.6666666666666665
代码：
import numpy as np
data=np.arange(15).reshape(3,5)
print(data)
print(data.shape)
print(data.ndim)
print(data.size)
print(data.dtype.name)
输出结果：
[[ 0 1 2 3 4][ 5 6 7 8 9][10 11 12 13 14]]
(3, 5)
2
15
int32
数组的创建
创建数组有多种方式。你可以使用np.array直接用Python的元组和列表来创建。
代码：
import numpy as np
a=np.array([1,2,3])
print(a.dtype)
b=np.array([1.1,2.2,3.3])
print(b.dtype)
c=np.array([(1,2,3),(4.5,5,6)]) #创建二维数组
print(c)
d=np.array([(1,2),(3,4)],dtype=complex) #数组的类型可以在创建时显式声明
print(d)
输出结果：
int32
float64
[[ 1. 2. 3. ][ 4.5 5. 6. ]]
[[ 1.+0.j 2.+0.j][ 3.+0.j 4.+0.j]]
通常，数组的元素的未知的，但是形状确实已知的。所以NumPy提供了多种创建空数组的方法。
np.zeros创建全是0的数组。
np.ones创建全是1的数组。
np.empty创建初始值是随机数的数组。
需要注意的是上述方法创建的数组元素的类型是 float64
代码：
e=np.zeros((3,4))
print(e)
f=np.ones((2,3,4),dtype=np.int16)#可以更改数据类型
print(f)
g=np.empty((2,3))
print(g)
输出结果：
[[ 0. 0. 0. 0.][ 0. 0. 0. 0.][ 0. 0. 0. 0.]]
[[[1 1 1 1][1 1 1 1][1 1 1 1]][[1 1 1 1][1 1 1 1][1 1 1 1]]]
[[ 1. 2. 3. ][ 4.5 5. 6. ]]
为了创建列表，NumPy提供了和 range类似的函数。
np.arange(start,end,step)
代码：
a=np.arange(10,30,5)
print(a)
b=np.arange(0,2,0.3)#同样可以接收浮点数
print(b)
输出结果：
[10 15 20 25]
[ 0. 0.3 0.6 0.9 1.2 1.5 1.8]
在生成浮点数列表时，最好不要使用np.arange，而是使用np.linspace。
np.linspace(start,stop,num)
代码：
np.linspace(0,2,9)
输出结果：
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
打印数组
当你打印一个数组时，NumPy显示数组的方式和嵌套的列表类似，但是会遵循以下布局：
- 最后一维从左到右显示
- 第二维到最后一维从上到下显示
- 剩下的同样从上到下显示，以空行分隔
一维数组显示成一行，二维数组显示成矩阵，三维数组显示成矩阵的列表。
代码：
a=np.arange(6)
print(a)
b=np.arange(12).reshape(4,3)
print(b)
c=np.arange(24).reshape(2,3,4)
print(c)
输出结果：
[0 1 2 3 4 5]
[[ 0 1 2][ 3 4 5][ 6 7 8][ 9 10 11]]
[[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11]][[12 13 14 15][16 17 18 19][20 21 22 23]]]
当一个数组元素太多，不方便显示时，NumPy会自动数组的中间部分，只显示边角的数据。
代码：
print(np.arange(10000))
输出结果：
[ 0 1 2 ..., 9997 9998 9999]
基本操作
数组的算数计算是在元素层级运算的。计算结果会存在一个新创建的数组中。
代码：
import numpy as np
a=np.array([20,30,40,50])
b=np.arange(4)
print(b)
c=a-b
print(c)
print(b**2)
print(10*np.sin(a))
print(a<35)
输出结果：
[0 1 2 3]
[20 29 38 47]
[0 1 4 9]
[ 9.12945251 -9.88031624 7.4511316 -2.62374854]
[ True True False False]
在NumPy中*号仍然表示乘法，矩阵乘积用np.dot来计算。
代码：
A=np.array([(1,1),(0,1)])
B=np.array([(2,0),(3,4)])
print(A*B)
print(A.dot(B))
print(np.dot(A,B))
输出结果：
[[2 0][0 4]]
[[5 4][3 4]]
[[5 4][3 4]]
类似于+=和*=的运算是直接在现有数组上计算的，没有创建新的数组。Numpy中的计算同样也是向上转型的，可以简单理解成浮点数和整数运算的结果是浮点数。
代码：
a = np.ones((2,3), dtype=int)
b = np.random.random((2,3))
a*=3
print(a)
b += a
print(b)
# a += b # 浮点数不会自动转换成整数
输出结果：
[[3 3 3][3 3 3]]
[[ 3.36167598 3.63342297 3.22543331][ 3.17992397 3.01462584 3.87847828]]
np.ndarray提供了许多一元操作。比如数组求和、求最大最小值等。
代码：
a=np.random.random((2,3))
print(a)
print(a.sum())
print(a.mean())
print(a.max())
print(a.min())
输出结果：
[[ 0.06108727 0.21625055 0.066292 ][ 0.20271722 0.93946432 0.37747181]]
1.86328317161
0.310547195269
0.939464322779
0.0610872663968
默认的，这些一元操作是对整个数组进行计算，没有考虑到数组的形状。你可以设置axis参数来指定运算方向。axis表示第n维（从0开始）。
代码：
b=np.arange(12).reshape(3,4)
print(b)
print(b.sum(axis=0)) #对第0维的元素求和
print(b.sum(axis=1)) #对第1维的元素求和
print(b.min(axis=1))
print(b.cumsum(axis=1)) #对第1维的元素累加求和
输出结果：
[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11]]
[12 15 18 21]
[ 6 22 38]
[0 4 8]
[[ 0 1 3 6][ 4 9 15 22][ 8 17 27 38]]
广播函数
NumPy提供了熟知的数学方法，如：sin、cos、exp等。在NumPy中，这些方法被称作广播函数。这些函数会对数组中的每个元素进行计算，返回计算后的数组。
代码：
B=np.arange(3)
print(B)
print(np.exp(B))
print(np.sqrt(B))
C=np.array([2,-1,4])
print(np.add(B,C))
print(B+C)输出结果：
[0 1 2]
[ 1. 2.71828183 7.3890561 ]
[ 0. 1. 1.41421356]
[2 0 6]
[2 0 6]
索引、切片和迭代
一维数组可以被索引、切片和迭代，就和Python中的列表一样。
代码：
a=np.arange(10)**3
print(a)
print(a[2])
print(a[2:5])
a[:6:2]=-1000
print(a)
print(a[::-1])
for i in a:print(i)
输出结果：
[ 0 1 8 27 64 125 216 343 512 729]
8
[ 8 27 64]
[-1000 1 -1000 27 -1000 125 216 343 512 729]
[ 729 512 343 216 125 -1000 27 -1000 1 -1000]
-1000
1
-1000
27
-1000
125
216
343
512
729
多维数组可以在每一个维度有一个索引，这些索引构成元组来进行访问。
代码：
def f(x,y):return 10*x+y
b=np.fromfunction(f,(5,4),dtype=int)
print(b)
print(b[2,3])
print(b[0:5,1])
print(b[:,1])
print(b[1:3,:])输出结果：
[[ 0 1 2 3][10 11 12 13][20 21 22 23][30 31 32 33][40 41 42 43]]
23
[ 1 11 21 31 41]
[ 1 11 21 31 41]
[[10 11 12 13][20 21 22 23]]
...表示对索引的省略。如下所示：
代码：
c = np.array( [[[ 0, 1, 2], # 三维数组[ 10, 12, 13]],[[100,101,102],[110,112,113]]])
print(c.shape)
print(c[1,...]) # 和 c[1,:,:] 、 c[1]效果相同
print(c[...,2]) # 和c[:,:,2]效果相同
输出结果：
(2, 2, 3)
[[100 101 102][110 112 113]]
[[ 2 13][102 113]]
对多维数组的迭代是在第一维进行迭代的。
代码：
for row in b:print(row)
输出结果：
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
如果需要遍历多维数组的所有元素，可以使用flat这个属性。
代码：
for element in b.flat:print(element)
输出结果：
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43
数组形状操作
更改数组的形状
有很多种方式可以更改数组的形状。下列的函数都没有对原数组进行更改，而是返回了一个更改后的新数组。
代码：
a = np.floor(10*np.random.random((3,4)))
print(a.ravel()) #返回铺平后的数组
print(a.reshape(6,2)) #按照指定的形状更改
print(a.T)#返回转置矩阵
输出结果：
[ 5. 0. 9. 5. 5. 4. 2. 2. 3. 2. 0. 7.]
[[ 5. 0.][ 9. 5.][ 5. 4.][ 2. 2.][ 3. 2.][ 0. 7.]]
[[ 5. 5. 3.][ 0. 4. 2.][ 9. 2. 0.][ 5. 2. 7.]]
如果一个维度填的是-1，则该维度的形状会自动进行计算
代码：
print(a.reshape(3,-1))
输出结果：
[[ 5. 0. 9. 5.][ 5. 4. 2. 2.][ 3. 2. 0. 7.]]
堆砌不同的数组
多个数组可以按照不同的轴合在一起
代码：
a=np.floor(10*np.random.random((2,2)))
print(a)
b=np.floor(10*np.random.random((2,2)))
print(b)
print(np.vstack((a,b)))#垂直方向堆砌
print(np.hstack((a,b)))#水平方向堆砌
from numpy import newaxis
print(a[:,newaxis])
输出结果：
[[ 5. 1.][ 4. 2.]]
[[ 8. 1.][ 7. 8.]]
[[ 5. 1.][ 4. 2.][ 8. 1.][ 7. 8.]]
[[ 5. 1. 8. 1.][ 4. 2. 7. 8.]]
[[[ 5. 1.]][[ 4. 2.]]]
将一个数组划分为多个更小的数组
使用hsplit，vsplit可以对数组按照水平方向和垂直方向进行划分。
代码：
a=np.floor(10*np.random.random((2,12)))
print(a)
print(np.hsplit(a,3))
print(np.hsplit(a,(1,2,3)))#在第一列，第二列，第三列进行划分
输出结果：
[[ 7. 4. 0. 7. 5. 6. 4. 4. 4. 7. 7. 0.][ 0. 1. 7. 7. 4. 9. 7. 0. 0. 2. 7. 5.]]
[array([[ 7., 4., 0., 7.],[ 0., 1., 7., 7.]]), array([[ 5., 6., 4., 4.],[ 4., 9., 7., 0.]]), array([[ 4., 7., 7., 0.],[ 0., 2., 7., 5.]])]
[array([[ 7.],[ 0.]]), array([[ 4.],[ 1.]]), array([[ 0.],[ 7.]]), array([[ 7., 5., 6., 4., 4., 4., 7., 7., 0.],[ 7., 4., 9., 7., 0., 0., 2., 7., 5.]])]
复制和视图
当操作数组时，数组的数据有时会复制到新数组中，有时又不会。这通常令初学者感到困难。总的来说有下面三种情况：
不复制
简单的赋值不会复制数组的数据。
代码：
a=np.arange(12)
b=a
print(b is a)
b.shape=3,4
print(a.shape)
输出结果：
True
(3, 4)
视图和浅复制
不同的数组可以使用同一份数据，view函数在同一份数据上创建了新的数组对象。
代码：
c=a.view()
print(c is a)
print(c.base is a) #c是a的数据的视图
print(c.flags.owndata)
c.shape=6,2
print(a.shape) #a的形状没有改变
c[4,1]=1234 #a的数据改变了
print(a)
输出结果：
False
True
False
(3, 4)
[[ 0 1 2 3][ 4 5 6 7][ 8 1234 10 11]]
对数组切片会返回数组的视图
代码：
s=a[:,1:3]
s[:]=10
print(a)
输出结果：
[[ 0 10 10 3][ 4 10 10 7][ 8 10 10 11]]
深复制
copy函数实现了对数据和数组的完全复制。
代码：
d=a.copy()
print(d is a)
print(d.base is a)
d[0,0]=9999
print(a)
输出结果：
False
False
[[ 0 10 10 3][ 4 10 10 7][ 8 10 10 11]]
多种多样的索引和索引的小技巧
相比Python的列表，NumPy提供了更多的索引功能。除了可以用整数和列表来访问数组之外，数组还可以被整型数组和布尔数组访问。
用数组访问数组
代码：
a=np.arange(12)**2
i=np.array([1,1,3,8,5])
print(a[i])
j=np.array([[3,4],[8,5]]) #用二维数组来访问数组
print(a[j]) #产生和访问的数组相同形状的结果
输出结果：
[ 1 1 9 64 25]
[[ 9 16][64 25]]
在时间序列的数据上寻找最大值通常会用到数组索引
代码：
time=np.linspace(20,145,5)
data=np.sin(np.arange(20)).reshape(5,4)
print(time)
print(data)
ind=data.argmax(axis=0)#返回按照指定轴的方向的最大值的索引
time_max=time[ind]
print(time_max)
data_max=data[ind,range(data.shape[1])]
print(data_max)
输出结果：
[ 20. 51.25 82.5 113.75 145. ]
[[ 0. 0.84147098 0.90929743 0.14112001][-0.7568025 -0.95892427 -0.2794155 0.6569866 ][ 0.98935825 0.41211849 -0.54402111 -0.99999021][-0.53657292 0.42016704 0.99060736 0.65028784][-0.28790332 -0.96139749 -0.75098725 0.14987721]]
[ 82.5 20. 113.75 51.25]
[ 0.98935825 0.84147098 0.99060736 0.6569866 ]
你也可以使用数组索引来赋值
代码：
a=np.arange(5)
a[[1,3,4]]=0
print(a)
输出结果：
[0 0 2 0 0]
如果赋值时有重复的索引，则赋值会执行多次，留下最后一次执行的结果
代码：
a=np.arange(5)
a[[0,0,0]]=[1,2,3]
print(a)
输出结果：
[3 1 2 3 4]
但是赋值时使用+=时，并不会重复计算
代码：
a=np.arange(5)
a[[0,0,0]]+=1
print(a)
输出结果：
[1 1 2 3 4]
这是因为"a+=1"最终是解释成了"a=a+1"
用布尔数组来访问数组
通过使用布尔数组索引，我们可以选择哪些数据是需要的，哪些是不需要的。
在赋值中也非常有用。
代码：
a = np.arange(12).reshape(3,4)
b = a > 4
print(b)
print(a[b])
a[b]=10
print(a)
输出结果：
[[False False False False][False True True True][ True True True True]]
[ 5 6 7 8 9 10 11]
[[ 0 1 2 3][ 4 10 10 10][10 10 10 10]]
下面的代码用布尔数组索引产生了曼德布洛特集合的图像。
代码：
import numpy as np
import matplotlib.pyplot as plt
def mandelbrot( h,w, maxit=20 ):"""Returns an image of the Mandelbrot fractal of size (h,w)."""y,x = np.ogrid[ -1.4:1.4:h*1j, -2:0.8:w*1j ]c = x+y*1jz = cdivtime = maxit + np.zeros(z.shape, dtype=int)for i in range(maxit):z = z**2 + cdiverge = z*np.conj(z) > 2**2 # who is divergingdiv_now = diverge & (divtime==maxit) # who is diverging nowdivtime[div_now] = i # note whenz[diverge] = 2 # avoid diverging too muchreturn divtime
plt.imshow(mandelbrot(400,400))
plt.show()
输出结果：
ix_()函数
ix_函数被用来计算不同的向量的乘积。
代码：
a = np.array([2,3,4,5])
b = np.array([8,5,4])
c = np.array([5,4,6,8,3])
ax,bx,cx = np.ix_(a,b,c)
print(ax)
print(bx)
print(cx)
print(ax.shape, bx.shape, cx.shape)
result = ax*bx*cx + ax
print(result)
print(result[3,2,4])
print(a[3]*b[2]*c[4]+a[3])#计算的结果是相同的
输出结果：
[[[2]][[3]][[4]][[5]]]
[[[8][5][4]]]
[[[5 4 6 8 3]]]
(4, 1, 1) (1, 3, 1) (1, 1, 5)
[[[ 82 66 98 130 50][ 52 42 62 82 32][ 42 34 50 66 26]][[123 99 147 195 75][ 78 63 93 123 48][ 63 51 75 99 39]][[164 132 196 260 100][104 84 124 164 64][ 84 68 100 132 52]][[205 165 245 325 125][130 105 155 205 80][105 85 125 165 65]]]
65
65
线性代数
提供基本的线性代数操作
简单的数组操作
代码：
import numpy as np
a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
a.transpose()
np.linalg.inv(a)
u = np.eye(2) # unit 2x2 matrix; "eye" represents "I"
j = np.array([[0.0, -1.0], [1.0, 0.0]])
np.dot (j, j) # 点积
np.trace(u) # 矩阵的迹
y = np.array([[5.], [7.]])
print(np.linalg.solve(a, y))#解线性方程组
print(np.linalg.eig(j))#计算特征值输出结果：
[[ 1. 2.][ 3. 4.]]
[[-3.][ 4.]]
(array([ 0.+1.j, 0.-1.j]), array([[ 0.70710678+0.j , 0.70710678-0.j ],[ 0.00000000-0.70710678j, 0.00000000+0.70710678j]]))
小技巧和小贴士
自动更改数组大小
在更改数组大小时，你可以省略一个维度的大小，这个维度的大小会自动计算出来
代码：
a = np.arange(30)
a.shape = 2,-1,3 # -1 表示自动计算大小
print(a.shape)输出结果：
(2, 5, 3)
直方图
代码：
import numpy as np
import matplotlib.pyplot as plt
mu,sigma=2,0.5
v=np.random.normal(mu,sigma,10000)
#matplotlib版本
plt.hist(v,bins=100,normed=1)
plt.show()
#NumPy版本
(n, bins) = np.histogram(v, bins=50, normed=True) # NumPy version (no plot)
plt.plot(.5*(bins[1:]+bins[:-1]), n)
plt.show()
输出结果：
上一章：【从 0 到 1 落地】机器学习实操项目目录：覆盖入门到进阶，大学生就业 / 竞赛必备
下一章：
机器学习核心知识点目录：机器学习核心知识点目录
机器学习实战项目：【从 0 到 1 落地】机器学习实操项目目录：覆盖入门到进阶，大学生就业 / 竞赛必备
---持续更新 四(91-))
 丰富的序列)
