NumPy数值计算基础

Author:龙箬
数据科学与大数据技术专业 理工男
用数据改变世界！
CSDN@weixin_43975035
“我可以怀疑一切，但我却不能怀疑我正在怀疑。”

掌握Numpy数组对象ndarray

创建数组对象

NumPy 提供的array函数可以创建一维或多维数组，基本使用语法如下：

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

创建数组并查看数组属性：

import numpy as np
arr1=np.array([1,2,3,4])
print('创建的数组为：',arr1)

#创建二维数组
arr2=np.array([[1,2,3,4],[5,6,7,8],[8,10,11,12]])
print('创建的数组为：\n',arr2)

print('数组维度为：',arr2.shape)#查看数组结构

print('数组类型为：',arr2.dtype)#查看数组类型

print('数组元素个数为：',arr2.size)#查看数组元素个数

print('数组每个元素大小为：',arr2.itemsize)#查看数组每个元素大小

重新设置数组的shape属性：

arr2.shape=4,3 #重新设置shape
print('重新设置shape后的arr2为：',arr2)

使用arange函数创建数组：

print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1))

使用linspace函数创建数组：

print('使用linspace函数创建的数组为：\n',np.linspace(0,1,12))

使用logspace函数创建等比数列：

print('使用logspace函数创建的数列为：\n',np.logspace(0,2,20))

使用zeros函数创建数组：

print('使用zeros函数创建的数组为：\n',np.zeros((2,3)))

使用eye函数创建数组：

print('使用eye函数创建的数组为：\n',np.eye((3)))

使用diag函数创建数组：

print('使用diag函数创建的数组为：\n',np.diag(([1,2,3,4])))

print('使用diag函数创建的数组为：\n',np.diag(([1,2,3,4,5]),k=-1))

使用ones函数创建数组：

print('使用ones函数创建的数组为：\n',np.ones((5,3)))

数组数据类型转换：

print('转换结果为：',np.float(42))#整型转换成浮点型

print('转换结果为：',np.int8(42.0))#浮点型转换成整型

print('转换结果为：',np.bool(42))#整型转换成布尔型

print('转换结果为：',np.bool(0))#整型转换成布尔型

print('转换结果为：',np.float(True))#布尔型转换成浮点型

print('转换结果为：',np.float(False))#布尔型转换成浮点型

创建数据类型：

df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
print('数据类型为：',df)

查看数据类型：

print('数据类型为：',df["name"])

print('数据类型为：',np.dtype(df["name"]))

自定义数据类型：

itemz=np.array([("tomatoes",42,4.14),("cabbages",13,1.72)],dtype=df)
print('自定义数据为：',itemz)

生成随机数

print('生成随机数组为：',np.random.random(100))

生成服从均匀分布的随机数：

print('生成随机数组为：',np.random.rand(10,5))#生成服从均匀分布的随机数

生成服从正态分布的随机数：

print('生成随机数组为：',np.random.randn(10,5))#生成服从正态分布的随机数

randint函数可以生成给定上下限范围的随机数，其格式如下：

numpy.random.randint(low, high=None, size=None, dtype='1')

生成给定上下限范围的随机数：

print('生成随机数组为：',np.random.randint(2,10,size=[2,5]))#生成给定上下限范围的随机数

通过索引访问数组

使用索引访问一维数组：

arr=np.arange(10)
print('索引结果为：',arr[5])#用整数作为下标可以获取数组中的某个元素

print('索引结果为：',arr[3:5])#用范围作为下标获取数组的一个切片，包括arr[3],不包括arr[5]

print('索引结果为：',arr[:5])#省略开始下标，表示从arr[0]开始

#下标可以用负数，-1表示从数组最后往前数的第一个元素
print('索引结果为：',arr[-2],arr[-1])

arr[2:4]=100,101
print('索引结果为：',arr)#下标还可以用来修改元素

#范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：',arr[1:-1:2])

print('索引结果为：',arr[5:1:-2])#步长为负数时，开始下标必须大于结束下标

使用索引访问多维数组：

arr=np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])
print('创建的的二维数组为：',arr)

print('索引结果为：',arr[0,3:5])#索引第0行中第3列和第4列的元素

print('索引结果为：',arr[1:,2:])#索引第2行和第3行中第3-5列的元素

print('索引结果为：',arr[:,2])#索引第2列的元素

使用整数函数和布尔值索引访问多维数组：

