NumPy 1.26 中文文档（六）-CSDN博客

原文：numpy.org/doc/

`numpy.ndarray.imag`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.imag.html

属性

ndarray.imag

数组的虚部。

示例

>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0\.        ,  0.70710678])
>>> x.imag.dtype
dtype('float64')

`numpy.ndarray.flat`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.flat.html

属性

ndarray.flat

数组上的一维迭代器。

这是一个numpy.flatiter实例，表现类似于但不是 Python 内置的迭代器对象的子类。

另见

flatten

返回将数组折叠成一维的副本。

flatiter

示例

>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
 [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
 [2, 5],
 [3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<class 'numpy.flatiter'>

一个赋值示例：

>>> x.flat = 3; x
array([[3, 3, 3],
 [3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
 [3, 1, 3]])

`numpy.ndarray.ctypes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.ctypes.html

属性

ndarray.ctypes

一个简化数组与 ctypes 模块交互的对象。

这个属性创建一个对象，使得在使用 ctypes 模块调用共享库时更容易地使用数组。返回的对象具有数据、形状和步幅属性（见下面的注释），它们本身返回可以用作共享库参数的 ctypes 对象。

参数：

无

cPython 对象

具有数据、形状、步幅等属性。

另请参阅

numpy.ctypeslib

注解

下面是该对象的公共属性，这些属性在“NumPy 指南”中有文档记录（我们已省略了未记录的公共属性和已记录的私有属性）：

_ctypes.data

一个指向数组内存区域的指针，作为 Python 整数。这个内存区域可能包含未对齐或不符合正确字节顺序的数据。内存区域甚至可能不可写。将此属性传递给任意的 C 代码时应尊重这个数组的数组标志和数据类型，以避免可能导致 Python 崩溃的麻烦。用户注意！这个属性的值与 self._array_interface_['data'][0] 完全相同。

请注意，与 data_as 不同，不会保留对数组的引用：像 ctypes.c_void_p((a + b).ctypes.data) 这样的代码将导致一个指向已解除分配的数组的指针，并且应该拼写为 (a + b).ctypes.data_as(ctypes.c_void_p)

_ctypes.shape

(c_intp*self.ndim): 一个长为 self.ndim 的 ctypes 数组，其基本类型是与平台上的 dtype('p') 对应的 C 整数（请参见 c_intp）。这个基本类型可以是 ctypes.c_int、ctypes.c_long 或 ctypes.c_longlong，这取决于平台。ctypes 数组包含底层数组的形状。

_ctypes.strides

(c_intp*self.ndim): 一个长为 self.ndim 的 ctypes 数组，其基本类型与形状属性相同。这个 ctypes 数组包含底层数组的步幅信息。这些步幅信息对于显示要跳过多少字节才能到达数组中的下一个元素是很重要的。

_ctypes.data_as(obj)

将数据指针强制转换为特定的 c 类型对象。例如，调用 self._as_parameter_ 相当于 self.data_as(ctypes.c_void_p)。也许您想将数据用作指向浮点数据的 ctypes 数组的指针：self.data_as(ctypes.POINTER(ctypes.c_double))。

返回的指针将保留对数组的引用。

_ctypes.shape_as(obj)

将形状元组作为某种其他的 c 类型类型的数组返回。例如：self.shape_as(ctypes.c_short)。

_ctypes.strides_as(obj)

以某种其他的 c 类型类型，返回作为数组的步幅元组。例如：self.strides_as(ctypes.c_longlong)。

如果 ctypes 模块不可用，则数组对象的 ctypes 属性仍将返回有用的东西，但不会返回 ctypes 对象，而是可能会引发错误。特别是，对象仍将具有 as_parameter 属性，该属性将返回一个等于数据属性的整数。

例子

>>> import ctypes
>>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
>>> x
array([[0, 1],
 [2, 3]], dtype=int32)
>>> x.ctypes.data
31962608 # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
<__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
c_uint(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
c_ulong(4294967296)
>>> x.ctypes.shape
<numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
>>> x.ctypes.strides
<numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary

`numpy.ndarray.item`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.item.html

方法

ndarray.item(*args)

将数组的一个元素复制到标准的 Python 标量并返回它。

参数：

*args参数（数量和类型可变）

none：在这种情况下，该方法仅适用于只有一个元素（a.size == 1）的数组，该元素被复制到一个标准的 Python 标量对象中并返回。
int_type：该参数被解释为数组的扁平索引，指定要复制和返回的元素。
int_types 元组：功能与单个 int_type 参数相同，只是参数被解释为数组的 nd 索引。

z标准的 Python 标量对象

副本：返回一个合适的 Python 标量，它是数组的指定元素的副本。

注意事项

当a的数据类型为 longdouble 或 clongdouble 时，item()返回一个标量数组对象，因为没有可用的 Python 标量可以不丢失信息。Void 数组对 item()返回一个缓冲区对象，除非定义了字段，在这种情况下返回一个元组。

item与 a[args]非常相似，但是返回的是一个标准的 Python 标量而不是数组标量。这对于加快访问数组元素和使用 Python 的优化数学进行数组元素的算术运算非常有用。

示例

>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
 [1, 3, 6],
 [1, 0, 1]])
>>> x.item(3)
1
>>> x.item(7)
0
>>> x.item((0, 1))
2
>>> x.item((2, 2))
1

`numpy.ndarray.tolist`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tolist.html

方法

ndarray.tolist()

将数组作为深度为a.ndim的嵌套 Python 标量列表返回。

将数组数据作为（嵌套的）Python 列表的副本返回。数据项将通过item函数转换为最接近的兼容的内置 Python 类型。

如果a.ndim为 0，那么由于嵌套列表的深度为 0，它根本不会是一个列表，而是一个简单的 Python 标量。

参数：

无

y对象，或对象列表，或对象列表的列表，或 …

数组元素可能嵌套的列表。

注意

可以通过a = np.array(a.tolist())重新创建数组，尽管这有时会丢失精度。

示例

对于一维数组，a.tolist()几乎与list(a) 相同，只不过tolist会将 numpy 标量改变为 Python 标量：

>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[1, 2]
>>> type(a_list[0])
<class 'numpy.uint32'>
>>> a_tolist = a.tolist()
>>> a_tolist
[1, 2]
>>> type(a_tolist[0])
<class 'int'>

另外，对于二维数组，tolist会递归应用：

>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]

这种递归的基本情形是 0 维数组：

>>> a = np.array(1)
>>> list(a)
Traceback (most recent call last):
  ...
TypeError: iteration over a 0-d array
>>> a.tolist()
1

`numpy.ndarray.itemset`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.itemset.html

方法

ndarray.itemset(*args)

将标量插入到数组中（如果可能，将标量转换为数组的 dtype）

必须至少有 1 个参数，并将最后一个参数定义为item。然后，a.itemset(*args) 等同于但比 a[args] = item 更快。该项应为标量值，args 必须选择数组a中的单个项。

参数:

*args参数

如果一个参数：标量，仅在大小为 1 时使用。如果两个参数：最后一个参数是要设置的值，必须是标量，第一个参数指定单个数组元素的位置。它可以是 int 类型或元组。

说明

与索引语法相比，itemset 在将标量放入ndarray的特定位置时提供了一些速度增加，如果必须这样做的话。然而，通常情况下这是不鼓励的：除了其他问题，它会使代码的外观变得复杂。此外，在循环中使用itemset（以及item）时，请确保将方法赋值给一个本地变量，以避免在每次循环迭代时进行属性查找。

示例

>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
 [1, 3, 6],
 [1, 0, 1]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[2, 2, 6],
 [1, 0, 6],
 [1, 0, 9]])

`numpy.ndarray.tostring`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tostring.html

方法

ndarray.tostring(order='C')

tobytes的兼容别名，具有完全相同的行为。

尽管其名称如此，但返回的是字节而不是字符串。

自 1.19.0 版本起被弃用。

`numpy.ndarray.tobytes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tobytes.html

方法

ndarray.tobytes(order='C')

构造包含数组中原始数据字节的 Python 字节。

构造出显示数据内存原始内容的 Python 字节。默认情况下，字节对象按照 C 顺序生成。这种行为由order参数控制。

1.9.0 版本新增。

参数:

order{‘C’, ‘F’, ‘A’}, 可选

控制字节对象的内存布局。‘C’代表 C 顺序，‘F’代表 F 顺序，‘A’（缩写形式为 Any）表示若 a 是 Fortran 连续的则返回 ‘F’，否则返回 ‘C’。默认是 ‘C’。

sbytes

显示 a 原始数据的 Python 字节。

另见

frombuffer

通过此操作的逆操作，从 Python 字节构造一个一维数组。

示例

>>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
>>> x.tobytes()
b'\x00\x00\x01\x00\x02\x00\x03\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x02\x00\x01\x00\x03\x00'

`numpy.ndarray.tofile`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tofile.html

方法

ndarray.tofile(fid, sep='', format='%s')

将数组作为文本或二进制（默认）写入文件。

数据始终以’C’顺序写入，与a的顺序无关。此方法生成的数据可以通过 fromfile()函数恢复。

参数:

fidfile or str or Path

一个打开的文件对象或包含文件名的字符串。

从版本 1.17.0 开始更改：现在接受pathlib.Path对象。

sepstr

文本输出中数组项之间的分隔符。如果为“”（空），则写入二进制文件，相当于file.write(a.tobytes())。

formatstr

文本文件输出的格式字符串。数组中的每个条目都通过首先将其转换为最接近的 Python 类型，然后使用“format” % item 来格式化为文本。

注意事项

这是一个快速存储数组数据的便捷函数。丢失了字节顺序和精度的信息，因此这种方法不适用于旨在存档数据或在具有不同字节顺序的计算机之间传输数据的文件。一些问题可以通过将数据输出为文本文件来解决，但代价是速度和文件大小。

当 fid 是一个文件对象时，数组内容直接写入文件，绕过文件对象的write方法。因此，tofile 不能与支持压缩的文件对象（例如 GzipFile）或不支持fileno()的类文件对象（例如 BytesIO）一起使用。

`numpy.ndarray.dump`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.dump.html

方法

ndarray.dump(file)

将数组的 pickle 转储到指定文件。可以使用 pickle.load 或 numpy.load 读取数组。

参数：

filestr 或 Path

一个字符串命名的转储文件。

自 1.17.0 版更改：现在接受pathlib.Path对象。

`numpy.ndarray.dumps`

numpy.org/doc/1.26/reference/generated/numpy.ndarray.dumps.html

方法

ndarray.dumps()

返回数组的 pickle 形式字符串。pickle.loads 可以将字符串转换回数组。

参数：

无

`numpy.ndarray.astype`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.astype.html

方法

ndarray.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

数组的副本，转换为指定的类型。

参数：

dtypestr 或 dtype

数组转换的类型代码或数据类型。

order{‘C’, ‘F’, ‘A’, ‘K’}，可选

控制结果的内存布局顺序。‘C’表示 C 顺序，‘F’表示 Fortran 顺序，‘A’表示如果所有数组都是 Fortran 连续的，则为‘F’顺序，否则为‘C’顺序，并且‘K’表示尽可能接近数组元素在内存中出现的顺序。默认为‘K’。

casting{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}，可选

控制可能发生的数据转换类型。默认为‘unsafe’，以保持向后兼容性。

‘no’表示不应更改数据类型。
‘equiv’表示只允许字节顺序更改。
‘safe’表示仅允许保留值的转换。
‘same_kind’表示仅允许安全转换或在种类内进行转换，如 float64 到 float32。
‘unsafe’表示可以进行任何数据转换。

subok布尔值，可选

若为 True，则子类将被传递（默认），否则返回的数组将被强制为基类数组。

copy布尔值，可选

默认情况下，astype 始终返回一个新分配的数组。如果设置为 false，并且满足dtype，order和subok的要求，则返回输入数组而不是副本。

arr_tndarray

除非copy为 False 并且返回输入数组的其他条件均满足（请参见copy输入参数的描述），arr_t是输入数组形状相同的新数组，其 dtype，order 由dtype，order给出。

提升：

ComplexWarning

从复数到浮点数或整数的转换。要避免这种情况，应该使用a.real.astype(t)。

注解

在版本 1.17.0 中更改：仅对于“unsafe”转换，简单数据类型和结构化类型之间的转换才可能发生。允许转换为多个字段，但不允许从多个字段转换。

从版本 1.9.0 开始更改：在“safe”转换模式下，从数值到字符串类型的转换需要字符串 dtype 的长度足够长，才能存储转换后的最大整数/浮点数值。

例子

>>> x = np.array([1, 2, 2.5])
>>> x
array([1\. ,  2\. ,  2.5])

>>> x.astype(int)
array([1, 2, 2])

`numpy.ndarray.byteswap`

numpy.org/doc/1.26/reference/generated/numpy.ndarray.byteswap.html

方法

ndarray.byteswap(inplace=False)

交换数组元素的字节

通过返回一个进行字节交换的数组，可选地就地交换，在小端和大端数据表示之间切换。字节字符串数组不进行交换。复数的实部和虚部分别进行交换。

参数：

inplace 布尔值，可选

如果True，就地交换字节，默认为False。

out ndarray

字节交换后的数组。如果inplace为True，则这是对自身的视图。

示例

>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> list(map(hex, A))
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([  256,     1, 13090], dtype=int16)
>>> list(map(hex, A))
['0x100', '0x1', '0x3322']

字节字符串数组不进行交换

>>> A = np.array([b'ceg', b'fac'])
>>> A.byteswap()
array([b'ceg', b'fac'], dtype='|S3')

A.newbyteorder().byteswap() 产生具有相同值的数组。

但在内存中表示方式不同

>>> A = np.array([1, 2, 3])
>>> A.view(np.uint8)
array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
 0, 0], dtype=uint8)
>>> A.newbyteorder().byteswap(inplace=True)
array([1, 2, 3])
>>> A.view(np.uint8)
array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
 0, 3], dtype=uint8)

