Python——numpy数值计算

数组对象

数组创建

(1) array() 函数创建数组

#array(object[,dtype=None,copy=True,order='K',subok=False,ndmin=0])
import numpy as np
a_arr=np.array([1,2,3,4,5,6])
b_arr=np.array([[1,2,3],[4,5,6]])
c_arr=np.array((1,2,3,4,5,6))
d_arr=np.array('Python')
e_arr=np.array({'Alice':95,'Beth':85,'Emily':65,'Tom':75})
print(a_arr)
print(b_arr)
print(c_arr)
print(d_arr)
print(e_arr)
#dtype可查看数据类型
#copy是拷贝权限，可复制则创建副本，指向不同的内存地址，不可复制则指向相同的地址
#subok是拷贝后的类型，Ture则类型一致（矩阵复制后仍然是矩阵）。
#ndmin是数组维数

(2) arange() 函数创建等差数组

#np.arange([start,]end,[step,]dtype=None)
import numpy as np 
a_arr=np.arange(1,10,2)
b_arr=np.arange(1,10,1.5)
print(a_arr)
print(b_arr)

(3) zeros() 函数创建全为零的数组

#np.zeros(shape[,dtype=float,order='C'])
import numpy as np 
a_arr=np.zeros(5)
b_arr=np.zeros((2,4),dtype=int)
c_arr=np.zeros((2,4,3))
print(a_arr)
print(b_arr)
print(c_arr)

(4) ones() 函数创建全为1的数组

#np.ones(shape[,dtype=float,order='C'])
import numpy as np 
a_arr=np.ones(5,complex)
b_arr=np.ones((2,4),int)
print(a_arr)
print(b_arr)

(5) empty() 函数创建空数组

#np.empty(shape[,dtype=float,order='C'])
import numpy as np 
a_arr=np.empty(5)
b_arr=np.empty((2,4),int)
print(a_arr)
print(b_arr)

(6) linspace() 函数创建等差数组

#np.linspace(start,end,num=50,endpoint=True,retstep=False,dtype=None)
#retstep为是否显示间距
#endpoint为是否包含结束点
import numpy as np 
a_arr=np.linspace(1,20)
b_arr=np.linspace(1,20,num=5,endpoint=False,retstep=True)
print(a_arr)
print(b_arr)

(7) logspace() 函数创建等比数组

#np.logspace(start,end,num=50,endpoint=True,base=10.0,dtype=None)
import numpy as np 
a_arr=np.logspace(10,100,10)
b_arr=np.logspace(2,4,3,base=2)
print(a_arr)
print(b_arr)

(8)创建随机数组

#rand()产生均匀分布的样本值
#np.random.rand(d0,d1,d2,...,dn)
import numpy as np 
a_arr=np.random.rand()#[0,1)随机数
b_arr=np.random.rand(2,3)#创建2*3数组
print(a_arr)
print(b_arr)

#randint()从指定的整数范围内随机抽取整数
#np.random.randint(low,high=None,size=None,dtype='1')
import numpy as np 
a_arr=np.random.randint(100) #[0,100)随机数
b_arr=np.random.randint(1,10,size=(2,5)) #创建2*5数组
print(a_arr)
print(b_arr)

#randn()从标准正态分布中随机抽取样本
#np.random.randn(d0,d1,d2,...,dn)
import numpy as np 
a_arr=np.random.randn()#[0,1)随机数
b_arr=np.random.randn(2,3)#创建2*3数组
print(a_arr)
print(b_arr)

#random()从指定的整数范围内随机抽取整数
#np.random.random((d0,d1,d2,...,dn))
import numpy as np 
a_arr=np.random.random()#[0,1)随机数
b_arr=np.random.random(2,3)#创建2*3数组
print(a_arr)
print(b_arr)

#seed()随机数种子

#permutation()对一个序列随机排序，不改变原数组

#shuffle()对一个序列随机排序，改变原数组

#uniform(low,high,size)创建一个从均匀分布[low，high)中随机采样，采样个数为size的数组
#np.random.uniform(low,high,size),low默认0.0，high默认1.0；size为整型或整型元组，表示数组维度大小。
import numpy as np 
a_arr=np.random.uniform(size=5)#[0,1)随机数
b_arr=np.random.uniform(1,10,size=(2,5))#创建2*3数组
print(a_arr)
print(b_arr)

#normal(loc,scale,size)创建一个以loc为均值，以scale为标准差，形状为size的数组
#np.random.normal(loc,scale,size)
import numpy as np 
a_arr=np.random.normal()
b_arr=np.random.normal(1,10,size=(2,5))#创建2*3数组
print(a_arr)
print(b_arr)

