NumPy-1-26-中文文档-九-

NumPy 1.26 中文文档（九）

原文：numpy.org/doc/

`numpy.flip`

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

numpy.flip(m, axis=None)

反转给定轴上数组中元素的顺序。

数组的形状保持不变，但元素被重新排序。

1.12.0 版新功能。

参数：

marray_like

输入数组。

axisNone 或 int 或 int 元组，可选

翻转的轴或轴。默认情况下，axis=None 将翻转输入数组的所有轴。如果 axis 为负数，则从最后一个轴向第一个轴计数。

如果 axis 是一个 int 元组，则在元组中指定的所有轴上执行翻转。

1.15.0 版本更改：支持 None 和轴的元组

outarray_like

具有轴的条目翻转的m的视图。由于返回的是视图，因此此操作在恒定时间内完成。

另请参阅

flipud

垂直翻转数组（axis=0）。

fliplr

水平翻转数组（axis=1）。

备注

flip(m, 0) 等同于 flipud(m)。

flip(m, 1) 等同于 fliplr(m)。

flip(m, n) 对应于在位置 n 上使用::-1的m[...,::-1,...]。

flip(m) 对应于在所有位置上使用::-1的m[::-1,::-1,...,::-1]。

flip(m, (0, 1)) 对应于在位置 0 和位置 1 上使用::-1的m[::-1,::-1,...]。

示例

>>> A = np.arange(8).reshape((2,2,2))
>>> A
array([[[0, 1],
 [2, 3]],
 [[4, 5],
 [6, 7]]])
>>> np.flip(A, 0)
array([[[4, 5],
 [6, 7]],
 [[0, 1],
 [2, 3]]])
>>> np.flip(A, 1)
array([[[2, 3],
 [0, 1]],
 [[6, 7],
 [4, 5]]])
>>> np.flip(A)
array([[[7, 6],
 [5, 4]],
 [[3, 2],
 [1, 0]]])
>>> np.flip(A, (0, 2))
array([[[5, 4],
 [7, 6]],
 [[1, 0],
 [3, 2]]])
>>> A = np.random.randn(3,4,5)
>>> np.all(np.flip(A,2) == A[:,:,::-1,...])
True

`numpy.fliplr`

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

numpy.fliplr(m)

沿轴 1（左/右）反转元素的顺序。

对于 2-D 数组，这会在左/右方向上翻转每行的条目。列被保留，但顺序与之前不同。

参数：

marray_like

输入数组，必须至少为 2-D。

返回值：

fndarray

以列反转的m视图。由于返回了一个视图，因此这个操作的 (\mathcal O(1))。

另请参阅

flipud

在上/下方向上翻转数组。

flip

在一个或多个维度上翻转数组。

rot90

逆时针旋转数组。

注释

相当于 m[:,::-1] 或 np.flip(m, axis=1)。需要数组至少为 2-D。

示例

>>> A = np.diag([1.,2.,3.])
>>> A
array([[1.,  0.,  0.],
 [0.,  2.,  0.],
 [0.,  0.,  3.]])
>>> np.fliplr(A)
array([[0.,  0.,  1.],
 [0.,  2.,  0.],
 [3.,  0.,  0.]])

>>> A = np.random.randn(2,3,5)
>>> np.all(np.fliplr(A) == A[:,::-1,...])
True

`numpy.flipud`

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

numpy.flipud(m)

沿轴 0（上/下）翻转元素顺序。

对于 2-D 数组，这会上下翻转每列的条目。行被保留，但以与之前不同的顺序出现。

参数：

marry_like

输入数组。

返回值：

outarray_like

倒置了行的视图 m。由于返回的是视图，所以此操作是(\mathcal O(1))。

另请参阅

fliplr

在左/右方向上翻转数组。

flip

在一个或多个维度上翻转数组。

rot90

逆时针旋转数组。

注意事项

等同于 m[::-1, ...] 或 np.flip(m, axis=0)。要求数组至少为 1-D。

示例

>>> A = np.diag([1.0, 2, 3])
>>> A
array([[1.,  0.,  0.],
 [0.,  2.,  0.],
 [0.,  0.,  3.]])
>>> np.flipud(A)
array([[0.,  0.,  3.],
 [0.,  2.,  0.],
 [1.,  0.,  0.]])

>>> A = np.random.randn(2,3,5)
>>> np.all(np.flipud(A) == A[::-1,...])
True

>>> np.flipud([1,2])
array([2, 1])

`numpy.reshape`

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

numpy.reshape(a, newshape, order='C')

不改变数据的情况下给数组赋予新形状。

参数：

aarray_like

要被重塑的数组。

newshape整数或整数元组

新形状应兼容原始形状。如果是整数，则结果将是该长度的 1-D 数组。一个形状维度可以是-1。在这种情况下，该值从数组的长度和剩余维度中推断出。

order，可选

使用此索引顺序读取a的元素，并使用此索引顺序将元素放入重塑后的数组中。‘C’表示使用类似 C 的索引顺序读取/写入元素，最后一个轴索引最快变化，回到第一个轴索引最慢变化的顺序。‘F’表示使用类似 Fortran 的索引顺序读取/写入元素，第一个索引最快变化，最后一个索引最慢变化。请注意，‘C’和‘F’选项不考虑底层数组的内存布局，只与索引顺序有关。‘A’表示如果a在内存中是 Fortran 连续的，则按照类似 Fortran 的索引顺序读取/写入元素，否则按照类似 C 的顺序。

reshaped_arrayndarray

如果可能的话，这将是一个新的视图对象；否则将是一个副本。请注意，不能保证返回数组的内存布局（C - 或 Fortran - 连续）。

参见

ndarray.reshape

等效方法。

注释

不总是能够在不复制数据的情况下更改数组的形状。

order关键字用于指定从a中获取值和将这些值放入输出数组时的索引顺序。例如，假设你有一个数组：

>>> a = np.arange(6).reshape((3, 2))
>>> a
array([[0, 1],
 [2, 3],
 [4, 5]])

可以将重塑看作首先对数组进行拉平（使用给定的索引顺序），然后使用与用于拉平的相同类型的索引顺序将来自已拉平数组的元素插入到新数组中。

>>> np.reshape(a, (2, 3)) # C-like index ordering
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
array([[0, 4, 3],
 [2, 1, 5]])
>>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
array([[0, 4, 3],
 [2, 1, 5]])

例子

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

>>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
array([[1, 2],
 [3, 4],
 [5, 6]])

`numpy.roll`

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

numpy.roll(a, shift, axis=None)

沿着给定轴滚动数组元素。

超出最后位置的元素会重新出现在第一个位置。

参数：

aarray_like

输入数组。

shiftint or tuple of ints

移动元素的位置数。如果是元组，则axis必须是相同大小的元组，每个给定轴都由相应的数字移动。如果axis是整数，而axis是整数元组，则所有给定轴都使用相同的值。

axisint or tuple of ints, optional

元素被移动的轴或轴。默认情况下，在移位之前，数组被展平，然后恢复原始形状。

resndarray

输出数组，与a具有相同的形状。

另请参见

rollaxis

将指定轴向后滚动，直到它处于给定位置。

注意

自 1.12.0 版本开始。

支持同时在多个维度上滚动。

示例

>>> x = np.arange(10)
>>> np.roll(x, 2)
array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
>>> np.roll(x, -2)
array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])

>>> x2 = np.reshape(x, (2, 5))
>>> x2
array([[0, 1, 2, 3, 4],
 [5, 6, 7, 8, 9]])
>>> np.roll(x2, 1)
array([[9, 0, 1, 2, 3],
 [4, 5, 6, 7, 8]])
>>> np.roll(x2, -1)
array([[1, 2, 3, 4, 5],
 [6, 7, 8, 9, 0]])
>>> np.roll(x2, 1, axis=0)
array([[5, 6, 7, 8, 9],
 [0, 1, 2, 3, 4]])
>>> np.roll(x2, -1, axis=0)
array([[5, 6, 7, 8, 9],
 [0, 1, 2, 3, 4]])
>>> np.roll(x2, 1, axis=1)
array([[4, 0, 1, 2, 3],
 [9, 5, 6, 7, 8]])
>>> np.roll(x2, -1, axis=1)
array([[1, 2, 3, 4, 0],
 [6, 7, 8, 9, 5]])
>>> np.roll(x2, (1, 1), axis=(1, 0))
array([[9, 5, 6, 7, 8],
 [4, 0, 1, 2, 3]])
>>> np.roll(x2, (2, 1), axis=(1, 0))
array([[8, 9, 5, 6, 7],
 [3, 4, 0, 1, 2]])

`numpy.rot90`

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

numpy.rot90(m, k=1, axes=(0, 1))

在指定轴平面上将数组旋转 90 度。

旋转方向是从第一个轴朝向第二个轴。这意味着对于默认的 k 和 axes 的 2D 数组，旋转将是逆时针方向的。

参数：

m 数组类型

二维或以上维度的数组。

k 整数

数组旋转 90 度的次数。

axes(2,) 数组类型

数组在轴定义的平面上旋转。轴必须不同。

自版本 1.12.0 开始引入。

y ndarray

m 的旋转视图。

同样可以参考：

flip

沿着给定轴翻转数组元素的顺序。

fliplr

水平翻转数组。

flipud

垂直翻转数组。

注意

rot90(m, k=1, axes=(1,0)) 是 rot90(m, k=1, axes=(0,1)) 的逆操作

rot90(m, k=1, axes=(1,0)) 等同于 rot90(m, k=-1, axes=(0,1))

示例

>>> m = np.array([[1,2],[3,4]], int)
>>> m
array([[1, 2],
 [3, 4]])
>>> np.rot90(m)
array([[2, 4],
 [1, 3]])
>>> np.rot90(m, 2)
array([[4, 3],
 [2, 1]])
>>> m = np.arange(8).reshape((2,2,2))
>>> np.rot90(m, 1, (1,2))
array([[[1, 3],
 [0, 2]],
 [[5, 7],
 [4, 6]]])

二进制操作

原文：numpy.org/doc/1.26/reference/routines.bitwise.html

逐元素位操作

`bitwise_and`(x1, x2, /[, out, where, ...])	计算两个数组的按位 AND，逐元素地。
`bitwise_or`(x1, x2, /[, out, where, casting, ...])	计算两个数组的按位 OR，逐元素地。
`bitwise_xor`(x1, x2, /[, out, where, ...])	计算两个数组的按位 XOR，逐元素地。
`invert`(x, /[, out, where, casting, order, ...])	计算元素的按位取反，或按位 NOT，逐元素地。
`left_shift`(x1, x2, /[, out, where, casting, ...])	将整数的位向左移动。
`right_shift`(x1, x2, /[, out, where, ...])	将整数的位向右移动。

位打包

`packbits`(a, /[, axis, bitorder])	将二值数组的元素打包到一个 uint8 数组的位中。
`unpackbits`(a, /[, axis, count, bitorder])	将 uint8 数组的元素解包到一个二值输出数组中。

输出格式化

`binary_repr`(num[, width])	返回输入数字的二进制表示作为字符串。

逐元素位操作

`bitwise_and`(x1, x2, /[, out, where, ...])	计算两个数组的按位 AND，逐元素地。
`bitwise_or`(x1, x2, /[, out, where, casting, ...])	计算两个数组的按位 OR，逐元素地。
`bitwise_xor`(x1, x2, /[, out, where, ...])	计算两个数组的按位 XOR，逐元素地。
`invert`(x, /[, out, where, casting, order, ...])	计算元素的按位取反，或按位 NOT，逐元素地。
`left_shift`(x1, x2, /[, out, where, casting, ...])	将整数的位向左移动。
`right_shift`(x1, x2, /[, out, where, ...])	将整数的位向右移动。

位打包

`packbits`(a, /[, axis, bitorder])	将二值数组的元素打包为 uint8 数组中的位。
`unpackbits`(a, /[, axis, count, bitorder])	将 uint8 数组的元素解包为二值输出数组。

输出格式化

`binary_repr`(num[, width])	将输入数字返回为字符串形式的二进制表示。

`numpy.bitwise_and`

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

numpy.bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'bitwise_and'>

逐个元素对两个数组进行按位 AND 计算。

计算输入数组中整数的基础二进制表示的按位 AND。这个 ufunc 实现了 C/Python 运算符 &。

参数：

x1, x2 array_like

仅处理整数和布尔类型。如果 x1.shape != x2.shape，它们必须可以广播到一个共同的形状（这将成为输出的形状）。

out ndarray、None 或者 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果不提供或为 None，则返回一个新分配的数组。一个元组（仅限关键字参数）的长度必须等于输出数量。

where array_like，可选

此条件广播到输入。在条件为真的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了未初始化的 out 数组，则其中条件为假的位置将保持未初始化。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

out ndarray 或者标量

结果。如果 x1 和 x2 都是标量，则为标量。

另请参阅

logical_and

bitwise_or

bitwise_xor

binary_repr

将输入数字的二进制表示作为字符串返回。

示例

数字 13 的表示为 00001101。同样，数字 17 的表示为 00010001。因此，13 和 17 的按位 AND 是 00000001，即 1：

>>> np.bitwise_and(13, 17)
1

>>> np.bitwise_and(14, 13)
12
>>> np.binary_repr(12)
'1100'
>>> np.bitwise_and([14,3], 13)
array([12,  1])

>>> np.bitwise_and([11,7], [4,25])
array([0, 1])
>>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
array([ 2,  4, 16])
>>> np.bitwise_and([True, True], [False, True])
array([False,  True])

& 运算符可用作对 ndarrays 上的 np.bitwise_and 的简写。

>>> x1 = np.array([2, 5, 255])
>>> x2 = np.array([3, 14, 16])
>>> x1 & x2
array([ 2,  4, 16])

`numpy.bitwise_or`

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

numpy.bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'bitwise_or'>

逐元素计算两个数组的按位 OR。

计算输入数组中整数的基础二进制表示的按位 OR。此 ufunc 实现了 C/Python 运算符|。

参数：

x1, x2 array_like

仅处理整数和布尔类型。如果x1.shape != x2.shape，它们必须可广播到一个公共形状（这成为输出的形状）。

out ndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有输出数量相等的长度。

where array_like，可选

此条件在输入上进行广播。在条件为真的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

关于其他关键字限定参数，请参见 ufunc 文档。

返回值：

out ndarray 或标量

结果。如果x1和x2都是标量，则这是一个标量。

另请参见

logical_or

bitwise_and

bitwise_xor

binary_repr

将输入数字的二进制表示作为字符串返回。

示例

数字 13 的二进制表示为00001101。同样，16 表示为00010000。然后，13 和 16 的按位 OR 运算结果为00011101，即 29：

>>> np.bitwise_or(13, 16)
29
>>> np.binary_repr(29)
'11101'

>>> np.bitwise_or(32, 2)
34
>>> np.bitwise_or([33, 4], 1)
array([33,  5])
>>> np.bitwise_or([33, 4], [1, 2])
array([33,  6])