`numpy.ndarray.copy`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.copy.html

方法

ndarray.copy(order='C')

返回数组的副本。

参数：

order{‘C’, ‘F’, ‘A’, ‘K’}，可选

控制副本的内存布局。'C'表示 C 顺序，'F'表示 F 顺序，'A'表示如果a是 Fortran 连续的，则为'F'，否则为'C'。'K'表示尽可能与a的布局匹配。（注意，该函数与numpy.copy非常相似，但对于它们的order=参数有不同的默认值，该函数始终传递子类。）

另请参见

numpy.copy

具有不同默认行为的类似函数

numpy.copyto

注释

该函数是创建数组副本的首选方法。函数numpy.copy相似，但默认使用'K'顺序，并且默认情况下不传递子类。

示例

>>> x = np.array([[1,2,3],[4,5,6]], order='F')

>>> y = x.copy()

>>> x.fill(0)

>>> x
array([[0, 0, 0],
 [0, 0, 0]])

>>> y
array([[1, 2, 3],
 [4, 5, 6]])

>>> y.flags['C_CONTIGUOUS']
True

`numpy.ndarray.view`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.view.html

方法

ndarray.view([dtype][, type])

具有相同数据的数组的新视图。

注

传递 None 给dtype与省略参数不同，因为前者调用dtype(None)，这是dtype('float_')的别名。

