numpy---科学计算库

最新推荐文章于 2024-11-05 15:28:12 发布

海森_

最新推荐文章于 2024-11-05 15:28:12 发布

阅读量103

点赞数

文章标签： python numpy

本文链接：https://blog.csdn.net/qq_41930594/article/details/103963395

版权

numpy —科学计算库

结构核心：
	ndarray对象：
    	内存是连续的
    	存储单一数据类型
    	多维数组
	两种存储风格：
    	C风格 ---C语言风格----按行优先存储
    	F风格 ---fortran语言风格 ----按列优先存储

数组的创建

import numpy as np

# 创建数组
# 使用列表转化数组
arr = np.array([1,2,3,4])
print("arr:\n",arr)
print("arr的类型：\n",type(arr))

# 使用arange来创建数组
# 参数1 开始位置
# 参数2 结束位置,不包含结束位置
# 参数3 步长
# 如果开始值为0，且步长为1，那么开始与步长可以省略
arr = np.arange(0, 5, 1)
arr = np.arange(5)
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# 创建等差数组
# 参数1  开始值
# 参数2  结束值,包含结束值
# 参数3  生成数组的元素的个数
arr = np.linspace(0, 5, 4)
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# 创建等比数组
# 参数1 开始值
# 参数2 结束值
# 参数3 生成数组的元素的个数
# 参数base ---默认是10，生成10^开始，10^结束的等比数组
arr = np.logspace(0,2,3,base=2)
print("arr:\n",arr)
print("arr的类型：\n",type(arr))


# 创建元素全部为0的数组
# 参数  生成数组的形状
arr = np.zeros(shape=(2,2))
print("arr:\n",arr)
print("arr的类型：\n",type(arr))

# 创建全部为1 的数组
arr = np.ones(shape=(2,2))
print("arr:\n",arr)
print("arr的类型：\n",type(arr))


# diag --创建一个类似于对角矩阵的数组
arr = np.diag(v=[1,2,3,4],k=0)
arr = np.diag(v=[1,2,3,4],k=1)
arr = np.diag(v=[1, 2, 3, 4], k=-1)
# 当v 为一维的时候
# 当k=0,给定的v 就在对角位置
# 当k>0，给定的v 顺着反对角向上移动k个位置
# 当k<0，给定的v 顺着反对角向下移动k个位置
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("x:\n", x)
arr = np.diag(v=x, k=0)
arr = np.diag(v=x, k=1)
arr = np.diag(v=x, k=-1)
arr = np.diag(v=x, k=5)
# arr = np.diag(v=[[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], k=5) # 错误的，v的值只能是一维或者2维
# 当v 为2 维的时候
# 当k=0,取v 的对角线
# 当k>0，取对角线向上走k个的结果
# 当k<0，取对角线向下走k个的结果
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# eye ---创建一个类似于单位矩阵的数组
arr = np.eye(N=2)
# 当只传N时，会创建一个N行，N列的单位矩阵的数组
arr = np.eye(N=2,M=3)
# 当NM都传且不相等时，先创建较小的单位矩阵数组，然后在多出的行、或者多出列位置补0
arr = np.eye(N=3,M=2)
arr = np.eye(N=3,M=2,k=0)
arr = np.eye(N=3,M=2,k=-1)
# k可以参考diag里面的k进行理解
print("arr:\n", arr)
print("arr的类型：\n", type(arr))


# 创建随机数组
# rand 和 random_sample 和random是一样的
# 创建一个均匀分布的小数数组,随机数在[0,1)之间
# 参数 可以是生成数组的元素个数，也可以是生成数组的行列数
arr = np.random.rand(10)
arr = np.random.rand(2,2,3)
arr = np.random.rand((2,3)) # 错误的，不可以传递形状
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# 创建符合标准正态分布的数组
# 同 standard_normal一样
# 参数可以是元素个数，也可以是生成数组的行列数，不能是形状
arr = np.random.randn(2,3) 
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# 生成随机整数数组
# 生成[low,high)的数组
# size 可以是元素个数,也可以是生成数组的形状
arr = np.random.randint(low=0,high=1,size=10)
arr = np.random.randint(low=0,high=1,size=(2,3))
arr = np.random.randint(low=0, high=1, size=[2, 3])
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

