数据分析与应用

谁践踏了优雅 2024-04-18 09:33 77阅读 0赞

Numpy数值计算基础

# 创建数组并且查看数组属性
    import numpy as np
    # 创建一维数组
    arr1=np.array([1,2,3,4])
    print('创建数组为：',arr1)

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

# 查看数组的维度
    print('数组维度为:',arr2.shape)

# 查看数组的类型
    print('数组类型:',arr2.dtype)

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

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

<table> 
 <tbody> 
  <tr> 
   <td># 数组arr1只有一行元素，因此它是以为数组。而数组arr2有3行4列元素，因此它是二维数组<br> # 其中第0轴的长度为3（即行数），第1轴的长度为4（即列数）。还可以通过修改数组的shape属性，在保持数组元素个数不变的情况下改变数组每个轴的长度<br> # 将数组arr2的shape改为(4,3)，注意，从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素的顺序并没有改变</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <tbody> 
  <tr> 
   <td># 上面的例子都是先创建一个python序列，然后通过array函数将其转换为数组，这样做的效率显然不高，因此numpy提供了很多专门用来创建数组的函数<br> # arange函数类似于python自带的函数range，通过指定开始值，终值和步长来创建一维数组，创建数组不含终值</td> 
  </tr> 
 </tbody> 
</table>

# 开始值，终值和步长
    print('使用arange函数创建的数组为:',np.arange(0,1,0.1))

# linspace 函数通过指定开始值，终值和元素个数来创建一维数组，默认设置包括终值
    # 这一点需要和arange函数区分
    # 使用linspace函数创建数组
    print("使用linspace函数创建的数组为:",np.linspace(0,1,12))

# logspace 函数和linspace 函数类似，它创建的是等比例数列，生成1(10^0)~100(10^2)
    print('使用logspace 函数创建的数列为:',np.logspace(0,2,20))

# 生成2行3列
    print('使用zeros函数创建的数组为:',np.zeros((2,3)))

# eye函数用来生成主对角线上的元素为1，其他的元素为0的数组，类似单位矩阵
    # 使用eye函数创建数组
    print('使用eye函数创建的数组为:',np.eye(3))

# diag 函数创建类似对焦的数组，即使对焦吸纳意外的其他元素都为0，对角线上的元素可以是0或者是其他值
    print("使用diag函数创建的数组为:",np.diag([1,2,3,4]))

# ones函数用力啊创建元素全部为1的数组，即使创建的数组元素全部填充为1
    print("使用ones函数创建的数组为:",np.ones((5,3)))

# 数组数据类型转换
    
    # 整型转换为浮点型
    print('转换结果为:',np.float64(42))
    
    # 浮点型转换为整型
    print('转换结果为:',np.int8(42.0))
    
    # 整型转换为布尔型
    print('转换结果为:',np.bool(42))
    
    # 整型转换为布尔型
    print('转换结果为:',np.bool(0))
    
    # 布尔型转换为浮点型
    print('转换结果为:',np.float(True))
    
    # 布尔型转换为浮点型
    print('转换结果为:',np.float(False))

