看不到报错, 不知道是不是 numpy的问题

定义PyTorch 和 NumPy 都是用于科学计算和数据处理的库，但它们的设计和用途略有不同。NumPy 是一个用于数值计算的库，它提供了一个强大的数组对象。ndarray，可以方便地进行数组操作、线性代数运算和数学函数计算等。而 PyTorch 是一个用于深度学习的库，它提供了一个称为张量（Tensor）的对象，可以方便地进行矩阵运算、向量运算和神经网络的前向和反向传播等。区别虽然 PyTorch 的张量和 NumPy 的 ndarray 都是多维数组，但它们在内存管理和计算方式上略有不同。NumPy 的 ndarray 是基于 C 语言编写的，它的内存管理是由操作系统负责的，因此数组的大小和形状在创建后不能更改。而 PyTorch 的张量是基于 Python 语言编写的，它的内存管理是由 PyTorch 自身负责的，因此可以在运行时动态地更改数组的大小和形状。这种灵活性在深度学习中非常重要，因为神经网络的输入和输出往往是不同的大小和形状。此外，PyTorch 的张量还支持 GPU 运算和自动微分。在深度学习中，很多计算都是在 GPU 上进行的，因此 PyTorch 的张量可以在 GPU 上进行矩阵运算和向量运算，从而提高计算效率。另外，自动微分是深度学习中的一个重要功能，它可以自动计算神经网络中每个参数的梯度，从而加快神经网络的训练速度。PyTorch 的张量支持自动微分，因此可以在训练神经网络时自动计算梯度，从而提高训练效率。打印pytorch张量张量的主要属性有以下3个张量的维度（rank，number of dimensions）指的是张量中用来索引元素的索引个数，0维张量就是标量，因为不需要索引，而对于向量（vector）而言，只需要一个索引就可以得到相应元素，后续同理。高维的张量其实就是对低维张量的堆叠。张量的形状（shape，number of rows and columns）指的是张量中每一维度的大小A张量的类型（type，data type of tensor's elements）指的是张量中每个元素的数据类型测试代码如下import torch a = torch.ones(3,4,5, dtype=torch.int32) print(f'ndimension:{a.ndimension()}') print(f'shape:{a.shape}') print(f'dtype:{a.dtype}')总结综上所述，PyTorch 的张量和 NumPy 的 ndarray 虽然都是多维数组，但它们在内存管理和计算方式上略有不同，因此 PyTorch 选择了自己实现张量。

windows系统，python版本是3.7.3，numpy换了好几个版本都是这个错误，这是怎么回事啊

 前言 学习数据分析，必绕不开numpy和pandas这两个库，numpy的ndarray数据结构和矩阵数据非常类似，最近搞科研的时候总是会用到，之前学的都忘记完了，所以，这次打算把numpy库的基本用法记录在一篇文章里，以便后面复习和使用。  ndarray多维数组创建 不要管复杂的概念，我们把多维数组看做成矩阵就行（实际使用中也是这样的），例如，下面的二维数据，我们就可以看做成2行3列的矩阵。  import numpy as np   b = np.array([[1,2,3],[4,5,6]]) print(b)   # [[1 2 3] # [4 5 6]] 一切从创建说起 一个特定的数据结构，肯定有着特定的创建方式，例如列表我们就是通过[]来创建，字典我们用{}来创建。ndarray多维数组用numpy库的array方法来创建。  numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0) object 数组或嵌套的数列（列表，元祖，数组，或者其他序列类型）  dtype 数组元素的数据类型，可选  copy 对象是否需要复制，可选  order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）  subok 默认返回一个与基类类型一致的数组  ndmin 指定生成数组的最小维度  # 1维数组 a = np.array([1,2,3]) print(a)   # [1,2,3]   # 2维数组 b = np.array([[1,2,3],[4,5,6]]) print(b)   # [[1 2 3] # [4 5 6]]   # 指定数据类型 c = np.array([[1,2,3],[4,5,6]], dtype = np.float64) print(c)   # reslut [[1. 2. 3.]  [4. 5. 6.]]  特殊创建方式 numpy也提供了一些函数用于创建特殊的数组。  zeros，全为0数组；  ones，全为1数据；  empty，垃圾值数组。  full，填充任意值    数值范围创建数组 我们做循环的时候经常会用到range，可以取数值范围，numpy中有个arange函数，可用于创建数组。  arr4 = np.arange(9) arr4   # [0, 1, 2, 3, 4, 5, 6, 7, 8] 这样创建的数组只能是一维的，arange函数经常和reshape一起使用（后面还会介绍），可以创建多维的数组。  arr5 = np.arange(9).reshape(3,3) arr5   array([[0, 1, 2],        [3, 4, 5],        [6, 7, 8]]) ndarray数据属性 属性我们常需要调用的就是ndim，shape和dtype。  ndarray.ndim 秩，即轴的数量或维度的数量  ndarray.shape 数组的维度，对于矩阵，n 行 m 列  ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值  ndarray.dtype ndarray 对象的元素类型  ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位  ndarray.flags ndarray 对象的内存信息  ndarray.real ndarray元素的实部  ndarray.imag ndarray 元素的虚部  ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元- 素，所以通常不需要使用这个属性。  arr5 = np.arange(9).reshape(3,3) print(arr5.ndim) print(arr5.shape) print(arr5.dtype)   2 (3, 3) int64 改变数组数据类型 这个我们经常会用到，例如我们把整数数组转换为浮点数数组，使用astype方法，用np.float64和'float64'都可以。  切片和索引 这部分内容非常重要，我们经常要选取特定的部分数据来操作，这里就必须要用到切片和索引。  小试牛刀 和列表的切片和索引很类似，都是从0开始计数，一维数组很简单，也很好理解（和列表一样操作就行），这里就不多介绍了。  二维数组，选取数据无非就以下几种情况，选取特定的行，特定的列，或者组合，我们来看看怎么写。  特定行  特定列  特定的行和列，这部分就有点不一样了，如果行或者列中有切片，就能得到我们想要的结果，例如获取2,3行以及1，3列。  如果我们想要获取1,3行以及1,3列，用这种写法结果就不对。  这其实获取的是第一行第一列以及第三行第三列的值，这时候我们就需要用到花式索引。  花式索引 要使用np.ix_来完成。  其实不用这样写也可以，就是稍微复杂一点。我们先选取第一行和第三行，选完之后，再选取列。  布尔索引 还有一个很重要的概念，就是布尔索引。    这里有两个函数需要介绍下，一个是all，一个是any，all是都为True，就返回True，any是一个为True，就返回True。  数组操作 修改数组形状 之前我们简单了解过reshape方法，可以改变数组的形状。通过flatten或者ravel可以将数组从新进行展开。  合并和分割数组 合并数组主要有以下几种方法：  concatenate 连接沿现有轴的数组序列  stack 沿着新的轴加入一系列数组。  hstack 水平堆叠序列中的数组（列方向）  vstack 竖直堆叠序列中的数组（行方向）  axis参数就是制定轴的方向，很多numpy函数都有这个参数，但是这个轴又不是很好理解，网上有很多的解释，我这里说一个很简单的解释。例如二维数组，我们索引的时候arr[i,j]，i就代表0，j就代表1，也就是说，行的方向就是0，列的方向就是1。    分割数组的函数为：  split 将一个数组分割为多个子数组  hsplit 将一个数组水平分割为多个子数组（按列）  vsplit 将一个数组垂直分割为多个子数组（按行）  numpy.split(ary, indices_or_sections, axis) ary：被分割的数组  indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）  axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向  修改数组 resize 返回指定形状的新数组  append 将值添加到数组末尾  insert 沿指定轴将值插入到指定下标之前  delete 删掉某个轴的子数组，并返回删除后的新数组  unique 查找数组内的唯一元素  这里要注意的是，如果不指定轴修改数组，会返回一维数组。  numpy.unique 函数用于去除数组中的重复元素。  numpy.unique(arr, return_index, return_inverse, return_counts) arr：输入数组，如果不是一维数组则会展开  return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储  return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储  return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数  翻转数组 transpose 对换数组的维度  ndarray.T 和 self.transpose() 相同  rollaxis 向后滚动指定的轴  swapaxes 对换数组的两个轴  numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：  numpy.rollaxis(arr, axis, start) 参数说明：arr：数组 axis：要向后滚动的轴，其它轴的相对位置不会改变 start：默认为零，表示完整的滚动。会滚动到特定位置。  numpy.swapaxes 函数用于交换数组的两个轴。  数学和统计函数 numpy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。这里就不一一介绍了，我们着重了解下复数处理函数。  numpy.around() 函数返回指定数字的四舍五入值。  numpy.around(a,decimals) numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。  numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。  算数函数 这里不一一介绍了，大家需要用到的时候自查即可。  add，相加  subtract，相减  multiply，相乘  divide，相除  reciprocal，函数返回参数逐元素的倒数。如 1/4 倒数为 4/1  power，第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂  mod，计算输入数组中相应元素的相除后的余数。函数 numpy.remainder() 也产生相同的结果。  统计函数 numpy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。sum，average等等，可以去numpy的官方文档了解更多。  条件函数 numpy.where() 函数返回输入数组中满足给定条件的元素的索引。  numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。  文件的存储与读取 load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。  savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。  loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)。    savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。  np.loadtxt(FILENAME, dtype=int, delimiter=' ') np.savetxt(FILENAME, a, fmt="%d", delimiter=",") 总结 numpy是Python数据科学必学的第三方库，但是说实话，一上来就学numpy其实是很痛苦的，他不像pandas那么直观，有很多实际的有趣的案例，所以本篇文章主要是将numpy的基础语法记录下来，供大家和自己以后查询所使用，最后附上numpy小抄给大家，我们下期再见。  ———————————————— 版权声明：本文为CSDN博主「罗罗攀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/luoluopan/article/details/126357310 