>>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))
array([  6,   5, 255])
>>> np.array([2, 5, 255]) | np.array([4, 4, 4])
array([  6,   5, 255])
>>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
...               np.array([4, 4, 4, 2147483647], dtype=np.int32))
array([         6,          5,        255, 2147483647])
>>> np.bitwise_or([True, True], [False, True])
array([ True,  True])

| 运算符可用作 ndarrays 上np.bitwise_or的简写。

>>> x1 = np.array([2, 5, 255])
>>> x2 = np.array([4, 4, 4])
>>> x1 | x2
array([  6,   5, 255])

`numpy.bitwise_xor`

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

numpy.bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'bitwise_xor'>

逐元素计算两个数组的位异或。

计算输入数组中整数的基础二进制表示的位异或。此 ufunc 实现了 C/Python 运算符 ^。

参数：

x1, x2array_like

仅处理整数和布尔类型。如果 x1.shape != x2.shape，它们必须能够广播到一个公共形状（这成为输出的形状）。

outndarray, None, 或包含 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数目相等的长度。

wherearray_like，可选

此条件在输入上进行广播。在此条件为真的位置，out 数组将设置为 ufunc 结果。其他地方，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建未初始化的 out 数组，则其中条件为假的位置将保持未初始化。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

outndarray 或标量

结果。如果 x1 和 x2 均为标量，则为标量。

另请参阅

logical_xor

bitwise_and

bitwise_or

binary_repr

返回输入数字的二进制表示形式作为字符串。

示例

数字 13 的表示为 00001101。同样，数字 17 的表示为 00010001。因此，13 和 17 的位异或是 00011100，即 28：

>>> np.bitwise_xor(13, 17)
28
>>> np.binary_repr(28)
'11100'

>>> np.bitwise_xor(31, 5)
26
>>> np.bitwise_xor([31,3], 5)
array([26,  6])

>>> np.bitwise_xor([31,3], [5,6])
array([26,  5])
>>> np.bitwise_xor([True, True], [False, True])
array([ True, False])

^ 运算符可用作对 ndarrays 的 np.bitwise_xor 的简写。

>>> x1 = np.array([True, True])
>>> x2 = np.array([False, True])
>>> x1 ^ x2
array([ True, False])

`numpy.invert`

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

numpy.invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'invert'>

计算按位取反，即按位“非”。

计算输入数组中整数的基础二进制表示的按位“非”。此 ufunc 实现了 C/Python 运算符 ~。

对于有符号整数输入，返回补码。在二进制补码系统中，负数由绝对值的补码表示。这是计算机上表示有符号整数最常用的方法[1]。一个 N 位的二进制补码系统可以表示范围在 (-2^{N-1}) 到 (+2^{N-1}-1) 的每一个整数。

参数：

xarray_like

只处理整数和布尔类型。

outndarray、None 或 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数。

wherearray_like，可选

此条件广播到输入。在条件为 True 的位置，out 数组将被设置为 ufunc 的结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了一个未初始化的 out 数组，则在其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

outndarray 或标量

结果。如果 x 是标量，则这是一个标量。

另请参阅

位与，位或，位异或

logical_not

binary_repr

将输入数字的二进制表示作为字符串返回。

注意

bitwise_not 是 invert 的别名：

>>> np.bitwise_not is np.invert
True

参考

[1]

维基百科中的“二进制补码”，en.wikipedia.org/wiki/Two’s_complement

示例

我们已经看到 13 被表示为 00001101。13 的反码或按位“非”是：

>>> x = np.invert(np.array(13, dtype=np.uint8))
>>> x
242
>>> np.binary_repr(x, width=8)
'11110010'

结果取决于位宽：

>>> x = np.invert(np.array(13, dtype=np.uint16))
>>> x
65522
>>> np.binary_repr(x, width=16)
'1111111111110010'

当使用有符号整数类型时，结果是无符号类型结果的补码：

>>> np.invert(np.array([13], dtype=np.int8))
array([-14], dtype=int8)
>>> np.binary_repr(-14, width=8)
'11110010'

也接受布尔值：

>>> np.invert(np.array([True, False]))
array([False,  True])

~ 运算符可以用作 ndarray 上 np.invert 的速记方式。

>>> x1 = np.array([True, False])
>>> ~x1
array([False,  True])

`numpy.left_shift`

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

numpy.left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'left_shift'>

将整数的位向左移动。

通过在x1右侧附加x2个 0 来向左移动位。由于数字的内部表示是以二进制格式，该操作等效于将x1乘以2**x2。

参数：

x1整型 array_like

输入数值。

x2整型数组

要附加到x1的零的数量。必须是非负整数。如果x1.shape != x2.shape，它们必须可广播到一个公共形状（这将成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入进行广播的形状。如果未提供或为 None，则将返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件将在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

out整型数组

返回将x1向左移动x2次的结果。如果x1和x2都是标量，则为标量。

亦参见

right_shift

将整数的位向右移动。

binary_repr

将输入数的二进制表示形式作为字符串返回。

示例

>>> np.binary_repr(5)
'101'
>>> np.left_shift(5, 2)
20
>>> np.binary_repr(20)
'10100'

>>> np.left_shift(5, [1,2,3])
array([10, 20, 40])

请注意，第二个参数的 dtype 可能会改变结果的 dtype，并可能在某些情况下导致意外的结果（请参阅强制转换规则）：

>>> a = np.left_shift(np.uint8(255), 1) # Expect 254
>>> print(a, type(a)) # Unexpected result due to upcasting
510 <class 'numpy.int64'>
>>> b = np.left_shift(np.uint8(255), np.uint8(1))
>>> print(b, type(b))
254 <class 'numpy.uint8'>

<<运算符可用作 ndarray 上np.left_shift的简写。

>>> x1 = 5
>>> x2 = np.array([1, 2, 3])
>>> x1 << x2
array([10, 20, 40])

`numpy.right_shift`

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

numpy.right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'right_shift'>

将整数的位向右移动。

位数向右移动 x2。因为数字的内部表示是二进制格式，所以该操作等同于将 x1 除以 2**x2。

参数：

x1array_like，int

输入值。

x2array_like，int

从 x1 的右边移除的位数。如果 x1.shape != x2.shape，它们必须能够进行广播以获得公共形状（该形状成为输出的形状）。

outndarray、None 或包含 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数目。

wherearray_like，可选

这个条件在输入中进行广播。在条件为真的位置，out 数组将被设置为 ufunc 结果。其他位置，out 数组将保持其原始值。请注意，如果通过默认 out=None 创建了一个未初始化的 out 数组，在其中条件为假的位置将保持未初始化。

**kwargs

有关其他关键字参数，请参见 ufunc 文档。

outndarray、int

将位数向右移动 x2 次的 x1 返回。如果 x1 和 x2 都是标量，返回标量。

另请参见

left_shift

将整数的位向左移动。

binary_repr

以字符串形式返回输入数字的二进制表示。

示例

>>> np.binary_repr(10)
'1010'
>>> np.right_shift(10, 1)
5
>>> np.binary_repr(5)
'101'

>>> np.right_shift(10, [1,2,3])
array([5, 2, 1])

在 ndarrays 上，>> 操作符可以作为 np.right_shift 的简写。

>>> x1 = 10
>>> x2 = np.array([1,2,3])
>>> x1 >> x2
array([5, 2, 1])

`numpy.packbits`

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

numpy.packbits(a, /, axis=None, bitorder='big')

将二进制值数组的元素打包成 uint8 数组中的位。

结果通过在末尾插入零位来填充到完整的字节。

参数：

a类似数组

应该被打包成位的整数或布尔值数组。

axis整数，可选

进行位包装的维度。None表示打包平坦数组。

bitorder，可选

输入位的顺序。'big'会模仿 bin(val)，[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011，'little'将颠倒顺序，所以[1, 1, 0, 0, 0, 0, 0, 0] => 3。默认为'big'。

版本 1.17.0 中的新功能。

packed数组

类型为 uint8 的数组，其元素表示与输入元素的逻辑值（0 或非零）相对应的位。 packed的形状与输入的维数相同（除非axis为 None，否则输出为 1-D）。

另请参阅

unpackbits

将 uint8 数组的元素拆包为二进制值输出数组。

例子

>>> a = np.array([[[1,0,1],
...                [0,1,0]],
...               [[1,1,0],
...                [0,0,1]]])
>>> b = np.packbits(a, axis=-1)
>>> b
array([[[160],
 [ 64]],
 [[192],
 [ 32]]], dtype=uint8)

注意，在二进制中 160 = 1010 0000，64 = 0100 0000，192 = 1100 0000，32 = 0010 0000。

`numpy.unpackbits`

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

numpy.unpackbits(a, /, axis=None, count=None, bitorder='big')

将 uint8 数组的元素解包到二进制值输出数组中。

a的每个元素表示应解压缩为二进制值输出数组的位字段。输出数组的形状要么是 1-D（如果axis为None），要么与指定轴一起解压缩的输入数组形状相同。

参数：

andarray，uint8 类型

输入数组。

axisint，可选

进行位解压缩的维度。None表示解压缩扁平化数组。

countint 或 None，可选

要沿* axis 解包的元素数，以撤消大小不是 8 的倍数的打包效果的方法。非负数意味着仅解包 count *位。负数意味着从末尾截取这么多位。None 意味着解包整个数组（默认）。更多的计数将在输出中添加零填充。负计数不能超过可用位数。

版本 1.17.0 中的新功能。

bitorder，可选

返回比特的顺序。‘big’将模仿 bin（val）， 3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]，‘little’将反转顺序为 [1, 1, 0, 0, 0, 0, 0, 0]。默认为‘big’。

版本 1.17.0 中的新功能。

unpackedndarray，uint8 类型

元素是二进制值（0 或 1）。

另请参阅

packbits

将二进制值数组的元素打包到 uint8 数组中的位中。

示例