参数：

dtype数据类型或者 ndarray 子类，可选参数

返回视图的数据类型描述符，例如，float32 或 int16。省略它会导致视图具有与a相同的数据类型。此参数也可以指定为 ndarray 子类，这样指定了返回对象的类型（这相当于设置type参数）。

typePython 类型，可选参数

返回视图的类型，例如 ndarray 或矩阵。同样，省略该参数会保持类型不变。

注意

a.view() 有两种不同的用法：

a.view(some_dtype) 或 a.view(dtype=some_dtype) 构造具有不同数据类型的数组内存的视图。这可能会导致内存字节的重新解释。

a.view(ndarray_subclass) 或 a.view(type=ndarray_subclass) 只是返回一个查看相同数组（相同形状，dtype 等）的ndarray_subclass的实例。这不会导致对内存的重新解释。

对于a.view(some_dtype)，如果some_dtype每个条目的字节数与先前的数据类型不同（例如，将常规数组转换为结构化数组），那么a的最后一个轴必须是连续的。结果中将调整该轴的大小。

1.23.0 版本中的更改：只有最后一个轴需要是连续的。以前，整个数组都必须是 C 连续的。

例子

>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])

使用不同的类型和数据类型查看数组数据：

>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> y
matrix([[513]], dtype=int16)
>>> print(type(y))
<class 'numpy.matrix'>