ndarray 的数据类型数据类型，即 dtype ，也是一个特殊的对象， 它包含了ndarray需要为某一种类型数据所申明的内存块信息（也成为了元数据，即表示数据的数据）dtype是NumPy能够与琪他系统数据灵活交互的原因。通常，其他系统提供一个硬盘或内存与数据的对应关系，使得利用C或Fortran等底层语言读写数据变得十分方便。名称描述bool_布尔型数据类型（True 或者 False）int_默认的整数类型（类似于 C 语言中的 long，int32 或 int64）intc与 C 的 int 类型一样，一般是 int32 或 int 64intp用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）int8字节（-128 to 127）int16整数（-32768 to 32767）int32整数（-2147483648 to 2147483647）int64整数（-9223372036854775808 to 9223372036854775807）uint8无符号整数（0 to 255）uint16无符号整数（0 to 65535）uint32无符号整数（0 to 4294967295）uint64无符号整数（0 to 18446744073709551615）float_float64 类型的简写float16半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位float32单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位float64双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位complex_complex128 类型的简写，即 128 位复数complex64复数，表示双 32 位浮点数（实数部分和虚数部分）complex128复数，表示双 64 位浮点数（实数部分和虚数部分）使用astype方法来显式的转换数组的数据类型123456arr = np.array([1,2,3,4,5])print(arr.dtype)print(arr)float_arr = arr.astype('float32')#也可以写作 arr.astype(np.float32)print(float_arr.dtype)print(float_arr)int32 [1 2 3 4 5] float32 [1. 2. 3. 4. 5.]注意：将内容为数字的字符串数组转为数字是可以的,当内容是浮点型数字的时候只能转成 float，不能 int，只有是整数的时候才可以转成int用其他数组的dtype来转换数据类型：123456int_arr = np.arange(10)calibers = np.array([.22, .270, .357], dtype=np.float64)print(calibers)arr_last = int_arr.astype(calibers.dtype)print(arr_last.dtype)print(arr_last)[0.22 0.27 0.357] float64 [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]补充：Python3：numpy的简单使用(ndarray的基本属性以及基本生成数组的方法)声明由于本人学习需要，所以开始学习numpy,这个科学计算工具，本文用于复习当前所学习的内容（当前使用numpy的版本为：1.17.4）1.ndarray的基本的属性2.生成数组的方法(主要测试生成0和生成1的方法:ones和zeros方法)1. 输出当前ndarray的基本属性1234567891011121314151617181920212223# 测试当前Numpy中的narray中的属性# 使用的numpy的版本为：1.17.4import numpy as np default_array = [[1, 2, 3, 4, 5, 6],                 [1, 2, 3, 4, 5, 6]]np_array = np.array(default_array)print("当前存储后的数据的dtype类型为：{}".format(np_array.dtype))  # int32print("查看这个对象的实际类型：{}".format(type(np_array)))  #print("查看这个对象的形状：{}".format(np_array.shape))  # （2，6）print("当前这个对象的字节长度：{}".format(np_array.itemsize))  # 4print("当前这个对象的长度(使用python的len方法)：{}".format(len(np_array)))  # 2 只迭代了一组数据外层的二维数据print("当前这个对象的长度(使用自己的size方法)：{}".format(np_array.size))  # 获取了所有的数据的数量 print(np.array([[1, 2, 3], [1, 2, 3]]).dtype)print(np.array([1.2, 2.2, 3.2]).dtype) # 可以看出当前默认使用的类型为int32# 默认使用的浮点类型为：float64 # 修改和设定当前的使用的初始化类型# print(np.array([[1.1,1.2,1.3]],dtype="int32").dtype)print(np.array([[1.1,1.2,1.3]],dtype=np.int32).dtype)结果：总结：1.创建了二维数据的时候使用原生的python的len方法获取的长度是外层的长度，并不是二维数组实际内容的长度！2.通过np.array(数组)将原来的python中的数组转换为ndarray类型的数据3.每一个ndarray中都会有一个数据类型使用dtype表示，默认使用的整数类型为int32，浮点类型为float644.通过ndarray.size获取当前ndarray中的元素的个数5.通过ndarray.shap获取当前的ndarray的形状6.使用np.array()创建ndarray的时候可以指定当前的ndarray的dtype，其形式可以是字符也可以是np.类型2.使用numpy生成简单的数组(np.zeros()，np.ones()，np.empty()，np.array())123456789101112131415161718192021# 使用numpy中的生成的数组数据的方法import numpy as np # 生成1的操作np_array = np.zeros([2, 2])print("当前生成的数据为：{}".format(np_array))print("输出当前生成的数据的类型为：{}".format(np_array.dtype)) # 说明当前默认产生的数据数据的类型为float64# 现在改变当前的dtype,直接将当前的dtype的数据类型设置为int32np_array.dtype = np.int32print("当前生成的数据为：{}".format(np_array))print("输出当前生成的数据的类型为：{}".format(np_array.dtype)) # 生成1的数据np_array_ones = np.ones([2, 2], dtype=np.int32)print(np_array_ones) # 创建一个未初始化的数据，默认未初始化x = np.empty([3, 2], dtype=int)print(x)结果：总结：1.使用当前的np.zeros(shape)和np.ones(shape)方法生成全是0或者全是1的指定形状的数组2.通过np.empty(shape)生成空的数组3.可以通过ndarray.dtype=dtype方式改变当前的ndarray的类型3.使用生成数组方式二(np.asarray()，np.copy())123456789101112# 从已有的数组中创建数据import numpy as np default_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]default_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)print(type(default_tuple))copy_array = np.asarray(default_array)  # 用于浅拷贝copy_tuple = np.asarray(default_tuple)print("asarray数组后的数据：{}".format(copy_array))print("asarray元组后的数据：{}".format(copy_tuple))deep_copy_array = np.copy(default_array)print("copy数组后的数据：{}".format(deep_copy_array))总结：1.这里使用np.asarray()方法生成的数组与原来的数组有关联，是浅拷贝2.这里的np.copy()方法生成的另外一份备份数据，是深拷贝4.生成指定范围的数组(np.range()，np.random.random()，np.random.randint()，np.linspace())123456789101112131415# 通过固定范围生成数组,使用arange方式生成0 到 9之间的数据,默认生成的数据为当前的为范围的值，这里的步长默认就是1,结果中不包含10，这里是按照指定的步长进行迭代range_array = np.arange(0, 10, dtype=np.int32)print("range_array:{}".format(range_array)) # 通过随机方式生成数组random_array = np.random.random((2, 2))print("使用随机方式生成数组：{}".format(random_array))  # 默认生成的数据为0到1之间的数据 # 2 生成随机的整数random_array_int = np.random.randint(1, 10, (2, 2))print("生成随机整数：{}".format(random_array_int)) # 在指定范围中生成15 个 1到 10之间的数,这是一个随机的数据，是等距离的，当要求的数据超过当前的范围的数据的时候默认就会随机生成一些数据listspace_array = np.linspace(1, 10, 15, dtype=np.int32)  # 就是按照一定的等分进行划分为指定个需要的数据，这里的结果中包含10，相当于当前的等差数列一样print("listspace_array:{}".format(listspace_array))结果：总结：1.当前的random方法就是随机生成指定区间的数据，可以指定类型2.range就是相当于当前的python中的range方法，可以指定步长，是一个[a，b)这中数据3.linspace用于在指定的范围中按照指定的方式生成数组，这个是等差数列，如果当前需要的数据大于这个范围就会出现随机生成的情况5.生成等比数列(np.logspace())123# 生成一个等比的数列，这里面的2 表示生成的样本的个数为2 ,起始数据为1，结束数据为4,表示最小为3的1次方到当前的3的4次方equal_ratio_array = np.logspace(1, 4, 2, dtype=np.int32)  # 这里的默认的底数为10 表示当前最小为10的一次方，最大为当前的10的4次方print("当前的等比数列的数据为：{}".format(equal_ratio_array))当前的等比数列的数据为：[ 10 10000]总结1.这个等比具有默认的底数为10,第一个表示10的1次方,第二个为生成数的最大次方为10的4次方,生成的数据2表示当前生成的等比数组的长度为22.可以设定当前的底数值，可以指定当前的类型6.总结1.当前的numpy这个模块可以实现创建当前的数组，可以生成指定类型和指定形状的数组2.通过numpy可以模拟需要的数据，产生数的方式很快！