# 为了帮助读者更好的理解数据结构，下面创建一个存储餐饮企业库存信息的数据类型
    # 用一个能存储40个字符的字符串来记录商品的名称，用一个64位的整数来记录商品的库存数量，最后一个用64位的单精度浮点数来记录商品的价格，具体步骤如下
    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.720)],dtype=df)
    print('自定义数据为:',itemz)
    
    # 生成随机数
    print('生成的随机数组为:',np.random.random(100))
    
    # rand函数可以生成服从均匀分布的随机数
    print('生成的随机数组为:',np.random.rand(10,5))
    
    # randn函数可以生成服从正态分布的随机数
    print('生成的随机数组为:',np.random.randn(10,5))
    
    # randint 函数可以生成给定上下限范围的随机数
    np.random.randint(low,high=none,size=none,dtype='1')
    
    # 生成给定上下限范围的随机数
    # 返回值为最小值不低于2，最大值不高于10的2行5列数组
    print('生成的随机数组为:',np.random.randint(2,10,size=[2,5]))
    
    # 通过索引访问数组
    arr=np.arange(10)
    print(arr)
    # 用整数作为下标可以获取数组中的某个元素
    print("索引结果为:",arr[5])
    
    # 用范围作为下标获取数组的一个切片，包括arr[3],不包括arr[5]
    print('索引结果为:',arr[3:5])
    
    # 省略开始下标，表示从arr[0]开始
    print("索引结果为:",arr[:5])
    
    # 下标可以使用负数，-1表示从数组最后往前的第一个元素
    print("索引结果为:",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)
    
    # 索引第0行中第3和第4列的元素
    print('索引结果为:',arr[0,3:5])
    
    # 索引第2行和3行中第3-5列的元素
    print('索引结果为:',arr[1:,2:])
    
    # 索引第2列的元素
    print('索引结果为:',arr[:,2])
    
    
    # 使用整数函数和布尔值索引访问多维数组
    # 从两个序列的对应位置取出两个整数来组成下标：arr[0,1],arr[1,2],arr[2,3]
    print(arr)
    print('索引结果为:',arr[[(0,1,2),(1,2,3)]])
    
    # mask是一个布尔数组，它索引的第1，3行中的第2列的元素
    mask=np.array([1,0,1],dtype=np.bool)
    print('索引结果为:',arr[mask,2])
    
    # 变换数组的形态
    # 创建一维数组
    arr=np.arange(12)
    print(arr)
    
    # 设置数组的形状
    print('新的一维数组的形状',arr.reshape(3,4))
    
    # 查看数组的维度
    print('数组的维度:',arr.reshape(3,4).ndim)
    
    # 在numpy中，可以使用ravel函数完成数组展平工作
    arr=np.arange(12).reshape(3,4)
    print(arr)
    
    # 数组展平后
    print('数组展平后:',arr.ravel())
    
    
    # flatten 函数展平数组
    # 横向展平
    print("数组展平为:",arr.flatten())

# 除了可以改变数组“形状”外，numpy也可以对数组进行组合。组合主要有横向组合与纵向组合
    # 读者可以使用hstack函数，vstack函数以及concatenate函数来完成数组的组合。下面将对数组组合常用的函数进行介绍
    # 横向组合是将ndarray对象构成的元组作为参数，传给htsack函数
    arr1=np.arange(12).reshape(3,4)
    print(arr1)
    
    arr2=arr1*3
    print('创建的数组2为:',arr2)
    
    # 使用hstack函数横向组合
    print('横向组合为:',np.hstack((arr1,arr2)))
    
    # 纵向组合同样是将ndarray对象构成的元组作为参数，只不过传给vstack函数
    print('纵向组合为:',np.vstack((arr1,arr2)))
    
    # concatenate函数也可以实现数组的横向组合和纵向组合，其中参数axis=1时按照横轴组合，参数axis=0时按照纵轴组合
    # 使用concatenate函数横向组合
    print('横向组合为:',np.concatenate((arr1,arr2),axis=1))
    
    # 使用concatenate函数纵向组合
    print('纵向组合为:',np.concatenate((arr1,arr2),axis=0))
    
    # 以上介绍了对数组进行横向和纵向的组合。除此之外，还可以对数组进行分割。numpy提供了hsplit vsplit dsplit split函数
    # 可以将数组分割成相同大小的子数组 也可以指定原数组中需要分割的位置
    
    # 使用hsplit函数实现数组横向分割
    arr=np.arange(16).reshape(4,4)
    print(arr)
    
    # 使用hsplit函数实现数组横向分割
    print('横向分割为:',np.hsplit(arr1,2))
    
    # 使用vsplit函数可以对实现数组进行纵向分割，以对ndarray对象构成的元组作为参数
    # split函数同样可以实现数组分割。在参数axis=1时，可以进行横向分割，在参数axis=0时，可以进行纵向分割
    
    # 使用vsplit函数纵向分割
    print('纵向分割为:',np.vsplit(arr,2))
    
    # 使用split函数分割数组
    print('横向分割:',np.split(arr,2,axis=1))
    
    # 使用split函数分割数组
    print('纵向分割:',np.split(arr,2,axis=0))