#从两个序列的对应位置取出两个整数来组成下标：arr[0,1]，arr[1,2]，arr[2,3]
print('索引结果为：',arr[0,1],arr[1,2],arr[2,3])
print('索引结果为：',arr[[0,1,2],[1,2,3]])

print('索引结果为：',arr[1:,(0,2,3)])#索引第2、3行中第0，2，3列的元素

mask=np.array([1,0,1],dtype=np.bool)
#mask是一个布尔数组，它索引第1，3行中第二列的元素
print('索引结果为：',arr[mask,2])

变换数组的形态

arr=np.arange(12)#创建一维数组
print('创建一维数组为：',arr)

print('新的一维数组为：',arr.reshape(3,4))#设置一维数组的形状

print('数组维度为：',arr.reshape(3,4).ndim)#查看数组维度

使用ravel函数展平数组：

arr=np.arange(12).reshape(3,4)
print('创建的二维数组为：',arr)

print('数据展平后为：',arr.ravel())

使用flatten函数展平数组：

print('数据展平后为：',arr.flatten())#横向展平

print('数据展平后为：',arr.flatten('F'))#纵向展平

使用hstack函数实现数组横向组合：

arr1=np.arange(12).reshape(3,4)
print('创建的数组1为：',arr1)

arr2=arr1*3
print('创建的数组2为：',arr2)

print('横向组合为：',np.hstack((arr1,arr2)))#使用hstack函数横向组合

使用vstack函数实现数组横向组合：

print('纵向组合为：',np.vstack((arr1,arr2)))#使用vstack函数横向组合

使用concatenate函数组合数组：

#使用concatenate函数横向组合
print('横向组合为：',np.concatenate((arr1,arr2),axis=1))#使用concatenate函数横向组合

#使用concatenate函数纵向组合
print('纵向组合为：',np.concatenate((arr1,arr2),axis=0))#使用concatenate函数纵向组合

使用hsplit函数实现数组横向分割：

arr=np.arange(16).reshape(4,4)
print('创建的二维数组为：',arr)

print('横向分割为：',np.hsplit(arr,2))#使用hsplit函数横向分割

使用vsplit函数实现数组纵向分割：

print('纵向分割为：',np.vsplit(arr,2))#使用vsplit函数纵向分割

使用split函数分割数组：

print('横向分割为：',np.split(arr,2,axis=1))#使用split函数横向分割

print('纵向分割为：',np.split(arr,2,axis=0))#使用split函数纵向分割

掌握Numpy矩阵与通用函数

创建Numpy矩阵

使用mat函数与matrix函数创建矩阵：

import numpy as np #导入NumPy库
matr1=np.mat("1,2,3;4,5,6;7,8,9")
print("输出矩阵为：",matr1)

matr2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
print("创建的矩阵为：",matr2)

使用bmat函数创建矩阵：

arr1=np.eye(3)
print('创建的数组1为：',arr1)

arr2=arr1*3
print('创建的数组2为：',arr2)

print('创建的矩阵为：',np.bmat("arr1 arr2;arr1 arr2"))

矩阵运算：

matr1=np.mat("1,2,3;4,5,6;7,8,9")#创建矩阵
print("创建的矩阵为：",matr1)

matr2=matr1*3#矩阵与数相乘
print("创建的矩阵为：",matr2)

print("矩阵相加结果为：",matr2+matr1)#矩阵相加

print("矩阵相减结果为：",matr2-matr1)#矩阵相减

print("矩阵相乘结果为：",matr2*matr1)#矩阵相乘

print("矩阵对应元素相乘结果为：",np.multiply(matr2,matr1))

查看矩阵属性：

print('矩阵转置结果为：',matr1.T)#转置

print('矩阵共轭转置结果为：',matr1.H)#共轭转置（实数的共轭就是其本身）

print('矩阵的逆矩阵结果为：',matr1.I)#逆矩阵

print('矩阵的二维数组结果为：',matr1.A)#返回二维数组的视图

ufunc函数

数组的四则运算：

x=np.array([1,2,3])
y=np.array([4,5,6])
print('数组相加的结果为：',x+y)#数组相加

print('数组相减的结果为：',x-y)#数组相减

print('数组相乘的结果为：',x*y)#数组相乘

print('数组相除的结果为：',x/y)#数组相除

print('数组幂运算的结果为：',x**y)#数组幂运算

数组的比较运算：

x=np.array([1,3,5])
y=np.array([2,3,4])
print('数组比较结果为：',x<y)

print('数组比较结果为：',x>y)

print('数组比较结果为：',x==y)