>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
 [ 7],
 [23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
 [0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
>>> c = np.unpackbits(a, axis=1, count=-3)
>>> c
array([[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0]], dtype=uint8)

>>> p = np.packbits(b, axis=0)
>>> np.unpackbits(p, axis=0)
array([[0, 0, 0, 0, 0, 0, 1, 0],
 [0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 1, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
>>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
True

`numpy.binary_repr`

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

numpy.binary_repr(num, width=None)

返回输入数字的二进制表示作为字符串。

对于负数，如果没有给出 width，则在前面添加一个负号。如果给出了 width，则返回该数的补码，相对于该 width。

在二进制补码系统中，负数由绝对值的补码表示。这是计算机上表示有符号整数最常用的方法[1]。N 位二进制补码系统可以表示范围内的每个整数 (-2^{N-1}) 到 (+2^{N-1}-1)。

参数：

numint

只能使用整数的十进制数。

widthint，可选

如果 num 为正数，则返回的字符串的长度；如果 num 为负数，则返回补码的长度，前提是 width 至少为 num 在指定形式中被表示的足够位数。

如果 width 值不足够，它将被忽略，并且 num 将以二进制形式 (num > 0) 或补码形式 (num < 0) 返回，其宽度等于以指定形式表示该数所需的最小位数。此行为已废弃，并将在以后引发错误。

自版本 1.12.0 弃用。

binstr

num 的二进制表示或 num 的补码。

参见

base_repr

返回数字在给定基数系统中的字符串表示。

bin

Python 内置的整数的二进制表示生成器。

注意事项

binary_repr 相当于使用基数 2 的 base_repr，但速度约为 25 倍。

参考

[1]

维基百科，“二进制补码”，en.wikipedia.org/wiki/Two’s_complement

示例

>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011'

当输入的数为负数且指定了 width 时，返回两个的补码：

>>> np.binary_repr(-3, width=3)
'101'
>>> np.binary_repr(-3, width=5)
'11101'

字符串操作

原文：numpy.org/doc/1.26/reference/routines.char.html

numpy.char 模块为类型为 numpy.str_ 或 numpy.bytes_ 的数组提供一组矢量化的字符串操作。例如

>>> np.char.capitalize(["python", "numpy"])
array(['Python', 'Numpy'], dtype='<U6')
>>> np.char.add(["num", "doc"], ["py", "umentation"])
array(['numpy', 'documentation'], dtype='<U13')

这个模块中的方法基于 String 模块中的方法

字符串操作

`add`(x1, x2)	返回两个 str 或 unicode 类型的数组逐元素进行字符串拼接的结果。
`multiply`(a, i)	返回(a * i)，即字符串的多次连接，逐个元素进行。
`mod`(a, values)	返回(a % i)，即对一对 str 或 unicode 类型的数组进行原始的 Python 2.6 字符串格式化（插值）。
`capitalize`(a)	返回一个只有每个元素的首字母大写的副本。
`center`(a, width[, fillchar])	返回一个将其元素居中在长度为 width 的字符串中的副本。
`decode`(a[, encoding, errors])	调用 `bytes.decode` 逐个进行。
`encode`(a[, encoding, errors])	调用 str.encode 逐个进行。
`expandtabs`(a[, tabsize])	返回将每个字符串元素中的制表符字符替换为一个或多个空格的副本。
`join`(sep, seq)	返回一个字符串，是序列 seq 中字符串的连接。
`ljust`(a, width[, fillchar])	返回一个将 a 的元素左对齐在长度为 width 的字符串中的副本。
`lower`(a)	返回将元素转换为小写的数组。
`lstrip`(a[, chars])	对于 a 中的每个元素，返回一个去除了前导字符的副本。
`partition`(a, sep)	分割 a 中的每个元素，围绕 sep 进行。
`replace`(a, old, new[, count])	对于 a 中的每个元素，返回一个将所有子字符串 old 替换为 new 的字符串副本。
`rjust`(a, width[, fillchar])	返回a元素的一个数组，右对齐在一个长度为width的字符串中。
`rpartition`(a, sep)	每个元素围绕最右边的分隔符分隔（拆分）元素。
`rsplit`(a[, sep, maxsplit])	对于a中的每个元素，返回字符串中的单词列表，使用sep作为分隔符字符串。
`rstrip`(a[, chars])	对于a中的每个元素，返回带有去除尾随字符的副本。
`split`(a[, sep, maxsplit])	对于a中的每个元素，返回字符串中的单词列表，使用sep作为分隔符字符串。
`splitlines`(a[, keepends])	对于a中的每个元素，返回元素中的行列表，按行分隔。
`strip`(a[, chars])	对于a中的每个元素，返回一个去除了前导和尾随字符的副本。
`swapcase`(a)	返回字符串的每个元素的副本，其中大写字母转换为小写字母，反之亦然。
`title`(a)	返回经过标题大小写处理的字符串或 Unicode 的每个元素方式。
`translate`(a, table[, deletechars])	对于a中的每个元素，返回去除了所有出现在可选参数deletechars中的字符的字符串的副本，并且剩余的字符已通过给定的转换表进行映射。
`upper`(a)	返回��元素转换为大写的数组。
`zfill`(a, width)	返回用零填充的数字字符串

比较

与标准的 numpy 比较运算符不同，char模块中的运算符在执行比较之前会去除尾随的空白字符。

`equal`(x1, x2)	返回(x1 == x2)元素方式。
`not_equal`(x1, x2)	返回(x1 != x2)元素方式。
`greater_equal`(x1, x2)	返回(x1 >= x2)元素方式。
`less_equal`(x1, x2)	按元素方式返回 (x1 <= x2)。
`greater`(x1, x2)	按元素方式返回 (x1 > x2)。
`less`(x1, x2)	按��素方式返回 (x1 < x2)。
`compare_chararrays`(a1, a2, cmp, rstrip)	使用cmp_op指定的比较运算符对两个字符串数组进行按元素比较。

字符串信息

`count`(a, sub[, start, end])	返回一个数组，其中包含子字符串 sub 在范围 [start, end] 中的非重叠出现次数。
`endswith`(a, suffix[, start, end])	返回一个布尔数组，其中字符串元素在 a 末尾以 suffix 结尾时为 True，否则为 False。
`find`(a, sub[, start, end])	对于每个元素，返回字符串中找到子字符串 sub 的最低索引。
`index`(a, sub[, start, end])	类似于`find`，但在子字符串未找到时会引发ValueError。
`isalpha`(a)	如果字符串中所有字符都是字母并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isalnum`(a)	如果字符串中所有字符都是字母数字并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isdecimal`(a)	对于每个元素，如果元素中只有十进制字符，则返回 True。
`isdigit`(a)	如果字符串中所有字符都是数字并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`islower`(a)	如果字符串中所有大小写字符都是小写并且至少有一个大小写字符，则对每个元素返回 true，否则返回 false。
`isnumeric`(a)	对于每个元素，如果元素中只有数字字符，则返回 True。
`isspace`(a)	如果字符串中只有空白字符且至少包含一个字符，则返回 true，否则返回 false。
`istitle`(a)	如果元素是 titlecased 字符串且至少包含一个字符，则返回 true，否则返回 false。
`isupper`(a)	如果字符串中的所有大小写字符都是大写且至少包含一个字符，则返回 true，否则返回 false。
`rfind`(a, sub[, start, end])	对于a中的每个元素，返回字符串中子字符串sub所在的最高索引，使得sub包含在[start, end]内。
`rindex`(a, sub[, start, end])	类似于`rfind`，但当未找到子字符串sub时引发ValueError。
`startswith`(a, prefix[, start, end])	返回布尔数组，其中True表示a中的字符串元素以prefix开头，否则为False。
`str_len`(a)	返回逐元素的 len(a)。

便捷类

`array`(obj[, itemsize, copy, unicode, order])	创建一个`chararray`。
`asarray`(obj[, itemsize, unicode, order])	将输入转换为`chararray`，只在必要时复制数据。
`chararray`(shape[, itemsize, unicode, ...])	提供对字符串和 unicode 值数组的便捷视图。

字符串操作

`add`(x1, x2)	返回两个 str 或 unicode 数组的逐元素字符串连接。
`multiply`(a, i)	返回(a * i)，即字符串多次连接，逐元素处理。
`mod`(a, values)	为一对 str 或 unicode 的数组对返回(a % i)，即 Python 2.6 之前的字符串格式化（插值），逐元素处理。
`capitalize`(a)	仅将每个元素的第一个字符大写后返回a的副本。
`center`(a, width[, fillchar])	返回在长度为width的字符串中，a的元素居中的副本。
`decode`(a[, encoding, errors])	逐个调用`bytes.decode`。
`encode`(a[, encoding, errors])	逐个调用str.encode。
`expandtabs`(a[, tabsize])	返回每个字符串元素的副本，其中所有制表符都被一个或多个空格替换。
`join`(sep, seq)	返回一个字符串，��中是序列seq中字符串的串联。
`ljust`(a, width[, fillchar])	返回一个数组，其中a中的元素左对齐在长度为width的字符串中。
`lower`(a)	返回将元素转换为小写的数组。
`lstrip`(a[, chars])	对于a中的每个元素，返回删除开头字符的副本。
`partition`(a, sep)	围绕sep对a中的每个元素进行划分。
`replace`(a, old, new[, count])	对于a中的每个元素，返回所有子字符串old替换为new的副本。
`rjust`(a, width[, fillchar])	返回一个数组，其中a中的元素右对齐在长度为width的字符串中。
`rpartition`(a, sep)	围绕最右边的分隔符对每个元素进行划分。
`rsplit`(a[, sep, maxsplit])	对于a中的每个元素，使用sep作为分隔符，返回字符串中单词的列表。
`rstrip`(a[, chars])	对于a中的每个元素，返回删除尾随字符的副本。
`split`(a[, sep, maxsplit])	对于a中的每个元素，使用sep作为分隔符，返回字符串中单词的列表。
`splitlines`(a[, keepends])	对于a中的每个元素，返回元素中的行列表，在行边界处断开。
`strip`(a[, chars])	对于a中的每个元素，返回一个删除了前导和尾随字符的副本。
`swapcase`(a)	返回一个字符串的副本，其中大写字符转换为小写，反之亦然。
`title`(a)	返回元素主题式大小写版本的字符串或 Unicode。
`translate`(a, table[, deletechars])	对于a中的每个元素，返回一个字符串的副本，在这个副本中，所有出现在可选参数deletechars中的字符都被删除，其余字符通过给定的翻译表进行映射。
`upper`(a)	返回一个元素转换为大写的数组。
`zfill`(a, width)	返回以零填充的数值字符串

比较

与标准 numpy 比较运算符不同，char模块中的比较运算符在执行比较之前会去除尾随的空白字符。

`equal`(x1, x2)	返回(x1 == x2)的每个元素。
`not_equal`(x1, x2)	返回(x1 != x2)的每个元素。
`greater_equal`(x1, x2)	返回(x1 >= x2)的每个元素。
`less_equal`(x1, x2)	返回(x1 <= x2)的每个元素。
`greater`(x1, x2)	返回(x1 > x2)的每个元素。
`less`(x1, x2)	返回(x1 < x2)的每个元素。
`compare_chararrays`(a1, a2, cmp, rstrip)	使用cmp_op指定的比较运算符，对两个字符串数组进行逐元素比较。

字符串信息

`count`(a, sub[, start, end])	返回一个数组，其中包含范围[start, end]内子字符串sub的非重叠出现次数。
`endswith`(a, suffix[, start, end])	返回一个布尔数组，其中 True 表示 a 中的字符串元素以 suffix 结尾，否则为 False。
`find`(a, sub[, start, end])	对每个元素，返回子字符串 sub 第一次出现的最低索引。
`index`(a, sub[, start, end])	类似于 `find`，但在子字符串未找到时引发 ValueError。
`isalpha`(a)	如果字符串中所有字符都是字母且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isalnum`(a)	对每个元素，如果字符串中所有字符都是字母数字且至少有一个字符，则返回 true，否则返回 false。
`isdecimal`(a)	对每个元素，如果元素中只��十进制字符，则返回 True。
`isdigit`(a)	对每个元素，如果字符串中所有字符都是数字且至少有一个字符，则返回 true，否则返回 false。
`islower`(a)	如果字符串中所有大小写字符都是小写且至少有一个大小写字符，则对每个元素返回 true，否则返回 false。
`isnumeric`(a)	对每个元素，如果元素中只有数字字符，则返回 True。
`isspace`(a)	对每个元素，如果字符串中只有空格字符且至少有一个字符，则返回 true，否则返回 false。
`istitle`(a)	如果元素是首字母大写且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isupper`(a)	对每个元素，如果字符串中所有大小写字符都是大写且至少有一个大小写字符，则返回 true，否则返回 false。
`rfind`(a, sub[, start, end])	对于 a 中的每个元素，返回子字符串 sub 最后一次出现的最高索引，使得 sub 包含在 [start, end] 中。
`rindex`(a, sub[, start, end])	类似于`rfind`，但在子字符串sub未找到时引发ValueError错误。
`startswith`(a, prefix[, start, end])	返回一个布尔数组，其中字符串元素在a中以prefix开头为True，否则为False。
`str_len`(a)	返回元素 a 的长度。

便利类

`array`(obj[, itemsize, copy, unicode, order])	创建一个`chararray`。
`asarray`(obj[, itemsize, unicode, order])	将输入转换为`chararray`，仅在必要时复制数据。
`chararray`(shape[, itemsize, unicode, ...])	为字符串和 unicode 值的数组提供了便利的视图。

`numpy.char.add`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.add.html

char.add(x1, x2)

返回两个 str 或 unicode 数组的逐元素字符串连接。

x1和x2必须具有相同的形状。

参数：

x1str 或 unicode 数组或 str 或 unicode 数组样式的数组

输入数组。

x2str 或 unicode 数组或 str 或 unicode 数组样式的数组

输入数组。

返回值：

addndarray

输出数组为与x1和x2具有相同形状和输入类型的bytes_或str_。

`numpy.char.multiply`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.multiply.html

char.multiply(a, i)

返回(a * i)，即字符串多次连接，逐元素处理。

小于 0 的i值被视为 0（这将产生一个空字符串）。

参数:

a字符串或 Unicode 的数组

i整数的数组

outndarray

输出字符串数组或 Unicode，取决于输入类型

示例

>>> a = np.array(["a", "b", "c"])
>>> np.char.multiply(x, 3)
array(['aaa', 'bbb', 'ccc'], dtype='<U3')
>>> i = np.array([1, 2, 3])
>>> np.char.multiply(a, i)
array(['a', 'bb', 'ccc'], dtype='<U3')
>>> np.char.multiply(np.array(['a']), i)
array(['a', 'aa', 'aaa'], dtype='<U3')
>>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3))
>>> np.char.multiply(a, 3)
array([['aaa', 'bbb', 'ccc'],
 ['ddd', 'eee', 'fff']], dtype='<U3')
>>> np.char.multiply(a, i)
array([['a', 'bb', 'ccc'],
 ['d', 'ee', 'fff']], dtype='<U3')

`numpy.char.mod`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.mod.html

char.mod(a, values)

返回（a % i），即在 Python 2.6 之前的字符串格式化（插值），对于一对 str 或 unicode 类型的 array_like 进行按元素操作。

参数:

astr 或 unicode 的 array_like

values值的 array_like

这些值将被按元素插值到字符串中。

返回值:

outndarray

输出的 str 或 unicode 数组，取决于输入类型

另请参阅

str.__mod__

`numpy.char.capitalize`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.capitalize.html

char.capitalize(a)

返回 a 的副本，其中每个元素的第一个字符大写。

逐个元素调用 str.capitalize。

对于 8 位字符串，此方法取决于区域设置。

参数：

a 字符串或 Unicode 的数组

输入需要大写首字母的字符串数组。

out ndarray

输出字符串或 Unicode 数组，具体取决于输入类型

另请参阅

str.capitalize

示例

>>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c
array(['a1b2', '1b2a', 'b2a1', '2a1b'],
 dtype='|S4')
>>> np.char.capitalize(c)
array(['A1b2', '1b2a', 'B2a1', '2a1b'],
 dtype='|S4')

`numpy.char.center`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.center.html

char.center(a, width, fillchar=' ')

返回* a 的副本，其元素在长度为 width *的字符串中居中。

逐个元素调用str.center。

参数：

a数组或字符串的数组

width整数

结果字符串的长度

fillchar字符串或 unicode，可选

要使用的填充字符（默认为空格）。

out数组

输出数组，类型取决于输入类型

另请参阅

str.center

说明

该函数旨在与字符串数组一起使用。填充字符不适用于数值类型。

示例

>>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c
array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='<U4')
>>> np.char.center(c, width=9)
array(['   a1b2  ', '   1b2a  ', '   b2a1  ', '   2a1b  '], dtype='<U9')
>>> np.char.center(c, width=9, fillchar='*')
array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='<U9')
>>> np.char.center(c, width=1)
array(['a', '1', 'b', '2'], dtype='<U1')

`numpy.char.decode`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.decode.html

char.decode(a, encoding=None, errors=None)

逐元素调用bytes.decode。

可用编解码器来自 Python 标准库，并且可以在运行时进行扩展。更多信息请参阅codecs 模块。

参数：

aarray_like of str or unicode

encodingstr, optional

编码的名称

errorsstr, optional

指定如何处理编码错误

outndarray

另请参阅

bytes.decode

注意

结果的类型将取决于指定的编码。

示例

>>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
...               b'\x81\x82\xc2\xc1\xc2\x82\x81'])
>>> c
array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
...    b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7')
>>> np.char.decode(c, encoding='cp037')
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')

`numpy.char.encode`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.encode.html

char.encode(a, encoding=None, errors=None)

逐个调用str.encode元素。

可用编解码器的集合来自 Python 标准库，并且可以在运行时进行扩展。有关更多信息，请参见编解码器模块。

参数：

a - str 或 unicode 的 array_like

encoding - str，可选

编码的名称

errors - str，可选

指定如何处理编码错误

out - ndarray

另请参阅

str.encode

注意：

结果的类型取决于指定的编码。

`numpy.char.expandtabs`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.expandtabs.html

char.expandtabs(a, tabsize=8)

返回每个字符串元素的副本，其中所有制表符替换为一个或多个空格。

逐元素调用str.expandtabs。

返回每个字符串元素的副本，其中所有制表符替换为一个或多个空格，具体取决于当前列和给定的tabsize。在字符串中出现每个换行符后，列号将被重置为零。这不理解其他非打印字符或转义序列。

参数：

a str 或 unicode 的 array_like

输入数组

tabsize整数，可选

用tabsize数量的空格替换制表符。如果未给出，默认为 8 个空格。

out ndarray

输出由 str 或 unicode 组成的数组，取决于输入类型

另请参阅

str.expandtabs

`numpy.char.join`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.join.html

char.join(sep, seq)

返回一个由序列seq中的字符串拼接而成的字符串。

对str.join进行逐元素调用。

参数：

sep 一个 str 或 unicode 的 array_like

seq 一个 str 或 unicode 的 array_like

返回值：

out ndarray

根据输入类型输出 str 或 unicode 数组

另请参阅

str.join

示例

>>> np.char.join('-', 'osd')
array('o-s-d', dtype='<U5')

>>> np.char.join(['-', '.'], ['ghc', 'osd'])
array(['g-h-c', 'o.s.d'], dtype='<U5')

`numpy.char.ljust`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.ljust.html

char.ljust(a, width, fillchar=' ')

返回一个数组，其中a的元素左对齐在长度为width的字符串中。

逐元素调用str.ljust。

参数:

a字符串或 Unicode 的数组

width整数

结果字符串的长度

fillchar字符串或 Unicode，可选

用于填充的字符

out ndarray

输出数组为字符串或 Unicode，取决于输入类型

另请参见

str.ljust

`numpy.char.lower`

原文：numpy.org/doc/Zh/1.26/reference/generated/numpy.char.lower.html

char.lower(a)

返回一个将元素转换为小写的数组。

逐个元素调用 str.lower。

对于 8 位字符串，此方法与地区有关。

参数：

a array_like, {str, unicode}