创建结构化数组上的视图，以便可以在计算中使用

>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
 [3, 4]], dtype=int8)
>>> xv.mean(0)
array([2.,  3.])

对视图进行修改会更改基础数组。

>>> xv[0,1] = 20
>>> x
array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])

使用视图将数组转换为 recarray：

>>> z = x.view(np.recarray)
>>> z.a
array([1, 3], dtype=int8)

视图共享数据：

>>> x[0] = (9, 10)
>>> z[0]
(9, 10)

改变 dtype 大小（每个条目的字节数）的视图应该通常避免在由切片，转置，Fortran 顺序等定义的数组上使用：

>>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
>>> y = x[:, ::2]
>>> y
array([[1, 3],
 [4, 6]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
  ...
ValueError: To change to a dtype of a different size, the last axis must be contiguous
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 3)],
 [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])

然而，改变 dtype 的视图对于最后一个轴是连续的数组是完全可以的，即使其他轴不是 C 连续的：

>>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
>>> x.transpose(1, 0, 2).view(np.int16)
array([[[ 256,  770],
 [3340, 3854]],

 [[1284, 1798],
 [4368, 4882]],

 [[2312, 2826],
 [5396, 5910]]], dtype=int16)

`numpy.ndarray.getfield`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.getfield.html

方法