# 生成指定范围内的随机小数的均匀数组
# 生成[low,high)的指定范围的随机均匀分布的小数
# size --可以数组的元素的个数---也可以是数组的形状
arr = np.random.uniform(low=1,high=10,size=(5,5))
print("arr:\n", arr)
print("arr的类型：\n", type(arr))

数组的属性

import numpy as np

# 将列表转化为 数组
arr = np.array([1, 2, 3, 4])
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 0]])
arr = np.array([[[1, 2, 3, 4], [5, 6, 7, 0]],[[1, 2, 3, 4], [5, 6, 7, 0]]])
print("arr:\n", arr)
print("arr 的类型：\n", type(arr))

# ndarray对象属性
# ndim shape  size  dtype itemsize
print("arr 的维度：\n", arr.ndim)
print("arr 的形状：\n", arr.shape)
print("arr 的元素的个数：\n", arr.size)
print("arr 的元素的类型：\n", arr.dtype)
print("arr 的每一个元素的大小：\n", arr.itemsize)

数组的类型及形状

import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4], dtype=np.float32)
print("arr:\n", arr)
print("arr 的元素类型：\n", arr.dtype)

# numpy里面数据类型
# numpy里面的数据类型，其实就是封装了Python里面基础的数据类型，进行细致划分之后封装为np.数据类型
# 1、创建数组的时候可以通过dtype属性来指定元素的数据类型
# 2、也可以进行强制转换
# 0 对应False  非0 对应是True
res = np.bool(0)
res = np.float32(5)
print("res:\n",res)
# 3、可以通过astype来修改数据类型
# 将arr的float32类型转化为int32类型
arr = arr.astype(np.int32)
print("arr:\n", arr)
print("arr 的数据类型：\n", arr.dtype)

# 形状---shape ---元组
arr = np.arange(16)
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)

# 修改形状 ---元素的总个数必须一致
# 1、通过shape 属性进行修改
arr.shape = (4, 4)
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)
# 2、可以通过reshape来修改数组的形状
# reshape 会返回一个新的数组，需要去接收
arr = arr.reshape((4,4))
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)

# reshape 中的(-1,1)的-1 代表在行上进行占位
arr = arr.reshape((-1,1))
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)

数组的索引

import numpy as np

# # 创建一个一维数组
arr = np.arange(1, 10)
print("arr:\n", arr)

# 使用单独的下标会降低维度
# 获取 arr 里面的 6 这个元素 --下标
print("获取arr里面的6：", arr[5])
# 获取 arr 里面的 9 这个元素 --下标
print("获取arr里面的9：", arr[-1])

# 获取 arr 里面的 6 9这两个元素 ---下标列表
print("获取arr里面的6和9 ：", arr[[5, -1]])

# 获取arr 里面的 6 这个元素 ---切片
print("获取arr里面的6：", arr[5:6])

# 获取 arr 里面的 9 这个元素 --切片
print("获取arr里面的9：", arr[-1:])

# 获取 arr 里面的 6 9这两个元素 ---切片
print("获取arr里面的6和9 ：", arr[5::3])

# 创建一个二维数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# 使用单独的下标会降低维度
# 使用切片不降低维度
# 使用下标列表---可以理解为 将多个下标的值取出来，然后组合起来--->一维

# 获取arr里面的 6 这个元素 --下标
print("获取arr里面的6：", arr[1, 1])
# 获取arr 里面的 11这个元素 --下标
print("获取arr里面的11 :", arr[2, 2])

# 获取 arr 里面的 6 和 11 这两个元素 --下标列表
# 找行列上一一对应位置的元素
print("获取arr 里面的6 和11 这两个元素：", arr[[1, 2], [1, 2]])

# 获取 arr 里面的 8 和 15 这两个元素 ---下标列表
print("获取arr 里面的8 和15 这个两个元素：", arr[[1, 3], [3, 2]])