#possion(lam,size)创建一个具有泊松分布的数组，lam表示随机事件发生的概率，形状为size，

数组属性

import numpy as np
a_arr=np.array([[1,2,3],[4,5,6.0]])
print("a_arr:\n",a_arr)
print(" 数组轴的个数： ",a_arr.ndim)
print(" 数组的维度： ",a_arr.shape)
print(" 数组元素个数： ",a_arr.size)
print(" 数组元素类型： ",a_arr.dtype)
print(" 数组元素字节大小： ",a_arr.itemsize)

数组基本操作

数组重塑

#reshape()不改变原数组的数据重塑数组的形状
#np.reshape(array,newshape,order='C')
import numpy as np
a_arr=np.arange(12)
print('a_arr数组为:',a_arr)
#重塑
b_arr=a_arr.reshape(3,4)
print('b_arr数组为:',b_arr)
print('a_arr数组的维度为:',a_arr.ndim)
print('b_arr数组的维度为:',b_arr.ndim)

#flatten()将多维数组转换为一维数组
#ndarray.flatten(order)
import numpy as np
a_arr=np.array([[1,2,3],[4,5,6]])
print('a_arr数组为:',a_arr)
#重塑
b_arr=a_arr.flatten()
c_arr=a_arr.flatten('F')
print('重塑后a_arr数组为:',a_arr)
print('b_arr数组为:',b_arr)
print('c_arr数组为:',c_arr)
print('a_arr数组的维度为:',a_arr.ndim)
print('b_arr数组的维度为:',b_arr.ndim)
print('c_arr数组的维度为:',c_arr.ndim)

#reval()将多维数组转换为一维数组
#np.ravel(array,order)
import numpy as np
a_arr=np.array([[1,2,3],[4,5,6]])
print('a_arr数组为:',a_arr)
#重塑
b_arr=np.ravel(a_arr)
print('重塑后a_arr数组为:',a_arr)
print('b_arr数组为:',b_arr)
b_arr[0]=100
print('重塑修改后后a_arr数组为:',a_arr)
print('b_arr数组为:',b_arr)
#transpos()反转或排列数组的轴
#resize()调整数组大小

数组合并

(1)concatenate()函数

#concatenate()用于沿着指定轴组合相同形状的两个或多个数组。其一般形式为：
#concatenate((array1,array2,...,arrayn),axis),0为逐行合并，1为逐列合并
import numpy as np
a_arr=np.array([[1,2,3],[4,5,6]])
b_arr=np.array([[7,8,9],[10,11,12]])
c_arr=np.concatenate((a_arr,b_arr),0)
d_arr=np.concatenate((a_arr,b_arr),1)
print('沿轴0连接的两个数组: \n',c_arr)
print('沿轴1连接的两个数组: \n',d_arr)

(2)stack()函数

#stack((array1,array2,...),axis)用于沿新的轴合并形状相同的数组，即增加一个维度
import numpy as np
a_arr=np.array([[1,2,3],[4,5,6]])
b_arr=np.array([[7,8,9],[10,11,12]])
c_arr=np.stack((a_arr,b_arr),0)
d_arr=np.stack((a_arr,b_arr),1)
print('沿轴0连接的两个数组: \n',c_arr)
print('沿轴1连接的两个数组: \n',d_arr)

(3)hstack()和vstack()函数

import numpy as np
a_arr=np.array([[1,2,3],[4,5,6]])
b_arr=np.array([[7,8,9],[10,11,12]])
c_arr=np.hstack((a_arr,b_arr))
d_arr=np.vstack((a_arr,b_arr))
print('水平合并: \n',c_arr)
print('垂直合并: \n',d_arr)

数组分割

(1)split()
(2)hsplit()和vsplit()函数

#np.split(array,indices_or_sections,axis)
#np.hsplit(array,indices_or_sections)
#np.vsplit(array,indices_or_sections)
#indices_or_sections，对于多维数组而言是平分
import numpy as np
a_arr=np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]]) 
print('a_arr 数组为：',a_arr)
# 分割数组，参数 axis 为默认值 0，表示横向划分
b_arr=np.split(a_arr,2)  
c_arr=np.hsplit(a_arr,3) # 水平分割数组，均分为三份
d_arr=np.vsplit(a_arr,2) # 垂直分割数组，均分为两份
print('使用split()函数分割: \n',b_arr)
print('水平分割: \n',c_arr)
print('垂直分割: \n',d_arr)

数组转置

(1)T属性

import numpy as np
a_arr=np.arange(12).reshape(3,4)
print('转置前:',a_arr)
b_arr=a_arr.T
print('转置后:',format(b_arr))