ndarray.getfield(dtype, offset=0)

返回给定数组的特定类型的字段。

字段是具有给定数据类型的数组数据的视图。视图中的值由给定类型和字节偏移决定到当前数组中。偏移量需要使视图的数据类型适合数组的数据类型；例如，dtype complex128 的数组具有 16 字节的元素。如果使用 32 位整数（4 字节）获取视图，则偏移量需要在 0 到 12 字节之间。

参数：

数据类型str 或 dtype

视图的数据类型。视图的数据类型大小不能大于数组本身的大小。

偏移量int

跳过开始查看元素之前的字节数。

示例

>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[1.+1.j,  0.+0.j],
 [0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64)
array([[1.,  0.],
 [0.,  2.]])

通过选择 8 字节的偏移量，我们可以选择数组的复数部分作为我们的视图：

>>> x.getfield(np.float64, offset=8)
array([[1.,  0.],
 [0.,  4.]])

`numpy.ndarray.setflags`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.setflags.html

方法

ndarray.setflags(write=None, align=None, uic=None)

分别设置数组标志 WRITEABLE、ALIGNED、WRITEBACKIFCOPY。

这些布尔标记会影响 NumPy 解释a占用的内存区域的方式（见下面的说明）。只有在数据实际按照类型对齐时，ALIGNED 标记才能设置为 True。WRITEBACKIFCOPY 标记永远不能被设置为 True。只有当数组拥有自己的内存，或者内存的最终所有者提供了可写的缓冲区接口，或者是字符串时，WRITEABLE 标记才能设置为 True。（对于字符串的例外是为了能够在不复制内存的情况下进行反序列化。）

参数：

writebool，可选项

指示是否能够写入a。

alignbool，可选项

描述a是否对其类型进行了正确对齐。

uicbool，可选项

描述a是否是另一个“基础”数组的副本。

说明

数组标记提供有关用于数组的内存区域如何解释的信息。有 7 个正在使用的布尔标记，其中用户只能更改四个：WRITEBACKIFCOPY、WRITEABLE 和 ALIGNED。

WRITEABLE（W）可以对数据区域进行写入；

ALIGNED（A）数据和步幅在硬件上适当对齐（由编译器决定）；

WRITEBACKIFCOPY（X）此数组是另一个“基础”数组的副本（由.base 引用）。在调用 C-API 函数 PyArray_ResolveWritebackIfCopy 时，基础数组将使用此数组的内容进行更新。

所有标记都可以使用单个（大写）字母以及完整名称来访问。

示例

>>> y = np.array([[3, 1, 7],
...               [2, 0, 0],
...               [8, 5, 9]])
>>> y
array([[3, 1, 7],
 [2, 0, 0],
 [8, 5, 9]])
>>> y.flags
 C_CONTIGUOUS : True
 F_CONTIGUOUS : False
 OWNDATA : True
 WRITEABLE : True
 ALIGNED : True
 WRITEBACKIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
 C_CONTIGUOUS : True
 F_CONTIGUOUS : False
 OWNDATA : True
 WRITEABLE : False
 ALIGNED : False
 WRITEBACKIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot set WRITEBACKIFCOPY flag to True

`numpy.ndarray.fill`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.fill.html

方法

ndarray.fill(value)

用标量值填充数组。

参数：

value标量

a的所有元素将被赋予这个值。

示例

>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1.,  1.])

Fill 期望一个标量值，并且始终与将值赋给单个数组元素的行为相同。以下是这种区别很重要的一个罕见例子：

>>> a = np.array([None, None], dtype=object)
>>> a[0] = np.array(3)
>>> a
array([array(3), None], dtype=object)
>>> a.fill(np.array(3))
>>> a
array([array(3), array(3)], dtype=object)

在其他形式的赋值会拆开被赋值的数组时：

>>> a[...] = np.array(3)
>>> a
array([3, 3], dtype=object)

`numpy.ndarray.reshape`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.reshape.html

方法

ndarray.reshape(shape, order='C')

返回一个包含相同数据的具有新形状的数组。

参考numpy.reshape获取完整文档。

另请参阅

numpy.reshape

等效函数

注意事项

与自由函数numpy.reshape不同，此方法允许将形状参数的元素作为单独的参数传递。例如，a.reshape(10, 11)等效于a.reshape((10, 11))。

`numpy.ndarray.resize`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.resize.html

方法

ndarray.resize(new_shape, refcheck=True)

原地修改数组的形状和大小。

参数：

new_shapeint 元组，或n个 int

调整大小后的数组形状。

refcheckbool, 可选