输入数组。

返回值：

out ndarray, {str, unicode}

输出数组，根据输入类型为 str 或 unicode

另请参阅

str.lower

示例

>>> c = np.array(['A1B C', '1BCA', 'BCA1']); c
array(['A1B C', '1BCA', 'BCA1'], dtype='<U5')
>>> np.char.lower(c)
array(['a1b c', '1bca', 'bca1'], dtype='<U5')

`numpy.char.lstrip`

numpy.org/doc/1.26/reference/generated/numpy.char.lstrip.html

char.lstrip(a, chars=None)

对于a中的每个元素，返回一个去除前导字符的副本。

对str.lstrip逐个元素进行调用。

参数：

a array-like，{str, unicode}

输入数组。

chars，可选

chars参数是一个字符串，指定要移除的字符集。如果省略或为 None，则chars参数默认为移除空白。chars参数不是前缀；而是删除其所有值的所有组合。

out ndarray，{str, unicode}

返回 str 类型或 unicode 类型的输出数组，取决于输入类型

另请参阅

str.lstrip

示例

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')

由于前导空格，将从 c[1]中的‘a’变量中移除修剪。

>>> np.char.lstrip(c, 'a')
array(['AaAaA', '  aA  ', 'bBABba'], dtype='<U7')

>>> np.char.lstrip(c, 'A') # leaves c unchanged
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, '')).all()
... # XXX: is this a regression? This used to return True
... # np.char.lstrip(c,'') does not modify c at all.
False
>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, None)).all()
True

`numpy.char.partition`

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

char.partition(a, sep)

围绕sep对a中的每个元素进行分区。

逐元素调用str.partition。

对于a中的每个元素，将该元素作为sep的第一次出现进行分割，并返回包含分隔符前面部分、分隔符本身以及分隔符后面部分的 3 个字符串。如果未找到分隔符，则返回包含字符串本身、然后是两个空字符串的 3 个字符串。

参数：

aarray_like, {str, unicode}

输入数组

sep

用于分割a中每个字符串元素的分隔符。

outndarray, {str, unicode}

输出数组为 str 或 unicode，取决于输入类型。输出数组将每个输入元素扩展为 3 个元素的额外维度。

参见

str.partition

`numpy.char.replace`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.replace.html

char.replace(a, old, new, count=None)

对于a中的每个元素，返回一个将所有子字符串old替换为new的副本字符串。

对str.replace进行逐元素调用。

参数：

a 字符串或 unicode 的数组-like

old, new 字符串或 unicode

count int，可选

如果给定了可选参数count，则只替换前count次出现的情况。

返回值：

out ndarray

输出字符串或 unicode 的数组，取决于输入类型

另请参见

str.replace

示例

>>> a = np.array(["That is a mango", "Monkeys eat mangos"])
>>> np.char.replace(a, 'mango', 'banana')
array(['That is a banana', 'Monkeys eat bananas'], dtype='<U19')

>>> a = np.array(["The dish is fresh", "This is it"])
>>> np.char.replace(a, 'is', 'was')
array(['The dwash was fresh', 'Thwas was it'], dtype='<U19')

`numpy.char.rjust`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.rjust.html

char.rjust(a, width, fillchar=' ')

返回一个将a的元素右对齐在长度为width的字符串中的数组。

逐元素调用 str.rjust。

参数：

astr 或 unicode 的 array_like

width整数

结果字符串的长度

fillcharstr 或 unicode，可选

用于填充的字符

outndarray

输出数组为 str 或 unicode，取决于输入类型

另请参阅

str.rjust

`numpy.char.rpartition`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.rpartition.html

char.rpartition(a, sep)

分隔（拆分）每个元素周围的右边分隔符。

逐元素调用str.rpartition。

对于a中的每个元素，将元素作为sep的最后出现位置拆分，并返回包含分隔符之前的部分，分隔符本身以及分隔符之后的部分的 3 个字符串。如果找不到分隔符，则返回包含字符串本身，其后跟两个空字符串的 3 个字符串。

参数：

a str 或 unicode 的 array_like

输入数组

sep 字符串或 unicode

右边分隔符来拆分数组中的每个元素。

out ndarray

输出字符串或 unicode 的数组，取决于输入类型。输出数组将在每个输入元素上增加一个额外的维度，每个元素会有 3 个元素。

另请参阅

str.rpartition

`numpy.char.rsplit`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.rsplit.html

char.rsplit(a, sep=None, maxsplit=None)

对于a中的每个元素，使用sep作为分隔符字符串，返回字符串中单词的列表。

逐个元素调用str.rsplit。

除了从右边开始分割外，rsplit 的行为类似于 split。

参数：

astr 或 unicode 的 array_like

sepstr 或 unicode，可选

如果未指定或为 None，则任何空白字符串均为分隔符。

maxsplitint，可选

如果给定maxsplit，最多进行maxsplit次拆分，最右边的拆分。

outndarray

列表对象数组

另请参阅

str.rsplit，split

`numpy.char.rstrip`

numpy.org/doc/1.26/reference/generated/numpy.char.rstrip.html

char.rstrip(a, chars=None)

对于 a 中的每个元素，返回去除尾部字符后的副本。

对元素调用 str.rstrip。

参数：

a类似数组的 str 或 unicode

charsstr 或 unicode，可选

chars 参数是一个字符串，指定要移除的字符集。如果省略或为 None，则 chars 参数默认为删除空白字符。 chars 参数不是后缀；而是移除其值的所有组合。

outndarray

输出为 str 或 unicode 数组，取决于输入类型

另请参阅

str.rstrip

示例

>>> c = np.array(['aAaAaA', 'abBABba'], dtype='S7'); c
array(['aAaAaA', 'abBABba'],
 dtype='|S7')
>>> np.char.rstrip(c, b'a')
array(['aAaAaA', 'abBABb'],
 dtype='|S7')
>>> np.char.rstrip(c, b'A')
array(['aAaAa', 'abBABba'],
 dtype='|S7')

`numpy.char.split`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.split.html

char.split(a, sep=None, maxsplit=None)

对于a中的每个元素，使用sep作为分隔符字符串，返回字符串中的单词列表。

对str.split进行逐元素调用。

参数：

astr 或 unicode 的 array_like

sepstr 或 unicode，可选

如果未指定sep或为 None，则任何空白字符串都是分隔符。

maxsplitint，可选

如果给定了maxsplit，最多进行maxsplit次分割。

outndarray

列表对象的数组

另请参阅

str.split, rsplit

`numpy.char.splitlines`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.splitlines.html

char.splitlines(a, keepends=None)

对于a中的每个元素，返回在元素中的行列表，以行边界分隔。

逐个元素调用str.splitlines。

参数：

aarray_like of str or unicode

keependsbool，可选

结果列表中不包括换行符，除非给定 keepends 并且为 true。

outndarray

数组的列表对象

另请参阅

str.splitlines

`numpy.char.strip`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.strip.html

char.strip(a, chars=None)

对于a中的每个元素，返回一个去除前导和尾随字符的副本。

逐元素调用str.strip。

参数：

a字符串或 unicode 的类数组

chars字符串或 unicode，可选

chars参数是一个指定要移除的字符集的字符串。如果省略或为 None，则chars参数默认为移除空格。chars参数不是前缀或后缀；相反，它的所有值组合都被剥离。

outndarray

输出字符串数组或 unicode，取决于输入类型

另请参阅

str.strip

示例

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> np.char.strip(c)
array(['aAaAaA', 'aA', 'abBABba'], dtype='<U7')
>>> np.char.strip(c, 'a') # 'a' unstripped from c[1] because whitespace leads
array(['AaAaA', '  aA  ', 'bBABb'], dtype='<U7')
>>> np.char.strip(c, 'A') # 'A' unstripped from c[1] because (unprinted) ws trails
array(['aAaAa', '  aA  ', 'abBABba'], dtype='<U7')

`numpy.char.swapcase`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.swapcase.html

char.swapcase(a)

返回逐个元素的字符串副本，其中大写字符转换为小写，反之亦然。

调用 str.swapcase 逐个元素进行大小写转换。

对于 8 位字符串，此方法取决于区域设置。

参数：

a array_like, {str, unicode}

输入数组。

out ndarray, {str, unicode}

输出为 str 或 unicode 数组，取决于输入类型

另请参阅

str.swapcase

示例

>>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c
array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'],
 dtype='|S5')
>>> np.char.swapcase(c)
array(['A1b C', '1B cA', 'B cA1', 'Ca1B'],
 dtype='|S5')

`numpy.char.title`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.title.html

char.title(a)

返回逐元素标题大小写的字符串或 unicode 版本。

标题大小写单词以大写字符开头，所有剩余的大小写字符都是小写。

逐元素调用str.title。

对于 8 位字符串，此方法取决于区域设置。

参数：

a array_like，{str，unicode}

输入数组。

out ndarray

输出数组为 str 或 unicode，取决于输入类型

另请参见

str.title

示例

>>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c
array(['a1b c', '1b ca', 'b ca1', 'ca1b'],
 dtype='|S5')
>>> np.char.title(c)
array(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'],
 dtype='|S5')

`numpy.char.translate`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.translate.html

char.translate(a, table, deletechars=None)

对于a中的每个元素，返回一个删除了可选参数deletechars中出现的所有字符，并且剩余字符经过给定的转换表映射的字符串副本。

逐个元素调用str.translate。

参数：

a是一个类似于 str 或 unicode 的数组。

table是长度为 256 的 str。

deletechars是一个 str。

out是一个 ndarray。

根据输入类型输出 str 或 unicode 的数组

另请参阅

str.translate。

`numpy.char.upper`

numpy.org/doc/1.26/reference/generated/numpy.char.upper.html

char.upper(a)

返回一个将元素转换为大写的数组。

逐元素调用str.upper。

对于 8 位字符串，此方法取决于区域设置。

参数：

aarray_like，{str，unicode}

输入数组。

outndarray，{str，unicode}

输出为 str 或 unicode 的数组，取决于输入类型

另请参阅

str.upper

示例

>>> c = np.array(['a1b c', '1bca', 'bca1']); c
array(['a1b c', '1bca', 'bca1'], dtype='<U5')
>>> np.char.upper(c)
array(['A1B C', '1BCA', 'BCA1'], dtype='<U5')

`numpy.char.zfill`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.zfill.html

char.zfill(a, width)

返回用零左填充的数字字符串

逐元素调用str.zfill。

参数：

a：array_like，{str，unicode}

输入数组。

width：int

a 中元素左填充的字符串宽度。

out：ndarray，{str，unicode}

输出为 str 或 unicode 的数组，取决于输入类型

另请参阅

str.zfill

`numpy.char.equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.equal.html

char.equal(x1, x2)

返回（x1 == x2）逐元素比较的结果。

与numpy.equal不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了向后兼容性与 numarray 提供的。

参数：

x1, x2array_like of str or unicode

输入数组具有相同的形状。

outndarray

返回布尔数组。

另请参见

not_equal, greater_equal, less_equal, greater, less

`numpy.char.not_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.not_equal.html

char.not_equal(x1, x2)

逐元素返回 (x1 != x2)。

与numpy.not_equal不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了与 numarray 向后兼容而提供的。

参数：

x1, x2 字符串或 unicode 的数组

相同形状的输入数组。

out ndarray

布尔值的输出数组。

另请参阅

equal, greater_equal, less_equal, greater, less

`numpy.char.greater_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.greater_equal.html

char.greater_equal(x1, x2)

逐元素返回(x1 >= x2)。

与numpy.greater_equal不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了向后兼容性与 numarray 提供的。

参数：

x1, x2str 或 unicode 的 array_like

相同形状的输入数组。

outndarray

布尔值的输出数组。

另请参阅

equal, not_equal, less_equal, greater, less

`numpy.char.less_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.less_equal.html

char.less_equal(x1, x2)

返回（x1 <= x2）逐元素比较。

与numpy.less_equal不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了向后兼容性与 numarray 而提供的。

参数：

x1, x2 字符串或 Unicode 的 array_like

输入形状相同的数组。

返回值：

out ndarray

布尔值的输出数组。

另请参阅

equal, not_equal, greater_equal, greater, less

`numpy.char.greater`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.greater.html

char.greater(x1, x2)

返回（x1 > x2）逐元素比较结果。

与numpy.greater不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了与 numarray 向后兼容而提供的。

参数：

x1, x2str 或 unicode 的 array_like

相同形状的输入数组。

outndarray

布尔值的输出数组。

另请参阅

equal, not_equal, greater_equal, less_equal, less

`numpy.char.less`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.less.html

char.less(x1, x2)

返回（x1 < x2）逐元素。

与numpy.greater不同，此比较是通过首先从字符串末尾剥离空格字符来执行的。此行为是为了与 numarray 向后兼容而提供的。

参数：

x1, x2字符串或 Unicode 的数组

输入形状相同的数组。

outndarray

布尔值的输出数组。

另请参见

equal, not_equal, greater_equal, less_equal, greater

`numpy.char.compare_chararrays`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.compare_chararrays.html

char.compare_chararrays(a1, a2, cmp, rstrip)

使用cmp_op指定的比较运算符对两个字符串数组进行逐元素比较。

参数：

a1, a2array_like

要比较的数组。

cmp

比较的类型。

rstripBoolean

如果为 True，则在比较之前移除字符串末尾的空格。

outndarray

具有与 a 和 b 相同形状的布尔类型输出数组。

Raises:

ValueError

如果cmp_op无效。

TypeError

如果a或b至少有一个是非字符串数组

示例

>>> a = np.array(["a", "b", "cde"])
>>> b = np.array(["a", "a", "dec"])
>>> np.compare_chararrays(a, b, ">", True)
array([False,  True, False])

`numpy.char.count`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.count.html

char.count(a, sub, start=0, end=None)

返回一个数组，其中包含范围[start, end]内子字符串sub的非重叠出现次数。

对str.count进行逐元素调用。

参数：

a字符串或 unicode 的 array_like

sub字符串或 unicode

要搜索的子字符串。

start, end整数，可选

可选参数start和end被解释为切片符号，用于指定计数范围。

outndarray

输出整数数组。

另请参阅

str.count

示例

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> np.char.count(c, 'A')
array([3, 1, 1])
>>> np.char.count(c, 'aA')
array([3, 1, 0])
>>> np.char.count(c, 'A', start=1, end=4)
array([2, 1, 1])
>>> np.char.count(c, 'A', start=1, end=3)
array([1, 0, 0])

`numpy.char.endswith`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.endswith.html

char.endswith(a, suffix, start=0, end=None)

返回一个布尔数组，其中字符串元素在 a 中以 suffix 结尾的地方为 True，否则为 False。

逐元素调用 str.endswith。

参数：

astr 或 unicode 的 array_like

后缀str

start, endint, 可选

可选参数 start，从该位置开始测试。可选参数 end，在该位置停止比较。

outndarray

输出一个布尔数组。

另请参阅

str.endswith

示例

