python как добавить массив numpy с нулями
Я хочу знать, как я могу поместить 2D массив numpy с нулями, используя python 2.6.6 с numpy версии 1.5.0. Прости! Но это мои ограничения. Поэтому я не могу использовать np.pad. Например, я хочу pad a с нулями такими, что его форма соответствует b. Причина, по которой я хочу это сделать, заключается в том, что я могу сделать:
b-a
такое, что
>>> a
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
>>> b
array([[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.]])
>>> c
array([[1, 1, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0]])
единственный способ, которым я могу думать об этом, - это добавление, однако это кажется довольно уродливым. там чище решение возможно использование b.shape?
изменить, Спасибо MSeiferts ответ. Мне пришлось немного прибраться, и вот что я получил:
def pad(array, reference_shape, offsets):
"""
array: Array to be padded
reference_shape: tuple of size of ndarray to create
offsets: list of offsets (number of elements must be equal to the dimension of the array)
will throw a ValueError if offsets is too big and the reference_shape cannot handle the offsets
"""
# Create an array of zeros with the reference shape
result = np.zeros(reference_shape)
# Create a list of slices from offset to offset + shape in each dimension
insertHere = [slice(offsets[dim], offsets[dim] + array.shape[dim]) for dim in range(array.ndim)]
# Insert the array in the result at the specified offsets
result[insertHere] = array
return result
4 ответов
очень просто, вы создаете массив, содержащий нули, используя ссылочную форму:
result = np.zeros(b.shape)
# actually you can also use result = np.zeros_like(b)
# but that also copies the dtype not only the shape
а затем вставьте массив, где вам это нужно:
result[:a.shape[0],:a.shape[1]] = a
и вуаля, вы проложили его:
print(result)
array([[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0.]])
вы также можете сделать его немного более общим, если вы определите, где должен быть вставлен верхний левый элемент
result = np.zeros_like(b)
x_offset = 1 # 0 would be what you wanted
y_offset = 1 # 0 in your case
result[x_offset:a.shape[0]+x_offset,y_offset:a.shape[1]+y_offset] = a
result
array([[ 0., 0., 0., 0., 0., 0.],
[ 0., 1., 1., 1., 1., 1.],
[ 0., 1., 1., 1., 1., 1.],
[ 0., 1., 1., 1., 1., 1.]])
но тогда будьте осторожны, что у вас нет смещения больше, чем разрешено. Для x_offset = 2 например это неудача.
если у вас есть arbitary количество измерений, вы можете определить список срезов для вставки исходного массива. Я нашел интересным немного поиграть и создал функцию заполнения, которая может заполнять (со смещением) массив в форме арбитра, пока массив и ссылка имеют одинаковое количество измерений, а смещения не слишком велики.
def pad(array, reference, offsets):
"""
array: Array to be padded
reference: Reference array with the desired shape
offsets: list of offsets (number of elements must be equal to the dimension of the array)
"""
# Create an array of zeros with the reference shape
result = np.zeros(reference.shape)
# Create a list of slices from offset to offset + shape in each dimension
insertHere = [slice(offset[dim], offset[dim] + array.shape[dim]) for dim in range(a.ndim)]
# Insert the array in the result at the specified offsets
result[insertHere] = a
return result
и некоторые тестовые случаи:
import numpy as np
# 1 Dimension
a = np.ones(2)
b = np.ones(5)
offset = [3]
pad(a, b, offset)
# 3 Dimensions
a = np.ones((3,3,3))
b = np.ones((5,4,3))
offset = [1,0,0]
pad(a, b, offset)
NumPy 1.7 (когда np.pad был добавлен) довольно старый сейчас (он был выпущен в 2013 году), поэтому, хотя вопрос задан без этой функции, я подумал, что было бы полезно знать, как это может быть достигнуто с помощью np.pad.
это на самом деле довольно просто:
>>> import numpy as np
>>> a = np.array([[ 1., 1., 1., 1., 1.],
... [ 1., 1., 1., 1., 1.],
... [ 1., 1., 1., 1., 1.]])
>>> np.pad(a, [(0, 1), (0, 1)], mode='constant')
array([[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0.]])
в этом случае я использовал это 0 значение по умолчанию для mode='constant'. Но это также может быть указано, передав его явно:
>>> np.pad(a, [(0, 1), (0, 1)], mode='constant', constant_values=0)
array([[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0.]])
просто в случай второй аргумент ([(0, 1), (0, 1)]) кажется запутанным: каждый элемент списка (в данном случае кортеж) соответствует измерению, а элемент в нем представляет собой заполнение до (первый элемент) и после (второй элемент). Итак:
[(0, 1), (0, 1)]
^^^^^^------ padding for second dimension
^^^^^^-------------- padding for first dimension
^------------------ no padding at the beginning of the first axis
^--------------- pad with one "value" at the end of the first axis.
в этом случае прокладка для первой и второй оси идентична, поэтому можно также просто пройти в 2-кортеж:
>>> np.pad(a, (0, 1), mode='constant')
array([[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 1., 1., 1., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0.]])
в случае, если прокладка до и после идентична, можно даже опустить кортеж (не применимо в этом случае):
>>> np.pad(a, 1, mode='constant')
array([[ 0., 0., 0., 0., 0., 0., 0.],
[ 0., 1., 1., 1., 1., 1., 0.],
[ 0., 1., 1., 1., 1., 1., 0.],
[ 0., 1., 1., 1., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0., 0.]])
или если заполнение до и после идентично, но отличается для оси, вы также можете опустить второй аргумент во внутренних кортежах:
>>> np.pad(a, [(1, ), (2, )], mode='constant')
array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
однако я предпочитаю всегда использовать явный, потому что это просто легко сделать ошибки (когда ожидания NumPys отличаются от ваших намерений):
>>> np.pad(a, [1, 2], mode='constant')
array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 1., 1., 1., 1., 1., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.]])
здесь NumPy думает, что вы хотели проложить всю ось с 1 элементом до и 2 элементы после каждой оси! Даже если вы намеревались использовать 1 элемент в оси 1 и 2 элемента для оси 2.
я использовал списки кортежей для заполнения, обратите внимание, что это просто "мое соглашение", вы также можете использовать списки списков или кортежей кортежей или даже кортежей массивов. NumPy просто проверяет длину аргумента (или если у него нет длины) и длину каждого элемента (или если у него есть длина)!
Я понимаю, что ваша главная проблема заключается в том, что вам нужно вычислить d=b-a но ваши массивы имеют различные размеры. Нет необходимости в промежуточной прокладке c
вы можете решить эту проблему без подклада:
import numpy as np
a = np.array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
b = np.array([[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.],
[ 3., 3., 3., 3., 3., 3.]])
d = b.copy()
d[:a.shape[0],:a.shape[1]] -= a
print d
выход:
[[ 2. 2. 2. 2. 2. 3.]
[ 2. 2. 2. 2. 2. 3.]
[ 2. 2. 2. 2. 2. 3.]
[ 3. 3. 3. 3. 3. 3.]]
в случае, если вам нужно добавить забор 1s в массив:
>>> mat = np.zeros((4,4), np.int32)
>>> mat
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]])
>>> mat[0,:] = mat[:,0] = mat[:,-1] = mat[-1,:] = 1
>>> mat
array([[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 0, 0, 1],
[1, 1, 1, 1]])