如果为 False，则不会检查引用计数。默认为 True。

None

引发异常：

ValueError

如果a没有自己拥有自己的数据，或者存在对它的引用或视图，并且数据内存必须更改。只适用于 PyPy:无法可靠地确定是否存在对其的引用或视图，因此如果数据内存必须更改，则始终会引发异常。

SystemError

如果指定了order关键字参数。这种行为是 NumPy 中的一个错误。

另请参见

resize

返回一个具有指定形状的新数组。

注意

如果需要，将重新分配数据区域的空间。

只能调整连续数组（内存中连续的数据元素）的大小。

引用计数检查的目的是确保您不将此数组用作另一个 Python 对象的缓冲区，然后重新分配内存。但是，引用计数也可能以其他方式增加，因此如果您确定您没有与另一个 Python 对象共享此数组的内存，则可以将refcheck安全地设置为 False。

示例

缩小数组：数组被展平（按照内存中存储的数据顺序），调整大小并重塑：

>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
 [1]])

>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
 [2]])

扩大数组：如上所述，但缺失的条目将用零填充：

>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
 [3, 0, 0]])

引用数组会阻止调整大小…

>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that references or is referenced ...

除非refcheck为 False：

>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])

`numpy.ndarray.transpose`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.transpose.html

method

ndarray.transpose(*axes)

返回具有轴转置的数组视图。

有关完整文档，请参阅numpy.transpose。

参数：

axesNone, tuple of ints, or n ints

没有参数或空参数：颠倒轴的顺序。
一组整数：元组中的i位于j处，意味着数组的i轴成为转置数组的j轴。
n个整数：与相同整数的 n-元组相同（这种形式只是作为元组形式的“便利”替代）。

Returns:

pndarray

视图将其轴适当地重新排列。

另请参见

transpose

等效函数。

ndarray.T

返回数组的转置。

ndarray.reshape

为数组重新定义形状，而不改变数据。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
 [3, 4]])