# 任务2.2 掌握numpy矩阵与通用函数
    # 使用mat函数与matrix函数创建矩阵
    # 导入numpy库
    import numpy as np
    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)
    
    # 很多时候会根据小的矩阵创建大的矩阵，即将小矩阵组合成大的矩阵。在numpy中，可以使用bmat分块矩阵(block matrix)函数实现
    arr1=np.eye(3)
    print('创建的数组1为:',arr1)
    
    arr2=3*arr1
    print('创建的数组2为:',arr2)
    
    # 在numpy中，矩阵计算是只能对整个矩阵中的每个元素进行的。在使用for循环相比。其在预决算速度上更快
    # 创建矩阵
    matr1=np.mat("1 2 3;4 5 6;7 8 9")
    print('创建的矩阵为:',matr1)
    
    # 矩阵与数相乘
    matr2=matr1*3
    print('创建的矩阵为:',matr2)
    
    
    # 矩阵相加2
    print('矩阵相加结果为:',matr1+matr2)
    
    # 矩阵相减
    print('矩阵相加结果为:',matr2-matr1)
    
    # 矩阵相乘结果
    print('矩阵相乘结果为:',np.multiply(matr1,matr2))
    
    # 查看矩阵属性
    print('矩阵转置结果为:',matr1.T)
    
    # 共轭转置（实数的共轭就是其本身）
    print('矩阵共轭转置结果为:',matr1.H)
    
    # 逆矩阵
    print('矩阵的逆矩阵结果为:',matr1.I)
    
    # 返回二位数组的视图
    print('矩阵的二维数组结果为:',matr1.A)
    
    # 掌握ufunc函数
    # ufunc函数全称为通用函数，是一种能够对数组中的所有元素和进行操作的函数
    # ufunc函数是针对数组进行操作的，并且都以Numpy数组作为输出，因此不需要对数组中的每一个元素都进行操作。对一个数组进行重复运算时，使用ufunc函数
    # 比使用math库中的函数效率要高很多
    
    
    # 常用的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)
    
    
    # ufunc中也可以用完整的比较运算:>、<、==、>=、<=、!= 比较运算返回的结果是一个布尔数组
    # 其中每个元素为数组对应元素的比较结果
    print('数组比较结果为:',x<y)
    
    print('数组比较结果为:',x>y)
    
    print('数组比较结果为:',x==y)
    
    print('数组比较结果为:',x!=y)
    
    print('数组比较结果为:',x<=y)
    
    print('数组比较结果为:',x>=y)
    
    
    # np.all()表示逻辑and
    print('数组逻辑运算结果为:',np.all(x==y))
    
    # np.any()表示逻辑or
    print('数组逻辑运算结果为:',np.all(x==y))
    
    # ufunc的广播机制
    # 一维数组的广播机制
    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的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('数组相加结果为:',arr1+arr2)

#二进制存储
    import numpy as np
    # 多个数组存储
    arr1=np.array([[1,2,3],[4,5,6]])
    arr2=np.arange(0,1.0,0.1)
    np.savez('arr',arr1,arr2)
    
    print('保存的数组2为:',arr2)
    
    # 读取二进制的时候可以使用load函数，用文件名作为参数
    loaded_data=np.load("arr.npz")
    print("读取的数组为:",loaded_data)
    
    arr=np.arange(0,12,0.5).reshape(4,-1)
    print("创建的数组为:",arr)
    np.savetxt('hhd.txt',arr,fmt="%d",delimiter=",")
    loaded_data=np.loadtxt('hhd.txt',delimiter=",")
    print("读取的数组为:",loaded_data)
    
    loaded_data = np.genfromtxt("hhd.txt",delimiter=",")
    print('读取的数组为:',loaded_data)
    
    # 排序
    # 设置随机种子
    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))
    print('创建的数组为:',arr)
    
    arr.sort()
    print("排序后数组为:",arr)
    
    # 沿着横轴排序
    arr.sort(axis=0)
    print("排序后数组为:",arr)
    
    # 沿着纵轴排序
    arr.sort(axis=1)
    print("排序后数组为:",arr)
    
    # 使用argsort函数和lexsort函数，可以在给定一个或者多个键时，得到一个由整数构成的索引数组，索引值
    # 表示数据在新的序列中的位置
    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])
    # lexsort函数只能接收一个参数,即(a,b,c)
    d=np.lexsort((a,b,c))
    print("排序后数组为:",list(zip(a[d],b[d],c[d])))
    
    # 使用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])
    # lexsort函数只能接收一个参数,即(a,b,c)
    d=np.lexsort((a,b,c))
    print("排序后数组为:",list(zip(a[d],b[d],c[d])))
    
    # 使用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])
    # lexsort函数只能接收一个参数,即(a,b,c)
    d=np.lexsort((a,b,c))
    print("排序后数组为:",list(zip(a[d],b[d],c[d])))
    
    print("去重的数组为:",np.unique(names))
    
    # 跟np.unique等价的python代码实现过程
    print('去重后的数组为:',sorted(set(names)))
    
    
    ints=np.array([1,2,3,4,4,5,6,6,7,8,8,9,10])
    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))

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)