>>> s = np.array(['foo', 'bar'])
>>> s[0] = 'foo'
>>> s[1] = 'bar'
>>> s
array(['foo', 'bar'], dtype='<U3')
>>> np.char.endswith(s, 'ar')
array([False,  True])
>>> np.char.endswith(s, 'a', start=1, end=2)
array([False,  True])

`numpy.char.find`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.find.html

char.find(a, sub, start=0, end=None)

对于每个元素，返回字符串中子字符串sub的最低索引。

逐元素调用str.find。

对于每个元素，返回字符串中子字符串sub的最低索引，使得sub包含在范围[start, end]内。

参数：

aarray_like of str or unicode

substr or unicode

start, endint, optional

可选参数start和end的解释方式与切片表示法相同。

outndarray or int

输出整数数组。如果未找到sub，则返回-1。

另请参见

str.find

示例

>>> a = np.array(["NumPy is a Python library"])
>>> np.char.find(a, "Python", start=0, end=None)
array([11])

`numpy.char.index`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.index.html

char.index(a, sub, start=0, end=None)

类似于find，但在未找到子字符串时引发ValueError。

逐元素调用str.index。

参数：

astr 或 unicode 的 array_like

substr 或 unicode

start, endint，可选

outndarray

返回整数的输出数组。如果sub未找到，则返回-1。

参见

find，str.find

示例

>>> a = np.array(["Computer Science"])
>>> np.char.index(a, "Science", start=0, end=None)
array([9])

`numpy.char.isalpha`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isalpha.html

char.isalpha(a)

如果字符串中的所有字符都是字母且至少有一个字符，则对每个元素返回 true，否则返回 false。

逐元素调用 str.isalpha。

对于 8 位字符串，此方法取决于区域设置。

参数：

a 字符串或 Unicode 的数组

out ndarray

布尔值的输出数组

另请参阅

str.isalpha

`numpy.char.isalnum`

numpy.org/doc/1.26/reference/generated/numpy.char.isalnum.html

char.isalnum(a)

返回值为真，如果字符串中的所有字符都是字母数字字符，并且至少有一个字符，否则为假。

逐元素调用 str.isalnum。

对于 8 位字符串，此方法取决于区域设置。

参数：

aarray_like of str or unicode

返回值：

outndarray

输出数组为 str 或 unicode，取决于输入类型

另请参阅

str.isalnum

`numpy.char.isdecimal`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isdecimal.html

char.isdecimal(a)

对于每个元素，如果元素中只有十进制字符，则返回 True。

逐元素调用str.isdecimal。

十进制字符包括数字字符和所有可用于形成十进制基数数字的字符，例如U+0660, 阿拉伯-印度数字零。

参数：

a array_like，unicode

输入数组。

返回值：

out ndarray，布尔值

与a形状相同的布尔数组。

另请参阅

str.isdecimal

示例

>>> np.char.isdecimal(['12345', '4.99', '123ABC', ''])
array([ True, False, False, False])

`numpy.char.isdigit`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isdigit.html

char.isdigit(a)

如果字符串中的所有字符都是数字且至少有一个字符，则对每个元素返回 true，否则返回 false。

逐元素调用str.isdigit。

对于 8 位字符串，此方法取决于区域设置。

参数：

a字符串或 unicode 的数组

out ndarray

输出布尔数组

另请参阅

str.isdigit

示例

>>> a = np.array(['a', 'b', '0'])
>>> np.char.isdigit(a)
array([False, False,  True])
>>> a = np.array([['a', 'b', '0'], ['c', '1', '2']])
>>> np.char.isdigit(a)
array([[False, False,  True], [False,  True,  True]])

`numpy.char.islower`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.islower.html

char.islower(a)

如果字符串中的所有大小写字符都是小写字母并且至少有一个大小写字符，则对每个元素返回 true，否则返回 false。

逐元素调用str.islower。

对于 8 位字符串，此方法取决于区域设置。

参数:

astr 或 unicode 的 array_like

Returns:

outndarray

布尔值的输出数组

另请参阅

str.islower

`numpy.char.isnumeric`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isnumeric.html

char.isnumeric(a)

对于每个元素，如果元素中只包含数字字符，则返回 True。

逐元素调用str.isnumeric。

数字字符包括数字字符和所有具有 Unicode 数字值属性的字符，例如U+2155，分数一五分之一。

参数：

aarray_like，unicode

输入数组。

outndarray，bool

与a相同形状的布尔数组。

另请参阅

str.isnumeric

示例

>>> np.char.isnumeric(['123', '123abc', '9.0', '1/4', 'VIII'])
array([ True, False, False, False, False])

`numpy.char.isspace`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isspace.html

char.isspace(a)

对于每个元素，如果字符串中只有空白字符并且至少有一个字符，则返回 true，否则返回 false。

调用 str.isspace 逐元素进行。

对于 8 位字符串，此方法取决于区域设置。

参数：

a array_like of str or unicode

out ndarray

布尔型的输出数组

另请参阅

str.isspace

`numpy.char.istitle`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.istitle.html

char.istitle(a)

对于每个元素，如果该元素是首字母大写的字符串并且至少有一个字符，则返回 true，否则返回 false。

逐个调用 str.istitle。

对于 8 位字符串，此方法依赖于 locale。

参数：

a - 字符串或 unicode 的 array_like

out - ndarray

布尔型的输出数组

另请参阅

str.istitle

`numpy.char.isupper`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.isupper.html

char.isupper(a)

如果字符串中所有大小写字符均为大写且至少有一个字符，则对于每个元素返回 true，否则返回 false。

逐元素调用 str.isupper。

对于 8 位字符，此方法取决于区域设置。

参数：

a 字符串数组或 Unicode

out ndarray

输出布尔数组

参见

str.isupper

示例

>>> str = "GHC"
>>> np.char.isupper(str)
array(True) 
>>> a = np.array(["hello", "HELLO", "Hello"])
>>> np.char.isupper(a)
array([False,  True, False])

`numpy.char.rfind`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.rfind.html

char.rfind(a, sub, start=0, end=None)

对于a中的每个元素，在字符串中返回子字符串sub的最高索引，该子字符串在[start，end]范围内。

逐元素调用str.rfind。

参数：

astr 或 unicode 类型的数组

substr 或 unicode 类型

start, endint，可选项

可选参数start和end按照切片符号进行解释。

outndarray

整型数组。失败时返回-1。

另请参见

str.rfind

`numpy.char.rindex`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.rindex.html

char.rindex(a, sub, start=0, end=None)

类似于rfind，但在未找到子字符串sub时会引发ValueError。

逐元素调用str.rindex。

参数：

a字符串或 unicode 的数组样式

子字符串或 unicode

start, end整数，可选

输出ndarray

输出整数数组。

另请参见

rfind, str.rindex

`numpy.char.startswith`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.startswith.html

char.startswith(a, prefix, start=0, end=None)

返回一个布尔数组，True 表示a中的字符串元素以prefix开头，否则为False。

逐元素调用str.startswith。

参数：

a字符串或 unicode 的数组

prefix字符串

start, end整数，可选

可选参数start，从该位置开始测试。可选参数end，在该位置停止比较。

outndarray

布尔数组

另请参阅

str.startswith

`numpy.char.str_len`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.str_len.html

char.str_len(a)

逐元素返回 a 的长度。

参数：

a 字符串或 unicode 的类数组

out ndarray

返回整数数组

另请参阅

len

示例

>>> a = np.array(['Grace Hopper Conference', 'Open Source Day'])
>>> np.char.str_len(a)
array([23, 15])
>>> a = np.array([u'Р', u'о'])
>>> np.char.str_len(a)
array([1, 1])
>>> a = np.array([['hello', 'world'], [u'Р', u'о']])
>>> np.char.str_len(a)
array([[5, 5], [1, 1]])

`numpy.char.array`

numpy.org/doc/1.26/reference/generated/numpy.char.array.html

char.array(obj, itemsize=None, copy=True, unicode=None, order=None)

创建一个 chararray。

注意

为了与 numarray 向后兼容，提供了这个类。新代码（与 numarray 兼容性无关）应该使用 bytes_ 或 str_ 类型的数组，并使用 numpy.char 中的自由函数进行快速向量化字符串操作。

与常规的 str 或 unicode 类型的 NumPy 数组相比，此类添加了以下功能：

当被索引时，值会自动移除末尾的空格

比较运算符在比较值时会自动移除末尾的空格

提供的矢量化字符串操作为方法（例如 str.endswith）和中缀运算符（例如 +, *, %）

参数：

objstr 或类似于 unicode 的数组

itemsizeint，可选

itemsize 是结果数组中每个标量的字符数。如果 itemsize 为 None，并且 obj 是对象数组或 Python 列表，则 itemsize 将被自动确定。如果提供了 itemsize 并且 obj 的类型为 str 或 unicode，则将 obj 字符串分成 itemsize 份。

copybool，可选

如果为 true（默认），则复制对象。否则，仅在 array 返回一个副本时，如果 obj 是嵌套序列，或者如果需要复制以满足其他要求（itemsize，unicode，order 等）时才会复制。

unicodebool，可选

当为 true 时，生成的 chararray 可包含 Unicode 字符，当为 false 时只有 8 位字符。如果 unicode 为 None 而 obj 是以下情况之一：

一个 chararray，

一个类型为 str 或 unicode 的 ndarray

一个 Python str 或 unicode 对象，

那么输出数组的 unicode 设置将自动确定。

order，可选

指定数组的顺序。如果 order 为‘C’（默认值），则数组将以 C 连续顺序排列（最后的索引变化最快）。如果 order 为‘F’，则返回的数组将以 Fortran 连续顺序排列（第一个索引变化最快）。如果 order 为‘A’，则返回的数组可以是任何顺序（无论是 C 连续，Fortran 连续，甚至不连续）。

`numpy.char.asarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.asarray.html

char.asarray(obj, itemsize=None, unicode=None, order=None)

将输入转换为chararray，只有在必要时才复制数据。

与正常的类型为str或unicode的 NumPy 数组相比，这个类增加了以下功能：

索引时自动删除末尾的空格

比较操作符在比较值时自动删除末尾的空格

字符串的矢量化操作提供为方法（比如str.endswith）和中缀操作符（比如+，*，%）

参数:

obj字符串或类似 unicode 的数组

itemsizeint，可选

itemsize是结果数组中每个标量的字符数。如果itemsize为 None，并且obj是对象数组或 Python 列表，则itemsize将被自动确定。如果提供了itemsize并且obj的类型是 str 或 unicode，则obj字符串将被分成itemsize片。

unicodebool，可选

当为真时，得到的chararray可以包含 Unicode 字符；当为假时，只能包含 8 位字符。如果 unicode 为 None，并且obj是以下之一：

一个chararray,

str 类型或‘unicode’的 ndarray

一个 Python str 或 unicode 对象,

然后输出数组的 unicode 设置将被自动确定。

顺序，可选

指定数组的顺序。如果顺序为‘C’（默认），则数组将按 C 连续顺序排列（最后一个索引变化最快）。如果顺序为‘F’，则返回的数组将按 Fortran 连续顺序排列（第一个索引变化最快）。

`numpy.char.chararray`

原文：numpy.org/doc/1.26/reference/generated/numpy.char.chararray.html

class numpy.char.chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order=None)

提供了方便查看字符串和 Unicode 值数组的功能。

注

chararray类是为了向后兼容 Numarray 而存在的，不建议用于新开发。从 numpy 1.4 开始，如果需要字符串数组，建议使用dtype为object_、bytes_或str_的数组，并在numpy.char模块中使用免费函数进行快速矢量化的字符串操作。

与常规的str或unicode类型的 NumPy 数组相比，此类添加了以下功能：

索引值时自动从末尾去除空格

比较运算符在比较值时自动去除末尾的空格

提供作为方法（例如 endswith）或中缀运算符（例如 `"+", "*", "%"）的向量化字符串操作。

应使用numpy.char.array或numpy.char.asarray创建 chararrays，而不是直接使用此构造函数。

此构造函数使用 buffer（带有 offset 和strides），如果它不是None，来创建数组。如果 buffer 是None，则以“C 顺序”构造一个新数组，除非len(shape) >= 2和order='F'，在这种情况下strides采用“Fortran 顺序”。

参数：

形状元组

数组的形状。

itemsizeint，可选

每个数组元素的长度，以字符数表示。默认为 1。

unicodebool，可选

数组元素是否为 unicode 类型（True）或字符串类型（False）。默认为 False。

缓冲区暴露缓冲区接口的对象或字符串，可选

数组数据的起始内存地址。默认为 None，在这种情况下创建一个新数组��

offsetint，可选

从轴的开始固定的跨度位移？默认为 0。

stridesint 数组，可选

数组的跨度（参见ndarray.strides进行详细描述）。默认为 None。

顺序，可选

数组数据在内存中存储的顺序：‘C’ -> “行优先”顺序（默认），‘F’ -> “列优先”（Fortran）顺序。

示例

>>> charar = np.chararray((3, 3))
>>> charar[:] = 'a'
>>> charar
chararray([[b'a', b'a', b'a'],
 [b'a', b'a', b'a'],
 [b'a', b'a', b'a']], dtype='|S1')

>>> charar = np.chararray(charar.shape, itemsize=5)
>>> charar[:] = 'abc'
>>> charar
chararray([[b'abc', b'abc', b'abc'],
 [b'abc', b'abc', b'abc'],
 [b'abc', b'abc', b'abc']], dtype='|S5')

属性：

T

转置数组的视图。

base

如果内存来自其他对象，则为基本对象。

ctypes

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

data

指向数组数据起始位置的 Python 缓冲区对象。

dtype

数组元素的数据类型。

flags

数组的内存布局信息。

flat

数组的一维迭代器。

imag

数组的虚部。

itemsize

每个数组元素的字节长度。

nbytes

数组元素占用的总字节数。

ndim

数组维度的数量。

real

数组的实部。

shape

数组维度的元组。

size

数组中的元素数。

strides

在遍历数组时，每个维度的步长的元组。

方法