>>> a.transpose()
array([[1, 3],
 [2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
 [2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
 [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.transpose()
array([1, 2, 3, 4])

`numpy.ndarray.swapaxes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.swapaxes.html

方法

ndarray.swapaxes(axis1, axis2)

返回一个交换了axis1和axis2的数组视图。

参考numpy.swapaxes了解完整文档。

另请参阅

numpy.swapaxes

等价函数

`numpy.ndarray.flatten`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.flatten.html

方法

ndarray.flatten(order='C')

将数组折叠为一维的副本。

参数：

order{‘C’, ‘F’, ‘A’, ‘K’}, 可选

‘C’ 表示按行主序（C 风格）展平。‘F’ 表示按列主序（Fortran 风格）展平。‘A’ 表示如果 a 在内存中是 Fortran 连续的，则按列主序展平，否则按行主序。‘K’ 表示按内存中元素出现的顺序展平。默认为‘C’。

yndarray

输入数组的一维展平副本。

另请参阅

ravel

返回一个展平的数组。

flat

数组的一维迭代器。

示例

>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])

`numpy.ndarray.ravel`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.ravel.html

方法

ndarray.ravel([order])

返回一个被展平的数组。

参考numpy.ravel了解完整文档。

另请参阅

numpy.ravel

等效函数

ndarray.flat

该数组的扁平迭代器。

`numpy.ndarray.squeeze`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.squeeze.html

方法

ndarray.squeeze(axis=None)

从a中移除长度为一的轴。

请参考numpy.squeeze获取完整文档。

另请参阅

numpy.squeeze

等价函数

`numpy.ndarray.take`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.take.html

方法

ndarray.take(indices, axis=None, out=None, mode='raise')

返回由a中给定索引处的元素形成的数组。

请参考numpy.take查看完整文档。

另请参阅

numpy.take

等效函数

`numpy.ndarray.put`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.put.html

方法

ndarray.put(indices, values, mode='raise')

将a.flat[n] = values[n]设置为所有n中的值。

详细文档请参阅numpy.put。

另请参阅

numpy.put

等效函数

`numpy.ndarray.repeat`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.repeat.html

方法

ndarray.repeat(repeats, axis=None)

重复数组的元素。

参考numpy.repeat获取完整文档。

另请参阅

numpy.repeat

等效函数

`numpy.ndarray.choose`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.choose.html

方法

ndarray.choose(choices, out=None, mode='raise')

使用索引数组从一组选择中构建新的数组。

有关详细文档，请参阅numpy.choose。

另请参阅

numpy.choose

等效函数

`numpy.ndarray.sort`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.sort.html

方法

ndarray.sort(axis=-1, kind=None, order=None)

对数组进行就地排序。详细文档请参见 numpy.sort。

参数：

axisint，可选

要排序的轴。默认值为-1，表示沿最后一个轴进行排序。

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，可选

排序算法。默认值为“quicksort”。注意，‘stable’和‘mergesort’都在内部使用 timsort，并且实际实现通常会随数据类型的不同而变化。为了向后兼容，保留了‘mergesort’选项。

版本 1.15.0 中的更改：添加了“stable”选项。

orderstr 或 str 列表，可选

当 a 是一个具有已定义字段的数组时，此参数指定要首先比较的字段、第二个字段等。可以指定单个字段作为字符串，不需要指定所有字段，但未指定的字段仍将按照它们在 dtype 中出现的顺序使用，以打破平局。

另请参见

numpy.sort

返回一个已排序的数组副本。

numpy.argsort

间接排序。

numpy.lexsort

多个键的间接稳定排序。

numpy.searchsorted

在已排序的数组中查找元素。

numpy.partition

部分排序。

注意事项

查看 numpy.sort了解不同排序算法的说明。

示例

>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
 [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
 [1, 4]])

使用 order 关键字指定在排序结构化数组时要使用的字段：

>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([(b'c', 1), (b'a', 2)],
 dtype=[('x', 'S1'), ('y', '<i8')])

`numpy.ndarray.argsort`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.argsort.html

方法

ndarray.argsort(axis=-1, kind=None, order=None)

返回对数组进行排序的索引。

参考numpy.argsort以获取完整的文档。

另请参阅

numpy.argsort

等效函数

`numpy.ndarray.partition`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.partition.html

方法

ndarray.partition(kth, axis=-1, kind='introselect', order=None)

对数组中的元素进行重新排列，使得第 k 个位置上的元素的值处于排序后数组中的位置。所有小于第 k 个元素的元素都被移动到该元素之前，所有相等或更大的元素都被移动到该元素之后。两个分区中的元素排序是未定义的。

从版本 1.8.0 开始提供。

参数：

第 k 个int 或 int 序列

按元素索引分区。第 k 个元素的值将处于其最终排序位置，并且所有较小的元素将在其之前移动，所有相等或更大的元素将在其之后移动。分区中所有元素的顺序是未定义的。如果提供了一个 kth 序列，它将会一次将由它们的第 k 个索引的所有元素分区到其排序位置。

从版本 1.22.0 开始弃用：作为索引传递布尔值已被弃用。

轴int，可选

排序的轴。默认为-1，表示沿着最后一个轴排序。

种类{‘introselect’}，可选

选择算法。默认值为‘introselect’。

顺序str 或 str 列表，可选

当a是一个定义了字段的数组时，该参数指定要首先比较哪些字段，第二个字段等。可以将单个字段指定为字符串，并不必指定所有字段，但未指定的字段仍将被使用，在 dtype 中出现的顺序会被用来打破关系。

另请参阅

numpy.partition

返回数组的分区副本。

argpartition

间接分区。

排序

完全排序。

笔记

请参阅np.partition以了解有关不同算法的注释。

示例

>>> a = np.array([3, 4, 2, 1])
>>> a.partition(3)
>>> a
array([2, 1, 3, 4])

>>> a.partition((1, 3))
>>> a
array([1, 2, 3, 4])

`numpy.ndarray.argpartition`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.argpartition.html

方法

ndarray.argpartition(kth, axis=-1, kind='introselect', order=None)

返回对数组进行分区的索引。

请参阅numpy.argpartition了解完整文档。

在 1.8.0 版中新增。

另请参阅

numpy.argpartition

等效函数

`numpy.ndarray.searchsorted`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.searchsorted.html

方法

ndarray.searchsorted(v, side='left', sorter=None)

查找应将 v 的元素插入 a 以保持顺序的索引。

查看完整文档，请参阅numpy.searchsorted

另请参阅

numpy.searchsorted

等效函数

`numpy.ndarray.nonzero`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.nonzero.html

方法

ndarray.nonzero()

返回非零元素的索引。

请参考numpy.nonzero获取完整文档。

另请参阅

numpy.nonzero

等效函数

`numpy.ndarray.compress`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.compress.html

方法

ndarray.compress(condition, axis=None, out=None)

返回沿指定轴选择的数组切片。

参考numpy.compress获取完整文档。

另请参阅

numpy.compress

等效函数

`numpy.ndarray.diagonal`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.diagonal.html

方法

ndarray.diagonal(offset=0, axis1=0, axis2=1)

返回指定的对角线。在 NumPy 1.9 中，返回的数组是一个只读视图，而不是像以前的 NumPy 版本中那样是一个副本。在将来的版本中，只读限制将被移除。

请参考numpy.diagonal获取完整文档。

另请参阅

numpy.diagonal

等效函数

`numpy.ndarray.max`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.max.html

方法

ndarray.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)

返回沿指定轴的最大值。

参考numpy.amax获取完整文档。

另请参阅

numpy.amax

等效函数

`numpy.ndarray.argmax`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.argmax.html

方法

ndarray.argmax(axis=None, out=None, *, keepdims=False)

返回沿给定轴的最大值的索引。

有关完整文档，请参考numpy.argmax。

另请参阅

numpy.argmax

等效函数

`numpy.ndarray.min`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.min.html

方法

ndarray.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)

返回沿指定轴的最小值。

请参考numpy.amin获取完整文档。

另请参阅

numpy.amin

等效函数

`numpy.ndarray.argmin`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.argmin.html

方法

ndarray.argmin(axis=None, out=None, *, keepdims=False)

返回沿给定轴的最小值的索引。

有关详细文档，请参考numpy.argmin。

另请参阅

numpy.argmin

等效函数

`numpy.ndarray.ptp`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.ptp.html

方法

ndarray.ptp(axis=None, out=None, keepdims=False)

峰值到峰值（最大值 - 最小值）沿着给定轴的数值。

参考numpy.ptp获取完整文档。

另请参阅

numpy.ptp

等效函数

`numpy.ndarray.clip`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.clip.html

方法

ndarray.clip(min=None, max=None, out=None, **kwargs)

返回一个数值被限制在[min, max]范围内的数组。max 和 min 中必须给定一个。

详细文档请参考numpy.clip。

另请参阅

numpy.clip

等效函数

`numpy.ndarray.conj`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.conj.html

方法

ndarray.conj()

对所有元素进行复共轭。

请参考 numpy.conjugate 获取完整文档。

参见

numpy.conjugate 参考

等效函数

`numpy.ndarray.round`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.round.html

方法

ndarray.round(decimals=0, out=None)

返回* a *，其中每个元素四舍五入到给定的小数位数。

参考numpy.around获取完整文档。

另请参阅

numpy.around

等效函数

`numpy.ndarray.trace`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.trace.html

方法

ndarray.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)

返回数组沿对角线的和。

参考numpy.trace获取完整文档。

另请参阅

numpy.trace

等效函数

`numpy.ndarray.sum`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.sum.html

方法

ndarray.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)

返回沿给定轴的数组元素的总和。

请参考numpy.sum获取完整文档。

另请参阅

numpy.sum

等效函数

`numpy.ndarray.cumsum`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.cumsum.html

方法

ndarray.cumsum(axis=None, dtype=None, out=None)

返回沿给定轴的元素的累积和。

有关完整文档，请参考numpy.cumsum。

另请参阅

numpy.cumsum

等效函数

`numpy.ndarray.mean`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.mean.html

方法

ndarray.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)

返回沿给定轴的数组元素的平均值。

请参考numpy.mean获取完整文档。

另请参阅

numpy.mean

等效函数

`numpy.ndarray.var`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.var.html

方法

ndarray.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)

返回沿指定轴的数组元素的方差。

参考numpy.var获取完整文档。

另请参阅

numpy.var

等效函数

`numpy.ndarray.std`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.std.html

方法

ndarray.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)

返回沿给定轴的数组元素的标准差。

参考numpy.std获取完整文档。

另请参阅

numpy.std

等效函数

`numpy.ndarray.prod`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.prod.html

方法

ndarray.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)

返回沿给定轴的数组元素的乘积

请参考numpy.prod获取完整文档。

另请参阅

numpy.prod

等效函数

`numpy.ndarray.cumprod`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.cumprod.html

方法

ndarray.cumprod(axis=None, dtype=None, out=None)

返回沿着给定轴的元素的累积乘积。

请参考numpy.cumprod获取完整文档。

参见

numpy.cumprod

等效函数

`numpy.ndarray.all`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.all.html

方法

ndarray.all(axis=None, out=None, keepdims=False, *, where=True)

如果所有元素都评估为 True，则返回 True。

请参考numpy.all获取完整文档。

参见

numpy.all

等效函数

`numpy.ndarray.any`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.any.html

方法

ndarray.any(axis=None, out=None, keepdims=False, *, where=True)

如果a的任何元素求值为 True，则返回 True。

参考numpy.any获取完整文档。

另请参阅

numpy.any

等效函数