print('数组比较结果为：',x>=y)

print('数组比较结果为：',x<=y)

print('数组比较结果为：',x!=y)

数组的逻辑运算：

print('数组逻辑运算结果为：',np.all(x==y))#np.all()表示逻辑and

print('数组逻辑运算结果为：',np.any(x==y))#np.any()表示逻辑or

一维数组的广播机制：

arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：',arr1)

print('数组1的shape为：',arr1.shape)

arr2=np.array([1,2,3])
print('创建的数组2为：',arr2)

print('数组2的shape为：',arr2.shape)

print('数组相加结果为：',arr1+arr2)

二维数组的广播机制：

arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：',arr1)

print('数组1的shape为：',arr1.shape)

arr2=np.array([1,2,3,4]).reshape((4,1))
print('创建的数组2为：',arr2)

print('数组2的shape为：',arr2.shape)

print('数组相加结果为：',arr1+arr2)

利用Numpy进行统计分析

读/写文件

二进制数据存储：

import numpy as np
arr=np.arange(100).reshape(10,10)#创建一个数组
np.save("D:\\pythonProject\\save_arr",arr)#保存数组
print('保存的数组为：\n',arr)

多个数组存储：

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1.0,0.1)
np.savez("D:\\pythonProject\\savez_arr",arr1,arr2)
print('保存的数组1为：',arr1)
print('保存的数组2为：',arr2)

二进制文件读取：

loaded_data=np.load("D:\\pythonProject\\save_arr.npy")#读取含有单个数组的文件
print('读取的数组为：\n',loaded_data)

#读取含有多个数组的文件
loaded_data1=np.load("D:\\pythonProject\\savez_arr.npz")
print('读取的数组1为：',loaded_data1['arr_0'])

print('读取的数组2为：',loaded_data1['arr_1'])

文件存储与读取：

arr=np.arange(0,12,0.5).reshape(4,-1)
print('创建的数组为：',arr)

#fmt="%d"表示保存的整数
np.savetxt("D:\\pythonProject\\arr.txt",arr,fmt="%d",delimiter=",")
#读入时也需要指定逗号分隔
loadad_data=np.loadtxt("D:\\pythonProject\\arr.txt",delimiter=",")
print("读取的数组为：",loadad_data)

使用genfromtxt函数读取数组：

loadad_data=np.genfromtxt("D:\\pythonProject\\arr.txt",delimiter=",")
print("读取的数组为：",loadad_data)

使用函数进行简单的统计分析

使用sort函数进行排序：

np.random.seed(42)#设置随机种子
arr=np.random.randint(1,10,size=10)#生成随机数组
print('创建的数组为：',arr)

arr.sort()#直接排序
print('排序后数组为：',arr)

arr=np.random.randint(1,10,size=(3,3))#生成3行3列的随机数组
print('创建的数组：',arr)