`astype`(dtype[, order, casting, subok, copy])	复制数组，并转换为指定类型。
`argsort`([axis, kind, order])	返回对该数组进行排序的索引。
`copy`([order])	返回数组的副本。
`count`(sub[, start, end])	返回范围[start,end]内子串 sub 的非重叠出现次数的数组。
`decode`([encoding, errors])	逐元素调用`bytes.decode`。
`dump`(file)	将数组的 pickle 转储到指定文件。
`dumps`()	返回数组的 pickle 作为字符串。
`encode`([encoding, errors])	逐元素调用str.encode。
`endswith`(suffix[, start, end])	返回一个布尔数组，在其中True表示self中的字符串元素以suffix结尾，否则为False。
`expandtabs`([tabsize])	返回每个字符串元素的副本，其中所有制表符字符都被一个或多个空格字符替换。
`fill`(value)	用标量值填充数组。
`find`(sub[, start, end])	对于每个元素，返回字符串中找到子字符串sub的最低索引。
`flatten`([order])	返回数组的一维折叠副本。
`getfield`(dtype[, offset])	返回给定数组的某个字段作为特定类型。
`index`(sub[, start, end])	类似于`find`，但当未找到子字符串时引发ValueError。
`isalnum`()	如果字符串中的所有字符都是字母数字字符，并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isalpha`()	如果字符串中的所有字符都是字母字符，并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`isdecimal`()	对于self中的每个元素，如果元素中只有十进制字符，则返回 True。
`isdigit`()	对于字符串中的每个元素，如果都是数字字符，并且至少有一个字符，则返回 true，否则返回 false。
`islower`()	如果字符串中所有大小写字符都是小写，并且至少有一个大小写字符，则对每个元素返回 true，否则返回 false。
`isnumeric`()	对于self中的每个元素，如果元素中只有数字字符，则返回 True。
`isspace`()	如果字符串中只有空白字符并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`istitle`()	对每个元素进行检查，如果元素是首字母大写的字符串且至少有一个字符，则返回 true，否则返回 false。
`isupper`()	如果字符串中所有大小写字符都是大写并且至少有一个字符，则对每个元素返回 true，否则返回 false。
`item`(*args)	将数组的一个元素复制到标准的 Python 标量并返回它。
`join`(seq)	返回一个字符串，其中包含seq序列中字符串的连接。
`ljust`(width[, fillchar])	返回一个数组，其中self的元素左对齐在长度为width的字符串中。
`lower`()	返回一个数组，其中self的元素转换为小写。
`lstrip`([chars])	对于self中的每个元素，返回一个删除前导字符的副本。
`nonzero`()	返回非零元素的索引。
`put`(indices, values[, mode])	设置`a.flat[n] = values[n]`，其中n为索引的所有值。
`ravel`([order])	返回一个扁平化的数组。
`repeat`(repeats[, axis])	重复数组的元素。
`replace`(old, new[, count])	对于 self 中的每个元素，返回一个将所有子字符串 old 替换为 new 的副本字符串。
`reshape`(shape[, order])	返回包含相同数据的数组，但具有新的形状。
`resize`(new_shape[, refcheck])	改变数组的形状和大小。
`rfind`(sub[, start, end])	对于 self 中的每个元素，返回字符串中找到子字符串 sub 的最高的索引，使得 sub 包含在 [start, end] 中。
`rindex`(sub[, start, end])	类似于 `rfind`，但在找不到子字符串 sub 时引发 ValueError。
`rjust`(width[, fillchar])	返回一个 self 中元素右对齐在长度为 width 的字符串中的数组。
`rsplit`([sep, maxsplit])	对于 self 中的每个元素，使用 sep 作为分隔符字符串，返回字符串中单词的列表。
`rstrip`([chars])	对于 self 中的每个元素，返回删除尾部字符的副本。
`searchsorted`(v[, side, sorter])	查找元素应插入到 a 中以保持顺序的索引。
`setfield`(val, dtype[, offset])	在由数据类型定义的字段的特定位置放置一个值。
`setflags`([write, align, uic])	分别设置数组标志 WRITEABLE, ALIGNED, WRITEBACKIFCOPY。
`sort`([axis, kind, order])	原地对数组进行排序。
`split`([sep, maxsplit])	对于 self 中的每个元素，使用 sep 作为分隔符字符串，返回字符串中单词的列表��
`splitlines`([keepends])	对self中的每个元素，返回在元素中的行列表，按行边界分割。
`squeeze`([axis])	从a中删除长度为一的轴。
`startswith`(prefix[, start, end])	返回一个布尔数组，其中True表示self中的字符串元素以prefix开头，否则为False。
`strip`([chars])	对self中的每个元素，返回一个删除了前导和尾随字符的副本。
`swapaxes`(axis1, axis2)	返回轴axis1和axis2交换的数组视图。
`swapcase`()	对self中的每个元素，返回一个将大写字符转换为小写字符，反之亦然的字符串副本。
`take`(indices[, axis, out, mode])	返回由给定索引处的a元素组成的数组。
`title`()	对self中的每个元素，返回一个单词首字母大写的版本：单词以大写字符开头，所有其余的字符都是小写的。
`tofile`(fid[, sep, format])	将数组写入文件作为文本或二进制（默认）。
`tolist`()	将数组作为一个`a.ndim`级别深的嵌套 Python 标量列表返回。
`tostring`([order])	`tobytes`的兼容别名，行为完全相同。
`translate`(table[, deletechars])	对self中的每个元素，返回一个删除了可选参数deletechars中出现的所有字符，并且剩余字符经过给定转换表映射的字符串副本。
`transpose`(*axes)	返回一个具有轴转置的数组视图。
`upper`()	返回一个将self中的元素转换为大写的数组。
`view`([dtype][, type])	具有相同数据的数组的新视图。
`zfill`(width)	返回长度为width的数字字符串左侧填充零的字符串。

C 类型外部函数接口（numpy.ctypeslib）

原文：numpy.org/doc/1.26/reference/routines.ctypeslib.html

numpy.ctypeslib.as_array(obj, shape=None)

从 ctypes 数组或 POINTER 创建一个 numpy 数组。

NumPy 数组与 ctypes 对象共享内存。

如果从 ctypes POINTER 进行转换，则必须提供形状参数。如果从 ctypes 数组进行转换，则忽略形状参数

numpy.ctypeslib.as_ctypes(obj)

从 numpy 数组创建并返回一个 ctypes 对象。实际上，任何暴露 __array_interface__ 的东西都被接受。

numpy.ctypeslib.as_ctypes_type(dtype)

将 dtype 转换为 ctypes 类型。

参数：

dtype dtype

要转换的数据类型

返回值：

ctype

ctype 标量，联合，数组或结构

抛出：

NotImplementedError

如果转换不可能

注释

此函数在任何方向上均无法完全循环。

np.dtype(as_ctypes_type(dt))将：

插入填充字段

按偏移排序重新排序字段

丢弃字段标题

as_ctypes_type(np.dtype(ctype)) 将：

丢弃ctypes.Structure 和 ctypes.Union 的类名。

将单元素 ctypes.Union 转换为单元素 ctypes.Structure

插入填充字段

numpy.ctypeslib.load_library(libname, loader_path)

可以使用以下方法加载库

>>> lib = ctypes.cdll[<full_path_name>]

但有跨平台考虑因素，比如库文件扩展名，再加上 Windows 将加载它找到的具有该名称的第一个库的事实。NumPy 提供 load_library 函数作为便利。

在版本 1.20.0 中更改：允许 libname 和 loader_path 接受任何路径类对象。

参数：

libname类似路径

库的名称，可以使用“lib”作为前缀，但没有扩展名。

loader_path类似路径

可以找到库的地方。

返回值：

ctypes.cdll[libpath]库对象

ctypes 库对象

抛出：

OSError

如果没有符合预期扩展名的库，或者库有缺陷且无法加载。

numpy.ctypeslib.ndpointer(dtype=None, ndim=None, shape=None, flags=None)

数组检查 restype/argtypes。

ndpointer 实例用于描述 restypes 和 argtypes 规范中的 ndarray。这种方法比使用例如 POINTER(c_double) 更灵活，因为可以指定几个限制条件，在调用 ctypes 函数时进行验证。这些包括数据类型、维数、形状和标志。如果给定数组不满足指定的限制条件，则会触发 TypeError。

参数：

dtype 数据类型，可选

数组数据类型。

ndim int 的，可选

数组维数。

shape int 的元组，可选

数组形状。

flags str 或 str 元组

数组标志；可以是一个或多个：

C 连续 / C / 连续

F_CONTIGUOUS / F / FORTRAN

OWNDATA / O

WRITEABLE / W

ALIGNED / A

WRITEBACKIFCOPY / X

klassndpointer 类型对象

一个类型对象，它是包含 dtype、ndim、shape 和 flags 信息的 _ndtpr 实例。

引发：

类型错误

如果给定的数组不满足指定的限制。

示例

>>> clib.somefunc.argtypes = [np.ctypeslib.ndpointer(dtype=np.float64,
...                                                  ndim=1,
...                                                  flags='C_CONTIGUOUS')]
... 
>>> clib.somefunc(np.array([1, 2, 3], dtype=np.float64))
...

class numpy.ctypeslib.c_intp

一个与 numpy.intp 大小相同的有符号整数类型，来自 ctypes。

根据平台的不同，它可以是 c_int、c_long 或 c_longlong 的别名。

日期时间支持函数

原文：numpy.org/doc/1.26/reference/routines.datetime.html

`datetime_as_string`(arr[, unit, timezone, ...])	将日期时间数组转换为字符串数组。
`datetime_data`(dtype, /)	获取关于日期或时间类型步长的信息。

工作日函数

`busdaycalendar`([weekmask, holidays])	一种高效存储定义 busday 函数有效日期信息的工作日历对象。
`is_busday`(dates[, weekmask, holidays, ...])	计算给定日期中哪些是有效日期，哪些不是。
`busday_offset`(dates, offsets[, roll, ...])	首先根据 `roll` 规则调整日期以落在有效日期上，然后应用计算在有效日期中的给定日期的偏移量。
`busday_count`(begindates, enddates[, ...])	计算 begindates 和 enddates 之间的有效日期数，不包括 enddates 这一天。

工作日函数

`busdaycalendar`([weekmask, holidays])	一种高效存储定义 busday 函数有效日期信息的工作日历对象。
`is_busday`(dates[, weekmask, holidays, ...])	计算给定日期中哪些是有效日期，哪些不是。
`busday_offset`(dates, offsets[, roll, ...])	首先根据 `roll` 规则调整日期以落在有效日期上，然后应用计算在有效日期中的给定日期的偏移量。
`busday_count`(begindates, enddates[, ...])	计算 begindates 和 enddates 之间的有效日期数，不包括 enddates 这一天。

`numpy.datetime_as_string`

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

numpy.datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')

将一个日期时间数组转换为一个字符串数组。

参数：

arr是 datetime64 的类数组。

要格式化的 UTC 时间戳数组。

unit是字符串。

为 None、‘auto’或日期时间单位之一。

timezone或 tzinfo

在显示日期时间时使用的时区信息。如果是‘UTC’，则以 Z 结尾表示 UTC 时间。如果是‘local’，首先转换为本地时区，并以+-####时区偏移量结尾。如果是 tzinfo 对象，则与‘local’一样，但使用指定的时区。

casting

在更改日期时间单位时允许转换。

str_arr是 ndarray。

一个与arr相同形状的字符串数组。

示例

>>> import pytz
>>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
>>> d
array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
 '2002-10-27T07:30'], dtype='datetime64[m]')

将时区设置为 UTC 会显示相同的信息，但会有一个 Z 后缀。

>>> np.datetime_as_string(d, timezone='UTC')
array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
 '2002-10-27T07:30Z'], dtype='<U35')

请注意，我们选择了跨越夏令时(DST)边界的日期时间。传入一个pytz时区对象将打印适当的偏移量。

>>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))
array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
 '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')

传入一个单位将改变精度。

>>> np.datetime_as_string(d, unit='h')
array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
 dtype='<U32')
>>> np.datetime_as_string(d, unit='s')
array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
 '2002-10-27T07:30:00'], dtype='<U38')

‘casting’可用于指定是否可以更改精度。

>>> np.datetime_as_string(d, unit='h', casting='safe')
Traceback (most recent call last):
  ...
TypeError: Cannot create a datetime string as units 'h' from a NumPy
datetime with units 'm' according to the rule 'safe'

`numpy.datetime_data`

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

numpy.datetime_data(dtype, /)

获取与日期或时间类型的步长大小相关的信息。

返回的元组可以作为numpy.datetime64和numpy.timedelta64的第二个参数传递。

参数:

dtypedtype

必须是datetime64或timedelta64类型的 dtype 对象。

unitstr

此 dtype 基于的 datetime 单元。

countint

步长中的基本单位数。

示例

>>> dt_25s = np.dtype('timedelta64[25s]')
>>> np.datetime_data(dt_25s)
('s', 25)
>>> np.array(10, dt_25s).astype('timedelta64[s]')
array(250, dtype='timedelta64[s]')

结果可用于构建使用与时间差相同单位的日期时间

>>> np.datetime64('2010', np.datetime_data(dt_25s))
numpy.datetime64('2010-01-01T00:00:00','25s')

`numpy.busdaycalendar`

译文：numpy.org/doc/1.26/reference/generated/numpy.busdaycalendar.html

class numpy.busdaycalendar(weekmask='1111100', holidays=None)

一个有效存储为 busday 函数系列定义有效日期的工作日日历对象。

默认的有效日期是周一到周五（“工作日”）。可以使用 busdaycalendar 对象指定任何一组每周有效日期，还可以添加一个可选的“假日”日期，该日期始终无效。

一旦创建了 busdaycalendar 对象，就无法修改 weekmask 和 holidays。

版本 1.7.0 中的新增功能。

参数：

weekmaskstr 或 array_like of bool，可选

一个由七个元素组成的数组，表示周一至周日哪些是有效日期。可以指定为长度为七的列表或数组，例如[1,1,1,1,1,0,0]；长度为七的字符串，例如‘1111100’；或者由星期几的三字符缩写组成的字符串，用空格分隔。有效的缩写为：Mon Tue Wed Thu Fri Sat Sun

holidaysarray_like of datetime64[D]，可选

要视为无效日期的日期数组，无论它们落在哪个工作日上。假日日期可以按任何顺序指定，并且忽略 NaT（非时间）日期。此列表以适合快速计算有效日期的标准化形式保存。

busdaycalendar 输出

包含指定 weekmask 和 holidays 值的工作日日历对象。

另请参见

is_busday

返回一个布尔数组，指示有效日期。

busday_offset

应用按有效日期计数的偏移量。

busday_count

计算半开日期范围内的有效日期数量。

示例

>>> # Some important days in July
... bdd = np.busdaycalendar(
...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
>>> # Default is Monday to Friday weekdays
... bdd.weekmask
array([ True,  True,  True,  True,  True, False, False])
>>> # Any holidays already on the weekend are removed
... bdd.holidays
array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')

属性：

注意：一旦创建了 busdaycalendar 对象，就无法修改

weekmask 或 holidays。这些属性返回内部数据的副本。

weekmask(副本)包含七个布尔值的数组

一个包含七个布尔掩码的副本，指示有效日期。

holidays(复制) datetime64[D]类型的已排序数组

一个包含额外无效日期的假日数组的副本。

`numpy.is_busday`

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

numpy.is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)

计算给定日期中哪些是有效的工作日，哪些不是。

自 1.7.0 版本中新增。

参数：

datesdatetime64[D]型的 array_like

要处理的日期数组。

weekmaskstr 或者 bool 型的 array_like，可选

一个七元素数组，表示周一到周日哪些是有效的工作日。可以指定为长度为七的列表或数组，比如[1,1,1,1,1,0,0]；长度为七的字符串，比如‘1111100’；或者类似于“Mon Tue Wed Thu Fri”的字符串，由星期几的 3 个字符缩写组成，可以选择是否用空格分隔。有效的缩写有：Mon Tue Wed Thu Fri Sat Sun

holidaysdatetime64[D]型的 array_like，可选

要考虑为非工作日的日期数组。它们可以按任何顺序指定，NaT（非时间）日期将被忽略。此列表以适合快速计算有效日期的规范形式保存。

busdaycalbusdaycalendar，可选

一个busdaycalendar对象，它指定了有效的工作日。如果提供了此参数，weekmask 和 holidays 均不得提供。

outbool 型的 array，可选

如果提供了，将用结果填充此数组。

outbool 型的 array

与dates具有相同形状的数组，对于每个有效的日期为 True，对于每个无效的日期为 False。

另请参见

busdaycalendar

指定定制的有效工作日集合的对象。

busday_offset

应用以有效工作日计算的偏移量。

busday_count

计算半开日期范围中有多少个有效工作日。

示例

>>> # The weekdays are Friday, Saturday, and Monday
... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
array([False, False,  True])

`numpy.busday_offset`

numpy.org/doc/1.26/reference/generated/numpy.busday_offset.html

numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)

首先根据roll规则调整日期，使其落在有效日期上，然后根据有效日期计算给定日期的偏移量。

1.7.0 版本中的新功能。

参数：

datesarray_like of datetime64[D]

要处理的日期数组。

offsetsarray_like of int

与dates一起广播的偏移量数组。

roll, optional

如何处理不落在有效日期上的日期。默认为‘raise’。

‘raise’ 表示对无效日期引发异常。

‘nat’ 表示对无效日期返回 NaT（非时间）。

‘forward’ 和 ‘following’ 表示沿时间线向后获取第一个较晚的有效日期。

‘backward’ 和 ‘preceding’ 表示沿时间线向前获取第一个较早的有效日期。

‘modifiedfollowing’ 表示向时间线的后面取第一个有效日期，除非跨越月份边界，此时取前一个有效日期。

‘modifiedpreceding’ 表��向时间线的前面取第一个有效日期，除非跨越月份边界，此时取后一个有效日期。

weekmaskstr or array_like of bool, optional

一个包含七个元素的数组，表示周一到周日哪些日期有效。可以指定为长度为七的列表或数组，如[1,1,1,1,1,0,0]；长度为七的字符串，如‘1111100’；或形如“Mon Tue Wed Thu Fri”的字符串，由一周中各工作日的三字符缩写组成，可选地由空格分隔。有效的缩写为：Mon Tue Wed Thu Fri Sat Sun

holidaysarray_like of datetime64[D], optional

一个要视为无效日期的日期数组。它们可以按任何顺序指定，NaT（非时间）日期将被忽略。此列表以适合快速计算有效日期的规范化形式保存。

busdaycalbusdaycalendar, optional

一个指定有效日期的工作日历对象。如果提供了此参数，则不能提供weekmask或holidays。

outarray of datetime64[D], optional

如果提供了，将使用该数组填充结果。

outarray of datetime64[D]

一个形状与以广播方式将dates和offsets一起的数组，包含应用偏移量的日期。

参见

工作日历

指定一组自定义有效日期的对象。

is_busday

返回一个布尔数组，指示有效日期。

工作日计数

计算半开日期范围中有多少个有效日期。

示例

>>> # First business day in October 2011 (not accounting for holidays)
... np.busday_offset('2011-10', 0, roll='forward')
numpy.datetime64('2011-10-03')
>>> # Last business day in February 2012 (not accounting for holidays)
... np.busday_offset('2012-03', -1, roll='forward')
numpy.datetime64('2012-02-29')
>>> # Third Wednesday in January 2011
... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
numpy.datetime64('2011-01-19')
>>> # 2012 Mother's Day in Canada and the U.S.
... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
numpy.datetime64('2012-05-13')

>>> # First business day on or after a date
... np.busday_offset('2011-03-20', 0, roll='forward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 0, roll='forward')
numpy.datetime64('2011-03-22')
>>> # First business day after a date
... np.busday_offset('2011-03-20', 1, roll='backward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 1, roll='backward')
numpy.datetime64('2011-03-23')

`numpy.busday_count`

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

numpy.busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)

计算 begindates 和 enddates 之间的有效日期数量，不包括 enddates 的那一天。

如果 enddates 指定的日期值早于对应的 begindates 日期值，则计数将为负数。

新功能在版本 1.7.0 中推出。

参数：

begindatesdatetime64[D] 数组

包含计数开始日期的数组。

enddatesdatetime64[D] 数组

包含计数结束日期的数组，这些日期本身不被计入计数。

weekmaskstr 或者 bool 数组，可选

一个包含星期一到星期日哪些是有效日期的七元素数组。可以指定为长度为七的列表或数组，如 [1,1,1,1,1,0,0]；长度为七的字符串，如 ‘1111100’；或者一个字符串，如 “Mon Tue Wed Thu Fri”，由平日的三个字符缩写组成，可以选择由空格分隔。有效的缩写为：Mon Tue Wed Thu Fri Sat Sun

holidaysdatetime64[D] 数组，可选

要考虑为无效日期的日期数组。它们可以以任何顺序指定，并且 NaT（不是时间）日期将被忽略。此列表以适合快速计算有效日期的规范化形式保存。

busdaycalbusdaycalendar，可选

一个 busdaycalendar 对象，指定了有效日期。如果提供了此参数，则不得提供 weekmask 或 holidays。

outint 数组，可选

如果提供了，该数组将被填充为结果。

返回值：

outint 数组

一个形状与 begindates 和 enddates 进行广播后的数组，包含开始日期和结束日期之间的有效日期数量。

另请参阅

busdaycalendar

一个指定自定义有效日期集合的对象。

is_busday

返回一个指示有效日期的布尔数组。

busday_offset

应用在有效日期中计算的偏移量。

示例

>>> # Number of weekdays in January 2011
... np.busday_count('2011-01', '2011-02')
21
>>> # Number of weekdays in 2011
>>> np.busday_count('2011', '2012')
260
>>> # Number of Saturdays in 2011
... np.busday_count('2011', '2012', weekmask='Sat')
53

数据类型例程

原文：numpy.org/doc/1.26/reference/routines.dtype.html

`can_cast`(from_, to[, casting])	根据转换规则，如果可以在数据类型之间进行转换，则返回 True。
`promote_types`(type1, type2)	返回可安全转换为`type1`和`type2`的最小大小和最小标量种类的数据类型。
`min_scalar_type`(a, /)	对于标量`a`，返回可以容纳其值的大小和最小标量种类的数据类型。
`result_type`(*arrays_and_dtypes)	返回应用 NumPy 类型提升规则到参数时得到的类型。
`common_type`(*arrays)	返回输入数组通用的标量类型。
`obj2sctype`(rep[, default])	返回对象的标量 dtype 或 Python 类型的 NumPy 等效类型。

创建数据类型

`dtype`(dtype[, align, copy])	创建数据类型对象。
`format_parser`(formats, names, titles[, ...])	将格式、名称、标题描述转换为数据类型的类。

数据类型信息

`finfo`(dtype)	浮点类型的机器限制。
`iinfo`(type)	整数类型的机器限制。

数据类型测试

`issctype`(rep)	确定给定对象是否表示标量数据类型。
`issubdtype`(arg1, arg2)	如果第一个参数在类型层次结构中的类型码较低/相等，则返回 True。
`issubsctype`(arg1, arg2)	判断第一个参数是否是第二个参数的子类。
`issubclass_`(arg1, arg2)	判断一个类是否是第二个类的子类。
`find_common_type`(array_types, scalar_types)	遵循标准强制规则确定常见类型。

杂项

`typename`(char)	返回给定数据类型代码的描述。
`sctype2char`(sctype)	返回标量数据类型的字符串表示。
`mintypecode`(typechars[, typeset, default])	返回给定类型可以安全转换的最小尺寸类型的字符。
`maximum_sctype`(t)	返回与输入相同种类的最高精度标量类型。

创建数据类型

`dtype`(dtype[, align, copy])	创建一个数据类型对象。
`format_parser`(formats, names, titles[, ...])	将格式、名称、标题描述转换为数据类型的类。

数据类型信息

`finfo`(dtype)	浮点数类型的机器限制。
`iinfo`(type)	整数类型的机器限制。

数据类型测试

`issctype`(rep)	确定给定对象是否表示标量数据类型。
`issubdtype`(arg1, arg2)	如果第一个参数在类型层次结构中低于/等于类型代码，则返回 True。
`issubsctype`(arg1, arg2)	判断第一个参数是否是第二个参数的子类。
`issubclass_`(arg1, arg2)	判断一个类是否是第二个类的子类。
`find_common_type`(array_types, scalar_types)	根据标准强制规则确定通用类型。

杂项

`typename`(char)	返回给定数据类型代码的描述。
`sctype2char`(sctype)	返回标量数据类型的字符串表示。
`mintypecode`(typechars[, typeset, default])	返回给定类型可以安全转换的最小尺寸类型的字符。
`maximum_sctype`(t)	返回与输入相同种类的最高精度标量类型。

`numpy.can_cast`

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

numpy.can_cast(from_, to, casting='safe')

如果根据转换规则可以进行数据类型之间的转换，则返回 True。如果 from 是标量或数组标量，则如果标量值可以在不溢出或截断的情况下转换为整数，则还返回 True。

参数:

从数据类型或数据类型说明符、标量或数组

要转换数据类型的数据类型、标量或数组。

至数据类型或数据类型说明符

要转换为的数据类型。

转换, 可选

控制进行何种类型的数据转换。

‘no’表示根本不应进行数据类型的转换。

‘equiv’表示只允许进行字节顺序的更改。

‘safe’表示只允许可以保留值的转换。

‘same_kind’表示只允许安全转换或类似类型之间的转换，如从 float64 到 float32。

‘unsafe’表示可能进行任何数据转换。

输出布尔

如果根据转换规则可以进行转换，则返回 True。

另请参阅

dtype，result_type

注意

在 1.17.0 版本中更改：简单数据类型与结构化数据类型之间的转换仅在“不安全”转换的情况下才可行。允许向多个字段进行转换，但不允许从多个字段进行转换。

在 1.9.0 版本中更改：在“安全”转换模式下，从数值到字符串类型的转换要求字符串数据类型的长度足够长，以存储转换后的最大整数/浮点数值。

示例

基本示例

>>> np.can_cast(np.int32, np.int64)
True
>>> np.can_cast(np.float64, complex)
True
>>> np.can_cast(complex, float)
False

>>> np.can_cast('i8', 'f8')
True
>>> np.can_cast('i8', 'f4')
False
>>> np.can_cast('i4', 'S4')
False

转换标量

>>> np.can_cast(100, 'i1')
True
>>> np.can_cast(150, 'i1')
False
>>> np.can_cast(150, 'u1')
True

>>> np.can_cast(3.5e100, np.float32)
False
>>> np.can_cast(1000.0, np.float32)
True

数组标量检查值，数组不检查

>>> np.can_cast(np.array(1000.0), np.float32)
True
>>> np.can_cast(np.array([1000.0]), np.float32)
False

使用转换规则

>>> np.can_cast('i8', 'i8', 'no')
True
>>> np.can_cast('<i8', '>i8', 'no')
False

>>> np.can_cast('<i8', '>i8', 'equiv')
True
>>> np.can_cast('<i4', '>i8', 'equiv')
False

>>> np.can_cast('<i4', '>i8', 'safe')
True
>>> np.can_cast('<i8', '>i4', 'safe')
False

>>> np.can_cast('<i8', '>i4', 'same_kind')
True
>>> np.can_cast('<i8', '>u4', 'same_kind')
False

>>> np.can_cast('<i8', '>u4', 'unsafe')
True

`numpy.promote_types`

numpy.org/doc/1.26/reference/generated/numpy.promote_types.html

numpy.promote_types(type1, type2)

返回最小大小和最小标量类型的数据类型，可以安全地将type1和type2都转换为该类型。返回的数据类型始终被认为是“规范的”，这主要意味着提升的数据类型总是处于本机字节顺序中。

此函数是对称的，但很少是结合性的。

参数：

type1 数据类型或数据类型指示符

第一个数据类型。

type2 数据类型或数据类型指示符

第二个数据类型。

out 数据类型

提升的数据类型。

参见

result_type，dtype，can_cast

注意事项

有关提升的更多信息，请参见numpy.result_type。

新版本：1.6.0。

从 NumPy 1.9 开始，当一个参数是整数或浮点数数据类型，另一个参数是字符串数据类型时，则 promote_types 函数现在会返回一个有效的字符串长度。以前，它始终返回输入的字符串数据类型，即使不足以存储转换为字符串的最大整数/浮点数值。

修改版本：1.23.0。

NumPy 现在支持更多结构化数据类型的提升。它现在会从结构数据类型中删除不必要的填充，并逐个提升包含的字段。

示例

>>> np.promote_types('f4', 'f8')
dtype('float64')

>>> np.promote_types('i8', 'f4')
dtype('float64')

>>> np.promote_types('>i8', '<c8')
dtype('complex128')

>>> np.promote_types('i4', 'S8')
dtype('S11')

一个非结合性案例的例子：

>>> p = np.promote_types
>>> p('S', p('i1', 'u1'))
dtype('S6')
>>> p(p('S', 'i1'), 'u1')
dtype('S4')

`numpy.min_scalar_type`

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

numpy.min_scalar_type(a, /)

对于标量 a，返回能够容纳其值的大小和标量种类最小的数据类型。对于非标量数组 a，返回未修改的向量数据类型。

浮点值不会降级为整数，复数值也不会降级为浮点数。

参数：

a标量或类似数组

要找到其最小数据类型的值。

返回值：

out数据类型

最小数据类型。

另请参阅

result_type, promote_types, dtype, can_cast

注意事项

新版本 1.6.0 中的新增内容。

示例

>>> np.min_scalar_type(10)
dtype('uint8')

>>> np.min_scalar_type(-260)
dtype('int16')

>>> np.min_scalar_type(3.1)
dtype('float16')

>>> np.min_scalar_type(1e50)
dtype('float64')

>>> np.min_scalar_type(np.arange(4,dtype='f8'))
dtype('float64')

`numpy.result_type`

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

numpy.result_type(*arrays_and_dtypes)

返回应用 NumPy 类型提升规则到参数时的结果类型。

NumPy 中的类型提升与诸如 C ++之类的语言中的规则类似，但略有不同。当同时使用标量和数组时，数组的类型优先，实际标量的值也会被考虑在内。

例如，计算 3*a，其中 a 是 32 位浮点数数组，直觉上应该会得到一个 32 位浮点数输出。如果 3 是 32 位整数，则 NumPy 规则表明它无法无损地转换为 32 位浮点数，因此结果类型应为 64 位浮点数。通过检查常量‘3’的值，我们可以看到它适合 8 位整数，可以无损地转换为 32 位浮点数。

参数：

arrays_and_dtypes数组和数据类型列表

需要结果类型的某些操作的操作数。

out数据类型

结果类型。

另请参见

dtype, promote_types, min_scalar_type, can_cast

注

在版本 1.6.0 中新增。

使用的特定算法如下。

类别通过首先检查所有数组和标量的所有数组和标量中的最大类别是布尔值、整数（int/uint）还是浮点数（float/complex）来确定。

如果只有标量或标量的最大类别高于数组的最大类别，则使用promote_types将数据类型组合以生成返回值。

否则，对每个标量调用min_scalar_type，并使用promote_types组合所有结果数据类型以生成返回值。

对于具有相同位数的类型，整数值的集合不是无符号整数值的子集，min_scalar_type中没有反映这一点，但在result_type中作为特殊情况处理。

示例

>>> np.result_type(3, np.arange(7, dtype='i1'))
dtype('int8')

>>> np.result_type('i4', 'c8')
dtype('complex128')

>>> np.result_type(3.0, -2)
dtype('float64')

`numpy.common_type`

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

numpy.common_type(*arrays)

返回一个与输入数组共同的标量类型。

返回类型始终为非精确的（即浮点）标量类型，即使所有数组都是整数数组。如果输入的其中一个是整数数组，则返回的最小精度类型是 64 位浮点 dtype。

所有输入数组，除了 int64 和 uint64，都可以安全地转换为返回的 dtype，而不会丢失信息。

参数:

array1, array2, …多维数组

输入数组。

输出数据类型代码

数据类型代码。

参见

dtype, mintypecode

例子

>>> np.common_type(np.arange(2, dtype=np.float32))
<class 'numpy.float32'>
>>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
<class 'numpy.float64'>
>>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
<class 'numpy.complex128'>

`numpy.obj2sctype`

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

numpy.obj2sctype(rep, default=None)

返回对象的标量 dtype 或 Python 类型的 NumPy 等效类型。

参数：

rep任意

要返回其类型的对象。

default任意，可选

如果给定，将返回给定对象类型无法确定的对象。如果未给定，则对于这些对象返回 None。

dtypedtype 或 Python 类型

rep的数据类型。

另请参阅

sctype2char, issctype, issubsctype, issubdtype, maximum_sctype

示例

>>> np.obj2sctype(np.int32)
<class 'numpy.int32'>
>>> np.obj2sctype(np.array([1., 2.]))
<class 'numpy.float64'>
>>> np.obj2sctype(np.array([1.j]))
<class 'numpy.complex128'>

>>> np.obj2sctype(dict)
<class 'numpy.object_'>
>>> np.obj2sctype('string')

>>> np.obj2sctype(1, default=list)
<class 'list'>

numpy 数据类型

numpy.org/doc/1.26/reference/generated/numpy.dtype.html的原文链接。

class numpy.dtype(dtype, align=False, copy=False[, metadata])

创建数据类型对象。

一个 numpy 数组是同质的，包含由数据类型对象描述的元素。数据类型对象可以由不同基本数值类型的不同组合构建。

参数：

dtype

要转换为数据类型对象的对象。

align布尔值，可选

添加填充以匹配类似 C 结构的 C 编译器输出的字段。只有当obj是字典或逗号分隔的字符串时才可能为True。如果正在创建结构数据类型，则还会设置一个粘性对齐标志isalignedstruct。

copy布尔值，可选

制作此数据类型对象的新副本。如果False，则结果可能仅是对内置数据类型对象的引用。

metadata字典，可选

一个可选的带有数据类型元数据的字典。

参见

result_type

示例

使用数组标量类型：

>>> np.dtype(np.int16)
dtype('int16')

结构化类型，一个名为‘f1’的字段，包含 int16：

>>> np.dtype([('f1', np.int16)])
dtype([('f1', '<i2')])

结构化类型，一个名为‘f1’的字段，其内部包含一个带有一个字段的结构化类型：

>>> np.dtype([('f1', [('f1', np.int16)])])
dtype([('f1', [('f1', '<i2')])])

结构化类型，两个字段：第一个字段包含一个无符号整数，第二个包含一个 int32：

>>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
dtype([('f1', '<u8'), ('f2', '<i4')])

使用数组协议类型字符串：

>>> np.dtype([('a','f8'),('b','S10')])
dtype([('a', '<f8'), ('b', 'S10')])

使用逗号分隔的字段格式。形状为（2,3）：

>>> np.dtype("i4, (2,3)f8")
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])

使用元组。int是一个固定类型，3 是字段的形状。void是一个灵活类型，在这个例子中大小为 10：

>>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
dtype([('hello', '<i8', (3,)), ('world', 'V10')])

将int16细分为 2 个int8，称为 x 和 y。0 和 1 是字节偏移量：

>>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))

使用字典。两个名为“gender”和“age”的字段：

>>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
dtype([('gender', 'S1'), ('age', 'u1')])

字节偏移量，这里为 0 和 25：

>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', 'S25'), ('age', 'u1')])

属性：

alignment

根据编译器，此数据类型的数据对齐（字节）要求。

base

返回子数组的基本元素的数据类型，而不考虑它们的维度或形状。

byteorder

表示此数据类型对象字节顺序的字符。

char

21 种不同的内置类型的每种的唯一字符代码。

descr

array_interface描述数据类型的接口。

fields

用于此数据类型定义的命名字段的字典，或为None。

flags

描述如何解释此数据类型的位标志。

hasobject

布尔值，指示此数据类型是否在任何字段或子数据类型中包含任何引用计数对象。

isalignedstruct

布尔值，指示该数据类型是否为保持字段对齐的结构体。

isbuiltin

表示此数据类型与内置数据类型的关系的整数。

isnative

布尔值，指示此数据类型的字节顺序是否为平台本地的。

itemsize

此数据类型对象的元素大小。

kind

一个字符代码（biufcmMOSUV之一），用于标识数据的一般类型。

metadata

None 或一个只读的元数据字典（mappingproxy）。

name

此数据类型的位宽名称。

names

字段名称的有序列表，如果没有字段则为None。

ndim

如果此数据类型描述一个子数组，则为其子数组的维度数，否则为0。

num

21 种不同内置类型中的每一种的唯一编号。

shape

如果此数据类型描述一个子数组，则为其子数组的形状元组，否则为()。

str

此数据类型对象的数组协议类型字符串。

subdtype

如果这个dtype描述一个子数组，则为元组(item_dtype, shape)，否则为None。

类型

方法

`newbyteorder`([new_order])	返回具有不同字节顺序的新数据类型。

`numpy.format_parser`

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

class numpy.format_parser(formats, names, titles, aligned=False, byteorder=None)

将格式、名称和标题说明转换为 dtype 的类。

构造 format_parser 对象之后，dtype 属性就是转换后的数据类型：dtype = format_parser(formats, names, titles).dtype

参数：

formatsstr 或 str 列表

格式描述，可以指定为以逗号分隔的格式描述字符串，格式为'f8, i4, a5'，或者以格式描述字符串的列表形式为['f8', 'i4', 'a5']。

namesstr 或 str 列表/元组

字段名可以指定为逗号分隔的字符串，格式为'col1, col2, col3'，或者以字符串的列表或元组形式为['col1', 'col2', 'col3']。可以使用空列表，在这种情况下将使用默认字段名称（‘f0’, ‘f1’, …）。

titles序列

标题字符串的序列。可以使用空列表来排除标题。

alignedbool，可选

如果为 True，则通过填充，使字段对齐，就像 C 编译器一样。默认为 False。

byteorderstr，可选

如果指定，则所有字段都会更改为所提供的字节顺序。否则，将使用默认的字节顺序。有关所有可用的字符串说明符，请参见dtype.newbyteorder。

参见

dtype, typename, sctype2char

示例

>>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
...                  ['T1', 'T2', 'T3']).dtype
dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])

names和/或titles可以是空列表。如果titles是一个空列表，标题将不会显示。如果names是空的，将使用默认字段名称。

>>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
...                  []).dtype
dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
>>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])

属性：

dtypedtype

转换后的数据类型。

`numpy.finfo`

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

class numpy.finfo(dtype)

浮点类型的机器限制。

参数：

dtypefloat、dtype 或实例

要获取有关的浮点或复杂浮点数据类型的信息。

参见

iinfo

整数数据类型的等效值。

spacing

值与最近的相邻数之间的距离

nextafter

从 x1 开始到 x2 的下一个浮点值

注意

对于 NumPy 的开发者：不要在模块级别实例化此参数。这些参数的初始计算是昂贵的，并且会对导入时间产生负面影响。这些对象已缓存，因此在函数内多次调用 finfo() 不是问题。

注意，smallest_normal 实际上不是 NumPy 浮点类型中可表示的最小正值。与 IEEE-754 标准相同[1]，NumPy 浮点类型利用子正规数来填补 0 和 smallest_normal 之间的差距。但是，子正规数可能具有显著降低的精度[2]。

此函数也可用于复杂数据类型。如果使用，则输出将与相应的实数浮点类型相同（例如 numpy.finfo(numpy.csingle) 与 numpy.finfo(numpy.single)相同）。然而，输出对于实部和虚部是真实的。

参考

[1]

浮点数算术的 IEEE 标准，IEEE Std 754-2008，第 1-70 页，2008 年，www.doi.org/10.1109/IEEESTD.2008.4610935

[2]

维基百科，“非规格化数”，en.wikipedia.org/wiki/Denormal_number

示例

>>> np.finfo(np.float64).dtype
dtype('float64')
>>> np.finfo(np.complex64).dtype
dtype('float32')

属性：

bitsint

类型所占的位数。

dtypedtype

返回 finfo 返回信息的 dtype。对于复数输入，返回的 dtype 是与其实部和复数部分对应的 float* dtype。

epsfloat

1.0 和大于 1.0 的下一个最小的可表示浮点数之间的差异。例如，对于 IEEE-754 标准中的 64 位二进制浮点数，eps = 2**-52，大约为 2.22e-16。

epsnegfloat

1.0 和小于 1.0 的下一个最小可表示浮点数之间的差异。例如，对于 IEEE-754 标准中的 64 位二进制浮点数，epsneg = 2**-53，大约为 1.11e-16。

iexpint

浮点表示的指数部分的位数。

machepint

产生 eps 的指数。

最大的适当类型浮点数

可表示的最大数。

maxexpint

导致溢出的基数(2)的最小正幂。

最小的适当类型浮点数

可表示的最小数值，通常为 -max。

minexp整型

基数 (2) 的最小负幂次，其尾数中没有前导 0 的情况下。

negep整型

产生 epsneg 的指数。

nexp整型

指数中包括其符号和偏置的位数。

nmant整型

尾数中的位数。

precision整型

此种浮点数精确的十进制位数的近似值。

分辨率适当类型的浮点数

此类型的近似十进制分辨率，即，10**-precision。

最小值浮点数

返回 tiny 的值，作为 smallest_normal 的别名。

最小正常值浮点数

返回最小正常值的值。

最小下正常值浮点数

在 IEEE-754 中，尾数中以 0 开头的最小正浮点数。

posted @ 2024-06-24 14:55 绝不原创的飞龙阅读(2) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

NumPy-1-26-中文文档-九-

NumPy 1.26 中文文档（九）

numpy.flip

numpy.fliplr

numpy.flipud

numpy.reshape

numpy.roll

numpy.rot90

二进制操作

逐元素位操作

位打包

输出格式化

逐元素位操作

位打包

输出格式化

numpy.bitwise_and

numpy.bitwise_or

numpy.bitwise_xor

numpy.invert

numpy.left_shift

numpy.right_shift

numpy.packbits

numpy.unpackbits

numpy.binary_repr

字符串操作

字符串操作

比较

字符串信息

便捷类

字符串操作

比较

字符串信息

便利类

numpy.char.add

numpy.char.multiply

numpy.char.mod

numpy.char.capitalize

numpy.char.center

numpy.char.decode

numpy.char.encode

numpy.char.expandtabs

numpy.char.join

numpy.char.ljust

numpy.char.lower

numpy.char.lstrip

numpy.char.partition

numpy.char.replace

numpy.char.rjust

numpy.char.rpartition

numpy.char.rsplit

numpy.char.rstrip

numpy.char.split

numpy.char.splitlines

numpy.char.strip

numpy.char.swapcase

numpy.char.title

numpy.char.translate

numpy.char.upper

numpy.char.zfill

numpy.char.equal

numpy.char.not_equal

numpy.char.greater_equal

numpy.char.less_equal

numpy.char.greater

numpy.char.less

numpy.char.compare_chararrays

numpy.char.count

numpy.char.endswith

numpy.char.find

numpy.char.index

numpy.char.isalpha

numpy.char.isalnum

numpy.char.isdecimal

numpy.char.isdigit

numpy.char.islower

numpy.char.isnumeric

numpy.char.isspace

numpy.char.istitle

`numpy.flip`

`numpy.fliplr`

`numpy.flipud`

`numpy.reshape`

`numpy.roll`

`numpy.rot90`

`numpy.bitwise_and`

`numpy.bitwise_or`

`numpy.bitwise_xor`

`numpy.invert`

`numpy.left_shift`

`numpy.right_shift`

`numpy.packbits`

`numpy.unpackbits`

`numpy.binary_repr`

`numpy.char.add`

`numpy.char.multiply`

`numpy.char.mod`

`numpy.char.capitalize`

`numpy.char.center`

`numpy.char.decode`

`numpy.char.encode`

`numpy.char.expandtabs`

`numpy.char.join`

`numpy.char.ljust`

`numpy.char.lower`

`numpy.char.lstrip`

`numpy.char.partition`

`numpy.char.replace`

`numpy.char.rjust`

`numpy.char.rpartition`

`numpy.char.rsplit`

`numpy.char.rstrip`

`numpy.char.split`

`numpy.char.splitlines`

`numpy.char.strip`

`numpy.char.swapcase`

`numpy.char.title`

`numpy.char.translate`

`numpy.char.upper`

`numpy.char.zfill`

`numpy.char.equal`

`numpy.char.not_equal`

`numpy.char.greater_equal`

`numpy.char.less_equal`

`numpy.char.greater`

`numpy.char.less`

`numpy.char.compare_chararrays`

`numpy.char.count`

`numpy.char.endswith`

`numpy.char.find`

`numpy.char.index`

`numpy.char.isalpha`

`numpy.char.isalnum`

`numpy.char.isdecimal`

`numpy.char.isdigit`

`numpy.char.islower`

`numpy.char.isnumeric`

`numpy.char.isspace`

`numpy.char.istitle`

`numpy.char.isupper`

`numpy.char.rfind`

`numpy.char.rindex`

`numpy.char.startswith`

`numpy.char.str_len`

`numpy.char.array`

`numpy.char.asarray`

`numpy.char.chararray`

`numpy.datetime_as_string`

`numpy.datetime_data`

`numpy.busdaycalendar`

`numpy.is_busday`

`numpy.busday_offset`

`numpy.busday_count`

`numpy.can_cast`

`numpy.promote_types`

`numpy.min_scalar_type`

`numpy.result_type`

`numpy.common_type`

`numpy.obj2sctype`