定义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 选择了自己实现张量。

在使用Tsensor.from_numpy()算子时，在mindspore出现了一些问题，想请教一下哪里出错了？

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

import numpy as np arr=np.arange(12) mask=arr%2==0 arr=arr[mask] print(arr)请问通过布尔数组过滤矩阵，在mindspore中有没有对应的函数实现，若没有，请问如何实现高效的上述逻辑

 前言 学习数据分析，必绕不开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 

使用Tensor.from_numpy时遇到了报错，同样的用法在paddle和numpy都是没有问题的。以下是报错信息：====================================================== FAILURES =======================================================___________________________________________________ test_hungarian ____________________________________________________    def test_hungarian():>       _test_classic_solver_on_linear_assignment(list(range(10, 30, 2)), list(range(30, 10, -2)), 10, pygm.hungarian, {            "nproc": [1, 2, 4],        }, ["pytorch", "numpy", "mindspore"])tests est_classic_solvers.py:146:_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _tests est_classic_solvers.py:128: in _test_classic_solver_on_linear_assignment    linear_sim = pygm.utils.build_batch(linear_sim)pygmtoolsutils.py:350: in build_batch    return fn(*args)pygmtoolsmindspore_backend.py:715: in build_batch    return Tensor.from_numpy(numpy.ascontiguousarray(numpy.stack(padded_ts, axis=0)))_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _array = array([[[Tensor(shape=[], dtype=Float32, value= 0.805453),         Tensor(shape=[], dtype=Float32, value= 0.839402),...        Tensor(shape=[], dtype=Float32, value= 0),         Tensor(shape=[], dtype=Float32, value= 0)]]], dtype=object)    @staticmethod    def from_numpy(array):        """        Convert numpy array to Tensor without copy data.        Args:            array (numpy.array): The input array.        Returns:            Tensor, has the same data type as input array.        Examples:            >>> import numpy as np            >>> from mindspore import Tensor            >>> x = np.array([1, 2])            >>> output = Tensor.from_numpy(x)            >>> print(output)            [1 2]        """>       return Tensor(Tensor_.from_numpy(array))E       RuntimeError: mindsporeccsrcpybind_apiir ensor_py.cc:252 MakeTensorOfNumpy] Unsupported data type!....AppDataRoamingPythonPython38site-packagesmindsporecommon ensor.py:418: RuntimeError下面是mindspore,paddle,numpy对同一函数的实现def build_batch(input, return_ori_dim=False): """ Mindspore implementation of building a batched tensor """ assert type(input[0]) == mindspore.Tensor # device it = iter(input) t = next(it) max_shape = list(t.shape) ori_shape = [[_] for _ in max_shape] while True: try: t = next(it) for i in range(len(max_shape)): max_shape[i] = int(max(max_shape[i], t.shape[i])) ori_shape[i].append(t.shape[i]) except StopIteration: break max_shape = numpy.array(max_shape) padded_ts = [] for t in input: pad_pattern = numpy.zeros((len(max_shape), 2), dtype=numpy.int64) pad_pattern[:, 1] = max_shape - numpy.array(t.shape) padded_ts.append(numpy.pad(t, pad_pattern, "constant", constant_values=0)) #pad_pattern[::-2] = max_shape - numpy.array(t.shape) #pad_pattern = tuple(list(pad_pattern)) #padded_ts.append(np.pad(pad_pattern, "constant")(t)) #if return_ori_dim: #return ops.Stack(axis=0)(padded_ts), tuple([mindspore.Tensor(_, dtype=mindspore.int64) for _ in ori_shape]) #else: #return ops.Stack(axis=0)(padded_ts) if return_ori_dim: return Tensor.from_numpy(numpy.stack(padded_ts, axis=0)), tuple([Tensor.from_numpy(_, dtype=mindspore.int64) for _ in ori_shape]) else: return Tensor.from_numpy(numpy.stack(padded_ts, axis=0))def build_batch(input, return_ori_dim=False): """ Paddle implementation of building a batched tensor """ assert type(input[0]) == paddle.Tensor device = input[0].place it = iter(input) t = next(it) max_shape = list(t.shape) ori_shape = [[_] for _ in max_shape] while True: try: t = next(it) for i in range(len(max_shape)): max_shape[i] = int(max(max_shape[i], t.shape[i])) ori_shape[i].append(t.shape[i]) except StopIteration: break max_shape = np.array(max_shape) padded_ts = [] for t in input: pad_pattern = np.zeros((len(max_shape), 2), dtype=np.int64) pad_pattern[:, 1] = max_shape - np.array(t.shape) padded_ts.append(np.pad(t, pad_pattern, "constant", constant_values=0)) if return_ori_dim: return paddle.to_tensor(np.stack(padded_ts, axis=0)), tuple([paddle.to_tensor(_, dtype=paddle.int64, place=device) for _ in ori_shape]) else: return paddle.to_tensor(np.stack(padded_ts, axis=0))def build_batch(input, return_ori_dim=False): """ numpy implementation of building a batched np.ndarray """ assert type(input[0]) == np.ndarray it = iter(input) t = next(it) max_shape = list(t.shape) ori_shape = tuple([[_] for _ in max_shape]) while True: try: t = next(it) for i in range(len(max_shape)): max_shape[i] = int(max(max_shape[i], t.shape[i])) ori_shape[i].append(t.shape[i]) except StopIteration: break max_shape = np.array(max_shape) padded_ts = [] for t in input: pad_pattern = np.zeros((len(max_shape), 2), dtype=np.int64) pad_pattern[:, 1] = max_shape - np.array(t.shape) padded_ts.append(np.pad(t, pad_pattern, "constant", constant_values=0)) if return_ori_dim: return np.stack(padded_ts, axis=0), ori_shape else: return np.stack(padded_ts, axis=0)