arr.sort(axis=1)#沿着横轴排序
print("排序后数组为：",arr

arr.sort(axis=0)#沿着纵轴排序
print("排序后数组为：",arr

使用argsort函数进行排序：

arr=np.array([2,3,6,8,0,7])
print("创建的数组为：",arr)

print("排序后数组为：",arr.argsort())#返回值为重新排序值的的下标

使用lexsort函数进行排序：

a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
d=np.lexsort((a,b,c))#lexsort函数只接受一个参数，即(a,b,c)
#多个键值排序时是按照最后一个传入数据计算的
print('排序后的数组为：',list(zip(a[d],b[d],c[d])))

数组内数据去重：

names=np.array(['小明','小黄','小花','小明','小花','小兰','小白'])
print("创建的数组为：",names)

print("去重后的数组为：",np.unique(names))

#和np.unique等价的Python代码实现过程
print('去重的数组为：',sorted(set(names)))

ints=np.array([1,2,3,4,5,6,7,8,8,9,10])#创建数值型数据
print('创建的数组为：',ints)

print("去重后的数组为：",np.unique(ints))

使用tile函数实现数据重复：

arr=np.arange(5)
print('创建的数组为：',arr)

print("重复后的数组为：",np.tile(arr,3))#对数组进行重复

使用repeat函数实现数据重复：

np.random.seed(42)#设置随机种子
arr=np.random.randint(0,10,size=(3,3))
print('创建的数组为：',arr)

print("重复后数组为：",arr.repeat(2,axis=0))#按行进行元素重复

print("重复后数组为：",arr.repeat(2,axis=1))#按列进行元素重复

Numpy中常用统计函数的使用：

arr=np.arange(20).reshape(4,5)
print('创建的数组为：',arr)

print('数组的和为：',np.sum(arr))#计算数组的和

print('数组纵轴的和为：',arr.sum(axis=0))#沿着纵轴求和

print('数组横轴的和为：',arr.sum(axis=1))#沿着横轴求和

print('数组的均值为：',np.mean(arr))#计算数组均值

print('数组纵轴的均值为：',arr.mean(axis=0))#沿着纵轴计算数组均值

print('数组横轴的均值为：',arr.mean(axis=1))#沿着横轴计算数组均值

print('数组的标准差为：',np.std(arr))#计算数组标准差

print('数组的方差为：',np.var(arr))#计算数组方差

print('数组的最小值为：',np.min(arr))#计算数组最小值

print('数组的最大值为：',np.max(arr))#计算数组最大值

print('数组的最小元素索引为：',np.argmin(arr))#返回数组最小元素的索引

print('数组的最大元素索引为：',np.argmax(arr))#返回数组最大元素的索引

cumsum函数和cumprod函数的使用：

arr=np.arange(2,10)
print('创建的数组为：',arr)

print('数组元素的累计和为：',np.cumsum(arr))#计算所有元素的累计和

print('数组元素的累计积为：',np.cumprod(arr))#计算所有元素的累计积

任务实现

读取iris数据集中的花萼长度数据（已保存CSV格式），并对其进行统计分析

iris_sepal_length=np.loadtxt("D:\\pythonProject\\iris_sepal_length.csv",delimiter=",")#读取文件
print('花萼长度表为：',iris_sepal_length)

iris_sepal_length.sort()#对数据进行排序
print('排序后的花萼长度表为：',iris_sepal_length)

#去除重复值
print('去重后的花萼长度表为：',np.unique(iris_sepal_length))

print('花萼长度表的总和为：',np.sum(iris_sepal_length))#计算数组总和

#计算所有元素的累计和
print('花萼长度表的累计和为：',np.cumsum(iris_sepal_length))

print('花萼长度表的均值为：',np.mean(iris_sepal_length))#计算数组均值

#计算数组标准差
print('花萼长度表的标准差为：',np.std(iris_sepal_length))

print('花萼长度表的方差为：',np.var(iris_sepal_length))#计算数组方差

print('花萼长度表的最小值为：',np.min(iris_sepal_length))#计算最小值

print('花萼长度表的最大值为：',np.max(iris_sepal_length))#计算最大值

课后操作题

生成范围在0~1、服从均匀分布的10行5列的数组：

import numpy as np
arr=np.random.rand(10,5)
print(arr)

生成2*2矩阵，并计算矩阵乘积

import numpy as np
matr1 = np.mat("8 3; 6 5")
matr1

matr2 = np.mat("2 6; 4 8")
matr2

# 矩阵相乘
matr1 * matr2

课后实训：创建一个国际象棋的棋盘

import numpy as np
#创建一个数值范围为0~1，间隔为0.01的数组
arr1=np.arange(0,1,0.01)
print("arange函数创建的数值范围为0~1间隔为0.01的数组arr1为：\n",arr1)
#创建由100个服从正态分布的随机数构成的数组
arr2=np.random.randn(100)
print('生成的随机数组arr2为：\n',arr2)
#对创建的两个数组进行四则运算
print('arr1 + arr2：\n',arr1+arr2)
print('arrl-arr2：\n',arr1-arr2)
print('arrl*arr2：\n',arr1*arr2)
print('arrl/arr2：\n',arr1/arr2)
#print('arrl**arr2：\n',arr1**arr2)
#对创建的数组进行简单的统计分析
print('正态分布数数组的累计和为：\n',np.cumsum(arr2))#计算所有元素的累计和
print('正态分布数去重后的值组为：\n',np.unique(arr2))#去除重复值
print('正态分布数组的均值为：',np.mean(arr2))#计算数组均值
print('正态分布数组的标准差为:',np.std(arr2))#计算数组标准差
print('正态分布数组的方差为：',np.var(arr2))#计算数组方差
print('正态分布数组的最小值为:',np.min(arr2))#计算最小值
print('正态分布数组的最大值为：',np.max(arr2))#计算最大值
print('正态分布数组的总和为：',np.sum(arr2))#计算数组总和

本代码来自于《Python数据分析与应用》
如有侵权，请联系侵删
需要本实验源数据的小伙伴请联系作者或联系QQ:2225872659