# 获取arr里面的 6 这个元素 --切片
print("获取arr 里面的6 这个元素：", arr[1:2, 1:2])
# 获取arr 里面的 11这个元素 --切片
print("获取arr里面的11 :", arr[2:3, 2:3])

# 获取 arr 里面的 6 和 11 这两个元素  ----下标列表
print("获取arr 里面的6 7 和10 11 这两个元素：", arr[1:3, 1:3])  # 获取的一块元素

#  获取 11 12  15 16 这4个元素
print("获取 11 12  15 16 这4个元素", arr[2:, 2:])

# 使用下标列表 --获取 11 12  15 16 这4个元素
print("获取 11 12  15 16 这4个元素", arr[[2, 2, 3, 3], [2, 3, 2, 3]])

#  获取4 8 12 16 这一列
print("获取4 8 12 16 这一列", arr[:, 3:])
print("获取4 8 12 16 这一列", arr[:, 3])

# 三维数组 ---arr[块,行,列]
# n维数组 ---arr[n-1个逗号]将N个维度划分开来，然后在对应的维度进行索引


# 创建一个二维数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# bool 数组索引
# 创建一个bool数组
bool_index = np.array([0, 1, 1, 0], dtype=np.bool)
print('bool_index:\n', bool_index)

# 利用bool数组进行索引 arr ---如果为True 就选中，如果为False就干掉
# bool数组长度必须和你要索引的维度的数量必须相等
print(arr[bool_index, :])
print(arr[:, bool_index])
print(arr[bool_index, bool_index])  # 参考前后都是下标列表理解

数组的展开

import numpy as np

# 创建一个二维数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# 将二维转化为一维
arr = arr.reshape((16,))
print("arr:\n", arr)

arr.shape = (16,)
print("arr:\n", arr)

# 数组的展开
# flatten -- ravel
# ---功能没有区别
# flatten ---返回一个拷贝的内存
# ravel ----返回原来的引用或者视图

np.ravel(arr,"C")
arr = arr.flatten('C')
arr = arr.flatten('F')
arr = arr.ravel('C')
arr = arr.ravel('F')
print("arr:\n", arr)

数组的合并与拆分

import numpy as np

# 创建两个二维数组
arr1 = np.array([[9, 0], [8, 9]])
arr2 = np.arange(4).reshape((2, 2))
print("arr1:\n", arr1)
print("arr2:\n", arr2)

# 将arr2 拼接到 arr1 下边 ---垂直
res = np.vstack((arr1, arr2))
print("res:\n",res)

# 将arr2 拼接到 arr1 右边 --水平
res = np.hstack((arr1,arr2))
print("res:\n",res)

# axis --->指定拼接的轴
res = np.concatenate((arr1, arr2),axis=0)
res = np.concatenate((arr1, arr2),axis=1)
print("res:\n",res)

# 创建一个数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# 拆分的时候，必须能整除，必须平均拆分
# 拆分
# 水平拆分----把横着的列打断
res = np.hsplit(arr,2)
print("res:\n",res)

# 垂直拆分 ---把竖着的行 打断
res = np.vsplit(arr,2)
print("res:\n",res)

# 在行的方向拆分
res = np.split(arr, 2, axis=0)
# 在列的方向拆分
res = np.split(arr, 2, axis=1)
print("res:\n", res)

# 拆分为 三部分[:1],[1:3],[3:]
res = np.split(arr, [1, 3], axis=0)
print("res:\n", res)

# 将数组拆分 第一列一部分 ，其他的列为1部分 ---索引获取指定的部分
res1 = arr[:, :1]
res2 = arr[:, 1:]
print("res1:\n", res1)
print("res2:\n", res2)

矩阵的创建

import numpy as np

# 创建矩阵 ---矩阵是二维的，也只能是二维
# mat 与 asmatrix 一样，与matrix 相比少了一个拷贝的过程。 ---推荐
# mat 可以将特殊字符串、列表嵌套、二维数组转化为矩阵
m1 = np.mat("1 2 3;4 5 6;7 8 9") #  <class 'numpy.matrixlib.defmatrix.matrix'>
m1 = np.mat([[1, 2], [3, 4]])
m1 = np.mat(np.array([[1, 2], [3, 4]]))
print("m1:\n", m1)
print("m1 的类型：\n", type(m1))
print("m1 的维度：\n",m1.ndim)
print(m1[0,:]) # 矩阵里面使用下标不降低维度