[:]和[::]的区别蛮大的，用的好可以节省时间，下面以实例进行分析array([:])12345678910111213>>> import numpy as np>>>>>> x=np.array([1,2,3,4,5,6,7,8,9,10,11,12])>>> print(x[1:5])#打印index为1~5的数组，范围是左闭右开[2 3 4 5]>>> print(x[3:])#打印index=3之后的数组，包含index=3[ 4  5  6  7  8  9 10 11 12]>>> print(x[:9])#打印index=9之前的数组，不包含index=9[1 2 3 4 5 6 7 8 9]>>> print(x[1:-2])#打印index=1到倒数第2个index之间的数组[ 2  3  4  5  6  7  8  9 10]>>> print(x[-9:-2])#打印倒数第9个index和倒数第2个index之间的数组，左开右闭[ 4  5  6  7  8  9 10]array([::])123456789101112>>> print(x[1::3])#以index=1为起始位置，间隔3[ 2  5  8 11]>>> print(x[::3])#默认从index=0开始，间隔3[ 1  4  7 10]>>> print(x[3::])#和[3:]一样[ 4  5  6  7  8  9 10 11 12]>>> print(x[::-1])#反向打印数据，从最后一个index开始，间隔为1[12 11 10  9  8  7  6  5  4  3  2  1]>>> print(x[::-3])#反向打印数据，从最后一个index开始，间隔为3[12  9  6  3]>>> print(x[7:2:-1])#反向打印index=2(不包含)到index=7之间的数据[8 7 6 5 4]也是碰到这方面的问题，没搞明白，干脆试了试就清楚了，应该[:]和[::]还有很多有趣的地方。补充：Numpy.array()详解 、np.array与np.asarray辨析、 np.array和np.ndarry的区别记录一下numpy.array()的详细用法，以及与np.asarray()和np.ndarray()的区别。1. Numpy.array()详解该函数的作用一言蔽之就是用来产生数组。1.1 函数形式123456numpy.array(object,     dtype=None,     copy=True,     order='K',     subok=False,     ndmin=0)1.2 参数详解object：必选参数，类型为array_like，可以有四种类型：数组，公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。np.array()的作用就是按照一定要求将object转换为数组。dtype：可选参数，用来表示数组元素的类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型。注： This argument can only be used to ‘upcast' the array. For downcasting, use the .astype(t) method.copy：可选参数，类型为bool值。如果为true（默认值），则复制对象。否则的话只有在以下三种情况下才会返回副本：（1）.if __array__ returns a copy；（2）. if obj is a nested sequence；（3）. if a copy is needed to satisfy any of the other requirements (dtype, order, etc.)order：{‘K', ‘A', ‘C', ‘F'}，optional 。指定阵列的内存布局。该参数我至今还没有遇到过具体用法，这句话的意思就是我不会，故在此省略。subok：可选参数，类型为bool值。如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。或者说，True：使用object的内部数据类型，False：使用object数组的数据类型。ndmin：可选参数，类型为int型。指定结果数组应具有的最小维数。返回对象out：输出ndarray，满足指定要求的数组对象。1.3 具体用法简单示例12345678910111213141516171819import numpy as np  arr01 = np.array([1,2,3])print(arr01) #[1 2 3]print(type(arr01))  #<class 'numpy.ndarray'>print(arr01.dtype)  #int32  #Upcastingarr02 = np.array([1.,2.,3.])print(arr02) #[1. 2. 3.]print(arr02.dtype)  #float64  #More than one dimension:arr03 = np.array([[1,2],[3,4]])print(arr03)"""[[1 2] [3 4]]"""dtype参数使用示例1234567891011121314151617181920import numpy as np  #指定数组元素类型为复数类型DYX= np.array([1,2,3],dtype = complex)print(DYX) #[1.+0.j 2.+0.j 3.+0.j]print(DYX.dtype)  #complex128  #由多个元素组成的数据类型：HXH = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i8')])print(HXH)  #[(1, 2) (3, 4)]#下面的输出有点神奇，我也只能记住规律了。print(HXH["a"]) #[1 3]print(HXH["b"])  #[2 4]print(HXH.dtype)  #[('a', '<i4'), ('b', '<i8')]print(HXH["a"].dtype) #int32print(HXH["b"].dtype) #int64  TSL = np.array([(1,2,3),(4,5,6)],dtype=[("a","i"),("b","i"),("c","i")])print(TSL["a"]) #[1 4]print(TSL["a"].dtype)  #int32上述代码中，numpy的数据类型，可以百度下subok参数使用示例import numpy as np  DYX = np.array(np.mat('1 2; 3 4'))#没有显示的写出subok的值，但是默认为Falseprint(DYX)#数组类型print(type(DYX))  #<class 'numpy.ndarray'>"""[[1 2] [3 4]]"""  HXH = np.array(np.mat('1 2; 3 4'), subok=True)print(HXH)#矩阵类型print(type(HXH))  #<class 'numpy.matrixlib.defmatrix.matrix'>"""[[1 2] [3 4]]"""前文对subok的描述是这样的：“如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）”。在上文的代码中“np.mat('1 2; 3 4')”，就是子类，是矩阵类型。DYX = np.array(np.mat('1 2; 3 4'))中subok为False，返回的数组类型被强制为基类数组，所以DYX的类型是<class 'numpy.ndarray'>，是数组；HXH = np.array(np.mat('1 2; 3 4'), subok=True)中subok为True，子类被传递，所以HXH的类型是矩阵<class 'numpy.matrixlib.defmatrix.matrix'>。这就是区别所在。ndmin参数使用示例12345678910import numpy as np  DYX = np.array([1,2,3],ndmin=0)print(DYX,DYX.shape) #[1 2 3] (3,)  HXH = np.array([1,2,3],ndmin=1)print(HXH,HXH.shape) #[1 2 3] (3,)  TSL = np.array([1,2,3],ndmin=2)print(TSL,TSL.shape) #[[1 2 3]] (1, 3)其他两个参数copy和order，我至今还没有遇到过，所以暂且不表。谁有介绍这两个参数用法的博客吗？2. Asarray和Array辨析Numpy.asaray的用法不再赘述，主要介绍一下二者的区别。2.1 object对象是普通迭代序列时12345678910111213141516171819202122import numpy as np  data = [1,1,1]print(type(data)) #<class 'list'> 列表类型arr_ar = np.array(data)arr_as = np.asarray(data)  #输出上没有区别print(arr_ar) #[1 1 1]print(arr_as) #[1 1 1]  data[1]=2#改变原序列对arr_ar和arr_as没影响print(arr_ar) #[1 1 1]print(arr_as) #[1 1 1]  #此时data是[1, 2, 1]#改变arr_ar和arr_as对原序列没有影响arr_ar[1]=3print(data) #[1, 2, 1]arr_as[1]=3print(data)  #[1, 2, 1]可见在参数对象是普通迭代序列时，asarray和array没有区别（在我的理解范围内）。2.2 object对象是ndarray对象时123456789101112131415161718192021222324252627import numpy as np data = np.ones((3,))#print(type(data)) #<class 'numpy.ndarray'> 数组类型arr_ar = np.array(data)arr_as = np.asarray(data)  print(arr_ar) #[1. 1. 1.]print(arr_as) #[1. 1. 1.]  """这边区别就出来了。修改原始序列后，np.array()产生的数组不变，但是np.asarray()产生的数组发生了变化"""data[1]=2print(arr_ar) #[1. 1. 1.]print(arr_as) #[1. 2. 1.]  !!!  """这边也有区别，修改array产生的数组，不影响原始序列修改asarray产生的数组，会影响原始序列"""#此时data=[1. 2. 1.]arr_ar[2]=3print(data)  #[1. 2. 1.]arr_as[2]=3print(data)  #[1. 2. 3.]我们总结一下：相同点：array和asarray都可以将数组转化为ndarray对象。区别：当参数为一般数组时，两个函数结果相同；当参数本身就是ndarray类型时，array会新建一个ndarray对象，作为参数的副本，但是asarray不会新建，而是与参数共享同一个内存。重点就是这个共享内存。3.Numpy.ndarray()这是最近在一个项目里看到的用法，搜索了一下用法，只在stackoverflow看到了一个问题：“What is the difference between ndarray and array in numpy?”。地址如下：https://stackoverflow.com/questions/15879315/what-is-the-difference-between-ndarray-and-array-in-numpynumpy.array只是一个创建ndarray的便利函数；它本身不是一个类。他讲到也可以使用numpy.ndarray创建一个数组，但这不是推荐的方法。 numpy.ndarray() 是一个类，而numpy.array() 是一个创建ndarray的方法/函数。在numpy docs中，如果你想从ndarray类创建一个数组，你可以用引用的2种方式来做：（1）.using array(), zeros() or empty() methods: Arrays should be constructed using array, zeros or empty (refer to the See Also section below). The parameters given here refer to a low-level method (ndarray(…)) for instantiating an array.【1-使用array()， zeros()或empty()方法：数组应该使用array, zeros()或empty()构造。这里给出的参数引用用于实例化数组的低级方法(ndarray(…))。】（2）.from ndarray class directly: There are two modes of creating an array using new: If buffer is None, then only shape, dtype, and order are used. If buffer is an object exposing the buffer interface, then all keywords are interpreted.【2-来自ndarray类：使用new创建数组有两种模式：如果buffer是None，则只使用shape，dtype和order。 如果buffer是公开buffer接口的对象，则解释所有关键字。】所以说老老实实用numpy.array()吧。