在torch上实现了下述代码，想置换成mindspore时，发现出现了一些问题，请问如何解决呢？import torch import numpy as np from mindspore import Tensor import mindspore import random import torch label = np.zeros((6, 6), np.float32) start_f = random.randint(1, 2) label0 = label[:, start_f:start_f + 4] # 根据start_f为起始列，在label截取4列作为输出 # label1 = Tensor.from_numpy(label0) # 出现问题 label2 = torch.from_numpy(label0) print(start_f) print(label) print(label0) print(type(label0)) # print(type(label1)) print(type(label2))

在使用Tsensor.from_numpy()算子时，发现相同的数据在pytorch上能成功实现，但在mindspore出现了一些问题，想请教一下哪里出错了？import torch import numpy as np from mindspore import Tensor x = np.zeros((64, 480, 240, 3)) output1 = torch.from_numpy(x.transpose([3, 0, 1, 2])) output = Tensor.from_numpy(x.transpose([3, 0, 1, 2])) print(output1.shape) print(x.shape) print(output.shape)D:\text1\venv\Scripts\python.exe D:/mindspore/2.py Traceback (most recent call last): File "D:\mindspore\2.py", line 7, in <module> output = Tensor.from_numpy(x.transpose([3, 0, 1, 2])) File "D:\text1\venv\lib\site-packages\mindspore\common\tensor.py", line 431, in from_numpy return Tensor(Tensor_.from_numpy(array)) RuntimeError: Array should be C contiguous. ---------------------------------------------------- - C++ Call Stack: (For framework developers) ---------------------------------------------------- mindspore\ccsrc\pybind_api\ir\tensor_py.cc:247 MakeTensorOfNumpy

【功能模块】mindspore.numpy【操作步骤&问题现象】1、环境mindspore 1.7  + python3.7.92、使用numpy进行array赋值操作时报错【截图信息】

报错信息：[WARNING] KERNEL(3957,fffefffff1e0,python):2022-07-29-15:33:37.403.130 [mindspore/ccsrc/backend/kernel_compiler/tbe/tbe_kernel_select/tbe_kernel_select.cc:210] FilterInVaildKernelInfo] Tbe kernel info list is empty, all valid kernel info was filtered out. Check the input shape, attrs or other value of node : Default/TransposeNOD-op1 Traceback (most recent call last): File "main.py", line 251, in <module> train() File "main.py", line 183, in train result = train_net(inputs, label) / args.batch_size File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 433, in __call__ raise err File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 430, in __call__ output = self.run_construct(cast_inputs, kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 352, in run_construct output = self.construct(*cast_inputs, **kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/wrap/cell_wrapper.py", line 353, in construct loss = self.network(*inputs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 433, in __call__ raise err File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 430, in __call__ output = self.run_construct(cast_inputs, kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 352, in run_construct output = self.construct(*cast_inputs, **kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/wrap/cell_wrapper.py", line 110, in construct out = self._backbone(data) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 433, in __call__ raise err File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 430, in __call__ output = self.run_construct(cast_inputs, kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 352, in run_construct output = self.construct(*cast_inputs, **kwargs) File "/home/ma-user/work/convLSTM/model.py", line 38, in construct output = self.decoder(state) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 433, in __call__ raise err File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 430, in __call__ output = self.run_construct(cast_inputs, kwargs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 352, in run_construct output = self.construct(*cast_inputs, **kwargs) File "/home/ma-user/work/convLSTM/decoder.py", line 52, in construct getattr(self, 'rnn3')) File "/home/ma-user/work/convLSTM/decoder.py", line 39, in forward_by_stage inputs = subnet(inputs) File "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py", line 415, in __call__ raise TypeError("The cell inputs should not be numpy arrays.") TypeError: The cell inputs should not be numpy arrays.

在官网上看到解释，该API会创建一个张量，但是实践操作是返回是却是numpy.ndarry类型？为什么？

【模块优化】在mindspore的numpy模块中,所有的方法的输入都是以mindspore.Tensor作为输入, 能否也封装一个可以接收numpy.ndarray作为输入的?另外, 在numpy或pytorch中,有许多方法都变成Tensor的内置函数, 比如在pytorch中:import torchindex = torch.ranint((10, 15))sigma = index.sigmoid()而在mindspore中需要先定义算子,再进行操作:import mindspore as msfrom mindspore import numpy as npfrom mindspore.nn import opsindex = np.ranint((10, 15))op = ops.Sigmoid()sigma = op(index)如果mindspore的Tensor有内置sigmoid函数, 则可以直接操作.

【问题描述】MindSpore中的Tensor有类似PyTorch中的to_sparse方法, 可以直接把元素不为0的位置给获取到吗?虽然在用numpy接口时, 可以用np.nonzero方法获取不为0元素的位置,但是mindspore中的numpy模块并没有实现该接口,下一个版本会提供吗?

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()吧。