# 使用matrix创建矩阵
# matrix 可以将特殊字符串、列表嵌套、二维数组转化为矩阵
m1 = np.matrix("1 2 3;4 5 6;7 8 9")
m1 = np.matrix([[1, 2], [3, 4]])
m1 = np.matrix(np.array([[1, 2], [3, 4]]))
print("m1:\n", m1)
print("m1 的类型：\n", type(m1))

# 使用bmat来合成矩阵
# bmat 可以直接将二维数组转化为矩阵
m1 = np.bmat(np.array([[1, 2], [3, 4]]))
m1 = np.bmat([[1, 2], [3, 4]]) # 错误的
m1 = np.bmat("1 2 3;4 5 6;7 8 9") # 错误的
print("m1:\n", m1)
print("m1 的类型：\n", type(m1))

m1 = np.mat(np.array([[1, 2], [2, 1]]))
m2 = np.mat(np.arange(4).reshape((2, 2)))
print("m1:\n", m1)
print("m2:\n", m2)

# 使用矩阵来组合矩阵
# 也可以使用数组来组合矩阵
m = np.bmat('m1 m2;m2 m1')
m = np.bmat([[m1, m2], [m2, m1]])
print("m:\n", m)

矩阵的运算及属性

import numpy as np

# 创建两个矩阵
m1 = np.mat(np.array([[1, 3], [4, 5]]))
m2 = np.mat(np.array([[1, 2], [1, 3]]))
print("m1:\n", m1)
print("m2:\n", m2)

# 矩阵与数的相乘 ---矩阵中的每一个元素与数进行相乘
m3 = m1 * 2
print("m3:\n", m3)
print("m3 的类型：\n", type(m3))

# 矩阵与矩阵的相加减 ---对应位置元素的相加减----必须是同型矩阵
m3 = m1 + m2
m3 = m1 - m2
print("m3:\n", m3)
print("m3 的类型：\n", type(m3))

# 矩阵的相乘 ---规则：左矩阵的列数必须等于右矩阵的行数，才能进行相乘，返回一个左矩阵行数、右矩阵列数的矩阵
# m1 ---(2,2)
# m2 ---(2,2)
# m3 ---(2,2)
m3 = m1 * m2
m3 = np.matmul(m1, m2)
m3 = np.dot(m1, m2)
print("m3:\n", m3)
print("m3 的类型：\n", type(m3))

# 同型矩阵对应位置元素的相乘
m3 = np.multiply(m1,m2)
print("m3:\n", m3)
print("m3 的类型：\n", type(m3))

# 获取矩阵的属性
print("m1 的转置为：\n",m1.T)
print("m1 的共轭转置为：\n",m1.H)
# 可以通过np.mat 将数组转化为矩阵，也可以通过m1.A将矩阵转化为数组
print("m1 的视图为：\n", m1.A)
print("m1 的视图的类型为：\n", type(m1.A))
print("m1 的逆矩阵为：\n",m1.I)
print("m1 * m1 的逆的值为：\n",np.matmul(m1,m1.I))

数组的全通用函数

import numpy as np

"""
数组的全通用函数---对数组的每一个元素都进行操作的函数 ----数组的形状必须是一样的
"""
# 创建两个数组
arr1 = np.array([[2, 1], [5, 6]])
arr2 = np.array([[0, 1], [1, 0]])
print("arr1:\n", arr1)
print("arr2:\n", arr2)
print("*" * 100)
# 数组的四则运算 --- + - * / ** ---对应位置进行运算
print("数组相加：\n", arr1 + arr2) # 对应位置元素进行相加
print("数组相减：\n", arr1 - arr2)  # 对应位置元素进行相减
print("数组相乘：\n", arr1 * arr2) # 对应位置元素进行相乘
print("数组相除：\n", arr2 / arr1) # 对应位置元素进行相除，注意：分母不能为0
print("数组相幂：\n", arr1 ** arr2)  # 对应位置元素进行求幂