np.argpartition 难以解决topKtopK是常用的一个功能，在python中，numpy等计算库使用了丰富的底层优化，对于矩阵计算的效率远高于python的for-loop实现。因此，我们希望尽量用一些numpy函数的组合实现topK。pytorch 库提供了topk函数，可以将高维数组沿某一维度（该维度共N项），选出最大（最小）的K项并排序。返回排序结果和index信息。奇怪的是，更轻量级的numpy库并没有直接提供 topK 函数。numpy只提供了argpartition 和 partition，可以将最大（最小）的K项排到前K位。以argpartition为例，最小的3项排到了前3位：123>>> x = np.array([3, 5, 6, 4, 2, 7, 1])>>> x[np.argpartition(x, 3)]array([2, 1, 3, 4, 5, 7, 6])注意，argpartition实现的是 partial sorting，如上例，前3项和其余项被分开，但是两部分各自都是不排序的！而我们可能更想要topK的几项排好序（其余项则不作要求）。因此，下面提供一种基于argpartition的topK方法。一个naive方法最简单的方法自然是全排序，然后取前K项。缺点在于，要把topK之外的数据也进行排序，当K << N时较为浪费时间，复杂度为O ( n log ⁡ n ) O(n \log n)O(nlogn):123456789101112131415161718192021222324252627def naive_arg_topK(matrix, K, axis=0):    """    perform topK based on np.argsort    :param matrix: to be sorted    :param K: select and sort the top K items    :param axis: dimension to be sorted.    :return:    """    full_sort = np.argsort(matrix, axis=axis)    return full_sort.take(np.arange(K), axis=axis) # Example>>> dists = np.random.permutation(np.arange(30)).reshape(6, 5)array([[17, 28,  1, 24, 23,  8],       [ 9, 21,  3, 22,  4,  5],       [19, 12, 26, 11, 13, 27],       [10, 15, 18, 14,  7, 16],       [ 0, 25, 29,  2,  6, 20]])>>> naive_arg_topK(dists, 2, axis=0)array([[4, 2, 0, 4, 1, 1],       [1, 3, 1, 2, 4, 0]])>>> naive_arg_topK(dists, 2, axis=1)array([[2, 5],       [2, 4],       [3, 1],       [4, 0],       [0, 3]])基于partition的方法对于 np.argpartition 函数，复杂度可能下降到 O ( n log ⁡ K ) O(n \log K)O(nlogK)，很多情况下，K << N，此时naive方法有优化的空间。以下方法首先选出 topK 项，然后仅对前topK项进行排序（matrix仅限2d-array）。def partition_arg_topK(matrix, K, axis=0):    """    perform topK based on np.argpartition    :param matrix: to be sorted    :param K: select and sort the top K items    :param axis: 0 or 1. dimension to be sorted.    :return:    """    a_part = np.argpartition(matrix, K, axis=axis)    if axis == 0:        row_index = np.arange(matrix.shape[1 - axis])        a_sec_argsort_K = np.argsort(matrix[a_part[0:K, :], row_index], axis=axis)        return a_part[0:K, :][a_sec_argsort_K, row_index]    else:        column_index = np.arange(matrix.shape[1 - axis])[:, None]        a_sec_argsort_K = np.argsort(matrix[column_index, a_part[:, 0:K]], axis=axis)        return a_part[:, 0:K][column_index, a_sec_argsort_K] # Example>>> dists = np.random.permutation(np.arange(30)).reshape(6, 5)array([[17, 28,  1, 24, 23,  8],       [ 9, 21,  3, 22,  4,  5],       [19, 12, 26, 11, 13, 27],       [10, 15, 18, 14,  7, 16],       [ 0, 25, 29,  2,  6, 20]])>>> partition_arg_topK(dists, 2, axis=0)array([[4, 2, 0, 4, 1, 1],       [1, 3, 1, 2, 4, 0]])>>> partition_arg_topK(dists, 2, axis=1)array([[2, 5],       [2, 4],       [3, 1],       [4, 0],       [0, 3]])大数据量测试对shape(5000, 100000)的矩阵进行topK排序，测试时间为：Kpartition(s)naive(s)108.88422.6041009.01222.45810008.90422.506500011.30522.844# 构建小顶堆跳转def sift(li, low, higt):    tmp = li[low]    i = low    j = 2 * i + 1    while j <= higt:  # 情况2：i已经是最后一层        if j + 1 <= higt and li[j + 1] < li[j]:  # 右孩子存在并且小于左孩子            j += 1        if tmp > li[j]:            li[i] = li[j]            i = j            j = 2 * i + 1        else:            break  # 情况1：j位置比tmp小    li[i] = tmp  def top_k(li, k):    heap = li[0:k]    # 建堆    for i in range(k // 2 - 1, -1, -1):        sift(heap, i, k - 1)    for i in range(k, len(li)):        if li[i] > heap[0]:            heap[0] = li[i]            sift(heap, 0, k - 1)    # 挨个输出    for i in range(k - 1, -1, -1):        heap[0], heap[i] = heap[i], heap[0]        sift(heap, 0, i - 1)    return heap  li = [0, 8, 6, 2, 4, 9, 1, 4, 6]print(top_k(li, 3))