(2)transpose()函数

#numpy.transpose(array,axes)
import numpy as np
a_arr=np.arange(12).reshape(3,4)
print('转置前:',a_arr)
b_arr=np.transpose(a_arr)
print('转置后:',format(b_arr))

(3)swapaxes()函数

#np.swapaxes(array,axis1.axis2)
import numpy as np
a_arr=np.arange(12).reshape(2,2,3)
print('转置前: \n',a_arr)
b_arr=np.swapaxes(a_arr,1,0)
print('转置后: \n',format(b_arr))

数组的索引和切片

一维数组的索引和切片

import numpy as np
a_arr=np.arange(0,10)
print('a_arr 数组为：',a_arr)
# 索引操作
print("a_arr[0]:",a_arr[0])
print("a_arr[-1]:",a_arr[-1])
print("a_arr[::]:",a_arr[::])
# 切片操作，从下标1开始到结束
print("a_arr[1::]",a_arr[1::])
# 切片操作，使用步长
print("a_arr[0:9:3]",a_arr[0:9:3])
# 切片操作，步长为负数
print("a_arr[9:1:-2]",a_arr[9:1:-2])

多维数组的索引和切片

import numpy as np
a_arr=np.arange(1,10).reshape(3,3)
print('a_arr数组为: \n',a_arr)
print('a_arr[0]为: \n',a_arr[0])
print('a_arr[:2]切片: \n',a_arr[:2])
print('a_arr[:2,:2]切片: \n',a_arr[:2,:2])
print('a_arr[1,1:2]切片: \n',a_arr[1,1:2])

花式索引

import numpy as np
# 创建一个简单的二维数组
arr = np.arange(1,10).reshape(3,3)
# 打印原始数组
print("Original array:",arr)
# 例子 1: 选择多个元素
row_indices = [0, 2]
col_indices = [1, 1]
selected_elements = arr[row_indices, col_indices]
print("\nSelected elements using row and column indices:",selected_elements)

# 例子 2: 选择整个行或列
selected_rows = arr[row_indices, :]
print("\nSelected rows:",selected_rows)


# 例子 3: 选择多个不连续的元素
indices = np.array([(0, 1), (2, 2)])
selected_elements = arr[indices[:, 0], indices[:, 1]]
print("\nSelected elements using multi-dimensional indexing:",selected_elements)

# 例子 4: 修改特定位置的值
new_values = np.array([10, 20])
arr[row_indices, col_indices] = new_values
print("\nArray after modification:",arr)

# 例子 5: 多维索引
print("Original array:",arr3d)
# 选择第一维的第 0 和 1 个元素，第二维的第 1 个元素，第三维的第 0 和 2 个元素
selected_3d_elements = arr3d[[0, 1], 1, [0, 2]]
print("\nSelected elements from the 3D array:",selected_3d_elements)

布尔索引

import numpy as np
# 创建一个简单的二维数组
arr = np.arange(1,10).reshape(3,3)
print("Original array:",arr)

# 例子 1: 选择大于某个阈值的元素
threshold = 4
mask = arr > threshold
print('\nbool数组',mask)
selected_elements = arr[mask]
print("\nElements greater than", threshold, ":", selected_elements)

# 例子 2: 修改满足条件的元素
arr[arr > 5] = 10
print("\nArray after modification:",arr)

# 例子 3: 选择并修改满足两个条件的元素
arr[0, arr[0] < 3] = 0
print("\nArray after modifying elements in row 0 that are less than 3:",arr)

# 例子 4: 使用多个条件
mask = (arr > 1) & (arr < 8)
selected_elements = arr[mask]
print("\nElements between 1 and 8:", selected_elements)

数组运算

矢量化运算

#矢量加法
import numpy as np
a_arr=np.arange(1,7).reshape(2,3)
b_arr=np.arange(7,13).reshape(2,3)
c_arr=a_arr+b_arr
print(c_arr)

#矢量乘法
import numpy as np
a_arr=np.array([[1],[2]])
b_arr=np.array([1,2,3])
c_arr=a_arr*b_arr
print(c_arr)

#标量与矢量运算
import numpy as np
a_arr=np.arange(1,7).reshape(2,3)
b_arr=a_arr+10
print(b_arr)

Numpy通用函数

