Python基础知识——Numpy数值计算篇

NumPy提供了一个名为ndarray的多维数组对象，该数组元素具有固定大小。即NumPy数组元素是同质的，只能存放同一种数据类型的对象。能够运用向量化运算来处理整个数组，具有较高的运算效率。

数组创建

通过array()函数创建ndarray数组

array()函数可以将Python的列表、元组、数组或其他序列类型作为参数创建ndarray数组。

import numpy as np
a1 = np.array([1, 2, 3, 4, 5, 6]) #一维列表
print("a1=",a1)

a2 = np.array([[1, 2, 3], [4, 5, 6]]) #二维列表
print("a2=",a2)

a3 = np.array('abcdf') #字符串
print("a3=",a3)

a4 = np.array((1, 2, 3)) #元组
print("a4=",a4)

a5 = np.array({'zhang':12, 'dd':45}) #字典
print("a5=",a5)

## 输出 ##
a1= [1 2 3 4 5 6]
a2= [[1 2 3]
 [4 5 6]]
a3= abcdf
a4= [1 2 3]
a5= {'zhang': 12, 'dd': 45}

创建特殊数组

NumPy提供了创建特殊数组的函数

import numpy as np
n1 = np.empty((2, 3))
print("empty()创建没有具体值的数，括号中是矩阵的大小:\n",n1)

n2 = np.zeros((3, 5))
print("zeros()创建全0数组，括号中是矩阵形状：\n",n2)

n3 = np.ones((4, 2))
print("ones()创建全1数组，括号中是矩阵形状：\n",n3)

n4 = np.eye(3)
print("eye()创建正方形的N×N单位矩阵，括号中是N的值：\n",n4)

n5 = np.ones_like(n1)
print("ones_like()创建和n1形状相同的全1数组：\n",n5)

## 输出 ##
empty()创建没有具体值的数，括号中是矩阵的大小:
 [[0. 0. 0.]
 [0. 0. 0.]]
zeros()创建全0数组，括号中是矩阵形状：
 [[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
ones()创建全1数组，括号中是矩阵形状：
 [[1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]]
eye()创建正方形的N×N单位矩阵，括号中是N的值：
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
ones_like()创建和n1形状相同的全1数组：
 [[1. 1. 1.]
 [1. 1. 1.]]

从数值范围创建数组

从数值范围创建数组的NumPy函数有3个：arange(),linspace(),logspace()；

numpy.arange(start, stop, step, dtype) #范围是左闭右开，step——步长：默认值“1”，dtype——返回ndarray数据类型，未提供，则使用输入数据的类型；

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) #生成num个等步长的样本数量，若endpoint为True，则包括stop的值，反之不包括；若retstep为True，则显示间距，反之不显示；

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None) #生成num个等步长的样本数量，若endpoint为True，则包括stop的值，反之不包括；base——对数log的底数，dtype——ndarray的数据类型。

import numpy as np
c1 = np.arange(10)
c2 = np.linspace(1, 10, 10) #等差数值
c3 = np.logspace(10, 100, 10) #等比数值
print("c1=",c1)
print("c2=",c2)
print("c3=",c3)