前言numpy支持对矩阵和数组进行运算，因此很多numpy的很多运算都需要指定操作的维数参数axis（当然这些axis都有带默认值的），本博客以numpy.sum求和函数为例，具体分析axis参数不同取值下的含义。先说结论设 numpy.sum的输入矩阵为a. numpy.sum的返回矩阵为rst.则矩阵a的形状为：sp=numpy.shape(a)，例如sp=[m,n,p,q···]rst的形状为将sp的第axis个元素设为1,即：123sp'=spsp'[axis]=1numpy.shape(rst)==sp' 为真.例如：axis=2，如果a是矩阵则：rst的形状应该为：[m,n,1,q···]对于rst的元素rst[m',n',1,q'···]计算方法为：【注意第axis轴】下标只能取1.numpy.sum(a,axis=2)的内部计算其实为：12for i in range(sp[axis]):    rst[m'][n'][1][q'][···]+=a[m'][n'][i][q'][···]结果上发现是第axis维变成1，计算过程其实是对第axis轴进行了遍历,让sp[axis]个元素合并成一个元素。而如果a是一个array则：rst的形状应该为：[m,n,q,···]注意第axis维直接不见了numpy.sum(a,axis=2)的内部计算12for i in range(sp[axis]):    rst[m'][n'][q'][···]+=a[m'][n'][i][q'][···]结果上发现是第axis维变没了，计算过程其实是对第axis轴进行了遍历,让sp[axis]个元素合并成一个元素。举例说明简单点的12import numpy as npa=np.mat([[1,2,3],[4,5,6]])a的shape:1print (np.shape(a))输出：(2, 3)计算：np.sum(a,axis=0)123>>> s0=np.sum(a,axis=0)>>> s0matrix([[5, 7, 9]])按照【先说结论】的方法：1axis=0a的形状：(2,3)所以rst的形状为：（1，3）对于rst的每个元素p,q:rst[p][q] 的 计算方法为（其中p只能等于0，q=0,1,2）：12for i in range(np.shape(a)[axis]):     rst[0][q]+=a[i][q]所以：123rst[0][0]=a[0][0]+a[1][0]=1+4=5rst[0][1]=a[0][1]+a[1][1]=2+5=7rst[0][2]=a[0][2]+a[1][2]=3+6=9所以rst就是[[5，7，9]]计算 numpy.sum（a,axis=1)a=[[1,2,3],[4,5,6]1234567>>> s1=np.sum(a,axis=1)>>> s1matrix([[ 6],        [15]])>>> np.shape(s1)(2, 1)>>> 一样的分析方法：按照【先说结论】的方法：1axis=1a的形状：(2,3)所以rst的形状为：（2，1）对于rst的每个元素p,q:rst[p][q] 的 计算方法为（其中p=0,1 ,而q只能为0）：12for i in range(np.shape(a)[axis]):     rst[p][0]+=a[p][i]所以：12rst[0][0]=a[0][0]+a[0][1]+a[0][2]=1+2+3=6rst[1][0]=a[1][1]+a[1][1]+a[1][2]=4+5+6=15所以rst就是[[6],[15]].复杂点的：1234567>>> b=np.array([[[1,2,3],[4,5,6],[7,8,9]]])>>> barray([[[1, 2, 3],        [4, 5, 6],        [7, 8, 9]]])>>> np.shape(b)(1, 3, 3)b是1x3x3，是一个array.那么np.sum(b,axis=2)等于多少呢？标准答案：12>>> print (np.sum(b,axis=2))[[ 6 15 24]]分析结果：返回值应该为1x3形状的array,对于元素rst[p][q].1rst[p][q]=a[p][q][0]+a[p][q][1]+a[p][q][2]例如rst[0][1]=a[0][1][0]+a[0][1][1]+a[0][1][2]=8+5+6=15.而np.sum(b,axis=2)的第一行第二个元素正是 15.关于axis默认值一般此类针对矩阵、array的函数都有一个axis参数，并且此默认为None.当axis为None使 表示运算是遍历矩阵（array）的每一个元素的，是逐元素的计算。补充：python中某些函数axis参数的理解总结为一句话：设axis=i，则numpy沿着第i个下标变化的方向进行操作。当然，这个i是从0开始数的，作为程序员的你一定不会搞错。axis意为“轴”，它指定了函数在张量（矩阵、等等）上进行操作的方向。例如有一个ndarray，名叫A，A.shape=(3,8,5,7)。那么np.sum(A, axis=2)计算的结果的shape就是(3,8,7)。假设这个shape是(3,8,7)的ndarray变量名为B，那么实际上：B[i][j][k]=A[i][j][0][k]+A[i][j][1][k]+A[i][j][2][k]+A[i][j][3][k]+A[i][j][4][k]以下代码你可以自己跑一下试试：12345import numpy as npA=np.random.randn(3,8,5,7)print("A.shape=",A.shape)B=np.sum(A,axis=2)print("B.shape=",B.shape)预期输出为：A.shape= (3, 8, 5, 7)B.shape= (3, 8, 7)

1. 引言2. 浅拷贝2.1 问题引入2.2 问题剖析3. 深拷贝3.1 举个栗子3.2 探究原因4. 技巧总结4.1 判断是否指向同一内存4.2 其他数据类型5. 总结1. 引言深拷贝和浅拷贝是Python中重要的概念，本文重点介绍在NumPy中深拷贝和浅拷贝相关操作的定义和背后的原理。闲话少说，我们直接开始吧！2. 浅拷贝2.1 问题引入我们来举个栗子，如下所示我们有两个数组a和b，样例代码如下：12345import numpy as npa = np.array([1, 2, 3])b = aprint('a =', a)print('b =', b)输出如下：a = [1 2 3]b = [1 2 3]此时如果我们对数组a做如下改变，代码如下：123456import numpy as npa = np.array([1, 2, 3])b = aa [0] = 42print('a =', a)print('b =', b)那么我们的问题为： 此时b的值应该为多少？运行上述代码后，我们得到输出如下：a = [42 2 3]b = [42 2 3]2.2 问题剖析也许有人会觉得输出应该为??a=[42 2 3]?? 和 ??b=[1 2 3]?? ,但是运行上述代码后我们发现??a??和??b??的值均发生了相应的改变。这主要是由于在??Numpy??中对变量的赋值操作，实际上发生的为浅拷贝。换句话说，此时两个变量指向同一块内存地址，如下所示：所以，此时如果我们修改数组??original_array??中的某个元素，`copy_array??由于和??original_array`公用同一块内存，所以其中的元素也会发生相应的变化。3. 深拷贝3.1 举个栗子如果我们想要对??Numpy??数组执行深拷贝，此时我们可以使用函数??copy()??。相关的样例代码如下：12345import numpy as npa = np.array([1, 2, 3])b = a.copy()print('a =', a)print('b =', b)输出如下：a = [1 2 3]b = [1 2 3]此时，如果我们改变数组??a??中的元素，代码如下：123456import numpy as npa = np.array([1, 2, 3])b = a.copy()a [0] = 42print('a =', a)print('b =', b)此时的代码输出如下：a = [42 2 3]b = [1 2 3]3.2 探究原因观察上述输出，我们可以清楚地看到数组??a??发生了改变而数组??b??没有发生变化，这是由于我们使用了深拷贝。此时的内存地址如下：由于 ??original_array??和??copy_array??指向不同的内存地址空间，所以此时我们对??original_array??的改变并不会对??copy_array??带来影响。4. 技巧总结经过上述对深拷贝和浅拷贝的举例和示例，相信大家都已有了清晰的认识，接着我们对上述知识点进行总结，归纳如下：4.1 判断是否指向同一内存如果我们需要知道两个变量是否指向同一块内存地址，我们可以方便地使用??is??操作。浅拷贝示例：123a = np.array([1, 2, 3])b = aprint(b is a)输出如下：True深拷贝示例：123a = np.array([1, 2, 3])b = a.copy()print(b is a)输出如下：False4.2 其他数据类型尽管本文中所有的示例都使用了NumPy数组，但本文中所涉及的知识也适用于Python中的列表和字典等其他数据类型。总之，我们需要时刻记载心中：在浅拷贝中，原始数组和新的数组共同执行同一块内存；同时在深拷贝中，新的数组是原始数据的单独的拷贝，它指向一块新的内存地址。

处理csv起来比较方便，不会不支持吧。。。

原文链接：https://blog.csdn.net/qq_49821869/article/details/122388098一、Numpy的属性ndim 维度shape 形状dtype 类型size 大小array = np.array([[1,2,3],                 [4,5,6]])print(array)123[[1 2 3] [4 5 6]]12print(array.ndim) # 维度121print(array.shape) # 形状1(2, 3)1print(array.dtype) # 元素类型1int641print(array.size) # 大小161二、创建array指定数据属性创建一维数据、二维数据zeros 全0、 ones 全1、 empty 全接近于0、 arange 等差一维数组reshape 改变矩阵形状a = np.array([1,2,3],dtype=np.int32) # 指定数据类型print(a)12[1 2 3]1b = np.array([1,2,3],dtype=np.float) # 指定数据类型 print(b.dtype)12float641c = np.array([1,2,3]) # 一维数据print(c)12[1 2 3]1d = np.array([[1,2,3],[4,5,6]]) # 二维数据print(d)12[[1 2 3] [4 5 6]]12zero = np.zeros((2,3)) # 生成2行3列的全0矩阵print(zero)12[[0. 0. 0.] [0. 0. 0.]]12one = np.ones((3,4)) # 生成3行4列的全1矩阵print(one)12[[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]]123empty = np.empty((3,3)) # 生成3行3列的全都接近于0（不等于0）的矩阵print(empty)12[[6.92430951e-310 4.67278860e-310 6.92414190e-310] [6.92414190e-310 6.92414190e-310 6.92414190e-310] [6.92414190e-310 6.92414190e-310 3.95252517e-322]]123e = np.arange(5) print(e)12[0 1 2 3 4]1f = np.arange(4,12)print(f)12[ 4  5  6  7  8  9 10 11]1g = np.arange(4,12,2)print(g)12[ 4  6  8 10]1h = np.arange(8).reshape(4,2) # 重新定义矩阵的形状print(h)12[[0 1] [2 3] [4 5] [6 7]]三、Numpy的运算‘+ - * / // ** % >’np.dot(arr1,arr2) == arr1.dot(arr2) 矩阵乘法arr1.T == np.transpose(arr1)arr1 = np.array([1,2,3])arr2 = np.array([4,5,6])print(arr1,arr2)123[1 2 3] [4 5 6]1print(arr1+arr2)1[5 7 9]1print(arr1-arr2)1[-3 -3 -3]1print(arr1*arr2)1[ 4 10 18]1print(arr1/arr2)1[0.25 0.4  0.5 ]1print(arr1**arr2)1[  1  32 729]1print(arr1 // arr2)1[0 0 0]1print(arr1 % arr2)1[1 2 3]1print(arr1 + 1)1[2 3 4]1print(arr1 * 3)1[3 6 9]1print(arr1 > 3)1[False False False]1arr3 = np.arange(6).reshape(3,2)arr4 = np.arange(6).reshape(2,3)12np.dot(arr3,arr4) # 矩阵乘法1array([[ 3,  4,  5],       [ 9, 14, 19],       [15, 24, 33]])arr3.dot(arr4)1array([[ 3,  4,  5],       [ 9, 14, 19],       [15, 24, 33]])123print(arr3.T) # 矩阵转置1[[0 2 4] [1 3 5]]12print(arr3)1[[0 1] [2 3] [4 5]]123print(np.transpose(arr3))1[[0 2 4] [1 3 5]]12四、随机数生成及矩阵的统计np.random.random 0-1的随机数np.random.normal 符合正态分布的随机数np.random.randint(0,10,size=()) 生成从0到10的size形状的随机整数np.sum() 求和、np.mean() 求平均值 np.max() 求最大值、 np.min() 求最小值np.sort() 排序、np.sqrt() 开方、 np.median() 求中位数、 axis=0 0行1列np.argmin() 求最小值的下标、np.argmax() 求最大值下标arr1 = np.random.random((2,2)) # 生成2行2列从0到1的随机数print(arr1)12[[0.70322893 0.62660424] [0.10822154 0.70288038]]12arr2 = np.random.normal(size=(3,3)) # 生成3行3列的符合标准正态分布的随机数print(arr2)12[[ 0.27050106  0.66089326  0.05234379] [ 0.81437662 -0.41467658  2.49832908] [-0.17560416  0.42175065 -1.02400744]]123arr3 = np.random.randint(0,10,size=(4,3)) # 生成4行3列的从0到10的随机整数print(arr3)12[[4 1 9] [8 7 9] [9 1 9] [5 0 9]]np.sum(arr1) # 求和 == arr1.sum()12.14093509458232761np.min(arr1) # 求最小值 == arr1.min()10.108221541469485151np.max(arr1) # 求最大值 == arr1.max()10.70322892713526411np.sum(arr1,axis=0) # 对列求和1array([0.81145047, 1.32948463])1np.sum(arr1,axis=1) # 对行求和1array([1.32983317, 0.81110192])1np.argmin(arr1) # 求最小值的索引 从0开始121np.argmax(arr1) # 求最大值的索引101np.mean(arr1) # 求平均值 == np.sum(arr1) / arr1.size == arr1.mean()10.53523377364558191np.median(arr1) # 求中位数10.66474231298878931np.sqrt(arr1) # 开方 == arr1 ** 0.51array([[ True,  True],       [ True,  True]])12np.sort(arr1) # 排序 每一行是升序1array([[0.62660424, 0.70322893],       [0.10822154, 0.70288038]])12np.clip(arr1,0.5,0.6) # 小于0.5变成0.5 大于0.6就变成0.61array([[0.6, 0.6],       [0.5, 0.6]])12五、Numpy索引索引arr1[1,2] == arr1[1][2]切片 [:,:] 逗号前面代表行，后面代表列遍历行、遍历列、遍历元素print(arr1)1[[0.62660424 0.70322893] [0.10822154 0.70288038]]12print(arr1[0]) 1[0.62660424 0.70322893]1print(arr1[0][1]) == print(arr1[0,1])  10.70322892713526411print(arr1[:,1]) # 第二列1[0.70322893 0.70288038]print(arr1[1,1])0.7028803828361643for i in arr1: # 迭代行    print(i)[0.62660424 0.70322893][0.10822154 0.70288038]for i in arr1.T: # 迭代列    print(i)[0.62660424 0.10822154][0.70322893 0.70288038]arr1.reshape(1,-1)array([[0.62660424, 0.70322893, 0.10822154, 0.70288038]])for i in arr1.flat: # 迭代所有元素    print(i)0.62660424314141430.70322892713526410.108221541469485150.7028803828361643六、合并一维数据合并 np.vstack 垂直合并、 np.hstack 水平合并多维数据合并 np.concatenate((arr1,arr2)) # 默认垂直合并、np.concatenate((arr1,arr2),axis=1) # 水平合并增加一个新的维度np.newaxis变成nd数据 np.atleast_nd n可以为1、2、3、4…arr1 = np.arange(3)arr2 = np.arange(3)print(arr1,arr2)[0 1 2] [0 1 2]np.vstack((arr1,arr2)) # 垂直合并array([[0, 1, 2],       [0, 1, 2]])np.hstack((arr1,arr2)) # 水平合并array([0, 1, 2, 0, 1, 2])np.concatenate((arr1,arr2)) array([0, 1, 2, 0, 1, 2])arr3 = np.arange(4).reshape(2,2) np.concatenate((arr3,arr3))array([[0, 1],       [2, 3],       [0, 1],       [2, 3]])np.concatenate((arr3,arr3),axis=1)  # 该方法不能对1维数据进行垂直合并array([[0, 1, 0, 1],       [2, 3, 2, 3]])arr1.T # 一维数据不能转置array([0, 1, 2])arr1[np.newaxis,:] # 在行这个维度上增加一个维array([[0, 1, 2]])arr1[:,np.newaxis]array([[0],       [1],       [2]])np.atleast_2d(arr1)array([[0, 1, 2]])七、分割等分 np.split 0行1列不等分 np.array_split 0行1列垂直分np.hsplit、水平分np.vsplitarr1 = np.arange(12).reshape(3,4)print(arr1)[[ 0  1  2  3] [ 4  5  6  7] [ 8  9 10 11]]np.split(arr1,2,axis=1) # 竖直方向分割，平均为2份 1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2,  3],        [ 6,  7],        [10, 11]])]12345np.split(arr1,3,axis=0) # 水平方向分割，平均为3份1[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]1np.split(arr1,3,axis=1) # 竖直方向分割，平均为3份1---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)/opt/conda/lib/python3.6/site-packages/numpy/lib/shape_base.py in split(ary, indices_or_sections, axis)    866     try:--> 867         len(indices_or_sections)    868     except TypeError:TypeError: object of type 'int' has no len()During handling of the above exception, another exception occurred:ValueError                                Traceback (most recent call last)<ipython-input-112-2e738d9e1da7> in <module>----> 1 np.split(arr1,3,axis=1) # 水平方向分割，平均为3份<__array_function__ internals> in split(*args, **kwargs)/opt/conda/lib/python3.6/site-packages/numpy/lib/shape_base.py in split(ary, indices_or_sections, axis)    871         if N % sections:    872             raise ValueError(--> 873                 'array split does not result in an equal division')    874     return array_split(ary, indices_or_sections, axis)    875 ValueError: array split does not result in an equal divisionnp.array_split(arr1,3,axis=1) # 竖直方向分割，不等分为3份1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2],        [ 6],        [10]]), array([[ 3],        [ 7],        [11]])]np.vsplit(arr1,3) # == np.split(arr1,3,axis=0) # 水平方向分割，平均为3份1[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]1np.hsplit(arr1,2)# == np.split(arr1,2,axis=1) # 竖直方向分割，平均为2份 1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2,  3],        [ 6,  7],        [10, 11]])]12345八、深浅拷贝Python是引用传递，默认内存共享arr1.copy() 深拷贝 完全独立开arr11array([[ 0,  1,  2,  3],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr2 = arr11arr2[0] = 0arr212array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr11array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr3 = arr1.copy() # 深拷贝1arr3[0] = 11arr31array([[ 1,  1,  1,  1],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr11array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])

NumPy 是Python 编程语言的库，增加了对大型、多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数集合。将Torch中Tensor 转换为 NumPy 数组，反之亦然是轻而易举的！Torch Tensor 和 NumPy 数组将共享它们的底层内存位置 ，改变一个将改变另一个。「将 Torch 张量转换为 NumPy 数组：」a = torch.ones(5) print(a)输出：tensor([1., 1., 1., 1., 1.])b = a.numpy() print(b)输出：[1., 1., 1., 1., 1.]让我们执行求和运算并检查值的变化：a.add_(1) print(a) print(b)输出：tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]「将 NumPy 数组转换为 Torch 张量：」import numpy as no a = np.ones(5) b = torch.from_numpy(a) np.add(a, 1, out=a) print(a) print(b)输出：[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

在Python中，我们可以利用Numpy模块中的numpy.fft  轻松实现快速傅立叶变换（FFT）运算操作。在理解了傅里叶变换背后的基本理论之后，我们就可以研究如何控制频谱输出来处理图像了。首先，我们需要了解低/高通滤波器。低通滤波器低通滤波器是一种只允许低频谱通过的滤波器。图像中的低频谱意味着像素值变化缓慢。例如，图像中颜色变化较小的平滑区域（如新空白白纸的中心）被视为低频谱内容。由于低通滤波器的输出只允许低频通过，对噪声等高频谱内容进行了阻塞，使得处理后的图像具有较少的噪声像素。因此，低通滤波器被广泛应用于图像的去噪。高通滤波器相反，高通滤波器是只允许高频谱通过的滤波器。图像中的高频谱意味着像素值变化很大。例如，图像中颜色变化较大的边缘区域，如两张重叠的白纸和黑纸之间的边缘，被认为是高频谱内容。在图像中，通过做适当的重复计算来锐化原图像，能用适当的重复计算来锐化原始图像的图像，从高通滤波器的输出可获得图像中的边缘。这将增强原始图像的清晰度，使边缘更加清晰。从图e（5）和图f（5），我们可以注意到这两个滤波器呈现不同的特性。低通滤波器倾向于保留图像中的整体信息。另一方面，高通滤波器试图辨别出图像中的变化。在了解了前一节中的低通/高通滤波器的工作原理后，让我们继续认识滤波器形状理想的滤波器公式 (a): 在理想低通滤波器的公式中，D₀是合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离在理想滤波器背后的概念非常简单：给定一个半径值D₀作为阈值，低通滤波器图（g）（1）在阈值下H（u，v）等于1，在阈值以上H（u，v）等于0。公式(b): 在理想高通滤波器的公式中，D₀是合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离相反，高通滤波器图（g）（2）在阈值下H（u，v）等于0，在阈值以上H（u，v）等于1。巴特沃思（Btterworth）滤波器公式(c): 在Butterworth低通滤波器的公式中， D₀是一个合理常量， D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离与理想滤波器不同的是，巴特沃斯滤波器没有明显的不连续性，使得通过的频率和被过滤的频率之间有明显的边界。巴特沃斯滤波器在函数中引入了一个新的参数n。当操作n时，它影响着通过的频率和被过滤的频率之间边界的清晰程度。图（h）和图（i）公式(d): 在Butterworth高通滤波器的公式中， D₀是一个合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离

【功能模块】在openEuler 20.09系统下安装 依赖包时出错，麻烦看看怎样才能安装这3个依赖包呢?谢谢，在centos 7.6下，可以安装成功。 yum -y install zlib* lapack* blas* python3.aa4 cmake3* boost_python* boost boost-devel numpy* python36-numpy flex bison【操作步骤&问题现象】1、2、【截图信息】【日志信息】（可选，上传日志内容或者附件）

1，前置条件yum install numpy opencv* python-devel gstreamer-plugins-base-devel libv4l-devel libpng-devel libjpeg-turbo-devel jasper-devel openexr-devel libtiff-devel libwebp-devel python-sphinx texlive python3-devel python3.aarch64 -y python3 -m pip install cython yum install blas-devel lapack-devel python3-devel pip3 install scipy     //会自动安装依赖numpy,本次采用官方源，未使用镜像源加速，安装过程很漫长，因为会自动编译安装  2，安装cmake，参考下边链接http://ic-openlabs.huawei.com/openlab/#/knowledgebasequery?task_id=R1S1584D002187178201911251854493362566973，下载opencv和opencv_contrib，两者版本必须一致，3.2.0测试编译成功，高版本可能失败wget    https://github.com/opencv/opencv/archive/3.2.0.zip wget  https://github.com/opencv/opencv_contrib/archive/3.2.0.zip4，解压，编译unzip 3.2.0.zip unzip 3.2.0.zip.1 cd opencv mkdir -p build cd build cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_opencv_python3=YES -D BUILD_opencv_python2=NO -D PYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib64/python3.6/site-packages/numpy/core/include/ -D OPENCV_EXTRA_MODULES=../../opencv_contrib-3.2.0/modules/ -D  PYTHON3_LIBRARIES=/lib64/libpython3.so -D PYTHON_DEFAULT_EXECUTABLE=/usr/bin/python3 -D __INSTALL_PATH_PYTHON3=/usr/local/lib/python3.6/site-packages/ ..5,安装make -j$(nproc) make install6，验证