numpy.pad#

numpy.pad(array, pad_width, mode='constant', **kwargs)[源代码]#

填充数组。

参数:

array数组类，秩为 N

要填充的数组。

pad_width{序列, 数组类, 整数, 字典}

沿每个轴边缘填充的值的数量。 ((before_1, after_1), ... (before_N, after_N)) 为每个轴指定不同的填充宽度。 (before, after) 或 ((before, after),) 为每个轴生成相同的 before 和 after 填充。 (pad,) 或 int 是沿所有轴的 before = after = pad 宽度的快捷方式。如果为 dict，则每个键是一个轴，其对应的值是描述该轴填充 (before, after) 或 pad 宽度的 int 或 int 对。

mode字符串或函数，可选

以下字符串值之一或用户提供的函数。

‘constant’（默认）: 用常量值填充。
‘edge’: 用数组的边缘值填充。
‘linear_ramp’: 用 end_value 和数组边缘值之间的线性斜坡填充。
‘maximum’: 用沿每个轴的向量的全部或部分最大值填充。
‘mean’: 用沿每个轴的向量的全部或部分平均值填充。
‘median’: 用沿每个轴的向量的全部或部分中值填充。
‘minimum’: 用沿每个轴的向量的全部或部分最小值填充。
‘reflect’: 沿每个轴，用向量的第一个和最后一个值镜像反射的向量填充。
‘symmetric’: 沿数组边缘镜像反射的向量填充。
‘wrap’: 沿轴用向量的环绕填充。第一个值用于填充末尾，末尾值用于填充开头。
‘empty’: 用未定义值填充。
<function>: 填充函数，参见 Notes。

stat_length序列或整数，可选

用于 ‘maximum’, ‘mean’, ‘median’, 和 ‘minimum’。用于计算统计值的每个轴边缘的值的数量。

((before_1, after_1), ... (before_N, after_N)) 为每个轴指定不同的统计长度。

(before, after) 或 ((before, after),) 为每个轴生成相同的 before 和 after 统计长度。

(stat_length,) 或 int 是沿所有轴的 before = after = statistic 长度的快捷方式。

默认值为 None，表示使用整个轴。

constant_values序列或标量，可选

用于 ‘constant’。用于为每个轴设置填充值的常量值。

((before_1, after_1), ... (before_N, after_N)) 为每个轴指定不同的填充常量。

(before, after) 或 ((before, after),) 为每个轴生成相同的 before 和 after 常量。

(constant,) 或 constant 是沿所有轴的 before = after = constant 的快捷方式。

默认值为 0。

end_values序列或标量，可选

用于 ‘linear_ramp’。用于线性斜坡的结束值，并将形成填充数组的边缘。

((before_1, after_1), ... (before_N, after_N)) 为每个轴指定不同的结束值。

(before, after) 或 ((before, after),) 为每个轴生成相同的 before 和 after 结束值。

(constant,) 或 constant 是沿所有轴的 before = after = constant 的快捷方式。

默认值为 0。

reflect_type{‘even’, ‘odd’}, optional

用于 ‘reflect’ 和 ‘symmetric’。‘even’ 模式是默认值，围绕边缘值进行未更改的反射。对于 ‘odd’ 模式，通过从边缘值的两倍减去反射值来创建数组的扩展部分。

返回:

padndarray: 填充后的数组，秩与 array 相同，形状根据 pad_width 增大。

备注

对于秩大于 1 的数组，后续轴的一些填充是根据前一个轴的填充计算的。用秩为 2 的数组来考虑这一点最容易，其中填充数组的角是通过使用第一个轴的填充值来计算的。

如果使用填充函数，它应该就地修改秩为 1 的数组。它具有以下签名：

padding_func(vector, iaxis_pad_width, iaxis, kwargs)

where

vectorndarray: 一个秩为 1 的数组，已用零填充。填充值是 vector[:iaxis_pad_width[0]] 和 vector[-iaxis_pad_width[1]:].
iaxis_pad_width元组: 一个包含两个整数的元组，iaxis_pad_width[0] 表示在 vector 开头填充的值的数量，iaxis_pad_width[1] 表示在 vector 末尾填充的值的数量。
iaxis整数: 当前正在计算的轴。
kwargs字典: 函数所需的任何关键字参数。

示例

>>> import numpy as np
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
array([4, 4, 1, ..., 6, 6, 6])

>>> np.pad(a, (2, 3), 'edge')
array([1, 1, 1, ..., 5, 5, 5])

>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])

>>> np.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])

>>> np.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])

>>> np.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])

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

>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])

>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

>>> np.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])

>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])

>>> np.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])

>>> def pad_with(vector, pad_width, iaxis, kwargs):
...     pad_value = kwargs.get('padder', 10)
...     vector[:pad_width[0]] = pad_value
...     vector[-pad_width[1]:] = pad_value
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.pad(a, 2, pad_with)
array([[10, 10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10, 10, 10],
       [10, 10,  0,  1,  2, 10, 10],
       [10, 10,  3,  4,  5, 10, 10],
       [10, 10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10, 10, 10]])
>>> np.pad(a, 2, pad_with, padder=100)
array([[100, 100, 100, 100, 100, 100, 100],
       [100, 100, 100, 100, 100, 100, 100],
       [100, 100,   0,   1,   2, 100, 100],
       [100, 100,   3,   4,   5, 100, 100],
       [100, 100, 100, 100, 100, 100, 100],
       [100, 100, 100, 100, 100, 100, 100]])

>>> a = np.arange(1, 7).reshape(2, 3)
>>> np.pad(a, {1: (1, 2)})
array([[0, 1, 2, 3, 0, 0],
       [0, 4, 5, 6, 0, 0]])
>>> np.pad(a, {-1: 2})
array([[0, 0, 1, 2, 3, 0, 0],
       [0, 0, 4, 5, 6, 0, 0]])
>>> np.pad(a, {0: (3, 0)})
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [1, 2, 3],
       [4, 5, 6]])
>>> np.pad(a, {0: (3, 0), 1: 2})
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 2, 3, 0, 0],
       [0, 0, 4, 5, 6, 0, 0]])