# 数组的比较运算 < > <= >= == != ---对应位置元素进行相比，如果满足条件，返回T,如果不满足条件，返回F，最终组合返回一个bool数组
# 返回bool数组
print("arr1 > arr2 :\n", arr1 > arr2)
print("arr1 != arr2:\n", arr1 != arr2)
print(" arr1 >= arr2 :\n",arr1 >= arr2)
print(" arr1 == arr2 :\n", arr1 == arr2)
print(" arr1 < arr2 :\n", arr1 < arr2)

# 数组的逻辑运算  ---返回bool值
# np.all  相当于and  只有所有条件都满足，才返回True
print(np.all(arr1 >= arr2))
print(np.all(arr1 > arr2))
# np.any  相当于or, 只要有一个满足条件，就返回True
print(np.any(arr1 == arr2))
print(np.any(arr1 < arr2))

数组的保存与读取

import numpy as np

# 二进制形式保存
# 创建数组
arr = np.arange(16).reshape((4, 4))
print("arr:\n", arr)
arr1 = np.array([1, 2, 3, 4, 5])
print("arr1 :\n", arr1)
# 保存起来---以二进制形式
# 参数1 --保存的路径+名称，后缀名可以省略，默认保存为.npy文件
# 参数2 ---需要保存的数组
# 以二进制保存单个数组
np.save("./arr",arr)
print("保存完毕")
# 加载保存的单个数组
# 参数 路径+名称，此时后缀名不能省略
res = np.load("./arr.npy")
print(res)

# 以二进制的形式保存多个数组
# 参数1 路径+名称，此时后缀名可以省略，默认保存为.npz结尾的文件
# 接下来的参数 ---需要保存数组
np.savez("./arr", arr, arr1)
print("保存完毕")

# 保存的时候以键值对的形式的进行保存的
# 加载.npz文件
res = np.load("./arr.npz")
print("res:\n",res)

for tmp in res:
    print(tmp)
# 根据键值 取保存的数组
a = res["arr_0"]
b = res["arr_1"]
print("a:\n",a)
print("b:\n",b)

# 也可以指定保存的key来进行保存数组
# 指定key 进行保存
np.savez("./arr_key", k1=arr, k2=arr1)
print("保存完毕")

# 加载arr_key.npz文件
res = np.load("./arr_key.npz")
for tmp in res:
    print(tmp)
k1 = res["k1"]
k2 = res['k2']
print("k1:\n",k1)
print("k2:\n",k2)

# 文本形式保存
# 参数1 保存路径+名称
# 参数2 需要保存的数组
# fmt 保存的格式
# delimiter --分隔符
np.savetxt("./arr.txt",arr, fmt='%d',delimiter=",")
print("保存完毕")

# 加载文本类型的数组
res = np.loadtxt("./arr.txt",dtype=int,delimiter=",")
print("res:\n",res)

# 可以读取含有缺失值的数组，默认会补上一个与数组不同的值
res = np.genfromtxt("./arr.txt",dtype=int,delimiter=",")
print("res:\n",res)

数组的排序

import numpy as np

# 数组的排序，自己排自己，与别的元素无关
# 创建一个一维数组
arr = np.array([5, 7, 2, 1, 0])
arr = np.array([[2, 1, 0], [5, 0, 1], [0, 2, -1]])
print(arr)
# 直接排序 --sort --对原数组直接进行排序
arr.sort(axis=1)
arr.sort(axis=0)
print("arr排序之后的结果：\n", arr)

# 间接排序
# argsort  ---返回排序之后结果所对应的元素在原来位置的下标
res = np.argsort(arr,axis=0)
print("res:\n",res)

# 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])

# 按照最后一个元素的规则进行排序，返回最后一个元素排序之后结果所对应的元素原来的下标
res = np.lexsort([a,b,c],axis=0)
res = np.lexsort([a,c,b],axis=0)
res = np.lexsort([b, c, a], axis=0)
print(res)

b_sorted = [b[i] for i in res]
print('b_sorted:\n', b_sorted)