函数	功能
abs()、fabs()	计算整数、浮点数或复数的绝对值
sqrt()	计算各元素平方根
square()	计算各元素二次方
exp()	计算各元素的e指数
log()	计算各元素的自然对数
log10()	计算各元素的10为底的对数
log2()	计算各元素的2为底的对数
log1p()	计算log(1+x)的对数
sign()	计算各元素的正负号，1为正，-1为负数，0为0
ceil()	计算各元素的”大于等于该值的最小整数“
floor()	计算各元素的”小于等于该值的最大整数“
around()	四舍五入
rint()	四舍五入
modf()	将数组的小数和整数部分以两个独立的数组的形式返回
isnan()	返回一个表示”哪些值是NaN（不是一个数）“的布尔型数组
isfinite()	返回一个表示”哪些元素是有穷的“布尔型数组
isinf()	返回一个表示”哪些元素是无穷的“布尔型数组
sin()、cos()、tan()、sinh()、cosh()、tanh()	三角函数
arcsin()、arcsos()、arctan()、arcsinh()、arccosh()、arctanh()	反三角函数

函数	描述
add()	数组中对应的元素相加
subtract()	数组中对应的元素相减
dot()	叉积，数列和矩阵对应位置相乘
multiply()	点积，矩阵对角线元素相乘，要求矩阵维度相同
*	点积，数组对应元素相乘，必要时使用广播规则
divide()	数组中对应的元素相除
floor_divide()	数组中对应的元素向下整除（含去余数）
maximum	数组中对应的元素比较取其大者，返回一个数组
minimum	数组中对应的元素比较取其小者，返回一个数组
mod()	元素级的模运算计算
copysign()	将第二个数组中的值的符号赋值给第一个数组的对应元素
greater()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 >
greater_equal()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 >=
less()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 <
less_equal()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 <=
equal()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 ==
not_equal()	数组对应元素进行比较运算，返回布尔型数组，相当于运算符 !=
logical_and()	数组对应元素进行逻辑与运算，得到布尔型数组
logical_or()	数组对应元素进行逻辑或运算，得到布尔型数组
logical_xor()	数组对应元素进行逻辑异或运算，得到布尔型数组

线性代数运算

函数	描述
dot()	计算两个数组的点积，即对应元素相乘
vdot()	计算两个向量的点积
det()	计算矩阵的行列式
solve()	求解线性方程组
inv()	计算矩阵的乘法逆矩阵
eig()	计算方阵的特征值和特征向量

数组相乘

#np.dot(ndarray,ndarray,out=None)
#vdot()计算两个数组的点积。如果第一个参数是复数，那么它的共轭复数会用于计算，如果参数是多维数组，则会被展开，在用于计算。
import numpy as np
a_arr=np.arange(1,7).reshape(2,3)
b_arr=np.arange(1,7).reshape(3,2)
c_arr=np.dot(a_arr,b_arr)
d_arr=np.vdot(a_arr,b_arr)
print(c_arr)
print(d_arr)

矩阵行列式

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

线性方程组

#np.linalg.solve(array,array)
import numpy as np
A=np.array([[1,1,1],[5,0,-1],[2,-3,-1]])
b=np.array([9,6,-9])
x=np.linalg.solve(A,b)
print('线性方程组的解为:',x)

逆矩阵

#np.linagl.inv(array)
import numpy as np
A=np.array([[1,2,3],[1,0,-1],[2,-3,-1]])
B=np.linalg.inv(A)
print(B)
print(np.dot(A,B))

特征值和特征向量

#np.linalg.eigval()
import numpy as np
A=np.array([[-1,1,0],[-4,3,0],[1,0,2]])
e=np.linalg.eigvals(A)#只接收特征值
x=np.linalg.eigvalsh(A)#直接收特征向量
y=np.linalg.eig(A)#接受特征值和特征向量
print(e)
print(x)
print(y)

Numpy数据文件的读写

二进制读写

#np.save(file,array)
#np.load(file)
import numpy as np
a_arr=np.arange(9).reshape(3,3)
np.save("C:/Users/21031/Desktop/file.npy",a_arr)
b_arr=np.load("C:/Users/21031/Desktop/file.npy")
print(b_arr)

文本文件的读写

#np.savetxt(filename,arr,fmt='%.18e',delimiter='',newline='\n')
#np.loadtxt(filename,dtype=<class 'float'>,delimiter=None,converters=None)

#delimiter为数据列之间的分隔符,newline为数据行之间的分隔符,fmt用于指定数据保存的格式。

#converters为读取数据时数据行之间的分隔符,delimiter为读取数据时数据列之间的分隔符。

import numpy as np
a_arr=np.arange(9).reshape(3,3)
np.savetxt("C:/Users/21031/Desktop/file1.txt",a_arr,delimiter=',')
b_arr=np.loadtxt("C:/Users/21031/Desktop/file1.txt",dtype="f",delimiter=",")
print(b_arr)