## 输出 ##
c1= [0 1 2 3 4 5 6 7 8 9]
c2= [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
c3= [1.e+010 1.e+020 1.e+030 1.e+040 1.e+050 1.e+060 1.e+070 1.e+080 1.e+090
 1.e+100]

使用asarray()函数创建NumPy数组

函数asarray()把Python列表、元组等转换为NumPy数组：

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

import numpy as np
d1 = [1, 2, 3, 4, 5, 6]
d2 = np.asarray(d1)
print(d2,d2.dtype)

## 输出 ##
[1 2 3 4 5 6] int32

随机数数组

在numpy.random模块中，提供了多种随机生成函数：

rand()函数，数组中的值服从[0,1)之间的均匀分布；

uniform()函数，uniform(low=0.0, high=1.0, size=None)返回一个区间在[low,high)中均匀分布的数组；

randn()函数，返回一个指定形状的数组，数组中的值服从标准正态分布（均值为0，方差为1）；

normal()函数，numpy.random.normal(loc=0.0, scale=1.0, size=None)生成一个由size指定形状的数组，数组中的值服从μ=loc,σ=scale的正态分布；

randint()函数，numpy.random.randint(low, high=None, size=None, dtype=‘1’)生成一个区间[low,high)中离散均匀抽样的数组；

numpy.random.random(size=None)，random()函数生成[0,1)之间均匀抽样的数组。

import numpy as np
a1 = np.random.rand(2, 4) #矩阵形状
print("rand()服从[0,1)之间的均匀分布：\n",a1)
print("")

a2 = np.random.uniform(size=(2, 4)) #矩阵形状，[low,high)为默认值[0,1)
b2 = np.random.uniform(3, 5, (2, 4)) #low=3, high=5
print("uniform()返回[low,high)中均匀分布的数组：\n",a2)
print(b2)
print("")

a3 = np.random.randn(2, 4) #返回指定形状的数组，数组中的值服从标准正态分布
print("randn()返回指定形状的数组，数组中的值服从标准正态分布:\n",a3)
print("")

a4 = np.random.normal(size=(2, 4))
print("normal()函数生成数组中的值服从μ=loc,σ=scale的正态分布:\n",a4)
print("")

a5 = np.random.randint(1, 10, size=(2, 4))
print("randint()函数生成一个区间[low,high)中离散均匀抽样的数组;\n",a5)
print("")

a6 = np.random.random((2, 4))
print("random()函数生成[0,1)之间均匀抽样的数组：\n",a6)

## 输出 ##
rand()服从[0,1)之间的均匀分布：
 [[0.50117497 0.09453935 0.24949911 0.35242339]
 [0.27614506 0.45828183 0.59054133 0.7599126 ]]

uniform()返回[low,high)中均匀分布的数组：
 [[0.83404081 0.29614946 0.87971516 0.68255478]
 [0.76991185 0.75489118 0.24766135 0.40941723]]
[[4.95719423 4.47697204 3.69370563 4.73220347]
 [3.72110036 3.42003985 3.35648397 3.97719674]]

randn()返回指定形状的数组，数组中的值服从标准正态分布:
 [[ 0.56189735  0.03944787  1.10676961 -0.9235279 ]
 [ 1.16715689  0.98365254 -1.48988996  1.40805524]]

normal()函数生成数组中的值服从μ=loc,σ=scale的正态分布:
 [[-0.65418483  0.25075608 -0.60689788 -0.21853615]
 [ 1.22485674 -0.82383098  0.68833713 -1.03313177]]

randint()函数生成一个区间[low,high)中离散均匀抽样的数组;
 [[4 1 2 5]
 [7 6 9 6]]

random()函数生成[0,1)之间均匀抽样的数组：
 [[0.59022693 0.06508505 0.24775246 0.30724648]
 [0.32689472 0.54365446 0.13251454 0.89979262]]

数组对象属性

import numpy as np
a = np.array([np.arange(3), np.linspace(3, 5, 3)])
print(np.arange(5).T) #一维数组的转置为自身（不改变）
print("a=",a)
print("秩，数据轴的个数:",a.ndim,"形状：", a.shape,"元素总个数：", a.size, "元素类型：",a.dtype,"每个元素的字节大小：", a.itemsize, "字节大小×数据个数：",a.nbytes)
print("数组转置：\n",a.T)
for item in a.flat: #flat迭代器遍历数组
    print(item, end=",")

## 输出 ##
[0 1 2 3 4]
a= [[0. 1. 2.]
 [3. 4. 5.]]
秩，数据轴的个数: 2 形状： (2, 3) 元素总个数： 6 元素类型： float64 每个元素的字节大小： 8 字节大小×数据个数： 48
数组转置：
 [[0. 3.]
 [1. 4.]
 [2. 5.]]
0.0,1.0,2.0,3.0,4.0,5.0,

数组数据类型

1、dtype指定数据类型
2、astype转换数据类型

import numpy as np
a = np.array([[1.1, 2.2],[3.3, 3.4]],dtype=np.float)
b = a.astype(np.int)
print('a=',a)
print('b=',b)
c = np.arange(5, dtype=np.int8)
print('c=',c)
print('c.dtype=',c.dtype)
print('数据类型转换后的dtype=',c.astype(np.float).dtype)
print('数据类型转换后的c=',c.astype(np.float))
print('c的数据类型未改变c.dtype=',c.dtype)

## 输出 ##
a= [[1.1 2.2]
 [3.3 3.4]]
b= [[1 2]
 [3 3]]
c= [0 1 2 3 4]
c.dtype= int8
数据类型转换后的dtype= float64
数据类型转换后的c= [0. 1. 2. 3. 4.]
c的数据类型未改变c.dtype= int8

数组索引与切片

数组索引

一维数组索引

import numpy as np
a = np.linspace(-10, 10, 11)
print(a)
a[0], a[1], a[2] = 100, 200, 300
print(a)

## 输出 ##
[-10.  -8.  -6.  -4.  -2.   0.   2.   4.   6.   8.  10.]
[100. 200. 300.  -4.  -2.   0.   2.   4.   6.   8.  10.]

二维数组索引

import numpy as np
a = np.arange(12).reshape(3, 4)
print('a=',a)
print('a[0]=',a[0], 'a[2]=',a[2])
print('a[0][0]=',a[0][0], 'a[0,0]=',a[0,0], 'a[1][2]=',a[1][2], 'a[1,2]=',a[1,2])
a[0] = 10
print("a[0]修改后的a",a)
a[2,0] = 1000
print("a[2,0]修改后的a",a)

## 输出 ##
a= [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
a[0]= [0 1 2 3] a[2]= [ 8  9 10 11]
a[0][0]= 0 a[0,0]= 0 a[1][2]= 6 a[1,2]= 6
a[0]修改后的a [[10 10 10 10]
 [ 4  5  6  7]
 [ 8  9 10 11]]
a[2,0]修改后的a [[  10   10   10   10]
 [   4    5    6    7]
 [1000    9   10   11]]

数组切片

一维数组切片的格式是[starting_index, ending_index, step]，step是步长，左闭右开原则，默认值为[0,1)；

多维数组按照轴方向切片，默认是0轴。

import numpy as np
#一维数组切片
a = np.arange(12)
print('a=',a)
print('a[1:3]=',a[1:3], 'a[9:]=',a[9:])
print('a[1:7:2]=',a[1:7:2])
print('a[:]=', a[:])

## 输出 ##
a= [ 0  1  2  3  4  5  6  7  8  9 10 11]
a[1:3]= [1 2] a[9:]= [ 9 10 11]
a[1:7:2]= [1 3 5]
a[:]= [ 0  1  2  3  4  5  6  7  8  9 10 11]

import numpy as np
#二维数组切片
a = np.arange(12).reshape(3, 4)
print('a=',a)
print('a[0:2][1:3]=',a[0:2][1:3], 'a[2:][:2]=',a[2:][1:2]) #都是0轴上的索引，取交集
print('a[0:2]=',a[0:2])

## 输出 ##
a= [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
a[0:2][1:3]= [[4 5 6 7]] a[2:][:2]= []
a[0:2]= [[0 1 2 3]
 [4 5 6 7]]

布尔型索引

注意：布尔数组的长度必须与目标数组对应的轴的长度一致

import numpy as np
from numpy.random import randn
name = np.array(['张','王','李','赵','钱']) #行索引
data = randn(5,3)
print(data)
print('钱对应的行：',data[name=='钱'])

## 输出 ##
[[ 2.37684956 -2.13037039 -1.63255503]
 [ 1.05606501  1.64442386 -0.48824817]
 [ 0.38975109  1.51344443  0.71365647]
 [ 0.46663813 -0.62115848 -0.03084856]
 [-0.49633786  0.34521226  0.86970657]]
钱对应的行： [[-0.49633786  0.34521226  0.86970657]]

import numpy as np
a = np.arange(12).reshape(3, 4)
print(a)
print('a>5', a>5)
print('a[a>5]', a[a>5])

## 输出 ##
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
a>5 [[False False False False]
 [False False  True  True]
 [ True  True  True  True]]
a[a>5] [ 6  7  8  9 10 11]

花式索引

通过整数列表或数组进行索引，也可以使用np.ix_()函数完成相同操作。

import numpy as np
a = np.arange(16).reshape(4, 4)
print(a)
print('花式索引1：\n', a[[0, 2, 3]][[0, 2]]) #“行”先对第一个数组进行索引，再对第二个数组进行索引
print('花式索引2：\n', a[[0, 2, 3]][:, [0, 2]]) #“行、列”
print('ix=\n', np.ix_([0, 2, 3], [0, 2]))
print('花式索引3：\n', a[np.ix_([0, 2, 3], [0, 2])])

## 输出 ##
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
花式索引1：
 [[ 0  1  2  3]
 [12 13 14 15]]
花式索引2：
 [[ 0  2]
 [ 8 10]
 [12 14]]
ix=
 (array([[0],
       [2],
       [3]]), array([[0, 2]]))
花式索引3：
 [[ 0  2]
 [ 8 10]
 [12 14]]

线性代数

数组相乘

1、dot()函数：计算两个数组的矩阵乘积；
2、vdot()函数：计算两个向量的点积。

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.dot(a, b)
d = np.vdot(a, b)
print(a)
print(b)
print('dot=', c)
print('vdot=', d)

## 输出 ##
[[1 2]
 [3 4]]
[[5 6]
 [7 8]]
dot= [[19 22]
 [43 50]]
vdot= 70

矩阵行列式

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

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.linalg.det(a)
print(b)

## 输出 ##
-2.0000000000000004

逆矩阵

numpy.linalg.inv()函数计算矩阵的乘法逆矩阵。
注意：如果矩阵是奇异的或者非方阵，使用inv()函数求逆矩阵，会出错。

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.linalg.inv(a)
print(a)
print(b)
print(np.dot(a, b))

## 输出 ##
[[1 2]
 [3 4]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]

线性方程组

numpy.linalg中的solve()函数可以求解线性方程组；
线性方程组 𝐴𝑥=𝑏 ，其中A是一个矩阵，b是一维或者二维数组，而x是未知量。
令已知的线性方程组为：𝑥+𝑦+𝑧=6 ；2𝑦+5𝑧=−4 ；2𝑥+5𝑦=27

import numpy as np
A = np.mat("1 1 1; 0 2 5; 2 5 -1");
b = np.array([6, -4, 27])
x = np.linalg.solve(A, b)
print('方程解：',x)
print(x.ndim) #维度
print(np.dot(A, x)) #验证

## 输出 ##
方程解： [ 5.  3. -2.]
1
[[ 6. -4. 27.]]

特征值和特征向量

使用numpy.linalg程序包提供的eigvals()函数和eig()函数；
其中eigvals()返回矩阵的特征向量，eig()函数返回一个元组，其元素为特征值和特征向量。

import numpy as np
A = np.mat("1 -1; 2 4")
print(A)
e = np.linalg.eigvals(A)
print('evigvals特征值：', e)
e, v = np.linalg.eig(A)
print("eig特征值：", e)
print("eig特征向量：", v)
d = v * np.diag(e) * np.linalg.inv(v) #原矩阵
print('原矩阵:', d)

## 输出 ##
[[ 1 -1]
 [ 2  4]]
evigvals特征值： [2. 3.]
eig特征值： [2. 3.]
eig特征向量： [[-0.70710678  0.4472136 ]
 [ 0.70710678 -0.89442719]]
原矩阵: [[ 1. -1.]
 [ 2.  4.]]

数组的存取

Numpy通过np.savetxt()函数对数组进行存储，通过np.loadtxt()函数对存储数组文件进行读取，并将其加载到一个数组中。

import numpy as np
a = np.arange(12).reshape(3, 4)
np.savetxt('1.txt', a)
b = np.loadtxt('1.txt')
print(b)

## 输出 ##
[[ 0.  1.  2.  3.]
 [ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]